25 #ifndef WTENSORBASE_TEST_H
26 #define WTENSORBASE_TEST_H
31 #ifdef WASSERT_AS_CASSERT
32 #define WASSERT_FLAG_CHANGED
33 #undefine WASSERT_AS_CASSERT
39 #include <cxxtest/TestSuite.h>
40 #include "../WTensorBase.h"
41 #include "../WMatrix.h"
42 #include "../WValue.h"
43 #include "../../WException.h"
69 TS_ASSERT_THROWS_NOTHING( T12 t12() );
74 std::size_t ds = T12::dataSize;
75 TS_ASSERT_EQUALS( ds, 2 );
79 for( std::size_t k = 0; k < 2; ++k )
81 TS_ASSERT_EQUALS( t12.m_data[ k ], 0.0 );
85 TS_ASSERT_THROWS_NOTHING( T23 t23() );
88 TS_ASSERT_EQUALS( ds, 9 );
89 for( std::size_t k = 0; k < 9; ++k )
91 TS_ASSERT_EQUALS( t23.m_data[ k ], 0.0f );
94 TS_ASSERT_THROWS_NOTHING( T42 t42() );
97 TS_ASSERT_EQUALS( ds, 16 );
98 for( std::size_t k = 0; k < 16; ++k )
100 TS_ASSERT_EQUALS( t42.m_data[ k ], 0 );
103 TS_ASSERT_THROWS_NOTHING( T63 t63() );
106 TS_ASSERT_EQUALS( ds, 729 );
107 for( std::size_t k = 0; k < 729; ++k )
109 TS_ASSERT_EQUALS( t63.m_data[ k ], 0.0 );
112 TS_ASSERT_THROWS_NOTHING( T00 t00() );
114 TS_ASSERT_EQUALS( t00.m_data, 0 );
139 TS_ASSERT_THROWS_NOTHING( T23 m( t ) );
143 TS_ASSERT_SAME_DATA( &t.m_data[ 0 ], &m.m_data[ 0 ], 9 *
sizeof(
int ) );
150 TS_ASSERT_SAME_DATA( &r.m_data[ 0 ], &t.m_data[ 0 ], 9 *
sizeof(
int ) );
159 t.m_data[ 7 ] = -1.0;
160 t.m_data[ 675 ] = 20.0;
161 t.m_data[ 239 ] = -134.243;
162 t.m_data[ 964 ] = 567.534;
163 t.m_data[ 1001 ] = -5.4276;
164 t.m_data[ 543 ] = 1233.4;
165 t.m_data[ 827 ] = -9878.765;
167 t.m_data[ 1023 ] = -265.63;
168 t.m_data[ 0 ] = 2453.0;
170 TS_ASSERT_THROWS_NOTHING( T54 m( t ) );
173 TS_ASSERT_SAME_DATA( &t.m_data[ 0 ], &m.m_data[ 0 ], 1024 *
sizeof(
double ) );
179 t.m_data[ 2 ] = 3.0f;
180 t.m_data[ 3 ] = 2.0f;
181 t.m_data[ 7 ] = -1.0f;
182 t.m_data[ 16 ] = 200.0f;
183 t.m_data[ 23 ] = -13.4243f;
184 t.m_data[ 19 ] = 5675.34f;
185 t.m_data[ 10 ] = -54276.0f;
186 t.m_data[ 24 ] = 123.34f;
187 t.m_data[ 18 ] = -98787.65f;
189 t.m_data[ 26 ] = -26.563f;
190 t.m_data[ 0 ] = 245.3f;
192 TS_ASSERT_THROWS_NOTHING( T33 m( t ) );
195 TS_ASSERT_SAME_DATA( &t.m_data[ 0 ], &m.m_data[ 0 ], 27 *
sizeof(
float ) );
202 TS_ASSERT_THROWS_NOTHING( T02 m( t ) );
205 TS_ASSERT_EQUALS( m.m_data, t.m_data );
234 TS_ASSERT_THROWS_NOTHING( m.operator = ( t ) );
238 TS_ASSERT_SAME_DATA( &t.m_data[ 0 ], &m.m_data[ 0 ], 9 *
sizeof(
int ) );
246 TS_ASSERT_SAME_DATA( &r.m_data[ 0 ], &t.m_data[ 0 ], 9 *
sizeof(
int ) );
255 t.m_data[ 7 ] = -1.0;
256 t.m_data[ 675 ] = 20.0;
257 t.m_data[ 239 ] = -134.243;
258 t.m_data[ 964 ] = 567.534;
259 t.m_data[ 1001 ] = -5.4276;
260 t.m_data[ 543 ] = 1233.4;
261 t.m_data[ 827 ] = -9878.765;
263 t.m_data[ 1023 ] = -265.63;
264 t.m_data[ 0 ] = 2453.0;
266 TS_ASSERT_THROWS_NOTHING( m.operator = ( t ) );
269 TS_ASSERT_SAME_DATA( &t.m_data[ 0 ], &m.m_data[ 0 ], 1024 *
sizeof(
double ) );
275 t.m_data[ 2 ] = 3.0f;
276 t.m_data[ 3 ] = 2.0f;
277 t.m_data[ 7 ] = -1.0f;
278 t.m_data[ 16 ] = 200.0f;
279 t.m_data[ 23 ] = -13.4243f;
280 t.m_data[ 19 ] = 5675.34f;
281 t.m_data[ 10 ] = -54276.0f;
282 t.m_data[ 24 ] = 123.34f;
283 t.m_data[ 18 ] = -98787.65f;
285 t.m_data[ 26 ] = -26.563f;
286 t.m_data[ 0 ] = 245.3f;
288 TS_ASSERT_THROWS_NOTHING( m.operator = ( t ) );
291 TS_ASSERT_SAME_DATA( &t.m_data[ 0 ], &m.m_data[ 0 ], 27 *
sizeof(
float ) );
299 TS_ASSERT_THROWS_NOTHING( T03 m( t ) );
303 TS_ASSERT_EQUALS( m.m_data, t.m_data );
310 t.m_data[ 2 ] = 3.0f;
311 t.m_data[ 3 ] = 2.0f;
312 t.m_data[ 7 ] = -1.0f;
313 t.m_data[ 16 ] = 200.0f;
314 t.m_data[ 23 ] = -13.4243f;
315 t.m_data[ 19 ] = 5675.34f;
316 t.m_data[ 10 ] = -54276.0f;
317 t.m_data[ 24 ] = 123.34f;
318 t.m_data[ 18 ] = -98787.65f;
320 t.m_data[ 26 ] = -26.563f;
321 t.m_data[ 0 ] = 245.3f;
325 TS_ASSERT_SAME_DATA( &t.m_data[ 0 ], &m.m_data[ 0 ], 27 *
sizeof(
float ) );
326 TS_ASSERT_SAME_DATA( &m.m_data[ 0 ], &u.m_data[ 0 ], 27 *
sizeof(
float ) );
327 TS_ASSERT_SAME_DATA( &u.m_data[ 0 ], &z.m_data[ 0 ], 27 *
sizeof(
float ) );
344 t.m_data[ 26 ] = -4.0;
345 t.m_data[ 4 ] = -564.4;
354 TS_ASSERT_THROWS_NOTHING( t.operator = ( t ) );
358 TS_ASSERT_SAME_DATA( &t.m_data[ 0 ], &m.m_data[ 0 ], 27 *
sizeof(
double ) );
368 TS_ASSERT_THROWS_NOTHING( t.operator = ( t ) );
371 TS_ASSERT_EQUALS( m.m_data, t.m_data );
390 int idx[] = { 0, 1, 2, 3 };
392 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
414 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
420 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
426 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
432 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
435 std::size_t idx2[] = { 0, 1, 2, 3, 8, 54643 };
436 TS_ASSERT_THROWS_NOTHING( t[ idx2 ] );
446 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
455 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
458 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
461 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
463 std::size_t idx2[] = { 0, 1, 2, 3, 8, 54643 };
464 TS_ASSERT_THROWS_NOTHING( t[ idx2 ] );
472 int idx[] = { 0, 1, 1 };
473 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
488 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
493 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
498 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
503 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
505 std::size_t idx2[] = { 0, 1, 1, 3, 8, 54643 };
506 TS_ASSERT_THROWS_NOTHING( t[ idx2 ] );
512 std::size_t idx[] = { 0, 1 };
513 std::size_t* idx2 = NULL;
515 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
516 TS_ASSERT_THROWS_NOTHING( t[ idx2 ] );
535 for( std::size_t k = 0; k < T23::dataSize; ++k )
544 std::size_t idx[] = { 0, 0 };
545 TS_ASSERT_EQUALS( t[ idx ], 0 );
547 TS_ASSERT_EQUALS( t[ idx ], 1 );
549 TS_ASSERT_EQUALS( t[ idx ], 2 );
551 TS_ASSERT_EQUALS( t[ idx ], 5 );
553 TS_ASSERT_EQUALS( t[ idx ], 4 );
555 TS_ASSERT_EQUALS( t[ idx ], 3 );
557 TS_ASSERT_EQUALS( t[ idx ], 6 );
559 TS_ASSERT_EQUALS( t[ idx ], 7 );
561 TS_ASSERT_EQUALS( t[ idx ], 8 );
565 idx[ 0 ] = idx[ 1 ] = 0;
566 TS_ASSERT_EQUALS( w[ idx ], 0 );
568 TS_ASSERT_EQUALS( w[ idx ], 1 );
570 TS_ASSERT_EQUALS( w[ idx ], 2 );
572 TS_ASSERT_EQUALS( w[ idx ], 5 );
574 TS_ASSERT_EQUALS( w[ idx ], 4 );
576 TS_ASSERT_EQUALS( w[ idx ], 3 );
578 TS_ASSERT_EQUALS( w[ idx ], 6 );
580 TS_ASSERT_EQUALS( w[ idx ], 7 );
582 TS_ASSERT_EQUALS( w[ idx ], 8 );
589 for( std::size_t k = 0; k < T34::dataSize; ++k )
603 std::size_t idx[] = { 0, 0, 0 };
604 TS_ASSERT_EQUALS( t[ idx ], 0 );
606 TS_ASSERT_EQUALS( t[ idx ], 8 );
608 TS_ASSERT_EQUALS( t[ idx ], 11 );
610 TS_ASSERT_EQUALS( t[ idx ], 27 );
612 TS_ASSERT_EQUALS( t[ idx ], 23 );
614 TS_ASSERT_EQUALS( t[ idx ], 55 );
616 TS_ASSERT_EQUALS( t[ idx ], 52 );
618 TS_ASSERT_EQUALS( t[ idx ], 60 );
620 TS_ASSERT_EQUALS( t[ idx ], 56 );
628 std::size_t idx[] = { 0, 1 };
629 std::size_t* idx2 = NULL;
631 TS_ASSERT_EQUALS( t[ idx ], 65 );
632 TS_ASSERT_EQUALS( t[ idx2 ], 65 );
651 std::vector< int > idx;
665 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
668 idx.push_back( 456 );
671 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
674 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
693 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
698 std::vector< int > idx;
702 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
705 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
707 idx.push_back( 456 );
708 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
711 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
716 std::vector< int > idx;
730 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
732 idx.push_back( 456 );
733 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
736 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
741 std::vector< int > idx;
743 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
746 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
749 TS_ASSERT_THROWS_NOTHING( w[ idx ] );
774 std::size_t idx[] = { 4 };
777 TS_ASSERT( !( t == m ) );
778 TS_ASSERT( !( m == t ) );
792 TS_ASSERT( !( t == m ) );
793 TS_ASSERT( !( m == t ) );
806 TS_ASSERT( ct == cm );
807 TS_ASSERT( cm == ct );
808 TS_ASSERT( ct == ct );
809 TS_ASSERT( cm == cm );
814 std::size_t idx[] = { 0, 0, 0 };
828 TS_ASSERT( !( t == m ) );
829 TS_ASSERT( !( m == t ) );
844 TS_ASSERT( !( t == m ) );
845 TS_ASSERT( !( m == t ) );
850 t.m_data[ 1 ] = -65464;
852 t.m_data[ 3 ] = 3276;
853 t.m_data[ 4 ] = -3276;
856 t.m_data[ 7 ] = -239;
859 m.m_data[ 1 ] = 65464;
861 m.m_data[ 3 ] = -3276;
862 m.m_data[ 4 ] = 3276;
867 TS_ASSERT( !( t == m ) );
868 TS_ASSERT( !( m == t ) );
885 TS_ASSERT( !( t == m ) );
886 TS_ASSERT( !( m == t ) );
911 TS_ASSERT( !( t != m ) );
912 TS_ASSERT( !( m != t ) );
915 TS_ASSERT( !( t != t ) );
916 TS_ASSERT( !( m != m ) );
919 t.m_data[ 23 ] = -23467;
923 TS_ASSERT( !( t != t ) );
924 TS_ASSERT( !( m != m ) );
927 TS_ASSERT( !( t != m ) );
928 TS_ASSERT( !( m != t ) );
933 TS_ASSERT( !( t != t ) );
934 TS_ASSERT( !( m != m ) );
937 TS_ASSERT( !( t != m ) );
938 TS_ASSERT( !( m != t ) );
939 TS_ASSERT( !( t != t ) );
940 TS_ASSERT( !( m != m ) );
945 TS_ASSERT( !( t != t ) );
946 TS_ASSERT( !( m != m ) );
950 TS_ASSERT( !( ct != cm ) );
951 TS_ASSERT( !( cm != ct ) );
952 TS_ASSERT( !( ct != ct ) );
953 TS_ASSERT( !( cm != cm ) );
958 TS_ASSERT( !( t != m ) );
959 TS_ASSERT( !( m != t ) );
960 TS_ASSERT( !( t != t ) );
961 TS_ASSERT( !( m != m ) );
967 TS_ASSERT( !( t != t ) );
968 TS_ASSERT( !( m != m ) );
972 TS_ASSERT( !( t != m ) );
973 TS_ASSERT( !( m != t ) );
974 TS_ASSERT( !( t != t ) );
975 TS_ASSERT( !( m != m ) );
1001 TS_ASSERT_THROWS_NOTHING( T12 t12() );
1006 std::size_t ds = T12::dataSize;
1007 TS_ASSERT_EQUALS( ds, 2 );
1011 for( std::size_t k = 0; k < 2; ++k )
1013 TS_ASSERT_EQUALS( t12.m_data[ k ], 0.0 );
1018 TS_ASSERT_THROWS_NOTHING( T23 t23() );
1021 TS_ASSERT_EQUALS( ds, 6 );
1022 for( std::size_t k = 0; k < 6; ++k )
1024 TS_ASSERT_EQUALS( t23.m_data[ k ], 0.0f );
1027 TS_ASSERT_THROWS_NOTHING( T42 t42() );
1030 TS_ASSERT_EQUALS( ds, 5 );
1031 for( std::size_t k = 0; k < 5; ++k )
1033 TS_ASSERT_EQUALS( t42.m_data[ k ], 0 );
1036 TS_ASSERT_THROWS_NOTHING( T63 t63() );
1039 TS_ASSERT_EQUALS( ds, 28 );
1040 for( std::size_t k = 0; k < 28; ++k )
1042 TS_ASSERT_EQUALS( t63.m_data[ k ], 0.0 );
1045 TS_ASSERT_THROWS_NOTHING( T00 t00() );
1047 TS_ASSERT_EQUALS( t00.m_data, 0 );
1070 t.m_data[ 5 ] = -25;
1073 TS_ASSERT_THROWS_NOTHING( T23 m( t ) );
1077 TS_ASSERT_SAME_DATA( &t.m_data[ 0 ], &m.m_data[ 0 ], 6 *
sizeof(
int ) );
1084 TS_ASSERT_SAME_DATA( &r.m_data[ 0 ], &t.m_data[ 0 ], 6 *
sizeof(
int ) );
1091 t.m_data[ 2 ] = 3.0;
1092 t.m_data[ 3 ] = 2.4;
1093 t.m_data[ 7 ] = -1.0;
1094 t.m_data[ 33 ] = 20.0;
1095 t.m_data[ 21 ] = -134.243;
1096 t.m_data[ 54 ] = 567.534;
1097 t.m_data[ 48 ] = -5.4276;
1098 t.m_data[ 34 ] = 1233.4;
1099 t.m_data[ 27 ] = -9878.765;
1101 t.m_data[ 55 ] = -265.63;
1102 t.m_data[ 0 ] = 2453.0;
1104 TS_ASSERT_THROWS_NOTHING( T54 m( t ) );
1107 TS_ASSERT_SAME_DATA( &t.m_data[ 0 ], &m.m_data[ 0 ], 56 *
sizeof(
double ) );
1113 t.m_data[ 2 ] = 3.0f;
1114 t.m_data[ 3 ] = 2.0f;
1115 t.m_data[ 7 ] = -1.0f;
1116 t.m_data[ 1 ] = -13.4243f;
1117 t.m_data[ 5 ] = 5675.34f;
1118 t.m_data[ 6 ] = -54276.0f;
1119 t.m_data[ 4 ] = 123.34f;
1120 t.m_data[ 8 ] = -98787.65f;
1122 t.m_data[ 9 ] = -26.563f;
1123 t.m_data[ 0 ] = 245.3f;
1125 TS_ASSERT_THROWS_NOTHING( T33 m( t ) );
1128 TS_ASSERT_SAME_DATA( &t.m_data[ 0 ], &m.m_data[ 0 ], 10 *
sizeof(
float ) );
1135 t.m_data[ 2 ] = 3.0f;
1136 t.m_data[ 3 ] = 2.0f;
1137 t.m_data[ 7 ] = -1.0f;
1138 t.m_data[ 1 ] = -13.4243f;
1139 t.m_data[ 5 ] = 5675.34f;
1140 t.m_data[ 6 ] = -54276.0f;
1141 t.m_data[ 4 ] = 123.34f;
1142 t.m_data[ 8 ] = -98787.65f;
1144 t.m_data[ 9 ] = -26.563f;
1145 t.m_data[ 0 ] = 245.3f;
1149 TS_ASSERT_SAME_DATA( &t.m_data[ 0 ], &m.m_data[ 0 ], 10 *
sizeof(
float ) );
1150 TS_ASSERT_SAME_DATA( &m.m_data[ 0 ], &u.m_data[ 0 ], 10 *
sizeof(
float ) );
1151 TS_ASSERT_SAME_DATA( &u.m_data[ 0 ], &z.m_data[ 0 ], 10 *
sizeof(
float ) );
1158 TS_ASSERT_THROWS_NOTHING( T02 m( t ) );
1161 TS_ASSERT_EQUALS( m.m_data, t.m_data );
1188 t.m_data[ 5 ] = -25;
1192 TS_ASSERT_THROWS_NOTHING( m.operator = ( t ) );
1196 TS_ASSERT_SAME_DATA( &t.m_data[ 0 ], &m.m_data[ 0 ], 6 *
sizeof(
int ) );
1204 TS_ASSERT_SAME_DATA( &r.m_data[ 0 ], &t.m_data[ 0 ], 6 *
sizeof(
int ) );
1211 t.m_data[ 2 ] = 3.0;
1212 t.m_data[ 3 ] = 2.4;
1213 t.m_data[ 7 ] = -1.0;
1214 t.m_data[ 33 ] = 20.0;
1215 t.m_data[ 21 ] = -134.243;
1216 t.m_data[ 54 ] = 567.534;
1217 t.m_data[ 48 ] = -5.4276;
1218 t.m_data[ 34 ] = 1233.4;
1219 t.m_data[ 27 ] = -9878.765;
1221 t.m_data[ 55 ] = -265.63;
1222 t.m_data[ 0 ] = 2453.0;
1224 TS_ASSERT_THROWS_NOTHING( m.operator = ( t ) );
1227 TS_ASSERT_SAME_DATA( &t.m_data[ 0 ], &m.m_data[ 0 ], 56 *
sizeof(
double ) );
1233 t.m_data[ 2 ] = 3.0f;
1234 t.m_data[ 3 ] = 2.0f;
1235 t.m_data[ 7 ] = -1.0f;
1236 t.m_data[ 1 ] = -13.4243f;
1237 t.m_data[ 5 ] = 5675.34f;
1238 t.m_data[ 6 ] = -54276.0f;
1239 t.m_data[ 4 ] = 123.34f;
1240 t.m_data[ 8 ] = -98787.65f;
1242 t.m_data[ 9 ] = -26.563f;
1243 t.m_data[ 0 ] = 245.3f;
1245 TS_ASSERT_THROWS_NOTHING( m.operator = ( t ) );
1248 TS_ASSERT_SAME_DATA( &t.m_data[ 0 ], &m.m_data[ 0 ], 10 *
sizeof(
float ) );
1256 TS_ASSERT_THROWS_NOTHING( T03 m( t ) );
1260 TS_ASSERT_EQUALS( m.m_data, t.m_data );
1277 t.m_data[ 9 ] = -4.0;
1278 t.m_data[ 4 ] = -564.4;
1287 TS_ASSERT_THROWS_NOTHING( t.operator = ( t ) );
1291 TS_ASSERT_SAME_DATA( &t.m_data[ 0 ], &m.m_data[ 0 ], 10 *
sizeof(
double ) );
1301 TS_ASSERT_THROWS_NOTHING( t.operator = ( t ) );
1304 TS_ASSERT_EQUALS( m.m_data, t.m_data );
1324 int idx[] = { 0, 1, 2, 3 };
1326 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
1348 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
1354 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
1360 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
1366 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
1369 std::size_t idx2[] = { 0, 1, 2, 3, 8, 54643 };
1370 TS_ASSERT_THROWS_NOTHING( t[ idx2 ] );
1380 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
1389 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
1392 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
1395 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
1397 std::size_t idx2[] = { 0, 1, 2, 3, 8, 54643 };
1398 TS_ASSERT_THROWS_NOTHING( t[ idx2 ] );
1406 int idx[] = { 0, 1, 1 };
1407 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
1422 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
1427 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
1432 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
1437 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
1439 std::size_t idx2[] = { 0, 1, 1, 3, 8, 54643 };
1440 TS_ASSERT_THROWS_NOTHING( t[ idx2 ] );
1446 std::size_t idx[] = { 0, 1 };
1447 std::size_t* idx2 = NULL;
1449 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
1450 TS_ASSERT_THROWS_NOTHING( t[ idx2 ] );
1468 for( std::size_t k = 0; k < T23::dataSize; ++k )
1477 std::size_t idx[] = { 0, 0 };
1478 TS_ASSERT_EQUALS( t[ idx ], 0 );
1480 TS_ASSERT_EQUALS( t[ idx ], 1 );
1482 TS_ASSERT_EQUALS( t[ idx ], 2 );
1484 TS_ASSERT_EQUALS( t[ idx ], 4 );
1486 TS_ASSERT_EQUALS( t[ idx ], 3 );
1488 TS_ASSERT_EQUALS( t[ idx ], 1 );
1490 TS_ASSERT_EQUALS( t[ idx ], 2 );
1492 TS_ASSERT_EQUALS( t[ idx ], 4 );
1494 TS_ASSERT_EQUALS( t[ idx ], 5 );
1498 idx[ 0 ] = idx[ 1 ] = 0;
1499 TS_ASSERT_EQUALS( w[ idx ], 0 );
1501 TS_ASSERT_EQUALS( w[ idx ], 1 );
1503 TS_ASSERT_EQUALS( w[ idx ], 2 );
1505 TS_ASSERT_EQUALS( w[ idx ], 4 );
1507 TS_ASSERT_EQUALS( w[ idx ], 3 );
1509 TS_ASSERT_EQUALS( w[ idx ], 1 );
1511 TS_ASSERT_EQUALS( w[ idx ], 2 );
1513 TS_ASSERT_EQUALS( w[ idx ], 4 );
1515 TS_ASSERT_EQUALS( w[ idx ], 5 );
1522 for( std::size_t k = 0; k < T34::dataSize; ++k )
1536 std::size_t idx[] = { 0, 0, 0 };
1537 TS_ASSERT_EQUALS( t[ idx ], 0 );
1539 TS_ASSERT_EQUALS( t[ idx ], 2 );
1541 TS_ASSERT_EQUALS( t[ idx ], 8 );
1543 TS_ASSERT_EQUALS( t[ idx ], 14 );
1545 TS_ASSERT_EQUALS( t[ idx ], 12 );
1547 TS_ASSERT_EQUALS( t[ idx ], 15 );
1549 TS_ASSERT_EQUALS( t[ idx ], 6 );
1551 TS_ASSERT_EQUALS( t[ idx ], 9 );
1553 TS_ASSERT_EQUALS( t[ idx ], 8 );
1568 for( std::size_t k = 0; k < T34::dataSize; ++k )
1574 std::size_t idx1[ 3 ][ 3 ] = { { 0, 0, 1 },
1578 std::size_t idx2[ 6 ][ 3 ] = { { 0, 1, 2 },
1585 std::size_t idx3[ 3 ][ 3 ] = { { 0, 0, 3 },
1589 std::size_t idx4[ 6 ][ 3 ] = { { 0, 3, 2 },
1597 TS_ASSERT_EQUALS( t[ idx1[ 0 ] ], t[ idx1[ 1 ] ] );
1598 TS_ASSERT_EQUALS( t[ idx1[ 1 ] ], t[ idx1[ 2 ] ] );
1600 TS_ASSERT_EQUALS( t[ idx2[ 0 ] ], t[ idx2[ 1 ] ] );
1601 TS_ASSERT_EQUALS( t[ idx2[ 1 ] ], t[ idx2[ 2 ] ] );
1602 TS_ASSERT_EQUALS( t[ idx2[ 2 ] ], t[ idx2[ 3 ] ] );
1603 TS_ASSERT_EQUALS( t[ idx2[ 3 ] ], t[ idx2[ 4 ] ] );
1604 TS_ASSERT_EQUALS( t[ idx2[ 4 ] ], t[ idx2[ 5 ] ] );
1606 TS_ASSERT_EQUALS( t[ idx3[ 0 ] ], t[ idx3[ 1 ] ] );
1607 TS_ASSERT_EQUALS( t[ idx3[ 1 ] ], t[ idx3[ 2 ] ] );
1609 TS_ASSERT_EQUALS( t[ idx4[ 0 ] ], t[ idx4[ 1 ] ] );
1610 TS_ASSERT_EQUALS( t[ idx4[ 1 ] ], t[ idx4[ 2 ] ] );
1611 TS_ASSERT_EQUALS( t[ idx4[ 2 ] ], t[ idx4[ 3 ] ] );
1612 TS_ASSERT_EQUALS( t[ idx4[ 3 ] ], t[ idx4[ 4 ] ] );
1613 TS_ASSERT_EQUALS( t[ idx4[ 4 ] ], t[ idx4[ 5 ] ] );
1616 TS_ASSERT_DIFFERS( t[ idx1[ 0 ] ], t[ idx2[ 0 ] ] );
1617 TS_ASSERT_DIFFERS( t[ idx1[ 1 ] ], t[ idx2[ 5 ] ] );
1618 TS_ASSERT_DIFFERS( t[ idx2[ 0 ] ], t[ idx4[ 4 ] ] );
1619 TS_ASSERT_DIFFERS( t[ idx2[ 0 ] ], t[ idx3[ 2 ] ] );
1620 TS_ASSERT_DIFFERS( t[ idx2[ 3 ] ], t[ idx3[ 1 ] ] );
1621 TS_ASSERT_DIFFERS( t[ idx3[ 0 ] ], t[ idx2[ 0 ] ] );
1622 TS_ASSERT_DIFFERS( t[ idx3[ 1 ] ], t[ idx4[ 3 ] ] );
1623 TS_ASSERT_DIFFERS( t[ idx3[ 0 ] ], t[ idx1[ 2 ] ] );
1624 TS_ASSERT_DIFFERS( t[ idx4[ 2 ] ], t[ idx1[ 0 ] ] );
1625 TS_ASSERT_DIFFERS( t[ idx4[ 5 ] ], t[ idx3[ 2 ] ] );
1642 std::vector< int > idx;
1656 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
1659 idx.push_back( 456 );
1662 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
1664 idx.push_back( -1 );
1665 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
1684 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
1689 std::vector< int > idx;
1693 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
1696 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
1698 idx.push_back( 456 );
1699 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
1701 idx.push_back( -1 );
1702 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
1707 std::vector< int > idx;
1721 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
1723 idx.push_back( 456 );
1724 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
1726 idx.push_back( -1 );
1727 TS_ASSERT_THROWS_NOTHING( t[ idx ] );
1730 TS_ASSERT_THROWS_NOTHING( w[ idx ] );
1747 TS_ASSERT( t == m );
1748 TS_ASSERT( m == t );
1751 TS_ASSERT( t == t );
1752 TS_ASSERT( m == m );
1755 std::size_t idx[] = { 4 };
1758 TS_ASSERT( !( t == m ) );
1759 TS_ASSERT( !( m == t ) );
1760 TS_ASSERT( t == t );
1761 TS_ASSERT( m == m );
1765 TS_ASSERT( t == m );
1766 TS_ASSERT( m == t );
1767 TS_ASSERT( t == t );
1768 TS_ASSERT( m == m );
1771 m[ idx ] = 543543.0;
1773 TS_ASSERT( !( t == m ) );
1774 TS_ASSERT( !( m == t ) );
1775 TS_ASSERT( t == t );
1776 TS_ASSERT( m == m );
1780 TS_ASSERT( t == m );
1781 TS_ASSERT( m == t );
1782 TS_ASSERT( t == t );
1783 TS_ASSERT( m == m );
1787 TS_ASSERT( ct == cm );
1788 TS_ASSERT( cm == ct );
1789 TS_ASSERT( ct == ct );
1790 TS_ASSERT( cm == cm );
1795 std::size_t idx[] = { 0, 0, 0 };
1798 TS_ASSERT( t == m );
1799 TS_ASSERT( m == t );
1802 TS_ASSERT( t == t );
1803 TS_ASSERT( m == m );
1809 TS_ASSERT( !( t == m ) );
1810 TS_ASSERT( !( m == t ) );
1811 TS_ASSERT( t == t );
1812 TS_ASSERT( m == m );
1816 TS_ASSERT( t == m );
1817 TS_ASSERT( m == t );
1818 TS_ASSERT( t == t );
1819 TS_ASSERT( m == m );
1825 TS_ASSERT( !( t == m ) );
1826 TS_ASSERT( !( m == t ) );
1827 TS_ASSERT( t == t );
1828 TS_ASSERT( m == m );
1831 t.m_data[ 1 ] = -65464;
1833 t.m_data[ 3 ] = 3276;
1836 m.m_data[ 1 ] = 65464;
1837 m.m_data[ 2 ] = -89;
1838 m.m_data[ 3 ] = -3276;
1840 TS_ASSERT( !( t == m ) );
1841 TS_ASSERT( !( m == t ) );
1842 TS_ASSERT( t == t );
1843 TS_ASSERT( m == m );
1849 TS_ASSERT( t == m );
1850 TS_ASSERT( m == t );
1853 TS_ASSERT( t == t );
1854 TS_ASSERT( m == m );
1858 TS_ASSERT( !( t == m ) );
1859 TS_ASSERT( !( m == t ) );
1860 TS_ASSERT( t == t );
1861 TS_ASSERT( m == m );
1865 TS_ASSERT( t == m );
1866 TS_ASSERT( m == t );
1867 TS_ASSERT( t == t );
1868 TS_ASSERT( m == m );
1884 TS_ASSERT( !( t != m ) );
1885 TS_ASSERT( !( m != t ) );
1888 TS_ASSERT( !( t != t ) );
1889 TS_ASSERT( !( m != m ) );
1892 t.m_data[ 4 ] = -23467;
1894 TS_ASSERT( t != m );
1895 TS_ASSERT( m != t );
1896 TS_ASSERT( !( t != t ) );
1897 TS_ASSERT( !( m != m ) );
1900 TS_ASSERT( !( t != m ) );
1901 TS_ASSERT( !( m != t ) );
1904 TS_ASSERT( t != m );
1905 TS_ASSERT( m != t );
1906 TS_ASSERT( !( t != t ) );
1907 TS_ASSERT( !( m != m ) );
1910 TS_ASSERT( !( t != m ) );
1911 TS_ASSERT( !( m != t ) );
1912 TS_ASSERT( !( t != t ) );
1913 TS_ASSERT( !( m != m ) );
1916 TS_ASSERT( t != m );
1917 TS_ASSERT( m != t );
1918 TS_ASSERT( !( t != t ) );
1919 TS_ASSERT( !( m != m ) );
1923 TS_ASSERT( !( ct != cm ) );
1924 TS_ASSERT( !( cm != ct ) );
1925 TS_ASSERT( !( ct != ct ) );
1926 TS_ASSERT( !( cm != cm ) );
1932 TS_ASSERT( !( t != m ) );
1933 TS_ASSERT( !( m != t ) );
1934 TS_ASSERT( !( t != t ) );
1935 TS_ASSERT( !( m != m ) );
1939 TS_ASSERT( t != m );
1940 TS_ASSERT( m != t );
1941 TS_ASSERT( !( t != t ) );
1942 TS_ASSERT( !( m != m ) );
1946 TS_ASSERT( !( t != m ) );
1947 TS_ASSERT( !( m != t ) );
1948 TS_ASSERT( !( t != t ) );
1949 TS_ASSERT( !( m != m ) );
1973 TS_ASSERT_THROWS_NOTHING( f( 0, 0, 0 ) );
1974 TS_ASSERT_THROWS_NOTHING( f( 1, 0, 0 ) );
1975 TS_ASSERT_THROWS_NOTHING( f( 2, 2, 2 ) );
1976 TS_ASSERT_THROWS_NOTHING( f( 1, 1, 1 ) );
1977 TS_ASSERT_THROWS_NOTHING( f( 1, 0, 2 ) );
1978 TS_ASSERT_THROWS_NOTHING( f( 0, 2, 0 ) );
1982 TS_ASSERT_THROWS( f( 0, 0, 3 ),
WException );
1983 TS_ASSERT_THROWS( f( 0, 654465, 0 ),
WException );
1984 TS_ASSERT_THROWS( f( 4, 0, 0 ),
WException );
1985 TS_ASSERT_THROWS( f( 0, 0, 45 ),
WException );
1986 TS_ASSERT_THROWS( f( 0, 64, 0 ),
WException );
1987 TS_ASSERT_THROWS( f( 792, 981, 5645 ),
WException );
1992 TS_ASSERT_THROWS_NOTHING( f( 0 ) );
1993 TS_ASSERT_THROWS_NOTHING( f( 1 ) );
1994 TS_ASSERT_THROWS_NOTHING( f( 2 ) );
1995 TS_ASSERT_THROWS_NOTHING( f( 3 ) );
1996 TS_ASSERT_THROWS_NOTHING( f( 4 ) );
2008 TS_ASSERT_THROWS_NOTHING( f( 0, 0 ) );
2009 TS_ASSERT_THROWS_NOTHING( f( 3, 0 ) );
2010 TS_ASSERT_THROWS_NOTHING( f( 2, 3 ) );
2011 TS_ASSERT_THROWS_NOTHING( f( 3, 3 ) );
2012 TS_ASSERT_THROWS_NOTHING( f( 0, 1 ) );
2030 for( std::size_t k = 0; k < 64; ++k )
2035 TS_ASSERT_EQUALS( f( 0, 0, 0, 0, 0, 0 ), 0 );
2036 TS_ASSERT_EQUALS( f( 0, 0, 0, 1, 0, 1 ), 5 );
2037 TS_ASSERT_EQUALS( f( 1, 1, 1, 0, 0, 0 ), 56 );
2038 TS_ASSERT_EQUALS( f( 0, 1, 0, 0, 0, 1 ), 17 );
2039 TS_ASSERT_EQUALS( f( 0, 0, 1, 0, 1, 0 ), 10 );
2040 TS_ASSERT_EQUALS( f( 1, 0, 1, 0, 0, 1 ), 41 );
2041 TS_ASSERT_EQUALS( f( 1, 1, 1, 1, 1, 1 ), 63 );
2044 TS_ASSERT_EQUALS( w( 0, 0, 0, 0, 0, 0 ), 0 );
2045 TS_ASSERT_EQUALS( w( 0, 0, 0, 1, 0, 1 ), 5 );
2046 TS_ASSERT_EQUALS( w( 1, 1, 1, 0, 0, 0 ), 56 );
2047 TS_ASSERT_EQUALS( w( 0, 1, 0, 0, 0, 1 ), 17 );
2048 TS_ASSERT_EQUALS( w( 0, 0, 1, 0, 1, 0 ), 10 );
2049 TS_ASSERT_EQUALS( w( 1, 0, 1, 0, 0, 1 ), 41 );
2050 TS_ASSERT_EQUALS( w( 1, 1, 1, 1, 1, 1 ), 63 );
2064 for( std::size_t k = 0; k < 70; ++k )
2069 std::size_t idx[ 8 ][ 6 ] = { { 0, 1, 2, 4 },
2078 TS_ASSERT( f( 0, 1, 2, 4 ) == f[ idx[ 0 ] ] );
2079 TS_ASSERT( f( 1, 0, 2, 4 ) == f[ idx[ 0 ] ] );
2080 TS_ASSERT( f( 4, 1, 0, 2 ) == f[ idx[ 0 ] ] );
2081 TS_ASSERT( f( 0, 3, 2, 4 ) == f[ idx[ 1 ] ] );
2082 TS_ASSERT( f( 0, 4, 4, 4 ) == f[ idx[ 2 ] ] );
2083 TS_ASSERT( f( 4, 0, 4, 4 ) == f[ idx[ 2 ] ] );
2084 TS_ASSERT( f( 0, 0, 0, 0 ) == f[ idx[ 3 ] ] );
2085 TS_ASSERT( f( 0, 1, 3, 4 ) == f[ idx[ 4 ] ] );
2086 TS_ASSERT( f( 2, 2, 2, 2 ) == f[ idx[ 5 ] ] );
2087 TS_ASSERT( f( 4, 4, 4, 4 ) == f[ idx[ 6 ] ] );
2088 TS_ASSERT( f( 2, 2, 3, 0 ) == f[ idx[ 7 ] ] );
2089 TS_ASSERT( f( 2, 3, 0, 2 ) == f[ idx[ 7 ] ] );
2092 TS_ASSERT( w( 0, 1, 2, 4 ) == w[ idx[ 0 ] ] );
2093 TS_ASSERT( w( 1, 0, 2, 4 ) == w[ idx[ 0 ] ] );
2094 TS_ASSERT( w( 4, 1, 0, 2 ) == w[ idx[ 0 ] ] );
2095 TS_ASSERT( w( 0, 3, 2, 4 ) == w[ idx[ 1 ] ] );
2096 TS_ASSERT( w( 0, 4, 4, 4 ) == w[ idx[ 2 ] ] );
2097 TS_ASSERT( w( 4, 0, 4, 4 ) == w[ idx[ 2 ] ] );
2098 TS_ASSERT( w( 0, 0, 0, 0 ) == w[ idx[ 3 ] ] );
2099 TS_ASSERT( w( 0, 1, 3, 4 ) == w[ idx[ 4 ] ] );
2100 TS_ASSERT( w( 2, 2, 2, 2 ) == w[ idx[ 5 ] ] );
2101 TS_ASSERT( w( 4, 4, 4, 4 ) == w[ idx[ 6 ] ] );
2102 TS_ASSERT( w( 2, 2, 3, 0 ) == w[ idx[ 7 ] ] );
2103 TS_ASSERT( w( 2, 3, 0, 2 ) == w[ idx[ 7 ] ] );
2129 std::size_t idx[ 2 ] = { 0, 3 };
2138 TS_ASSERT_THROWS_NOTHING( T24 t = T24( s ) );
2141 TS_ASSERT_EQUALS( t[ idx ], 3.0 );
2146 TS_ASSERT_EQUALS( t[ idx ], -2.0 );
2150 TS_ASSERT_EQUALS( t[ idx ], 0.0 );
2156 std::size_t idx[ 1 ] = { 0 };
2164 TS_ASSERT_THROWS_NOTHING( T14 t = T14( s ) );
2167 TS_ASSERT_EQUALS( t[ idx ], 3.0 );
2169 TS_ASSERT_EQUALS( t[ idx ], -2.0 );
2171 TS_ASSERT_EQUALS( t[ idx ], 0.0 );
2173 TS_ASSERT_EQUALS( t[ idx ], 0.0 );
2179 std::size_t* idx = NULL;
2182 TS_ASSERT_THROWS_NOTHING( T04( s ) );
2185 TS_ASSERT_EQUALS( t[ idx ], 5.0 );
2206 std::size_t idx[ 2 ] = { 0, 3 };
2215 TS_ASSERT_THROWS_NOTHING( t = s );
2218 TS_ASSERT_EQUALS( t[ idx ], 3.0 );
2223 TS_ASSERT_EQUALS( t[ idx ], -2.0 );
2227 TS_ASSERT_EQUALS( t[ idx ], 0.0 );
2234 std::size_t idx[ 1 ] = { 0 };
2242 TS_ASSERT_THROWS_NOTHING( t = s );
2245 TS_ASSERT_EQUALS( t[ idx ], 3.0 );
2247 TS_ASSERT_EQUALS( t[ idx ], -2.0 );
2249 TS_ASSERT_EQUALS( t[ idx ], 0.0 );
2251 TS_ASSERT_EQUALS( t[ idx ], 0.0 );
2258 std::size_t* idx = NULL;
2261 TS_ASSERT_THROWS_NOTHING( t = s );
2264 TS_ASSERT_EQUALS( t[ idx ], 5.0 );
2283 TS_ASSERT_EQUALS( d, 3.0 );
2287 TS_ASSERT_EQUALS( f, 3.0f );
2291 TS_ASSERT_EQUALS( i, 3 );
2301 TS_ASSERT_EQUALS( d, 3.0 );
2305 TS_ASSERT_EQUALS( f, 3.0f );
2309 TS_ASSERT_EQUALS( i, 3 );
2326 TS_ASSERT_EQUALS( v.
size(), 5 );
2328 TS_ASSERT_EQUALS( v[ 0 ], -9.765 );
2329 TS_ASSERT_EQUALS( v[ 1 ], 154.06 );
2330 TS_ASSERT_EQUALS( v[ 2 ], 0.0 );
2331 TS_ASSERT_EQUALS( v[ 3 ], 0.0 );
2332 TS_ASSERT_EQUALS( v[ 4 ], -57.0 );
2342 TS_ASSERT_EQUALS( v.
size(), 5 );
2344 TS_ASSERT_EQUALS( v[ 0 ], -9.765 );
2345 TS_ASSERT_EQUALS( v[ 1 ], 154.06 );
2346 TS_ASSERT_EQUALS( v[ 2 ], 0.0 );
2347 TS_ASSERT_EQUALS( v[ 3 ], 0.0 );
2348 TS_ASSERT_EQUALS( v[ 4 ], -57.0 );
2368 for( std::size_t i = 0; i < 3; ++i )
2370 for( std::size_t j = 0; j < 3; ++j )
2372 TS_ASSERT_EQUALS( m( i, j ), t( i, j ) );
2387 for( std::size_t i = 0; i < 3; ++i )
2389 for( std::size_t j = 0; j < 3; ++j )
2391 TS_ASSERT_EQUALS( m( i, j ), t( i, j ) );
2412 std::vector< std::size_t > is( 3, 0 );
2413 std::vector< std::size_t > shouldBe( 3, 0 );
2416 positionIterateOneStep< 3, 3 >( is );
2417 TS_ASSERT_SAME_DATA( &is[ 0 ], &shouldBe[ 0 ], 3 *
sizeof( std::size_t ) );
2419 positionIterateOneStep< 3, 3 >( is );
2420 positionIterateOneStep< 3, 3 >( is );
2424 TS_ASSERT_SAME_DATA( &is[ 0 ], &shouldBe[ 0 ], 3 *
sizeof( std::size_t ) );
2427 positionIterateOneStep< 3, 2 >( is );
2428 positionIterateOneStep< 3, 2 >( is );
2432 TS_ASSERT_SAME_DATA( &is[ 0 ], &shouldBe[ 0 ], 3 *
sizeof( std::size_t ) );
2434 positionIterateOneStep< 3, 2 >( is );
2437 TS_ASSERT_SAME_DATA( &is[ 0 ], &shouldBe[ 0 ], 3 *
sizeof( std::size_t ) );
2445 std::vector< std::size_t > v( 3, 0 );
2449 for( std::size_t k = 0; k < numIter; ++k )
2451 positionIterateSortedOneStep< 3, 3 >( v );
2452 TS_ASSERT( v[ 0 ] <= v[ 1 ] );
2453 TS_ASSERT( v[ 1 ] <= v[ 2 ] );
2457 TS_ASSERT_EQUALS( v[ 0 ], 2 );
2458 TS_ASSERT_EQUALS( v[ 1 ], 2 );
2459 TS_ASSERT_EQUALS( v[ 2 ], 2 );
2462 v[ 0 ] = v[ 1 ] = v[ 2 ] = 0;
2466 for( std::size_t k = 0; k < numIter; ++k )
2468 positionIterateSortedOneStep< 3, 2 >( v );
2469 TS_ASSERT( v[ 0 ] <= v[ 1 ] );
2470 TS_ASSERT( v[ 1 ] <= v[ 2 ] );
2474 TS_ASSERT_EQUALS( v[ 0 ], 1 );
2475 TS_ASSERT_EQUALS( v[ 1 ], 1 );
2476 TS_ASSERT_EQUALS( v[ 2 ], 1 );
2481 #ifdef WASSERT_FLAG_CHANGED
2482 #define WASSERT_AS_CASSERT
2483 #undefine WASSERT_FLAG_CHANGED
2486 #endif // WTENSORBASE_TEST_H