source: pacpussensors/trunk/Vislab/lib3dv-1.2.0/lib3dv/eigen/test/ref.cpp

Last change on this file was 136, checked in by ldecherf, 8 years ago

Doc

File size: 10.9 KB
Line 
1// This file is part of Eigen, a lightweight C++ template library
2// for linear algebra.
3//
4// Copyright (C) 20013 Gael Guennebaud <gael.guennebaud@inria.fr>
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// This unit test cannot be easily written to work with EIGEN_DEFAULT_TO_ROW_MAJOR
11#ifdef EIGEN_DEFAULT_TO_ROW_MAJOR
12#undef EIGEN_DEFAULT_TO_ROW_MAJOR
13#endif
14
15static int nb_temporaries;
16
17inline void on_temporary_creation(int) {
18 // here's a great place to set a breakpoint when debugging failures in this test!
19 nb_temporaries++;
20}
21
22
23#define EIGEN_DENSE_STORAGE_CTOR_PLUGIN { on_temporary_creation(size); }
24
25#include "main.h"
26
27#define VERIFY_EVALUATION_COUNT(XPR,N) {\
28 nb_temporaries = 0; \
29 XPR; \
30 if(nb_temporaries!=N) std::cerr << "nb_temporaries == " << nb_temporaries << "\n"; \
31 VERIFY( (#XPR) && nb_temporaries==N ); \
32 }
33
34
35// test Ref.h
36
37// Deal with i387 extended precision
38#if EIGEN_ARCH_i386 && !(EIGEN_ARCH_x86_64)
39
40#if EIGEN_COMP_GNUC_STRICT && EIGEN_GNUC_AT_LEAST(4,4)
41#pragma GCC optimize ("-ffloat-store")
42#else
43#undef VERIFY_IS_EQUAL
44#define VERIFY_IS_EQUAL(X,Y) VERIFY_IS_APPROX(X,Y)
45#endif
46
47#endif
48
49template<typename MatrixType> void ref_matrix(const MatrixType& m)
50{
51 typedef typename MatrixType::Index Index;
52 typedef typename MatrixType::Scalar Scalar;
53 typedef typename MatrixType::RealScalar RealScalar;
54 typedef Matrix<Scalar,Dynamic,Dynamic,MatrixType::Options> DynMatrixType;
55 typedef Matrix<RealScalar,Dynamic,Dynamic,MatrixType::Options> RealDynMatrixType;
56
57 typedef Ref<MatrixType> RefMat;
58 typedef Ref<DynMatrixType> RefDynMat;
59 typedef Ref<const DynMatrixType> ConstRefDynMat;
60 typedef Ref<RealDynMatrixType , 0, Stride<Dynamic,Dynamic> > RefRealMatWithStride;
61
62 Index rows = m.rows(), cols = m.cols();
63
64 MatrixType m1 = MatrixType::Random(rows, cols),
65 m2 = m1;
66
67 Index i = internal::random<Index>(0,rows-1);
68 Index j = internal::random<Index>(0,cols-1);
69 Index brows = internal::random<Index>(1,rows-i);
70 Index bcols = internal::random<Index>(1,cols-j);
71
72 RefMat rm0 = m1;
73 VERIFY_IS_EQUAL(rm0, m1);
74 RefDynMat rm1 = m1;
75 VERIFY_IS_EQUAL(rm1, m1);
76 RefDynMat rm2 = m1.block(i,j,brows,bcols);
77 VERIFY_IS_EQUAL(rm2, m1.block(i,j,brows,bcols));
78 rm2.setOnes();
79 m2.block(i,j,brows,bcols).setOnes();
80 VERIFY_IS_EQUAL(m1, m2);
81
82 m2.block(i,j,brows,bcols).setRandom();
83 rm2 = m2.block(i,j,brows,bcols);
84 VERIFY_IS_EQUAL(m1, m2);
85
86 ConstRefDynMat rm3 = m1.block(i,j,brows,bcols);
87 m1.block(i,j,brows,bcols) *= 2;
88 m2.block(i,j,brows,bcols) *= 2;
89 VERIFY_IS_EQUAL(rm3, m2.block(i,j,brows,bcols));
90 RefRealMatWithStride rm4 = m1.real();
91 VERIFY_IS_EQUAL(rm4, m2.real());
92 rm4.array() += 1;
93 m2.real().array() += 1;
94 VERIFY_IS_EQUAL(m1, m2);
95}
96
97template<typename VectorType> void ref_vector(const VectorType& m)
98{
99 typedef typename VectorType::Index Index;
100 typedef typename VectorType::Scalar Scalar;
101 typedef typename VectorType::RealScalar RealScalar;
102 typedef Matrix<Scalar,Dynamic,1,VectorType::Options> DynMatrixType;
103 typedef Matrix<Scalar,Dynamic,Dynamic,ColMajor> MatrixType;
104 typedef Matrix<RealScalar,Dynamic,1,VectorType::Options> RealDynMatrixType;
105
106 typedef Ref<VectorType> RefMat;
107 typedef Ref<DynMatrixType> RefDynMat;
108 typedef Ref<const DynMatrixType> ConstRefDynMat;
109 typedef Ref<RealDynMatrixType , 0, InnerStride<> > RefRealMatWithStride;
110 typedef Ref<DynMatrixType , 0, InnerStride<> > RefMatWithStride;
111
112 Index size = m.size();
113
114 VectorType v1 = VectorType::Random(size),
115 v2 = v1;
116 MatrixType mat1 = MatrixType::Random(size,size),
117 mat2 = mat1,
118 mat3 = MatrixType::Random(size,size);
119
120 Index i = internal::random<Index>(0,size-1);
121 Index bsize = internal::random<Index>(1,size-i);
122
123 RefMat rm0 = v1;
124 VERIFY_IS_EQUAL(rm0, v1);
125 RefDynMat rv1 = v1;
126 VERIFY_IS_EQUAL(rv1, v1);
127 RefDynMat rv2 = v1.segment(i,bsize);
128 VERIFY_IS_EQUAL(rv2, v1.segment(i,bsize));
129 rv2.setOnes();
130 v2.segment(i,bsize).setOnes();
131 VERIFY_IS_EQUAL(v1, v2);
132
133 v2.segment(i,bsize).setRandom();
134 rv2 = v2.segment(i,bsize);
135 VERIFY_IS_EQUAL(v1, v2);
136
137 ConstRefDynMat rm3 = v1.segment(i,bsize);
138 v1.segment(i,bsize) *= 2;
139 v2.segment(i,bsize) *= 2;
140 VERIFY_IS_EQUAL(rm3, v2.segment(i,bsize));
141
142 RefRealMatWithStride rm4 = v1.real();
143 VERIFY_IS_EQUAL(rm4, v2.real());
144 rm4.array() += 1;
145 v2.real().array() += 1;
146 VERIFY_IS_EQUAL(v1, v2);
147
148 RefMatWithStride rm5 = mat1.row(i).transpose();
149 VERIFY_IS_EQUAL(rm5, mat1.row(i).transpose());
150 rm5.array() += 1;
151 mat2.row(i).array() += 1;
152 VERIFY_IS_EQUAL(mat1, mat2);
153 rm5.noalias() = rm4.transpose() * mat3;
154 mat2.row(i) = v2.real().transpose() * mat3;
155 VERIFY_IS_APPROX(mat1, mat2);
156}
157
158template<typename PlainObjectType> void check_const_correctness(const PlainObjectType&)
159{
160 // verify that ref-to-const don't have LvalueBit
161 typedef typename internal::add_const<PlainObjectType>::type ConstPlainObjectType;
162 VERIFY( !(internal::traits<Ref<ConstPlainObjectType> >::Flags & LvalueBit) );
163 VERIFY( !(internal::traits<Ref<ConstPlainObjectType, Aligned> >::Flags & LvalueBit) );
164 VERIFY( !(Ref<ConstPlainObjectType>::Flags & LvalueBit) );
165 VERIFY( !(Ref<ConstPlainObjectType, Aligned>::Flags & LvalueBit) );
166}
167
168template<typename B>
169EIGEN_DONT_INLINE void call_ref_1(Ref<VectorXf> a, const B &b) { VERIFY_IS_EQUAL(a,b); }
170template<typename B>
171EIGEN_DONT_INLINE void call_ref_2(const Ref<const VectorXf>& a, const B &b) { VERIFY_IS_EQUAL(a,b); }
172template<typename B>
173EIGEN_DONT_INLINE void call_ref_3(Ref<VectorXf,0,InnerStride<> > a, const B &b) { VERIFY_IS_EQUAL(a,b); }
174template<typename B>
175EIGEN_DONT_INLINE void call_ref_4(const Ref<const VectorXf,0,InnerStride<> >& a, const B &b) { VERIFY_IS_EQUAL(a,b); }
176template<typename B>
177EIGEN_DONT_INLINE void call_ref_5(Ref<MatrixXf,0,OuterStride<> > a, const B &b) { VERIFY_IS_EQUAL(a,b); }
178template<typename B>
179EIGEN_DONT_INLINE void call_ref_6(const Ref<const MatrixXf,0,OuterStride<> >& a, const B &b) { VERIFY_IS_EQUAL(a,b); }
180template<typename B>
181EIGEN_DONT_INLINE void call_ref_7(Ref<Matrix<float,Dynamic,3> > a, const B &b) { VERIFY_IS_EQUAL(a,b); }
182
183void call_ref()
184{
185 VectorXcf ca = VectorXcf::Random(10);
186 VectorXf a = VectorXf::Random(10);
187 RowVectorXf b = RowVectorXf::Random(10);
188 MatrixXf A = MatrixXf::Random(10,10);
189 RowVector3f c = RowVector3f::Random();
190 const VectorXf& ac(a);
191 VectorBlock<VectorXf> ab(a,0,3);
192 const VectorBlock<VectorXf> abc(a,0,3);
193
194
195 VERIFY_EVALUATION_COUNT( call_ref_1(a,a), 0);
196 VERIFY_EVALUATION_COUNT( call_ref_1(b,b.transpose()), 0);
197// call_ref_1(ac,a<c); // does not compile because ac is const
198 VERIFY_EVALUATION_COUNT( call_ref_1(ab,ab), 0);
199 VERIFY_EVALUATION_COUNT( call_ref_1(a.head(4),a.head(4)), 0);
200 VERIFY_EVALUATION_COUNT( call_ref_1(abc,abc), 0);
201 VERIFY_EVALUATION_COUNT( call_ref_1(A.col(3),A.col(3)), 0);
202// call_ref_1(A.row(3),A.row(3)); // does not compile because innerstride!=1
203 VERIFY_EVALUATION_COUNT( call_ref_3(A.row(3),A.row(3).transpose()), 0);
204 VERIFY_EVALUATION_COUNT( call_ref_4(A.row(3),A.row(3).transpose()), 0);
205// call_ref_1(a+a, a+a); // does not compile for obvious reason
206
207 MatrixXf tmp = A*A.col(1);
208 VERIFY_EVALUATION_COUNT( call_ref_2(A*A.col(1), tmp), 1); // evaluated into a temp
209 VERIFY_EVALUATION_COUNT( call_ref_2(ac.head(5),ac.head(5)), 0);
210 VERIFY_EVALUATION_COUNT( call_ref_2(ac,ac), 0);
211 VERIFY_EVALUATION_COUNT( call_ref_2(a,a), 0);
212 VERIFY_EVALUATION_COUNT( call_ref_2(ab,ab), 0);
213 VERIFY_EVALUATION_COUNT( call_ref_2(a.head(4),a.head(4)), 0);
214 tmp = a+a;
215 VERIFY_EVALUATION_COUNT( call_ref_2(a+a,tmp), 1); // evaluated into a temp
216 VERIFY_EVALUATION_COUNT( call_ref_2(ca.imag(),ca.imag()), 1); // evaluated into a temp
217
218 VERIFY_EVALUATION_COUNT( call_ref_4(ac.head(5),ac.head(5)), 0);
219 tmp = a+a;
220 VERIFY_EVALUATION_COUNT( call_ref_4(a+a,tmp), 1); // evaluated into a temp
221 VERIFY_EVALUATION_COUNT( call_ref_4(ca.imag(),ca.imag()), 0);
222
223 VERIFY_EVALUATION_COUNT( call_ref_5(a,a), 0);
224 VERIFY_EVALUATION_COUNT( call_ref_5(a.head(3),a.head(3)), 0);
225 VERIFY_EVALUATION_COUNT( call_ref_5(A,A), 0);
226// call_ref_5(A.transpose(),A.transpose()); // does not compile because storage order does not match
227 VERIFY_EVALUATION_COUNT( call_ref_5(A.block(1,1,2,2),A.block(1,1,2,2)), 0);
228 VERIFY_EVALUATION_COUNT( call_ref_5(b,b), 0); // storage order do not match, but this is a degenerate case that should work
229 VERIFY_EVALUATION_COUNT( call_ref_5(a.row(3),a.row(3)), 0);
230
231 VERIFY_EVALUATION_COUNT( call_ref_6(a,a), 0);
232 VERIFY_EVALUATION_COUNT( call_ref_6(a.head(3),a.head(3)), 0);
233 VERIFY_EVALUATION_COUNT( call_ref_6(A.row(3),A.row(3)), 1); // evaluated into a temp thouth it could be avoided by viewing it as a 1xn matrix
234 tmp = A+A;
235 VERIFY_EVALUATION_COUNT( call_ref_6(A+A,tmp), 1); // evaluated into a temp
236 VERIFY_EVALUATION_COUNT( call_ref_6(A,A), 0);
237 VERIFY_EVALUATION_COUNT( call_ref_6(A.transpose(),A.transpose()), 1); // evaluated into a temp because the storage orders do not match
238 VERIFY_EVALUATION_COUNT( call_ref_6(A.block(1,1,2,2),A.block(1,1,2,2)), 0);
239
240 VERIFY_EVALUATION_COUNT( call_ref_7(c,c), 0);
241}
242
243typedef Matrix<double,Dynamic,Dynamic,RowMajor> RowMatrixXd;
244int test_ref_overload_fun1(Ref<MatrixXd> ) { return 1; }
245int test_ref_overload_fun1(Ref<RowMatrixXd> ) { return 2; }
246int test_ref_overload_fun1(Ref<MatrixXf> ) { return 3; }
247
248int test_ref_overload_fun2(Ref<const MatrixXd> ) { return 4; }
249int test_ref_overload_fun2(Ref<const MatrixXf> ) { return 5; }
250
251// See also bug 969
252void test_ref_overloads()
253{
254 MatrixXd Ad, Bd;
255 RowMatrixXd rAd, rBd;
256 VERIFY( test_ref_overload_fun1(Ad)==1 );
257 VERIFY( test_ref_overload_fun1(rAd)==2 );
258
259 MatrixXf Af, Bf;
260 VERIFY( test_ref_overload_fun2(Ad)==4 );
261 VERIFY( test_ref_overload_fun2(Ad+Bd)==4 );
262 VERIFY( test_ref_overload_fun2(Af+Bf)==5 );
263}
264
265void test_ref()
266{
267 for(int i = 0; i < g_repeat; i++) {
268 CALL_SUBTEST_1( ref_vector(Matrix<float, 1, 1>()) );
269 CALL_SUBTEST_1( check_const_correctness(Matrix<float, 1, 1>()) );
270 CALL_SUBTEST_2( ref_vector(Vector4d()) );
271 CALL_SUBTEST_2( check_const_correctness(Matrix4d()) );
272 CALL_SUBTEST_3( ref_vector(Vector4cf()) );
273 CALL_SUBTEST_4( ref_vector(VectorXcf(8)) );
274 CALL_SUBTEST_5( ref_vector(VectorXi(12)) );
275 CALL_SUBTEST_5( check_const_correctness(VectorXi(12)) );
276
277 CALL_SUBTEST_1( ref_matrix(Matrix<float, 1, 1>()) );
278 CALL_SUBTEST_2( ref_matrix(Matrix4d()) );
279 CALL_SUBTEST_1( ref_matrix(Matrix<float,3,5>()) );
280 CALL_SUBTEST_4( ref_matrix(MatrixXcf(internal::random<int>(1,10),internal::random<int>(1,10))) );
281 CALL_SUBTEST_4( ref_matrix(Matrix<std::complex<double>,10,15>()) );
282 CALL_SUBTEST_5( ref_matrix(MatrixXi(internal::random<int>(1,10),internal::random<int>(1,10))) );
283 CALL_SUBTEST_6( call_ref() );
284 }
285
286 CALL_SUBTEST_7( test_ref_overloads() );
287}
Note: See TracBrowser for help on using the repository browser.