SparseMap.h
Go to the documentation of this file.
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_MAP_H
11 #define EIGEN_SPARSE_MAP_H
12 
13 namespace Eigen {
14 
15 namespace internal {
16 
17 template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
18 struct traits<Map<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
19  : public traits<SparseMatrix<MatScalar,MatOptions,MatIndex> >
20 {
23  enum {
24  Flags = TraitsBase::Flags & (~NestByRefBit)
25  };
26 };
27 
28 template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
29 struct traits<Map<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
30  : public traits<SparseMatrix<MatScalar,MatOptions,MatIndex> >
31 {
34  enum {
35  Flags = TraitsBase::Flags & (~ (NestByRefBit | LvalueBit))
36  };
37 };
38 
39 } // end namespace internal
40 
41 template<typename Derived,
43 > class SparseMapBase;
44 
49 template<typename Derived>
51  : public SparseCompressedBase<Derived>
52 {
53  public:
55  typedef typename Base::Scalar Scalar;
56  typedef typename Base::StorageIndex StorageIndex;
57  enum { IsRowMajor = Base::IsRowMajor };
58  using Base::operator=;
59  protected:
60 
61  typedef typename internal::conditional<
63  Scalar *, const Scalar *>::type ScalarPointer;
64  typedef typename internal::conditional<
66  StorageIndex *, const StorageIndex *>::type IndexPointer;
67 
71  IndexPointer m_outerIndex;
72  IndexPointer m_innerIndices;
73  ScalarPointer m_values;
74  IndexPointer m_innerNonZeros;
75 
76  public:
77 
79  inline Index rows() const { return IsRowMajor ? m_outerSize : m_innerSize; }
81  inline Index cols() const { return IsRowMajor ? m_innerSize : m_outerSize; }
83  inline Index innerSize() const { return m_innerSize; }
85  inline Index outerSize() const { return m_outerSize; }
87  inline Index nonZeros() const { return m_zero_nnz[1]; }
88 
90  bool isCompressed() const { return m_innerNonZeros==0; }
91 
92  //----------------------------------------
93  // direct access interface
95  inline const Scalar* valuePtr() const { return m_values; }
97  inline const StorageIndex* innerIndexPtr() const { return m_innerIndices; }
99  inline const StorageIndex* outerIndexPtr() const { return m_outerIndex; }
101  inline const StorageIndex* innerNonZeroPtr() const { return m_innerNonZeros; }
102  //----------------------------------------
103 
105  inline Scalar coeff(Index row, Index col) const
106  {
107  const Index outer = IsRowMajor ? row : col;
108  const Index inner = IsRowMajor ? col : row;
109 
110  Index start = m_outerIndex[outer];
111  Index end = isCompressed() ? m_outerIndex[outer+1] : start + m_innerNonZeros[outer];
112  if (start==end)
113  return Scalar(0);
114  else if (end>0 && inner==m_innerIndices[end-1])
115  return m_values[end-1];
116  // ^^ optimization: let's first check if it is the last coefficient
117  // (very common in high level algorithms)
118 
119  const StorageIndex* r = std::lower_bound(&m_innerIndices[start],&m_innerIndices[end-1],inner);
120  const Index id = r-&m_innerIndices[0];
121  return ((*r==inner) && (id<end)) ? m_values[id] : Scalar(0);
122  }
123 
124  inline SparseMapBase(Index rows, Index cols, Index nnz, IndexPointer outerIndexPtr, IndexPointer innerIndexPtr,
125  ScalarPointer valuePtr, IndexPointer innerNonZerosPtr = 0)
126  : m_outerSize(IsRowMajor?rows:cols), m_innerSize(IsRowMajor?cols:rows), m_zero_nnz(0,internal::convert_index<StorageIndex>(nnz)), m_outerIndex(outerIndexPtr),
127  m_innerIndices(innerIndexPtr), m_values(valuePtr), m_innerNonZeros(innerNonZerosPtr)
128  {}
129 
130  // for vectors
131  inline SparseMapBase(Index size, Index nnz, IndexPointer innerIndexPtr, ScalarPointer valuePtr)
132  : m_outerSize(1), m_innerSize(size), m_zero_nnz(0,internal::convert_index<StorageIndex>(nnz)), m_outerIndex(m_zero_nnz.data()),
133  m_innerIndices(innerIndexPtr), m_values(valuePtr), m_innerNonZeros(0)
134  {}
135 
137  inline ~SparseMapBase() {}
138 
139  protected:
140  inline SparseMapBase() {}
141 };
142 
147 template<typename Derived>
149  : public SparseMapBase<Derived,ReadOnlyAccessors>
150 {
152 
153  public:
155  typedef typename Base::Scalar Scalar;
157  enum { IsRowMajor = Base::IsRowMajor };
158 
159  using Base::operator=;
160 
161  public:
162 
163  //----------------------------------------
164  // direct access interface
165  using Base::valuePtr;
166  using Base::innerIndexPtr;
167  using Base::outerIndexPtr;
168  using Base::innerNonZeroPtr;
170  inline Scalar* valuePtr() { return Base::m_values; }
172  inline StorageIndex* innerIndexPtr() { return Base::m_innerIndices; }
174  inline StorageIndex* outerIndexPtr() { return Base::m_outerIndex; }
176  inline StorageIndex* innerNonZeroPtr() { return Base::m_innerNonZeros; }
177  //----------------------------------------
178 
180  inline Scalar& coeffRef(Index row, Index col)
181  {
182  const Index outer = IsRowMajor ? row : col;
183  const Index inner = IsRowMajor ? col : row;
184 
185  Index start = Base::m_outerIndex[outer];
186  Index end = Base::isCompressed() ? Base::m_outerIndex[outer+1] : start + Base::m_innerNonZeros[outer];
187  eigen_assert(end>=start && "you probably called coeffRef on a non finalized matrix");
188  eigen_assert(end>start && "coeffRef cannot be called on a zero coefficient");
189  StorageIndex* r = std::lower_bound(&Base::m_innerIndices[start],&Base::m_innerIndices[end],inner);
190  const Index id = r - &Base::m_innerIndices[0];
191  eigen_assert((*r==inner) && (id<end) && "coeffRef cannot be called on a zero coefficient");
192  return const_cast<Scalar*>(Base::m_values)[id];
193  }
194 
195  inline SparseMapBase(Index rows, Index cols, Index nnz, StorageIndex* outerIndexPtr, StorageIndex* innerIndexPtr,
196  Scalar* valuePtr, StorageIndex* innerNonZerosPtr = 0)
197  : Base(rows, cols, nnz, outerIndexPtr, innerIndexPtr, valuePtr, innerNonZerosPtr)
198  {}
199 
200  // for vectors
201  inline SparseMapBase(Index size, Index nnz, StorageIndex* innerIndexPtr, Scalar* valuePtr)
202  : Base(size, nnz, innerIndexPtr, valuePtr)
203  {}
204 
206  inline ~SparseMapBase() {}
207 
208  protected:
209  inline SparseMapBase() {}
210 };
211 
220 #ifndef EIGEN_PARSED_BY_DOXYGEN
221 template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
222 class Map<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType>
223  : public SparseMapBase<Map<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
224 #else
225 template<typename SparseMatrixType>
226 class Map<SparseMatrixType>
227  : public SparseMapBase<Derived,WriteAccessors>
228 #endif
229 {
230  public:
233  enum { IsRowMajor = Base::IsRowMajor };
234 
235  public:
236 
245  inline Map(Index rows, Index cols, Index nnz, StorageIndex* outerIndexPtr,
246  StorageIndex* innerIndexPtr, Scalar* valuePtr, StorageIndex* innerNonZerosPtr = 0)
247  : Base(rows, cols, nnz, outerIndexPtr, innerIndexPtr, valuePtr, innerNonZerosPtr)
248  {}
249 #ifndef EIGEN_PARSED_BY_DOXYGEN
250 
251  inline ~Map() {}
252 };
253 
254 template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
255 class Map<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType>
256  : public SparseMapBase<Map<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
257 {
258  public:
261  enum { IsRowMajor = Base::IsRowMajor };
262 
263  public:
264 #endif
265 
270  inline Map(Index rows, Index cols, Index nnz, const StorageIndex* outerIndexPtr,
271  const StorageIndex* innerIndexPtr, const Scalar* valuePtr, const StorageIndex* innerNonZerosPtr = 0)
272  : Base(rows, cols, nnz, outerIndexPtr, innerIndexPtr, valuePtr, innerNonZerosPtr)
273  {}
274 
276  inline ~Map() {}
277 };
278 
279 namespace internal {
280 
281 template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
282 struct evaluator<Map<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
283  : evaluator<SparseCompressedBase<Map<SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> > >
284 {
287  evaluator() : Base() {}
288  explicit evaluator(const XprType &mat) : Base(mat) {}
289 };
290 
291 template<typename MatScalar, int MatOptions, typename MatIndex, int Options, typename StrideType>
292 struct evaluator<Map<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> >
293  : evaluator<SparseCompressedBase<Map<const SparseMatrix<MatScalar,MatOptions,MatIndex>, Options, StrideType> > >
294 {
297  evaluator() : Base() {}
298  explicit evaluator(const XprType &mat) : Base(mat) {}
299 };
300 
301 }
302 
303 } // end namespace Eigen
304 
305 #endif // EIGEN_SPARSE_MAP_H
SCALAR Scalar
Definition: bench_gemm.cpp:33
Map(Index rows, Index cols, Index nnz, StorageIndex *outerIndexPtr, StorageIndex *innerIndexPtr, Scalar *valuePtr, StorageIndex *innerNonZerosPtr=0)
Definition: SparseMap.h:245
Scalar & coeffRef(Index row, Index col)
Definition: SparseMap.h:180
const StorageIndex * outerIndexPtr() const
Definition: SparseMap.h:99
Map< const SparseMatrix< MatScalar, MatOptions, MatIndex >, Options, StrideType > XprType
Definition: SparseMap.h:296
A versatible sparse matrix representation.
Definition: SparseMatrix.h:96
Q id(Eigen::AngleAxisd(0, Q_z_axis))
SparseMapBase< Derived, ReadOnlyAccessors > Base
Definition: SparseMap.h:154
A matrix or vector expression mapping an existing array of data.
Definition: Map.h:94
Common base class for Map and Ref instance of sparse matrix and vector.
Definition: SparseMap.h:50
const unsigned int LvalueBit
Definition: Constants.h:139
Namespace containing all symbols from the Eigen library.
Definition: jet.h:637
EIGEN_DEVICE_FUNC IndexDest convert_index(const IndexSrc &idx)
Definition: XprHelper.h:31
internal::conditional< bool(internal::is_lvalue< Derived >::value), StorageIndex *, const StorageIndex * >::type IndexPointer
Definition: SparseMap.h:66
Eigen::Index Index
The interface type of indices.
Definition: EigenBase.h:38
const StorageIndex * innerNonZeroPtr() const
Definition: SparseMap.h:101
Map< SparseMatrix< MatScalar, MatOptions, MatIndex >, Options, StrideType > XprType
Definition: SparseMap.h:286
Scalar Scalar int size
Definition: benchVecAdd.cpp:17
internal::traits< Derived >::StorageIndex StorageIndex
MapBase< Derived, ReadOnlyAccessors > ReadOnlyMapBase
Definition: SparseMap.h:151
#define EIGEN_SPARSE_PUBLIC_INTERFACE(Derived)
Definition: SparseUtil.h:43
Base class for dense Map and Block expression with direct access.
Definition: MapBase.h:37
SparseMapBase(Index size, Index nnz, IndexPointer innerIndexPtr, ScalarPointer valuePtr)
Definition: SparseMap.h:131
SparseMapBase(Index rows, Index cols, Index nnz, IndexPointer outerIndexPtr, IndexPointer innerIndexPtr, ScalarPointer valuePtr, IndexPointer innerNonZerosPtr=0)
Definition: SparseMap.h:124
internal::traits< Derived >::Scalar Scalar
m row(1)
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:33
#define eigen_assert(x)
Definition: Macros.h:579
int data[]
evaluator< SparseCompressedBase< Map< SparseMatrix< MatScalar, MatOptions, MatIndex >, Options, StrideType > > > Base
Definition: SparseMap.h:285
Scalar coeff(Index row, Index col) const
Definition: SparseMap.h:105
SparseMapBase(Index rows, Index cols, Index nnz, StorageIndex *outerIndexPtr, StorageIndex *innerIndexPtr, Scalar *valuePtr, StorageIndex *innerNonZerosPtr=0)
Definition: SparseMap.h:195
const StorageIndex * innerIndexPtr() const
Definition: SparseMap.h:97
SparseCompressedBase< Derived > Base
Definition: SparseMap.h:54
const unsigned int NestByRefBit
Definition: Constants.h:164
internal::conditional< bool(internal::is_lvalue< Derived >::value), Scalar *, const Scalar * >::type ScalarPointer
Definition: SparseMap.h:63
Map(Index rows, Index cols, Index nnz, const StorageIndex *outerIndexPtr, const StorageIndex *innerIndexPtr, const Scalar *valuePtr, const StorageIndex *innerNonZerosPtr=0)
Definition: SparseMap.h:270
evaluator< SparseCompressedBase< Map< const SparseMatrix< MatScalar, MatOptions, MatIndex >, Options, StrideType > > > Base
Definition: SparseMap.h:295
m col(1)
SparseMapBase(Index size, Index nnz, StorageIndex *innerIndexPtr, Scalar *valuePtr)
Definition: SparseMap.h:201
Common base class for sparse [compressed]-{row|column}-storage format.
Definition: pytypes.h:897


gtsam
Author(s):
autogenerated on Sat May 8 2021 02:44:34