gsSparseVector.h

Go to the documentation of this file.

 
# pragma once
 
// Assumes that Eigen library has been already included
 
 
namespace gismo
{
 
template<typename T, int _Options, typename _Index>
class gsSparseVector : public gsEigen::SparseVector<T,_Options,_Index>
{
public:
 
    typedef gsEigen::SparseVector<T,_Options,_Index> Base;
    
    // Type pointing to a block of the sparse vector
    typedef typename gsEigen::Block<Base> Block;
    
    // Type pointing to a block view of the sparse vector
    typedef gsMatrixBlockView<Base> BlockView;
    
    typedef memory::shared_ptr< gsSparseVector > Ptr;
    
public:
    gsSparseVector() : Base() { }
    gsSparseVector(_Index rows) : Base(rows) { }
 
    template<typename OtherDerived>
    gsSparseVector(const gsEigen::EigenBase<OtherDerived>& other)  : Base(other) { }
 
    template<typename OtherDerived> 
    gsSparseVector(const gsEigen::MatrixBase<OtherDerived>& other)  : Base(other) { } 
    
    template<typename OtherDerived> 
    gsSparseVector(const gsEigen::SparseMatrixBase<OtherDerived>& other)  : Base(other) { } 
 
    template<typename OtherDerived> 
    gsSparseVector(const gsEigen::ReturnByValue<OtherDerived>& other)  : Base(other) { } 
    
    ~gsSparseVector() { }
    
#if !EIGEN_HAS_RVALUE_REFERENCES
    // Using the assignment operators of Eigen
    // Note: using Base::operator=; is ambiguous in MSVC
#ifdef _MSC_VER
    template <class EigenExpr>
    gsSparseVector& operator= (const EigenExpr & other) 
    {
        this->Base::operator=(other);
        return *this;
    }
#else
    using Base::operator=;
#endif
    
#else
    
    // Avoid default keyword for MSVC<2013 
    // https://msdn.microsoft.com/en-us/library/hh567368.aspx
    gsSparseVector(const gsSparseVector& other) : Base(other)
    { Base::operator=(other); }
 
    gsSparseVector& operator= (const gsSparseVector & other)
    { Base::operator=(other); return *this; }
        
    gsSparseVector(gsSparseVector&& other)
    { operator=(std::forward<gsSparseVector>(other)); }
 
    gsSparseVector & operator=(gsSparseVector&& other)
    {
        this->swap(other);
        other.clear();
        return *this;
    }    
 
#endif
 
    void clear()
    {
        this->resize(0);
        this->data().squeeze();
    }
 
    inline T   at (_Index i ) const { return this->coeff(i); }
    inline T & at (_Index i ) { return this->coeffRef(i); }
 
    inline T    operator () (_Index i) const { return this->coeff(i); }
    inline T  & operator () (_Index i) { return this->coeffRef(i); }
 
    inline T    operator [] (_Index i) const { return this->coeff(i); }
    inline T  & operator [] (_Index i) { return this->coeffRef(i); }
 
    gsSparseVector * clone() const
    { return new gsSparseVector(*this); }
 
}; // class gsSparseVector
 
 
 
 
} // namespace gismo