1 // This file is part of Eigen, a lightweight C++ template library
2 // for linear algebra.
3 //
4 // Copyright (C) 2018-2019 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 #include "main.h"
11 #include <iterator>
12 #include <numeric>
13
14 template< class Iterator >
15 std::reverse_iterator<Iterator>
make_reverse_iterator(Iterator i)16 make_reverse_iterator( Iterator i )
17 {
18 return std::reverse_iterator<Iterator>(i);
19 }
20
21 #if !EIGEN_HAS_CXX11
22 template<class ForwardIt>
is_sorted_until(ForwardIt firstIt,ForwardIt lastIt)23 ForwardIt is_sorted_until(ForwardIt firstIt, ForwardIt lastIt)
24 {
25 if (firstIt != lastIt) {
26 ForwardIt next = firstIt;
27 while (++next != lastIt) {
28 if (*next < *firstIt)
29 return next;
30 firstIt = next;
31 }
32 }
33 return lastIt;
34 }
35 template<class ForwardIt>
is_sorted(ForwardIt firstIt,ForwardIt lastIt)36 bool is_sorted(ForwardIt firstIt, ForwardIt lastIt)
37 {
38 return ::is_sorted_until(firstIt, lastIt) == lastIt;
39 }
40 #else
41 using std::is_sorted;
42 #endif
43
44 template<typename XprType>
is_pointer_based_stl_iterator(const internal::pointer_based_stl_iterator<XprType> &)45 bool is_pointer_based_stl_iterator(const internal::pointer_based_stl_iterator<XprType> &) { return true; }
46
47 template<typename XprType>
is_generic_randaccess_stl_iterator(const internal::generic_randaccess_stl_iterator<XprType> &)48 bool is_generic_randaccess_stl_iterator(const internal::generic_randaccess_stl_iterator<XprType> &) { return true; }
49
50 template<typename Iter>
is_default_constructible_and_assignable(const Iter & it)51 bool is_default_constructible_and_assignable(const Iter& it)
52 {
53 #if EIGEN_HAS_CXX11
54 VERIFY(std::is_default_constructible<Iter>::value);
55 VERIFY(std::is_nothrow_default_constructible<Iter>::value);
56 #endif
57 Iter it2;
58 it2 = it;
59 return (it==it2);
60 }
61
62 template<typename Xpr>
check_begin_end_for_loop(Xpr xpr)63 void check_begin_end_for_loop(Xpr xpr)
64 {
65 const Xpr& cxpr(xpr);
66 Index i = 0;
67
68 i = 0;
69 for(typename Xpr::iterator it = xpr.begin(); it!=xpr.end(); ++it) { VERIFY_IS_EQUAL(*it,xpr[i++]); }
70
71 i = 0;
72 for(typename Xpr::const_iterator it = xpr.cbegin(); it!=xpr.cend(); ++it) { VERIFY_IS_EQUAL(*it,xpr[i++]); }
73
74 i = 0;
75 for(typename Xpr::const_iterator it = cxpr.begin(); it!=cxpr.end(); ++it) { VERIFY_IS_EQUAL(*it,xpr[i++]); }
76
77 i = 0;
78 for(typename Xpr::const_iterator it = xpr.begin(); it!=xpr.end(); ++it) { VERIFY_IS_EQUAL(*it,xpr[i++]); }
79
80 {
81 // simple API check
82 typename Xpr::const_iterator cit = xpr.begin();
83 cit = xpr.cbegin();
84
85 #if EIGEN_HAS_CXX11
86 auto tmp1 = xpr.begin();
87 VERIFY(tmp1==xpr.begin());
88 auto tmp2 = xpr.cbegin();
89 VERIFY(tmp2==xpr.cbegin());
90 #endif
91 }
92
93 VERIFY( xpr.end() -xpr.begin() == xpr.size() );
94 VERIFY( xpr.cend()-xpr.begin() == xpr.size() );
95 VERIFY( xpr.end() -xpr.cbegin() == xpr.size() );
96 VERIFY( xpr.cend()-xpr.cbegin() == xpr.size() );
97
98 if(xpr.size()>0) {
99 VERIFY(xpr.begin() != xpr.end());
100 VERIFY(xpr.begin() < xpr.end());
101 VERIFY(xpr.begin() <= xpr.end());
102 VERIFY(!(xpr.begin() == xpr.end()));
103 VERIFY(!(xpr.begin() > xpr.end()));
104 VERIFY(!(xpr.begin() >= xpr.end()));
105
106 VERIFY(xpr.cbegin() != xpr.end());
107 VERIFY(xpr.cbegin() < xpr.end());
108 VERIFY(xpr.cbegin() <= xpr.end());
109 VERIFY(!(xpr.cbegin() == xpr.end()));
110 VERIFY(!(xpr.cbegin() > xpr.end()));
111 VERIFY(!(xpr.cbegin() >= xpr.end()));
112
113 VERIFY(xpr.begin() != xpr.cend());
114 VERIFY(xpr.begin() < xpr.cend());
115 VERIFY(xpr.begin() <= xpr.cend());
116 VERIFY(!(xpr.begin() == xpr.cend()));
117 VERIFY(!(xpr.begin() > xpr.cend()));
118 VERIFY(!(xpr.begin() >= xpr.cend()));
119 }
120 }
121
122 template<typename Scalar, int Rows, int Cols>
test_stl_iterators(int rows=Rows,int cols=Cols)123 void test_stl_iterators(int rows=Rows, int cols=Cols)
124 {
125 typedef Matrix<Scalar,Rows,1> VectorType;
126 #if EIGEN_HAS_CXX11
127 typedef Matrix<Scalar,1,Cols> RowVectorType;
128 #endif
129 typedef Matrix<Scalar,Rows,Cols,ColMajor> ColMatrixType;
130 typedef Matrix<Scalar,Rows,Cols,RowMajor> RowMatrixType;
131 VectorType v = VectorType::Random(rows);
132 const VectorType& cv(v);
133 ColMatrixType A = ColMatrixType::Random(rows,cols);
134 const ColMatrixType& cA(A);
135 RowMatrixType B = RowMatrixType::Random(rows,cols);
136
137 Index i, j;
138
139 // Verify that iterators are default constructible (See bug #1900)
140 {
141 VERIFY( is_default_constructible_and_assignable(v.begin()));
142 VERIFY( is_default_constructible_and_assignable(v.end()));
143 VERIFY( is_default_constructible_and_assignable(cv.begin()));
144 VERIFY( is_default_constructible_and_assignable(cv.end()));
145
146 VERIFY( is_default_constructible_and_assignable(A.row(0).begin()));
147 VERIFY( is_default_constructible_and_assignable(A.row(0).end()));
148 VERIFY( is_default_constructible_and_assignable(cA.row(0).begin()));
149 VERIFY( is_default_constructible_and_assignable(cA.row(0).end()));
150
151 VERIFY( is_default_constructible_and_assignable(B.row(0).begin()));
152 VERIFY( is_default_constructible_and_assignable(B.row(0).end()));
153 }
154
155 // Check we got a fast pointer-based iterator when expected
156 {
157 VERIFY( is_pointer_based_stl_iterator(v.begin()) );
158 VERIFY( is_pointer_based_stl_iterator(v.end()) );
159 VERIFY( is_pointer_based_stl_iterator(cv.begin()) );
160 VERIFY( is_pointer_based_stl_iterator(cv.end()) );
161
162 j = internal::random<Index>(0,A.cols()-1);
163 VERIFY( is_pointer_based_stl_iterator(A.col(j).begin()) );
164 VERIFY( is_pointer_based_stl_iterator(A.col(j).end()) );
165 VERIFY( is_pointer_based_stl_iterator(cA.col(j).begin()) );
166 VERIFY( is_pointer_based_stl_iterator(cA.col(j).end()) );
167
168 i = internal::random<Index>(0,A.rows()-1);
169 VERIFY( is_pointer_based_stl_iterator(A.row(i).begin()) );
170 VERIFY( is_pointer_based_stl_iterator(A.row(i).end()) );
171 VERIFY( is_pointer_based_stl_iterator(cA.row(i).begin()) );
172 VERIFY( is_pointer_based_stl_iterator(cA.row(i).end()) );
173
174 VERIFY( is_pointer_based_stl_iterator(A.reshaped().begin()) );
175 VERIFY( is_pointer_based_stl_iterator(A.reshaped().end()) );
176 VERIFY( is_pointer_based_stl_iterator(cA.reshaped().begin()) );
177 VERIFY( is_pointer_based_stl_iterator(cA.reshaped().end()) );
178
179 VERIFY( is_pointer_based_stl_iterator(B.template reshaped<AutoOrder>().begin()) );
180 VERIFY( is_pointer_based_stl_iterator(B.template reshaped<AutoOrder>().end()) );
181
182 VERIFY( is_generic_randaccess_stl_iterator(A.template reshaped<RowMajor>().begin()) );
183 VERIFY( is_generic_randaccess_stl_iterator(A.template reshaped<RowMajor>().end()) );
184 }
185
186 {
187 check_begin_end_for_loop(v);
188 check_begin_end_for_loop(A.col(internal::random<Index>(0,A.cols()-1)));
189 check_begin_end_for_loop(A.row(internal::random<Index>(0,A.rows()-1)));
190 check_begin_end_for_loop(v+v);
191 }
192
193 #if EIGEN_HAS_CXX11
194 // check swappable
195 {
196 using std::swap;
197 // pointer-based
198 {
199 VectorType v_copy = v;
200 auto a = v.begin();
201 auto b = v.end()-1;
202 swap(a,b);
203 VERIFY_IS_EQUAL(v,v_copy);
204 VERIFY_IS_EQUAL(*b,*v.begin());
205 VERIFY_IS_EQUAL(*b,v(0));
206 VERIFY_IS_EQUAL(*a,v.end()[-1]);
207 VERIFY_IS_EQUAL(*a,v(last));
208 }
209
210 // generic
211 {
212 RowMatrixType B_copy = B;
213 auto Br = B.reshaped();
214 auto a = Br.begin();
215 auto b = Br.end()-1;
216 swap(a,b);
217 VERIFY_IS_EQUAL(B,B_copy);
218 VERIFY_IS_EQUAL(*b,*Br.begin());
219 VERIFY_IS_EQUAL(*b,Br(0));
220 VERIFY_IS_EQUAL(*a,Br.end()[-1]);
221 VERIFY_IS_EQUAL(*a,Br(last));
222 }
223 }
224
225 // check non-const iterator with for-range loops
226 {
227 i = 0;
228 for(auto x : v) { VERIFY_IS_EQUAL(x,v[i++]); }
229
230 j = internal::random<Index>(0,A.cols()-1);
231 i = 0;
232 for(auto x : A.col(j)) { VERIFY_IS_EQUAL(x,A(i++,j)); }
233
234 i = 0;
235 for(auto x : (v+A.col(j))) { VERIFY_IS_APPROX(x,v(i)+A(i,j)); ++i; }
236
237 j = 0;
238 i = internal::random<Index>(0,A.rows()-1);
239 for(auto x : A.row(i)) { VERIFY_IS_EQUAL(x,A(i,j++)); }
240
241 i = 0;
242 for(auto x : A.reshaped()) { VERIFY_IS_EQUAL(x,A(i++)); }
243 }
244
245 // same for const_iterator
246 {
247 i = 0;
248 for(auto x : cv) { VERIFY_IS_EQUAL(x,v[i++]); }
249
250 i = 0;
251 for(auto x : cA.reshaped()) { VERIFY_IS_EQUAL(x,A(i++)); }
252
253 j = 0;
254 i = internal::random<Index>(0,A.rows()-1);
255 for(auto x : cA.row(i)) { VERIFY_IS_EQUAL(x,A(i,j++)); }
256 }
257
258 // check reshaped() on row-major
259 {
260 i = 0;
261 Matrix<Scalar,Dynamic,Dynamic,ColMajor> Bc = B;
262 for(auto x : B.reshaped()) { VERIFY_IS_EQUAL(x,Bc(i++)); }
263 }
264
265 // check write access
266 {
267 VectorType w(v.size());
268 i = 0;
269 for(auto& x : w) { x = v(i++); }
270 VERIFY_IS_EQUAL(v,w);
271 }
272
273 // check for dangling pointers
274 {
275 // no dangling because pointer-based
276 {
277 j = internal::random<Index>(0,A.cols()-1);
278 auto it = A.col(j).begin();
279 for(i=0;i<rows;++i) {
280 VERIFY_IS_EQUAL(it[i],A(i,j));
281 }
282 }
283
284 // no dangling because pointer-based
285 {
286 i = internal::random<Index>(0,A.rows()-1);
287 auto it = A.row(i).begin();
288 for(j=0;j<cols;++j) { VERIFY_IS_EQUAL(it[j],A(i,j)); }
289 }
290
291 {
292 j = internal::random<Index>(0,A.cols()-1);
293 // this would produce a dangling pointer:
294 // auto it = (A+2*A).col(j).begin();
295 // we need to name the temporary expression:
296 auto tmp = (A+2*A).col(j);
297 auto it = tmp.begin();
298 for(i=0;i<rows;++i) {
299 VERIFY_IS_APPROX(it[i],3*A(i,j));
300 }
301 }
302 }
303
304 {
305 // check basic for loop on vector-wise iterators
306 j=0;
307 for (auto it = A.colwise().cbegin(); it != A.colwise().cend(); ++it, ++j) {
308 VERIFY_IS_APPROX( it->coeff(0), A(0,j) );
309 VERIFY_IS_APPROX( (*it).coeff(0), A(0,j) );
310 }
311 j=0;
312 for (auto it = A.colwise().begin(); it != A.colwise().end(); ++it, ++j) {
313 (*it).coeffRef(0) = (*it).coeff(0); // compilation check
314 it->coeffRef(0) = it->coeff(0); // compilation check
315 VERIFY_IS_APPROX( it->coeff(0), A(0,j) );
316 VERIFY_IS_APPROX( (*it).coeff(0), A(0,j) );
317 }
318
319 // check valuetype gives us a copy
320 j=0;
321 for (auto it = A.colwise().cbegin(); it != A.colwise().cend(); ++it, ++j) {
322 typename decltype(it)::value_type tmp = *it;
323 VERIFY_IS_NOT_EQUAL( tmp.data() , it->data() );
324 VERIFY_IS_APPROX( tmp, A.col(j) );
325 }
326 }
327
328 #endif
329
330 if(rows>=3) {
331 VERIFY_IS_EQUAL((v.begin()+rows/2)[1], v(rows/2+1));
332
333 VERIFY_IS_EQUAL((A.rowwise().begin()+rows/2)[1], A.row(rows/2+1));
334 }
335
336 if(cols>=3) {
337 VERIFY_IS_EQUAL((A.colwise().begin()+cols/2)[1], A.col(cols/2+1));
338 }
339
340 // check std::sort
341 {
342 // first check that is_sorted returns false when required
343 if(rows>=2)
344 {
345 v(1) = v(0)-Scalar(1);
346 #if EIGEN_HAS_CXX11
347 VERIFY(!is_sorted(std::begin(v),std::end(v)));
348 #else
349 VERIFY(!is_sorted(v.cbegin(),v.cend()));
350 #endif
351 }
352
353 // on a vector
354 {
355 std::sort(v.begin(),v.end());
356 VERIFY(is_sorted(v.begin(),v.end()));
357 VERIFY(!::is_sorted(make_reverse_iterator(v.end()),make_reverse_iterator(v.begin())));
358 }
359
360 // on a column of a column-major matrix -> pointer-based iterator and default increment
361 {
362 j = internal::random<Index>(0,A.cols()-1);
363 // std::sort(begin(A.col(j)),end(A.col(j))); // does not compile because this returns const iterators
364 typename ColMatrixType::ColXpr Acol = A.col(j);
365 std::sort(Acol.begin(),Acol.end());
366 VERIFY(is_sorted(Acol.cbegin(),Acol.cend()));
367 A.setRandom();
368
369 std::sort(A.col(j).begin(),A.col(j).end());
370 VERIFY(is_sorted(A.col(j).cbegin(),A.col(j).cend()));
371 A.setRandom();
372 }
373
374 // on a row of a rowmajor matrix -> pointer-based iterator and runtime increment
375 {
376 i = internal::random<Index>(0,A.rows()-1);
377 typename ColMatrixType::RowXpr Arow = A.row(i);
378 VERIFY_IS_EQUAL( std::distance(Arow.begin(),Arow.end()), cols);
379 std::sort(Arow.begin(),Arow.end());
380 VERIFY(is_sorted(Arow.cbegin(),Arow.cend()));
381 A.setRandom();
382
383 std::sort(A.row(i).begin(),A.row(i).end());
384 VERIFY(is_sorted(A.row(i).cbegin(),A.row(i).cend()));
385 A.setRandom();
386 }
387
388 // with a generic iterator
389 {
390 Reshaped<RowMatrixType,RowMatrixType::SizeAtCompileTime,1> B1 = B.reshaped();
391 std::sort(B1.begin(),B1.end());
392 VERIFY(is_sorted(B1.cbegin(),B1.cend()));
393 B.setRandom();
394
395 // assertion because nested expressions are different
396 // std::sort(B.reshaped().begin(),B.reshaped().end());
397 // VERIFY(is_sorted(B.reshaped().cbegin(),B.reshaped().cend()));
398 // B.setRandom();
399 }
400 }
401
402 // check with partial_sum
403 {
404 j = internal::random<Index>(0,A.cols()-1);
405 typename ColMatrixType::ColXpr Acol = A.col(j);
406 std::partial_sum(Acol.begin(), Acol.end(), v.begin());
407 VERIFY_IS_APPROX(v(seq(1,last)), v(seq(0,last-1))+Acol(seq(1,last)));
408
409 // inplace
410 std::partial_sum(Acol.begin(), Acol.end(), Acol.begin());
411 VERIFY_IS_APPROX(v, Acol);
412 }
413
414 // stress random access as required by std::nth_element
415 if(rows>=3)
416 {
417 v.setRandom();
418 VectorType v1 = v;
419 std::sort(v1.begin(),v1.end());
420 std::nth_element(v.begin(), v.begin()+rows/2, v.end());
421 VERIFY_IS_APPROX(v1(rows/2), v(rows/2));
422
423 v.setRandom();
424 v1 = v;
425 std::sort(v1.begin()+rows/2,v1.end());
426 std::nth_element(v.begin()+rows/2, v.begin()+rows/4, v.end());
427 VERIFY_IS_APPROX(v1(rows/4), v(rows/4));
428 }
429
430 #if EIGEN_HAS_CXX11
431 // check rows/cols iterators with range-for loops
432 {
433 j = 0;
434 for(auto c : A.colwise()) { VERIFY_IS_APPROX(c.sum(), A.col(j).sum()); ++j; }
435 j = 0;
436 for(auto c : B.colwise()) { VERIFY_IS_APPROX(c.sum(), B.col(j).sum()); ++j; }
437
438 j = 0;
439 for(auto c : B.colwise()) {
440 i = 0;
441 for(auto& x : c) {
442 VERIFY_IS_EQUAL(x, B(i,j));
443 x = A(i,j);
444 ++i;
445 }
446 ++j;
447 }
448 VERIFY_IS_APPROX(A,B);
449 B.setRandom();
450
451 i = 0;
452 for(auto r : A.rowwise()) { VERIFY_IS_APPROX(r.sum(), A.row(i).sum()); ++i; }
453 i = 0;
454 for(auto r : B.rowwise()) { VERIFY_IS_APPROX(r.sum(), B.row(i).sum()); ++i; }
455 }
456
457
458 // check rows/cols iterators with STL algorithms
459 {
460 RowVectorType row = RowVectorType::Random(cols);
461 A.rowwise() = row;
462 VERIFY( std::all_of(A.rowwise().begin(), A.rowwise().end(), [&row](typename ColMatrixType::RowXpr x) { return internal::isApprox(x.squaredNorm(),row.squaredNorm()); }) );
463 VERIFY( std::all_of(A.rowwise().rbegin(), A.rowwise().rend(), [&row](typename ColMatrixType::RowXpr x) { return internal::isApprox(x.squaredNorm(),row.squaredNorm()); }) );
464
465 VectorType col = VectorType::Random(rows);
466 A.colwise() = col;
467 VERIFY( std::all_of(A.colwise().begin(), A.colwise().end(), [&col](typename ColMatrixType::ColXpr x) { return internal::isApprox(x.squaredNorm(),col.squaredNorm()); }) );
468 VERIFY( std::all_of(A.colwise().rbegin(), A.colwise().rend(), [&col](typename ColMatrixType::ColXpr x) { return internal::isApprox(x.squaredNorm(),col.squaredNorm()); }) );
469 VERIFY( std::all_of(A.colwise().cbegin(), A.colwise().cend(), [&col](typename ColMatrixType::ConstColXpr x) { return internal::isApprox(x.squaredNorm(),col.squaredNorm()); }) );
470 VERIFY( std::all_of(A.colwise().crbegin(), A.colwise().crend(), [&col](typename ColMatrixType::ConstColXpr x) { return internal::isApprox(x.squaredNorm(),col.squaredNorm()); }) );
471
472 i = internal::random<Index>(0,A.rows()-1);
473 A.setRandom();
474 A.row(i).setZero();
475 VERIFY_IS_EQUAL( std::find_if(A.rowwise().begin(), A.rowwise().end(), [](typename ColMatrixType::RowXpr x) { return x.squaredNorm() == Scalar(0); })-A.rowwise().begin(), i );
476 VERIFY_IS_EQUAL( std::find_if(A.rowwise().rbegin(), A.rowwise().rend(), [](typename ColMatrixType::RowXpr x) { return x.squaredNorm() == Scalar(0); })-A.rowwise().rbegin(), (A.rows()-1) - i );
477
478 j = internal::random<Index>(0,A.cols()-1);
479 A.setRandom();
480 A.col(j).setZero();
481 VERIFY_IS_EQUAL( std::find_if(A.colwise().begin(), A.colwise().end(), [](typename ColMatrixType::ColXpr x) { return x.squaredNorm() == Scalar(0); })-A.colwise().begin(), j );
482 VERIFY_IS_EQUAL( std::find_if(A.colwise().rbegin(), A.colwise().rend(), [](typename ColMatrixType::ColXpr x) { return x.squaredNorm() == Scalar(0); })-A.colwise().rbegin(), (A.cols()-1) - j );
483 }
484
485 {
486 using VecOp = VectorwiseOp<ArrayXXi, 0>;
487 STATIC_CHECK(( internal::is_same<VecOp::const_iterator, decltype(std::declval<const VecOp&>().cbegin())>::value ));
488 STATIC_CHECK(( internal::is_same<VecOp::const_iterator, decltype(std::declval<const VecOp&>().cend ())>::value ));
489 #if EIGEN_COMP_CXXVER>=14
490 STATIC_CHECK(( internal::is_same<VecOp::const_iterator, decltype(std::cbegin(std::declval<const VecOp&>()))>::value ));
491 STATIC_CHECK(( internal::is_same<VecOp::const_iterator, decltype(std::cend (std::declval<const VecOp&>()))>::value ));
492 #endif
493 }
494
495 #endif
496 }
497
498
499 #if EIGEN_HAS_CXX11
500 // When the compiler sees expression IsContainerTest<C>(0), if C is an
501 // STL-style container class, the first overload of IsContainerTest
502 // will be viable (since both C::iterator* and C::const_iterator* are
503 // valid types and NULL can be implicitly converted to them). It will
504 // be picked over the second overload as 'int' is a perfect match for
505 // the type of argument 0. If C::iterator or C::const_iterator is not
506 // a valid type, the first overload is not viable, and the second
507 // overload will be picked.
508 template <class C,
509 class Iterator = decltype(::std::declval<const C&>().begin()),
510 class = decltype(::std::declval<const C&>().end()),
511 class = decltype(++::std::declval<Iterator&>()),
512 class = decltype(*::std::declval<Iterator>()),
513 class = typename C::const_iterator>
IsContainerType(int)514 bool IsContainerType(int /* dummy */) { return true; }
515
516 template <class C>
IsContainerType(long)517 bool IsContainerType(long /* dummy */) { return false; }
518
519 template <typename Scalar, int Rows, int Cols>
test_stl_container_detection(int rows=Rows,int cols=Cols)520 void test_stl_container_detection(int rows=Rows, int cols=Cols)
521 {
522 typedef Matrix<Scalar,Rows,1> VectorType;
523 typedef Matrix<Scalar,Rows,Cols,ColMajor> ColMatrixType;
524 typedef Matrix<Scalar,Rows,Cols,RowMajor> RowMatrixType;
525
526 ColMatrixType A = ColMatrixType::Random(rows, cols);
527 RowMatrixType B = RowMatrixType::Random(rows, cols);
528
529 Index i = 1;
530
531 using ColMatrixColType = decltype(A.col(i));
532 using ColMatrixRowType = decltype(A.row(i));
533 using RowMatrixColType = decltype(B.col(i));
534 using RowMatrixRowType = decltype(B.row(i));
535
536 // Vector and matrix col/row are valid Stl-style container.
537 VERIFY_IS_EQUAL(IsContainerType<VectorType>(0), true);
538 VERIFY_IS_EQUAL(IsContainerType<ColMatrixColType>(0), true);
539 VERIFY_IS_EQUAL(IsContainerType<ColMatrixRowType>(0), true);
540 VERIFY_IS_EQUAL(IsContainerType<RowMatrixColType>(0), true);
541 VERIFY_IS_EQUAL(IsContainerType<RowMatrixRowType>(0), true);
542
543 // But the matrix itself is not a valid Stl-style container.
544 VERIFY_IS_EQUAL(IsContainerType<ColMatrixType>(0), rows == 1 || cols == 1);
545 VERIFY_IS_EQUAL(IsContainerType<RowMatrixType>(0), rows == 1 || cols == 1);
546 }
547 #endif
548
EIGEN_DECLARE_TEST(stl_iterators)549 EIGEN_DECLARE_TEST(stl_iterators)
550 {
551 for(int i = 0; i < g_repeat; i++) {
552 CALL_SUBTEST_1(( test_stl_iterators<double,2,3>() ));
553 CALL_SUBTEST_1(( test_stl_iterators<float,7,5>() ));
554 CALL_SUBTEST_1(( test_stl_iterators<int,Dynamic,Dynamic>(internal::random<int>(5,10), internal::random<int>(5,10)) ));
555 CALL_SUBTEST_1(( test_stl_iterators<int,Dynamic,Dynamic>(internal::random<int>(10,200), internal::random<int>(10,200)) ));
556 }
557
558 #if EIGEN_HAS_CXX11
559 CALL_SUBTEST_1(( test_stl_container_detection<float,1,1>() ));
560 CALL_SUBTEST_1(( test_stl_container_detection<float,5,5>() ));
561 #endif
562 }
563