xref: /aosp_15_r20/external/eigen/test/sparse_basic.cpp (revision bf2c37156dfe67e5dfebd6d394bad8b2ab5804d4)
1 // This file is part of Eigen, a lightweight C++ template library
2 // for linear algebra.
3 //
4 // Copyright (C) 2008-2011 Gael Guennebaud <[email protected]>
5 // Copyright (C) 2008 Daniel Gomez Ferro <[email protected]>
6 // Copyright (C) 2013 Désiré Nuentsa-Wakam <[email protected]>
7 //
8 // This Source Code Form is subject to the terms of the Mozilla
9 // Public License v. 2.0. If a copy of the MPL was not distributed
10 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
11 
12 #ifndef EIGEN_SPARSE_TEST_INCLUDED_FROM_SPARSE_EXTRA
13 static long g_realloc_count = 0;
14 #define EIGEN_SPARSE_COMPRESSED_STORAGE_REALLOCATE_PLUGIN g_realloc_count++;
15 
16 static long g_dense_op_sparse_count = 0;
17 #define EIGEN_SPARSE_ASSIGNMENT_FROM_DENSE_OP_SPARSE_PLUGIN g_dense_op_sparse_count++;
18 #define EIGEN_SPARSE_ASSIGNMENT_FROM_SPARSE_ADD_DENSE_PLUGIN g_dense_op_sparse_count+=10;
19 #define EIGEN_SPARSE_ASSIGNMENT_FROM_SPARSE_SUB_DENSE_PLUGIN g_dense_op_sparse_count+=20;
20 #endif
21 
22 #include "sparse.h"
23 
sparse_basic(const SparseMatrixType & ref)24 template<typename SparseMatrixType> void sparse_basic(const SparseMatrixType& ref)
25 {
26   typedef typename SparseMatrixType::StorageIndex StorageIndex;
27   typedef Matrix<StorageIndex,2,1> Vector2;
28 
29   const Index rows = ref.rows();
30   const Index cols = ref.cols();
31   //const Index inner = ref.innerSize();
32   //const Index outer = ref.outerSize();
33 
34   typedef typename SparseMatrixType::Scalar Scalar;
35   typedef typename SparseMatrixType::RealScalar RealScalar;
36   enum { Flags = SparseMatrixType::Flags };
37 
38   double density = (std::max)(8./(rows*cols), 0.01);
39   typedef Matrix<Scalar,Dynamic,Dynamic> DenseMatrix;
40   typedef Matrix<Scalar,Dynamic,1> DenseVector;
41   Scalar eps = 1e-6;
42 
43   Scalar s1 = internal::random<Scalar>();
44   {
45     SparseMatrixType m(rows, cols);
46     DenseMatrix refMat = DenseMatrix::Zero(rows, cols);
47     DenseVector vec1 = DenseVector::Random(rows);
48 
49     std::vector<Vector2> zeroCoords;
50     std::vector<Vector2> nonzeroCoords;
51     initSparse<Scalar>(density, refMat, m, 0, &zeroCoords, &nonzeroCoords);
52 
53     // test coeff and coeffRef
54     for (std::size_t i=0; i<zeroCoords.size(); ++i)
55     {
56       VERIFY_IS_MUCH_SMALLER_THAN( m.coeff(zeroCoords[i].x(),zeroCoords[i].y()), eps );
57       if(internal::is_same<SparseMatrixType,SparseMatrix<Scalar,Flags> >::value)
58         VERIFY_RAISES_ASSERT( m.coeffRef(zeroCoords[i].x(),zeroCoords[i].y()) = 5 );
59     }
60     VERIFY_IS_APPROX(m, refMat);
61 
62     if(!nonzeroCoords.empty()) {
63       m.coeffRef(nonzeroCoords[0].x(), nonzeroCoords[0].y()) = Scalar(5);
64       refMat.coeffRef(nonzeroCoords[0].x(), nonzeroCoords[0].y()) = Scalar(5);
65     }
66 
67     VERIFY_IS_APPROX(m, refMat);
68 
69       // test assertion
70       VERIFY_RAISES_ASSERT( m.coeffRef(-1,1) = 0 );
71       VERIFY_RAISES_ASSERT( m.coeffRef(0,m.cols()) = 0 );
72     }
73 
74     // test insert (inner random)
75     {
76       DenseMatrix m1(rows,cols);
77       m1.setZero();
78       SparseMatrixType m2(rows,cols);
79       bool call_reserve = internal::random<int>()%2;
80       Index nnz = internal::random<int>(1,int(rows)/2);
81       if(call_reserve)
82       {
83         if(internal::random<int>()%2)
84           m2.reserve(VectorXi::Constant(m2.outerSize(), int(nnz)));
85         else
86           m2.reserve(m2.outerSize() * nnz);
87       }
88       g_realloc_count = 0;
89       for (Index j=0; j<cols; ++j)
90       {
91         for (Index k=0; k<nnz; ++k)
92         {
93           Index i = internal::random<Index>(0,rows-1);
94           if (m1.coeff(i,j)==Scalar(0))
95             m2.insert(i,j) = m1(i,j) = internal::random<Scalar>();
96         }
97       }
98 
99       if(call_reserve && !SparseMatrixType::IsRowMajor)
100       {
101         VERIFY(g_realloc_count==0);
102       }
103 
104       m2.finalize();
105       VERIFY_IS_APPROX(m2,m1);
106     }
107 
108     // test insert (fully random)
109     {
110       DenseMatrix m1(rows,cols);
111       m1.setZero();
112       SparseMatrixType m2(rows,cols);
113       if(internal::random<int>()%2)
114         m2.reserve(VectorXi::Constant(m2.outerSize(), 2));
115       for (int k=0; k<rows*cols; ++k)
116       {
117         Index i = internal::random<Index>(0,rows-1);
118         Index j = internal::random<Index>(0,cols-1);
119         if ((m1.coeff(i,j)==Scalar(0)) && (internal::random<int>()%2))
120           m2.insert(i,j) = m1(i,j) = internal::random<Scalar>();
121         else
122         {
123           Scalar v = internal::random<Scalar>();
124           m2.coeffRef(i,j) += v;
125           m1(i,j) += v;
126         }
127       }
128       VERIFY_IS_APPROX(m2,m1);
129     }
130 
131     // test insert (un-compressed)
132     for(int mode=0;mode<4;++mode)
133     {
134       DenseMatrix m1(rows,cols);
135       m1.setZero();
136       SparseMatrixType m2(rows,cols);
137       VectorXi r(VectorXi::Constant(m2.outerSize(), ((mode%2)==0) ? int(m2.innerSize()) : std::max<int>(1,int(m2.innerSize())/8)));
138       m2.reserve(r);
139       for (Index k=0; k<rows*cols; ++k)
140       {
141         Index i = internal::random<Index>(0,rows-1);
142         Index j = internal::random<Index>(0,cols-1);
143         if (m1.coeff(i,j)==Scalar(0))
144           m2.insert(i,j) = m1(i,j) = internal::random<Scalar>();
145         if(mode==3)
146           m2.reserve(r);
147       }
148       if(internal::random<int>()%2)
149         m2.makeCompressed();
150       VERIFY_IS_APPROX(m2,m1);
151     }
152 
153   // test basic computations
154   {
155     DenseMatrix refM1 = DenseMatrix::Zero(rows, cols);
156     DenseMatrix refM2 = DenseMatrix::Zero(rows, cols);
157     DenseMatrix refM3 = DenseMatrix::Zero(rows, cols);
158     DenseMatrix refM4 = DenseMatrix::Zero(rows, cols);
159     SparseMatrixType m1(rows, cols);
160     SparseMatrixType m2(rows, cols);
161     SparseMatrixType m3(rows, cols);
162     SparseMatrixType m4(rows, cols);
163     initSparse<Scalar>(density, refM1, m1);
164     initSparse<Scalar>(density, refM2, m2);
165     initSparse<Scalar>(density, refM3, m3);
166     initSparse<Scalar>(density, refM4, m4);
167 
168     if(internal::random<bool>())
169       m1.makeCompressed();
170 
171     Index m1_nnz = m1.nonZeros();
172 
173     VERIFY_IS_APPROX(m1*s1, refM1*s1);
174     VERIFY_IS_APPROX(m1+m2, refM1+refM2);
175     VERIFY_IS_APPROX(m1+m2+m3, refM1+refM2+refM3);
176     VERIFY_IS_APPROX(m3.cwiseProduct(m1+m2), refM3.cwiseProduct(refM1+refM2));
177     VERIFY_IS_APPROX(m1*s1-m2, refM1*s1-refM2);
178     VERIFY_IS_APPROX(m4=m1/s1, refM1/s1);
179     VERIFY_IS_EQUAL(m4.nonZeros(), m1_nnz);
180 
181     if(SparseMatrixType::IsRowMajor)
182       VERIFY_IS_APPROX(m1.innerVector(0).dot(refM2.row(0)), refM1.row(0).dot(refM2.row(0)));
183     else
184       VERIFY_IS_APPROX(m1.innerVector(0).dot(refM2.col(0)), refM1.col(0).dot(refM2.col(0)));
185 
186     DenseVector rv = DenseVector::Random(m1.cols());
187     DenseVector cv = DenseVector::Random(m1.rows());
188     Index r = internal::random<Index>(0,m1.rows()-2);
189     Index c = internal::random<Index>(0,m1.cols()-1);
190     VERIFY_IS_APPROX(( m1.template block<1,Dynamic>(r,0,1,m1.cols()).dot(rv)) , refM1.row(r).dot(rv));
191     VERIFY_IS_APPROX(m1.row(r).dot(rv), refM1.row(r).dot(rv));
192     VERIFY_IS_APPROX(m1.col(c).dot(cv), refM1.col(c).dot(cv));
193 
194     VERIFY_IS_APPROX(m1.conjugate(), refM1.conjugate());
195     VERIFY_IS_APPROX(m1.real(), refM1.real());
196 
197     refM4.setRandom();
198     // sparse cwise* dense
199     VERIFY_IS_APPROX(m3.cwiseProduct(refM4), refM3.cwiseProduct(refM4));
200     // dense cwise* sparse
201     VERIFY_IS_APPROX(refM4.cwiseProduct(m3), refM4.cwiseProduct(refM3));
202 //     VERIFY_IS_APPROX(m3.cwise()/refM4, refM3.cwise()/refM4);
203 
204     // mixed sparse-dense
205     VERIFY_IS_APPROX(refM4 + m3, refM4 + refM3);
206     VERIFY_IS_APPROX(m3 + refM4, refM3 + refM4);
207     VERIFY_IS_APPROX(refM4 - m3, refM4 - refM3);
208     VERIFY_IS_APPROX(m3 - refM4, refM3 - refM4);
209     VERIFY_IS_APPROX((RealScalar(0.5)*refM4 + RealScalar(0.5)*m3).eval(), RealScalar(0.5)*refM4 + RealScalar(0.5)*refM3);
210     VERIFY_IS_APPROX((RealScalar(0.5)*refM4 + m3*RealScalar(0.5)).eval(), RealScalar(0.5)*refM4 + RealScalar(0.5)*refM3);
211     VERIFY_IS_APPROX((RealScalar(0.5)*refM4 + m3.cwiseProduct(m3)).eval(), RealScalar(0.5)*refM4 + refM3.cwiseProduct(refM3));
212 
213     VERIFY_IS_APPROX((RealScalar(0.5)*refM4 + RealScalar(0.5)*m3).eval(), RealScalar(0.5)*refM4 + RealScalar(0.5)*refM3);
214     VERIFY_IS_APPROX((RealScalar(0.5)*refM4 + m3*RealScalar(0.5)).eval(), RealScalar(0.5)*refM4 + RealScalar(0.5)*refM3);
215     VERIFY_IS_APPROX((RealScalar(0.5)*refM4 + (m3+m3)).eval(), RealScalar(0.5)*refM4 + (refM3+refM3));
216     VERIFY_IS_APPROX(((refM3+m3)+RealScalar(0.5)*m3).eval(), RealScalar(0.5)*refM3 + (refM3+refM3));
217     VERIFY_IS_APPROX((RealScalar(0.5)*refM4 + (refM3+m3)).eval(), RealScalar(0.5)*refM4 + (refM3+refM3));
218     VERIFY_IS_APPROX((RealScalar(0.5)*refM4 + (m3+refM3)).eval(), RealScalar(0.5)*refM4 + (refM3+refM3));
219 
220 
221     VERIFY_IS_APPROX(m1.sum(), refM1.sum());
222 
223     m4 = m1; refM4 = m4;
224 
225     VERIFY_IS_APPROX(m1*=s1, refM1*=s1);
226     VERIFY_IS_EQUAL(m1.nonZeros(), m1_nnz);
227     VERIFY_IS_APPROX(m1/=s1, refM1/=s1);
228     VERIFY_IS_EQUAL(m1.nonZeros(), m1_nnz);
229 
230     VERIFY_IS_APPROX(m1+=m2, refM1+=refM2);
231     VERIFY_IS_APPROX(m1-=m2, refM1-=refM2);
232 
233     refM3 = refM1;
234 
235     VERIFY_IS_APPROX(refM1+=m2, refM3+=refM2);
236     VERIFY_IS_APPROX(refM1-=m2, refM3-=refM2);
237 
238     g_dense_op_sparse_count=0; VERIFY_IS_APPROX(refM1 =m2+refM4, refM3 =refM2+refM4);  VERIFY_IS_EQUAL(g_dense_op_sparse_count,10);
239     g_dense_op_sparse_count=0; VERIFY_IS_APPROX(refM1+=m2+refM4, refM3+=refM2+refM4);  VERIFY_IS_EQUAL(g_dense_op_sparse_count,1);
240     g_dense_op_sparse_count=0; VERIFY_IS_APPROX(refM1-=m2+refM4, refM3-=refM2+refM4);  VERIFY_IS_EQUAL(g_dense_op_sparse_count,1);
241     g_dense_op_sparse_count=0; VERIFY_IS_APPROX(refM1 =refM4+m2, refM3 =refM2+refM4);  VERIFY_IS_EQUAL(g_dense_op_sparse_count,1);
242     g_dense_op_sparse_count=0; VERIFY_IS_APPROX(refM1+=refM4+m2, refM3+=refM2+refM4);  VERIFY_IS_EQUAL(g_dense_op_sparse_count,1);
243     g_dense_op_sparse_count=0; VERIFY_IS_APPROX(refM1-=refM4+m2, refM3-=refM2+refM4);  VERIFY_IS_EQUAL(g_dense_op_sparse_count,1);
244 
245     g_dense_op_sparse_count=0; VERIFY_IS_APPROX(refM1 =m2-refM4, refM3 =refM2-refM4);  VERIFY_IS_EQUAL(g_dense_op_sparse_count,20);
246     g_dense_op_sparse_count=0; VERIFY_IS_APPROX(refM1+=m2-refM4, refM3+=refM2-refM4);  VERIFY_IS_EQUAL(g_dense_op_sparse_count,1);
247     g_dense_op_sparse_count=0; VERIFY_IS_APPROX(refM1-=m2-refM4, refM3-=refM2-refM4);  VERIFY_IS_EQUAL(g_dense_op_sparse_count,1);
248     g_dense_op_sparse_count=0; VERIFY_IS_APPROX(refM1 =refM4-m2, refM3 =refM4-refM2);  VERIFY_IS_EQUAL(g_dense_op_sparse_count,1);
249     g_dense_op_sparse_count=0; VERIFY_IS_APPROX(refM1+=refM4-m2, refM3+=refM4-refM2);  VERIFY_IS_EQUAL(g_dense_op_sparse_count,1);
250     g_dense_op_sparse_count=0; VERIFY_IS_APPROX(refM1-=refM4-m2, refM3-=refM4-refM2);  VERIFY_IS_EQUAL(g_dense_op_sparse_count,1);
251     refM3 = m3;
252 
253     if (rows>=2 && cols>=2)
254     {
255       VERIFY_RAISES_ASSERT( m1 += m1.innerVector(0) );
256       VERIFY_RAISES_ASSERT( m1 -= m1.innerVector(0) );
257       VERIFY_RAISES_ASSERT( refM1 -= m1.innerVector(0) );
258       VERIFY_RAISES_ASSERT( refM1 += m1.innerVector(0) );
259     }
260     m1 = m4; refM1 = refM4;
261 
262     // test aliasing
263     VERIFY_IS_APPROX((m1 = -m1), (refM1 = -refM1));
264     VERIFY_IS_EQUAL(m1.nonZeros(), m1_nnz);
265     m1 = m4; refM1 = refM4;
266     VERIFY_IS_APPROX((m1 = m1.transpose()), (refM1 = refM1.transpose().eval()));
267     VERIFY_IS_EQUAL(m1.nonZeros(), m1_nnz);
268     m1 = m4; refM1 = refM4;
269     VERIFY_IS_APPROX((m1 = -m1.transpose()), (refM1 = -refM1.transpose().eval()));
270     VERIFY_IS_EQUAL(m1.nonZeros(), m1_nnz);
271     m1 = m4; refM1 = refM4;
272     VERIFY_IS_APPROX((m1 += -m1), (refM1 += -refM1));
273     VERIFY_IS_EQUAL(m1.nonZeros(), m1_nnz);
274     m1 = m4; refM1 = refM4;
275 
276     if(m1.isCompressed())
277     {
278       VERIFY_IS_APPROX(m1.coeffs().sum(), m1.sum());
279       m1.coeffs() += s1;
280       for(Index j = 0; j<m1.outerSize(); ++j)
281         for(typename SparseMatrixType::InnerIterator it(m1,j); it; ++it)
282           refM1(it.row(), it.col()) += s1;
283       VERIFY_IS_APPROX(m1, refM1);
284     }
285 
286     // and/or
287     {
288       typedef SparseMatrix<bool, SparseMatrixType::Options, typename SparseMatrixType::StorageIndex> SpBool;
289       SpBool mb1 = m1.real().template cast<bool>();
290       SpBool mb2 = m2.real().template cast<bool>();
291       VERIFY_IS_EQUAL(mb1.template cast<int>().sum(), refM1.real().template cast<bool>().count());
292       VERIFY_IS_EQUAL((mb1 && mb2).template cast<int>().sum(), (refM1.real().template cast<bool>() && refM2.real().template cast<bool>()).count());
293       VERIFY_IS_EQUAL((mb1 || mb2).template cast<int>().sum(), (refM1.real().template cast<bool>() || refM2.real().template cast<bool>()).count());
294       SpBool mb3 = mb1 && mb2;
295       if(mb1.coeffs().all() && mb2.coeffs().all())
296       {
297         VERIFY_IS_EQUAL(mb3.nonZeros(), (refM1.real().template cast<bool>() && refM2.real().template cast<bool>()).count());
298       }
299     }
300   }
301 
302   // test reverse iterators
303   {
304     DenseMatrix refMat2 = DenseMatrix::Zero(rows, cols);
305     SparseMatrixType m2(rows, cols);
306     initSparse<Scalar>(density, refMat2, m2);
307     std::vector<Scalar> ref_value(m2.innerSize());
308     std::vector<Index> ref_index(m2.innerSize());
309     if(internal::random<bool>())
310       m2.makeCompressed();
311     for(Index j = 0; j<m2.outerSize(); ++j)
312     {
313       Index count_forward = 0;
314 
315       for(typename SparseMatrixType::InnerIterator it(m2,j); it; ++it)
316       {
317         ref_value[ref_value.size()-1-count_forward] = it.value();
318         ref_index[ref_index.size()-1-count_forward] = it.index();
319         count_forward++;
320       }
321       Index count_reverse = 0;
322       for(typename SparseMatrixType::ReverseInnerIterator it(m2,j); it; --it)
323       {
324         VERIFY_IS_APPROX( std::abs(ref_value[ref_value.size()-count_forward+count_reverse])+1, std::abs(it.value())+1);
325         VERIFY_IS_EQUAL( ref_index[ref_index.size()-count_forward+count_reverse] , it.index());
326         count_reverse++;
327       }
328       VERIFY_IS_EQUAL(count_forward, count_reverse);
329     }
330   }
331 
332   // test transpose
333   {
334     DenseMatrix refMat2 = DenseMatrix::Zero(rows, cols);
335     SparseMatrixType m2(rows, cols);
336     initSparse<Scalar>(density, refMat2, m2);
337     VERIFY_IS_APPROX(m2.transpose().eval(), refMat2.transpose().eval());
338     VERIFY_IS_APPROX(m2.transpose(), refMat2.transpose());
339 
340     VERIFY_IS_APPROX(SparseMatrixType(m2.adjoint()), refMat2.adjoint());
341 
342     // check isApprox handles opposite storage order
343     typename Transpose<SparseMatrixType>::PlainObject m3(m2);
344     VERIFY(m2.isApprox(m3));
345   }
346 
347   // test prune
348   {
349     SparseMatrixType m2(rows, cols);
350     DenseMatrix refM2(rows, cols);
351     refM2.setZero();
352     int countFalseNonZero = 0;
353     int countTrueNonZero = 0;
354     m2.reserve(VectorXi::Constant(m2.outerSize(), int(m2.innerSize())));
355     for (Index j=0; j<m2.cols(); ++j)
356     {
357       for (Index i=0; i<m2.rows(); ++i)
358       {
359         float x = internal::random<float>(0,1);
360         if (x<0.1f)
361         {
362           // do nothing
363         }
364         else if (x<0.5f)
365         {
366           countFalseNonZero++;
367           m2.insert(i,j) = Scalar(0);
368         }
369         else
370         {
371           countTrueNonZero++;
372           m2.insert(i,j) = Scalar(1);
373           refM2(i,j) = Scalar(1);
374         }
375       }
376     }
377     if(internal::random<bool>())
378       m2.makeCompressed();
379     VERIFY(countFalseNonZero+countTrueNonZero == m2.nonZeros());
380     if(countTrueNonZero>0)
381       VERIFY_IS_APPROX(m2, refM2);
382     m2.prune(Scalar(1));
383     VERIFY(countTrueNonZero==m2.nonZeros());
384     VERIFY_IS_APPROX(m2, refM2);
385   }
386 
387   // test setFromTriplets
388   {
389     typedef Triplet<Scalar,StorageIndex> TripletType;
390     std::vector<TripletType> triplets;
391     Index ntriplets = rows*cols;
392     triplets.reserve(ntriplets);
393     DenseMatrix refMat_sum  = DenseMatrix::Zero(rows,cols);
394     DenseMatrix refMat_prod = DenseMatrix::Zero(rows,cols);
395     DenseMatrix refMat_last = DenseMatrix::Zero(rows,cols);
396 
397     for(Index i=0;i<ntriplets;++i)
398     {
399       StorageIndex r = internal::random<StorageIndex>(0,StorageIndex(rows-1));
400       StorageIndex c = internal::random<StorageIndex>(0,StorageIndex(cols-1));
401       Scalar v = internal::random<Scalar>();
402       triplets.push_back(TripletType(r,c,v));
403       refMat_sum(r,c) += v;
404       if(std::abs(refMat_prod(r,c))==0)
405         refMat_prod(r,c) = v;
406       else
407         refMat_prod(r,c) *= v;
408       refMat_last(r,c) = v;
409     }
410     SparseMatrixType m(rows,cols);
411     m.setFromTriplets(triplets.begin(), triplets.end());
412     VERIFY_IS_APPROX(m, refMat_sum);
413 
414     m.setFromTriplets(triplets.begin(), triplets.end(), std::multiplies<Scalar>());
415     VERIFY_IS_APPROX(m, refMat_prod);
416 #if (EIGEN_COMP_CXXVER >= 11)
417     m.setFromTriplets(triplets.begin(), triplets.end(), [] (Scalar,Scalar b) { return b; });
418     VERIFY_IS_APPROX(m, refMat_last);
419 #endif
420   }
421 
422   // test Map
423   {
424     DenseMatrix refMat2(rows, cols), refMat3(rows, cols);
425     SparseMatrixType m2(rows, cols), m3(rows, cols);
426     initSparse<Scalar>(density, refMat2, m2);
427     initSparse<Scalar>(density, refMat3, m3);
428     {
429       Map<SparseMatrixType> mapMat2(m2.rows(), m2.cols(), m2.nonZeros(), m2.outerIndexPtr(), m2.innerIndexPtr(), m2.valuePtr(), m2.innerNonZeroPtr());
430       Map<SparseMatrixType> mapMat3(m3.rows(), m3.cols(), m3.nonZeros(), m3.outerIndexPtr(), m3.innerIndexPtr(), m3.valuePtr(), m3.innerNonZeroPtr());
431       VERIFY_IS_APPROX(mapMat2+mapMat3, refMat2+refMat3);
432       VERIFY_IS_APPROX(mapMat2+mapMat3, refMat2+refMat3);
433     }
434     {
435       MappedSparseMatrix<Scalar,SparseMatrixType::Options,StorageIndex> mapMat2(m2.rows(), m2.cols(), m2.nonZeros(), m2.outerIndexPtr(), m2.innerIndexPtr(), m2.valuePtr(), m2.innerNonZeroPtr());
436       MappedSparseMatrix<Scalar,SparseMatrixType::Options,StorageIndex> mapMat3(m3.rows(), m3.cols(), m3.nonZeros(), m3.outerIndexPtr(), m3.innerIndexPtr(), m3.valuePtr(), m3.innerNonZeroPtr());
437       VERIFY_IS_APPROX(mapMat2+mapMat3, refMat2+refMat3);
438       VERIFY_IS_APPROX(mapMat2+mapMat3, refMat2+refMat3);
439     }
440 
441     Index i = internal::random<Index>(0,rows-1);
442     Index j = internal::random<Index>(0,cols-1);
443     m2.coeffRef(i,j) = 123;
444     if(internal::random<bool>())
445       m2.makeCompressed();
446     Map<SparseMatrixType> mapMat2(rows, cols, m2.nonZeros(), m2.outerIndexPtr(), m2.innerIndexPtr(), m2.valuePtr(),  m2.innerNonZeroPtr());
447     VERIFY_IS_EQUAL(m2.coeff(i,j),Scalar(123));
448     VERIFY_IS_EQUAL(mapMat2.coeff(i,j),Scalar(123));
449     mapMat2.coeffRef(i,j) = -123;
450     VERIFY_IS_EQUAL(m2.coeff(i,j),Scalar(-123));
451   }
452 
453   // test triangularView
454   {
455     DenseMatrix refMat2(rows, cols), refMat3(rows, cols);
456     SparseMatrixType m2(rows, cols), m3(rows, cols);
457     initSparse<Scalar>(density, refMat2, m2);
458     refMat3 = refMat2.template triangularView<Lower>();
459     m3 = m2.template triangularView<Lower>();
460     VERIFY_IS_APPROX(m3, refMat3);
461 
462     refMat3 = refMat2.template triangularView<Upper>();
463     m3 = m2.template triangularView<Upper>();
464     VERIFY_IS_APPROX(m3, refMat3);
465 
466     {
467       refMat3 = refMat2.template triangularView<UnitUpper>();
468       m3 = m2.template triangularView<UnitUpper>();
469       VERIFY_IS_APPROX(m3, refMat3);
470 
471       refMat3 = refMat2.template triangularView<UnitLower>();
472       m3 = m2.template triangularView<UnitLower>();
473       VERIFY_IS_APPROX(m3, refMat3);
474     }
475 
476     refMat3 = refMat2.template triangularView<StrictlyUpper>();
477     m3 = m2.template triangularView<StrictlyUpper>();
478     VERIFY_IS_APPROX(m3, refMat3);
479 
480     refMat3 = refMat2.template triangularView<StrictlyLower>();
481     m3 = m2.template triangularView<StrictlyLower>();
482     VERIFY_IS_APPROX(m3, refMat3);
483 
484     // check sparse-triangular to dense
485     refMat3 = m2.template triangularView<StrictlyUpper>();
486     VERIFY_IS_APPROX(refMat3, DenseMatrix(refMat2.template triangularView<StrictlyUpper>()));
487   }
488 
489   // test selfadjointView
490   if(!SparseMatrixType::IsRowMajor)
491   {
492     DenseMatrix refMat2(rows, rows), refMat3(rows, rows);
493     SparseMatrixType m2(rows, rows), m3(rows, rows);
494     initSparse<Scalar>(density, refMat2, m2);
495     refMat3 = refMat2.template selfadjointView<Lower>();
496     m3 = m2.template selfadjointView<Lower>();
497     VERIFY_IS_APPROX(m3, refMat3);
498 
499     refMat3 += refMat2.template selfadjointView<Lower>();
500     m3 += m2.template selfadjointView<Lower>();
501     VERIFY_IS_APPROX(m3, refMat3);
502 
503     refMat3 -= refMat2.template selfadjointView<Lower>();
504     m3 -= m2.template selfadjointView<Lower>();
505     VERIFY_IS_APPROX(m3, refMat3);
506 
507     // selfadjointView only works for square matrices:
508     SparseMatrixType m4(rows, rows+1);
509     VERIFY_RAISES_ASSERT(m4.template selfadjointView<Lower>());
510     VERIFY_RAISES_ASSERT(m4.template selfadjointView<Upper>());
511   }
512 
513   // test sparseView
514   {
515     DenseMatrix refMat2 = DenseMatrix::Zero(rows, rows);
516     SparseMatrixType m2(rows, rows);
517     initSparse<Scalar>(density, refMat2, m2);
518     VERIFY_IS_APPROX(m2.eval(), refMat2.sparseView().eval());
519 
520     // sparse view on expressions:
521     VERIFY_IS_APPROX((s1*m2).eval(), (s1*refMat2).sparseView().eval());
522     VERIFY_IS_APPROX((m2+m2).eval(), (refMat2+refMat2).sparseView().eval());
523     VERIFY_IS_APPROX((m2*m2).eval(), (refMat2.lazyProduct(refMat2)).sparseView().eval());
524     VERIFY_IS_APPROX((m2*m2).eval(), (refMat2*refMat2).sparseView().eval());
525   }
526 
527   // test diagonal
528   {
529     DenseMatrix refMat2 = DenseMatrix::Zero(rows, cols);
530     SparseMatrixType m2(rows, cols);
531     initSparse<Scalar>(density, refMat2, m2);
532     VERIFY_IS_APPROX(m2.diagonal(), refMat2.diagonal().eval());
533     DenseVector d = m2.diagonal();
534     VERIFY_IS_APPROX(d, refMat2.diagonal().eval());
535     d = m2.diagonal().array();
536     VERIFY_IS_APPROX(d, refMat2.diagonal().eval());
537     VERIFY_IS_APPROX(const_cast<const SparseMatrixType&>(m2).diagonal(), refMat2.diagonal().eval());
538 
539     initSparse<Scalar>(density, refMat2, m2, ForceNonZeroDiag);
540     m2.diagonal()      += refMat2.diagonal();
541     refMat2.diagonal() += refMat2.diagonal();
542     VERIFY_IS_APPROX(m2, refMat2);
543   }
544 
545   // test diagonal to sparse
546   {
547     DenseVector d = DenseVector::Random(rows);
548     DenseMatrix refMat2 = d.asDiagonal();
549     SparseMatrixType m2;
550     m2 = d.asDiagonal();
551     VERIFY_IS_APPROX(m2, refMat2);
552     SparseMatrixType m3(d.asDiagonal());
553     VERIFY_IS_APPROX(m3, refMat2);
554     refMat2 += d.asDiagonal();
555     m2 += d.asDiagonal();
556     VERIFY_IS_APPROX(m2, refMat2);
557     m2.setZero();       m2 += d.asDiagonal();
558     refMat2.setZero();  refMat2 += d.asDiagonal();
559     VERIFY_IS_APPROX(m2, refMat2);
560     m2.setZero();       m2 -= d.asDiagonal();
561     refMat2.setZero();  refMat2 -= d.asDiagonal();
562     VERIFY_IS_APPROX(m2, refMat2);
563 
564     initSparse<Scalar>(density, refMat2, m2);
565     m2.makeCompressed();
566     m2 += d.asDiagonal();
567     refMat2 += d.asDiagonal();
568     VERIFY_IS_APPROX(m2, refMat2);
569 
570     initSparse<Scalar>(density, refMat2, m2);
571     m2.makeCompressed();
572     VectorXi res(rows);
573     for(Index i=0; i<rows; ++i)
574       res(i) = internal::random<int>(0,3);
575     m2.reserve(res);
576     m2 -= d.asDiagonal();
577     refMat2 -= d.asDiagonal();
578     VERIFY_IS_APPROX(m2, refMat2);
579   }
580 
581   // test conservative resize
582   {
583       std::vector< std::pair<StorageIndex,StorageIndex> > inc;
584       if(rows > 3 && cols > 2)
585         inc.push_back(std::pair<StorageIndex,StorageIndex>(-3,-2));
586       inc.push_back(std::pair<StorageIndex,StorageIndex>(0,0));
587       inc.push_back(std::pair<StorageIndex,StorageIndex>(3,2));
588       inc.push_back(std::pair<StorageIndex,StorageIndex>(3,0));
589       inc.push_back(std::pair<StorageIndex,StorageIndex>(0,3));
590       inc.push_back(std::pair<StorageIndex,StorageIndex>(0,-1));
591       inc.push_back(std::pair<StorageIndex,StorageIndex>(-1,0));
592       inc.push_back(std::pair<StorageIndex,StorageIndex>(-1,-1));
593 
594       for(size_t i = 0; i< inc.size(); i++) {
595         StorageIndex incRows = inc[i].first;
596         StorageIndex incCols = inc[i].second;
597         SparseMatrixType m1(rows, cols);
598         DenseMatrix refMat1 = DenseMatrix::Zero(rows, cols);
599         initSparse<Scalar>(density, refMat1, m1);
600 
601         SparseMatrixType m2 = m1;
602         m2.makeCompressed();
603 
604         m1.conservativeResize(rows+incRows, cols+incCols);
605         m2.conservativeResize(rows+incRows, cols+incCols);
606         refMat1.conservativeResize(rows+incRows, cols+incCols);
607         if (incRows > 0) refMat1.bottomRows(incRows).setZero();
608         if (incCols > 0) refMat1.rightCols(incCols).setZero();
609 
610         VERIFY_IS_APPROX(m1, refMat1);
611         VERIFY_IS_APPROX(m2, refMat1);
612 
613         // Insert new values
614         if (incRows > 0)
615           m1.insert(m1.rows()-1, 0) = refMat1(refMat1.rows()-1, 0) = 1;
616         if (incCols > 0)
617           m1.insert(0, m1.cols()-1) = refMat1(0, refMat1.cols()-1) = 1;
618 
619         VERIFY_IS_APPROX(m1, refMat1);
620 
621 
622       }
623   }
624 
625   // test Identity matrix
626   {
627     DenseMatrix refMat1 = DenseMatrix::Identity(rows, rows);
628     SparseMatrixType m1(rows, rows);
629     m1.setIdentity();
630     VERIFY_IS_APPROX(m1, refMat1);
631     for(int k=0; k<rows*rows/4; ++k)
632     {
633       Index i = internal::random<Index>(0,rows-1);
634       Index j = internal::random<Index>(0,rows-1);
635       Scalar v = internal::random<Scalar>();
636       m1.coeffRef(i,j) = v;
637       refMat1.coeffRef(i,j) = v;
638       VERIFY_IS_APPROX(m1, refMat1);
639       if(internal::random<Index>(0,10)<2)
640         m1.makeCompressed();
641     }
642     m1.setIdentity();
643     refMat1.setIdentity();
644     VERIFY_IS_APPROX(m1, refMat1);
645   }
646 
647   // test array/vector of InnerIterator
648   {
649     typedef typename SparseMatrixType::InnerIterator IteratorType;
650 
651     DenseMatrix refMat2 = DenseMatrix::Zero(rows, cols);
652     SparseMatrixType m2(rows, cols);
653     initSparse<Scalar>(density, refMat2, m2);
654     IteratorType static_array[2];
655     static_array[0] = IteratorType(m2,0);
656     static_array[1] = IteratorType(m2,m2.outerSize()-1);
657     VERIFY( static_array[0] || m2.innerVector(static_array[0].outer()).nonZeros() == 0 );
658     VERIFY( static_array[1] || m2.innerVector(static_array[1].outer()).nonZeros() == 0 );
659     if(static_array[0] && static_array[1])
660     {
661       ++(static_array[1]);
662       static_array[1] = IteratorType(m2,0);
663       VERIFY( static_array[1] );
664       VERIFY( static_array[1].index() == static_array[0].index() );
665       VERIFY( static_array[1].outer() == static_array[0].outer() );
666       VERIFY( static_array[1].value() == static_array[0].value() );
667     }
668 
669     std::vector<IteratorType> iters(2);
670     iters[0] = IteratorType(m2,0);
671     iters[1] = IteratorType(m2,m2.outerSize()-1);
672   }
673 
674   // test reserve with empty rows/columns
675   {
676     SparseMatrixType m1(0,cols);
677     m1.reserve(ArrayXi::Constant(m1.outerSize(),1));
678     SparseMatrixType m2(rows,0);
679     m2.reserve(ArrayXi::Constant(m2.outerSize(),1));
680   }
681 }
682 
683 
684 template<typename SparseMatrixType>
big_sparse_triplet(Index rows,Index cols,double density)685 void big_sparse_triplet(Index rows, Index cols, double density) {
686   typedef typename SparseMatrixType::StorageIndex StorageIndex;
687   typedef typename SparseMatrixType::Scalar Scalar;
688   typedef Triplet<Scalar,Index> TripletType;
689   std::vector<TripletType> triplets;
690   double nelements = density * rows*cols;
691   VERIFY(nelements>=0 && nelements < static_cast<double>(NumTraits<StorageIndex>::highest()));
692   Index ntriplets = Index(nelements);
693   triplets.reserve(ntriplets);
694   Scalar sum = Scalar(0);
695   for(Index i=0;i<ntriplets;++i)
696   {
697     Index r = internal::random<Index>(0,rows-1);
698     Index c = internal::random<Index>(0,cols-1);
699     // use positive values to prevent numerical cancellation errors in sum
700     Scalar v = numext::abs(internal::random<Scalar>());
701     triplets.push_back(TripletType(r,c,v));
702     sum += v;
703   }
704   SparseMatrixType m(rows,cols);
705   m.setFromTriplets(triplets.begin(), triplets.end());
706   VERIFY(m.nonZeros() <= ntriplets);
707   VERIFY_IS_APPROX(sum, m.sum());
708 }
709 
710 template<int>
bug1105()711 void bug1105()
712 {
713   // Regression test for bug 1105
714   int n = Eigen::internal::random<int>(200,600);
715   SparseMatrix<std::complex<double>,0, long> mat(n, n);
716   std::complex<double> val;
717 
718   for(int i=0; i<n; ++i)
719   {
720     mat.coeffRef(i, i%(n/10)) = val;
721     VERIFY(mat.data().allocatedSize()<20*n);
722   }
723 }
724 
725 #ifndef EIGEN_SPARSE_TEST_INCLUDED_FROM_SPARSE_EXTRA
726 
EIGEN_DECLARE_TEST(sparse_basic)727 EIGEN_DECLARE_TEST(sparse_basic)
728 {
729   g_dense_op_sparse_count = 0;  // Suppresses compiler warning.
730   for(int i = 0; i < g_repeat; i++) {
731     int r = Eigen::internal::random<int>(1,200), c = Eigen::internal::random<int>(1,200);
732     if(Eigen::internal::random<int>(0,4) == 0) {
733       r = c; // check square matrices in 25% of tries
734     }
735     EIGEN_UNUSED_VARIABLE(r+c);
736     CALL_SUBTEST_1(( sparse_basic(SparseMatrix<double>(1, 1)) ));
737     CALL_SUBTEST_1(( sparse_basic(SparseMatrix<double>(8, 8)) ));
738     CALL_SUBTEST_2(( sparse_basic(SparseMatrix<std::complex<double>, ColMajor>(r, c)) ));
739     CALL_SUBTEST_2(( sparse_basic(SparseMatrix<std::complex<double>, RowMajor>(r, c)) ));
740     CALL_SUBTEST_1(( sparse_basic(SparseMatrix<double>(r, c)) ));
741     CALL_SUBTEST_5(( sparse_basic(SparseMatrix<double,ColMajor,long int>(r, c)) ));
742     CALL_SUBTEST_5(( sparse_basic(SparseMatrix<double,RowMajor,long int>(r, c)) ));
743 
744     r = Eigen::internal::random<int>(1,100);
745     c = Eigen::internal::random<int>(1,100);
746     if(Eigen::internal::random<int>(0,4) == 0) {
747       r = c; // check square matrices in 25% of tries
748     }
749 
750     CALL_SUBTEST_6(( sparse_basic(SparseMatrix<double,ColMajor,short int>(short(r), short(c))) ));
751     CALL_SUBTEST_6(( sparse_basic(SparseMatrix<double,RowMajor,short int>(short(r), short(c))) ));
752   }
753 
754   // Regression test for bug 900: (manually insert higher values here, if you have enough RAM):
755   CALL_SUBTEST_3((big_sparse_triplet<SparseMatrix<float, RowMajor, int> >(10000, 10000, 0.125)));
756   CALL_SUBTEST_4((big_sparse_triplet<SparseMatrix<double, ColMajor, long int> >(10000, 10000, 0.125)));
757 
758   CALL_SUBTEST_7( bug1105<0>() );
759 }
760 #endif
761