Vector.h

 
// Description: A simple, parallel Vector class with the utility needed to
//              support the basis generation methods of this library.  A
//              distributed Vector has its rows distributed across processors.
 
#ifndef included_Vector_h
#define included_Vector_h
 
#include "utils/Utilities.h"
#include <memory>
#include <vector>
#include <functional>
 
namespace CAROM {
 
class Vector
{
public:
    Vector();
 
    Vector(
        int dim,
        bool distributed);
 
    Vector(
        double* vec,
        int dim,
        bool distributed,
        bool copy_data = true);
 
    Vector(
        const Vector& other);
 
    ~Vector();
 
    Vector&
    operator = (
        const Vector& rhs);
 
    Vector&
    operator += (
        const Vector& rhs);
 
    Vector&
    operator -= (
        const Vector& rhs);
 
    Vector&
    operator = (
        const double& a);
 
    Vector&
    operator *= (
        const double& a);
 
    Vector&
    transform(std::function<void(const int size, double* vector)> transformer);
 
    void
    transform(Vector& result,
              std::function<void(const int size, double* vector)> transformer) const;
 
    void
    transform(Vector*& result,
              std::function<void(const int size, double* vector)> transformer) const;
 
    Vector&
    transform(
        std::function<void(const int size, double* origVector, double* resultVector)>
        transformer);
 
    void
    transform(Vector& result,
              std::function<void(const int size, double* origVector, double* resultVector)>
              transformer) const;
 
    void
    setSize(int dim)
    {
        if (dim > d_alloc_size) {
            if (!d_owns_data) {
                CAROM_ERROR("Can not reallocate externally owned storage.");
            }
            if (d_vec) {
                delete [] d_vec;
            }
 
            // Allocate new array and initialize all values to zero.
            d_vec = new double [dim] {0.0};
            d_alloc_size = dim;
        }
        d_dim = dim;
    }
 
    bool
    distributed() const
    {
        return d_distributed;
    }
 
    int
    dim() const
    {
        return d_dim;
    }
 
    double
    inner_product(
        const Vector& other) const;
 
    double
    norm() const;
 
    double
    norm2() const;
 
    double
    normalize();
 
    std::unique_ptr<Vector>
    plus(const Vector& other) const
    {
        Vector *result = new Vector(d_dim, d_distributed);
        plus(other, *result);
        return std::unique_ptr<Vector>(result);
    }
 
    void
    plus(
        const Vector& other,
        Vector& result) const;
 
    std::unique_ptr<Vector>
    plusAx(
        double factor,
        const Vector& other) const
    {
        Vector *result = new Vector(d_dim, d_distributed);
        plusAx(factor, other, *result);
        return std::unique_ptr<Vector>(result);
    }
 
    void
    plusAx(
        double factor,
        const Vector& other,
        Vector& result) const;
 
    void
    plusEqAx(
        double factor,
        const Vector& other);
 
    std::unique_ptr<Vector>
    minus(
        const Vector& other) const
    {
        Vector *result = new Vector(d_dim, d_distributed);
        minus(other, *result);
        return std::unique_ptr<Vector>(result);
    }
 
    void
    minus(
        const Vector& other,
        Vector& result) const;
 
    std::unique_ptr<Vector>
    mult(
        double factor) const
    {
        Vector *result = new Vector(d_dim, d_distributed);
        mult(factor, *result);
        return std::unique_ptr<Vector>(result);
    }
 
    void
    mult(
        double factor,
        Vector& result) const;
 
    const double&
    item(int i) const
    {
        CAROM_ASSERT((0 <= i) && (i < dim()));
        return d_vec[i];
    }
 
    double&
    item(int i)
    {
        CAROM_ASSERT((0 <= i) && (i < dim()));
        return d_vec[i];
    }
 
    const double& operator() (int i) const
    {
        return item(i);
    }
 
    double& operator() (int i)
    {
        return item(i);
    }
 
    void print(const char * prefix) const;
 
    void write(const std::string& base_file_name);
 
    void read(const std::string& base_file_name);
 
    void local_read(const std::string& base_file_name, int rank);
 
    double *getData() const
    {
        return d_vec;
    }
 
    double localMin(int nmax = 0);
 
    void distribute(const int local_dim);
 
    void gather();
 
private:
    double* d_vec;
 
    int d_dim;
 
    int d_alloc_size;
 
    bool d_distributed;
 
    int d_num_procs;
 
    int d_rank;
 
    bool d_owns_data;
};
 
int getCenterPoint(const std::vector<const Vector*>& points,
                   bool use_centroid);
 
int getCenterPoint(const std::vector<Vector>& points,
                   bool use_centroid);
 
int getClosestPoint(const std::vector<const Vector*>& points,
                    const Vector & test_point);
 
int getClosestPoint(const std::vector<Vector>& points,
                    const Vector & test_point);
}
 
#endif