Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-09-16 17:22:55 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity

Remove vtkm::Scalar and vtkm::Vector# types

Browse Source 
Providing these types tends to "lock in" the precision of the algorithms
used in VTK-m. Since we are using templating anyway, our templates
should be generic enough to handle difference precision in the data.
Usually the appropriate type can be determined by the data provided. In
the case where there is no hint on the precision of data to use (for
example, in the code that provides coordinates for uniform data), there
is a vtkm::FloatDefault.
This commit is contained in:
Kenneth Moreland 2014-10-09 08:54:56 -06:00
parent 4881ed4ddb
commit 7f94eafc9c
25 changed files with 383 additions and 356 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
vtkm/TypeTraits.h
View File

@ -111,28 +111,12 @@ VTKM_BASIC_INTEGER_TYPE(vtkm::UInt64);
#undef VTKM_BASIC_REAL_TYPE
#undef VTKM_BASIC_INTEGER_TYPE
#define VTKM_VECTOR_TYPE(T, NTag) \
template<> struct TypeTraits<T> { \
typedef NTag NumericTag; \
typedef TypeTraitsVectorTag DimensionalityTag; \
}
/// Traits for vector types.
///
VTKM_VECTOR_TYPE(vtkm::Id3, TypeTraitsIntegerTag);
VTKM_VECTOR_TYPE(vtkm::Vector2, TypeTraitsRealTag);
VTKM_VECTOR_TYPE(vtkm::Vector3, TypeTraitsRealTag);
VTKM_VECTOR_TYPE(vtkm::Vector4, TypeTraitsRealTag);
#undef VTKM_VECTOR_TYPE
/// Traits for tuples.
/// Traits for Vec types.
///
template<typename T, vtkm::IdComponent Size>
struct TypeTraits<vtkm::Vec<T, Size> >
struct TypeTraits<vtkm::Vec<T,Size> >
{
typedef typename TypeTraits<T>::NumericTag NumericTag;
typedef typename vtkm::TypeTraits<T>::NumericTag NumericTag;
typedef TypeTraitsVectorTag DimensionalityTag;
};

47
vtkm/Types.h
View File

@ -156,13 +156,13 @@ typedef vtkm::Int32 IdComponent;
#ifdef VTKM_USE_DOUBLE_PRECISION
/// Scalar corresponds to a floating point number.
typedef vtkm::Float64 Scalar;
/// The floating point type to use when no other precision is specified.
typedef vtkm::Float64 FloatDefault;
#else //VTKM_USE_DOUBLE_PRECISION
/// Scalar corresponds to a floating point number.
typedef vtkm::Float32 Scalar;
/// The floating point type to use when no other precision is specified.
typedef vtkm::Float32 FloatDefault;
#endif //VTKM_USE_DOUBLE_PRECISION
@ -1043,9 +1043,6 @@ public:
}
};
/// Vector2 corresponds to a 2-tuple
typedef vtkm::Vec<vtkm::Scalar,2> Vector2;
/// Id2 corresponds to a 2-dimensional index
typedef vtkm::Vec<vtkm::Id,2> Id2;
@ -1071,9 +1068,6 @@ public:
}
};
/// Vector3 corresponds to a 3-tuple
typedef vtkm::Vec<vtkm::Scalar,3> Vector3;
/// Id3 corresponds to a 3-dimensional index for 3d arrays. Note that
/// the precision of each index may be less than vtkm::Id.
typedef vtkm::Vec<vtkm::Id,3> Id3;
@ -1101,39 +1095,6 @@ public:
}
};
/// Vector4 corresponds to a 4-tuple
typedef vtkm::Vec<vtkm::Scalar,4> Vector4;
/// Initializes and returns a Vector2.
VTKM_EXEC_CONT_EXPORT vtkm::Vector2 make_Vector2(vtkm::Scalar x,
vtkm::Scalar y)
{
return vtkm::Vector2(x, y);
}
/// Initializes and returns a Vector3.
VTKM_EXEC_CONT_EXPORT vtkm::Vector3 make_Vector3(vtkm::Scalar x,
vtkm::Scalar y,
vtkm::Scalar z)
{
return vtkm::Vector3(x, y, z);
}
/// Initializes and returns a Vector4.
VTKM_EXEC_CONT_EXPORT vtkm::Vector4 make_Vector4(vtkm::Scalar x,
vtkm::Scalar y,
vtkm::Scalar z,
vtkm::Scalar w)
{
return vtkm::Vector4(x, y, z, w);
}
/// Initializes and returns an Id3
VTKM_EXEC_CONT_EXPORT vtkm::Id3 make_Id3(vtkm::Id x, vtkm::Id y, vtkm::Id z)
{
return vtkm::Id3(x, y, z);
}
/// Initializes and returns a Vec of length 2.
///

34
vtkm/cont/ArrayHandleUniformPointCoordinates.h
View File

