1 /*
2 * Tiny Vector Matrix Library
3 * Dense Vector Matrix Libary of Tiny size using Expression Templates
4 *
5 * Copyright (C) 2001 - 2006 Olaf Petzold <opetzold@users.sourceforge.net>
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 *
21 * $Id: TestMatrixEval.h,v 1.2 2006-11-20 20:22:18 opetzold Exp $
22 */
23
24 #ifndef TVMET_TEST_MATRIX_EVAL_H
25 #define TVMET_TEST_MATRIX_EVAL_H
26
27 #include <cppunit/extensions/HelperMacros.h>
28
29 #include <tvmet/Matrix.h>
30
31 #include <cassert>
32
33 template <class T>
34 class TestMatrixEval : public CppUnit::TestFixture
35 {
36 CPPUNIT_TEST_SUITE( TestMatrixEval );
37 CPPUNIT_TEST( Greater );
38 CPPUNIT_TEST( Less );
39 CPPUNIT_TEST( GreaterOrEqual );
40 CPPUNIT_TEST( LessOrEqual );
41 CPPUNIT_TEST( Equal );
42 CPPUNIT_TEST( NotEqual );
43 CPPUNIT_TEST( LogicalAnd );
44 CPPUNIT_TEST( LogicalOr );
45
46 // others
47 CPPUNIT_TEST( AllElements );
48 CPPUNIT_TEST( AnyElements );
49 CPPUNIT_TEST( Eval3 );
50 CPPUNIT_TEST( EvalPod3 );
51
52 CPPUNIT_TEST_SUITE_END();
53
54 private:
55 typedef tvmet::Matrix<T, 3, 3> matrix_type;
56
57 public:
TestMatrixEval()58 TestMatrixEval()
59 : mOne(1), mZero(0) { }
60
61 public: // cppunit interface
62 /** cppunit hook for fixture set up. */
63 void setUp();
64
65 /** cppunit hook for fixture tear down. */
66 void tearDown();
67
68 protected:
69 void Greater();
70 void Less();
71 void GreaterOrEqual();
72 void LessOrEqual();
73 void Equal();
74 void NotEqual();
75 void LogicalAnd();
76 void LogicalOr();
77
78 void AllElements();
79 void AnyElements();
80 void Eval3();
81 void EvalPod3();
82
83 private:
84 matrix_type m1;
85 matrix_type mBig; /**< matrix bigger than m1 */
86 const matrix_type mOne;
87 const matrix_type mZero;
88 };
89
90 /*****************************************************************************
91 * Implementation Part I (cppunit part)
92 ****************************************************************************/
93
94 template <class T>
setUp()95 void TestMatrixEval<T>::setUp () {
96 m1 = 1,4,7,
97 2,5,8,
98 3,6,9;
99 mBig = 10,40,70,
100 20,50,80,
101 30,60,90;
102 }
103
104 template <class T>
tearDown()105 void TestMatrixEval<T>::tearDown() { }
106
107 /*****************************************************************************
108 * Implementation Part II
109 * these are elemental - therefore we use std::assert
110 ****************************************************************************/
111
112 /*
113 * on SelfTest, we have the guarantee, that the container holds the
114 * expected values. Now check comparing operation using tvmet's
115 * eval function. This is the basic for all further test since it's
116 * the way we check the correctness. The other way would be element wise
117 * compare as in SelfTest, urgh...
118 */
119 template <class T>
120 void
Greater()121 TestMatrixEval<T>::Greater() {
122 // all test are element wise !
123 assert( all_elements(mBig > m1) );
124 }
125
126 template <class T>
127 void
Less()128 TestMatrixEval<T>::Less() {
129 // all test are element wise !
130 assert( all_elements(m1 < mBig) );
131 }
132
133 template <class T>
134 void
GreaterOrEqual()135 TestMatrixEval<T>::GreaterOrEqual() {
136 // all test are element wise !
137 assert( all_elements(mBig >= m1) );
138 assert( all_elements(m1 >= m1) );
139 assert( all_elements(mBig >= mBig) );
140 assert( all_elements(mOne >= T(1)) );
141 assert( all_elements(mZero>= T(0)) );
142 }
143
144 template <class T>
145 void
LessOrEqual()146 TestMatrixEval<T>::LessOrEqual() {
147 // all test are element wise !
148 assert( all_elements(m1 <= mBig) );
149 assert( all_elements(m1 <= m1) );
150 assert( all_elements(mBig <= mBig) );
151 assert( all_elements(mOne <= T(1)) );
152 assert( all_elements(mZero<= T(0)) );
153 }
154
155 template <class T>
156 void
Equal()157 TestMatrixEval<T>::Equal() {
158 // all test are element wise !
159 assert( all_elements(m1 == m1) );
160 assert( all_elements(mBig == mBig) );
161 assert( all_elements(mOne == T(1)) );
162 assert( all_elements(mZero == T(0)) );
163 }
164
165 template <class T>
166 void
NotEqual()167 TestMatrixEval<T>::NotEqual() {
168 // all test are element wise !
169 assert( all_elements(m1 != mBig) );
170 }
171
172 template <class T>
173 void
LogicalAnd()174 TestMatrixEval<T>::LogicalAnd() {
175 // TODO: implement
176 }
177
178 template <class T>
179 void
LogicalOr()180 TestMatrixEval<T>::LogicalOr() {
181 // TODO: implement
182 }
183
184 /*****************************************************************************
185 * Implementation Part III
186 * test on generell and eval functions
187 ****************************************************************************/
188
189 template <class T>
190 void
AllElements()191 TestMatrixEval<T>::AllElements() {
192 // true cases
193 CPPUNIT_ASSERT( all_elements(mBig > T(0)) );
194 CPPUNIT_ASSERT( all_elements(mBig >= T(1)) );
195
196 CPPUNIT_ASSERT( all_elements(mBig < T(1000)) );
197 CPPUNIT_ASSERT( all_elements(mBig <= T(1000)) );
198
199 CPPUNIT_ASSERT( all_elements(T(0) < mBig) ); // possible, I newer would write it
200 CPPUNIT_ASSERT( all_elements(T(1000) > mBig) ); // possible, I newer would write it
201
202 CPPUNIT_ASSERT( all_elements(mOne == T(1)) );
203 CPPUNIT_ASSERT( all_elements(mZero == T(0)) );
204
205 CPPUNIT_ASSERT( all_elements(mBig != T(1000)) );
206
207 // false cases
208 CPPUNIT_ASSERT( !all_elements(mBig < T(0)) );
209 }
210
211
212 template <class T>
213 void
AnyElements()214 TestMatrixEval<T>::AnyElements() {
215 // true cases
216 CPPUNIT_ASSERT( any_elements(mBig > T(0)) );
217 CPPUNIT_ASSERT( any_elements(mBig >= T(1)) );
218
219 CPPUNIT_ASSERT( any_elements(mBig < T(1000)) );
220 CPPUNIT_ASSERT( any_elements(mBig <= T(1000)) );
221
222 CPPUNIT_ASSERT( any_elements(T(2) < m1) ); // possible, I newer would write it
223 CPPUNIT_ASSERT( any_elements(T(2) > m1) ); // possible, I newer would write it
224
225 CPPUNIT_ASSERT( any_elements(mOne == T(1)) );
226 CPPUNIT_ASSERT( any_elements(mZero == T(0)) );
227
228 CPPUNIT_ASSERT( any_elements(mBig != T(1000)) );
229
230 // false cases
231 CPPUNIT_ASSERT( !any_elements(mBig < T(2)) );
232 CPPUNIT_ASSERT( !any_elements(mOne == T(0)) );
233 CPPUNIT_ASSERT( !any_elements(mZero == T(1)) );
234 }
235
236
237 template <class T>
238 void
Eval3()239 TestMatrixEval<T>::Eval3() {
240 matrix_type v;
241 T a(1); // scalar
242
243 // XprMatrix<E1, Rows, Cols> ? Matrix<T2, Rows, Cols> : Matrix<T3, Rows, Cols>
244 v = eval( m1 < mBig, m1, mBig);
245 CPPUNIT_ASSERT( all_elements(v == m1) );
246
247 v = eval( m1 > mBig, m1, mBig);
248 CPPUNIT_ASSERT( all_elements(v == mBig) );
249
250 // XprMatrix<E1, Rows, Cols> ? Matrix<T2, Rows, Cols> : XprMatrix<E3, Rows, Cols>
251 v = eval( m1 < mBig, m1, a*mBig);
252 CPPUNIT_ASSERT( all_elements(v == m1) );
253
254 v = eval( m1 > mBig, m1, a*mBig);
255 CPPUNIT_ASSERT( all_elements(v == mBig) );
256
257 // XprMatrix<E1, Rows, Cols> ? XprMatrix<E2, Rows, Cols> : Matrix<T3, Rows, Cols>
258 v = eval( m1 < mBig, a*m1, mBig);
259 CPPUNIT_ASSERT( all_elements(v == m1) );
260
261 v = eval( m1 > mBig, a*m1, mBig);
262 CPPUNIT_ASSERT( all_elements(v == mBig) );
263
264 // XprMatrix<E1, Rows, Cols> ? XprMatrix<E2, Rows, Cols> : XprMatrix<E3, Rows, Cols>
265 v = eval( m1 < mBig, a*m1, a*mBig);
266 CPPUNIT_ASSERT( all_elements(v == m1) );
267
268 v = eval( m1 > mBig, a*m1, a*mBig);
269 CPPUNIT_ASSERT( all_elements(v == mBig) );
270 }
271
272
273 template <class T>
274 void
EvalPod3()275 TestMatrixEval<T>::EvalPod3() {
276 matrix_type v;
277 T a(1); // scalar
278
279 // XprMatrix<E, Rows, Cols> ? POD1 : POD2
280 v = eval( m1 < mBig, T(0), T(1));
281 CPPUNIT_ASSERT( all_elements(v == T(0)) );
282
283 v = eval( m1 > mBig, T(0), T(1));
284 CPPUNIT_ASSERT( all_elements(v == T(1)) );
285
286 // XprMatrix<E1, Rows, Cols> ? POD : XprMatrix<E3, Rows, Cols>
287 v = eval( m1 < mBig, 1, a*mBig);
288 CPPUNIT_ASSERT( all_elements(v == mOne) );
289
290 v = eval( m1 > mBig, 1, a*mBig);
291 CPPUNIT_ASSERT( all_elements(v == mBig) );
292
293 // XprMatrix<E1, Rows, Cols> ? XprMatrix<E2, Rows, Cols> : POD
294 v = eval( m1 < mBig, a*m1, T(1));
295 CPPUNIT_ASSERT( all_elements(v == m1) );
296
297 v = eval( m1 > mBig, a*m1, T(1));
298 CPPUNIT_ASSERT( all_elements(v == mOne) );
299
300 }
301
302
303 #endif // TVMET_TEST_MATRIX_EVAL_H
304
305 // Local Variables:
306 // mode:C++
307 // End:
308