30 #include <cxxtest/TestSuite.h>
32 #include "../WValue.h"
66 const size_t size = 3;
68 TS_ASSERT_EQUALS( value.
size(), size );
76 const size_t size = 3;
78 TS_ASSERT_EQUALS( value[0], 0. );
79 TS_ASSERT_EQUALS( value[1], 0. );
80 TS_ASSERT_EQUALS( value[2], 0. );
82 const double a = 3.14;
84 TS_ASSERT_EQUALS( value[1], a );
92 const size_t size = 3;
94 TS_ASSERT_EQUALS( value[0], 0. );
95 TS_ASSERT_EQUALS( value[1], 0. );
96 TS_ASSERT_EQUALS( value[2], 0. );
104 const size_t size = 3;
105 const double a = 1.2, b = 3.4, c = 5.6;
117 TS_ASSERT_EQUALS( value1 == value2,
true );
121 TS_ASSERT_EQUALS( value1 == value2,
false );
129 const size_t size = 3;
130 const double a = 1.2, b = 3.4, c = 5.6;
142 TS_ASSERT_EQUALS( value1 != value2,
false );
146 TS_ASSERT_EQUALS( value1 != value2,
true );
154 const size_t size = 3;
155 const double a = 1.2, b = 3.4, c = 5.6;
168 TS_ASSERT_EQUALS( value1 == value2,
false );
172 TS_ASSERT_EQUALS( value1 == value2,
true );
178 TS_ASSERT_EQUALS( value2 == value3,
false );
179 TS_ASSERT_EQUALS( value2 == value4,
false );
183 value4 = value3 = value2;
184 TS_ASSERT_EQUALS( value2 == value3,
true );
185 TS_ASSERT_EQUALS( value2 == value4,
true );
186 TS_ASSERT_EQUALS( value3 == value4,
true );
194 const size_t size = 3;
195 const double a = 1.2, b = 3.4, c = 5.6;
208 TS_ASSERT_EQUALS( value1 == value2,
false );
212 TS_ASSERT_DELTA( value1[0], 1. + 2. * a,
delta );
213 TS_ASSERT_DELTA( value1[1], 2. + 2. * b,
delta );
214 TS_ASSERT_DELTA( value1[2], 3. + 2. * c,
delta );
220 TS_ASSERT_EQUALS( value2 == value3,
false );
221 TS_ASSERT_EQUALS( value2 == value4,
false );
225 value4 += value3 += value2;
226 TS_ASSERT_EQUALS( value2 == value3,
true );
227 TS_ASSERT_EQUALS( value2 == value4,
true );
228 TS_ASSERT_EQUALS( value3 == value4,
true );
236 const size_t size = 3;
237 const double a = 1.2, b = 3.4, c = 5.6;
250 TS_ASSERT_EQUALS( value1 == value2,
false );
254 TS_ASSERT_DELTA( value1[0], -1.,
delta );
255 TS_ASSERT_DELTA( value1[1], -2.,
delta );
256 TS_ASSERT_DELTA( value1[2], -3.,
delta );
262 TS_ASSERT_EQUALS( value2 == value3,
false );
263 TS_ASSERT_EQUALS( value2 == value4,
false );
267 value4 -= value3 -= value2;
268 TS_ASSERT_DELTA( value3[0], -value2[0],
delta );
269 TS_ASSERT_DELTA( value3[1], -value2[1],
delta );
270 TS_ASSERT_DELTA( value3[2], -value2[2],
delta );
271 TS_ASSERT_DELTA( value4[0], value2[0],
delta );
272 TS_ASSERT_DELTA( value4[1], value2[1],
delta );
273 TS_ASSERT_DELTA( value4[2], value2[2],
delta );
281 const size_t size = 3;
282 const double a = 1.2, b = 3.4, c = 5.6;
284 const double scalar = 32.32;
292 double expected[] = { 38.784, 109.888, 180.992 };
293 TS_ASSERT_DELTA( value1[0], expected[0],
delta );
294 TS_ASSERT_DELTA( value1[1], expected[1],
delta );
295 TS_ASSERT_DELTA( value1[2], expected[2],
delta );
305 TS_ASSERT_EQUALS( value2 == value1,
false );
309 value2 = value1 *= scalar;
310 TS_ASSERT_DELTA( value1[0], expected[0],
delta );
311 TS_ASSERT_DELTA( value1[1], expected[1],
delta );
312 TS_ASSERT_DELTA( value1[2], expected[2],
delta );
313 TS_ASSERT_DELTA( value2[0], value1[0],
delta );
314 TS_ASSERT_DELTA( value2[1], value1[1],
delta );
315 TS_ASSERT_DELTA( value2[2], value1[2],
delta );
322 const size_t size = 3;
323 const double a = 1.2, b = 3.4, c = 5.6;
337 double expected[] = { 2.64, 18.36, 48.16 };
338 TS_ASSERT_DELTA( value1[0], expected[0],
delta );
339 TS_ASSERT_DELTA( value1[1], expected[1],
delta );
340 TS_ASSERT_DELTA( value1[2], expected[2],
delta );
353 double expected2[] = { 6.072, 102.816, 428.624 };
357 value3 *= value1 *= value2;
358 TS_ASSERT_DELTA( value1[0], expected[0],
delta );
359 TS_ASSERT_DELTA( value1[1], expected[1],
delta );
360 TS_ASSERT_DELTA( value1[2], expected[2],
delta );
361 TS_ASSERT_DELTA( value3[0], expected2[0],
delta );
362 TS_ASSERT_DELTA( value3[1], expected2[1],
delta );
363 TS_ASSERT_DELTA( value3[2], expected2[2],
delta );
371 const size_t size = 3;
372 const double a = 1.2, b = 3.4, c = 5.6;
386 value3 = value1 + value2;
388 TS_ASSERT_DELTA( value3[0], 2 * a + 1,
delta );
389 TS_ASSERT_DELTA( value3[1], 2 * b + 2,
delta );
390 TS_ASSERT_DELTA( value3[2], 2 * c + 3,
delta );
393 TS_ASSERT_EQUALS( value1[0], a );
394 TS_ASSERT_EQUALS( value1[1], b );
395 TS_ASSERT_EQUALS( value1[2], c );
396 TS_ASSERT_EQUALS( value2[0], a + 1 );
397 TS_ASSERT_EQUALS( value2[1], b + 2 );
398 TS_ASSERT_EQUALS( value2[2], c + 3 );
406 const size_t size = 3;
407 const double a = 1.2, b = 3.4, c = 5.6;
421 value3 = value1 - value2;
423 TS_ASSERT_DELTA( value3[0], -1,
delta );
424 TS_ASSERT_DELTA( value3[1], -2,
delta );
425 TS_ASSERT_DELTA( value3[2], -3,
delta );
428 TS_ASSERT_EQUALS( value1[0], a );
429 TS_ASSERT_EQUALS( value1[1], b );
430 TS_ASSERT_EQUALS( value1[2], c );
431 TS_ASSERT_EQUALS( value2[0], a + 1 );
432 TS_ASSERT_EQUALS( value2[1], b + 2 );
433 TS_ASSERT_EQUALS( value2[2], c + 3 );
441 const size_t size = 3;
442 const double a = 1.2, b = 3.4, c = 5.6;
456 value3 = value1 * value2;
458 double expected[] = { 2.64, 18.36, 48.16 };
459 TS_ASSERT_DELTA( value3[0], expected[0],
delta );
460 TS_ASSERT_DELTA( value3[1], expected[1],
delta );
461 TS_ASSERT_DELTA( value3[2], expected[2],
delta );
464 TS_ASSERT_EQUALS( value1[0], a );
465 TS_ASSERT_EQUALS( value1[1], b );
466 TS_ASSERT_EQUALS( value1[2], c );
467 TS_ASSERT_EQUALS( value2[0], a + 1 );
468 TS_ASSERT_EQUALS( value2[1], b + 2 );
469 TS_ASSERT_EQUALS( value2[2], c + 3 );
477 const size_t size = 3;
478 const double a = 1.2, b = 3.4, c = 5.6;
484 TS_ASSERT_DELTA( value1.
norm(), 6.660330322, 1e-7 );
492 const size_t size = 3;
493 const int a = 1, b = 2, c = 3;
499 TS_ASSERT_DELTA( value1.
norm(), 3.74165738677, 1e-7 );
507 const size_t size = 3;
508 const double a = 1.2, b = 3.4, c = 5.6;
522 const size_t size = 3;
523 const double a = 1.2, b = 3.4, c = 5.6;
530 TS_ASSERT( std::abs( value1.
norm() - 1. ) > 1e-9 );
532 TS_ASSERT_DELTA( value1.
norm(), 1.,
delta );
540 const size_t size = 3;
541 const double a = 1.2, b = 3.4, c = 5.6;
549 TS_ASSERT( std::abs( value1.
norm() - 1. ) > 1e-9 );
553 TS_ASSERT( std::abs( value1.
norm() - 1. ) > 1e-9 );
554 TS_ASSERT_EQUALS( value1, valueCopy );
557 TS_ASSERT_DELTA( value2.
norm(), 1.,
delta );
565 const size_t size = 3;
566 const double a = 1.2, b = 3.4, c = 5.6;
569 const double scalar = 32.32;
576 value2 = scalar * value1;
578 double expected[] = { 38.784, 109.888, 180.992 };
579 TS_ASSERT_DELTA( value2[0], expected[0],
delta );
580 TS_ASSERT_DELTA( value2[1], expected[1],
delta );
581 TS_ASSERT_DELTA( value2[2], expected[2],
delta );
589 const size_t size = 3;
590 const double a = 1.2, b = 3.4, c = 5.6;
593 const double scalar = 32.32;
600 value2 = value1 * scalar;
602 double expected[] = { 38.784, 109.888, 180.992 };
603 TS_ASSERT_DELTA( value2[0], expected[0],
delta );
604 TS_ASSERT_DELTA( value2[1], expected[1],
delta );
605 TS_ASSERT_DELTA( value2[2], expected[2],
delta );
613 const size_t size = 3;
614 const double a = 1.2, b = 3.4, c = 5.6;
618 const double scalar = 32.32;
626 value2 = value1 * scalar;
627 value3 = scalar * value1;
629 TS_ASSERT_EQUALS( value2, value3 );
640 std::string expected(
"[1.0000000000000000e+00, 5.0000000000000000e+00]" );
641 std::stringstream ss;
643 TS_ASSERT_EQUALS( ss.str(), expected );
655 TS_ASSERT_EQUALS( val.
mean(), 2.0 );
667 TS_ASSERT_EQUALS( val.
mean(), 2.0 );
671 #endif // WVALUE_TEST_H