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

Change vtkm::Tuple to vtkm::Vec

Browse Source 
There are multiple reasons for this name change:

* The name Tuple conflicts with the boost::Tuple class, which as a
different interface and feature set. This gets confusing, especially
since VTK-m uses boost quite a bit.

* The use of this class is usually (although not always) as a
mathematical vector.

* The vtkm::Scalar and vtkm::Vector* classes are going to go away soon
to better support multiple base data type widths. Having this
abbriviated name will hopefully make the code a bit nicer when these
types have to be explicitly specified.

Also modified the implementation a bit to consolidate some of the code.
This commit is contained in:
Kenneth Moreland 2014-10-07 17:17:03 -06:00
parent cbe6284b83
commit 2139d93206
16 changed files with 793 additions and 516 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
vtkm/Extent.h
View File

@ -30,15 +30,15 @@ namespace vtkm {
template<vtkm::IdComponent Dimensions>
struct Extent
{
vtkm::Tuple<vtkm::Id,Dimensions> Min;
vtkm::Tuple<vtkm::Id,Dimensions> Max;
vtkm::Vec<vtkm::Id,Dimensions> Min;
vtkm::Vec<vtkm::Id,Dimensions> Max;
VTKM_EXEC_CONT_EXPORT
Extent() : Min(0), Max(0) { }
VTKM_EXEC_CONT_EXPORT
Extent(const vtkm::Tuple<vtkm::Id,Dimensions> &min,
const vtkm::Tuple<vtkm::Id,Dimensions> &max)
Extent(const vtkm::Vec<vtkm::Id,Dimensions> &min,
const vtkm::Vec<vtkm::Id,Dimensions> &max)
: Min(min), Max(max) { }
VTKM_EXEC_CONT_EXPORT
@ -68,10 +68,10 @@ typedef vtkm::Extent<2> Extent2;
///
template<vtkm::IdComponent Dimensions>
VTKM_EXEC_CONT_EXPORT
vtkm::Tuple<vtkm::Id,Dimensions>
vtkm::Vec<vtkm::Id,Dimensions>
ExtentPointDimensions(const vtkm::Extent<Dimensions> &extent)
{
return extent.Max - extent.Min + vtkm::Tuple<vtkm::Id,Dimensions>(1);
return extent.Max - extent.Min + vtkm::Vec<vtkm::Id,Dimensions>(1);
}
VTKM_EXEC_CONT_EXPORT
@ -95,7 +95,7 @@ vtkm::Id2 ExtentPointDimensions(const vtkm::Extent2 &extent)
///
template<vtkm::IdComponent Dimensions>
VTKM_EXEC_CONT_EXPORT
vtkm::Tuple<vtkm::Id,Dimensions>
vtkm::Vec<vtkm::Id,Dimensions>
ExtentCellDimensions(const vtkm::Extent<Dimensions> &extent)
{
return extent.Max - extent.Min;
@ -107,7 +107,7 @@ template<vtkm::IdComponent Dimensions>
VTKM_EXEC_CONT_EXPORT
vtkm::Id ExtentNumberOfPoints(const vtkm::Extent<Dimensions> &extent)
{
return internal::product_vector<Dimensions>()(
return internal::VecProduct<Dimensions>()(
vtkm::ExtentPointDimensions(extent));
}
@ -138,7 +138,7 @@ template<vtkm::IdComponent Dimensions>
VTKM_EXEC_CONT_EXPORT
vtkm::Id ExtentNumberOfCells(const vtkm::Extent<Dimensions> &extent)
{
return internal::product_vector<Dimensions>()(
return internal::VecProduct<Dimensions>()(
vtkm::ExtentCellDimensions(extent));
}
@ -170,13 +170,13 @@ vtkm::Id ExtentNumberOfCells(const vtkm::Extent2 &extent)
///
template<vtkm::IdComponent Dimensions>
VTKM_EXEC_CONT_EXPORT
vtkm::Tuple<vtkm::Id,Dimensions>
vtkm::Vec<vtkm::Id,Dimensions>
ExtentPointFlatIndexToTopologyIndex(vtkm::Id index,
const vtkm::Extent<Dimensions> &extent)
{
const vtkm::Tuple<vtkm::Id,Dimensions> dims =
const vtkm::Vec<vtkm::Id,Dimensions> dims =
vtkm::ExtentPointDimensions(extent);
vtkm::Tuple<vtkm::Id,Dimensions> ijkIndex;
vtkm::Vec<vtkm::Id,Dimensions> ijkIndex;
vtkm::Id indexOnDim = index;
for (vtkm::IdComponent dimIndex = 0; dimIndex < Dimensions-1; dimIndex++)
{
@ -218,13 +218,13 @@ vtkm::Id2 ExtentPointFlatIndexToTopologyIndex(vtkm::Id index,
///
template<vtkm::IdComponent Dimensions>
VTKM_EXEC_CONT_EXPORT
vtkm::Tuple<vtkm::Id,Dimensions>
vtkm::Vec<vtkm::Id,Dimensions>
ExtentCellFlatIndexToTopologyIndex(vtkm::Id index,
const vtkm::Extent<Dimensions> &extent)
{
const vtkm::Tuple<vtkm::Id,Dimensions> dims =
const vtkm::Vec<vtkm::Id,Dimensions> dims =
vtkm::ExtentCellDimensions(extent);
vtkm::Tuple<vtkm::Id,Dimensions> ijkIndex;
vtkm::Vec<vtkm::Id,Dimensions> ijkIndex;
vtkm::Id indexOnDim = index;
for (vtkm::IdComponent dimIndex = 0; dimIndex < Dimensions-1; dimIndex++)
{
@ -267,11 +267,11 @@ vtkm::Id2 ExtentCellFlatIndexToTopologyIndex(vtkm::Id index,
template<vtkm::IdComponent Dimensions>
VTKM_EXEC_CONT_EXPORT
vtkm::Id
ExtentPointTopologyIndexToFlatIndex(const vtkm::Tuple<vtkm::Id,Dimensions> &ijk,
ExtentPointTopologyIndexToFlatIndex(const vtkm::Vec<vtkm::Id,Dimensions> &ijk,
const vtkm::Extent<Dimensions> &extent)
{
const vtkm::Tuple<vtkm::Id,Dimensions> dims = ExtentPointDimensions(extent);
const vtkm::Tuple<vtkm::Id,Dimensions> deltas = ijk - extent.Min;
const vtkm::Vec<vtkm::Id,Dimensions> dims = ExtentPointDimensions(extent);
const vtkm::Vec<vtkm::Id,Dimensions> deltas = ijk - extent.Min;
vtkm::Id flatIndex = deltas[Dimensions-1];
for (vtkm::IdComponent dimIndex = Dimensions-2; dimIndex >= 0; dimIndex--)
{
@ -288,11 +288,11 @@ ExtentPointTopologyIndexToFlatIndex(const vtkm::Tuple<vtkm::Id,Dimensions> &ijk,
template<vtkm::IdComponent Dimensions>
VTKM_EXEC_CONT_EXPORT
vtkm::Id
ExtentCellTopologyIndexToFlatIndex(const vtkm::Tuple<vtkm::Id,Dimensions> &ijk,
ExtentCellTopologyIndexToFlatIndex(const vtkm::Vec<vtkm::Id,Dimensions> &ijk,
const vtkm::Extent<Dimensions> &extent)
{
const vtkm::Tuple<vtkm::Id,Dimensions> dims = ExtentCellDimensions(extent);
const vtkm::Tuple<vtkm::Id,Dimensions> deltas = ijk - extent.Min;
const vtkm::Vec<vtkm::Id,Dimensions> dims = ExtentCellDimensions(extent);
const vtkm::Vec<vtkm::Id,Dimensions> deltas = ijk - extent.Min;
vtkm::Id flatIndex = deltas[Dimensions-1];
for (vtkm::IdComponent dimIndex = Dimensions-2; dimIndex >= 0; dimIndex--)
{

2
vtkm/TypeTraits.h
View File

@ -137,7 +137,7 @@ VTKM_VECTOR_TYPE(vtkm::Vector4, TypeTraitsRealTag);
/// Traits for tuples.
///
template<typename T, vtkm::IdComponent Size>
struct TypeTraits<vtkm::Tuple<T, Size> >
struct TypeTraits<vtkm::Vec<T, Size> >
{
typedef typename TypeTraits<T>::NumericTag NumericTag;
typedef TypeTraitsVectorTag DimensionalityTag;

1108
vtkm/Types.h
View File

File diff suppressed because it is too large Load Diff

47
vtkm/VectorTraits.h
View File

@ -88,11 +88,11 @@ struct VectorTraits
vtkm::IdComponent component,
ComponentType value);
/// Converts whatever type this vector is into the standard VTKm Tuple.
/// Converts whatever type this vector is into the standard VTK-m Vec.
///
VTKM_EXEC_CONT_EXPORT
static vtkm::Tuple<ComponentType,NUM_COMPONENTS>
ToTuple(const VectorType &vector);
static vtkm::Vec<ComponentType,NUM_COMPONENTS>
ToVec(const VectorType &vector);
};
#else // VTKM_DOXYGEN_ONLY
;
@ -106,9 +106,9 @@ struct VectorTraits<const T> : VectorTraits<T>
{ };
template<typename T, vtkm::IdComponent Size>
struct VectorTraits<vtkm::Tuple<T,Size> >
struct VectorTraits<vtkm::Vec<T,Size> >
{
typedef vtkm::Tuple<T,Size> VectorType;
typedef vtkm::Vec<T,Size> VectorType;
/// Type of the components in the vector.
///
@ -149,8 +149,8 @@ struct VectorTraits<vtkm::Tuple<T,Size> >
/// Converts whatever type this vector is into the standard VTKm Tuple.
///
VTKM_EXEC_CONT_EXPORT
static vtkm::Tuple<ComponentType,NUM_COMPONENTS>
ToTuple(const VectorType &vector)
static vtkm::Vec<ComponentType,NUM_COMPONENTS>
ToVec(const VectorType &vector)
{
return vector;
}
@ -182,9 +182,9 @@ struct VectorTraitsBasic {
}
VTKM_EXEC_CONT_EXPORT
static vtkm::Tuple<ScalarType,1> ToTuple(const ScalarType &vector)
static vtkm::Vec<ScalarType,1> ToVec(const ScalarType &vector)
{
return vtkm::Tuple<ScalarType,1>(vector);
return vtkm::Vec<ScalarType,1>(vector);
}
};
}
@ -192,30 +192,23 @@ struct VectorTraitsBasic {
#define VTKM_BASIC_TYPE_VECTOR(type) \
template<> \
struct VectorTraits<type> \
: public vtkm::internal::VectorTraitsBasic<type> { };/* \
: public vtkm::internal::VectorTraitsBasic<type> { }/*; \
template<> \
struct VectorTraits<const type> \
: public vtkm::internal::VectorTraitsBasic<type> { }*/
/// Allows you to treat basic types as if they were vectors.
VTKM_BASIC_TYPE_VECTOR(float);
VTKM_BASIC_TYPE_VECTOR(double);
VTKM_BASIC_TYPE_VECTOR(char);
VTKM_BASIC_TYPE_VECTOR(unsigned char);
VTKM_BASIC_TYPE_VECTOR(short);
VTKM_BASIC_TYPE_VECTOR(unsigned short);
VTKM_BASIC_TYPE_VECTOR(int);
VTKM_BASIC_TYPE_VECTOR(unsigned int);
#if VTKM_SIZE_LONG == 8
VTKM_BASIC_TYPE_VECTOR(long);
VTKM_BASIC_TYPE_VECTOR(unsigned long);
#elif VTKM_SIZE_LONG_LONG == 8
VTKM_BASIC_TYPE_VECTOR(long long);
VTKM_BASIC_TYPE_VECTOR(unsigned long long);
#else
#error No implementation for 64-bit vector traits.
#endif
VTKM_BASIC_TYPE_VECTOR(vtkm::Float32);
VTKM_BASIC_TYPE_VECTOR(vtkm::Float64);
VTKM_BASIC_TYPE_VECTOR(vtkm::Int8);
VTKM_BASIC_TYPE_VECTOR(vtkm::UInt8);
VTKM_BASIC_TYPE_VECTOR(vtkm::Int16);
VTKM_BASIC_TYPE_VECTOR(vtkm::UInt16);
VTKM_BASIC_TYPE_VECTOR(vtkm::Int32);
VTKM_BASIC_TYPE_VECTOR(vtkm::UInt32);
VTKM_BASIC_TYPE_VECTOR(vtkm::Int64);
VTKM_BASIC_TYPE_VECTOR(vtkm::UInt64);
#undef VTKM_BASIC_TYPE_VECTOR

16
vtkm/cont/ArrayHandleCompositeVector.h
View File

@ -42,7 +42,7 @@ struct CompositeVectorSwizzleFunctor
{
static const vtkm::IdComponent NUM_COMPONENTS =
vtkm::VectorTraits<ValueType>::NUM_COMPONENTS;
typedef vtkm::Tuple<vtkm::IdComponent, NUM_COMPONENTS> ComponentMapType;
typedef vtkm::Vec<vtkm::IdComponent, NUM_COMPONENTS> ComponentMapType;
// Caution! This is a reference.
const ComponentMapType &SourceComponents;
@ -166,7 +166,7 @@ template<typename SignatureWithPortals>
class ArrayPortalCompositeVector
{
typedef vtkm::internal::FunctionInterface<SignatureWithPortals> PortalTypes;
typedef vtkm::Tuple<vtkm::IdComponent, PortalTypes::ARITY> ComponentMapType;
typedef vtkm::Vec<vtkm::IdComponent, PortalTypes::ARITY> ComponentMapType;
public:
typedef typename PortalTypes::ResultType ValueType;
@ -181,7 +181,7 @@ public:
VTKM_CONT_EXPORT
ArrayPortalCompositeVector(
const PortalTypes portals,
vtkm::Tuple<vtkm::IdComponent, NUM_COMPONENTS> sourceComponents)
vtkm::Vec<vtkm::IdComponent, NUM_COMPONENTS> sourceComponents)
: Portals(portals), SourceComponents(sourceComponents) { }
VTKM_EXEC_EXPORT
@ -223,7 +223,7 @@ public:
typedef typename FunctionInterfaceArrays::ResultType ValueType;
static const vtkm::IdComponent NUM_COMPONENTS =
vtkm::VectorTraits<ValueType>::NUM_COMPONENTS;
typedef vtkm::Tuple<vtkm::IdComponent, NUM_COMPONENTS> ComponentMapType;
typedef vtkm::Vec<vtkm::IdComponent, NUM_COMPONENTS> ComponentMapType;
// If you get a compile error here, it means you probably tried to create
// an ArrayHandleCompositeVector with a return type of a vector with a
@ -284,7 +284,7 @@ class Storage<
typedef vtkm::internal::FunctionInterface<SignatureWithArrays>
FunctionInterfaceWithArrays;
static const vtkm::IdComponent NUM_COMPONENTS = FunctionInterfaceWithArrays::ARITY;
typedef vtkm::Tuple<vtkm::IdComponent, NUM_COMPONENTS> ComponentMapType;
typedef vtkm::Vec<vtkm::IdComponent, NUM_COMPONENTS> ComponentMapType;
public:
typedef ArrayPortalCompositeVectorCont<SignatureWithArrays> PortalType;
@ -609,7 +609,7 @@ struct ArrayHandleCompositeVectorType
private:
typedef typename vtkm::VectorTraits<typename ArrayHandleType1::ValueType>::ComponentType
ComponentType;
typedef vtkm::Tuple<ComponentType,4> Signature(
typedef vtkm::Vec<ComponentType,4> Signature(
ArrayHandleType1,ArrayHandleType2,ArrayHandleType3,ArrayHandleType4);
public:
typedef vtkm::cont::ArrayHandleCompositeVector<Signature> type;
@ -624,7 +624,7 @@ struct ArrayHandleCompositeVectorType<
private:
typedef typename vtkm::VectorTraits<typename ArrayHandleType1::ValueType>::ComponentType
ComponentType;
typedef vtkm::Tuple<ComponentType,3> Signature(
typedef vtkm::Vec<ComponentType,3> Signature(
ArrayHandleType1,ArrayHandleType2,ArrayHandleType3);
public:
typedef vtkm::cont::ArrayHandleCompositeVector<Signature> type;
@ -637,7 +637,7 @@ struct ArrayHandleCompositeVectorType<ArrayHandleType1,ArrayHandleType2>
private:
typedef typename vtkm::VectorTraits<typename ArrayHandleType1::ValueType>::ComponentType
ComponentType;
typedef vtkm::Tuple<ComponentType,2> Signature(
typedef vtkm::Vec<ComponentType,2> Signature(
ArrayHandleType1,ArrayHandleType2);
public:
typedef vtkm::cont::ArrayHandleCompositeVector<Signature> type;

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

@ -121,7 +121,7 @@ void TryScalarArray()
std::cout << "Creating a scalar array from one of "
<< inComponents << " components." << std::endl;
typedef vtkm::Tuple<vtkm::Scalar,inComponents> InValueType;
typedef vtkm::Vec<vtkm::Scalar,inComponents> InValueType;
typedef vtkm::cont::ArrayHandle<InValueType, StorageTag> InArrayType;
int inArrayId = 0;
InArrayType inArray = MakeInputArray<InValueType>(inArrayId);

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

@ -44,8 +44,8 @@ vtkm::Scalar TestValue(vtkm::Id index, vtkm::Scalar) {
}
template<typename T, vtkm::IdComponent N>
vtkm::Tuple<T,N> TestValue(vtkm::Id index, vtkm::Tuple<T,N>) {
vtkm::Tuple<T,N> value;
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);

6
vtkm/cont/testing/UnitTestStorageListTag.cxx
View File

@ -44,7 +44,7 @@ struct TestFunctor
};
template<vtkm::IdComponent N>
void CheckSame(const vtkm::Tuple<TypeId,N> &expected,
void CheckSame(const vtkm::Vec<TypeId,N> &expected,
const std::vector<TypeId> &found)
{
VTKM_TEST_ASSERT(static_cast<vtkm::IdComponent>(found.size()) == N,
@ -58,7 +58,7 @@ void CheckSame(const vtkm::Tuple<TypeId,N> &expected,
}
template<vtkm::IdComponent N, typename ListTag>
void TryList(const vtkm::Tuple<TypeId,N> &expected, ListTag)
void TryList(const vtkm::Vec<TypeId,N> &expected, ListTag)
{
TestFunctor functor;
vtkm::ListForEach(functor, ListTag());
@ -68,7 +68,7 @@ void TryList(const vtkm::Tuple<TypeId,N> &expected, ListTag)
void TestLists()
{
std::cout << "StorageListTagBasic" << std::endl;
TryList(vtkm::Tuple<TypeId,1>(BASIC), vtkm::cont::StorageListTagBasic());
TryList(vtkm::Vec<TypeId,1>(BASIC), vtkm::cont::StorageListTagBasic());
}
} // anonymous namespace

6
vtkm/testing/Testing.h
View File

@ -344,14 +344,14 @@ bool test_equal(const std::string &string1, const std::string &string2)
///
template<typename T, vtkm::IdComponent Size>
VTKM_EXEC_CONT_EXPORT
std::ostream &operator<<(std::ostream &stream, const vtkm::Tuple<T,Size> &tuple)
std::ostream &operator<<(std::ostream &stream, const vtkm::Vec<T,Size> &vec)
{
stream << "[";
for (vtkm::IdComponent component = 0; component < Size-1; component++)
{
stream << tuple[component] << ",";
stream << vec[component] << ",";
}
return stream << tuple[Size-1] << "]";
return stream << vec[Size-1] << "]";
}
#endif //vtk_m_testing_Testing_h

6
vtkm/testing/UnitTestExtent.cxx
View File

@ -38,8 +38,8 @@ void TestDimensions(vtkm::Extent<Dimensions>)
<< std::endl;
vtkm::Extent<Dimensions> extent;
vtkm::Tuple<vtkm::Id,Dimensions> pointDims;
vtkm::Tuple<vtkm::Id,Dimensions> cellDims;
vtkm::Vec<vtkm::Id,Dimensions> pointDims;
vtkm::Vec<vtkm::Id,Dimensions> cellDims;
vtkm::Id numPoints;
vtkm::Id numCells;
@ -82,7 +82,7 @@ void TestDimensions(vtkm::Extent<Dimensions>)
template<vtkm::IdComponent Dimensions>
void TryIndexConversion(const vtkm::Extent<Dimensions> &extent)
{
typedef vtkm::Tuple<vtkm::Id,Dimensions> IdX;
typedef vtkm::Vec<vtkm::Id,Dimensions> IdX;
vtkm::Id lastFlatIndex;
IdX correctTopologyIndex;

16
vtkm/testing/UnitTestListTag.cxx
View File

@ -81,7 +81,7 @@ struct ConstantFunctor
};
template<vtkm::IdComponent N>
void CheckSame(const vtkm::Tuple<int,N> &expected,
void CheckSame(const vtkm::Vec<int,N> &expected,
const std::vector<int> &found)
{
VTKM_TEST_ASSERT(static_cast<int>(found.size()) == N,
@ -95,7 +95,7 @@ void CheckSame(const vtkm::Tuple<int,N> &expected,
}
template<vtkm::IdComponent N, typename ListTag>
void TryList(const vtkm::Tuple<int,N> &expected, ListTag)
void TryList(const vtkm::Vec<int,N> &expected, ListTag)
{
std::cout << " Try mutable for each" << std::endl;
MutableFunctor functor;
@ -110,22 +110,22 @@ void TryList(const vtkm::Tuple<int,N> &expected, ListTag)
void TestLists()
{
std::cout << "ListTagEmpty" << std::endl;
TryList(vtkm::Tuple<int,0>(), vtkm::ListTagEmpty());
TryList(vtkm::Vec<int,0>(), vtkm::ListTagEmpty());
std::cout << "ListTagBase" << std::endl;
TryList(vtkm::Tuple<int,1>(11), TestListTag1());
TryList(vtkm::Vec<int,1>(11), TestListTag1());
std::cout << "ListTagBase2" << std::endl;
TryList(vtkm::Tuple<int,2>(21,22), TestListTag2());
TryList(vtkm::Vec<int,2>(21,22), TestListTag2());
std::cout << "ListTagBase3" << std::endl;
TryList(vtkm::Tuple<int,3>(31,32,33), TestListTag3());
TryList(vtkm::Vec<int,3>(31,32,33), TestListTag3());
std::cout << "ListTagBase4" << std::endl;
TryList(vtkm::Tuple<int,4>(41,42,43,44), TestListTag4());
TryList(vtkm::Vec<int,4>(41,42,43,44), TestListTag4());
std::cout << "ListTagJoin" << std::endl;
TryList(vtkm::Tuple<int,4>(31,32,33,11), TestListTagJoin());
TryList(vtkm::Vec<int,4>(31,32,33,11), TestListTagJoin());
}
} // anonymous namespace

26
vtkm/testing/UnitTestTypeListTag.cxx
View File

@ -58,7 +58,7 @@ struct TestFunctor
};
template<vtkm::IdComponent N>
void CheckSame(const vtkm::Tuple<TypeId,N> &expected,
void CheckSame(const vtkm::Vec<TypeId,N> &expected,
const std::vector<TypeId> &found)
{
VTKM_TEST_ASSERT(static_cast<vtkm::IdComponent>(found.size()) == N,
@ -72,7 +72,7 @@ void CheckSame(const vtkm::Tuple<TypeId,N> &expected,
}
template<vtkm::IdComponent N, typename ListTag>
void TryList(const vtkm::Tuple<TypeId,N> &expected, ListTag)
void TryList(const vtkm::Vec<TypeId,N> &expected, ListTag)
{
TestFunctor functor;
vtkm::ListForEach(functor, ListTag());
@ -82,38 +82,38 @@ void TryList(const vtkm::Tuple<TypeId,N> &expected, ListTag)
void TestLists()
{
std::cout << "TypeListTagId" << std::endl;
TryList(vtkm::Tuple<TypeId,1>(ID), vtkm::TypeListTagId());
TryList(vtkm::Vec<TypeId,1>(ID), vtkm::TypeListTagId());
std::cout << "TypeListTagId2" << std::endl;
TryList(vtkm::Tuple<TypeId,1>(ID2), vtkm::TypeListTagId2());
TryList(vtkm::Vec<TypeId,1>(ID2), vtkm::TypeListTagId2());
std::cout << "TypeListTagId3" << std::endl;
TryList(vtkm::Tuple<TypeId,1>(ID3), vtkm::TypeListTagId3());
TryList(vtkm::Vec<TypeId,1>(ID3), vtkm::TypeListTagId3());
std::cout << "TypeListTagScalar" << std::endl;
TryList(vtkm::Tuple<TypeId,1>(SCALAR), vtkm::TypeListTagScalar());
TryList(vtkm::Vec<TypeId,1>(SCALAR), vtkm::TypeListTagScalar());
std::cout << "TypeListTagVector2" << std::endl;
TryList(vtkm::Tuple<TypeId,1>(VECTOR2), vtkm::TypeListTagVector2());
TryList(vtkm::Vec<TypeId,1>(VECTOR2), vtkm::TypeListTagVector2());
std::cout << "TypeListTagVector3" << std::endl;
TryList(vtkm::Tuple<TypeId,1>(VECTOR3), vtkm::TypeListTagVector3());
TryList(vtkm::Vec<TypeId,1>(VECTOR3), vtkm::TypeListTagVector3());
std::cout << "TypeListTagVector4" << std::endl;
TryList(vtkm::Tuple<TypeId,1>(VECTOR4), vtkm::TypeListTagVector4());
TryList(vtkm::Vec<TypeId,1>(VECTOR4), vtkm::TypeListTagVector4());
std::cout << "TypeListTagIndex" << std::endl;
TryList(vtkm::Tuple<TypeId,3>(ID,ID2,ID3), vtkm::TypeListTagIndex());
TryList(vtkm::Vec<TypeId,3>(ID,ID2,ID3), vtkm::TypeListTagIndex());
std::cout << "TypeListTagReal" << std::endl;
TryList(vtkm::Tuple<TypeId,4>(SCALAR,VECTOR2,VECTOR3,VECTOR4),
TryList(vtkm::Vec<TypeId,4>(SCALAR,VECTOR2,VECTOR3,VECTOR4),
vtkm::TypeListTagReal());
std::cout << "TypeListTagCommon" << std::endl;
TryList(vtkm::Tuple<TypeId,3>(ID,SCALAR,VECTOR3), vtkm::TypeListTagCommon());
TryList(vtkm::Vec<TypeId,3>(ID,SCALAR,VECTOR3), vtkm::TypeListTagCommon());
std::cout << "TypeListTagAll" << std::endl;
vtkm::Tuple<TypeId,7> allTags;
vtkm::Vec<TypeId,7> allTags;
allTags[0] = ID;
allTags[1] = ID2;
allTags[2] = ID3;

4
vtkm/testing/UnitTestTypeTraits.cxx
View File

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

10
vtkm/testing/UnitTestTypes.cxx
View File

@ -497,11 +497,11 @@ void TestTypes()
vtkm::testing::Testing::TryAllTypes(TypeTestFunctor());
//try with some custom tuple types
TypeTestFunctor()( vtkm::Tuple<vtkm::Scalar,6>() );
TypeTestFunctor()( vtkm::Tuple<vtkm::Id,4>() );
TypeTestFunctor()( vtkm::Tuple<unsigned char,4>() );
TypeTestFunctor()( vtkm::Tuple<vtkm::Id,1>() );
TypeTestFunctor()( vtkm::Tuple<vtkm::Scalar,1>() );
TypeTestFunctor()( vtkm::Vec<vtkm::Scalar,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>() );
}
} // anonymous namespace

4
vtkm/testing/UnitTestVectorTraits.cxx
View File

@ -47,8 +47,8 @@ void TestVectorTraits()
{
TestVectorTypeFunctor test;
vtkm::testing::Testing::TryAllTypes(test);
std::cout << "vtkm::Tuple<vtkm::Scalar, 5>" << std::endl;
test(vtkm::Tuple<vtkm::Scalar,5>());
std::cout << "vtkm::Vec<vtkm::Scalar, 5>" << std::endl;
test(vtkm::Vec<vtkm::Scalar,5>());
vtkm::testing::TestVectorComponentsTag<vtkm::Id3>();
vtkm::testing::TestVectorComponentsTag<vtkm::Vector3>();

10
vtkm/testing/VectorTraitsTests.h
View File

@ -62,8 +62,8 @@ static void TestVectorTypeImpl(
{
Traits::SetComponent(result, i, multiplier*Traits::GetComponent(vector, i));
}
VTKM_TEST_ASSERT(test_equal(Traits::ToTuple(result),
multiplier*Traits::ToTuple(vector)),
VTKM_TEST_ASSERT(test_equal(Traits::ToVec(result),
multiplier*Traits::ToVec(vector)),
"Got bad result for scalar multiple");
}
@ -75,8 +75,8 @@ static void TestVectorTypeImpl(
Traits::GetComponent(result, i)
= multiplier * Traits::GetComponent(vector, i);
}
VTKM_TEST_ASSERT(test_equal(Traits::ToTuple(result),
multiplier*Traits::ToTuple(vector)),
VTKM_TEST_ASSERT(test_equal(Traits::ToVec(result),
multiplier*Traits::ToVec(vector)),
"Got bad result for scalar multiple");
}
@ -90,7 +90,7 @@ static void TestVectorTypeImpl(
}
VTKM_TEST_ASSERT(
test_equal(result,
vtkm::dot(Traits::ToTuple(vector), Traits::ToTuple(vector))),
vtkm::dot(Traits::ToVec(vector), Traits::ToVec(vector))),
"Got bad result for dot product");
}