Eigen  3.2.93
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 
35 template<typename Derived>
37  : public SparseMatrixBase<Derived>
38 {
39  public:
41  EIGEN_SPARSE_PUBLIC_INTERFACE(SparseCompressedBase)
42  using Base::operator=;
43  using Base::IsRowMajor;
44 
45  class InnerIterator;
46  class ReverseInnerIterator;
47 
48  protected:
49  typedef typename Base::IndexVector IndexVector;
50  Eigen::Map<IndexVector> innerNonZeros() { return Eigen::Map<IndexVector>(innerNonZeroPtr(), isCompressed()?0:derived().outerSize()); }
51  const Eigen::Map<const IndexVector> innerNonZeros() const { return Eigen::Map<const IndexVector>(innerNonZeroPtr(), isCompressed()?0:derived().outerSize()); }
52 
53  public:
54 
56  inline Index nonZeros() const
57  {
58  if(Derived::IsVectorAtCompileTime && outerIndexPtr()==0)
59  return derived().nonZeros();
60  else if(isCompressed())
61  return outerIndexPtr()[derived().outerSize()]-outerIndexPtr()[0];
62  else if(derived().outerSize()==0)
63  return 0;
64  else
65  return innerNonZeros().sum();
66  }
67 
71  inline const Scalar* valuePtr() const { return derived().valuePtr(); }
75  inline Scalar* valuePtr() { return derived().valuePtr(); }
76 
80  inline const StorageIndex* innerIndexPtr() const { return derived().innerIndexPtr(); }
84  inline StorageIndex* innerIndexPtr() { return derived().innerIndexPtr(); }
85 
90  inline const StorageIndex* outerIndexPtr() const { return derived().outerIndexPtr(); }
95  inline StorageIndex* outerIndexPtr() { return derived().outerIndexPtr(); }
96 
100  inline const StorageIndex* innerNonZeroPtr() const { return derived().innerNonZeroPtr(); }
104  inline StorageIndex* innerNonZeroPtr() { return derived().innerNonZeroPtr(); }
105 
107  inline bool isCompressed() const { return innerNonZeroPtr()==0; }
108 
109  protected:
112  private:
113  template<typename OtherDerived> explicit SparseCompressedBase(const SparseCompressedBase<OtherDerived>&);
114 };
115 
116 template<typename Derived>
117 class SparseCompressedBase<Derived>::InnerIterator
118 {
119  public:
120  InnerIterator()
121  : m_values(0), m_indices(0), m_outer(0), m_id(0), m_end(0)
122  {}
123 
124  InnerIterator(const InnerIterator& other)
125  : m_values(other.m_values), m_indices(other.m_indices), m_outer(other.m_outer), m_id(other.m_id), m_end(other.m_end)
126  {}
127 
128  InnerIterator& operator=(const InnerIterator& other)
129  {
130  m_values = other.m_values;
131  m_indices = other.m_indices;
132  const_cast<OuterType&>(m_outer).setValue(other.m_outer.value());
133  m_id = other.m_id;
134  m_end = other.m_end;
135  return *this;
136  }
137 
138  InnerIterator(const SparseCompressedBase& mat, Index outer)
139  : m_values(mat.valuePtr()), m_indices(mat.innerIndexPtr()), m_outer(outer)
140  {
141  if(Derived::IsVectorAtCompileTime && mat.outerIndexPtr()==0)
142  {
143  m_id = 0;
144  m_end = mat.nonZeros();
145  }
146  else
147  {
148  m_id = mat.outerIndexPtr()[outer];
149  if(mat.isCompressed())
150  m_end = mat.outerIndexPtr()[outer+1];
151  else
152  m_end = m_id + mat.innerNonZeroPtr()[outer];
153  }
154  }
155 
156  explicit InnerIterator(const SparseCompressedBase& mat)
157  : m_values(mat.valuePtr()), m_indices(mat.innerIndexPtr()), m_outer(0), m_id(0), m_end(mat.nonZeros())
158  {
159  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
160  }
161 
162  explicit InnerIterator(const internal::CompressedStorage<Scalar,StorageIndex>& data)
163  : m_values(data.valuePtr()), m_indices(data.indexPtr()), m_outer(0), m_id(0), m_end(data.size())
164  {
165  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
166  }
167 
168  inline InnerIterator& operator++() { m_id++; return *this; }
169 
170  inline const Scalar& value() const { return m_values[m_id]; }
171  inline Scalar& valueRef() { return const_cast<Scalar&>(m_values[m_id]); }
172 
173  inline StorageIndex index() const { return m_indices[m_id]; }
174  inline Index outer() const { return m_outer.value(); }
175  inline Index row() const { return IsRowMajor ? m_outer.value() : index(); }
176  inline Index col() const { return IsRowMajor ? index() : m_outer.value(); }
177 
178  inline operator bool() const { return (m_id < m_end); }
179 
180  protected:
181  const Scalar* m_values;
182  const StorageIndex* m_indices;
183  typedef internal::variable_if_dynamic<Index,Derived::IsVectorAtCompileTime?0:Dynamic> OuterType;
184  const OuterType m_outer;
185  Index m_id;
186  Index m_end;
187  private:
188  // If you get here, then you're not using the right InnerIterator type, e.g.:
189  // SparseMatrix<double,RowMajor> A;
190  // SparseMatrix<double>::InnerIterator it(A,0);
191  template<typename T> InnerIterator(const SparseMatrixBase<T>&, Index outer);
192 };
193 
194 template<typename Derived>
195 class SparseCompressedBase<Derived>::ReverseInnerIterator
196 {
197  public:
198  ReverseInnerIterator(const SparseCompressedBase& mat, Index outer)
199  : m_values(mat.valuePtr()), m_indices(mat.innerIndexPtr()), m_outer(outer)
200  {
201  if(Derived::IsVectorAtCompileTime && mat.outerIndexPtr()==0)
202  {
203  m_start = 0;
204  m_id = mat.nonZeros();
205  }
206  else
207  {
208  m_start.value() = mat.outerIndexPtr()[outer];
209  if(mat.isCompressed())
210  m_id = mat.outerIndexPtr()[outer+1];
211  else
212  m_id = m_start.value() + mat.innerNonZeroPtr()[outer];
213  }
214  }
215 
216  explicit ReverseInnerIterator(const SparseCompressedBase& mat)
217  : m_values(mat.valuePtr()), m_indices(mat.innerIndexPtr()), m_outer(0), m_start(0), m_id(mat.nonZeros())
218  {
219  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
220  }
221 
222  explicit ReverseInnerIterator(const internal::CompressedStorage<Scalar,StorageIndex>& data)
223  : m_values(data.valuePtr()), m_indices(data.indexPtr()), m_outer(0), m_start(0), m_id(data.size())
224  {
225  EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived);
226  }
227 
228  inline ReverseInnerIterator& operator--() { --m_id; return *this; }
229 
230  inline const Scalar& value() const { return m_values[m_id-1]; }
231  inline Scalar& valueRef() { return const_cast<Scalar&>(m_values[m_id-1]); }
232 
233  inline StorageIndex index() const { return m_indices[m_id-1]; }
234  inline Index outer() const { return m_outer.value(); }
235  inline Index row() const { return IsRowMajor ? m_outer.value() : index(); }
236  inline Index col() const { return IsRowMajor ? index() : m_outer.value(); }
237 
238  inline operator bool() const { return (m_id > m_start.value()); }
239 
240  protected:
241  const Scalar* m_values;
242  const StorageIndex* m_indices;
243  const internal::variable_if_dynamic<Index,Derived::IsVectorAtCompileTime?0:Dynamic> m_outer;
244  Index m_id;
245  const internal::variable_if_dynamic<Index,Derived::IsVectorAtCompileTime?0:Dynamic> m_start;
246 };
247 
248 namespace internal {
249 
250 template<typename Derived>
251 struct evaluator<SparseCompressedBase<Derived> >
252  : evaluator_base<Derived>
253 {
254  typedef typename Derived::Scalar Scalar;
255  typedef typename Derived::InnerIterator InnerIterator;
256  typedef typename Derived::ReverseInnerIterator ReverseInnerIterator;
257 
258  enum {
259  CoeffReadCost = NumTraits<Scalar>::ReadCost,
260  Flags = Derived::Flags
261  };
262 
263  evaluator() : m_matrix(0)
264  {
265  EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
266  }
267  explicit evaluator(const Derived &mat) : m_matrix(&mat)
268  {
269  EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
270  }
271 
272  inline Index nonZerosEstimate() const {
273  return m_matrix->nonZeros();
274  }
275 
276  operator Derived&() { return m_matrix->const_cast_derived(); }
277  operator const Derived&() const { return *m_matrix; }
278 
279  typedef typename DenseCoeffsBase<Derived,ReadOnlyAccessors>::CoeffReturnType CoeffReturnType;
280  Scalar coeff(Index row, Index col) const
281  { return m_matrix->coeff(row,col); }
282 
283  Scalar& coeffRef(Index row, Index col)
284  {
285  eigen_internal_assert(row>=0 && row<m_matrix->rows() && col>=0 && col<m_matrix->cols());
286 
287  const Index outer = Derived::IsRowMajor ? row : col;
288  const Index inner = Derived::IsRowMajor ? col : row;
289 
290  Index start = m_matrix->outerIndexPtr()[outer];
291  Index end = m_matrix->isCompressed() ? m_matrix->outerIndexPtr()[outer+1] : m_matrix->outerIndexPtr()[outer] + m_matrix->innerNonZeroPtr()[outer];
292  eigen_assert(end>start && "you are using a non finalized sparse matrix or written coefficient does not exist");
293  const Index p = std::lower_bound(m_matrix->innerIndexPtr()+start, m_matrix->innerIndexPtr()+end,inner)
294  - m_matrix->innerIndexPtr();
295  eigen_assert((p<end) && (m_matrix->innerIndexPtr()[p]==inner) && "written coefficient does not exist");
296  return m_matrix->const_cast_derived().valuePtr()[p];
297  }
298 
299  const Derived *m_matrix;
300 };
301 
302 }
303 
304 } // end namespace Eigen
305 
306 #endif // EIGEN_SPARSE_COMPRESSED_BASE_H
bool isCompressed() const
Definition: SparseCompressedBase.h:107
A matrix or vector expression mapping an existing array of data.
Definition: Map.h:88
Namespace containing all symbols from the Eigen library.
Definition: Core:271
StorageIndex * innerIndexPtr()
Definition: SparseCompressedBase.h:84
Holds information about the various numeric (i.e. scalar) types allowed by Eigen. ...
Definition: NumTraits.h:167
Index nonZeros() const
Definition: SparseCompressedBase.h:56
const StorageIndex * innerNonZeroPtr() const
Definition: SparseCompressedBase.h:100
Base class of any sparse matrices or sparse expressions.
Definition: ForwardDeclarations.h:281
StorageIndex * innerNonZeroPtr()
Definition: SparseCompressedBase.h:104
Scalar * valuePtr()
Definition: SparseCompressedBase.h:75
const StorageIndex * innerIndexPtr() const
Definition: SparseCompressedBase.h:80
const StorageIndex * outerIndexPtr() const
Definition: SparseCompressedBase.h:90
StorageIndex * outerIndexPtr()
Definition: SparseCompressedBase.h:95
Definition: Eigen_Colamd.h:50
Common base class for sparse [compressed]-{row|column}-storage format.
Definition: SparseCompressedBase.h:15
const Scalar * valuePtr() const
Definition: SparseCompressedBase.h:71
SparseCompressedBase()
Definition: SparseCompressedBase.h:111