sparse_basic.cpp
Go to the documentation of this file.
1 // This file is part of Eigen, a lightweight C++ template library
2 // for linear algebra.
3 //
4 // Copyright (C) 2008-2011 Gael Guennebaud <gael.guennebaud@inria.fr>
5 // Copyright (C) 2008 Daniel Gomez Ferro <dgomezferro@gmail.com>
6 // Copyright (C) 2013 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
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 
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>
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>
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 
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
test_docs.d
d
Definition: test_docs.py:28
m
Matrix3f m
Definition: AngleAxis_mimic_euler.cpp:1
Eigen::SparseMatrixBase::real
EIGEN_DEVICE_FUNC RealReturnType real() const
Definition: SparseMatrixBase.h:101
DenseMatrix
Matrix< Scalar, Dynamic, Dynamic > DenseMatrix
Definition: BenchSparseUtil.h:23
Scalar
SCALAR Scalar
Definition: bench_gemm.cpp:46
VERIFY_RAISES_ASSERT
#define VERIFY_RAISES_ASSERT(a)
Definition: main.h:340
max
#define max(a, b)
Definition: datatypes.h:20
CALL_SUBTEST_6
#define CALL_SUBTEST_6(FUNC)
Definition: split_test_helper.h:34
CALL_SUBTEST_4
#define CALL_SUBTEST_4(FUNC)
Definition: split_test_helper.h:22
Eigen::ColMajor
Definition: Constants.h:319
y
Scalar * y
Definition: level1_cplx_impl.h:124
b
Scalar * b
Definition: benchVecAdd.cpp:17
cols
int cols
Definition: Tutorial_commainit_02.cpp:1
Eigen::SparseMatrix
A versatible sparse matrix representation.
Definition: SparseMatrix.h:96
Eigen::Map
A matrix or vector expression mapping an existing array of data.
Definition: Map.h:94
CALL_SUBTEST_3
#define CALL_SUBTEST_3(FUNC)
Definition: split_test_helper.h:16
Eigen::Transpose
Expression of the transpose of a matrix.
Definition: Transpose.h:52
m2
MatrixType m2(n_dims)
CALL_SUBTEST_7
#define CALL_SUBTEST_7(FUNC)
Definition: split_test_helper.h:40
n
int n
Definition: BiCGSTAB_simple.cpp:1
diagonal
void diagonal(const MatrixType &m)
Definition: diagonal.cpp:12
c
Scalar Scalar * c
Definition: benchVecAdd.cpp:17
g_dense_op_sparse_count
static long g_dense_op_sparse_count
Definition: sparse_basic.cpp:16
Eigen::NumTraits
Holds information about the various numeric (i.e. scalar) types allowed by Eigen. ...
Definition: NumTraits.h:232
big_sparse_triplet
void big_sparse_triplet(Index rows, Index cols, double density)
Definition: sparse_basic.cpp:685
res
cout<< "Here is the matrix m:"<< endl<< m<< endl;Matrix< ptrdiff_t, 3, 1 > res
Definition: PartialRedux_count.cpp:3
DenseVector
Matrix< Scalar, Dynamic, 1 > DenseVector
Definition: BenchSparseUtil.h:24
VERIFY_IS_APPROX
#define VERIFY_IS_APPROX(a, b)
Definition: integer_types.cpp:15
dot
Scalar EIGEN_BLAS_FUNC() dot(int *n, RealScalar *px, int *incx, RealScalar *py, int *incy)
Definition: level1_real_impl.h:49
VERIFY_IS_EQUAL
#define VERIFY_IS_EQUAL(a, b)
Definition: main.h:386
CALL_SUBTEST_1
#define CALL_SUBTEST_1(FUNC)
Definition: split_test_helper.h:4
m1
Matrix3d m1
Definition: IOFormat.cpp:2
test_callbacks.value
value
Definition: test_callbacks.py:148
Eigen::g_repeat
static int g_repeat
Definition: main.h:169
Eigen::Index
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:74
v
Array< int, Dynamic, 1 > v
Definition: Array_initializer_list_vector_cxx11.cpp:1
tree::f
Point2(* f)(const Point3 &, OptionalJacobian< 2, 3 >)
Definition: testExpression.cpp:218
e
Array< double, 1, 3 > e(1./3., 0.5, 2.)
RealScalar
NumTraits< Scalar >::Real RealScalar
Definition: bench_gemm.cpp:47
ref
Reference counting helper.
Definition: object.h:67
mat
MatrixXf mat
Definition: Tutorial_AdvancedInitialization_CommaTemporary.cpp:1
bug1105
void bug1105()
Definition: sparse_basic.cpp:711
VERIFY_IS_MUCH_SMALLER_THAN
#define VERIFY_IS_MUCH_SMALLER_THAN(a, b)
Definition: main.h:390
EIGEN_DECLARE_TEST
EIGEN_DECLARE_TEST(sparse_basic)
Definition: sparse_basic.cpp:727
Eigen::Triplet
A small structure to hold a non zero as a triplet (i,j,value).
Definition: SparseUtil.h:162
vec1
RowVectorXd vec1(3)
gtsam::Vector2
Eigen::Vector2d Vector2
Definition: Vector.h:42
CALL_SUBTEST_5
#define CALL_SUBTEST_5(FUNC)
Definition: split_test_helper.h:28
VERIFY
#define VERIFY(a)
Definition: main.h:380
triangularView< Lower >
A triangularView< Lower >().adjoint().solveInPlace(B)
Eigen::RowMajor
Definition: Constants.h:321
rows
int rows
Definition: Tutorial_commainit_02.cpp:1
sparse_basic
void sparse_basic(const SparseMatrixType &ref)
Definition: sparse_basic.cpp:24
CALL_SUBTEST_2
#define CALL_SUBTEST_2(FUNC)
Definition: split_test_helper.h:10
eval
internal::nested_eval< T, 1 >::type eval(const T &xpr)
Definition: sparse_permutations.cpp:38
g_realloc_count
static long g_realloc_count
Definition: sparse_basic.cpp:13
mode
static const DiscreteKey mode(modeKey, 2)
Eigen::Matrix
The matrix class, also used for vectors and row-vectors.
Definition: 3rdparty/Eigen/Eigen/src/Core/Matrix.h:178
x
set noclip points set clip one set noclip two set bar set border lt lw set xdata set ydata set zdata set x2data set y2data set boxwidth set dummy x
Definition: gnuplot_common_settings.hh:12
abs
#define abs(x)
Definition: datatypes.h:17
i
int i
Definition: BiCGSTAB_step_by_step.cpp:9
j
std::ptrdiff_t j
Definition: tut_arithmetic_redux_minmax.cpp:2
EIGEN_UNUSED_VARIABLE
#define EIGEN_UNUSED_VARIABLE(var)
Definition: Macros.h:1076

gtsam
Author(s):
autogenerated on Tue Jul 4 2023 02:35:53