| | |
| | |
| | |
| | |
| | |
| | |
| | |
| | |
| |
|
| | #ifndef EIGEN_SPARSE_BLOCK_H |
| | #define EIGEN_SPARSE_BLOCK_H |
| |
|
| | namespace Eigen { |
| |
|
| | |
| | template<typename XprType, int BlockRows, int BlockCols> |
| | class BlockImpl<XprType,BlockRows,BlockCols,true,Sparse> |
| | : public SparseMatrixBase<Block<XprType,BlockRows,BlockCols,true> > |
| | { |
| | typedef typename internal::remove_all<typename XprType::Nested>::type _MatrixTypeNested; |
| | typedef Block<XprType, BlockRows, BlockCols, true> BlockType; |
| | public: |
| | enum { IsRowMajor = internal::traits<BlockType>::IsRowMajor }; |
| | protected: |
| | enum { OuterSize = IsRowMajor ? BlockRows : BlockCols }; |
| | typedef SparseMatrixBase<BlockType> Base; |
| | using Base::convert_index; |
| | public: |
| | EIGEN_SPARSE_PUBLIC_INTERFACE(BlockType) |
| |
|
| | inline BlockImpl(XprType& xpr, Index i) |
| | : m_matrix(xpr), m_outerStart(convert_index(i)), m_outerSize(OuterSize) |
| | {} |
| |
|
| | inline BlockImpl(XprType& xpr, Index startRow, Index startCol, Index blockRows, Index blockCols) |
| | : m_matrix(xpr), m_outerStart(convert_index(IsRowMajor ? startRow : startCol)), m_outerSize(convert_index(IsRowMajor ? blockRows : blockCols)) |
| | {} |
| |
|
| | EIGEN_STRONG_INLINE Index rows() const { return IsRowMajor ? m_outerSize.value() : m_matrix.rows(); } |
| | EIGEN_STRONG_INLINE Index cols() const { return IsRowMajor ? m_matrix.cols() : m_outerSize.value(); } |
| |
|
| | Index nonZeros() const |
| | { |
| | typedef internal::evaluator<XprType> EvaluatorType; |
| | EvaluatorType matEval(m_matrix); |
| | Index nnz = 0; |
| | Index end = m_outerStart + m_outerSize.value(); |
| | for(Index j=m_outerStart; j<end; ++j) |
| | for(typename EvaluatorType::InnerIterator it(matEval, j); it; ++it) |
| | ++nnz; |
| | return nnz; |
| | } |
| |
|
| | inline const Scalar coeff(Index row, Index col) const |
| | { |
| | return m_matrix.coeff(row + (IsRowMajor ? m_outerStart : 0), col + (IsRowMajor ? 0 : m_outerStart)); |
| | } |
| |
|
| | inline const Scalar coeff(Index index) const |
| | { |
| | return m_matrix.coeff(IsRowMajor ? m_outerStart : index, IsRowMajor ? index : m_outerStart); |
| | } |
| |
|
| | inline const XprType& nestedExpression() const { return m_matrix; } |
| | inline XprType& nestedExpression() { return m_matrix; } |
| | Index startRow() const { return IsRowMajor ? m_outerStart : 0; } |
| | Index startCol() const { return IsRowMajor ? 0 : m_outerStart; } |
| | Index blockRows() const { return IsRowMajor ? m_outerSize.value() : m_matrix.rows(); } |
| | Index blockCols() const { return IsRowMajor ? m_matrix.cols() : m_outerSize.value(); } |
| |
|
| | protected: |
| |
|
| | typename internal::ref_selector<XprType>::non_const_type m_matrix; |
| | Index m_outerStart; |
| | const internal::variable_if_dynamic<Index, OuterSize> m_outerSize; |
| |
|
| | protected: |
| | |
| | |
| | template<typename T> |
| | BlockImpl& operator=(const T&) |
| | { |
| | EIGEN_STATIC_ASSERT(sizeof(T)==0, THIS_SPARSE_BLOCK_SUBEXPRESSION_IS_READ_ONLY); |
| | return *this; |
| | } |
| | }; |
| |
|
| |
|
| | |
| | |
| | |
| |
|
| | namespace internal { |
| |
|
| | template<typename SparseMatrixType, int BlockRows, int BlockCols> |
| | class sparse_matrix_block_impl |
| | : public SparseCompressedBase<Block<SparseMatrixType,BlockRows,BlockCols,true> > |
| | { |
| | typedef typename internal::remove_all<typename SparseMatrixType::Nested>::type _MatrixTypeNested; |
| | typedef Block<SparseMatrixType, BlockRows, BlockCols, true> BlockType; |
| | typedef SparseCompressedBase<Block<SparseMatrixType,BlockRows,BlockCols,true> > Base; |
| | using Base::convert_index; |
| | public: |
| | enum { IsRowMajor = internal::traits<BlockType>::IsRowMajor }; |
| | EIGEN_SPARSE_PUBLIC_INTERFACE(BlockType) |
| | protected: |
| | typedef typename Base::IndexVector IndexVector; |
| | enum { OuterSize = IsRowMajor ? BlockRows : BlockCols }; |
| | public: |
| |
|
| | inline sparse_matrix_block_impl(SparseMatrixType& xpr, Index i) |
| | : m_matrix(xpr), m_outerStart(convert_index(i)), m_outerSize(OuterSize) |
| | {} |
| |
|
| | inline sparse_matrix_block_impl(SparseMatrixType& xpr, Index startRow, Index startCol, Index blockRows, Index blockCols) |
| | : m_matrix(xpr), m_outerStart(convert_index(IsRowMajor ? startRow : startCol)), m_outerSize(convert_index(IsRowMajor ? blockRows : blockCols)) |
| | {} |
| |
|
| | template<typename OtherDerived> |
| | inline BlockType& operator=(const SparseMatrixBase<OtherDerived>& other) |
| | { |
| | typedef typename internal::remove_all<typename SparseMatrixType::Nested>::type _NestedMatrixType; |
| | _NestedMatrixType& matrix = m_matrix; |
| | |
| | |
| |
|
| | |
| | Ref<const SparseMatrix<Scalar, IsRowMajor ? RowMajor : ColMajor, StorageIndex> > tmp(other.derived()); |
| | eigen_internal_assert(tmp.outerSize()==m_outerSize.value()); |
| |
|
| | |
| | Index nnz = tmp.nonZeros(); |
| | Index start = m_outerStart==0 ? 0 : m_matrix.outerIndexPtr()[m_outerStart]; |
| | Index end = m_matrix.outerIndexPtr()[m_outerStart+m_outerSize.value()]; |
| | Index block_size = end - start; |
| | Index tail_size = m_matrix.outerIndexPtr()[m_matrix.outerSize()] - end; |
| |
|
| | Index free_size = m_matrix.isCompressed() |
| | ? Index(matrix.data().allocatedSize()) + block_size |
| | : block_size; |
| |
|
| | Index tmp_start = tmp.outerIndexPtr()[0]; |
| |
|
| | bool update_trailing_pointers = false; |
| | if(nnz>free_size) |
| | { |
| | |
| | typename SparseMatrixType::Storage newdata(m_matrix.data().allocatedSize() - block_size + nnz); |
| |
|
| | internal::smart_copy(m_matrix.valuePtr(), m_matrix.valuePtr() + start, newdata.valuePtr()); |
| | internal::smart_copy(m_matrix.innerIndexPtr(), m_matrix.innerIndexPtr() + start, newdata.indexPtr()); |
| |
|
| | internal::smart_copy(tmp.valuePtr() + tmp_start, tmp.valuePtr() + tmp_start + nnz, newdata.valuePtr() + start); |
| | internal::smart_copy(tmp.innerIndexPtr() + tmp_start, tmp.innerIndexPtr() + tmp_start + nnz, newdata.indexPtr() + start); |
| |
|
| | internal::smart_copy(matrix.valuePtr()+end, matrix.valuePtr()+end + tail_size, newdata.valuePtr()+start+nnz); |
| | internal::smart_copy(matrix.innerIndexPtr()+end, matrix.innerIndexPtr()+end + tail_size, newdata.indexPtr()+start+nnz); |
| |
|
| | newdata.resize(m_matrix.outerIndexPtr()[m_matrix.outerSize()] - block_size + nnz); |
| |
|
| | matrix.data().swap(newdata); |
| |
|
| | update_trailing_pointers = true; |
| | } |
| | else |
| | { |
| | if(m_matrix.isCompressed() && nnz!=block_size) |
| | { |
| | |
| | matrix.data().resize(start + nnz + tail_size); |
| |
|
| | internal::smart_memmove(matrix.valuePtr()+end, matrix.valuePtr() + end+tail_size, matrix.valuePtr() + start+nnz); |
| | internal::smart_memmove(matrix.innerIndexPtr()+end, matrix.innerIndexPtr() + end+tail_size, matrix.innerIndexPtr() + start+nnz); |
| |
|
| | update_trailing_pointers = true; |
| | } |
| |
|
| | internal::smart_copy(tmp.valuePtr() + tmp_start, tmp.valuePtr() + tmp_start + nnz, matrix.valuePtr() + start); |
| | internal::smart_copy(tmp.innerIndexPtr() + tmp_start, tmp.innerIndexPtr() + tmp_start + nnz, matrix.innerIndexPtr() + start); |
| | } |
| |
|
| | |
| | if(IsVectorAtCompileTime) |
| | { |
| | if(!m_matrix.isCompressed()) |
| | matrix.innerNonZeroPtr()[m_outerStart] = StorageIndex(nnz); |
| | matrix.outerIndexPtr()[m_outerStart] = StorageIndex(start); |
| | } |
| | else |
| | { |
| | StorageIndex p = StorageIndex(start); |
| | for(Index k=0; k<m_outerSize.value(); ++k) |
| | { |
| | StorageIndex nnz_k = internal::convert_index<StorageIndex>(tmp.innerVector(k).nonZeros()); |
| | if(!m_matrix.isCompressed()) |
| | matrix.innerNonZeroPtr()[m_outerStart+k] = nnz_k; |
| | matrix.outerIndexPtr()[m_outerStart+k] = p; |
| | p += nnz_k; |
| | } |
| | } |
| |
|
| | if(update_trailing_pointers) |
| | { |
| | StorageIndex offset = internal::convert_index<StorageIndex>(nnz - block_size); |
| | for(Index k = m_outerStart + m_outerSize.value(); k<=matrix.outerSize(); ++k) |
| | { |
| | matrix.outerIndexPtr()[k] += offset; |
| | } |
| | } |
| |
|
| | return derived(); |
| | } |
| |
|
| | inline BlockType& operator=(const BlockType& other) |
| | { |
| | return operator=<BlockType>(other); |
| | } |
| |
|
| | inline const Scalar* valuePtr() const |
| | { return m_matrix.valuePtr(); } |
| | inline Scalar* valuePtr() |
| | { return m_matrix.valuePtr(); } |
| |
|
| | inline const StorageIndex* innerIndexPtr() const |
| | { return m_matrix.innerIndexPtr(); } |
| | inline StorageIndex* innerIndexPtr() |
| | { return m_matrix.innerIndexPtr(); } |
| |
|
| | inline const StorageIndex* outerIndexPtr() const |
| | { return m_matrix.outerIndexPtr() + m_outerStart; } |
| | inline StorageIndex* outerIndexPtr() |
| | { return m_matrix.outerIndexPtr() + m_outerStart; } |
| |
|
| | inline const StorageIndex* innerNonZeroPtr() const |
| | { return isCompressed() ? 0 : (m_matrix.innerNonZeroPtr()+m_outerStart); } |
| | inline StorageIndex* innerNonZeroPtr() |
| | { return isCompressed() ? 0 : (m_matrix.innerNonZeroPtr()+m_outerStart); } |
| |
|
| | bool isCompressed() const { return m_matrix.innerNonZeroPtr()==0; } |
| |
|
| | inline Scalar& coeffRef(Index row, Index col) |
| | { |
| | return m_matrix.coeffRef(row + (IsRowMajor ? m_outerStart : 0), col + (IsRowMajor ? 0 : m_outerStart)); |
| | } |
| |
|
| | inline const Scalar coeff(Index row, Index col) const |
| | { |
| | return m_matrix.coeff(row + (IsRowMajor ? m_outerStart : 0), col + (IsRowMajor ? 0 : m_outerStart)); |
| | } |
| |
|
| | inline const Scalar coeff(Index index) const |
| | { |
| | return m_matrix.coeff(IsRowMajor ? m_outerStart : index, IsRowMajor ? index : m_outerStart); |
| | } |
| |
|
| | const Scalar& lastCoeff() const |
| | { |
| | EIGEN_STATIC_ASSERT_VECTOR_ONLY(sparse_matrix_block_impl); |
| | eigen_assert(Base::nonZeros()>0); |
| | if(m_matrix.isCompressed()) |
| | return m_matrix.valuePtr()[m_matrix.outerIndexPtr()[m_outerStart+1]-1]; |
| | else |
| | return m_matrix.valuePtr()[m_matrix.outerIndexPtr()[m_outerStart]+m_matrix.innerNonZeroPtr()[m_outerStart]-1]; |
| | } |
| |
|
| | EIGEN_STRONG_INLINE Index rows() const { return IsRowMajor ? m_outerSize.value() : m_matrix.rows(); } |
| | EIGEN_STRONG_INLINE Index cols() const { return IsRowMajor ? m_matrix.cols() : m_outerSize.value(); } |
| |
|
| | inline const SparseMatrixType& nestedExpression() const { return m_matrix; } |
| | inline SparseMatrixType& nestedExpression() { return m_matrix; } |
| | Index startRow() const { return IsRowMajor ? m_outerStart : 0; } |
| | Index startCol() const { return IsRowMajor ? 0 : m_outerStart; } |
| | Index blockRows() const { return IsRowMajor ? m_outerSize.value() : m_matrix.rows(); } |
| | Index blockCols() const { return IsRowMajor ? m_matrix.cols() : m_outerSize.value(); } |
| |
|
| | protected: |
| |
|
| | typename internal::ref_selector<SparseMatrixType>::non_const_type m_matrix; |
| | Index m_outerStart; |
| | const internal::variable_if_dynamic<Index, OuterSize> m_outerSize; |
| |
|
| | }; |
| |
|
| | } |
| |
|
| | template<typename _Scalar, int _Options, typename _StorageIndex, int BlockRows, int BlockCols> |
| | class BlockImpl<SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols,true,Sparse> |
| | : public internal::sparse_matrix_block_impl<SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols> |
| | { |
| | public: |
| | typedef _StorageIndex StorageIndex; |
| | typedef SparseMatrix<_Scalar, _Options, _StorageIndex> SparseMatrixType; |
| | typedef internal::sparse_matrix_block_impl<SparseMatrixType,BlockRows,BlockCols> Base; |
| | inline BlockImpl(SparseMatrixType& xpr, Index i) |
| | : Base(xpr, i) |
| | {} |
| |
|
| | inline BlockImpl(SparseMatrixType& xpr, Index startRow, Index startCol, Index blockRows, Index blockCols) |
| | : Base(xpr, startRow, startCol, blockRows, blockCols) |
| | {} |
| |
|
| | using Base::operator=; |
| | }; |
| |
|
| | template<typename _Scalar, int _Options, typename _StorageIndex, int BlockRows, int BlockCols> |
| | class BlockImpl<const SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols,true,Sparse> |
| | : public internal::sparse_matrix_block_impl<const SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols> |
| | { |
| | public: |
| | typedef _StorageIndex StorageIndex; |
| | typedef const SparseMatrix<_Scalar, _Options, _StorageIndex> SparseMatrixType; |
| | typedef internal::sparse_matrix_block_impl<SparseMatrixType,BlockRows,BlockCols> Base; |
| | inline BlockImpl(SparseMatrixType& xpr, Index i) |
| | : Base(xpr, i) |
| | {} |
| |
|
| | inline BlockImpl(SparseMatrixType& xpr, Index startRow, Index startCol, Index blockRows, Index blockCols) |
| | : Base(xpr, startRow, startCol, blockRows, blockCols) |
| | {} |
| |
|
| | using Base::operator=; |
| | private: |
| | template<typename Derived> BlockImpl(const SparseMatrixBase<Derived>& xpr, Index i); |
| | template<typename Derived> BlockImpl(const SparseMatrixBase<Derived>& xpr); |
| | }; |
| |
|
| | |
| |
|
| | |
| | |
| | |
| | template<typename XprType, int BlockRows, int BlockCols, bool InnerPanel> |
| | class BlockImpl<XprType,BlockRows,BlockCols,InnerPanel,Sparse> |
| | : public SparseMatrixBase<Block<XprType,BlockRows,BlockCols,InnerPanel> >, internal::no_assignment_operator |
| | { |
| | typedef Block<XprType, BlockRows, BlockCols, InnerPanel> BlockType; |
| | typedef SparseMatrixBase<BlockType> Base; |
| | using Base::convert_index; |
| | public: |
| | enum { IsRowMajor = internal::traits<BlockType>::IsRowMajor }; |
| | EIGEN_SPARSE_PUBLIC_INTERFACE(BlockType) |
| |
|
| | typedef typename internal::remove_all<typename XprType::Nested>::type _MatrixTypeNested; |
| |
|
| | |
| | |
| | inline BlockImpl(XprType& xpr, Index i) |
| | : m_matrix(xpr), |
| | m_startRow( (BlockRows==1) && (BlockCols==XprType::ColsAtCompileTime) ? convert_index(i) : 0), |
| | m_startCol( (BlockRows==XprType::RowsAtCompileTime) && (BlockCols==1) ? convert_index(i) : 0), |
| | m_blockRows(BlockRows==1 ? 1 : xpr.rows()), |
| | m_blockCols(BlockCols==1 ? 1 : xpr.cols()) |
| | {} |
| |
|
| | |
| | |
| | inline BlockImpl(XprType& xpr, Index startRow, Index startCol, Index blockRows, Index blockCols) |
| | : m_matrix(xpr), m_startRow(convert_index(startRow)), m_startCol(convert_index(startCol)), m_blockRows(convert_index(blockRows)), m_blockCols(convert_index(blockCols)) |
| | {} |
| |
|
| | inline Index rows() const { return m_blockRows.value(); } |
| | inline Index cols() const { return m_blockCols.value(); } |
| |
|
| | inline Scalar& coeffRef(Index row, Index col) |
| | { |
| | return m_matrix.coeffRef(row + m_startRow.value(), col + m_startCol.value()); |
| | } |
| |
|
| | inline const Scalar coeff(Index row, Index col) const |
| | { |
| | return m_matrix.coeff(row + m_startRow.value(), col + m_startCol.value()); |
| | } |
| |
|
| | inline Scalar& coeffRef(Index index) |
| | { |
| | return m_matrix.coeffRef(m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index), |
| | m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0)); |
| | } |
| |
|
| | inline const Scalar coeff(Index index) const |
| | { |
| | return m_matrix.coeff(m_startRow.value() + (RowsAtCompileTime == 1 ? 0 : index), |
| | m_startCol.value() + (RowsAtCompileTime == 1 ? index : 0)); |
| | } |
| |
|
| | inline const XprType& nestedExpression() const { return m_matrix; } |
| | inline XprType& nestedExpression() { return m_matrix; } |
| | Index startRow() const { return m_startRow.value(); } |
| | Index startCol() const { return m_startCol.value(); } |
| | Index blockRows() const { return m_blockRows.value(); } |
| | Index blockCols() const { return m_blockCols.value(); } |
| |
|
| | protected: |
| | |
| | friend struct internal::unary_evaluator<Block<XprType,BlockRows,BlockCols,InnerPanel>, internal::IteratorBased, Scalar >; |
| |
|
| | Index nonZeros() const { return Dynamic; } |
| |
|
| | typename internal::ref_selector<XprType>::non_const_type m_matrix; |
| | const internal::variable_if_dynamic<Index, XprType::RowsAtCompileTime == 1 ? 0 : Dynamic> m_startRow; |
| | const internal::variable_if_dynamic<Index, XprType::ColsAtCompileTime == 1 ? 0 : Dynamic> m_startCol; |
| | const internal::variable_if_dynamic<Index, RowsAtCompileTime> m_blockRows; |
| | const internal::variable_if_dynamic<Index, ColsAtCompileTime> m_blockCols; |
| |
|
| | protected: |
| | |
| | |
| | template<typename T> |
| | BlockImpl& operator=(const T&) |
| | { |
| | EIGEN_STATIC_ASSERT(sizeof(T)==0, THIS_SPARSE_BLOCK_SUBEXPRESSION_IS_READ_ONLY); |
| | return *this; |
| | } |
| |
|
| | }; |
| |
|
| | namespace internal { |
| |
|
| | template<typename ArgType, int BlockRows, int BlockCols, bool InnerPanel> |
| | struct unary_evaluator<Block<ArgType,BlockRows,BlockCols,InnerPanel>, IteratorBased > |
| | : public evaluator_base<Block<ArgType,BlockRows,BlockCols,InnerPanel> > |
| | { |
| | class InnerVectorInnerIterator; |
| | class OuterVectorInnerIterator; |
| | public: |
| | typedef Block<ArgType,BlockRows,BlockCols,InnerPanel> XprType; |
| | typedef typename XprType::StorageIndex StorageIndex; |
| | typedef typename XprType::Scalar Scalar; |
| |
|
| | enum { |
| | IsRowMajor = XprType::IsRowMajor, |
| | OuterVector = (BlockCols == 1 && ArgType::IsRowMajor) || (BlockRows == 1 && !ArgType::IsRowMajor), |
| | CoeffReadCost = evaluator<ArgType>::CoeffReadCost, |
| | Flags = XprType::Flags |
| | }; |
| |
|
| | typedef typename internal::conditional<OuterVector,OuterVectorInnerIterator,InnerVectorInnerIterator>::type InnerIterator; |
| |
|
| | explicit unary_evaluator(const XprType& op) |
| | : m_argImpl(op.nestedExpression()), m_block(op) |
| | {} |
| |
|
| | inline Index nonZerosEstimate() const { |
| | const Index nnz = m_block.nonZeros(); |
| | if(nnz < 0) { |
| | |
| | |
| | const Index nested_sz = m_block.nestedExpression().size(); |
| | return nested_sz == 0 ? 0 : m_argImpl.nonZerosEstimate() * m_block.size() / nested_sz; |
| | } |
| | return nnz; |
| | } |
| |
|
| | protected: |
| | typedef typename evaluator<ArgType>::InnerIterator EvalIterator; |
| |
|
| | evaluator<ArgType> m_argImpl; |
| | const XprType &m_block; |
| | }; |
| |
|
| | template<typename ArgType, int BlockRows, int BlockCols, bool InnerPanel> |
| | class unary_evaluator<Block<ArgType,BlockRows,BlockCols,InnerPanel>, IteratorBased>::InnerVectorInnerIterator |
| | : public EvalIterator |
| | { |
| | |
| | |
| | |
| | enum { XprIsRowMajor = unary_evaluator::IsRowMajor }; |
| | const XprType& m_block; |
| | Index m_end; |
| | public: |
| |
|
| | EIGEN_STRONG_INLINE InnerVectorInnerIterator(const unary_evaluator& aEval, Index outer) |
| | : EvalIterator(aEval.m_argImpl, outer + (XprIsRowMajor ? aEval.m_block.startRow() : aEval.m_block.startCol())), |
| | m_block(aEval.m_block), |
| | m_end(XprIsRowMajor ? aEval.m_block.startCol()+aEval.m_block.blockCols() : aEval.m_block.startRow()+aEval.m_block.blockRows()) |
| | { |
| | while( (EvalIterator::operator bool()) && (EvalIterator::index() < (XprIsRowMajor ? m_block.startCol() : m_block.startRow())) ) |
| | EvalIterator::operator++(); |
| | } |
| |
|
| | inline StorageIndex index() const { return EvalIterator::index() - convert_index<StorageIndex>(XprIsRowMajor ? m_block.startCol() : m_block.startRow()); } |
| | inline Index outer() const { return EvalIterator::outer() - (XprIsRowMajor ? m_block.startRow() : m_block.startCol()); } |
| | inline Index row() const { return EvalIterator::row() - m_block.startRow(); } |
| | inline Index col() const { return EvalIterator::col() - m_block.startCol(); } |
| |
|
| | inline operator bool() const { return EvalIterator::operator bool() && EvalIterator::index() < m_end; } |
| | }; |
| |
|
| | template<typename ArgType, int BlockRows, int BlockCols, bool InnerPanel> |
| | class unary_evaluator<Block<ArgType,BlockRows,BlockCols,InnerPanel>, IteratorBased>::OuterVectorInnerIterator |
| | { |
| | |
| | enum { XprIsRowMajor = unary_evaluator::IsRowMajor }; |
| | const unary_evaluator& m_eval; |
| | Index m_outerPos; |
| | const Index m_innerIndex; |
| | Index m_end; |
| | EvalIterator m_it; |
| | public: |
| |
|
| | EIGEN_STRONG_INLINE OuterVectorInnerIterator(const unary_evaluator& aEval, Index outer) |
| | : m_eval(aEval), |
| | m_outerPos( (XprIsRowMajor ? aEval.m_block.startCol() : aEval.m_block.startRow()) ), |
| | m_innerIndex(XprIsRowMajor ? aEval.m_block.startRow() : aEval.m_block.startCol()), |
| | m_end(XprIsRowMajor ? aEval.m_block.startCol()+aEval.m_block.blockCols() : aEval.m_block.startRow()+aEval.m_block.blockRows()), |
| | m_it(m_eval.m_argImpl, m_outerPos) |
| | { |
| | EIGEN_UNUSED_VARIABLE(outer); |
| | eigen_assert(outer==0); |
| |
|
| | while(m_it && m_it.index() < m_innerIndex) ++m_it; |
| | if((!m_it) || (m_it.index()!=m_innerIndex)) |
| | ++(*this); |
| | } |
| |
|
| | inline StorageIndex index() const { return convert_index<StorageIndex>(m_outerPos - (XprIsRowMajor ? m_eval.m_block.startCol() : m_eval.m_block.startRow())); } |
| | inline Index outer() const { return 0; } |
| | inline Index row() const { return XprIsRowMajor ? 0 : index(); } |
| | inline Index col() const { return XprIsRowMajor ? index() : 0; } |
| |
|
| | inline Scalar value() const { return m_it.value(); } |
| | inline Scalar& valueRef() { return m_it.valueRef(); } |
| |
|
| | inline OuterVectorInnerIterator& operator++() |
| | { |
| | |
| | while(++m_outerPos<m_end) |
| | { |
| | |
| | m_it.~EvalIterator(); |
| | ::new (&m_it) EvalIterator(m_eval.m_argImpl, m_outerPos); |
| | |
| | while(m_it && m_it.index() < m_innerIndex) ++m_it; |
| | if(m_it && m_it.index()==m_innerIndex) break; |
| | } |
| | return *this; |
| | } |
| |
|
| | inline operator bool() const { return m_outerPos < m_end; } |
| | }; |
| |
|
| | template<typename _Scalar, int _Options, typename _StorageIndex, int BlockRows, int BlockCols> |
| | struct unary_evaluator<Block<SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols,true>, IteratorBased> |
| | : evaluator<SparseCompressedBase<Block<SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols,true> > > |
| | { |
| | typedef Block<SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols,true> XprType; |
| | typedef evaluator<SparseCompressedBase<XprType> > Base; |
| | explicit unary_evaluator(const XprType &xpr) : Base(xpr) {} |
| | }; |
| |
|
| | template<typename _Scalar, int _Options, typename _StorageIndex, int BlockRows, int BlockCols> |
| | struct unary_evaluator<Block<const SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols,true>, IteratorBased> |
| | : evaluator<SparseCompressedBase<Block<const SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols,true> > > |
| | { |
| | typedef Block<const SparseMatrix<_Scalar, _Options, _StorageIndex>,BlockRows,BlockCols,true> XprType; |
| | typedef evaluator<SparseCompressedBase<XprType> > Base; |
| | explicit unary_evaluator(const XprType &xpr) : Base(xpr) {} |
| | }; |
| |
|
| | } |
| |
|
| |
|
| | } |
| |
|
| | #endif |
| |
|