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 );
2142 TS_ASSERT_EQUALS( t[ idx ], 3.0 );
2147 TS_ASSERT_EQUALS( t[ idx ], -2.0 );
2151 TS_ASSERT_EQUALS( t[ idx ], 0.0 );
2157 std::size_t idx[ 1 ] = { 0 };
2165 TS_ASSERT_THROWS_NOTHING( T14 t = T14( s );
2169 TS_ASSERT_EQUALS( t[ idx ], 3.0 );
2171 TS_ASSERT_EQUALS( t[ idx ], -2.0 );
2173 TS_ASSERT_EQUALS( t[ idx ], 0.0 );
2175 TS_ASSERT_EQUALS( t[ idx ], 0.0 );
2181 std::size_t* idx = NULL;
2184 TS_ASSERT_THROWS_NOTHING( T04 t = T04( s );
2188 TS_ASSERT_EQUALS( t[ idx ], 5.0 );
2209 std::size_t idx[ 2 ] = { 0, 3 };
2218 TS_ASSERT_THROWS_NOTHING( t = s );
2221 TS_ASSERT_EQUALS( t[ idx ], 3.0 );
2226 TS_ASSERT_EQUALS( t[ idx ], -2.0 );
2230 TS_ASSERT_EQUALS( t[ idx ], 0.0 );
2237 std::size_t idx[ 1 ] = { 0 };
2245 TS_ASSERT_THROWS_NOTHING( t = s );
2248 TS_ASSERT_EQUALS( t[ idx ], 3.0 );
2250 TS_ASSERT_EQUALS( t[ idx ], -2.0 );
2252 TS_ASSERT_EQUALS( t[ idx ], 0.0 );
2254 TS_ASSERT_EQUALS( t[ idx ], 0.0 );
2261 std::size_t* idx = NULL;
2264 TS_ASSERT_THROWS_NOTHING( t = s );
2267 TS_ASSERT_EQUALS( t[ idx ], 5.0 );
2286 TS_ASSERT_EQUALS( d, 3.0 );
2290 TS_ASSERT_EQUALS( f, 3.0f );
2294 TS_ASSERT_EQUALS( i, 3 );
2304 TS_ASSERT_EQUALS( d, 3.0 );
2308 TS_ASSERT_EQUALS( f, 3.0f );
2312 TS_ASSERT_EQUALS( i, 3 );
2329 TS_ASSERT_EQUALS( v.
size(), 5 );
2331 TS_ASSERT_EQUALS( v[ 0 ], -9.765 );
2332 TS_ASSERT_EQUALS( v[ 1 ], 154.06 );
2333 TS_ASSERT_EQUALS( v[ 2 ], 0.0 );
2334 TS_ASSERT_EQUALS( v[ 3 ], 0.0 );
2335 TS_ASSERT_EQUALS( v[ 4 ], -57.0 );
2345 TS_ASSERT_EQUALS( v.
size(), 5 );
2347 TS_ASSERT_EQUALS( v[ 0 ], -9.765 );
2348 TS_ASSERT_EQUALS( v[ 1 ], 154.06 );
2349 TS_ASSERT_EQUALS( v[ 2 ], 0.0 );
2350 TS_ASSERT_EQUALS( v[ 3 ], 0.0 );
2351 TS_ASSERT_EQUALS( v[ 4 ], -57.0 );
2371 for( std::size_t i = 0; i < 3; ++i )
2373 for( std::size_t j = 0; j < 3; ++j )
2375 TS_ASSERT_EQUALS( m( i, j ), t( i, j ) );
2390 for( std::size_t i = 0; i < 3; ++i )
2392 for( std::size_t j = 0; j < 3; ++j )
2394 TS_ASSERT_EQUALS( m( i, j ), t( i, j ) );
2415 boost::array< std::size_t, 3 > is;
2417 std::vector< std::size_t > shouldBe( 3, 0 );
2420 positionIterateOneStep< 3, 3 >( is );
2421 TS_ASSERT_SAME_DATA( &is[ 0 ], &shouldBe[ 0 ], 3 *
sizeof( std::size_t ) );
2423 positionIterateOneStep< 3, 3 >( is );
2424 positionIterateOneStep< 3, 3 >( is );
2428 TS_ASSERT_SAME_DATA( &is[ 0 ], &shouldBe[ 0 ], 3 *
sizeof( std::size_t ) );
2431 positionIterateOneStep< 3, 2 >( is );
2432 positionIterateOneStep< 3, 2 >( is );
2436 TS_ASSERT_SAME_DATA( &is[ 0 ], &shouldBe[ 0 ], 3 *
sizeof( std::size_t ) );
2438 positionIterateOneStep< 3, 2 >( is );
2441 TS_ASSERT_SAME_DATA( &is[ 0 ], &shouldBe[ 0 ], 3 *
sizeof( std::size_t ) );
2449 boost::array< std::size_t, 3 > v;
2455 for( std::size_t k = 0; k < numIter; ++k )
2457 positionIterateSortedOneStep< 3, 3 >( v );
2458 TS_ASSERT( v[ 0 ] <= v[ 1 ] );
2459 TS_ASSERT( v[ 1 ] <= v[ 2 ] );
2463 TS_ASSERT_EQUALS( v[ 0 ], 2 );
2464 TS_ASSERT_EQUALS( v[ 1 ], 2 );
2465 TS_ASSERT_EQUALS( v[ 2 ], 2 );
2468 v[ 0 ] = v[ 1 ] = v[ 2 ] = 0;
2472 for( std::size_t k = 0; k < numIter; ++k )
2474 positionIterateSortedOneStep< 3, 2 >( v );
2475 TS_ASSERT( v[ 0 ] <= v[ 1 ] );
2476 TS_ASSERT( v[ 1 ] <= v[ 2 ] );
2480 TS_ASSERT_EQUALS( v[ 0 ], 1 );
2481 TS_ASSERT_EQUALS( v[ 1 ], 1 );
2482 TS_ASSERT_EQUALS( v[ 2 ], 1 );
2487 #ifdef WASSERT_FLAG_CHANGED
2488 #define WASSERT_AS_CASSERT
2489 #undefine WASSERT_FLAG_CHANGED
2492 #endif // WTENSORBASE_TEST_H
void testWTensorBaseCompareOperator()
Test if operator == works correctly.
void testTensorBaseConstructor()
The standard constructor should allocate enough memory and set all elements to zero.
void testCastTensorToVector()
Test casts from any tensorbase of order 1 to a WValue.
void testCastTensorToMatrix()
Test casts from any tensorbase of order 2 to a WMatrix.
void testCopyOperatorBaseFromSym()
Test assignment of a WTensorBaseSym to a WTensorBase.
size_t getNbCols() const
Get number of columns.
void testAccessOperatorErrors()
Test operator () error conditions.
void testWTensorBaseArrayAccessErrorConditions()
Test if the access operator correctly throws Exceptions only when the input indices are invalid...
void testCastTensorToValue()
Test casts from any tensorbase of order 0 to a value.
void testWTensorBaseSymCompareOperator()
Test if operator == works correctly.
void testWTensorBaseCopyConstructor()
The copy constructor should copy all values.
Normal tensor base class.
Symmetric tensor base class.
void testIndexIterationSorted()
Test sorted iteration of indices.
void testWTensorBaseSymAccessOperatorPermutations()
Test if operator [] correctly maps permutations of the same set of indices to the same array position...
void testAccessOperatorSymmetry()
Test if operator () keeps the symmetry of a WTensorBaseSym intact.
Implements compile-time calculation of binomial coefficients.
void testWTensorBaseCopyOperatorSelfCopy()
Test if the copy operator handles assignments of variables to themselves correctly.
Test some utility functions.
void testCopyContructorBaseFromBaseSym()
Test constructing a WTensorBase from a WTensorBaseSym.
A class that tests the WTensorFunc template.
void testWTensorBaseSymVectorAccess()
Test the std::vector version of operator [] for correct handling of various input vector sizes...
void testTensorBaseSymConstructor()
The standard constructor should allocate enough memory and set all elements to zero.
boost::array< Data_T, dataSize > m_data
Stores the elements of this tensor lexicographical ordered on their indices, where for each set of pe...
void testWTensorBaseSymArrayAccess()
Test if the array access operator returns the correct elements.
void testWTensorBaseSymCopyOperatorSelfCopy()
Test if the copy operator handles assignments of variables to themselves correctly.
Test all typecasts and copy operators that copy from another type.
void testWTensorBaseCopyOperatorSimple()
Test the copy operator.
Implements functions that should only be defined for certain values of order.
void testWTensorBaseVectorAccess()
Test the std::vector version of operator [] for correct handling of various input vector sizes...
void testWTensorBaseCompareOperator2()
Test if operator != works correctly.
size_t size() const
Get number of components the value consists of.
boost::array< Data_T, dataSize > m_data
Stores all elements.
void testWTensorBaseSymCompareOperator2()
Test if operator != works correctly.
size_t getNbRows() const
Get number of rows.
void testAccessOperator()
Test if operator () returns the correct elements.
void testWTensorBaseSymCopyOperatorSimple()
Test the copy operator.
void testWTensorBaseSymCopyConstructor()
The copy constructor should copy all values.
Test class for WTensorBase.
Test class for WTensorBaseSym.
void testWTensorBaseArrayAccess()
Test if the array access operator returns the correct elements.
void testIndexIteration()
Test iteration of indices.
void testWTensorBaseSymArrayAccessErrorConditions()
Test if the access operator correctly throws Exceptions only when the input indices are invalid...