@ -36,15 +36,15 @@ namespace internal {
class ArrayPortalUniformPointCoordinates
{
public:
typedef vtkm::Vector3 ValueType;
typedef vtkm::Vec<vtkm::FloatDefault,3> ValueType;
VTKM_EXEC_CONT_EXPORT
ArrayPortalUniformPointCoordinates() : NumberOfValues(0) { }
VTKM_EXEC_CONT_EXPORT
ArrayPortalUniformPointCoordinates(vtkm::Extent3 extent,
vtkm::Vector3 origin,
vtkm::Vector3 spacing)
ValueType origin,
ValueType spacing)
: Extent(extent),
Dimensions(vtkm::ExtentPointDimensions(extent)),
NumberOfValues(vtkm::ExtentNumberOfPoints(extent)),
@ -78,7 +78,7 @@ public:
vtkm::Id GetNumberOfValues() const { return this->NumberOfValues; }
VTKM_EXEC_CONT_EXPORT
vtkm::Vector3 Get(vtkm::Id index) const {
ValueType Get(vtkm::Id index) const {
return this->GetCoordinatesForTopologyIndex(
vtkm::ExtentPointFlatIndexToTopologyIndex(index, this->Extent));
}
@ -87,7 +87,7 @@ public:
vtkm::Id3 GetRange3() const { return this->Dimensions; }
VTKM_EXEC_CONT_EXPORT
vtkm::Vector3 Get(vtkm::Id3 index) const {
ValueType Get(vtkm::Id3 index) const {
return this->GetCoordinatesForTopologyIndex(index + this->Extent.Min);
}
@ -95,14 +95,14 @@ private:
vtkm::Extent3 Extent;
vtkm::Id3 Dimensions;
vtkm::Id NumberOfValues;
vtkm::Vector3 Origin;
vtkm::Vector3 Spacing;
ValueType Origin;
ValueType Spacing;
VTKM_EXEC_CONT_EXPORT
vtkm::Vector3 GetCoordinatesForTopologyIndex(vtkm::Id3 ijk) const {
return vtkm::Vector3(this->Origin[0] + this->Spacing[0]*ijk[0],
this->Origin[1] + this->Spacing[1]*ijk[1],
this->Origin[2] + this->Spacing[2]*ijk[2]);
ValueType GetCoordinatesForTopologyIndex(vtkm::Id3 ijk) const {
return ValueType(this->Origin[0] + this->Spacing[0]*ijk[0],
this->Origin[1] + this->Spacing[1]*ijk[1],
this->Origin[2] + this->Spacing[2]*ijk[2]);
}
};
@ -115,12 +115,16 @@ private:
///
class ArrayHandleUniformPointCoordinates
: public vtkm::cont::ArrayHandle<
vtkm::Vector3,
vtkm::Vec<vtkm::FloatDefault,3>,
vtkm::cont::StorageTagImplicit<
internal::ArrayPortalUniformPointCoordinates> >
{
public:
typedef vtkm::Vec<vtkm::FloatDefault,3> ValueType;
private:
typedef vtkm::cont::ArrayHandle<
vtkm::Vector3,
ValueType,
vtkm::cont::StorageTagImplicit<
internal::ArrayPortalUniformPointCoordinates> > Superclass;
@ -130,8 +134,8 @@ public:
VTKM_CONT_EXPORT
ArrayHandleUniformPointCoordinates(vtkm::Extent3 extent,
vtkm::Vector3 origin,
vtkm::Vector3 spacing)
ValueType origin,
ValueType spacing)
: Superclass(
internal::ArrayPortalUniformPointCoordinates(extent, origin, spacing))
{ }

12
vtkm/cont/DynamicPointCoordinates.h
View File

@ -91,7 +91,17 @@ public:
template<typename Storage>
VTKM_CONT_EXPORT
DynamicPointCoordinates(
const vtkm::cont::ArrayHandle<vtkm::Vector3,Storage> &array)
const vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Float32,3>,Storage> &array)
: PointCoordinatesContainer(new vtkm::cont::PointCoordinatesArray(array))
{ }
/// Special constructor for the common case of using a basic array to store
/// point coordinates.
///
template<typename Storage>
VTKM_CONT_EXPORT
DynamicPointCoordinates(
const vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Float64,3>,Storage> &array)
: PointCoordinatesContainer(new vtkm::cont::PointCoordinatesArray(array))
{ }

8
vtkm/cont/PointCoordinatesArray.h
View File

@ -52,7 +52,13 @@ public:
template<typename Storage>
VTKM_CONT_EXPORT
PointCoordinatesArray(
const vtkm::cont::ArrayHandle<vtkm::Vector3,Storage> &array)
const vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Float32,3>,Storage> &array)
: Array(array) { }
template<typename Storage>
VTKM_CONT_EXPORT
PointCoordinatesArray(
const vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Float64,3>,Storage> &array)
: Array(array) { }
/// In this \c CastAndCall, \c TypeList is ignored. All point coordinates are

6
vtkm/cont/PointCoordinatesUniform.h
View File

@ -39,13 +39,15 @@ namespace cont {
class PointCoordinatesUniform : public internal::PointCoordinatesBase
{
public:
typedef vtkm::Vec<vtkm::FloatDefault,3> ValueType;
VTKM_CONT_EXPORT
PointCoordinatesUniform() { }
VTKM_CONT_EXPORT
PointCoordinatesUniform(const vtkm::Extent3 &extent,
const vtkm::Vector3 &origin,
const vtkm::Vector3 &spacing)
const ValueType &origin,
const ValueType &spacing)
: Array(extent, origin, spacing)
{ }

2
vtkm/cont/Timer.h
View File

@ -60,7 +60,7 @@ public:
/// asynchronous operations.
///
VTKM_CONT_EXPORT
vtkm::Scalar GetElapsedTime()
vtkm::Float64 GetElapsedTime()
{
return this->TimerImplementation.GetElapsedTime();
}

10
vtkm/cont/internal/DeviceAdapterAlgorithm.h
View File

@ -347,15 +347,15 @@ public:
/// number of times to get the progressive time. This method synchronizes all
/// asynchronous operations.
///
VTKM_CONT_EXPORT vtkm::Scalar GetElapsedTime()
VTKM_CONT_EXPORT vtkm::Float64 GetElapsedTime()
{
TimeStamp currentTime = this->GetCurrentTime();
vtkm::Scalar elapsedTime;
elapsedTime = vtkm::Scalar(currentTime.Seconds - this->StartTime.Seconds);
vtkm::Float64 elapsedTime;
elapsedTime = vtkm::Float64(currentTime.Seconds - this->StartTime.Seconds);
elapsedTime +=
(vtkm::Scalar(currentTime.Microseconds - this->StartTime.Microseconds)
/vtkm::Scalar(1000000));
(vtkm::Float64(currentTime.Microseconds - this->StartTime.Microseconds)
/vtkm::Float64(1000000));
return elapsedTime;
}

14
vtkm/cont/internal/testing/UnitTestDynamicTransform.cxx
View File

@ -40,7 +40,7 @@ static int g_FunctionCalls;
struct TypeListTagString : vtkm::ListTagBase<std::string> { };
struct ScalarFunctor {
void operator()(vtkm::Scalar) const {
void operator()(vtkm::FloatDefault) const {
std::cout << " In Scalar functor." << std::endl;
g_FunctionCalls++;
}
@ -51,7 +51,7 @@ struct ArrayHandleScalarFunctor {
void operator()(const vtkm::cont::ArrayHandle<T> &) const {
VTKM_TEST_FAIL("Called wrong form of functor operator.");
}
void operator()(const vtkm::cont::ArrayHandle<vtkm::Scalar> &) const {
void operator()(const vtkm::cont::ArrayHandle<vtkm::FloatDefault> &) const {
std::cout << " In ArrayHandle<Scalar> functor." << std::endl;
g_FunctionCalls++;
}
@ -71,8 +71,8 @@ struct FunctionInterfaceFunctor {
}
void operator()(
const vtkm::internal::FunctionInterface<
void(vtkm::cont::ArrayHandle<vtkm::Scalar>,
vtkm::cont::ArrayHandle<vtkm::Scalar>,
void(vtkm::cont::ArrayHandle<vtkm::FloatDefault>,
vtkm::cont::ArrayHandle<vtkm::FloatDefault>,
vtkm::cont::ArrayHandle<std::string>,
vtkm::cont::ArrayHandleUniformPointCoordinates)> &) const {
std::cout << " In FunctionInterface<...> functor." << std::endl;
@ -87,10 +87,10 @@ void TestBasicTransform()
vtkm::cont::internal::DynamicTransform transform;
std::cout << " Trying with simple scalar." << std::endl;
TRY_TRANSFORM(transform(vtkm::Scalar(5), ScalarFunctor()));
TRY_TRANSFORM(transform(vtkm::FloatDefault(5), ScalarFunctor()));
std::cout << " Trying with basic scalar array." << std::endl;
vtkm::cont::ArrayHandle<vtkm::Scalar> concreteArray;
vtkm::cont::ArrayHandle<vtkm::FloatDefault> concreteArray;
TRY_TRANSFORM(transform(concreteArray, ArrayHandleScalarFunctor()));
std::cout << " Trying scalar dynamic array." << std::endl;
@ -107,7 +107,7 @@ void TestFunctionTransform()
{
std::cout << "Testing transforms in FunctionInterface." << std::endl;
vtkm::cont::ArrayHandle<vtkm::Scalar> scalarArray;
vtkm::cont::ArrayHandle<vtkm::FloatDefault> scalarArray;
vtkm::cont::ArrayHandle<std::string> stringArray;
vtkm::cont::ArrayHandleUniformPointCoordinates pointCoordinatesArray;

54
vtkm/cont/testing/TestingDeviceAdapter.h
View File

@ -120,7 +120,7 @@ private:
typedef vtkm::cont::ArrayHandle<vtkm::Id, StorageTag>
IdArrayHandle;
typedef vtkm::cont::ArrayHandle<vtkm::Scalar,StorageTag>
typedef vtkm::cont::ArrayHandle<vtkm::FloatDefault,StorageTag>
ScalarArrayHandle;
typedef vtkm::cont::internal::ArrayManagerExecution<
@ -134,8 +134,8 @@ private:
typedef typename IdArrayHandle::template ExecutionTypes<DeviceAdapterTag>
::PortalConst IdPortalConstType;
typedef vtkm::cont::ArrayHandle<vtkm::Vector3,StorageTag>
Vector3ArrayHandle;
typedef vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::FloatDefault,3>,StorageTag>
Vec3ArrayHandle;
typedef vtkm::cont::DeviceAdapterAlgorithm<DeviceAdapterTag>
Algorithm;
@ -357,26 +357,26 @@ private:
std::cout << "Testing ArrayManagerExecution" << std::endl;
typedef vtkm::cont::internal::ArrayManagerExecution<
vtkm::Scalar,StorageTagBasic,DeviceAdapterTag>
vtkm::FloatDefault,StorageTagBasic,DeviceAdapterTag>
ArrayManagerExecution;
// Create original input array.
vtkm::Scalar inputArray[ARRAY_SIZE*2];
vtkm::FloatDefault inputArray[ARRAY_SIZE*2];
for (vtkm::Id index = 0; index < ARRAY_SIZE*2; index++)
{
inputArray[index] = vtkm::Scalar(index);
inputArray[index] = vtkm::FloatDefault(index);
}
::vtkm::cont::internal::ArrayPortalFromIterators<vtkm::Scalar *>
::vtkm::cont::internal::ArrayPortalFromIterators<vtkm::FloatDefault *>
inputPortal(inputArray, inputArray+ARRAY_SIZE*2);
ArrayManagerExecution inputManager;
inputManager.LoadDataForInput(
::vtkm::cont::internal::ArrayPortalFromIterators<const vtkm::Scalar*>(inputPortal));
::vtkm::cont::internal::ArrayPortalFromIterators<const vtkm::FloatDefault*>(inputPortal));
// Change size.
inputManager.Shrink(ARRAY_SIZE);
// Copy array back.
vtkm::Scalar outputArray[ARRAY_SIZE];
vtkm::FloatDefault outputArray[ARRAY_SIZE];
vtkm::cont::ArrayPortalToIterators<
typename ArrayManagerExecution::PortalConstType>
iterators(inputManager.GetPortalConst());
@ -437,7 +437,7 @@ private:
Sleep(1000);
#endif
vtkm::Scalar elapsedTime = timer.GetElapsedTime();
vtkm::FloatDefault elapsedTime = timer.GetElapsedTime();
std::cout << "Elapsed time: " << elapsedTime << std::endl;
@ -562,7 +562,7 @@ private:
// VTKM_TEST_ASSERT(singleElement[0] == 1234,
// "output of single scheduling is incorrect");
// std::vector<vtkm::Scalar> field(ARRAY_SIZE);
// std::vector<vtkm::FloatDefault> field(ARRAY_SIZE);
// for (vtkm::Id i = 0; i < ARRAY_SIZE; i++)
// {
// field[i]=i;
@ -580,8 +580,8 @@ private:
// for (vtkm::Id i = 0; i < ARRAY_SIZE; i++)
// {
// vtkm::Scalar squareValue = multPortal.Get(i);
// vtkm::Scalar squareTrue = field[i]*field[i];
// vtkm::FloatDefault squareValue = multPortal.Get(i);
// vtkm::FloatDefault squareTrue = field[i]*field[i];
// VTKM_TEST_ASSERT(test_equal(squareValue, squareTrue),
// "Got bad multiply result");
// }
@ -592,15 +592,15 @@ private:
// for (vtkm::Id i = 0; i < ARRAY_SIZE; i++)
// {
// vtkm::Scalar squareValue = multPortal.Get(i);
// vtkm::Scalar squareTrue = field[i]*4.0f;
// vtkm::FloatDefault squareValue = multPortal.Get(i);
// vtkm::FloatDefault squareTrue = field[i]*4.0f;
// VTKM_TEST_ASSERT(test_equal(squareValue, squareTrue),
// "Got bad multiply result");
// }
// std::cout << "Testing Schedule on Subset" << std::endl;
// std::vector<vtkm::Scalar> fullField(ARRAY_SIZE);
// std::vector<vtkm::FloatDefault> fullField(ARRAY_SIZE);
// std::vector<vtkm::Id> subSetLookup(ARRAY_SIZE/2);
// for (vtkm::Id i = 0; i < ARRAY_SIZE; i++)
// {
@ -852,10 +852,10 @@ private:
// }
// IdArrayHandle keys = MakeArrayHandle(testKeys, ARRAY_SIZE);
// Vector3ArrayHandle values = MakeArrayHandle(testValues, ARRAY_SIZE);
// Vec3ArrayHandle values = MakeArrayHandle(testValues, ARRAY_SIZE);
// IdArrayHandle sorted_keys;
// Vector3ArrayHandle sorted_values;
// Vec3ArrayHandle sorted_values;
// Algorithm::Copy(keys,sorted_keys);
// Algorithm::Copy(values,sorted_values);
@ -865,7 +865,7 @@ private:
// {
// //keys should be sorted from 1 to ARRAY_SIZE
// //values should be sorted from (ARRAY_SIZE-1) to 0
// vtkm::Scalar sorted_value =
// vtkm::FloatDefault sorted_value =
// sorted_values.GetPortalConstControl().Get(i)[0];
// vtkm::Id sorted_key = sorted_keys.GetPortalConstControl().Get(i);
@ -880,7 +880,7 @@ private:
// {
// //keys should be sorted from ARRAY_SIZE to 1
// //values should be sorted from 0 to (ARRAY_SIZE-1)
// vtkm::Scalar sorted_value =
// vtkm::FloatDefault sorted_value =
// sorted_values.GetPortalConstControl().Get(i)[0];
// vtkm::Id sorted_key = sorted_keys.GetPortalConstControl().Get(i);
@ -896,7 +896,7 @@ private:
// {
// //keys should be sorted from ARRAY_SIZE to 1
// //values should be sorted from 0 to (ARRAY_SIZE-1)
// vtkm::Scalar sorted_value =
// vtkm::FloatDefault sorted_value =
// sorted_values.GetPortalConstControl().Get(i)[0];
// vtkm::Id sorted_key = sorted_keys.GetPortalConstControl().Get(i);
@ -1119,7 +1119,7 @@ private:
// vtkm::Vector3 trueGradient = vtkm::make_Vector3(1.0, 1.0, 1.0);
// std::vector<vtkm::Scalar> field(grid->GetNumberOfPoints());
// std::vector<vtkm::FloatDefault> field(grid->GetNumberOfPoints());
// std::cout << "Number of Points in the grid: "
// << grid->GetNumberOfPoints()
// << std::endl;
@ -1147,8 +1147,8 @@ private:
// pointIndex < grid->GetNumberOfPoints();
// pointIndex++)
// {
// vtkm::Scalar squareValue = squarePortal.Get(pointIndex);
// vtkm::Scalar squareTrue = field[pointIndex]*field[pointIndex];
// vtkm::FloatDefault squareValue = squarePortal.Get(pointIndex);
// vtkm::FloatDefault squareTrue = field[pointIndex]*field[pointIndex];
// VTKM_TEST_ASSERT(test_equal(squareValue, squareTrue),
// "Got bad square");
// }
@ -1209,7 +1209,7 @@ private:
// vtkm::Vector3 trueGradient = vtkm::make_Vector3(1.0, 1.0, 1.0);
// std::vector<vtkm::Scalar> field(grid->GetNumberOfPoints());
// std::vector<vtkm::FloatDefault> field(grid->GetNumberOfPoints());
// for (vtkm::Id pointIndex = 0;
// pointIndex < grid->GetNumberOfPoints();
// pointIndex++)
@ -1219,7 +1219,7 @@ private:
// }
// ScalarArrayHandle fieldHandle = MakeArrayHandle(field);
// Vector3ArrayHandle gradientHandle;
// Vec3ArrayHandle gradientHandle;
// std::cout << "Running CellGradient worklet" << std::endl;
@ -1230,7 +1230,7 @@ private:
// fieldHandle,
// gradientHandle);
// typename Vector3ArrayHandle::PortalConstControl gradientPortal =
// typename Vec3ArrayHandle::PortalConstControl gradientPortal =
// gradientHandle.GetPortalConstControl();
// std::cout << "Checking result" << std::endl;

229
vtkm/cont/testing/UnitTestArrayHandle.cxx
View File

@ -25,6 +25,8 @@
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/TypeTraits.h>
#include <vtkm/cont/testing/Testing.h>
#include <algorithm>
@ -32,9 +34,32 @@
namespace {
const vtkm::Id ARRAY_SIZE = 10;
vtkm::Scalar TestValue(vtkm::Id index)
template<typename T>
T TestValue(vtkm::Id index, T, vtkm::TypeTraitsIntegerTag)
{
return static_cast<vtkm::Scalar>(10.0*index + 0.01*(index+1));
return T(index*100);
}
template<typename T>
T TestValue(vtkm::Id index, T, vtkm::TypeTraitsRealTag)
{
return T(10.0*index + 0.01*(index+1))/100;
}
template<typename T>
T TestValue(vtkm::Id index, T)
{
return TestValue(index, T(), typename vtkm::TypeTraits<T>::NumericTag());
}
template<typename T, vtkm::IdComponent N>
vtkm::Vec<T,N> TestValue(vtkm::Id index, vtkm::Vec<T,N>) {
vtkm::Vec<T,N> value;
for (vtkm::IdComponent i = 0; i < N; i++)
{
value[i] = TestValue(index, T()) + (i + 1);
}
return value;
}
template<class IteratorType>
@ -43,7 +68,7 @@ bool CheckIterators(IteratorType begin, IteratorType end)
vtkm::Id index = 0;
for (IteratorType iter = begin; iter != end; iter++)
{
if (!test_equal(*iter, TestValue(index))) { return false; }
if (!test_equal(*iter, TestValue(index, *iter))) { return false; }
index++;
}
return true;
@ -62,105 +87,113 @@ bool CheckArray(const vtkm::cont::ArrayHandle<T> &handle)
return CheckPortal(handle.GetPortalConstControl());
}
struct TryArrayHandleType
{
template<typename T>
void operator()(T) const
{
std::cout << "Create array handle." << std::endl;
T array[ARRAY_SIZE];
for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
{
array[index] = TestValue(index, T());
}
typename vtkm::cont::ArrayHandle<T>::PortalControl arrayPortal(
&array[0], &array[ARRAY_SIZE]);
vtkm::cont::ArrayHandle<T> arrayHandle(arrayPortal);
VTKM_TEST_ASSERT(arrayHandle.GetNumberOfValues() == ARRAY_SIZE,
"ArrayHandle has wrong number of entries.");
std::cout << "Check basic array." << std::endl;
VTKM_TEST_ASSERT(CheckArray(arrayHandle),
"Array values not set correctly.");
std::cout << "Check out execution array behavior." << std::endl;
{
typename vtkm::cont::ArrayHandle<T>::template
ExecutionTypes<VTKM_DEFAULT_DEVICE_ADAPTER_TAG>::PortalConst
executionPortal;
executionPortal =
arrayHandle.PrepareForInput(VTKM_DEFAULT_DEVICE_ADAPTER_TAG());
VTKM_TEST_ASSERT(CheckPortal(executionPortal),
"Array not copied to execution correctly.");
}
{
bool gotException = false;
try
{
arrayHandle.PrepareForInPlace(VTKM_DEFAULT_DEVICE_ADAPTER_TAG());
}
catch (vtkm::cont::Error &error)
{
std::cout << "Got expected error: " << error.GetMessage() << std::endl;
gotException = true;
}
VTKM_TEST_ASSERT(gotException,
"PrepareForInPlace did not fail for const array.");
}
{
typedef typename vtkm::cont::ArrayHandle<T>::template
ExecutionTypes<VTKM_DEFAULT_DEVICE_ADAPTER_TAG>::Portal
ExecutionPortalType;
ExecutionPortalType executionPortal =
arrayHandle.PrepareForOutput(ARRAY_SIZE*2,
VTKM_DEFAULT_DEVICE_ADAPTER_TAG());
for (vtkm::Id index = 0;
index < executionPortal.GetNumberOfValues();
index++)
{
executionPortal.Set(index, TestValue(index, T()));
}
}
VTKM_TEST_ASSERT(arrayHandle.GetNumberOfValues() == ARRAY_SIZE*2,
"Array not allocated correctly.");
VTKM_TEST_ASSERT(CheckArray(arrayHandle),
"Array values not retrieved from execution.");
std::cout << "Try shrinking the array." << std::endl;
arrayHandle.Shrink(ARRAY_SIZE);
VTKM_TEST_ASSERT(arrayHandle.GetNumberOfValues() == ARRAY_SIZE,
"Array size did not shrink correctly.");
VTKM_TEST_ASSERT(CheckArray(arrayHandle),
"Array values not retrieved from execution.");
std::cout << "Try in place operation." << std::endl;
{
typedef typename vtkm::cont::ArrayHandle<T>::template
ExecutionTypes<VTKM_DEFAULT_DEVICE_ADAPTER_TAG>::Portal
ExecutionPortalType;
ExecutionPortalType executionPortal =
arrayHandle.PrepareForInPlace(VTKM_DEFAULT_DEVICE_ADAPTER_TAG());
for (vtkm::Id index = 0;
index < executionPortal.GetNumberOfValues();
index++)
{
executionPortal.Set(index, executionPortal.Get(index) + T(1));
}
}
typename vtkm::cont::ArrayHandle<T>::PortalConstControl controlPortal =
arrayHandle.GetPortalConstControl();
for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
{
VTKM_TEST_ASSERT(test_equal(controlPortal.Get(index),
TestValue(index, T()) + T(1)),
"Did not get result from in place operation.");
}
}
};
void TestArrayHandle()
{
std::cout << "Create array handle." << std::endl;
vtkm::Scalar array[ARRAY_SIZE];
for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
{
array[index] = TestValue(index);
}
vtkm::cont::ArrayHandle<vtkm::Scalar>::PortalControl arrayPortal(
&array[0], &array[ARRAY_SIZE]);
vtkm::cont::ArrayHandle<vtkm::Scalar>
arrayHandle(arrayPortal);
VTKM_TEST_ASSERT(arrayHandle.GetNumberOfValues() == ARRAY_SIZE,
"ArrayHandle has wrong number of entries.");
std::cout << "Check basic array." << std::endl;
VTKM_TEST_ASSERT(CheckArray(arrayHandle),
"Array values not set correctly.");
std::cout << "Check out execution array behavior." << std::endl;
{
vtkm::cont::ArrayHandle<vtkm::Scalar>::
ExecutionTypes<VTKM_DEFAULT_DEVICE_ADAPTER_TAG>::PortalConst
executionPortal;
executionPortal =
arrayHandle.PrepareForInput(VTKM_DEFAULT_DEVICE_ADAPTER_TAG());
VTKM_TEST_ASSERT(CheckPortal(executionPortal),
"Array not copied to execution correctly.");
}
{
bool gotException = false;
try
{
arrayHandle.PrepareForInPlace(VTKM_DEFAULT_DEVICE_ADAPTER_TAG());
}
catch (vtkm::cont::Error &error)
{
std::cout << "Got expected error: " << error.GetMessage() << std::endl;
gotException = true;
}
VTKM_TEST_ASSERT(gotException,
"PrepareForInPlace did not fail for const array.");
}
{
typedef vtkm::cont::ArrayHandle<vtkm::Scalar>::
ExecutionTypes<VTKM_DEFAULT_DEVICE_ADAPTER_TAG>::Portal
ExecutionPortalType;
ExecutionPortalType executionPortal =
arrayHandle.PrepareForOutput(ARRAY_SIZE*2,
VTKM_DEFAULT_DEVICE_ADAPTER_TAG());
for (vtkm::Id index = 0;
index < executionPortal.GetNumberOfValues();
index++)
{
executionPortal.Set(index, TestValue(index));
}
}
VTKM_TEST_ASSERT(arrayHandle.GetNumberOfValues() == ARRAY_SIZE*2,
"Array not allocated correctly.");
VTKM_TEST_ASSERT(CheckArray(arrayHandle),
"Array values not retrieved from execution.");
std::cout << "Try shrinking the array." << std::endl;
arrayHandle.Shrink(ARRAY_SIZE);
VTKM_TEST_ASSERT(arrayHandle.GetNumberOfValues() == ARRAY_SIZE,
"Array size did not shrink correctly.");
VTKM_TEST_ASSERT(CheckArray(arrayHandle),
"Array values not retrieved from execution.");
std::cout << "Try in place operation." << std::endl;
{
typedef vtkm::cont::ArrayHandle<vtkm::Scalar>::
ExecutionTypes<VTKM_DEFAULT_DEVICE_ADAPTER_TAG>::Portal
ExecutionPortalType;
ExecutionPortalType executionPortal =
arrayHandle.PrepareForInPlace(VTKM_DEFAULT_DEVICE_ADAPTER_TAG());
for (vtkm::Id index = 0;
index < executionPortal.GetNumberOfValues();
index++)
{
executionPortal.Set(index, executionPortal.Get(index) + 1);
}
}
vtkm::cont::ArrayHandle<vtkm::Scalar>::PortalConstControl controlPortal =
arrayHandle.GetPortalConstControl();
for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
{
VTKM_TEST_ASSERT(test_equal(controlPortal.Get(index), TestValue(index) + 1),
"Did not get result from in place operation.");
}
}
vtkm::testing::Testing::TryAllTypes(TryArrayHandleType());
}
} // anonymous namespace
int UnitTestArrayHandle(int, char *[])
{

37
vtkm/cont/testing/UnitTestArrayHandleCompositeVector.cxx
View File

@ -40,11 +40,11 @@ const vtkm::Id ARRAY_SIZE = 10;
typedef vtkm::cont::StorageTagBasic StorageTag;
vtkm::Scalar TestValue(vtkm::Id index,
vtkm::FloatDefault TestValue(vtkm::Id index,
vtkm::IdComponent inComponentIndex,
int inArrayId)
{
return index + vtkm::Scalar(0.1)*inComponentIndex + vtkm::Scalar(0.01)*inArrayId;
return index + vtkm::FloatDefault(0.1)*inComponentIndex + vtkm::FloatDefault(0.01)*inArrayId;
}
template<typename ValueType>
@ -104,9 +104,9 @@ void CheckArray(const vtkm::cont::ArrayHandle<ValueType,C> &outArray,
componentIndex < VTraits::NUM_COMPONENTS;
componentIndex++)
{
vtkm::Scalar retrievedComponent =
vtkm::FloatDefault retrievedComponent =
VTraits::GetComponent(retreivedValue, componentIndex);
vtkm::Scalar expectedComponent = TestValue(index,
vtkm::FloatDefault expectedComponent = TestValue(index,
inComponents[componentIndex],
inArrayIds[componentIndex]);
VTKM_TEST_ASSERT(retrievedComponent == expectedComponent,
@ -121,7 +121,7 @@ void TryScalarArray()
std::cout << "Creating a scalar array from one of "
<< inComponents << " components." << std::endl;
typedef vtkm::Vec<vtkm::Scalar,inComponents> InValueType;
typedef vtkm::Vec<vtkm::FloatDefault,inComponents> InValueType;
typedef vtkm::cont::ArrayHandle<InValueType, StorageTag> InArrayType;
int inArrayId = 0;
InArrayType inArray = MakeInputArray<InValueType>(inArrayId);
@ -209,9 +209,12 @@ void TryVector3(vtkm::cont::ArrayHandle<T1,StorageTag> array1,
}
std::cout << " Fourth component from Scalar." << std::endl;
TryVector4(array1, array2, array3, MakeInputArray<vtkm::Scalar>(3));
TryVector4(array1, array2, array3, MakeInputArray<vtkm::FloatDefault>(3));
std::cout << " Fourth component from Vector4." << std::endl;
TryVector4(array1, array2, array3, MakeInputArray<vtkm::Vector4>(3));
TryVector4(array1,
array2,
array3,
MakeInputArray<vtkm::Vec<vtkm::FloatDefault,4> >(3));
}
template<typename T1, typename T2>
@ -239,9 +242,11 @@ void TryVector2(vtkm::cont::ArrayHandle<T1,StorageTag> array1,
}
std::cout << " Third component from Scalar." << std::endl;
TryVector3(array1, array2, MakeInputArray<vtkm::Scalar>(2));
TryVector3(array1, array2, MakeInputArray<vtkm::FloatDefault>(2));
std::cout << " Third component from Vector2." << std::endl;
TryVector3(array1, array2, MakeInputArray<vtkm::Vector2>(2));
TryVector3(array1,
array2,
MakeInputArray<vtkm::Vec<vtkm::FloatDefault,2> >(2));
}
template<typename T1>
@ -261,9 +266,9 @@ void TryVector1(vtkm::cont::ArrayHandle<T1,StorageTag> array1)
}
std::cout << " Second component from Scalar." << std::endl;
TryVector2(array1, MakeInputArray<vtkm::Scalar>(1));
TryVector2(array1, MakeInputArray<vtkm::FloatDefault>(1));
std::cout << " Second component from Vector4." << std::endl;
TryVector2(array1, MakeInputArray<vtkm::Vector4>(1));
TryVector2(array1, MakeInputArray<vtkm::Vec<vtkm::FloatDefault,4> >(1));
}
void TryVector()
@ -271,18 +276,18 @@ void TryVector()
std::cout << "Trying many permutations of composite vectors." << std::endl;
std::cout << " First component from Scalar." << std::endl;
TryVector1(MakeInputArray<vtkm::Scalar>(0));
TryVector1(MakeInputArray<vtkm::FloatDefault>(0));
std::cout << " First component from Vector3." << std::endl;
TryVector1(MakeInputArray<vtkm::Vector3>(0));
TryVector1(MakeInputArray<vtkm::Vec<vtkm::FloatDefault,3> >(0));
}
void TestBadArrayLengths() {
std::cout << "Checking behavior when size of input arrays do not agree."
<< std::endl;
typedef vtkm::cont::ArrayHandle<vtkm::Scalar, StorageTag> InArrayType;
InArrayType longInArray = MakeInputArray<vtkm::Scalar>(0);
InArrayType shortInArray = MakeInputArray<vtkm::Scalar>(1);
typedef vtkm::cont::ArrayHandle<vtkm::FloatDefault, StorageTag> InArrayType;
InArrayType longInArray = MakeInputArray<vtkm::FloatDefault>(0);
InArrayType shortInArray = MakeInputArray<vtkm::FloatDefault>(1);
shortInArray.Shrink(ARRAY_SIZE/2);
try

3
vtkm/cont/testing/UnitTestArrayHandleCounting.cxx
View File

@ -127,7 +127,8 @@ struct TestFunctor
void TestArrayHandleCounting()
{
TestFunctor()(vtkm::Id(0));
TestFunctor()(vtkm::Scalar(0));
TestFunctor()(vtkm::Float32(0));
TestFunctor()(vtkm::Float64(0));
TestFunctor()(StringInt(0));
TestFunctor()(StringInt(10));
}

10
vtkm/cont/testing/UnitTestArrayHandleUniformPointCoordinates.cxx
View File

@ -24,14 +24,16 @@
namespace {
typedef vtkm::Vec<vtkm::FloatDefault, 3> Vector3;
const vtkm::Id3 MIN_VALUES(-5, 8, 40);
const vtkm::Id3 MAX_VALUES(10, 25, 44);
const vtkm::Id3 POINT_DIMS(16, 18, 5);
const vtkm::Id NUM_POINTS = 1440;
const vtkm::Vector3 ORIGIN(30, -3, -14);
const vtkm::Vector3 SPACING(10, 1, 0.1f);
const vtkm::Vector3 LOWER_LEFT(-20, 5, -10); // MIN_VALUES*SPACING + ORIGIN
const Vector3 ORIGIN(30, -3, -14);
const Vector3 SPACING(10, 1, 0.1f);
const Vector3 LOWER_LEFT(-20, 5, -10); // MIN_VALUES*SPACING + ORIGIN
void TestArrayHandleUniformPointCoordinates()
{
@ -51,7 +53,7 @@ void TestArrayHandleUniformPointCoordinates()
"Portal range is wrong.");
std::cout << "Checking computed values of portal." << std::endl;
vtkm::Vector3 expectedValue;
Vector3 expectedValue;
vtkm::Id flatIndex = 0;
vtkm::Id3 blockIndex;
expectedValue[2] = LOWER_LEFT[2];

16
vtkm/cont/testing/UnitTestDynamicArrayHandle.cxx
View File

@ -271,12 +271,18 @@ void TryUnusualTypeAndStorage()
void TestDynamicArrayHandle()
{
std::cout << "Try common types with default type lists." << std::endl;
std::cout << "*** vtkm::Id ***************" << std::endl;
std::cout << "*** vtkm::Id **********************" << std::endl;
TryDefaultType(vtkm::Id());
std::cout << "*** vtkm::Scalar ***********" << std::endl;
TryDefaultType(vtkm::Scalar());
std::cout << "*** vtkm::Vector3 **********" << std::endl;
TryDefaultType(vtkm::Vector3());
std::cout << "*** vtkm::FloatDefault ************" << std::endl;
TryDefaultType(vtkm::FloatDefault());
std::cout << "*** vtkm::Float32 *****************" << std::endl;
TryDefaultType(vtkm::Float32());
std::cout << "*** vtkm::Float64 *****************" << std::endl;
TryDefaultType(vtkm::Float64());
std::cout << "*** vtkm::Vec<Float32,3> **********" << std::endl;
TryDefaultType(vtkm::Vec<vtkm::Float32,3>());
std::cout << "*** vtkm::Vec<Float64,3> **********" << std::endl;
TryDefaultType(vtkm::Vec<vtkm::Float64,3>());
std::cout << "Try all VTK-m types." << std::endl;
vtkm::testing::Testing::TryAllTypes(TryBasicVTKmType());

62
vtkm/cont/testing/UnitTestDynamicPointCoordinates.cxx
View File

@ -32,18 +32,18 @@
namespace {
const vtkm::Extent3 EXTENT = vtkm::Extent3(vtkm::Id3(0,0,0), vtkm::Id3(9,9,9));
const vtkm::Vector3 ORIGIN = vtkm::Vector3(0, 0, 0);
const vtkm::Vector3 SPACING = vtkm::Vector3(1, 1, 1);
const vtkm::Vec<vtkm::FloatDefault,3> ORIGIN =
vtkm::Vec<vtkm::FloatDefault,3>(0, 0, 0);
const vtkm::Vec<vtkm::FloatDefault,3> SPACING =
vtkm::Vec<vtkm::FloatDefault,3>(1, 1, 1);
const vtkm::Id3 DIMENSION = vtkm::ExtentPointDimensions(EXTENT);
const vtkm::Id ARRAY_SIZE = DIMENSION[0]*DIMENSION[1]*DIMENSION[2];
vtkm::Vector3 TestValue(vtkm::Id index)
vtkm::Vec<vtkm::FloatDefault,3> TestValue(vtkm::Id index)
{
vtkm::Id3 index3d = vtkm::ExtentPointFlatIndexToTopologyIndex(index, EXTENT);
return vtkm::Vector3(vtkm::Scalar(index3d[0]),
vtkm::Scalar(index3d[1]),
vtkm::Scalar(index3d[2]));
return vtkm::Vec<vtkm::FloatDefault,3>(index3d[0], index3d[1], index3d[2]);
}
int g_CheckArrayInvocations;
@ -57,6 +57,8 @@ struct CheckArray
template<typename ArrayType>
void operator()(const ArrayType &array) const
{
typedef typename ArrayType::ValueType ValueType;
std::cout << " In CastAndCall functor" << std::endl;
g_CheckArrayInvocations++;
typename ArrayType::PortalConstControl portal =
@ -67,8 +69,8 @@ struct CheckArray
for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
{
const vtkm::Vector3 receivedValue = portal.Get(index);
const vtkm::Vector3 expectedValue = TestValue(index);
const ValueType receivedValue = portal.Get(index);
const ValueType expectedValue = TestValue(index);
VTKM_TEST_ASSERT(receivedValue == expectedValue,
"Got bad value in array.");
}
@ -77,7 +79,7 @@ struct CheckArray
struct UnusualPortal
{
typedef vtkm::Vector3 ValueType;
typedef vtkm::Vec<vtkm::FloatDefault,3> ValueType;
VTKM_EXEC_CONT_EXPORT
vtkm::Id GetNumberOfValues() const { return ARRAY_SIZE; }
@ -87,9 +89,9 @@ struct UnusualPortal
};
class ArrayHandleWithUnusualStorage
: public vtkm::cont::ArrayHandle<vtkm::Vector3, vtkm::cont::StorageTagImplicit<UnusualPortal> >
: public vtkm::cont::ArrayHandle<UnusualPortal::ValueType, vtkm::cont::StorageTagImplicit<UnusualPortal> >
{
typedef vtkm::cont::ArrayHandle<vtkm::Vector3, vtkm::cont::StorageTagImplicit<UnusualPortal> >
typedef vtkm::cont::ArrayHandle<UnusualPortal::ValueType, vtkm::cont::StorageTagImplicit<UnusualPortal> >
Superclass;
public:
VTKM_CONT_EXPORT
@ -113,25 +115,29 @@ struct PointCoordinatesUnusual : vtkm::cont::internal::PointCoordinatesBase
struct PointCoordinatesListUnusual
: vtkm::ListTagBase<PointCoordinatesUnusual> { };
void TryDefaultArray()
struct TryDefaultArray
{
std::cout << "Trying a basic point coordinates array with a default storage."
<< std::endl;
std::vector<vtkm::Vector3> buffer(ARRAY_SIZE);
for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
template<typename Vector3>
void operator()(Vector3) const
{
buffer[index] = TestValue(index);
std::cout << "Trying basic point coordinates array with a default storage."
<< std::endl;
std::vector<Vector3> buffer(ARRAY_SIZE);
for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
{
buffer[index] = TestValue(index);
}
vtkm::cont::DynamicPointCoordinates pointCoordinates =
vtkm::cont::DynamicPointCoordinates(
vtkm::cont::make_ArrayHandle(buffer));
pointCoordinates.CastAndCall(CheckArray());
VTKM_TEST_ASSERT(g_CheckArrayInvocations == 1,
"CastAndCall functor not called expected number of times.");
}
vtkm::cont::DynamicPointCoordinates pointCoordinates =
vtkm::cont::DynamicPointCoordinates(
vtkm::cont::make_ArrayHandle(buffer));
pointCoordinates.CastAndCall(CheckArray());
VTKM_TEST_ASSERT(g_CheckArrayInvocations == 1,
"CastAndCall functor not called expected number of times.");
}
};
void TryUnusualStorage()
{
@ -205,7 +211,7 @@ void TryUnusualPointCoordinates()
void DynamicPointCoordiantesTest()
{
TryDefaultArray();
vtkm::testing::Testing::TryTypes(TryDefaultArray(), vtkm::TypeListTagVec3());
TryUnusualStorage();
TryUniformPointCoordinates();
TryUnusualPointCoordinates();

67
vtkm/cont/testing/UnitTestPointCoordinates.cxx
View File

@ -42,8 +42,10 @@
namespace {
const vtkm::Extent3 EXTENT = vtkm::Extent3(vtkm::Id3(0,0,0), vtkm::Id3(9,9,9));
const vtkm::Vector3 ORIGIN = vtkm::Vector3(0, 0, 0);
const vtkm::Vector3 SPACING = vtkm::Vector3(1, 1, 1);
const vtkm::Vec<vtkm::FloatDefault,3> ORIGIN =
vtkm::Vec<vtkm::FloatDefault,3>(0, 0, 0);
const vtkm::Vec<vtkm::FloatDefault,3> SPACING =
vtkm::Vec<vtkm::FloatDefault,3>(1, 1, 1);
const vtkm::Id3 DIMENSION = vtkm::ExtentPointDimensions(EXTENT);
const vtkm::Id ARRAY_SIZE = DIMENSION[0]*DIMENSION[1]*DIMENSION[2];
@ -52,12 +54,10 @@ typedef vtkm::cont::StorageTagBasic StorageTag;
struct StorageListTag : vtkm::cont::StorageListTagBasic { };
vtkm::Vector3 TestValue(vtkm::Id index)
vtkm::Vec<vtkm::FloatDefault,3> TestValue(vtkm::Id index)
{
vtkm::Id3 index3d = vtkm::ExtentPointFlatIndexToTopologyIndex(index, EXTENT);
return vtkm::Vector3(vtkm::Scalar(index3d[0]),
vtkm::Scalar(index3d[1]),
vtkm::Scalar(index3d[2]));
return vtkm::Vec<vtkm::FloatDefault,3>(index3d[0], index3d[1], index3d[2]);
}
struct CheckArray
@ -65,6 +65,8 @@ struct CheckArray
template<typename ArrayType>
void operator()(const ArrayType &array) const
{
typedef typename ArrayType::ValueType ValueType;
std::cout << " In CastAndCall functor" << std::endl;
typename ArrayType::PortalConstControl portal =
array.GetPortalConstControl();
@ -74,38 +76,42 @@ struct CheckArray
for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
{
const vtkm::Vector3 receivedValue = portal.Get(index);
const vtkm::Vector3 expectedValue = TestValue(index);
const ValueType receivedValue = portal.Get(index);
const ValueType expectedValue = TestValue(index);
VTKM_TEST_ASSERT(receivedValue == expectedValue,
"Got bad value in array.");
}
}
};
void TestPointCoordinatesArray()
struct TestPointCoordinatesArray
{
std::cout << "Testing PointCoordinatesArray" << std::endl;
std::cout << " Creating buffer of data values" << std::endl;
std::vector<vtkm::Vector3> buffer(ARRAY_SIZE);
for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
template<typename Vector3>
void operator()(Vector3) const
{
buffer[index] = TestValue(index);
std::cout << "Testing PointCoordinatesArray" << std::endl;
std::cout << " Creating buffer of data values" << std::endl;
std::vector<Vector3> buffer(ARRAY_SIZE);
for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
{
buffer[index] = TestValue(index);
}
std::cout << " Creating and checking array handle" << std::endl;
vtkm::cont::ArrayHandle<Vector3,StorageTag> array =
vtkm::cont::make_ArrayHandle(buffer, StorageTag());
CheckArray()(array);
std::cout << " Creating and checking PointCoordinatesArray" << std::endl;
vtkm::cont::PointCoordinatesArray pointCoordinates =
vtkm::cont::PointCoordinatesArray(array);
pointCoordinates.CastAndCall(
CheckArray(),
vtkm::ListTagEmpty(), // Internally sets to Vector3
vtkm::cont::StorageListTagBasic());
}
std::cout << " Creating and checking array handle" << std::endl;
vtkm::cont::ArrayHandle<vtkm::Vector3,StorageTag> array =
vtkm::cont::make_ArrayHandle(buffer, StorageTag());
CheckArray()(array);
std::cout << " Creating and checking PointCoordinatesArray" << std::endl;
vtkm::cont::PointCoordinatesArray pointCoordinates =
vtkm::cont::PointCoordinatesArray(array);
pointCoordinates.CastAndCall(
CheckArray(),
vtkm::ListTagEmpty(), // Internally sets to Vector3
vtkm::cont::StorageListTagBasic());
}
};
void TestPointCoordinatesUniform()
{
@ -121,7 +127,8 @@ void TestPointCoordinatesUniform()
void PointCoordinatesTests()
{
TestPointCoordinatesArray();
vtkm::testing::Testing::TryTypes(TestPointCoordinatesArray(),
vtkm::TypeListTagVec3());
TestPointCoordinatesUniform();
}

2
vtkm/cont/testing/UnitTestTimer.cxx
View File

@ -38,7 +38,7 @@ void Time()
Sleep(1000);
#endif
vtkm::Scalar elapsedTime = timer.GetElapsedTime();
vtkm::Float64 elapsedTime = timer.GetElapsedTime();
std::cout << "Elapsed time: " << elapsedTime << std::endl;

2
vtkm/internal/testing/UnitTestConfigureFor32.cxx
View File

@ -45,7 +45,7 @@ void TestTypeSizes()
"vtkm::Id an unexpected size.");
VTKM_TEST_ASSERT(VTKM_SIZE_SCALAR == EXPECTED_SIZE,
"VTKM_SIZE_SCALAR an unexpected size.");
VTKM_TEST_ASSERT(sizeof(vtkm::Scalar) == EXPECTED_SIZE,
VTKM_TEST_ASSERT(sizeof(vtkm::FloatDefault) == EXPECTED_SIZE,
"vtkm::Scalar an unexpected size.");
}

2
vtkm/internal/testing/UnitTestConfigureFor64.cxx
View File

@ -45,7 +45,7 @@ void TestTypeSizes()
"vtkm::Id an unexpected size.");
VTKM_TEST_ASSERT(VTKM_SIZE_SCALAR == EXPECTED_SIZE,
"VTKM_SIZE_SCALAR an unexpected size.");
VTKM_TEST_ASSERT(sizeof(vtkm::Scalar) == EXPECTED_SIZE,
VTKM_TEST_ASSERT(sizeof(vtkm::FloatDefault) == EXPECTED_SIZE,
"vtkm::Scalar an unexpected size.");
}

70
vtkm/internal/testing/UnitTestFunctionInterface.cxx
View File

@ -32,13 +32,13 @@ namespace {
typedef vtkm::Id Type1;
const Type1 Arg1 = 1234;
typedef vtkm::Scalar Type2;
typedef vtkm::Float64 Type2;
const Type2 Arg2 = 5678.125;
typedef std::string Type3;
const Type3 Arg3("Third argument");
typedef vtkm::Vector3 Type4;
typedef vtkm::Vec<vtkm::Float32,3> Type4;
const Type4 Arg4(1.2f, 3.4f, 5.6f);
typedef vtkm::Id3 Type5;
@ -151,16 +151,16 @@ struct FiveArgSwizzledFunctor {
struct LotsOfArgsFunctor {
LotsOfArgsFunctor() : Field(0) { }
void operator()(vtkm::Scalar arg1,
vtkm::Scalar arg2,
vtkm::Scalar arg3,
vtkm::Scalar arg4,
vtkm::Scalar arg5,
vtkm::Scalar arg6,
vtkm::Scalar arg7,
vtkm::Scalar arg8,
vtkm::Scalar arg9,
vtkm::Scalar arg10) {
void operator()(vtkm::FloatDefault arg1,
vtkm::FloatDefault arg2,
vtkm::FloatDefault arg3,
vtkm::FloatDefault arg4,
vtkm::FloatDefault arg5,
vtkm::FloatDefault arg6,
vtkm::FloatDefault arg7,
vtkm::FloatDefault arg8,
vtkm::FloatDefault arg9,
vtkm::FloatDefault arg10) {
VTKM_TEST_ASSERT(arg1 == 1.0, "Got bad argument");
VTKM_TEST_ASSERT(arg2 == 2.0, "Got bad argument");
VTKM_TEST_ASSERT(arg3 == 3.0, "Got bad argument");
@ -175,7 +175,7 @@ struct LotsOfArgsFunctor {
this->Field +=
arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10;
}
vtkm::Scalar Field;
vtkm::FloatDefault Field;
};
template<typename T>
@ -458,37 +458,37 @@ void TestInvokeTime()
{
f(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f);
}
vtkm::Scalar directCallTime = timer.GetElapsedTime();
vtkm::Float64 directCallTime = timer.GetElapsedTime();
std::cout << "Time for direct call: " << directCallTime << " seconds"
<< std::endl;
vtkm::internal::FunctionInterface<void(vtkm::Scalar,
vtkm::Scalar,
vtkm::Scalar,
vtkm::Scalar,
vtkm::Scalar,
vtkm::Scalar,
vtkm::Scalar,
vtkm::Scalar,
vtkm::Scalar,
vtkm::Scalar)> funcInterface =
vtkm::internal::make_FunctionInterface<void>(vtkm::Scalar(1),
vtkm::Scalar(2),
vtkm::Scalar(3),
vtkm::Scalar(4),
vtkm::Scalar(5),
vtkm::Scalar(6),
vtkm::Scalar(7),
vtkm::Scalar(8),
vtkm::Scalar(9),
vtkm::Scalar(10));
vtkm::internal::FunctionInterface<void(vtkm::FloatDefault,
vtkm::FloatDefault,
vtkm::FloatDefault,
vtkm::FloatDefault,
vtkm::FloatDefault,
vtkm::FloatDefault,
vtkm::FloatDefault,
vtkm::FloatDefault,
vtkm::FloatDefault,
vtkm::FloatDefault)> funcInterface =
vtkm::internal::make_FunctionInterface<void>(vtkm::FloatDefault(1),
vtkm::FloatDefault(2),
vtkm::FloatDefault(3),
vtkm::FloatDefault(4),
vtkm::FloatDefault(5),
vtkm::FloatDefault(6),
vtkm::FloatDefault(7),
vtkm::FloatDefault(8),
vtkm::FloatDefault(9),
vtkm::FloatDefault(10));
timer.Reset();
for (vtkm::Id trial = 0; trial < NUM_TRIALS; trial++)
{
funcInterface.InvokeCont(f);
}
vtkm::Scalar invokeCallTime = timer.GetElapsedTime();
vtkm::Float64 invokeCallTime = timer.GetElapsedTime();
std::cout << "Time for invoking function interface: " << invokeCallTime
<< " seconds" << std::endl;
std::cout << "Pointless result (makeing sure compiler computes it) "

4
vtkm/testing/UnitTestTesting.cxx
View File

@ -42,9 +42,9 @@ void GoodAssert()
void TestTestEqual()
{
VTKM_TEST_ASSERT(test_equal(vtkm::Scalar(2.0), vtkm::Scalar(1.9999999)),
VTKM_TEST_ASSERT(test_equal(2.0, 1.9999999),
"These should be close enough.");
VTKM_TEST_ASSERT(!test_equal(vtkm::Scalar(2.0), vtkm::Scalar(1.999)),
VTKM_TEST_ASSERT(!test_equal(2.0, 1.999),
"These should not be close enough.");
}

4
vtkm/testing/UnitTestTypeTraits.cxx
View File

@ -75,8 +75,8 @@ static void TestTypeTraits()
{
TypeTraitTest test;
vtkm::testing::Testing::TryAllTypes(test);
std::cout << "vtkm::Vec<vtkm::Scalar, 5>" << std::endl;
test(vtkm::Vec<vtkm::Scalar, 5>());
std::cout << "vtkm::Vec<vtkm::FloatDefault, 5>" << std::endl;
test(vtkm::Vec<vtkm::FloatDefault, 5>());
}
} // anonymous namespace

12
vtkm/testing/UnitTestTypes.cxx
View File

@ -176,7 +176,7 @@ void TypeTest(const vtkm::Vec<Scalar,2> &)
"Vectors to not multiply correctly.");
Vector div = a / b;
VTKM_TEST_ASSERT(test_equal(div, vtkm::make_Vector2(2, 2)),
VTKM_TEST_ASSERT(test_equal(div, vtkm::make_Vec(2, 2)),
"Vectors to not divide correctly.");
mult = s * a;
@ -248,7 +248,7 @@ void TypeTest(const vtkm::Vec<Scalar,3> &)
VTKM_TEST_ASSERT(test_equal(mult, vtkm::make_Vec(10, 20, 30)),
"Vector and scalar to not multiply correctly.");
vtkm::Scalar d = vtkm::dot(a, b);
Scalar d = vtkm::dot(a, b);
VTKM_TEST_ASSERT(test_equal(d, Scalar(28)), "dot(Vector3) wrong");
VTKM_TEST_ASSERT(!(a < b), "operator< wrong");
@ -309,8 +309,8 @@ void TypeTest(const vtkm::Vec<Scalar,4> &)
VTKM_TEST_ASSERT(test_equal(mult, vtkm::make_Vec(10, 20, 30, 40)),
"Vector and scalar to not multiply correctly.");
vtkm::Scalar d = vtkm::dot(a, b);
VTKM_TEST_ASSERT(test_equal(d, vtkm::Scalar(60)), "dot(Vector4) wrong");
Scalar d = vtkm::dot(a, b);
VTKM_TEST_ASSERT(test_equal(d, Scalar(60)), "dot(Vector4) wrong");
VTKM_TEST_ASSERT(!(a < b), "operator< wrong");
@ -396,11 +396,11 @@ void TestTypes()
vtkm::testing::Testing::TryAllTypes(TypeTestFunctor());
//try with some custom tuple types
TypeTestFunctor()( vtkm::Vec<vtkm::Scalar,6>() );
TypeTestFunctor()( vtkm::Vec<vtkm::FloatDefault,6>() );
TypeTestFunctor()( vtkm::Vec<vtkm::Id,4>() );
TypeTestFunctor()( vtkm::Vec<unsigned char,4>() );
TypeTestFunctor()( vtkm::Vec<vtkm::Id,1>() );
TypeTestFunctor()( vtkm::Vec<vtkm::Scalar,1>() );
TypeTestFunctor()( vtkm::Vec<vtkm::Float64,1>() );
}
} // anonymous namespace

10
vtkm/testing/UnitTestVecTraits.cxx
View File

@ -47,14 +47,14 @@ void TestVecTraits()
{
TestVecTypeFunctor test;
vtkm::testing::Testing::TryAllTypes(test);
std::cout << "vtkm::Vec<vtkm::Scalar, 5>" << std::endl;
test(vtkm::Vec<vtkm::Scalar,5>());
std::cout << "vtkm::Vec<vtkm::FloatDefault, 5>" << std::endl;
test(vtkm::Vec<vtkm::FloatDefault,5>());
vtkm::testing::TestVecComponentsTag<vtkm::Id3>();
vtkm::testing::TestVecComponentsTag<vtkm::Vector3>();
vtkm::testing::TestVecComponentsTag<vtkm::Vector4>();
vtkm::testing::TestVecComponentsTag<vtkm::Vec<vtkm::FloatDefault,3> >();
vtkm::testing::TestVecComponentsTag<vtkm::Vec<vtkm::FloatDefault,4> >();
vtkm::testing::TestScalarComponentsTag<vtkm::Id>();
vtkm::testing::TestScalarComponentsTag<vtkm::Scalar>();
vtkm::testing::TestScalarComponentsTag<vtkm::FloatDefault>();
}
} // anonymous namespace