Eigen  3.2.91
SparseCompressedBase.h
1 // This file is part of Eigen, a lightweight C++ template library
2 // for linear algebra.
3 //
4 // Copyright (C) 2015 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_SPARSE_COMPRESSED_BASE_H
11 #define EIGEN_SPARSE_COMPRESSED_BASE_H
12 
13 namespace Eigen {
14 
15 template<typename Derived> class SparseCompressedBase;
16 
17 namespace internal {
18 
19 template<typename Derived>
20 struct traits<SparseCompressedBase<Derived> > : traits<Derived>
21 {};
22 
23 } // end namespace internal
24 
25 template<typename Derived>
26 class SparseCompressedBase
27  : public SparseMatrixBase<Derived>
28 {
29  public:
30  typedef SparseMatrixBase<Derived> Base;
31  _EIGEN_SPARSE_PUBLIC_INTERFACE(SparseCompressedBase)
32  using Base::operator=;
33  using Base::IsRowMajor;
34 
35  class InnerIterator;
36  class ReverseInnerIterator;
37 
38  protected:
39  typedef typename Base::IndexVector IndexVector;
40  Eigen::Map<IndexVector> innerNonZeros() { return Eigen::Map<IndexVector>(innerNonZeroPtr(), isCompressed()?0:derived().outerSize()); }
41  const Eigen::Map<const IndexVector> innerNonZeros() const { return Eigen::Map<const IndexVector>(innerNonZeroPtr(), isCompressed()?0:derived().outerSize()); }
42 
43  public:
44 
46  inline Index nonZeros() const
47  {
48  if(isCompressed())
49  return outerIndexPtr()[derived().outerSize()]-outerIndexPtr()[0];
50  else if(derived().outerSize()==0)
51  return 0;
52  else
53  return innerNonZeros().sum();
54 
55  }
56 
60  inline const Scalar* valuePtr() const { return derived().valuePtr(); }
64  inline Scalar* valuePtr() { return derived().valuePtr(); }
65 
69  inline const StorageIndex* innerIndexPtr() const { return derived().innerIndexPtr(); }
73  inline StorageIndex* innerIndexPtr() { return derived().innerIndexPtr(); }
74 
78  inline const StorageIndex* outerIndexPtr() const { return derived().outerIndexPtr(); }
82  inline StorageIndex* outerIndexPtr() { return derived().outerIndexPtr(); }
83 
87  inline const StorageIndex* innerNonZeroPtr() const { return derived().innerNonZeroPtr(); }
91  inline StorageIndex* innerNonZeroPtr() { return derived().innerNonZeroPtr(); }
92 
94  inline bool isCompressed() const { return innerNonZeroPtr()==0; }
95 
96 };
97 
98 template<typename Derived>
99 class SparseCompressedBase<Derived>::InnerIterator
100 {
101  public:
102  InnerIterator(const SparseCompressedBase& mat, Index outer)
103  : m_values(mat.valuePtr()), m_indices(mat.innerIndexPtr()), m_outer(outer), m_id(mat.outerIndexPtr()[outer])
104  {
105  if(mat.isCompressed())
106  m_end = mat.outerIndexPtr()[outer+1];
107  else
108  m_end = m_id + mat.innerNonZeroPtr()[outer];
109  }
110 
111  inline InnerIterator& operator++() { m_id++; return *this; }
112 
113  inline const Scalar& value() const { return m_values[m_id]; }
114  inline Scalar& valueRef() { return const_cast<Scalar&>(m_values[m_id]); }
115 
116  inline StorageIndex index() const { return m_indices[m_id]; }
117  inline Index outer() const { return m_outer; }
118  inline Index row() const { return IsRowMajor ? m_outer : index(); }
119  inline Index col() const { return IsRowMajor ? index() : m_outer; }
120 
121  inline operator bool() const { return (m_id < m_end); }
122 
123  protected:
124  const Scalar* m_values;
125  const StorageIndex* m_indices;
126  const Index m_outer;
127  Index m_id;
128  Index m_end;
129  private:
130  // If you get here, then you're not using the right InnerIterator type, e.g.:
131  // SparseMatrix<double,RowMajor> A;
132  // SparseMatrix<double>::InnerIterator it(A,0);
133  template<typename T> InnerIterator(const SparseMatrixBase<T>&, Index outer);
134 };
135 
136 template<typename Derived>
137 class SparseCompressedBase<Derived>::ReverseInnerIterator
138 {
139  public:
140  ReverseInnerIterator(const SparseCompressedBase& mat, Index outer)
141  : m_values(mat.valuePtr()), m_indices(mat.innerIndexPtr()), m_outer(outer), m_start(mat.outerIndexPtr()[outer])
142  {
143  if(mat.isCompressed())
144  m_id = mat.outerIndexPtr()[outer+1];
145  else
146  m_id = m_start + mat.innerNonZeroPtr()[outer];
147  }
148 
149  inline ReverseInnerIterator& operator--() { --m_id; return *this; }
150 
151  inline const Scalar& value() const { return m_values[m_id-1]; }
152  inline Scalar& valueRef() { return const_cast<Scalar&>(m_values[m_id-1]); }
153 
154  inline StorageIndex index() const { return m_indices[m_id-1]; }
155  inline Index outer() const { return m_outer; }
156  inline Index row() const { return IsRowMajor ? m_outer : index(); }
157  inline Index col() const { return IsRowMajor ? index() : m_outer; }
158 
159  inline operator bool() const { return (m_id > m_start); }
160 
161  protected:
162  const Scalar* m_values;
163  const StorageIndex* m_indices;
164  const Index m_outer;
165  Index m_id;
166  const Index m_start;
167 };
168 
169 namespace internal {
170 
171 template<typename Derived>
172 struct evaluator<SparseCompressedBase<Derived> >
173  : evaluator_base<Derived>
174 {
175  typedef typename Derived::Scalar Scalar;
176  typedef typename Derived::InnerIterator InnerIterator;
177  typedef typename Derived::ReverseInnerIterator ReverseInnerIterator;
178 
179  enum {
180  CoeffReadCost = NumTraits<Scalar>::ReadCost,
181  Flags = Derived::Flags
182  };
183 
184  evaluator() : m_matrix(0) {}
185  explicit evaluator(const Derived &mat) : m_matrix(&mat) {}
186 
187  inline Index nonZerosEstimate() const {
188  return m_matrix->nonZeros();
189  }
190 
191  operator Derived&() { return m_matrix->const_cast_derived(); }
192  operator const Derived&() const { return *m_matrix; }
193 
194  typedef typename DenseCoeffsBase<Derived,ReadOnlyAccessors>::CoeffReturnType CoeffReturnType;
195  Scalar coeff(Index row, Index col) const
196  { return m_matrix->coeff(row,col); }
197 
198  Scalar& coeffRef(Index row, Index col)
199  {
200  eigen_internal_assert(row>=0 && row<m_matrix->rows() && col>=0 && col<m_matrix->cols());
201 
202  const Index outer = Derived::IsRowMajor ? row : col;
203  const Index inner = Derived::IsRowMajor ? col : row;
204 
205  Index start = m_matrix->outerIndexPtr()[outer];
206  Index end = m_matrix->isCompressed() ? m_matrix->outerIndexPtr()[outer+1] : m_matrix->outerIndexPtr()[outer] + m_matrix->innerNonZeroPtr()[outer];
207  eigen_assert(end>start && "you are using a non finalized sparse matrix or written coefficient does not exist");
208  const Index p = std::lower_bound(m_matrix->innerIndexPtr()+start, m_matrix->innerIndexPtr()+end,inner)
209  - m_matrix->innerIndexPtr();
210  eigen_assert((p<end) && (m_matrix->innerIndexPtr()[p]==inner) && "written coefficient does not exist");
211  return m_matrix->const_cast_derived().valuePtr()[p];
212  }
213 
214  const Derived *m_matrix;
215 };
216 
217 }
218 
219 } // end namespace Eigen
220 
221 #endif // EIGEN_SPARSE_COMPRESSED_BASE_H
A matrix or vector expression mapping an existing array of data.
Definition: Map.h:89
RowXpr row(Index i)
Definition: SparseMatrixBase.h:797
Definition: LDLT.h:16
Derived & derived()
Definition: EigenBase.h:44
Eigen::Index Index
The interface type of indices.
Definition: EigenBase.h:37
Index outerSize() const
Definition: SparseMatrixBase.h:165
Definition: Eigen_Colamd.h:54
ColXpr col(Index i)
Definition: SparseMatrixBase.h:778