1 // This file is part of Eigen, a lightweight C++ template library
2 // for linear algebra.
3 //
4 // Copyright (C) 2008-2010 Gael Guennebaud <[email protected]>
5 //
6 // This Source Code Form is subject to the terms of the Mozilla
7 // Public License v. 2.0. If a copy of the MPL was not distributed
8 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
9
10
11 // import basic and product tests for deprecated DynamicSparseMatrix
12 #if 0 // sparse_basic(DynamicSparseMatrix) does not compile at all -> disabled
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
21 #define EIGEN_SPARSE_TEST_INCLUDED_FROM_SPARSE_EXTRA 1
22 #endif
23
24 #define EIGEN_NO_DEPRECATED_WARNING
25 // Disable counting of temporaries, since sparse_product(DynamicSparseMatrix)
26 // has an extra copy-assignment.
27 #define EIGEN_SPARSE_PRODUCT_IGNORE_TEMPORARY_COUNT
28 #include "sparse_product.cpp"
29
30 #if 0 // sparse_basic(DynamicSparseMatrix) does not compile at all -> disabled
31 #include "sparse_basic.cpp"
32 #endif
33
34 #if EIGEN_HAS_CXX11
35
36 #ifdef min
37 #undef min
38 #endif
39
40 #ifdef max
41 #undef max
42 #endif
43
44 #include <unordered_map>
45 #define EIGEN_UNORDERED_MAP_SUPPORT
46
47 #endif
48
49
50 #include <Eigen/SparseExtra>
51
52 template<typename SetterType,typename DenseType, typename Scalar, int Options>
test_random_setter(SparseMatrix<Scalar,Options> & sm,const DenseType & ref,const std::vector<Vector2i> & nonzeroCoords)53 bool test_random_setter(SparseMatrix<Scalar,Options>& sm, const DenseType& ref, const std::vector<Vector2i>& nonzeroCoords)
54 {
55 {
56 sm.setZero();
57 SetterType w(sm);
58 std::vector<Vector2i> remaining = nonzeroCoords;
59 while(!remaining.empty())
60 {
61 int i = internal::random<int>(0,static_cast<int>(remaining.size())-1);
62 w(remaining[i].x(),remaining[i].y()) = ref.coeff(remaining[i].x(),remaining[i].y());
63 remaining[i] = remaining.back();
64 remaining.pop_back();
65 }
66 }
67 return sm.isApprox(ref);
68 }
69
70 template<typename SetterType,typename DenseType, typename T>
test_random_setter(DynamicSparseMatrix<T> & sm,const DenseType & ref,const std::vector<Vector2i> & nonzeroCoords)71 bool test_random_setter(DynamicSparseMatrix<T>& sm, const DenseType& ref, const std::vector<Vector2i>& nonzeroCoords)
72 {
73 sm.setZero();
74 std::vector<Vector2i> remaining = nonzeroCoords;
75 while(!remaining.empty())
76 {
77 int i = internal::random<int>(0,static_cast<int>(remaining.size())-1);
78 sm.coeffRef(remaining[i].x(),remaining[i].y()) = ref.coeff(remaining[i].x(),remaining[i].y());
79 remaining[i] = remaining.back();
80 remaining.pop_back();
81 }
82 return sm.isApprox(ref);
83 }
84
sparse_extra(const SparseMatrixType & ref)85 template<typename SparseMatrixType> void sparse_extra(const SparseMatrixType& ref)
86 {
87 const Index rows = ref.rows();
88 const Index cols = ref.cols();
89 typedef typename SparseMatrixType::Scalar Scalar;
90 enum { Flags = SparseMatrixType::Flags };
91
92 double density = (std::max)(8./(rows*cols), 0.01);
93 typedef Matrix<Scalar,Dynamic,Dynamic> DenseMatrix;
94 typedef Matrix<Scalar,Dynamic,1> DenseVector;
95 Scalar eps = 1e-6;
96
97 SparseMatrixType m(rows, cols);
98 DenseMatrix refMat = DenseMatrix::Zero(rows, cols);
99 DenseVector vec1 = DenseVector::Random(rows);
100
101 std::vector<Vector2i> zeroCoords;
102 std::vector<Vector2i> nonzeroCoords;
103 initSparse<Scalar>(density, refMat, m, 0, &zeroCoords, &nonzeroCoords);
104
105 if (zeroCoords.size()==0 || nonzeroCoords.size()==0)
106 return;
107
108 // test coeff and coeffRef
109 for (int i=0; i<(int)zeroCoords.size(); ++i)
110 {
111 VERIFY_IS_MUCH_SMALLER_THAN( m.coeff(zeroCoords[i].x(),zeroCoords[i].y()), eps );
112 if(internal::is_same<SparseMatrixType,SparseMatrix<Scalar,Flags> >::value)
113 VERIFY_RAISES_ASSERT( m.coeffRef(zeroCoords[0].x(),zeroCoords[0].y()) = 5 );
114 }
115 VERIFY_IS_APPROX(m, refMat);
116
117 m.coeffRef(nonzeroCoords[0].x(), nonzeroCoords[0].y()) = Scalar(5);
118 refMat.coeffRef(nonzeroCoords[0].x(), nonzeroCoords[0].y()) = Scalar(5);
119
120 VERIFY_IS_APPROX(m, refMat);
121
122 // random setter
123 // {
124 // m.setZero();
125 // VERIFY_IS_NOT_APPROX(m, refMat);
126 // SparseSetter<SparseMatrixType, RandomAccessPattern> w(m);
127 // std::vector<Vector2i> remaining = nonzeroCoords;
128 // while(!remaining.empty())
129 // {
130 // int i = internal::random<int>(0,remaining.size()-1);
131 // w->coeffRef(remaining[i].x(),remaining[i].y()) = refMat.coeff(remaining[i].x(),remaining[i].y());
132 // remaining[i] = remaining.back();
133 // remaining.pop_back();
134 // }
135 // }
136 // VERIFY_IS_APPROX(m, refMat);
137
138 VERIFY(( test_random_setter<RandomSetter<SparseMatrixType, StdMapTraits> >(m,refMat,nonzeroCoords) ));
139 #ifdef EIGEN_UNORDERED_MAP_SUPPORT
140 VERIFY(( test_random_setter<RandomSetter<SparseMatrixType, StdUnorderedMapTraits> >(m,refMat,nonzeroCoords) ));
141 #endif
142 #ifdef EIGEN_GOOGLEHASH_SUPPORT
143 VERIFY(( test_random_setter<RandomSetter<SparseMatrixType, GoogleDenseHashMapTraits> >(m,refMat,nonzeroCoords) ));
144 VERIFY(( test_random_setter<RandomSetter<SparseMatrixType, GoogleSparseHashMapTraits> >(m,refMat,nonzeroCoords) ));
145 #endif
146
147
148 // test RandomSetter
149 /*{
150 SparseMatrixType m1(rows,cols), m2(rows,cols);
151 DenseMatrix refM1 = DenseMatrix::Zero(rows, rows);
152 initSparse<Scalar>(density, refM1, m1);
153 {
154 Eigen::RandomSetter<SparseMatrixType > setter(m2);
155 for (int j=0; j<m1.outerSize(); ++j)
156 for (typename SparseMatrixType::InnerIterator i(m1,j); i; ++i)
157 setter(i.index(), j) = i.value();
158 }
159 VERIFY_IS_APPROX(m1, m2);
160 }*/
161
162
163 }
164
165
166 template<typename SparseMatrixType>
check_marketio()167 void check_marketio()
168 {
169 typedef Matrix<typename SparseMatrixType::Scalar, Dynamic, Dynamic> DenseMatrix;
170 Index rows = internal::random<Index>(1,100);
171 Index cols = internal::random<Index>(1,100);
172 SparseMatrixType m1, m2;
173 m1 = DenseMatrix::Random(rows, cols).sparseView();
174 saveMarket(m1, "sparse_extra.mtx");
175 loadMarket(m2, "sparse_extra.mtx");
176 VERIFY_IS_EQUAL(DenseMatrix(m1),DenseMatrix(m2));
177 }
178
179 template<typename VectorType>
check_marketio_vector()180 void check_marketio_vector()
181 {
182 Index size = internal::random<Index>(1,100);
183 VectorType v1, v2;
184 v1 = VectorType::Random(size);
185 saveMarketVector(v1, "vector_extra.mtx");
186 loadMarketVector(v2, "vector_extra.mtx");
187 VERIFY_IS_EQUAL(v1,v2);
188 }
189
EIGEN_DECLARE_TEST(sparse_extra)190 EIGEN_DECLARE_TEST(sparse_extra)
191 {
192 for(int i = 0; i < g_repeat; i++) {
193 int s = Eigen::internal::random<int>(1,50);
194 CALL_SUBTEST_1( sparse_extra(SparseMatrix<double>(8, 8)) );
195 CALL_SUBTEST_2( sparse_extra(SparseMatrix<std::complex<double> >(s, s)) );
196 CALL_SUBTEST_1( sparse_extra(SparseMatrix<double>(s, s)) );
197
198 CALL_SUBTEST_3( sparse_extra(DynamicSparseMatrix<double>(s, s)) );
199 // CALL_SUBTEST_3(( sparse_basic(DynamicSparseMatrix<double>(s, s)) ));
200 // CALL_SUBTEST_3(( sparse_basic(DynamicSparseMatrix<double,ColMajor,long int>(s, s)) ));
201
202 CALL_SUBTEST_3( (sparse_product<DynamicSparseMatrix<float, ColMajor> >()) );
203 CALL_SUBTEST_3( (sparse_product<DynamicSparseMatrix<float, RowMajor> >()) );
204
205 CALL_SUBTEST_4( (check_marketio<SparseMatrix<float,ColMajor,int> >()) );
206 CALL_SUBTEST_4( (check_marketio<SparseMatrix<double,ColMajor,int> >()) );
207 CALL_SUBTEST_4( (check_marketio<SparseMatrix<std::complex<float>,ColMajor,int> >()) );
208 CALL_SUBTEST_4( (check_marketio<SparseMatrix<std::complex<double>,ColMajor,int> >()) );
209 CALL_SUBTEST_4( (check_marketio<SparseMatrix<float,ColMajor,long int> >()) );
210 CALL_SUBTEST_4( (check_marketio<SparseMatrix<double,ColMajor,long int> >()) );
211 CALL_SUBTEST_4( (check_marketio<SparseMatrix<std::complex<float>,ColMajor,long int> >()) );
212 CALL_SUBTEST_4( (check_marketio<SparseMatrix<std::complex<double>,ColMajor,long int> >()) );
213
214
215 CALL_SUBTEST_5( (check_marketio_vector<Matrix<float,1,Dynamic> >()) );
216 CALL_SUBTEST_5( (check_marketio_vector<Matrix<double,1,Dynamic> >()) );
217 CALL_SUBTEST_5( (check_marketio_vector<Matrix<std::complex<float>,1,Dynamic> >()) );
218 CALL_SUBTEST_5( (check_marketio_vector<Matrix<std::complex<double>,1,Dynamic> >()) );
219 CALL_SUBTEST_5( (check_marketio_vector<Matrix<float,Dynamic,1> >()) );
220 CALL_SUBTEST_5( (check_marketio_vector<Matrix<double,Dynamic,1> >()) );
221 CALL_SUBTEST_5( (check_marketio_vector<Matrix<std::complex<float>,Dynamic,1> >()) );
222 CALL_SUBTEST_5( (check_marketio_vector<Matrix<std::complex<double>,Dynamic,1> >()) );
223
224 TEST_SET_BUT_UNUSED_VARIABLE(s);
225 }
226 }
227