VectorField_fwd.hpp

Go to the documentation of this file.

#ifndef MEDUSA_BITS_TYPES_VECTORFIELD_FWD_HPP_
#define MEDUSA_BITS_TYPES_VECTORFIELD_FWD_HPP_
 
#include <medusa/Config.hpp>
#include <medusa/bits/utils/assert.hpp>
#include "Vec_fwd.hpp"
#include "traits.hpp"
#include <Eigen/Core>
 
namespace mm {
 
template <typename Scalar, int dimension>
class VectorField : public Eigen::Matrix<Scalar, Eigen::Dynamic, dimension> {
  public:
    typedef Scalar scalar_t;  
    typedef Eigen::Matrix<Scalar, Eigen::Dynamic, dimension> Base;  
    using Base::operator=;  // inherit assignment operators
 
    VectorField(void) : Base() {}
    VectorField(const VectorField&) = default;
    VectorField& operator=(const VectorField&) = default;
    VectorField(VectorField&&) noexcept = default;
    VectorField& operator=(VectorField&&) noexcept = default;
 
    template <typename OtherDerived>
    VectorField(const Eigen::MatrixBase<OtherDerived>& other);
 
    template <typename OtherDerived>
    VectorField& operator=(const Eigen::MatrixBase<OtherDerived>& other);
 
    template <typename SizeType>
    explicit VectorField(SizeType N) : Base(N, dimension) {}
 
    VectorField& operator=(const Vec<Scalar, dimension>& v);
 
    template <typename OtherDerived>
    static VectorField fromLinear(const Eigen::PlainObjectBase<OtherDerived>& other);
 
  private:
    class VectorFieldView {
        VectorField& sf;  
        const indexes_t& indexes;  
        friend class VectorField;
        VectorFieldView(VectorField& sf, const indexes_t& indexes) : sf(sf), indexes(indexes) {}
      public:
        void operator=(const Vec<scalar_t, dimension>& other) {
            sf(indexes, Eigen::all) = other.transpose().replicate(indexes.size(), 1);
        }
    };
 
  public:
    Eigen::Transpose<typename Base::RowXpr> operator[](typename Eigen::Index i) {
        return Base::row(i).transpose();
    }
    SINL Eigen::Transpose<typename Base::ConstRowXpr> operator[](typename Eigen::Index i) const {
        return Base::row(i).transpose();
    }
 
    using Base::operator();
    SINL Eigen::Transpose<typename Base::RowXpr> operator()(typename Eigen::Index i) {
        return Base::row(i).transpose();
    }
    SINL Eigen::Transpose<typename Base::ConstRowXpr> operator()(typename Eigen::Index i) const {
        return Base::row(i).transpose();
    }
 
    SINL typename Base::ColXpr c(typename Eigen::Index i) { return Base::col(i); }
    SINL typename Base::ConstColXpr c(typename Eigen::Index i) const { return Base::col(i); }
 
    Eigen::IndexedView<Base, indexes_t, Eigen::internal::AllRange<dimension>>
    SINL operator()(const indexes_t& rowIndices) {
        return Base::operator()(rowIndices, Eigen::all);
    }
 
    SINL VectorFieldView operator[](const indexes_t& indexes) {
        return VectorFieldView(*this, indexes);
    }
 
    Scalar* begin() { return this->data(); }
    const Scalar* begin() const { return this->data(); }
 
    Scalar* end() { return this->data() + this->size(); }
    const Scalar* end() const { return this->data() + this->size(); }
 
    const Scalar* cbegin() const { return this->data(); }
    const Scalar* cend() const { return this->data() + this->size(); }
};
template <typename Scalar, int dim> struct vector_type<VectorField<Scalar, dim>> {
    typedef Vec<Scalar, dim> type;  
};
 
typedef VectorField<double, 1> VectorField1d;  
typedef VectorField<double, 2> VectorField2d;  
typedef VectorField<double, 3> VectorField3d;  
 
}  // namespace mm
 
#endif  // MEDUSA_BITS_TYPES_VECTORFIELD_FWD_HPP_