EigenMapTools.h

Go to the documentation of this file.

 
#pragma once
 
#include <Eigen/Core>
#include <cassert>
#include <vector>
 
namespace MathLib
{
template <typename Matrix>
Eigen::Map<Matrix> createZeroedMatrix(std::vector<double>& data,
                                      Eigen::MatrixXd::Index rows,
                                      Eigen::MatrixXd::Index cols)
{
    static_assert(Matrix::IsRowMajor || Matrix::IsVectorAtCompileTime,
                  "The default storage order in OGS is row major storage for "
                  "dense matrices.");
    assert(Matrix::RowsAtCompileTime == Eigen::Dynamic ||
           Matrix::RowsAtCompileTime == rows);
    assert(Matrix::ColsAtCompileTime == Eigen::Dynamic ||
           Matrix::ColsAtCompileTime == cols);
    assert(data.empty());  // in order that resize fills the vector with zeros.
 
    data.resize(rows * cols);
    return {data.data(), rows, cols};
}
 
inline Eigen::Map<
    Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>>
createZeroedMatrix(std::vector<double>& data,
                   Eigen::MatrixXd::Index rows,
                   Eigen::MatrixXd::Index cols)
{
    return createZeroedMatrix<
        Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>>(
        data, rows, cols);
}
 
template <typename Matrix>
Eigen::Map<const Matrix> toMatrix(std::vector<double> const& data,
                                  Eigen::MatrixXd::Index rows,
                                  Eigen::MatrixXd::Index cols)
{
    static_assert(Matrix::IsRowMajor || Matrix::IsVectorAtCompileTime,
                  "The default storage order in OGS is row major storage for "
                  "dense matrices.");
    assert(Matrix::RowsAtCompileTime == Eigen::Dynamic ||
           Matrix::RowsAtCompileTime == rows);
    assert(Matrix::ColsAtCompileTime == Eigen::Dynamic ||
           Matrix::ColsAtCompileTime == cols);
    assert(static_cast<Eigen::MatrixXd::Index>(data.size()) == rows * cols);
 
    return {data.data(), rows, cols};
}
 
inline Eigen::Map<
    const Eigen::
        Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>>
toMatrix(std::vector<double> const& data,
         Eigen::MatrixXd::Index rows,
         Eigen::MatrixXd::Index cols)
{
    return toMatrix<
        Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>>(
        data, rows, cols);
}
 
template <typename Matrix>
Eigen::Map<Matrix> toMatrix(std::vector<double>& data,
                            Eigen::MatrixXd::Index rows,
                            Eigen::MatrixXd::Index cols)
{
    static_assert(Matrix::IsRowMajor || Matrix::IsVectorAtCompileTime,
                  "The default storage order in OGS is row major storage for "
                  "dense matrices.");
    assert(Matrix::RowsAtCompileTime == Eigen::Dynamic ||
           Matrix::RowsAtCompileTime == rows);
    assert(Matrix::ColsAtCompileTime == Eigen::Dynamic ||
           Matrix::ColsAtCompileTime == cols);
    assert(static_cast<Eigen::MatrixXd::Index>(data.size()) == rows * cols);
 
    return {data.data(), rows, cols};
}
 
inline Eigen::Map<
    Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>>
toMatrix(std::vector<double>& data,
         Eigen::MatrixXd::Index rows,
         Eigen::MatrixXd::Index cols)
{
    return toMatrix<
        Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>>(
        data, rows, cols);
}
 
template <typename Vector>
Eigen::Map<Vector> createZeroedVector(std::vector<double>& data,
                                      Eigen::VectorXd::Index size)
{
    static_assert(Vector::IsVectorAtCompileTime, "A vector type is required.");
    assert(Vector::SizeAtCompileTime == Eigen::Dynamic ||
           Vector::SizeAtCompileTime == size);
    assert(data.empty());  // in order that resize fills the vector with zeros.
 
    data.resize(size);
    return {data.data(), size};
}
 
template <typename Vector>
Eigen::Map<const Vector> toVector(std::vector<double> const& data,
                                  Eigen::VectorXd::Index size)
{
    static_assert(Vector::IsVectorAtCompileTime, "A vector type is required.");
    assert(Vector::SizeAtCompileTime == Eigen::Dynamic ||
           Vector::SizeAtCompileTime == size);
    assert(static_cast<Eigen::VectorXd::Index>(data.size()) == size);
 
    return {data.data(), size};
}
 
template <typename Vector>
Eigen::Map<Vector> toVector(std::vector<double>& data,
                            Eigen::VectorXd::Index size)
{
    static_assert(Vector::IsVectorAtCompileTime, "A vector type is required.");
    assert(Vector::SizeAtCompileTime == Eigen::Dynamic ||
           Vector::SizeAtCompileTime == size);
    assert(static_cast<Eigen::VectorXd::Index>(data.size()) == size);
 
    return {data.data(), size};
}
 
inline Eigen::Map<const Eigen::VectorXd> toVector(
    std::vector<double> const& data)
{
    return {data.data(), static_cast<Eigen::VectorXd::Index>(data.size())};
}
 
inline Eigen::Map<Eigen::VectorXd> toVector(std::vector<double>& data)
{
    return {data.data(), static_cast<Eigen::VectorXd::Index>(data.size())};
}
 
}  // namespace MathLib