Medial Code Documentation
Loading...
Searching...
No Matches
SparseBlock.h
1// This file is part of Eigen, a lightweight C++ template library
2// for linear algebra.
3//
4// Copyright (C) 2008-2014 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_BLOCK_H
11#define EIGEN_SPARSE_BLOCK_H
12
13namespace Eigen {
14
15// Subset of columns or rows
16template<typename XprType, int BlockRows, int BlockCols>
17class BlockImpl<XprType,BlockRows,BlockCols,true,Sparse>
18 : public SparseMatrixBase<Block<XprType,BlockRows,BlockCols,true> >
19{
20 typedef typename internal::remove_all<typename XprType::Nested>::type _MatrixTypeNested;
21 typedef Block<XprType, BlockRows, BlockCols, true> BlockType;
22public:
23 enum { IsRowMajor = internal::traits<BlockType>::IsRowMajor };
24protected:
25 enum { OuterSize = IsRowMajor ? BlockRows : BlockCols };
26 typedef SparseMatrixBase<BlockType> Base;
27 using Base::convert_index;
28public:
29 EIGEN_SPARSE_PUBLIC_INTERFACE(BlockType)
30
31 inline BlockImpl(XprType& xpr, Index i)
32 : m_matrix(xpr), m_outerStart(convert_index(i)), m_outerSize(OuterSize)
33 {}
34
35 inline BlockImpl(XprType& xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
36 : m_matrix(xpr), m_outerStart(convert_index(IsRowMajor ? startRow : startCol)), m_outerSize(convert_index(IsRowMajor ? blockRows : blockCols))
37 {}
38
39 EIGEN_STRONG_INLINE Index rows() const { return IsRowMajor ? m_outerSize.value() : m_matrix.rows(); }
40 EIGEN_STRONG_INLINE Index cols() const { return IsRowMajor ? m_matrix.cols() : m_outerSize.value(); }
41
42 Index nonZeros() const
43 {
44 typedef internal::evaluator<XprType> EvaluatorType;
45 EvaluatorType matEval(m_matrix);
46 Index nnz = 0;
47 Index end = m_outerStart + m_outerSize.value();
48 for(Index j=m_outerStart; j<end; ++j)
49 for(typename EvaluatorType::InnerIterator it(matEval, j); it; ++it)
50 ++nnz;
51 return nnz;
52 }
53
54 inline const Scalar coeff(Index row, Index col) const
55 {
56 return m_matrix.coeff(row + (IsRowMajor ? m_outerStart : 0), col + (IsRowMajor ? 0 : m_outerStart));
57 }
58
59 inline const Scalar coeff(Index index) const
60 {
61 return m_matrix.coeff(IsRowMajor ? m_outerStart : index, IsRowMajor ? index : m_outerStart);
62 }
63
64 inline const XprType& nestedExpression() const { return m_matrix; }
65 inline XprType& nestedExpression() { return m_matrix; }
66 Index startRow() const { return IsRowMajor ? m_outerStart : 0; }
67 Index startCol() const { return IsRowMajor ? 0 : m_outerStart; }
68 Index blockRows() const { return IsRowMajor ? m_outerSize.value() : m_matrix.rows(); }
69 Index blockCols() const { return IsRowMajor ? m_matrix.cols() : m_outerSize.value(); }
70
71 protected:
72
73 typename internal::ref_selector<XprType>::non_const_type m_matrix;
74 Index m_outerStart;
75 const internal::variable_if_dynamic<Index, OuterSize> m_outerSize;
76
77 protected:
78 // Disable assignment with clear error message.
79 // Note that simply removing operator= yields compilation errors with ICC+MSVC
80 template<typename T>
81 BlockImpl& operator=(const T&)
82 {
83 EIGEN_STATIC_ASSERT(sizeof(T)==0, THIS_SPARSE_BLOCK_SUBEXPRESSION_IS_READ_ONLY);
84 return *this;
85 }
86};
87
88
89/***************************************************************************
90* specialization for SparseMatrix
91***************************************************************************/
92
93namespace internal {
94
95template<typename SparseMatrixType, int BlockRows, int BlockCols>
96class sparse_matrix_block_impl
97 : public SparseCompressedBase<Block<SparseMatrixType,BlockRows,BlockCols,true> >
98{
99 typedef typename internal::remove_all<typename SparseMatrixType::Nested>::type _MatrixTypeNested;
100 typedef Block<SparseMatrixType, BlockRows, BlockCols, true> BlockType;
101 typedef SparseCompressedBase<Block<SparseMatrixType,BlockRows,BlockCols,true> > Base;
102 using Base::convert_index;
103public:
104 enum { IsRowMajor = internal::traits<BlockType>::IsRowMajor };
105 EIGEN_SPARSE_PUBLIC_INTERFACE(BlockType)
106protected:
107 typedef typename Base::IndexVector IndexVector;
108 enum { OuterSize = IsRowMajor ? BlockRows : BlockCols };
109public:
110
111 inline sparse_matrix_block_impl(SparseMatrixType& xpr, Index i)
112 : m_matrix(xpr), m_outerStart(convert_index(i)), m_outerSize(OuterSize)
113 {}
114
115 inline sparse_matrix_block_impl(SparseMatrixType& xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
116 : m_matrix(xpr), m_outerStart(convert_index(IsRowMajor ? startRow : startCol)), m_outerSize(convert_index(IsRowMajor ? blockRows : blockCols))
117 {}
118
119 template<typename OtherDerived>
120 inline BlockType& operator=(const SparseMatrixBase<OtherDerived>& other)
121 {
122 typedef typename internal::remove_all<typename SparseMatrixType::Nested>::type _NestedMatrixType;
123 _NestedMatrixType& matrix = m_matrix;
124 // This assignment is slow if this vector set is not empty
125 // and/or it is not at the end of the nonzeros of the underlying matrix.
126
127 // 1 - eval to a temporary to avoid transposition and/or aliasing issues
128 Ref<const SparseMatrix<Scalar, IsRowMajor ? RowMajor : ColMajor, StorageIndex> > tmp(other.derived());
129 eigen_internal_assert(tmp.outerSize()==m_outerSize.value());
130
131 // 2 - let's check whether there is enough allocated memory
132 Index nnz = tmp.nonZeros();
133 Index start = m_outerStart==0 ? 0 : m_matrix.outerIndexPtr()[m_outerStart]; // starting position of the current block
134 Index end = m_matrix.outerIndexPtr()[m_outerStart+m_outerSize.value()]; // ending position of the current block
135 Index block_size = end - start; // available room in the current block
136 Index tail_size = m_matrix.outerIndexPtr()[m_matrix.outerSize()] - end;
137
138 Index free_size = m_matrix.isCompressed()
139 ? Index(matrix.data().allocatedSize()) + block_size
140 : block_size;
141
142 Index tmp_start = tmp.outerIndexPtr()[0];
143
144 bool update_trailing_pointers = false;
145 if(nnz>free_size)
146 {
147 // realloc manually to reduce copies
148 typename SparseMatrixType::Storage newdata(m_matrix.data().allocatedSize() - block_size + nnz);
149
150 internal::smart_copy(m_matrix.valuePtr(), m_matrix.valuePtr() + start, newdata.valuePtr());
151 internal::smart_copy(m_matrix.innerIndexPtr(), m_matrix.innerIndexPtr() + start, newdata.indexPtr());
152
153 internal::smart_copy(tmp.valuePtr() + tmp_start, tmp.valuePtr() + tmp_start + nnz, newdata.valuePtr() + start);
154 internal::smart_copy(tmp.innerIndexPtr() + tmp_start, tmp.innerIndexPtr() + tmp_start + nnz, newdata.indexPtr() + start);
155
156 internal::smart_copy(matrix.valuePtr()+end, matrix.valuePtr()+end + tail_size, newdata.valuePtr()+start+nnz);
157 internal::smart_copy(matrix.innerIndexPtr()+end, matrix.innerIndexPtr()+end + tail_size, newdata.indexPtr()+start+nnz);
158
159 newdata.resize(m_matrix.outerIndexPtr()[m_matrix.outerSize()] - block_size + nnz);
160
161 matrix.data().swap(newdata);
162
163 update_trailing_pointers = true;
164 }
165 else
166 {
167 if(m_matrix.isCompressed() && nnz!=block_size)
168 {
169 // no need to realloc, simply copy the tail at its respective position and insert tmp
170 matrix.data().resize(start + nnz + tail_size);
171
172 internal::smart_memmove(matrix.valuePtr()+end, matrix.valuePtr() + end+tail_size, matrix.valuePtr() + start+nnz);
173 internal::smart_memmove(matrix.innerIndexPtr()+end, matrix.innerIndexPtr() + end+tail_size, matrix.innerIndexPtr() + start+nnz);
174
175 update_trailing_pointers = true;
176 }
177
178 internal::smart_copy(tmp.valuePtr() + tmp_start, tmp.valuePtr() + tmp_start + nnz, matrix.valuePtr() + start);
179 internal::smart_copy(tmp.innerIndexPtr() + tmp_start, tmp.innerIndexPtr() + tmp_start + nnz, matrix.innerIndexPtr() + start);
180 }
181
182 // update outer index pointers and innerNonZeros
183 if(IsVectorAtCompileTime)
184 {
185 if(!m_matrix.isCompressed())
186 matrix.innerNonZeroPtr()[m_outerStart] = StorageIndex(nnz);
187 matrix.outerIndexPtr()[m_outerStart] = StorageIndex(start);
188 }
189 else
190 {
191 StorageIndex p = StorageIndex(start);
192 for(Index k=0; k<m_outerSize.value(); ++k)
193 {
194 StorageIndex nnz_k = internal::convert_index<StorageIndex>(tmp.innerVector(k).nonZeros());
195 if(!m_matrix.isCompressed())
196 matrix.innerNonZeroPtr()[m_outerStart+k] = nnz_k;
197 matrix.outerIndexPtr()[m_outerStart+k] = p;
198 p += nnz_k;
199 }
200 }
201
202 if(update_trailing_pointers)
203 {
204 StorageIndex offset = internal::convert_index<StorageIndex>(nnz - block_size);
205 for(Index k = m_outerStart + m_outerSize.value(); k<=matrix.outerSize(); ++k)
206 {
207 matrix.outerIndexPtr()[k] += offset;
208 }
209 }
210
211 return derived();
212 }
213
214 inline BlockType& operator=(const BlockType& other)
215 {
216 return operator=<BlockType>(other);
217 }
218
219 inline const Scalar* valuePtr() const
220 { return m_matrix.valuePtr(); }
221 inline Scalar* valuePtr()
222 { return m_matrix.valuePtr(); }
223
224 inline const StorageIndex* innerIndexPtr() const
225 { return m_matrix.innerIndexPtr(); }
226 inline StorageIndex* innerIndexPtr()
227 { return m_matrix.innerIndexPtr(); }
228
229 inline const StorageIndex* outerIndexPtr() const
230 { return m_matrix.outerIndexPtr() + m_outerStart; }
231 inline StorageIndex* outerIndexPtr()
232 { return m_matrix.outerIndexPtr() + m_outerStart; }
233
234 inline const StorageIndex* innerNonZeroPtr() const
235 { return isCompressed() ? 0 : (m_matrix.innerNonZeroPtr()+m_outerStart); }
236 inline StorageIndex* innerNonZeroPtr()
237 { return isCompressed() ? 0 : (m_matrix.innerNonZeroPtr()+m_outerStart); }
238
239 bool isCompressed() const { return m_matrix.innerNonZeroPtr()==0; }
240
241 inline Scalar& coeffRef(Index row, Index col)
242 {
243 return m_matrix.coeffRef(row + (IsRowMajor ? m_outerStart : 0), col + (IsRowMajor ? 0 : m_outerStart));
244 }
245
246 inline const Scalar coeff(Index row, Index col) const
247 {
248 return m_matrix.coeff(row + (IsRowMajor ? m_outerStart : 0), col + (IsRowMajor ? 0 : m_outerStart));
249 }
250
251 inline const Scalar coeff(Index index) const
252 {
253 return m_matrix.coeff(IsRowMajor ? m_outerStart : index, IsRowMajor ? index : m_outerStart);
254 }
255
256 const Scalar& lastCoeff() const
257 {
258 EIGEN_STATIC_ASSERT_VECTOR_ONLY(sparse_matrix_block_impl);
259 eigen_assert(Base::nonZeros()>0);
260 if(m_matrix.isCompressed())
261 return m_matrix.valuePtr()[m_matrix.outerIndexPtr()[m_outerStart+1]-1];
262 else
263 return m_matrix.valuePtr()[m_matrix.outerIndexPtr()[m_outerStart]+m_matrix.innerNonZeroPtr()[m_outerStart]-1];
264 }
265
266 EIGEN_STRONG_INLINE Index rows() const { return IsRowMajor ? m_outerSize.value() : m_matrix.rows(); }
267 EIGEN_STRONG_INLINE Index cols() const { return IsRowMajor ? m_matrix.cols() : m_outerSize.value(); }
268
269 inline const SparseMatrixType& nestedExpression() const { return m_matrix; }
270 inline SparseMatrixType& nestedExpression() { return m_matrix; }
271 Index startRow() const { return IsRowMajor ? m_outerStart : 0; }
272 Index startCol() const { return IsRowMajor ? 0 : m_outerStart; }
273 Index blockRows() const { return IsRowMajor ? m_outerSize.value() : m_matrix.rows(); }
274 Index blockCols() const { return IsRowMajor ? m_matrix.cols() : m_outerSize.value(); }
275
276 protected:
277
278 typename internal::ref_selector<SparseMatrixType>::non_const_type m_matrix;
279 Index m_outerStart;
280 const internal::variable_if_dynamic<Index, OuterSize> m_outerSize;
281
282};
283
284} // namespace internal
285
286template<typename _Scalar, int _Options, typename _StorageIndex, int BlockRows, int BlockCols>
287class BlockImpl<SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols,true,Sparse>
288 : public internal::sparse_matrix_block_impl<SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols>
289{
290public:
291 typedef _StorageIndex StorageIndex;
292 typedef SparseMatrix<_Scalar, _Options, _StorageIndex> SparseMatrixType;
293 typedef internal::sparse_matrix_block_impl<SparseMatrixType,BlockRows,BlockCols> Base;
294 inline BlockImpl(SparseMatrixType& xpr, Index i)
295 : Base(xpr, i)
296 {}
297
298 inline BlockImpl(SparseMatrixType& xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
299 : Base(xpr, startRow, startCol, blockRows, blockCols)
300 {}
301
302 using Base::operator=;
303};
304
305template<typename _Scalar, int _Options, typename _StorageIndex, int BlockRows, int BlockCols>
306class BlockImpl<const SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols,true,Sparse>
307 : public internal::sparse_matrix_block_impl<const SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols>
308{
309public:
310 typedef _StorageIndex StorageIndex;
311 typedef const SparseMatrix<_Scalar, _Options, _StorageIndex> SparseMatrixType;
312 typedef internal::sparse_matrix_block_impl<SparseMatrixType,BlockRows,BlockCols> Base;
313 inline BlockImpl(SparseMatrixType& xpr, Index i)
314 : Base(xpr, i)
315 {}
316
317 inline BlockImpl(SparseMatrixType& xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
318 : Base(xpr, startRow, startCol, blockRows, blockCols)
319 {}
320
321 using Base::operator=;
322private:
323 template<typename Derived> BlockImpl(const SparseMatrixBase<Derived>& xpr, Index i);
324 template<typename Derived> BlockImpl(const SparseMatrixBase<Derived>& xpr);
325};
326
327//----------
328
332template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel>
333class BlockImpl<XprType,BlockRows,BlockCols,InnerPanel,Sparse>
334 : public SparseMatrixBase<Block<XprType,BlockRows,BlockCols,InnerPanel> >, internal::no_assignment_operator
335{
336 typedef Block<XprType, BlockRows, BlockCols, InnerPanel> BlockType;
337 typedef SparseMatrixBase<BlockType> Base;
338 using Base::convert_index;
339public:
340 enum { IsRowMajor = internal::traits<BlockType>::IsRowMajor };
341 EIGEN_SPARSE_PUBLIC_INTERFACE(BlockType)
342
343 typedef typename internal::remove_all<typename XprType::Nested>::type _MatrixTypeNested;
344
347 inline BlockImpl(XprType& xpr, Index i)
348 : m_matrix(xpr),
349 m_startRow( (BlockRows==1) && (BlockCols==XprType::ColsAtCompileTime) ? convert_index(i) : 0),
350 m_startCol( (BlockRows==XprType::RowsAtCompileTime) && (BlockCols==1) ? convert_index(i) : 0),
351 m_blockRows(BlockRows==1 ? 1 : xpr.rows()),
352 m_blockCols(BlockCols==1 ? 1 : xpr.cols())
353 {}
354
357 inline BlockImpl(XprType& xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
358 : m_matrix(xpr), m_startRow(convert_index(startRow)), m_startCol(convert_index(startCol)), m_blockRows(convert_index(blockRows)), m_blockCols(convert_index(blockCols))
359 {}
360
361 inline Index rows() const { return m_blockRows.value(); }
362 inline Index cols() const { return m_blockCols.value(); }
363
364 inline Scalar& coeffRef(Index row, Index col)
365 {
366 return m_matrix.coeffRef(row + m_startRow.value(), col + m_startCol.value());
367 }
368
369 inline const Scalar coeff(Index row, Index col) const
370 {
371 return m_matrix.coeff(row + m_startRow.value(), col + m_startCol.value());
372 }
373
374 inline Scalar& coeffRef(Index index)
375 {
376 return m_matrix.coeffRef(m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
377 m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0));
378 }
379
380 inline const Scalar coeff(Index index) const
381 {
382 return m_matrix.coeff(m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index),
383 m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0));
384 }
385
386 inline const XprType& nestedExpression() const { return m_matrix; }
387 inline XprType& nestedExpression() { return m_matrix; }
388 Index startRow() const { return m_startRow.value(); }
389 Index startCol() const { return m_startCol.value(); }
390 Index blockRows() const { return m_blockRows.value(); }
391 Index blockCols() const { return m_blockCols.value(); }
392
393 protected:
394// friend class internal::GenericSparseBlockInnerIteratorImpl<XprType,BlockRows,BlockCols,InnerPanel>;
395 friend struct internal::unary_evaluator<Block<XprType,BlockRows,BlockCols,InnerPanel>, internal::IteratorBased, Scalar >;
396
397 Index nonZeros() const { return Dynamic; }
398
399 typename internal::ref_selector<XprType>::non_const_type m_matrix;
400 const internal::variable_if_dynamic<Index, XprType::RowsAtCompileTime == 1 ? 0 : Dynamic> m_startRow;
401 const internal::variable_if_dynamic<Index, XprType::ColsAtCompileTime == 1 ? 0 : Dynamic> m_startCol;
402 const internal::variable_if_dynamic<Index, RowsAtCompileTime> m_blockRows;
403 const internal::variable_if_dynamic<Index, ColsAtCompileTime> m_blockCols;
404
405 protected:
406 // Disable assignment with clear error message.
407 // Note that simply removing operator= yields compilation errors with ICC+MSVC
408 template<typename T>
409 BlockImpl& operator=(const T&)
410 {
411 EIGEN_STATIC_ASSERT(sizeof(T)==0, THIS_SPARSE_BLOCK_SUBEXPRESSION_IS_READ_ONLY);
412 return *this;
413 }
414
415};
416
417namespace internal {
418
419template<typename ArgType, int BlockRows, int BlockCols, bool InnerPanel>
420struct unary_evaluator<Block<ArgType,BlockRows,BlockCols,InnerPanel>, IteratorBased >
421 : public evaluator_base<Block<ArgType,BlockRows,BlockCols,InnerPanel> >
422{
423 class InnerVectorInnerIterator;
424 class OuterVectorInnerIterator;
425 public:
426 typedef Block<ArgType,BlockRows,BlockCols,InnerPanel> XprType;
427 typedef typename XprType::StorageIndex StorageIndex;
428 typedef typename XprType::Scalar Scalar;
429
430 enum {
431 IsRowMajor = XprType::IsRowMajor,
432 OuterVector = (BlockCols == 1 && ArgType::IsRowMajor) || (BlockRows == 1 && !ArgType::IsRowMajor),
433 CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
434 Flags = XprType::Flags
435 };
436
437 typedef typename internal::conditional<OuterVector,OuterVectorInnerIterator,InnerVectorInnerIterator>::type InnerIterator;
438
439 explicit unary_evaluator(const XprType& op)
440 : m_argImpl(op.nestedExpression()), m_block(op)
441 {}
442
443 inline Index nonZerosEstimate() const {
444 const Index nnz = m_block.nonZeros();
445 if(nnz < 0) {
446 // Scale the non-zero estimate for the underlying expression linearly with block size.
447 // Return zero if the underlying block is empty.
448 const Index nested_sz = m_block.nestedExpression().size();
449 return nested_sz == 0 ? 0 : m_argImpl.nonZerosEstimate() * m_block.size() / nested_sz;
450 }
451 return nnz;
452 }
453
454 protected:
455 typedef typename evaluator<ArgType>::InnerIterator EvalIterator;
456
457 evaluator<ArgType> m_argImpl;
458 const XprType &m_block;
459};
460
461template<typename ArgType, int BlockRows, int BlockCols, bool InnerPanel>
462class unary_evaluator<Block<ArgType,BlockRows,BlockCols,InnerPanel>, IteratorBased>::InnerVectorInnerIterator
463 : public EvalIterator
464{
465 // NOTE MSVC fails to compile if we don't explicitely "import" IsRowMajor from unary_evaluator
466 // because the base class EvalIterator has a private IsRowMajor enum too. (bug #1786)
467 // NOTE We cannot call it IsRowMajor because it would shadow unary_evaluator::IsRowMajor
468 enum { XprIsRowMajor = unary_evaluator::IsRowMajor };
469 const XprType& m_block;
470 Index m_end;
471public:
472
473 EIGEN_STRONG_INLINE InnerVectorInnerIterator(const unary_evaluator& aEval, Index outer)
474 : EvalIterator(aEval.m_argImpl, outer + (XprIsRowMajor ? aEval.m_block.startRow() : aEval.m_block.startCol())),
475 m_block(aEval.m_block),
476 m_end(XprIsRowMajor ? aEval.m_block.startCol()+aEval.m_block.blockCols() : aEval.m_block.startRow()+aEval.m_block.blockRows())
477 {
478 while( (EvalIterator::operator bool()) && (EvalIterator::index() < (XprIsRowMajor ? m_block.startCol() : m_block.startRow())) )
479 EvalIterator::operator++();
480 }
481
482 inline StorageIndex index() const { return EvalIterator::index() - convert_index<StorageIndex>(XprIsRowMajor ? m_block.startCol() : m_block.startRow()); }
483 inline Index outer() const { return EvalIterator::outer() - (XprIsRowMajor ? m_block.startRow() : m_block.startCol()); }
484 inline Index row() const { return EvalIterator::row() - m_block.startRow(); }
485 inline Index col() const { return EvalIterator::col() - m_block.startCol(); }
486
487 inline operator bool() const { return EvalIterator::operator bool() && EvalIterator::index() < m_end; }
488};
489
490template<typename ArgType, int BlockRows, int BlockCols, bool InnerPanel>
491class unary_evaluator<Block<ArgType,BlockRows,BlockCols,InnerPanel>, IteratorBased>::OuterVectorInnerIterator
492{
493 // NOTE see above
494 enum { XprIsRowMajor = unary_evaluator::IsRowMajor };
495 const unary_evaluator& m_eval;
496 Index m_outerPos;
497 const Index m_innerIndex;
498 Index m_end;
499 EvalIterator m_it;
500public:
501
502 EIGEN_STRONG_INLINE OuterVectorInnerIterator(const unary_evaluator& aEval, Index outer)
503 : m_eval(aEval),
504 m_outerPos( (XprIsRowMajor ? aEval.m_block.startCol() : aEval.m_block.startRow()) ),
505 m_innerIndex(XprIsRowMajor ? aEval.m_block.startRow() : aEval.m_block.startCol()),
506 m_end(XprIsRowMajor ? aEval.m_block.startCol()+aEval.m_block.blockCols() : aEval.m_block.startRow()+aEval.m_block.blockRows()),
507 m_it(m_eval.m_argImpl, m_outerPos)
508 {
509 EIGEN_UNUSED_VARIABLE(outer);
510 eigen_assert(outer==0);
511
512 while(m_it && m_it.index() < m_innerIndex) ++m_it;
513 if((!m_it) || (m_it.index()!=m_innerIndex))
514 ++(*this);
515 }
516
517 inline StorageIndex index() const { return convert_index<StorageIndex>(m_outerPos - (XprIsRowMajor ? m_eval.m_block.startCol() : m_eval.m_block.startRow())); }
518 inline Index outer() const { return 0; }
519 inline Index row() const { return XprIsRowMajor ? 0 : index(); }
520 inline Index col() const { return XprIsRowMajor ? index() : 0; }
521
522 inline Scalar value() const { return m_it.value(); }
523 inline Scalar& valueRef() { return m_it.valueRef(); }
524
525 inline OuterVectorInnerIterator& operator++()
526 {
527 // search next non-zero entry
528 while(++m_outerPos<m_end)
529 {
530 // Restart iterator at the next inner-vector:
531 m_it.~EvalIterator();
532 ::new (&m_it) EvalIterator(m_eval.m_argImpl, m_outerPos);
533 // search for the key m_innerIndex in the current outer-vector
534 while(m_it && m_it.index() < m_innerIndex) ++m_it;
535 if(m_it && m_it.index()==m_innerIndex) break;
536 }
537 return *this;
538 }
539
540 inline operator bool() const { return m_outerPos < m_end; }
541};
542
543template<typename _Scalar, int _Options, typename _StorageIndex, int BlockRows, int BlockCols>
544struct unary_evaluator<Block<SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols,true>, IteratorBased>
545 : evaluator<SparseCompressedBase<Block<SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols,true> > >
546{
547 typedef Block<SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols,true> XprType;
548 typedef evaluator<SparseCompressedBase<XprType> > Base;
549 explicit unary_evaluator(const XprType &xpr) : Base(xpr) {}
550};
551
552template<typename _Scalar, int _Options, typename _StorageIndex, int BlockRows, int BlockCols>
553struct unary_evaluator<Block<const SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols,true>, IteratorBased>
554 : evaluator<SparseCompressedBase<Block<const SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols,true> > >
555{
556 typedef Block<const SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols,true> XprType;
557 typedef evaluator<SparseCompressedBase<XprType> > Base;
558 explicit unary_evaluator(const XprType &xpr) : Base(xpr) {}
559};
560
561} // end namespace internal
562
563
564} // end namespace Eigen
565
566#endif // EIGEN_SPARSE_BLOCK_H
Eigen::BlockImpl< XprType, BlockRows, BlockCols, InnerPanel, Sparse >::BlockImpl
BlockImpl(XprType &xpr, Index startRow, Index startCol, Index blockRows, Index blockCols)
Dynamic-size constructor.
Definition SparseBlock.h:357
Eigen::BlockImpl< XprType, BlockRows, BlockCols, InnerPanel, Sparse >::BlockImpl
BlockImpl(XprType &xpr, Index i)
Column or Row constructor.
Definition SparseBlock.h:347
Eigen::BlockImpl
Definition Block.h:67
Eigen::Block
Expression of a fixed-size or dynamic-size block.
Definition Block.h:105
Eigen::DenseBase::resize
EIGEN_DEVICE_FUNC void resize(Index newSize)
Only plain matrices/arrays, not expressions, may be resized; therefore the only useful resize methods...
Definition DenseBase.h:246
Eigen::DenseBase::value
EIGEN_DEVICE_FUNC CoeffReturnType value() const
Definition DenseBase.h:526
Eigen::MatrixBase
Base class for all dense matrices, vectors, and expressions.
Definition MatrixBase.h:50
Eigen::SparseCompressedBase
Common base class for sparse [compressed]-{row|column}-storage format.
Definition SparseCompressedBase.h:38
Eigen::SparseMatrixBase
Base class of any sparse matrices or sparse expressions.
Definition SparseMatrixBase.h:28
Eigen::SparseMatrixBase::StorageIndex
internal::traits< Derived >::StorageIndex StorageIndex
The integer type used to store indices within a SparseMatrix.
Definition SparseMatrixBase.h:43
Eigen::SparseMatrixBase::IsVectorAtCompileTime
@ IsVectorAtCompileTime
This is set to true if either the number of rows or the number of columns is known at compile-time to...
Definition SparseMatrixBase.h:84
Eigen::SparseMatrix
A versatible sparse matrix representation.
Definition SparseMatrix.h:98
Eigen::internal::no_assignment_operator
Definition XprHelper.h:110
Eigen::internal::sparse_matrix_block_impl
Definition SparseBlock.h:98
Eigen::internal::variable_if_dynamic
Definition XprHelper.h:130
Eigen
Namespace containing all symbols from the Eigen library.
Definition LDLT.h:16
Eigen::Index
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition Meta.h:74
Eigen::Dynamic
const int Dynamic
This value means that a positive quantity (e.g., a size) is not known at compile-time,...
Definition Constants.h:22
Eigen::EigenBase::Index
Eigen::Index Index
The interface type of indices.
Definition EigenBase.h:39
Eigen::Sparse
The type used to identify a general sparse storage.
Definition Constants.h:510
Eigen::internal::IteratorBased
Definition Constants.h:545
Eigen::internal::evaluator_base
Definition CoreEvaluators.h:111
Eigen::internal::evaluator
Definition CoreEvaluators.h:91
Eigen::internal::traits
Definition ForwardDeclarations.h:17
Eigen::internal::true_type
Definition Meta.h:96
Eigen::internal::unary_evaluator
Definition CoreEvaluators.h:65
Generated on Thu Dec 18 2025 18:56:34 for Medial Code Documentation by doxygen 1.9.8