EigenVector.h

Go to the documentation of this file.

 
#pragma once
 
#include <vector>
#ifndef NDEBUG
#include <fstream>
#include <string>
#endif
 
#include <Eigen/Eigen>
#include <Eigen/Sparse>
 
namespace MathLib
{
class EigenVector final
{
public:
    using RawVectorType = Eigen::VectorXd;
 
    // The Index type of the Eigen::VectorXd class differs from the
    // Eigen::SparseMatrix<double> index type. Maybe an Eigen::SparseVector is a
    // more appropriate RawVectorType for the global vectors.
    using IndexType = Eigen::SparseMatrix<double>::Index;
 
    // TODO: preliminary
    EigenVector() = default;
 
    explicit EigenVector(IndexType length) : vec_(length) {}
 
    EigenVector(EigenVector const& src) = default;
 
    IndexType size() const { return static_cast<IndexType>(vec_.size()); }
 
    static constexpr IndexType getRangeBegin() { return 0; }
 
    IndexType getRangeEnd() const { return size(); }
 
    // TODO preliminary
    void setZero() { vec_.setZero(); }
 
    double const& operator[](IndexType rowId) const { return vec_[rowId]; }
    double& operator[](IndexType rowId) { return vec_[rowId]; }
 
    double get(IndexType rowId) const { return vec_[rowId]; }
 
    std::vector<double> get(std::vector<IndexType> const& indices) const
    {
        std::vector<double> local_x;
        local_x.reserve(indices.size());
 
        transform(cbegin(indices), cend(indices), back_inserter(local_x),
                  [&](auto const i) { return vec_[i]; });
 
        return local_x;
    }
 
    void set(IndexType rowId, double v) { vec_[rowId] = v; }
 
    void add(IndexType rowId, double v) { vec_[rowId] += v; }
 
    template <class T_SUBVEC>
    void add(const std::vector<IndexType>& pos, const T_SUBVEC& sub_vec)
    {
        auto const length = pos.size();
        for (std::size_t i = 0; i < length; ++i)
        {
            add(pos[i], sub_vec[i]);
        }
    }
 
    void copyValues(std::vector<double>& u) const
    {
        assert(u.size() == (std::size_t)vec_.size());
        copy_n(vec_.data(), vec_.size(), u.begin());
    }
 
#ifndef NDEBUG
    void write(const std::string& filename) const
    {
        std::ofstream os(filename);
        os << vec_;
    }
#endif
 
    RawVectorType& getRawVector() { return vec_; }
 
    const RawVectorType& getRawVector() const { return vec_; }
 
private:
    RawVectorType vec_;
};
 
}  // namespace MathLib