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: TestVectorEval.h,v 1.2 2006-11-20 20:22:18 opetzold Exp $
22 */
23
24 #ifndef TVMET_TEST_VECTOR_EVAL_H
25 #define TVMET_TEST_VECTOR_EVAL_H
26
27 #include <cppunit/extensions/HelperMacros.h>
28
29 #include <tvmet/Vector.h>
30
31 #include <cassert>
32
33 template <class T>
34 class TestVectorEval : public CppUnit::TestFixture
35 {
36 // basic tests
37 CPPUNIT_TEST_SUITE( TestVectorEval );
38 CPPUNIT_TEST( Greater );
39 CPPUNIT_TEST( Less );
40 CPPUNIT_TEST( GreaterOrEqual );
41 CPPUNIT_TEST( LessOrEqual );
42 CPPUNIT_TEST( Equal );
43 CPPUNIT_TEST( NotEqual );
44 CPPUNIT_TEST( LogicalAnd );
45 CPPUNIT_TEST( LogicalOr );
46
47 // others
48 CPPUNIT_TEST( AllElements );
49 CPPUNIT_TEST( AnyElements );
50 CPPUNIT_TEST( Eval3 );
51 CPPUNIT_TEST( EvalPod3 );
52
53 CPPUNIT_TEST_SUITE_END();
54
55 private:
56 typedef tvmet::Vector<T, 3> vector_type;
57
58 public:
TestVectorEval()59 TestVectorEval()
60 : vOne(1), vZero(0) { }
61
62 public: // cppunit interface
63 /** cppunit hook for fixture set up. */
64 void setUp();
65
66 /** cppunit hook for fixture tear down. */
67 void tearDown();
68
69 protected:
70 void Greater();
71 void Less();
72 void GreaterOrEqual();
73 void LessOrEqual();
74 void Equal();
75 void NotEqual();
76 void LogicalAnd();
77 void LogicalOr();
78
79 void AllElements();
80 void AnyElements();
81 void Eval3();
82 void EvalPod3();
83
84 private:
85 vector_type v1;
86 vector_type vBig; /**< vector bigger than v1 */
87 const vector_type vOne;
88 const vector_type vZero;
89
90 };
91
92 /*****************************************************************************
93 * Implementation Part I (cppunit part)
94 ****************************************************************************/
95
96 template <class T>
setUp()97 void TestVectorEval<T>::setUp () {
98 v1 = 1,2,3;
99 vBig = 10,20,30;
100 }
101
102 template <class T>
tearDown()103 void TestVectorEval<T>::tearDown() { }
104
105 /*****************************************************************************
106 * Implementation Part II
107 * these are elemental - therefore we use std::assert
108 ****************************************************************************/
109
110 /*
111 * on SelfTest, we have the guarantee, that the container holds the
112 * expected values. Now check comparing operation using tvmet's
113 * eval function. This is the basic for all further test since it's
114 * the way we check the correctness. The other way would be element wise
115 * compare as in SelfTest, urgh...
116 */
117 template <class T>
118 void
Greater()119 TestVectorEval<T>::Greater() {
120 // all test are element wise !
121 assert( all_elements(vBig > v1) );
122 }
123
124 template <class T>
125 void
Less()126 TestVectorEval<T>::Less() {
127 // all test are element wise !
128 assert( all_elements(v1 < vBig) );
129 }
130
131 template <class T>
132 void
GreaterOrEqual()133 TestVectorEval<T>::GreaterOrEqual() {
134 // all test are element wise !
135 assert( all_elements(vBig >= v1) );
136 assert( all_elements(v1 >= v1) );
137 assert( all_elements(vBig >= vBig) );
138 assert( all_elements(vOne >= T(1)) );
139 assert( all_elements(vZero>= T(0)) );
140 }
141
142 template <class T>
143 void
LessOrEqual()144 TestVectorEval<T>::LessOrEqual() {
145 // all test are element wise !
146 assert( all_elements(v1 <= vBig) );
147 assert( all_elements(v1 <= v1) );
148 assert( all_elements(vBig <= vBig) );
149 assert( all_elements(vOne <= T(1)) );
150 assert( all_elements(vZero<= T(0)) );
151 }
152
153 template <class T>
154 void
Equal()155 TestVectorEval<T>::Equal() {
156 // all test are element wise !
157 assert( all_elements(v1 == v1) );
158 assert( all_elements(vBig == vBig) );
159 assert( all_elements(vOne == 1) );
160 assert( all_elements(vZero == T(0)) );
161 }
162
163 template <class T>
164 void
NotEqual()165 TestVectorEval<T>::NotEqual() {
166 // all test are element wise !
167 assert( all_elements(v1 != vBig) );
168 }
169
170 template <class T>
171 void
LogicalAnd()172 TestVectorEval<T>::LogicalAnd() {
173 // TODO: implement
174 }
175
176 template <class T>
177 void
LogicalOr()178 TestVectorEval<T>::LogicalOr() {
179 // TODO: implement
180 }
181
182 /*****************************************************************************
183 * Implementation Part III
184 * test on generell and eval functions
185 ****************************************************************************/
186
187 template <class T>
188 void
AllElements()189 TestVectorEval<T>::AllElements() {
190 // true cases
191 CPPUNIT_ASSERT( all_elements(vBig > T(0)) );
192 CPPUNIT_ASSERT( all_elements(vBig >= T(1)) );
193
194 CPPUNIT_ASSERT( all_elements(vBig < T(1000)) );
195 CPPUNIT_ASSERT( all_elements(vBig <= T(1000)) );
196
197 CPPUNIT_ASSERT( all_elements(T(0) < vBig) ); // possible, I newer would write it
198 CPPUNIT_ASSERT( all_elements(T(1000) > vBig) ); // possible, I newer would write it
199
200 CPPUNIT_ASSERT( all_elements(vOne == T(1)) );
201 CPPUNIT_ASSERT( all_elements(vZero == T(0)) );
202
203 CPPUNIT_ASSERT( all_elements(vBig != T(1000)) );
204
205 // false cases
206 CPPUNIT_ASSERT( !all_elements(vBig < T(0)) );
207 }
208
209
210 template <class T>
211 void
AnyElements()212 TestVectorEval<T>::AnyElements() {
213 // true cases
214 CPPUNIT_ASSERT( any_elements(vBig > T(0)) );
215 CPPUNIT_ASSERT( any_elements(vBig >= T(1)) );
216
217 CPPUNIT_ASSERT( any_elements(vBig < T(1000)) );
218 CPPUNIT_ASSERT( any_elements(vBig <= T(1000)) );
219
220 CPPUNIT_ASSERT( any_elements(T(2) < v1) ); // possible, I newer would write it
221 CPPUNIT_ASSERT( any_elements(T(2) > v1) ); // possible, I newer would write it
222
223 CPPUNIT_ASSERT( any_elements(vOne == T(1)) );
224 CPPUNIT_ASSERT( any_elements(vZero == T(0)) );
225
226 CPPUNIT_ASSERT( any_elements(vBig != T(1000)) );
227
228 // false cases
229 CPPUNIT_ASSERT( !any_elements(vBig < T(2)) );
230 CPPUNIT_ASSERT( !any_elements(vOne == T(0)) );
231 CPPUNIT_ASSERT( !any_elements(vZero == T(1)) );
232 }
233
234
235 template <class T>
236 void
Eval3()237 TestVectorEval<T>::Eval3() {
238 vector_type v;
239 T a(1); // scalar
240
241 // XprVector<E1, Sz> ? Vector<T2, Sz> : Vector<T3, Sz>
242 v = eval( v1 < vBig, v1, vBig);
243 CPPUNIT_ASSERT( all_elements(v == v1) );
244
245 v = eval( v1 > vBig, v1, vBig);
246 CPPUNIT_ASSERT( all_elements(v == vBig) );
247
248 // XprVector<E1, Sz> ? Vector<T2, Sz> : XprVector<E3, Sz>
249 v = eval( v1 < vBig, v1, a*vBig);
250 CPPUNIT_ASSERT( all_elements(v == v1) );
251
252 v = eval( v1 > vBig, v1, a*vBig);
253 CPPUNIT_ASSERT( all_elements(v == vBig) );
254
255 // XprVector<E1, Sz> ? XprVector<E2, Sz> : Vector<T3, Sz>
256 v = eval( v1 < vBig, a*v1, vBig);
257 CPPUNIT_ASSERT( all_elements(v == v1) );
258
259 v = eval( v1 > vBig, a*v1, vBig);
260 CPPUNIT_ASSERT( all_elements(v == vBig) );
261
262 // XprVector<E1, Sz> ? XprVector<E2, Sz> : XprVector<E3, Sz>
263 v = eval( v1 < vBig, a*v1, a*vBig);
264 CPPUNIT_ASSERT( all_elements(v == v1) );
265
266 v = eval( v1 > vBig, a*v1, a*vBig);
267 CPPUNIT_ASSERT( all_elements(v == vBig) );
268 }
269
270
271 template <class T>
272 void
EvalPod3()273 TestVectorEval<T>::EvalPod3() {
274 vector_type v;
275 T a(1); // scalar
276
277 // XprVector<E, Sz> ? POD1 : POD2
278 v = eval( v1 < vBig, T(0), T(1));
279 CPPUNIT_ASSERT( all_elements(v == T(0)) );
280
281 v = eval( v1 > vBig, T(0), T(1));
282 CPPUNIT_ASSERT( all_elements(v == T(1)) );
283
284 // XprVector<E1, Sz> ? POD : XprVector<E3, Sz>
285 v = eval( v1 < vBig, 1, a*vBig);
286 CPPUNIT_ASSERT( all_elements(v == vOne) );
287
288 v = eval( v1 > vBig, 1, a*vBig);
289 CPPUNIT_ASSERT( all_elements(v == vBig) );
290
291 // XprVector<E1, Sz> ? XprVector<E2, Sz> : POD
292 v = eval( v1 < vBig, a*v1, T(1));
293 CPPUNIT_ASSERT( all_elements(v == v1) );
294
295 v = eval( v1 > vBig, a*v1, T(1));
296 CPPUNIT_ASSERT( all_elements(v == vOne) );
297 }
298
299
300 #endif // TVMET_TEST_VECTOR_EVAL_H
301
302 // Local Variables:
303 // mode:C++
304 // End:
305