10 #ifndef EIGEN_SPARSEMATRIX_H
11 #define EIGEN_SPARSEMATRIX_H
42 template<
typename _Scalar,
int _Options,
typename _Index>
43 struct traits<SparseMatrix<_Scalar, _Options, _Index> >
45 typedef _Scalar Scalar;
47 typedef Sparse StorageKind;
48 typedef MatrixXpr XprKind;
54 Flags = _Options | NestByRefBit |
LvalueBit,
55 CoeffReadCost = NumTraits<Scalar>::ReadCost,
56 SupportedAccessPatterns = InnerRandomAccessPattern
60 template<
typename _Scalar,
int _Options,
typename _Index,
int DiagIndex>
61 struct traits<Diagonal<const SparseMatrix<_Scalar, _Options, _Index>, DiagIndex> >
63 typedef SparseMatrix<_Scalar, _Options, _Index> MatrixType;
64 typedef typename nested<MatrixType>::type MatrixTypeNested;
65 typedef typename remove_reference<MatrixTypeNested>::type _MatrixTypeNested;
67 typedef _Scalar Scalar;
68 typedef Dense StorageKind;
70 typedef MatrixXpr XprKind;
74 ColsAtCompileTime = 1,
76 MaxColsAtCompileTime = 1,
78 CoeffReadCost = _MatrixTypeNested::CoeffReadCost*10
84 template<
typename _Scalar,
int _Options,
typename _Index>
90 EIGEN_SPARSE_INHERIT_ASSIGNMENT_OPERATOR(
SparseMatrix, +=)
91 EIGEN_SPARSE_INHERIT_ASSIGNMENT_OPERATOR(
SparseMatrix, -=)
94 using Base::IsRowMajor;
95 typedef internal::CompressedStorage<Scalar,Index> Storage;
107 Index* m_innerNonZeros;
119 inline Index
rows()
const {
return IsRowMajor ? m_outerSize : m_innerSize; }
121 inline Index
cols()
const {
return IsRowMajor ? m_innerSize : m_outerSize; }
131 inline const Scalar*
valuePtr()
const {
return &m_data.value(0); }
135 inline Scalar*
valuePtr() {
return &m_data.value(0); }
165 inline Storage& data() {
return m_data; }
167 inline const Storage& data()
const {
return m_data; }
173 eigen_assert(row>=0 && row<
rows() && col>=0 && col<
cols());
175 const Index outer = IsRowMajor ? row :
col;
176 const Index inner = IsRowMajor ? col :
row;
177 Index end = m_innerNonZeros ? m_outerIndex[outer] + m_innerNonZeros[outer] : m_outerIndex[outer+1];
178 return m_data.atInRange(m_outerIndex[outer], end, inner);
191 eigen_assert(row>=0 && row<
rows() && col>=0 && col<
cols());
193 const Index outer = IsRowMajor ? row :
col;
194 const Index inner = IsRowMajor ? col :
row;
196 Index start = m_outerIndex[outer];
197 Index end = m_innerNonZeros ? m_outerIndex[outer] + m_innerNonZeros[outer] : m_outerIndex[outer+1];
198 eigen_assert(end>=start &&
"you probably called coeffRef on a non finalized matrix");
201 const Index p = m_data.searchLowerIndex(start,end-1,inner);
202 if((p<end) && (m_data.index(p)==inner))
203 return m_data.value(p);
222 eigen_assert(row>=0 && row<
rows() && col>=0 && col<
cols());
228 return insertUncompressed(row,col);
234 class ReverseInnerIterator;
240 memset(m_outerIndex, 0, (m_outerSize+1)*
sizeof(Index));
242 memset(m_innerNonZeros, 0, (m_outerSize)*
sizeof(Index));
249 return innerNonZeros().sum();
250 return static_cast<Index
>(m_data.size());
258 eigen_assert(
isCompressed() &&
"This function does not make sense in non compressed mode.");
259 m_data.reserve(reserveSize);
262 #ifdef EIGEN_PARSED_BY_DOXYGEN
266 template<
class SizesType>
267 inline void reserve(
const SizesType& reserveSizes);
269 template<
class SizesType>
270 inline void reserve(
const SizesType& reserveSizes,
const typename SizesType::value_type& enableif =
typename SizesType::value_type())
272 EIGEN_UNUSED_VARIABLE(enableif);
273 reserveInnerVectors(reserveSizes);
275 template<
class SizesType>
276 inline void reserve(
const SizesType& reserveSizes,
const typename SizesType::Scalar& enableif =
277 #
if (!defined(_MSC_VER)) || (_MSC_VER>=1500)
282 EIGEN_UNUSED_VARIABLE(enableif);
283 reserveInnerVectors(reserveSizes);
285 #endif // EIGEN_PARSED_BY_DOXYGEN
287 template<
class SizesType>
288 inline void reserveInnerVectors(
const SizesType& reserveSizes)
292 std::size_t totalReserveSize = 0;
294 m_innerNonZeros =
static_cast<Index*
>(std::malloc(m_outerSize *
sizeof(Index)));
295 if (!m_innerNonZeros) internal::throw_std_bad_alloc();
298 Index* newOuterIndex = m_innerNonZeros;
301 for(Index j=0; j<m_outerSize; ++j)
303 newOuterIndex[j] = count;
304 count += reserveSizes[j] + (m_outerIndex[j+1]-m_outerIndex[j]);
305 totalReserveSize += reserveSizes[j];
307 m_data.reserve(totalReserveSize);
308 Index previousOuterIndex = m_outerIndex[m_outerSize];
309 for(Index j=m_outerSize-1; j>=0; --j)
311 Index innerNNZ = previousOuterIndex - m_outerIndex[j];
312 for(Index i=innerNNZ-1; i>=0; --i)
314 m_data.index(newOuterIndex[j]+i) = m_data.index(m_outerIndex[j]+i);
315 m_data.value(newOuterIndex[j]+i) = m_data.value(m_outerIndex[j]+i);
317 previousOuterIndex = m_outerIndex[j];
318 m_outerIndex[j] = newOuterIndex[j];
319 m_innerNonZeros[j] = innerNNZ;
321 m_outerIndex[m_outerSize] = m_outerIndex[m_outerSize-1] + m_innerNonZeros[m_outerSize-1] + reserveSizes[m_outerSize-1];
323 m_data.resize(m_outerIndex[m_outerSize]);
327 Index* newOuterIndex =
static_cast<Index*
>(std::malloc((m_outerSize+1)*
sizeof(Index)));
328 if (!newOuterIndex) internal::throw_std_bad_alloc();
331 for(Index j=0; j<m_outerSize; ++j)
333 newOuterIndex[j] = count;
334 Index alreadyReserved = (m_outerIndex[j+1]-m_outerIndex[j]) - m_innerNonZeros[j];
335 Index toReserve = std::max<Index>(reserveSizes[j], alreadyReserved);
336 count += toReserve + m_innerNonZeros[j];
338 newOuterIndex[m_outerSize] = count;
340 m_data.resize(count);
341 for(Index j=m_outerSize-1; j>=0; --j)
343 Index offset = newOuterIndex[j] - m_outerIndex[j];
346 Index innerNNZ = m_innerNonZeros[j];
347 for(Index i=innerNNZ-1; i>=0; --i)
349 m_data.index(newOuterIndex[j]+i) = m_data.index(m_outerIndex[j]+i);
350 m_data.value(newOuterIndex[j]+i) = m_data.value(m_outerIndex[j]+i);
355 std::swap(m_outerIndex, newOuterIndex);
356 std::free(newOuterIndex);
374 inline Scalar& insertBack(Index
row, Index
col)
376 return insertBackByOuterInner(IsRowMajor?row:col, IsRowMajor?col:row);
381 inline Scalar& insertBackByOuterInner(Index outer, Index inner)
383 eigen_assert(
size_t(m_outerIndex[outer+1]) == m_data.size() &&
"Invalid ordered insertion (invalid outer index)");
384 eigen_assert( (m_outerIndex[outer+1]-m_outerIndex[outer]==0 || m_data.index(m_data.size()-1)<inner) &&
"Invalid ordered insertion (invalid inner index)");
385 Index p = m_outerIndex[outer+1];
386 ++m_outerIndex[outer+1];
387 m_data.append(0, inner);
388 return m_data.value(p);
393 inline Scalar& insertBackByOuterInnerUnordered(Index outer, Index inner)
395 Index p = m_outerIndex[outer+1];
396 ++m_outerIndex[outer+1];
397 m_data.append(0, inner);
398 return m_data.value(p);
403 inline void startVec(Index outer)
405 eigen_assert(m_outerIndex[outer]==
int(m_data.size()) &&
"You must call startVec for each inner vector sequentially");
406 eigen_assert(m_outerIndex[outer+1]==0 &&
"You must call startVec for each inner vector sequentially");
407 m_outerIndex[outer+1] = m_outerIndex[outer];
413 inline void finalize()
417 Index
size =
static_cast<Index
>(m_data.size());
418 Index i = m_outerSize;
420 while (i>=0 && m_outerIndex[i]==0)
423 while (i<=m_outerSize)
425 m_outerIndex[i] =
size;
433 template<
typename InputIterators>
434 void setFromTriplets(
const InputIterators& begin,
const InputIterators& end);
436 void sumupDuplicates();
442 Scalar& insertByOuterInner(Index j, Index i)
444 return insert(IsRowMajor ? j : i, IsRowMajor ? i : j);
454 Index oldStart = m_outerIndex[1];
455 m_outerIndex[1] = m_innerNonZeros[0];
456 for(Index j=1; j<m_outerSize; ++j)
458 Index nextOldStart = m_outerIndex[j+1];
459 Index offset = oldStart - m_outerIndex[j];
462 for(Index k=0; k<m_innerNonZeros[j]; ++k)
464 m_data.index(m_outerIndex[j]+k) = m_data.index(oldStart+k);
465 m_data.value(m_outerIndex[j]+k) = m_data.value(oldStart+k);
468 m_outerIndex[j+1] = m_outerIndex[j] + m_innerNonZeros[j];
469 oldStart = nextOldStart;
471 std::free(m_innerNonZeros);
473 m_data.resize(m_outerIndex[m_outerSize]);
480 if(m_innerNonZeros != 0)
482 m_innerNonZeros =
static_cast<Index*
>(std::malloc(m_outerSize *
sizeof(Index)));
483 for (
int i = 0; i < m_outerSize; i++)
485 m_innerNonZeros[i] = m_outerIndex[i+1] - m_outerIndex[i];
492 prune(default_prunning_func(reference,epsilon));
502 template<
typename KeepFunc>
503 void prune(
const KeepFunc& keep = KeepFunc())
510 for(Index j=0; j<m_outerSize; ++j)
512 Index previousStart = m_outerIndex[j];
514 Index end = m_outerIndex[j+1];
515 for(Index i=previousStart; i<end; ++i)
517 if(keep(IsRowMajor?j:m_data.index(i), IsRowMajor?m_data.index(i):j, m_data.value(i)))
519 m_data.value(k) = m_data.value(i);
520 m_data.index(k) = m_data.index(i);
525 m_outerIndex[m_outerSize] = k;
535 if (this->
rows() == rows && this->
cols() == cols)
return;
538 if(rows==0 || cols==0)
return resize(rows,cols);
540 Index innerChange = IsRowMajor ? cols - this->
cols() : rows - this->
rows();
541 Index outerChange = IsRowMajor ? rows - this->
rows() : cols - this->
cols();
542 Index newInnerSize = IsRowMajor ? cols :
rows;
548 Index *newInnerNonZeros =
static_cast<Index*
>(std::realloc(m_innerNonZeros, (m_outerSize + outerChange) *
sizeof(Index)));
549 if (!newInnerNonZeros) internal::throw_std_bad_alloc();
550 m_innerNonZeros = newInnerNonZeros;
552 for(Index i=m_outerSize; i<m_outerSize+outerChange; i++)
553 m_innerNonZeros[i] = 0;
555 else if (innerChange < 0)
558 m_innerNonZeros =
static_cast<Index*
>(std::malloc((m_outerSize+outerChange+1) *
sizeof(Index)));
559 if (!m_innerNonZeros) internal::throw_std_bad_alloc();
560 for(Index i = 0; i < m_outerSize; i++)
561 m_innerNonZeros[i] = m_outerIndex[i+1] - m_outerIndex[i];
565 if (m_innerNonZeros && innerChange < 0)
567 for(Index i = 0; i < m_outerSize + (std::min)(outerChange, Index(0)); i++)
569 Index &n = m_innerNonZeros[i];
570 Index start = m_outerIndex[i];
571 while (n > 0 && m_data.index(start+n-1) >= newInnerSize) --n;
575 m_innerSize = newInnerSize;
578 if (outerChange == 0)
581 Index *newOuterIndex =
static_cast<Index*
>(std::realloc(m_outerIndex, (m_outerSize + outerChange + 1) *
sizeof(Index)));
582 if (!newOuterIndex) internal::throw_std_bad_alloc();
583 m_outerIndex = newOuterIndex;
586 Index last = m_outerSize == 0 ? 0 : m_outerIndex[m_outerSize];
587 for(Index i=m_outerSize; i<m_outerSize+outerChange+1; i++)
588 m_outerIndex[i] = last;
590 m_outerSize += outerChange;
599 m_innerSize = IsRowMajor ? cols :
rows;
601 if (m_outerSize != outerSize || m_outerSize==0)
603 std::free(m_outerIndex);
604 m_outerIndex =
static_cast<Index*
>(std::malloc((outerSize + 1) *
sizeof(Index)));
605 if (!m_outerIndex) internal::throw_std_bad_alloc();
611 std::free(m_innerNonZeros);
614 memset(m_outerIndex, 0, (m_outerSize+1)*
sizeof(Index));
619 void resizeNonZeros(Index size)
630 : m_outerSize(-1), m_innerSize(0), m_outerIndex(0), m_innerNonZeros(0)
632 check_template_parameters();
638 : m_outerSize(0), m_innerSize(0), m_outerIndex(0), m_innerNonZeros(0)
640 check_template_parameters();
645 template<
typename OtherDerived>
647 : m_outerSize(0), m_innerSize(0), m_outerIndex(0), m_innerNonZeros(0)
649 EIGEN_STATIC_ASSERT((internal::is_same<Scalar, typename OtherDerived::Scalar>::value),
650 YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
651 check_template_parameters();
656 template<
typename OtherDerived,
unsigned int UpLo>
658 : m_outerSize(0), m_innerSize(0), m_outerIndex(0), m_innerNonZeros(0)
660 check_template_parameters();
666 :
Base(), m_outerSize(0), m_innerSize(0), m_outerIndex(0), m_innerNonZeros(0)
668 check_template_parameters();
673 template<
typename OtherDerived>
675 :
Base(), m_outerSize(0), m_innerSize(0), m_outerIndex(0), m_innerNonZeros(0)
677 check_template_parameters();
678 initAssignment(other);
687 std::swap(m_outerIndex, other.m_outerIndex);
688 std::swap(m_innerSize, other.m_innerSize);
689 std::swap(m_outerSize, other.m_outerSize);
690 std::swap(m_innerNonZeros, other.m_innerNonZeros);
691 m_data.swap(other.m_data);
697 eigen_assert(
rows() ==
cols() &&
"ONLY FOR SQUARED MATRICES");
698 this->m_data.resize(
rows());
705 if (other.isRValue())
707 swap(other.const_cast_derived());
709 else if(
this!=&other)
711 initAssignment(other);
714 memcpy(m_outerIndex, other.m_outerIndex, (m_outerSize+1)*
sizeof(Index));
715 m_data = other.m_data;
719 Base::operator=(other);
725 #ifndef EIGEN_PARSED_BY_DOXYGEN
726 template<
typename Lhs,
typename Rhs>
727 inline SparseMatrix& operator=(
const SparseSparseProduct<Lhs,Rhs>& product)
728 {
return Base::operator=(product); }
730 template<
typename OtherDerived>
731 inline SparseMatrix& operator=(
const ReturnByValue<OtherDerived>& other)
733 initAssignment(other);
734 return Base::operator=(other.derived());
737 template<
typename OtherDerived>
738 inline SparseMatrix& operator=(
const EigenBase<OtherDerived>& other)
739 {
return Base::operator=(other.derived()); }
742 template<
typename OtherDerived>
743 EIGEN_DONT_INLINE
SparseMatrix& operator=(
const SparseMatrixBase<OtherDerived>& other);
745 friend std::ostream & operator << (std::ostream & s,
const SparseMatrix& m)
748 s <<
"Nonzero entries:\n";
750 for (Index i=0; i<m.nonZeros(); ++i)
751 s <<
"(" << m.m_data.value(i) <<
"," << m.m_data.index(i) <<
") ";
753 for (Index i=0; i<m.outerSize(); ++i)
755 int p = m.m_outerIndex[i];
756 int pe = m.m_outerIndex[i]+m.m_innerNonZeros[i];
759 s <<
"(" << m.m_data.value(k) <<
"," << m.m_data.index(k) <<
") ";
760 for (; k<m.m_outerIndex[i+1]; ++k)
765 s <<
"Outer pointers:\n";
766 for (Index i=0; i<m.outerSize(); ++i)
767 s << m.m_outerIndex[i] <<
" ";
768 s <<
" $" << std::endl;
769 if(!m.isCompressed())
771 s <<
"Inner non zeros:\n";
772 for (Index i=0; i<m.outerSize(); ++i)
773 s << m.m_innerNonZeros[i] <<
" ";
774 s <<
" $" << std::endl;
778 s << static_cast<const SparseMatrixBase<SparseMatrix>&>(m);
785 std::free(m_outerIndex);
786 std::free(m_innerNonZeros);
789 #ifndef EIGEN_PARSED_BY_DOXYGEN
794 # ifdef EIGEN_SPARSEMATRIX_PLUGIN
795 # include EIGEN_SPARSEMATRIX_PLUGIN
800 template<
typename Other>
801 void initAssignment(
const Other& other)
803 resize(other.rows(), other.cols());
806 std::free(m_innerNonZeros);
813 EIGEN_DONT_INLINE Scalar& insertCompressed(Index
row, Index
col);
817 class SingletonVector
822 typedef Index value_type;
823 SingletonVector(Index i, Index v)
824 : m_index(i), m_value(v)
827 Index operator[](Index i)
const {
return i==m_index ? m_value : 0; }
832 EIGEN_DONT_INLINE Scalar& insertUncompressed(Index
row, Index
col);
837 EIGEN_STRONG_INLINE Scalar& insertBackUncompressed(Index
row, Index
col)
839 const Index outer = IsRowMajor ? row :
col;
840 const Index inner = IsRowMajor ? col :
row;
843 eigen_assert(m_innerNonZeros[outer]<=(m_outerIndex[outer+1] - m_outerIndex[outer]));
845 Index p = m_outerIndex[outer] + m_innerNonZeros[outer]++;
846 m_data.index(p) = inner;
847 return (m_data.value(p) = 0);
851 static void check_template_parameters()
853 EIGEN_STATIC_ASSERT(NumTraits<Index>::IsSigned,THE_INDEX_TYPE_MUST_BE_A_SIGNED_TYPE);
854 EIGEN_STATIC_ASSERT((Options&(
ColMajor|
RowMajor))==Options,INVALID_MATRIX_TEMPLATE_PARAMETERS);
857 struct default_prunning_func {
858 default_prunning_func(
const Scalar& ref,
const RealScalar& eps) : reference(ref), epsilon(eps) {}
859 inline bool operator() (
const Index&,
const Index&,
const Scalar& value)
const
861 return !internal::isMuchSmallerThan(value, reference, epsilon);
868 template<
typename Scalar,
int _Options,
typename _Index>
869 class SparseMatrix<Scalar,_Options,_Index>::InnerIterator
873 : m_values(mat.
valuePtr()), m_indices(mat.
innerIndexPtr()), m_outer(outer), m_id(mat.m_outerIndex[outer])
875 if(mat.isCompressed())
876 m_end = mat.m_outerIndex[outer+1];
878 m_end = m_id + mat.m_innerNonZeros[outer];
881 inline InnerIterator& operator++() { m_id++;
return *
this; }
883 inline const Scalar& value()
const {
return m_values[m_id]; }
884 inline Scalar& valueRef() {
return const_cast<Scalar&
>(m_values[m_id]); }
886 inline Index index()
const {
return m_indices[m_id]; }
887 inline Index outer()
const {
return m_outer; }
888 inline Index
row()
const {
return IsRowMajor ? m_outer : index(); }
889 inline Index
col()
const {
return IsRowMajor ? index() : m_outer; }
891 inline operator bool()
const {
return (m_id < m_end); }
894 const Scalar* m_values;
895 const Index* m_indices;
901 template<
typename Scalar,
int _Options,
typename _Index>
902 class SparseMatrix<Scalar,_Options,_Index>::ReverseInnerIterator
905 ReverseInnerIterator(
const SparseMatrix& mat, Index outer)
906 : m_values(mat.
valuePtr()), m_indices(mat.
innerIndexPtr()), m_outer(outer), m_start(mat.m_outerIndex[outer])
908 if(mat.isCompressed())
909 m_id = mat.m_outerIndex[outer+1];
911 m_id = m_start + mat.m_innerNonZeros[outer];
914 inline ReverseInnerIterator& operator--() { --m_id;
return *
this; }
916 inline const Scalar& value()
const {
return m_values[m_id-1]; }
917 inline Scalar& valueRef() {
return const_cast<Scalar&
>(m_values[m_id-1]); }
919 inline Index index()
const {
return m_indices[m_id-1]; }
920 inline Index outer()
const {
return m_outer; }
921 inline Index
row()
const {
return IsRowMajor ? m_outer : index(); }
922 inline Index
col()
const {
return IsRowMajor ? index() : m_outer; }
924 inline operator bool()
const {
return (m_id > m_start); }
927 const Scalar* m_values;
928 const Index* m_indices;
936 template<
typename InputIterator,
typename SparseMatrixType>
937 void set_from_triplets(
const InputIterator& begin,
const InputIterator& end, SparseMatrixType& mat,
int Options = 0)
939 EIGEN_UNUSED_VARIABLE(Options);
940 enum { IsRowMajor = SparseMatrixType::IsRowMajor };
941 typedef typename SparseMatrixType::Scalar Scalar;
942 SparseMatrix<Scalar,IsRowMajor?ColMajor:RowMajor> trMat(mat.rows(),mat.cols());
949 for(InputIterator it(begin); it!=end; ++it)
951 eigen_assert(it->row()>=0 && it->row()<mat.rows() && it->col()>=0 && it->col()<mat.cols());
952 wi(IsRowMajor ? it->col() : it->row())++;
957 for(InputIterator it(begin); it!=end; ++it)
958 trMat.insertBackUncompressed(it->row(),it->col()) = it->value();
961 trMat.sumupDuplicates();
1008 template<
typename Scalar,
int _Options,
typename _Index>
1009 template<
typename InputIterators>
1012 internal::set_from_triplets(begin, end, *
this);
1016 template<
typename Scalar,
int _Options,
typename _Index>
1019 eigen_assert(!isCompressed());
1025 for(
int j=0; j<outerSize(); ++j)
1027 Index start = count;
1028 Index oldEnd = m_outerIndex[j]+m_innerNonZeros[j];
1029 for(Index k=m_outerIndex[j]; k<oldEnd; ++k)
1031 Index i = m_data.index(k);
1035 m_data.value(wi(i)) += m_data.value(k);
1039 m_data.value(count) = m_data.value(k);
1040 m_data.index(count) = m_data.index(k);
1045 m_outerIndex[j] = start;
1047 m_outerIndex[m_outerSize] = count;
1050 std::free(m_innerNonZeros);
1051 m_innerNonZeros = 0;
1052 m_data.resize(m_outerIndex[m_outerSize]);
1055 template<
typename Scalar,
int _Options,
typename _Index>
1056 template<
typename OtherDerived>
1057 EIGEN_DONT_INLINE SparseMatrix<Scalar,_Options,_Index>& SparseMatrix<Scalar,_Options,_Index>::operator=(
const SparseMatrixBase<OtherDerived>& other)
1059 EIGEN_STATIC_ASSERT((internal::is_same<Scalar, typename OtherDerived::Scalar>::value),
1060 YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
1063 if (needToTranspose)
1069 typedef typename internal::nested<OtherDerived,2>::type OtherCopy;
1070 typedef typename internal::remove_all<OtherCopy>::type _OtherCopy;
1071 OtherCopy otherCopy(other.derived());
1073 SparseMatrix dest(other.rows(),other.cols());
1078 for (Index j=0; j<otherCopy.outerSize(); ++j)
1079 for (
typename _OtherCopy::InnerIterator it(otherCopy, j); it; ++it)
1080 ++dest.m_outerIndex[it.index()];
1084 VectorXi positions(dest.outerSize());
1085 for (Index j=0; j<dest.outerSize(); ++j)
1087 Index tmp = dest.m_outerIndex[j];
1088 dest.m_outerIndex[j] = count;
1089 positions[j] = count;
1092 dest.m_outerIndex[dest.outerSize()] = count;
1094 dest.m_data.
resize(count);
1096 for (Index j=0; j<otherCopy.outerSize(); ++j)
1098 for (
typename _OtherCopy::InnerIterator it(otherCopy, j); it; ++it)
1100 Index pos = positions[it.index()]++;
1101 dest.m_data.index(pos) = j;
1102 dest.m_data.value(pos) = it.value();
1110 if(other.isRValue())
1111 initAssignment(other.derived());
1113 return Base::operator=(other.derived());
1117 template<
typename _Scalar,
int _Options,
typename _Index>
1118 EIGEN_DONT_INLINE
typename SparseMatrix<_Scalar,_Options,_Index>::Scalar& SparseMatrix<_Scalar,_Options,_Index>::insertUncompressed(Index row, Index col)
1120 eigen_assert(!isCompressed());
1122 const Index outer = IsRowMajor ? row : col;
1123 const Index inner = IsRowMajor ? col : row;
1125 Index room = m_outerIndex[outer+1] - m_outerIndex[outer];
1126 Index innerNNZ = m_innerNonZeros[outer];
1130 reserve(SingletonVector(outer,std::max<Index>(2,innerNNZ)));
1133 Index startId = m_outerIndex[outer];
1134 Index p = startId + m_innerNonZeros[outer];
1135 while ( (p > startId) && (m_data.index(p-1) > inner) )
1137 m_data.index(p) = m_data.index(p-1);
1138 m_data.value(p) = m_data.value(p-1);
1141 eigen_assert((p<=startId || m_data.index(p-1)!=inner) &&
"you cannot insert an element that already exist, you must call coeffRef to this end");
1143 m_innerNonZeros[outer]++;
1145 m_data.index(p) = inner;
1146 return (m_data.value(p) = 0);
1149 template<
typename _Scalar,
int _Options,
typename _Index>
1150 EIGEN_DONT_INLINE
typename SparseMatrix<_Scalar,_Options,_Index>::Scalar& SparseMatrix<_Scalar,_Options,_Index>::insertCompressed(Index row, Index col)
1152 eigen_assert(isCompressed());
1154 const Index outer = IsRowMajor ? row : col;
1155 const Index inner = IsRowMajor ? col : row;
1157 Index previousOuter = outer;
1158 if (m_outerIndex[outer+1]==0)
1161 while (previousOuter>=0 && m_outerIndex[previousOuter]==0)
1163 m_outerIndex[previousOuter] =
static_cast<Index
>(m_data.size());
1166 m_outerIndex[outer+1] = m_outerIndex[outer];
1172 bool isLastVec = (!(previousOuter==-1 && m_data.size()!=0))
1173 && (size_t(m_outerIndex[outer+1]) == m_data.size());
1175 size_t startId = m_outerIndex[outer];
1177 size_t p = m_outerIndex[outer+1];
1178 ++m_outerIndex[outer+1];
1180 float reallocRatio = 1;
1181 if (m_data.allocatedSize()<=m_data.size())
1184 if (m_data.size()==0)
1193 float nnzEstimate = float(m_outerIndex[outer])*float(m_outerSize)/float(outer+1);
1194 reallocRatio = (nnzEstimate-float(m_data.size()))/float(m_data.size());
1198 reallocRatio = (std::min)((std::max)(reallocRatio,1.5f),8.f);
1201 m_data.resize(m_data.size()+1,reallocRatio);
1205 if (previousOuter==-1)
1209 for (Index k=0; k<=(outer+1); ++k)
1210 m_outerIndex[k] = 0;
1212 while(m_outerIndex[k]==0)
1213 m_outerIndex[k++] = 1;
1214 while (k<=m_outerSize && m_outerIndex[k]!=0)
1215 m_outerIndex[k++]++;
1218 k = m_outerIndex[k]-1;
1221 m_data.index(k) = m_data.index(k-1);
1222 m_data.value(k) = m_data.value(k-1);
1231 while (j<=m_outerSize && m_outerIndex[j]!=0)
1232 m_outerIndex[j++]++;
1235 Index k = m_outerIndex[j]-1;
1238 m_data.index(k) = m_data.index(k-1);
1239 m_data.value(k) = m_data.value(k-1);
1245 while ( (p > startId) && (m_data.index(p-1) > inner) )
1247 m_data.index(p) = m_data.index(p-1);
1248 m_data.value(p) = m_data.value(p-1);
1252 m_data.index(p) = inner;
1253 return (m_data.value(p) = 0);
1258 #endif // EIGEN_SPARSEMATRIX_H
Index rows() const
Definition: SparseMatrix.h:119
Index * outerIndexPtr()
Definition: SparseMatrix.h:153
Scalar coeff(Index row, Index col) const
Definition: SparseMatrix.h:171
Index cols() const
Definition: SparseMatrix.h:121
void resize(Index rows, Index cols)
Definition: SparseMatrix.h:596
const Scalar * valuePtr() const
Definition: SparseMatrix.h:131
void conservativeResize(Index rows, Index cols)
Definition: SparseMatrix.h:532
A versatible sparse matrix representation.
Definition: SparseMatrix.h:85
bool isCompressed() const
Definition: SparseMatrix.h:116
Definition: Constants.h:266
RowXpr row(Index i)
Definition: SparseMatrixBase.h:726
const Diagonal< const SparseMatrix > diagonal() const
Definition: SparseMatrix.h:626
void swap(SparseMatrix &other)
Definition: SparseMatrix.h:684
A matrix or vector expression mapping an existing array of data.
Definition: Map.h:104
SparseMatrix(Index rows, Index cols)
Definition: SparseMatrix.h:637
void makeCompressed()
Definition: SparseMatrix.h:449
Pseudo expression to manipulate a triangular sparse matrix as a selfadjoint matrix.
Definition: SparseSelfAdjointView.h:49
const Index * innerNonZeroPtr() const
Definition: SparseMatrix.h:158
Holds information about the various numeric (i.e. scalar) types allowed by Eigen. ...
Definition: NumTraits.h:88
const int Dynamic
Definition: Constants.h:21
const Index * outerIndexPtr() const
Definition: SparseMatrix.h:149
Scalar & coeffRef(Index row, Index col)
Definition: SparseMatrix.h:189
Definition: Constants.h:264
Definition: EigenBase.h:26
void setIdentity()
Definition: SparseMatrix.h:695
Index * innerNonZeroPtr()
Definition: SparseMatrix.h:162
Index nonZeros() const
Definition: SparseMatrix.h:246
Base class of any sparse matrices or sparse expressions.
Definition: SparseMatrixBase.h:26
Derived & derived()
Definition: EigenBase.h:34
const unsigned int LvalueBit
Definition: Constants.h:131
SparseMatrix(const SparseSelfAdjointView< OtherDerived, UpLo > &other)
Definition: SparseMatrix.h:657
SparseMatrix(const SparseMatrix &other)
Definition: SparseMatrix.h:665
Index size() const
Definition: SparseMatrixBase.h:155
Index * innerIndexPtr()
Definition: SparseMatrix.h:144
Scalar & insert(Index row, Index col)
Definition: SparseMatrix.h:220
Index outerSize() const
Definition: SparseMatrix.h:126
SparseMatrix(const ReturnByValue< OtherDerived > &other)
Copy constructor with in-place evaluation.
Definition: SparseMatrix.h:674
SparseMatrix()
Definition: SparseMatrix.h:629
~SparseMatrix()
Definition: SparseMatrix.h:783
void setFromTriplets(const InputIterators &begin, const InputIterators &end)
Definition: SparseMatrix.h:1010
SparseMatrix(const SparseMatrixBase< OtherDerived > &other)
Definition: SparseMatrix.h:646
void prune(const Scalar &reference, const RealScalar &epsilon=NumTraits< RealScalar >::dummy_precision())
Definition: SparseMatrix.h:490
const unsigned int RowMajorBit
Definition: Constants.h:53
Scalar * valuePtr()
Definition: SparseMatrix.h:135
Expression of a diagonal/subdiagonal/superdiagonal in a matrix.
Definition: Diagonal.h:64
void resize(Index nbRows, Index nbCols)
Definition: PlainObjectBase.h:232
Index innerSize() const
Definition: SparseMatrix.h:124
Matrix< int, Dynamic, 1 > VectorXi
Definition: Matrix.h:393
void reserve(Index reserveSize)
Definition: SparseMatrix.h:256
Sparse matrix.
Definition: MappedSparseMatrix.h:31
void uncompress()
Definition: SparseMatrix.h:478
void setZero()
Definition: SparseMatrix.h:237
const Index * innerIndexPtr() const
Definition: SparseMatrix.h:140
ColXpr col(Index i)
Definition: SparseMatrixBase.h:709
Derived & setZero(Index size)
Definition: CwiseNullaryOp.h:515
void prune(const KeepFunc &keep=KeepFunc())
Definition: SparseMatrix.h:503