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@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
13namespace 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) \
22template<typename OtherDerived> \
23EIGEN_STRONG_INLINE Derived& operator Op(const Eigen::SparseMatrixBase<OtherDerived>& other) \
24{ \
25  return Base::operator Op(other.derived()); \
26} \
27EIGEN_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) \
33template<typename Other> \
34EIGEN_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) \
40EIGEN_SPARSE_INHERIT_ASSIGNMENT_OPERATOR(Derived, =) \
41EIGEN_SPARSE_INHERIT_ASSIGNMENT_OPERATOR(Derived, +=) \
42EIGEN_SPARSE_INHERIT_ASSIGNMENT_OPERATOR(Derived, -=) \
43EIGEN_SPARSE_INHERIT_SCALAR_ASSIGNMENT_OPERATOR(Derived, *=) \
44EIGEN_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
65const int CoherentAccessPattern     = 0x1;
66const int InnerRandomAccessPattern  = 0x2 | CoherentAccessPattern;
67const int OuterRandomAccessPattern  = 0x4 | CoherentAccessPattern;
68const int RandomAccessPattern       = 0x8 | OuterRandomAccessPattern | InnerRandomAccessPattern;
69
70template<typename Derived> class SparseMatrixBase;
71template<typename _Scalar, int _Flags = 0, typename _Index = int>  class SparseMatrix;
72template<typename _Scalar, int _Flags = 0, typename _Index = int>  class DynamicSparseMatrix;
73template<typename _Scalar, int _Flags = 0, typename _Index = int>  class SparseVector;
74template<typename _Scalar, int _Flags = 0, typename _Index = int>  class MappedSparseMatrix;
75
76template<typename MatrixType, int Mode>           class SparseTriangularView;
77template<typename MatrixType, unsigned int UpLo>  class SparseSelfAdjointView;
78template<typename Lhs, typename Rhs>              class SparseDiagonalProduct;
79template<typename MatrixType> class SparseView;
80
81template<typename Lhs, typename Rhs>        class SparseSparseProduct;
82template<typename Lhs, typename Rhs>        class SparseTimeDenseProduct;
83template<typename Lhs, typename Rhs>        class DenseTimeSparseProduct;
84template<typename Lhs, typename Rhs, bool Transpose> class SparseDenseOuterProduct;
85
86template<typename Lhs, typename Rhs> struct SparseSparseProductReturnType;
87template<typename Lhs, typename Rhs,
88         int InnerSize = EIGEN_SIZE_MIN_PREFER_FIXED(internal::traits<Lhs>::ColsAtCompileTime,internal::traits<Rhs>::RowsAtCompileTime)> struct DenseSparseProductReturnType;
89template<typename Lhs, typename Rhs,
90         int InnerSize = EIGEN_SIZE_MIN_PREFER_FIXED(internal::traits<Lhs>::ColsAtCompileTime,internal::traits<Rhs>::RowsAtCompileTime)> struct SparseDenseProductReturnType;
91template<typename MatrixType,int UpLo> class SparseSymmetricPermutationProduct;
92
93namespace internal {
94
95template<typename T,int Rows,int Cols> struct sparse_eval;
96
97template<typename T> struct eval<T,Sparse>
98  : public sparse_eval<T, traits<T>::RowsAtCompileTime,traits<T>::ColsAtCompileTime>
99{};
100
101template<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
108template<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
115template<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
123template<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
129template<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  */
148template<typename Scalar, typename Index=typename SparseMatrix<Scalar>::Index >
149class Triplet
150{
151public:
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; }
166protected:
167  Index m_row, m_col;
168  Scalar m_value;
169};
170
171} // end namespace Eigen
172
173#endif // EIGEN_SPARSEUTIL_H
174