Home | History | Annotate | Download | only in SparseCore 
      1 // This file is part of Eigen, a lightweight C++ template library
      2 // for linear algebra.
      3 //
      4 // Copyright (C) 2008 Gael Guennebaud <gael.guennebaud (at) inria.fr>
      5 //
      6 // This Source Code Form is subject to the terms of the Mozilla
      7 // Public License v. 2.0. If a copy of the MPL was not distributed
      8 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
      9 
     10 #ifndef EIGEN_SPARSEUTIL_H
     11 #define EIGEN_SPARSEUTIL_H
     12 
     13 namespace Eigen {
     14 
     15 #ifdef NDEBUG
     16 #define EIGEN_DBG_SPARSE(X)
     17 #else
     18 #define EIGEN_DBG_SPARSE(X) X
     19 #endif
     20 
     21 #define EIGEN_SPARSE_INHERIT_ASSIGNMENT_OPERATOR(Derived, Op) \
     22 template<typename OtherDerived> \
     23 EIGEN_STRONG_INLINE Derived& operator Op(const Eigen::SparseMatrixBase<OtherDerived>& other) \
     24 { \
     25   return Base::operator Op(other.derived()); \
     26 } \
     27 EIGEN_STRONG_INLINE Derived& operator Op(const Derived& other) \
     28 { \
     29   return Base::operator Op(other); \
     30 }
     31 
     32 #define EIGEN_SPARSE_INHERIT_SCALAR_ASSIGNMENT_OPERATOR(Derived, Op) \
     33 template<typename Other> \
     34 EIGEN_STRONG_INLINE Derived& operator Op(const Other& scalar) \
     35 { \
     36   return Base::operator Op(scalar); \
     37 }
     38 
     39 #define EIGEN_SPARSE_INHERIT_ASSIGNMENT_OPERATORS(Derived) \
     40 EIGEN_SPARSE_INHERIT_ASSIGNMENT_OPERATOR(Derived, =) \
     41 EIGEN_SPARSE_INHERIT_ASSIGNMENT_OPERATOR(Derived, +=) \
     42 EIGEN_SPARSE_INHERIT_ASSIGNMENT_OPERATOR(Derived, -=) \
     43 EIGEN_SPARSE_INHERIT_SCALAR_ASSIGNMENT_OPERATOR(Derived, *=) \
     44 EIGEN_SPARSE_INHERIT_SCALAR_ASSIGNMENT_OPERATOR(Derived, /=)
     45 
     46 #define _EIGEN_SPARSE_PUBLIC_INTERFACE(Derived, BaseClass) \
     47   typedef BaseClass Base; \
     48   typedef typename Eigen::internal::traits<Derived >::Scalar Scalar; \
     49   typedef typename Eigen::NumTraits<Scalar>::Real RealScalar; \
     50   typedef typename Eigen::internal::nested<Derived >::type Nested; \
     51   typedef typename Eigen::internal::traits<Derived >::StorageKind StorageKind; \
     52   typedef typename Eigen::internal::traits<Derived >::Index Index; \
     53   enum { RowsAtCompileTime = Eigen::internal::traits<Derived >::RowsAtCompileTime, \
     54         ColsAtCompileTime = Eigen::internal::traits<Derived >::ColsAtCompileTime, \
     55         Flags = Eigen::internal::traits<Derived >::Flags, \
     56         CoeffReadCost = Eigen::internal::traits<Derived >::CoeffReadCost, \
     57         SizeAtCompileTime = Base::SizeAtCompileTime, \
     58         IsVectorAtCompileTime = Base::IsVectorAtCompileTime }; \
     59   using Base::derived; \
     60   using Base::const_cast_derived;
     61 
     62 #define EIGEN_SPARSE_PUBLIC_INTERFACE(Derived) \
     63   _EIGEN_SPARSE_PUBLIC_INTERFACE(Derived, Eigen::SparseMatrixBase<Derived >)
     64 
     65 const int CoherentAccessPattern     = 0x1;
     66 const int InnerRandomAccessPattern  = 0x2 | CoherentAccessPattern;
     67 const int OuterRandomAccessPattern  = 0x4 | CoherentAccessPattern;
     68 const int RandomAccessPattern       = 0x8 | OuterRandomAccessPattern | InnerRandomAccessPattern;
     69 
     70 template<typename Derived> class SparseMatrixBase;
     71 template<typename _Scalar, int _Flags = 0, typename _Index = int>  class SparseMatrix;
     72 template<typename _Scalar, int _Flags = 0, typename _Index = int>  class DynamicSparseMatrix;
     73 template<typename _Scalar, int _Flags = 0, typename _Index = int>  class SparseVector;
     74 template<typename _Scalar, int _Flags = 0, typename _Index = int>  class MappedSparseMatrix;
     75 
     76 template<typename MatrixType, int Mode>           class SparseTriangularView;
     77 template<typename MatrixType, unsigned int UpLo>  class SparseSelfAdjointView;
     78 template<typename Lhs, typename Rhs>              class SparseDiagonalProduct;
     79 template<typename MatrixType> class SparseView;
     80 
     81 template<typename Lhs, typename Rhs>        class SparseSparseProduct;
     82 template<typename Lhs, typename Rhs>        class SparseTimeDenseProduct;
     83 template<typename Lhs, typename Rhs>        class DenseTimeSparseProduct;
     84 template<typename Lhs, typename Rhs, bool Transpose> class SparseDenseOuterProduct;
     85 
     86 template<typename Lhs, typename Rhs> struct SparseSparseProductReturnType;
     87 template<typename Lhs, typename Rhs,
     88          int InnerSize = EIGEN_SIZE_MIN_PREFER_FIXED(internal::traits<Lhs>::ColsAtCompileTime,internal::traits<Rhs>::RowsAtCompileTime)> struct DenseSparseProductReturnType;
     89 template<typename Lhs, typename Rhs,
     90          int InnerSize = EIGEN_SIZE_MIN_PREFER_FIXED(internal::traits<Lhs>::ColsAtCompileTime,internal::traits<Rhs>::RowsAtCompileTime)> struct SparseDenseProductReturnType;
     91 template<typename MatrixType,int UpLo> class SparseSymmetricPermutationProduct;
     92 
     93 namespace internal {
     94 
     95 template<typename T,int Rows,int Cols> struct sparse_eval;
     96 
     97 template<typename T> struct eval<T,Sparse>
     98   : public sparse_eval<T, traits<T>::RowsAtCompileTime,traits<T>::ColsAtCompileTime>
     99 {};
    100 
    101 template<typename T,int Cols> struct sparse_eval<T,1,Cols> {
    102     typedef typename traits<T>::Scalar _Scalar;
    103     typedef typename traits<T>::Index _Index;
    104   public:
    105     typedef SparseVector<_Scalar, RowMajor, _Index> type;
    106 };
    107 
    108 template<typename T,int Rows> struct sparse_eval<T,Rows,1> {
    109     typedef typename traits<T>::Scalar _Scalar;
    110     typedef typename traits<T>::Index _Index;
    111   public:
    112     typedef SparseVector<_Scalar, ColMajor, _Index> type;
    113 };
    114 
    115 template<typename T,int Rows,int Cols> struct sparse_eval {
    116     typedef typename traits<T>::Scalar _Scalar;
    117     typedef typename traits<T>::Index _Index;
    118     enum { _Options = ((traits<T>::Flags&RowMajorBit)==RowMajorBit) ? RowMajor : ColMajor };
    119   public:
    120     typedef SparseMatrix<_Scalar, _Options, _Index> type;
    121 };
    122 
    123 template<typename T> struct sparse_eval<T,1,1> {
    124     typedef typename traits<T>::Scalar _Scalar;
    125   public:
    126     typedef Matrix<_Scalar, 1, 1> type;
    127 };
    128 
    129 template<typename T> struct plain_matrix_type<T,Sparse>
    130 {
    131   typedef typename traits<T>::Scalar _Scalar;
    132   typedef typename traits<T>::Index _Index;
    133   enum { _Options = ((traits<T>::Flags&RowMajorBit)==RowMajorBit) ? RowMajor : ColMajor };
    134   public:
    135     typedef SparseMatrix<_Scalar, _Options, _Index> type;
    136 };
    137 
    138 } // end namespace internal
    139 
    140 /** \ingroup SparseCore_Module
    141   *
    142   * \class Triplet
    143   *
    144   * \brief A small structure to hold a non zero as a triplet (i,j,value).
    145   *
    146   * \sa SparseMatrix::setFromTriplets()
    147   */
    148 template<typename Scalar, typename Index=typename SparseMatrix<Scalar>::Index >
    149 class Triplet
    150 {
    151 public:
    152   Triplet() : m_row(0), m_col(0), m_value(0) {}
    153 
    154   Triplet(const Index& i, const Index& j, const Scalar& v = Scalar(0))
    155     : m_row(i), m_col(j), m_value(v)
    156   {}
    157 
    158   /** \returns the row index of the element */
    159   const Index& row() const { return m_row; }
    160 
    161   /** \returns the column index of the element */
    162   const Index& col() const { return m_col; }
    163 
    164   /** \returns the value of the element */
    165   const Scalar& value() const { return m_value; }
    166 protected:
    167   Index m_row, m_col;
    168   Scalar m_value;
    169 };
    170 
    171 } // end namespace Eigen
    172 
    173 #endif // EIGEN_SPARSEUTIL_H
    174