/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ /* ex: set filetype=cpp softtabstop=4 shiftwidth=4 tabstop=4 cindent expandtab: */ /* Author(s): Daniel Li, Anton Deguet Created on: 2006-07-10 (C) Copyright 2006-2013 Johns Hopkins University (JHU), All Rights Reserved. --- begin cisst license - do not edit --- This software is provided "as is" under an open source license, with no warranty. The complete license can be found in license.txt and http://www.cisst.org/cisst/license.txt. --- end cisst license --- */ #include "vctDynamicNArrayTest.h" #include "vctGenericContainerTest.h" #include "vctGenericNArrayTest.h" #include #include #include #include #include template void vctDynamicNArrayTest::TestAssignment(void) { typedef _elementType value_type; enum {DIMENSION = 4}; typedef vctDynamicNArray ArrayType; typename ArrayType::nsize_type sizes; vctRandom(sizes, static_cast(MIN_SIZE), static_cast(MAX_SIZE)); ArrayType nArray1(sizes); vctRandom(nArray1, static_cast(-10), static_cast(10)); ArrayType nArray2(sizes); vctGenericNArrayTest::TestAssignment(nArray1, nArray2); return; } void vctDynamicNArrayTest::TestAssignmentDouble(void) { TestAssignment(); } void vctDynamicNArrayTest::TestAssignmentFloat(void) { TestAssignment(); } void vctDynamicNArrayTest::TestAssignmentInt(void) { TestAssignment(); } #if DANIEL template void vctDynamicNArrayTest::TestAccessMethods(void) { enum {ROWS = 3, COLS = 5}; typedef _elementType value_type; vctDynamicNArray inputNArray(ROWS, COLS); vctRandom(inputNArray, static_cast(-10), static_cast(10)); vctDynamicConstNArrayRef constInputNArray(ROWS, COLS, inputNArray.row_stride(), inputNArray.col_stride(), inputNArray.Pointer()); vctGenericNArrayTest::TestAccessMethods(inputNArray, constInputNArray); } void vctDynamicNArrayTest::TestAccessMethodsDouble(void) { TestAccessMethods(); } void vctDynamicNArrayTest::TestAccessMethodsFloat(void) { TestAccessMethods(); } void vctDynamicNArrayTest::TestAccessMethodsInt(void) { TestAccessMethods(); } #endif // DANIEL template void vctDynamicNArrayTest::TestSoNiOperations(void) { typedef _elementType value_type; enum {DIMENSION = 4}; typedef vctDynamicNArray ArrayType; typename ArrayType::nsize_type sizes; vctRandom(sizes, static_cast(MIN_SIZE), static_cast(MAX_SIZE)); ArrayType nArray(sizes); ArrayType result(sizes); vctRandom(nArray, static_cast(-10), static_cast(10)); vctGenericContainerTest::TestSoCiOperations(nArray, result); } void vctDynamicNArrayTest::TestSoNiOperationsDouble(void) { TestSoNiOperations(); } void vctDynamicNArrayTest::TestSoNiOperationsFloat(void) { TestSoNiOperations(); } void vctDynamicNArrayTest::TestSoNiOperationsInt(void) { TestSoNiOperations(); } template void vctDynamicNArrayTest::TestSoNiNiOperations(void) { typedef _elementType value_type; enum {DIMENSION = 4}; typedef vctDynamicNArray ArrayType; typename ArrayType::nsize_type sizes; vctRandom(sizes, static_cast(MIN_SIZE), static_cast(MAX_SIZE)); ArrayType nArray1(sizes); ArrayType nArray2(sizes); ArrayType nArray3(sizes); vctRandom(nArray1, static_cast(-10), static_cast(10)); vctRandom(nArray2, static_cast(-10), static_cast(10)); vctRandom(nArray3, static_cast(-10), static_cast(10)); vctGenericContainerTest::TestSoCiCiOperations(nArray1, nArray2, nArray3); } void vctDynamicNArrayTest::TestSoNiNiOperationsDouble(void) { TestSoNiNiOperations(); } void vctDynamicNArrayTest::TestSoNiNiOperationsFloat(void) { TestSoNiNiOperations(); } void vctDynamicNArrayTest::TestSoNiNiOperationsInt(void) { TestSoNiNiOperations(); } template void vctDynamicNArrayTest::TestNioNiOperations(void) { typedef _elementType value_type; enum {DIMENSION = 4}; typedef vctDynamicNArray ArrayType; typename ArrayType::nsize_type sizes; vctRandom(sizes, static_cast(MIN_SIZE), static_cast(MAX_SIZE)); ArrayType nArray1(sizes); ArrayType nArray2(sizes); ArrayType result(sizes); vctRandom(nArray1, static_cast(-10), static_cast(10)); vctRandom(nArray2, static_cast(-10), static_cast(10)); RemoveQuasiZero(nArray2); vctGenericContainerTest::TestCioCiOperations(nArray1, nArray2, result); } void vctDynamicNArrayTest::TestNioNiOperationsDouble(void) { TestNioNiOperations(); } void vctDynamicNArrayTest::TestNioNiOperationsFloat(void) { TestNioNiOperations(); } void vctDynamicNArrayTest::TestNioNiOperationsInt(void) { TestNioNiOperations(); } template void vctDynamicNArrayTest::TestNioSiNiOperations(void) { typedef _elementType value_type; enum {DIMENSION = 4}; typedef vctDynamicNArray ArrayType; typename ArrayType::nsize_type sizes; vctRandom(sizes, static_cast(MIN_SIZE), static_cast(MAX_SIZE)); ArrayType nArray1(sizes); ArrayType nArray2(sizes); ArrayType result(sizes); vctRandom(nArray1, static_cast(-10), static_cast(10)); vctRandom(nArray2, static_cast(-10), static_cast(10)); RemoveQuasiZero(nArray2); value_type scalar; cmnRandomSequence & randomSequence = cmnRandomSequence::GetInstance(); randomSequence.ExtractRandomValue(value_type(-10), value_type(10), scalar); vctGenericContainerTest::TestCioSiCiOperations(nArray1, scalar, nArray2, result); } void vctDynamicNArrayTest::TestNioSiNiOperationsDouble(void) { TestNioSiNiOperations(); } void vctDynamicNArrayTest::TestNioSiNiOperationsFloat(void) { TestNioSiNiOperations(); } void vctDynamicNArrayTest::TestNioSiNiOperationsInt(void) { TestNioSiNiOperations(); } template void vctDynamicNArrayTest::TestNioNiNiOperations(void) { typedef _elementType value_type; enum {DIMENSION = 4}; typedef vctDynamicNArray ArrayType; typename ArrayType::nsize_type sizes; vctRandom(sizes, static_cast(MIN_SIZE), static_cast(MAX_SIZE)); ArrayType nArray1(sizes); ArrayType nArray2(sizes); ArrayType nArray3(sizes); ArrayType result(sizes); vctRandom(nArray1, static_cast(-10), static_cast(10)); vctRandom(nArray2, static_cast(-10), static_cast(10)); vctRandom(nArray3, static_cast(-10), static_cast(10)); RemoveQuasiZero(nArray3); vctGenericContainerTest::TestCioCiCiOperations(nArray1, nArray2, nArray3, result); } void vctDynamicNArrayTest::TestNioNiNiOperationsDouble(void) { TestNioNiNiOperations(); } void vctDynamicNArrayTest::TestNioNiNiOperationsFloat(void) { TestNioNiNiOperations(); } void vctDynamicNArrayTest::TestNioNiNiOperationsInt(void) { TestNioNiNiOperations(); } template void vctDynamicNArrayTest::TestNoNiNiOperations(void) { typedef _elementType value_type; enum {DIMENSION = 4}; typedef vctDynamicNArray ArrayType; typename ArrayType::nsize_type sizes; vctRandom(sizes, static_cast(MIN_SIZE), static_cast(MAX_SIZE)); ArrayType nArray1(sizes); ArrayType nArray2(sizes); ArrayType result(sizes); vctRandom(nArray1, static_cast(-10), static_cast(10)); vctRandom(nArray2, static_cast(-10), static_cast(10)); RemoveQuasiZero(nArray2); vctGenericContainerTest::TestCoCiCiOperations(nArray1, nArray2, result); } void vctDynamicNArrayTest::TestNoNiNiOperationsDouble(void) { TestNoNiNiOperations(); } void vctDynamicNArrayTest::TestNoNiNiOperationsFloat(void) { TestNoNiNiOperations(); } void vctDynamicNArrayTest::TestNoNiNiOperationsInt(void) { TestNoNiNiOperations(); } template void vctDynamicNArrayTest::TestNoNiOperations(void) { typedef _elementType value_type; enum {DIMENSION = 4}; typedef vctDynamicNArray ArrayType; typename ArrayType::nsize_type sizes; vctRandom(sizes, static_cast(MIN_SIZE), static_cast(MAX_SIZE)); ArrayType nArray(sizes); ArrayType result(sizes); vctRandom(nArray, static_cast(-10), static_cast(10)); vctRandom(result, static_cast(-10), static_cast(10)); vctGenericContainerTest::TestCoCiOperations(nArray, result); } void vctDynamicNArrayTest::TestNoNiOperationsDouble(void) { TestNoNiOperations(); } void vctDynamicNArrayTest::TestNoNiOperationsFloat(void) { TestNoNiOperations(); } void vctDynamicNArrayTest::TestNoNiOperationsInt(void) { TestNoNiOperations(); } template void vctDynamicNArrayTest::TestNoNiSiOperations(void) { typedef _elementType value_type; enum {DIMENSION = 4}; typedef vctDynamicNArray ArrayType; typename ArrayType::nsize_type sizes; vctRandom(sizes, static_cast(MIN_SIZE), static_cast(MAX_SIZE)); ArrayType nArray(sizes); ArrayType result(sizes); vctRandom(nArray, static_cast(-10), static_cast(10)); value_type scalar; cmnRandomSequence & randomSequence = cmnRandomSequence::GetInstance(); randomSequence.ExtractRandomValue(value_type(-5), value_type(5), scalar); if ((scalar < value_type(1)) && (scalar > -value_type(1))) { scalar = value_type(3); } vctGenericContainerTest::TestCoCiSiOperations(nArray, scalar, result); } void vctDynamicNArrayTest::TestNoNiSiOperationsDouble(void) { TestNoNiSiOperations(); } void vctDynamicNArrayTest::TestNoNiSiOperationsFloat(void) { TestNoNiSiOperations(); } void vctDynamicNArrayTest::TestNoNiSiOperationsInt(void) { TestNoNiSiOperations(); } template void vctDynamicNArrayTest::TestNoSiNiOperations(void) { typedef _elementType value_type; enum {DIMENSION = 4}; typedef vctDynamicNArray ArrayType; typename ArrayType::nsize_type sizes; vctRandom(sizes, static_cast(MIN_SIZE), static_cast(MAX_SIZE)); ArrayType nArray(sizes); ArrayType result(sizes); vctRandom(nArray, static_cast(-10), static_cast(10)); RemoveQuasiZero(nArray); value_type scalar; cmnRandomSequence & randomSequence = cmnRandomSequence::GetInstance(); randomSequence.ExtractRandomValue(value_type(-5), value_type(5), scalar); vctGenericContainerTest::TestCoSiCiOperations(scalar, nArray, result); } void vctDynamicNArrayTest::TestNoSiNiOperationsDouble(void) { TestNoSiNiOperations(); } void vctDynamicNArrayTest::TestNoSiNiOperationsFloat(void) { TestNoSiNiOperations(); } void vctDynamicNArrayTest::TestNoSiNiOperationsInt(void) { TestNoSiNiOperations(); } template void vctDynamicNArrayTest::TestNioSiOperations(void) { typedef _elementType value_type; enum {DIMENSION = 3}; typedef vctDynamicNArray ArrayType; typename ArrayType::nsize_type sizes; vctRandom(sizes, static_cast(MIN_SIZE), static_cast(MAX_SIZE)); ArrayType nArray(sizes); ArrayType result(sizes); vctRandom(nArray, static_cast(-10), static_cast(10)); value_type scalar; cmnRandomSequence & randomSequence = cmnRandomSequence::GetInstance(); randomSequence.ExtractRandomValue(value_type(-5), value_type(5), scalar); if ( (scalar < value_type(1)) && (scalar > -value_type(1)) ) { scalar = value_type(3); } vctGenericContainerTest::TestCioSiOperations(nArray, scalar, result); } void vctDynamicNArrayTest::TestNioSiOperationsDouble(void) { TestNioSiOperations(); } void vctDynamicNArrayTest::TestNioSiOperationsFloat(void) { TestNioSiOperations(); } void vctDynamicNArrayTest::TestNioSiOperationsInt(void) { TestNioSiOperations(); } template void vctDynamicNArrayTest::TestNioOperations(void) { typedef _elementType value_type; enum {DIMENSION = 4}; typedef vctDynamicNArray ArrayType; typename ArrayType::nsize_type sizes; vctRandom(sizes, static_cast(MIN_SIZE), static_cast(MAX_SIZE)); ArrayType nArray(sizes); ArrayType result(sizes); vctRandom(nArray, static_cast(-10), static_cast(10)); vctGenericContainerTest::TestCioOperations(nArray, result); } void vctDynamicNArrayTest::TestNioOperationsDouble(void) { TestNioOperations(); } void vctDynamicNArrayTest::TestNioOperationsFloat(void) { TestNioOperations(); } void vctDynamicNArrayTest::TestNioOperationsInt(void) { TestNioOperations(); } template void vctDynamicNArrayTest::TestSoNiSiOperations(void) { typedef _elementType value_type; enum {DIMENSION = 4}; typedef vctDynamicNArray ArrayType; typename ArrayType::nsize_type sizes; vctRandom(sizes, static_cast(MIN_SIZE), static_cast(MAX_SIZE)); ArrayType nArray(sizes); ArrayType result(sizes); vctRandom(nArray, static_cast(-10), static_cast(10)); value_type scalar; cmnRandomSequence & randomSequence = cmnRandomSequence::GetInstance(); randomSequence.ExtractRandomValue(value_type(-5), value_type(5), scalar); vctGenericContainerTest::TestSoCiSiOperations(nArray, scalar, result); } void vctDynamicNArrayTest::TestSoNiSiOperationsDouble(void) { TestSoNiSiOperations(); } void vctDynamicNArrayTest::TestSoNiSiOperationsFloat(void) { TestSoNiSiOperations(); } void vctDynamicNArrayTest::TestSoNiSiOperationsInt(void) { TestSoNiSiOperations(); } template void vctDynamicNArrayTest::TestMinAndMax(void) { typedef _elementType value_type; enum {DIMENSION = 4}; typedef vctDynamicNArray ArrayType; typename ArrayType::nsize_type sizes; vctRandom(sizes, static_cast(MIN_SIZE), static_cast(MAX_SIZE)); ArrayType nArray(sizes); vctRandom(nArray, static_cast(-10), static_cast(10)); vctGenericContainerTest::TestMinAndMax(nArray); } void vctDynamicNArrayTest::TestMinAndMaxDouble(void) { TestMinAndMax(); } void vctDynamicNArrayTest::TestMinAndMaxFloat(void) { TestMinAndMax(); } void vctDynamicNArrayTest::TestMinAndMaxInt(void) { TestMinAndMax(); } template void vctDynamicNArrayTest::TestIterators(void) { typedef _elementType value_type; enum {DIMENSION = 4}; typedef vctDynamicNArray ArrayType; typename ArrayType::nsize_type sizes; vctRandom(sizes, static_cast(MIN_SIZE), static_cast(MAX_SIZE)); ArrayType nArray(sizes); vctRandom(nArray, static_cast(-10), static_cast(10)); vctGenericContainerTest::TestIterators(nArray); } void vctDynamicNArrayTest::TestIteratorsDouble(void) { TestIterators(); } void vctDynamicNArrayTest::TestIteratorsFloat(void) { TestIterators(); } void vctDynamicNArrayTest::TestIteratorsInt(void) { TestIterators(); } template void vctDynamicNArrayTest::TestSTLFunctions(void) { typedef _elementType value_type; enum {DIMENSION = 4}; typedef vctDynamicNArray ArrayType; typename ArrayType::nsize_type sizes; vctRandom(sizes, static_cast(MIN_SIZE), static_cast(MAX_SIZE)); ArrayType nArray(sizes); vctRandom(nArray, static_cast(-10), static_cast(10)); ArrayType result(sizes); vctGenericContainerTest::TestSTLFunctions(nArray, result); } void vctDynamicNArrayTest::TestSTLFunctionsDouble(void) { TestSTLFunctions(); } void vctDynamicNArrayTest::TestSTLFunctionsFloat(void) { TestSTLFunctions(); } void vctDynamicNArrayTest::TestSTLFunctionsInt(void) { TestSTLFunctions(); } template void vctDynamicNArrayTest::TestIsCompact(void) { typedef _elementType value_type; enum {DIMENSION = 4}; typedef vctDynamicNArray ArrayType; typedef vctDynamicNArrayRef ArrayRefType; typedef vctDynamicConstNArrayRef ConstArrayRefType; typedef typename ArrayType::nsize_type SizesType;; typedef typename ArrayType::ndimension_type DimensionsType; typedef typename ArrayType::nindex_type IndicesType; typedef typename ArrayType::index_type IndexType; SizesType sizes; vctRandom(sizes, static_cast(1), static_cast(MAX_SIZE)); // compact arrays, same order for dimensions ArrayType array(sizes); CPPUNIT_ASSERT(array.IsCompact()); ArrayRefType arrayRef(array); CPPUNIT_ASSERT(arrayRef.IsCompact()); ConstArrayRefType constArrayRef(arrayRef); CPPUNIT_ASSERT(constArrayRef.IsCompact()); // build a permutation vector DimensionsType permutation; IndicesType swaps; IndexType index; for (index = 0; index < permutation.size(); index++) { permutation.Element(index) = index; } vctRandom(swaps, static_cast(0), permutation.size()); IndexType temp; for (index = 0; index < permutation.size(); index++) { temp = permutation[0]; permutation[0] = permutation[swaps[index]]; permutation[swaps[index]] = temp; } // test on compact permutations,i.e. no windowing arrayRef.PermutationOf(array, permutation); CPPUNIT_ASSERT(arrayRef.IsCompact()); constArrayRef.PermutationOf(arrayRef, permutation); CPPUNIT_ASSERT(constArrayRef.IsCompact()); // test on non compact permutations, create windows. For each // dimension, take all but first elements. vctRandom(sizes, static_cast(2), static_cast(MAX_SIZE)); array.SetSize(sizes); arrayRef.SubarrayOf(array, SizesType(1), array.sizes() - SizesType(1)); CPPUNIT_ASSERT(!arrayRef.IsCompact()); constArrayRef.SubarrayOf(array, SizesType(1), array.sizes() - SizesType(1)); CPPUNIT_ASSERT(!constArrayRef.IsCompact()); } void vctDynamicNArrayTest::TestIsCompactDouble(void) { TestIsCompact(); } void vctDynamicNArrayTest::TestIsCompactFloat(void) { TestIsCompact(); } void vctDynamicNArrayTest::TestIsCompactInt(void) { TestIsCompact(); } template void vctDynamicNArrayTest::TestFastCopyOf(void) { enum {DIMENSION = 4}; enum {DIM0 = 3, DIM1 = 5, DIM2 = 7, DIM3 = 5}; // Important, DIM1 == DIM3 typedef _elementType value_type; typedef vctDynamicNArray ArrayType; typedef vctDynamicNArrayRef ArrayRefType; typedef typename ArrayType::nsize_type nsize_type; const nsize_type baseSize(DIM0, DIM1, DIM2, DIM3); // dynamic nArray ArrayType destination(baseSize); ArrayType validSource(baseSize); vctRandom(validSource, value_type(-10), value_type(10)); vctGenericContainerTest::TestFastCopyOf(validSource, destination); // test for different storage order, but same sizes. Permute dim // 1 and 3 which have the same size. ArrayRefType invalidSource; invalidSource.PermutationOf(validSource, nsize_type(0, 3, 2, 1)); CPPUNIT_ASSERT(!destination.FastCopyCompatible(invalidSource)); CPPUNIT_ASSERT(!destination.FastCopyOf(invalidSource)); // test for exception if different size ArrayType largerNArray(nsize_type(baseSize.MaxElement())); vctGenericContainerTest::TestFastCopyOfException(largerNArray, destination); // safe tests using a larger source and not performing checks CPPUNIT_ASSERT(largerNArray.FastCopyOf(destination, false)); CPPUNIT_ASSERT(destination.FastCopyOf(invalidSource, false)); } void vctDynamicNArrayTest::TestFastCopyOfDouble(void) { TestFastCopyOf(); } void vctDynamicNArrayTest::TestFastCopyOfFloat(void) { TestFastCopyOf(); } void vctDynamicNArrayTest::TestFastCopyOfInt(void) { TestFastCopyOf(); } CPPUNIT_TEST_SUITE_REGISTRATION(vctDynamicNArrayTest);