122 lines
4.2 KiB
C++
122 lines
4.2 KiB
C++
|
//============================================================================
|
||
|
// Copyright (c) Kitware, Inc.
|
||
|
// All rights reserved.
|
||
|
// See LICENSE.txt for details.
|
||
|
//
|
||
|
// This software is distributed WITHOUT ANY WARRANTY; without even
|
||
|
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
||
|
// PURPOSE. See the above copyright notice for more information.
|
||
|
//============================================================================
|
||
|
|
||
|
#include <vtkm/VecFlat.h>
|
||
|
|
||
|
#include <vtkm/VecAxisAlignedPointCoordinates.h>
|
||
|
|
||
|
#include <vtkm/cont/Logging.h>
|
||
|
|
||
|
#include <vtkm/testing/Testing.h>
|
||
|
|
||
|
namespace
|
||
|
{
|
||
|
|
||
|
template <typename T>
|
||
|
void CheckTraits(const T&, vtkm::IdComponent numComponents)
|
||
|
{
|
||
|
VTKM_TEST_ASSERT((std::is_same<typename vtkm::TypeTraits<T>::DimensionalityTag,
|
||
|
vtkm::TypeTraitsVectorTag>::value));
|
||
|
VTKM_TEST_ASSERT(vtkm::VecTraits<T>::NUM_COMPONENTS == numComponents);
|
||
|
}
|
||
|
|
||
|
void TryBasicVec()
|
||
|
{
|
||
|
using NestedVecType = vtkm::Vec<vtkm::Vec<vtkm::Id, 2>, 3>;
|
||
|
std::cout << "Trying " << vtkm::cont::TypeToString<NestedVecType>() << std::endl;
|
||
|
|
||
|
NestedVecType nestedVec = { { 0, 1 }, { 2, 3 }, { 4, 5 } };
|
||
|
std::cout << " original: " << nestedVec << std::endl;
|
||
|
|
||
|
auto flatVec = vtkm::make_VecFlat(nestedVec);
|
||
|
std::cout << " flat: " << flatVec << std::endl;
|
||
|
CheckTraits(flatVec, 6);
|
||
|
VTKM_TEST_ASSERT(decltype(flatVec)::NUM_COMPONENTS == 6);
|
||
|
VTKM_TEST_ASSERT(flatVec[0] == 0);
|
||
|
VTKM_TEST_ASSERT(flatVec[1] == 1);
|
||
|
VTKM_TEST_ASSERT(flatVec[2] == 2);
|
||
|
VTKM_TEST_ASSERT(flatVec[3] == 3);
|
||
|
VTKM_TEST_ASSERT(flatVec[4] == 4);
|
||
|
VTKM_TEST_ASSERT(flatVec[5] == 5);
|
||
|
|
||
|
flatVec = vtkm::VecFlat<NestedVecType>{ 5, 4, 3, 2, 1, 0 };
|
||
|
std::cout << " flat backward: " << flatVec << std::endl;
|
||
|
VTKM_TEST_ASSERT(flatVec[0] == 5);
|
||
|
VTKM_TEST_ASSERT(flatVec[1] == 4);
|
||
|
VTKM_TEST_ASSERT(flatVec[2] == 3);
|
||
|
VTKM_TEST_ASSERT(flatVec[3] == 2);
|
||
|
VTKM_TEST_ASSERT(flatVec[4] == 1);
|
||
|
VTKM_TEST_ASSERT(flatVec[5] == 0);
|
||
|
|
||
|
nestedVec = flatVec;
|
||
|
std::cout << " nested backward: " << nestedVec << std::endl;
|
||
|
VTKM_TEST_ASSERT(nestedVec[0][0] == 5);
|
||
|
VTKM_TEST_ASSERT(nestedVec[0][1] == 4);
|
||
|
VTKM_TEST_ASSERT(nestedVec[1][0] == 3);
|
||
|
VTKM_TEST_ASSERT(nestedVec[1][1] == 2);
|
||
|
VTKM_TEST_ASSERT(nestedVec[2][0] == 1);
|
||
|
VTKM_TEST_ASSERT(nestedVec[2][1] == 0);
|
||
|
}
|
||
|
|
||
|
void TryScalar()
|
||
|
{
|
||
|
using ScalarType = vtkm::Id;
|
||
|
std::cout << "Trying " << vtkm::cont::TypeToString<ScalarType>() << std::endl;
|
||
|
|
||
|
ScalarType scalar = TestValue(0, ScalarType{});
|
||
|
std::cout << " original: " << scalar << std::endl;
|
||
|
|
||
|
auto flatVec = vtkm::make_VecFlat(scalar);
|
||
|
std::cout << " flat: " << flatVec << std::endl;
|
||
|
CheckTraits(flatVec, 1);
|
||
|
VTKM_TEST_ASSERT(decltype(flatVec)::NUM_COMPONENTS == 1);
|
||
|
VTKM_TEST_ASSERT(test_equal(flatVec[0], TestValue(0, ScalarType{})));
|
||
|
}
|
||
|
|
||
|
void TrySpecialVec()
|
||
|
{
|
||
|
using NestedVecType = vtkm::Vec<vtkm::VecAxisAlignedPointCoordinates<1>, 2>;
|
||
|
std::cout << "Trying " << vtkm::cont::TypeToString<NestedVecType>() << std::endl;
|
||
|
|
||
|
NestedVecType nestedVec = { { { 0, 0, 0 }, { 1, 1, 1 } }, { { 1, 1, 1 }, { 1, 1, 1 } } };
|
||
|
std::cout << " original: " << nestedVec << std::endl;
|
||
|
|
||
|
auto flatVec = vtkm::make_VecFlat(nestedVec);
|
||
|
std::cout << " flat: " << flatVec << std::endl;
|
||
|
CheckTraits(flatVec, 12);
|
||
|
VTKM_TEST_ASSERT(decltype(flatVec)::NUM_COMPONENTS == 12);
|
||
|
VTKM_TEST_ASSERT(test_equal(flatVec[0], nestedVec[0][0][0]));
|
||
|
VTKM_TEST_ASSERT(test_equal(flatVec[1], nestedVec[0][0][1]));
|
||
|
VTKM_TEST_ASSERT(test_equal(flatVec[2], nestedVec[0][0][2]));
|
||
|
VTKM_TEST_ASSERT(test_equal(flatVec[3], nestedVec[0][1][0]));
|
||
|
VTKM_TEST_ASSERT(test_equal(flatVec[4], nestedVec[0][1][1]));
|
||
|
VTKM_TEST_ASSERT(test_equal(flatVec[5], nestedVec[0][1][2]));
|
||
|
VTKM_TEST_ASSERT(test_equal(flatVec[6], nestedVec[1][0][0]));
|
||
|
VTKM_TEST_ASSERT(test_equal(flatVec[7], nestedVec[1][0][1]));
|
||
|
VTKM_TEST_ASSERT(test_equal(flatVec[8], nestedVec[1][0][2]));
|
||
|
VTKM_TEST_ASSERT(test_equal(flatVec[9], nestedVec[1][1][0]));
|
||
|
VTKM_TEST_ASSERT(test_equal(flatVec[10], nestedVec[1][1][1]));
|
||
|
VTKM_TEST_ASSERT(test_equal(flatVec[11], nestedVec[1][1][2]));
|
||
|
}
|
||
|
|
||
|
void DoTest()
|
||
|
{
|
||
|
TryBasicVec();
|
||
|
TryScalar();
|
||
|
TrySpecialVec();
|
||
|
}
|
||
|
|
||
|
} // anonymous namespace
|
||
|
|
||
|
int UnitTestVecFlat(int argc, char* argv[])
|
||
|
{
|
||
|
return vtkm::testing::Testing::Run(DoTest, argc, argv);
|
||
|
}
|