ed9cf46a17
We made this change a while ago to help with completion in IDEs. (Completion was matching a bunch of wrapper macros that were almost never used anywhere.) Most of the changes are in comments, but there are a few bad macro definitions.
930 lines
23 KiB
C++
930 lines
23 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.
|
|
//
|
|
// Copyright 2014 Sandia Corporation.
|
|
// Copyright 2014 UT-Battelle, LLC.
|
|
// Copyright 2014. Los Alamos National Security
|
|
//
|
|
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
|
|
// the U.S. Government retains certain rights in this software.
|
|
//
|
|
// Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
|
|
// Laboratory (LANL), the U.S. Government retains certain rights in
|
|
// this software.
|
|
//============================================================================
|
|
#ifndef vtk_m_Types_h
|
|
#define vtk_m_Types_h
|
|
|
|
|
|
#include <vtkm/internal/Configure.h>
|
|
#include <vtkm/internal/ExportMacros.h>
|
|
|
|
/*!
|
|
* \namespace vtkm
|
|
* \brief VTKm Toolkit.
|
|
*
|
|
* vtkm is the namespace for the VTKm Toolkit. It contains other sub namespaces,
|
|
* as well as basic data types and functions callable from all components in VTKm
|
|
* toolkit.
|
|
*
|
|
* \namespace vtkm::cont
|
|
* \brief VTKm Control Environment.
|
|
*
|
|
* vtkm::cont defines the publicly accessible API for the VTKm Control
|
|
* Environment. Users of the VTKm Toolkit can use this namespace to access the
|
|
* Control Environment.
|
|
*
|
|
* \namespace vtkm::cuda
|
|
* \brief CUDA implementation.
|
|
*
|
|
* vtkm::cuda includes the code to implement the VTKm for CUDA-based platforms.
|
|
*
|
|
* \namespace vtkm::cuda::cont
|
|
* \brief CUDA implementation for Control Environment.
|
|
*
|
|
* vtkm::cuda::cont includes the code to implement the VTKm Control Environment
|
|
* for CUDA-based platforms.
|
|
*
|
|
* \namespace vtkm::cuda::exec
|
|
* \brief CUDA implementation for Execution Environment.
|
|
*
|
|
* vtkm::cuda::exec includes the code to implement the VTKm Execution Environment
|
|
* for CUDA-based platforms.
|
|
*
|
|
* \namespace vtkm::exec
|
|
* \brief VTKm Execution Environment.
|
|
*
|
|
* vtkm::exec defines the publicly accessible API for the VTKm Execution
|
|
* Environment. Worklets typically use classes/apis defined within this
|
|
* namespace alone.
|
|
*
|
|
* \namespace vtkm::internal
|
|
* \brief VTKm Internal Environment
|
|
*
|
|
* vtkm::internal defines API which is internal and subject to frequent
|
|
* change. This should not be used for projects using VTKm. Instead it servers
|
|
* are a reference for the developers of VTKm.
|
|
*
|
|
* \namespace vtkm::math
|
|
* \brief Utility math functions
|
|
*
|
|
* vtkm::math defines the publicly accessible API for Utility Math functions.
|
|
*
|
|
* \namespace vtkm::testing
|
|
* \brief Internal testing classes
|
|
*
|
|
*/
|
|
|
|
namespace vtkm {
|
|
//*****************************************************************************
|
|
// Typedefs for basic types.
|
|
//*****************************************************************************
|
|
|
|
/// Alignment requirements are prescribed by CUDA on device (Table B-1 in NVIDIA
|
|
/// CUDA C Programming Guide 4.0)
|
|
|
|
namespace internal {
|
|
|
|
#if VTKM_SIZE_INT == 4
|
|
typedef int Int32Type;
|
|
typedef unsigned int UInt32Type;
|
|
#else
|
|
#error Could not find a 32-bit integer.
|
|
#endif
|
|
|
|
#if VTKM_SIZE_LONG == 8
|
|
typedef long Int64Type;
|
|
typedef unsigned long UInt64Type;
|
|
#elif VTKM_SIZE_LONG_LONG == 8
|
|
typedef long long Int64Type;
|
|
typedef unsigned long long UInt64Type;
|
|
#else
|
|
#error Could not find a 64-bit integer.
|
|
#endif
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
template<int Size>
|
|
struct equals
|
|
{
|
|
template<typename T>
|
|
VTKM_EXEC_CONT_EXPORT bool operator()(const T& a, const T& b) const
|
|
{
|
|
return equals<Size-1>()(a,b) && a[Size-1] == b[Size-1];
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct equals<1>
|
|
{
|
|
template<typename T>
|
|
VTKM_EXEC_CONT_EXPORT bool operator()(const T& a, const T& b) const
|
|
{
|
|
return a[0] == b[0];
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct equals<2>
|
|
{
|
|
template<typename T>
|
|
VTKM_EXEC_CONT_EXPORT bool operator()(const T& a, const T& b) const
|
|
{
|
|
return a[0] == b[0] && a[1] == b[1];
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct equals<3>
|
|
{
|
|
template<typename T>
|
|
VTKM_EXEC_CONT_EXPORT bool operator()(const T& a, const T& b) const
|
|
{
|
|
return a[0] == b[0] && a[1] == b[1] && a[2] == b[2];
|
|
}
|
|
};
|
|
|
|
template<int Size>
|
|
struct assign_scalar_to_vector
|
|
{
|
|
template<typename VectorType, typename ComponentType>
|
|
VTKM_EXEC_CONT_EXPORT
|
|
void operator()(VectorType &dest, const ComponentType &src)
|
|
{
|
|
assign_scalar_to_vector<Size-1>()(dest, src);
|
|
dest[Size-1] = src;
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct assign_scalar_to_vector<1>
|
|
{
|
|
template<typename VectorType, typename ComponentType>
|
|
VTKM_EXEC_CONT_EXPORT
|
|
void operator()(VectorType &dest, const ComponentType &src)
|
|
{
|
|
dest[0] = src;
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct assign_scalar_to_vector<2>
|
|
{
|
|
template<typename VectorType, typename ComponentType>
|
|
VTKM_EXEC_CONT_EXPORT
|
|
void operator()(VectorType &dest, const ComponentType &src)
|
|
{
|
|
dest[0] = src;
|
|
dest[1] = src;
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct assign_scalar_to_vector<3>
|
|
{
|
|
template<typename VectorType, typename ComponentType>
|
|
VTKM_EXEC_CONT_EXPORT
|
|
void operator()(VectorType &dest, const ComponentType &src)
|
|
{
|
|
dest[0] = src;
|
|
dest[1] = src;
|
|
dest[2] = src;
|
|
}
|
|
};
|
|
|
|
template<int Size>
|
|
struct copy_vector
|
|
{
|
|
template<typename T1, typename T2>
|
|
VTKM_EXEC_CONT_EXPORT void operator()(T1 &dest, const T2 &src)
|
|
{
|
|
copy_vector<Size-1>()(dest, src);
|
|
dest[Size-1] = src[Size-1];
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct copy_vector<1>
|
|
{
|
|
template<typename T1, typename T2>
|
|
VTKM_EXEC_CONT_EXPORT void operator()(T1 &dest, const T2 &src)
|
|
{
|
|
dest[0] = src[0];
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct copy_vector<2>
|
|
{
|
|
template<typename T1, typename T2>
|
|
VTKM_EXEC_CONT_EXPORT void operator()(T1 &dest, const T2 &src)
|
|
{
|
|
dest[0] = src[0];
|
|
dest[1] = src[1];
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct copy_vector<3>
|
|
{
|
|
template<typename T1, typename T2>
|
|
VTKM_EXEC_CONT_EXPORT void operator()(T1 &dest, const T2 &src)
|
|
{
|
|
dest[0] = src[0];
|
|
dest[1] = src[1];
|
|
dest[2] = src[2];
|
|
}
|
|
};
|
|
|
|
template<int Size>
|
|
struct sum_vector
|
|
{
|
|
template<typename T>
|
|
VTKM_EXEC_CONT_EXPORT
|
|
typename T::ComponentType operator()(const T &x)
|
|
{
|
|
return sum_vector<Size-1>()(x) + x[Size-1];
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct sum_vector<1>
|
|
{
|
|
template<typename T>
|
|
VTKM_EXEC_CONT_EXPORT
|
|
typename T::ComponentType operator()(const T &x)
|
|
{
|
|
return x[0];
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct sum_vector<2>
|
|
{
|
|
template<typename T>
|
|
VTKM_EXEC_CONT_EXPORT
|
|
typename T::ComponentType operator()(const T &x)
|
|
{
|
|
return x[0] + x[1];
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct sum_vector<3>
|
|
{
|
|
template<typename T>
|
|
VTKM_EXEC_CONT_EXPORT
|
|
typename T::ComponentType operator()(const T &x)
|
|
{
|
|
return x[0] + x[1] + x[2];
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct sum_vector<4>
|
|
{
|
|
template<typename T>
|
|
VTKM_EXEC_CONT_EXPORT
|
|
typename T::ComponentType operator()(const T &x)
|
|
{
|
|
return x[0] + x[1] + x[2] + x[3];
|
|
}
|
|
};
|
|
|
|
template<int Size>
|
|
struct product_vector
|
|
{
|
|
template<typename T>
|
|
VTKM_EXEC_CONT_EXPORT
|
|
typename T::ComponentType operator()(const T &x)
|
|
{
|
|
return product_vector<Size-1>()(x) * x[Size-1];
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct product_vector<1>
|
|
{
|
|
template<typename T>
|
|
VTKM_EXEC_CONT_EXPORT
|
|
typename T::ComponentType operator()(const T &x)
|
|
{
|
|
return x[0];
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct product_vector<2>
|
|
{
|
|
template<typename T>
|
|
VTKM_EXEC_CONT_EXPORT
|
|
typename T::ComponentType operator()(const T &x)
|
|
{
|
|
return x[0] * x[1];
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct product_vector<3>
|
|
{
|
|
template<typename T>
|
|
VTKM_EXEC_CONT_EXPORT
|
|
typename T::ComponentType operator()(const T &x)
|
|
{
|
|
return x[0] * x[1] * x[2];
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct product_vector<4>
|
|
{
|
|
template<typename T>
|
|
VTKM_EXEC_CONT_EXPORT
|
|
typename T::ComponentType operator()(const T &x)
|
|
{
|
|
return x[0] * x[1] * x[2] * x[3];
|
|
}
|
|
};
|
|
|
|
|
|
} // namespace internal
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#if VTKM_SIZE_ID == 4
|
|
|
|
/// Represents an ID.
|
|
typedef internal::Int32Type Id;
|
|
|
|
#elif VTKM_SIZE_ID == 8
|
|
|
|
/// Represents an ID.
|
|
typedef internal::Int64Type Id;
|
|
|
|
#else
|
|
#error Unknown Id Size
|
|
#endif
|
|
|
|
#ifdef VTKM_USE_DOUBLE_PRECISION
|
|
|
|
/// Scalar corresponds to a floating point number.
|
|
typedef double Scalar;
|
|
|
|
#else //VTKM_USE_DOUBLE_PRECISION
|
|
|
|
/// Scalar corresponds to a floating point number.
|
|
typedef float Scalar;
|
|
|
|
#endif //VTKM_USE_DOUBLE_PRECISION
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
/// Tuple corresponds to a Size-tuple of type T
|
|
template<typename T, int Size>
|
|
class Tuple
|
|
{
|
|
public:
|
|
typedef T ComponentType;
|
|
static const int NUM_COMPONENTS=Size;
|
|
|
|
VTKM_EXEC_CONT_EXPORT Tuple() {}
|
|
VTKM_EXEC_CONT_EXPORT explicit Tuple(const ComponentType& value)
|
|
{
|
|
for(int i=0; i < NUM_COMPONENTS; ++i)
|
|
{
|
|
this->Components[i]=value;
|
|
}
|
|
}
|
|
VTKM_EXEC_CONT_EXPORT explicit Tuple(const ComponentType* values)
|
|
{
|
|
for(int i=0; i < NUM_COMPONENTS; ++i)
|
|
{
|
|
this->Components[i]=values[i];
|
|
}
|
|
}
|
|
VTKM_EXEC_CONT_EXPORT
|
|
Tuple(const Tuple<ComponentType, Size> &src)
|
|
{
|
|
for (int i = 0; i < NUM_COMPONENTS; i++)
|
|
{
|
|
this->Components[i] = src[i];
|
|
}
|
|
}
|
|
|
|
VTKM_EXEC_CONT_EXPORT
|
|
Tuple<ComponentType, Size> &operator=(const Tuple<ComponentType, Size> &src)
|
|
{
|
|
for (int i = 0; i < NUM_COMPONENTS; i++)
|
|
{
|
|
this->Components[i] = src[i];
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
VTKM_EXEC_CONT_EXPORT const ComponentType &operator[](int idx) const
|
|
{
|
|
return this->Components[idx];
|
|
}
|
|
VTKM_EXEC_CONT_EXPORT ComponentType &operator[](int idx)
|
|
{
|
|
return this->Components[idx];
|
|
}
|
|
|
|
VTKM_EXEC_CONT_EXPORT
|
|
bool operator==(const Tuple<T,NUM_COMPONENTS> &other) const
|
|
{
|
|
bool same = true;
|
|
for (int componentIndex=0; componentIndex<NUM_COMPONENTS; componentIndex++)
|
|
{
|
|
same &= (this->Components[componentIndex] == other[componentIndex]);
|
|
}
|
|
return same;
|
|
}
|
|
|
|
VTKM_EXEC_CONT_EXPORT
|
|
bool operator<(const Tuple<T,NUM_COMPONENTS> &other) const
|
|
{
|
|
for(vtkm::Id i=0; i < NUM_COMPONENTS; ++i)
|
|
{
|
|
//ignore equals as that represents check next value
|
|
if(this->Components[i] < other[i])
|
|
{ return true; }
|
|
else if(other[i] < this->Components[i])
|
|
{ return false; }
|
|
} //if all same we are not less
|
|
return false;
|
|
}
|
|
|
|
VTKM_EXEC_CONT_EXPORT
|
|
bool operator!=(const Tuple<T,NUM_COMPONENTS> &other) const
|
|
{
|
|
return !(this->operator==(other));
|
|
}
|
|
|
|
protected:
|
|
ComponentType Components[NUM_COMPONENTS];
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Specializations for small tuples. These are not exactly common but can occur
|
|
// with generalizations. We implement them a bit special.
|
|
|
|
template<typename T>
|
|
class Tuple<T, 0>
|
|
{
|
|
public:
|
|
typedef T ComponentType;
|
|
static const int NUM_COMPONENTS = 1;
|
|
|
|
VTKM_EXEC_CONT_EXPORT Tuple() {}
|
|
VTKM_EXEC_CONT_EXPORT explicit Tuple(const ComponentType&) { }
|
|
VTKM_EXEC_CONT_EXPORT explicit Tuple(const ComponentType*) { }
|
|
VTKM_EXEC_CONT_EXPORT
|
|
Tuple(const Tuple<ComponentType, NUM_COMPONENTS> &) { }
|
|
|
|
VTKM_EXEC_CONT_EXPORT
|
|
Tuple<ComponentType, NUM_COMPONENTS> &
|
|
operator=(const Tuple<ComponentType, NUM_COMPONENTS> &)
|
|
{
|
|
return *this;
|
|
}
|
|
|
|
VTKM_EXEC_CONT_EXPORT ComponentType operator[](int vtkmNotUsed(idx)) const
|
|
{
|
|
return ComponentType();
|
|
}
|
|
|
|
VTKM_EXEC_CONT_EXPORT
|
|
bool operator==(const Tuple<T, NUM_COMPONENTS> &vtkmNotUsed(other)) const
|
|
{
|
|
return true;
|
|
}
|
|
VTKM_EXEC_CONT_EXPORT
|
|
bool operator!=(const Tuple<T, NUM_COMPONENTS> &vtkmNotUsed(other)) const
|
|
{
|
|
return false;
|
|
}
|
|
};
|
|
|
|
template<typename T>
|
|
class Tuple<T, 1>
|
|
{
|
|
public:
|
|
typedef T ComponentType;
|
|
static const int NUM_COMPONENTS = 1;
|
|
|
|
VTKM_EXEC_CONT_EXPORT Tuple() {}
|
|
VTKM_EXEC_CONT_EXPORT explicit Tuple(const ComponentType& value)
|
|
: Component(value) { }
|
|
VTKM_EXEC_CONT_EXPORT explicit Tuple(const ComponentType* values)
|
|
: Component(*values) { }
|
|
VTKM_EXEC_CONT_EXPORT
|
|
Tuple(const Tuple<ComponentType, NUM_COMPONENTS> &src)
|
|
: Component(src.Component) { }
|
|
|
|
VTKM_EXEC_CONT_EXPORT
|
|
Tuple<ComponentType, NUM_COMPONENTS> &
|
|
operator=(const Tuple<ComponentType, NUM_COMPONENTS> &src)
|
|
{
|
|
this->Component = src.Component;
|
|
return *this;
|
|
}
|
|
|
|
VTKM_EXEC_CONT_EXPORT
|
|
const ComponentType &operator[](int vtkmNotUsed(idx)) const
|
|
{
|
|
return this->Component;
|
|
}
|
|
VTKM_EXEC_CONT_EXPORT
|
|
ComponentType &operator[](int vtkmNotUsed(idx))
|
|
{
|
|
return this->Component;
|
|
}
|
|
|
|
VTKM_EXEC_CONT_EXPORT
|
|
bool operator==(const Tuple<T, NUM_COMPONENTS> &other) const
|
|
{
|
|
return this->Component == other.Component;
|
|
}
|
|
VTKM_EXEC_CONT_EXPORT
|
|
bool operator!=(const Tuple<T, NUM_COMPONENTS> &other) const
|
|
{
|
|
return !(this->operator==(other));
|
|
}
|
|
|
|
VTKM_EXEC_CONT_EXPORT
|
|
bool operator<(const Tuple<T, NUM_COMPONENTS> &other) const
|
|
{
|
|
return this->Component < other.Component;
|
|
}
|
|
|
|
protected:
|
|
ComponentType Component;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Specializations for common tuple sizes (with special names).
|
|
|
|
template<typename T>
|
|
class Tuple<T,2>
|
|
{
|
|
public:
|
|
typedef T ComponentType;
|
|
static const int NUM_COMPONENTS = 2;
|
|
|
|
VTKM_EXEC_CONT_EXPORT Tuple() {}
|
|
VTKM_EXEC_CONT_EXPORT explicit Tuple(const ComponentType& value)
|
|
{
|
|
internal::assign_scalar_to_vector<NUM_COMPONENTS>()(this->Components,value);
|
|
}
|
|
VTKM_EXEC_CONT_EXPORT explicit Tuple(const ComponentType* values)
|
|
{
|
|
internal::copy_vector<NUM_COMPONENTS>()(this->Components, values);
|
|
}
|
|
VTKM_EXEC_CONT_EXPORT Tuple(ComponentType x, ComponentType y)
|
|
{
|
|
this->Components[0] = x;
|
|
this->Components[1] = y;
|
|
}
|
|
VTKM_EXEC_CONT_EXPORT
|
|
Tuple(const Tuple<ComponentType, NUM_COMPONENTS> &src)
|
|
{
|
|
internal::copy_vector<NUM_COMPONENTS>()(this->Components, src.Components);
|
|
}
|
|
|
|
VTKM_EXEC_CONT_EXPORT
|
|
Tuple<ComponentType, NUM_COMPONENTS> &
|
|
operator=(const Tuple<ComponentType, NUM_COMPONENTS> &src)
|
|
{
|
|
internal::copy_vector<NUM_COMPONENTS>()(this->Components, src.Components);
|
|
return *this;
|
|
}
|
|
|
|
VTKM_EXEC_CONT_EXPORT const ComponentType &operator[](int idx) const
|
|
{
|
|
return this->Components[idx];
|
|
}
|
|
VTKM_EXEC_CONT_EXPORT ComponentType &operator[](int idx)
|
|
{
|
|
return this->Components[idx];
|
|
}
|
|
|
|
VTKM_EXEC_CONT_EXPORT
|
|
bool operator==(const Tuple<T,NUM_COMPONENTS> &other) const
|
|
{
|
|
return internal::equals<NUM_COMPONENTS>()(*this, other);
|
|
}
|
|
VTKM_EXEC_CONT_EXPORT
|
|
bool operator!=(const Tuple<T,NUM_COMPONENTS> &other) const
|
|
{
|
|
return !(this->operator==(other));
|
|
}
|
|
|
|
VTKM_EXEC_CONT_EXPORT
|
|
bool operator<(const Tuple<T,NUM_COMPONENTS> &other) const
|
|
{
|
|
return( (this->Components[0] < other[0]) ||
|
|
(!(other[0] < this->Components[0]) && (this->Components[1] < other[1]))
|
|
);
|
|
}
|
|
|
|
protected:
|
|
ComponentType Components[NUM_COMPONENTS];
|
|
};
|
|
|
|
/// Vector2 corresponds to a 2-tuple
|
|
typedef vtkm::Tuple<vtkm::Scalar,2> Vector2;
|
|
|
|
|
|
/// Id2 corresponds to a 2-dimensional index
|
|
typedef vtkm::Tuple<vtkm::Id,2> Id2;
|
|
|
|
template<typename T>
|
|
class Tuple<T,3>
|
|
{
|
|
public:
|
|
typedef T ComponentType;
|
|
static const int NUM_COMPONENTS = 3;
|
|
|
|
VTKM_EXEC_CONT_EXPORT Tuple() {}
|
|
VTKM_EXEC_CONT_EXPORT explicit Tuple(const ComponentType& value)
|
|
{
|
|
internal::assign_scalar_to_vector<NUM_COMPONENTS>()(this->Components,value);
|
|
}
|
|
VTKM_EXEC_CONT_EXPORT explicit Tuple(const ComponentType* values)
|
|
{
|
|
internal::copy_vector<NUM_COMPONENTS>()(this->Components, values);
|
|
}
|
|
VTKM_EXEC_CONT_EXPORT
|
|
Tuple(ComponentType x, ComponentType y, ComponentType z)
|
|
{
|
|
this->Components[0] = x;
|
|
this->Components[1] = y;
|
|
this->Components[2] = z;
|
|
}
|
|
VTKM_EXEC_CONT_EXPORT
|
|
Tuple(const Tuple<ComponentType, NUM_COMPONENTS> &src)
|
|
{
|
|
internal::copy_vector<NUM_COMPONENTS>()(this->Components, src.Components);
|
|
}
|
|
|
|
VTKM_EXEC_CONT_EXPORT
|
|
Tuple<ComponentType, NUM_COMPONENTS> &
|
|
operator=(const Tuple<ComponentType, NUM_COMPONENTS> &src)
|
|
{
|
|
internal::copy_vector<NUM_COMPONENTS>()(this->Components, src.Components);
|
|
return *this;
|
|
}
|
|
|
|
VTKM_EXEC_CONT_EXPORT const ComponentType &operator[](int idx) const
|
|
{
|
|
return this->Components[idx];
|
|
}
|
|
VTKM_EXEC_CONT_EXPORT ComponentType &operator[](int idx)
|
|
{
|
|
return this->Components[idx];
|
|
}
|
|
|
|
VTKM_EXEC_CONT_EXPORT
|
|
bool operator==(const Tuple<T,NUM_COMPONENTS> &other) const
|
|
{
|
|
return internal::equals<NUM_COMPONENTS>()(*this, other);
|
|
}
|
|
VTKM_EXEC_CONT_EXPORT
|
|
bool operator!=(const Tuple<T,NUM_COMPONENTS> &other) const
|
|
{
|
|
return !(this->operator==(other));
|
|
}
|
|
|
|
VTKM_EXEC_CONT_EXPORT
|
|
bool operator<(const Tuple<T,NUM_COMPONENTS> &other) const
|
|
{
|
|
return((this->Components[0] < other[0]) ||
|
|
( !(other[0] < this->Components[0]) &&
|
|
(this->Components[1] < other[1])) ||
|
|
( !(other[0] < this->Components[0]) &&
|
|
!(other[1] < this->Components[1]) &&
|
|
(this->Components[2] < other[2]) ) );
|
|
}
|
|
|
|
protected:
|
|
ComponentType Components[NUM_COMPONENTS];
|
|
};
|
|
|
|
/// Vector3 corresponds to a 3-tuple
|
|
typedef vtkm::Tuple<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::Tuple<vtkm::Id,3> Id3;
|
|
|
|
template<typename T>
|
|
class Tuple<T,4>
|
|
{
|
|
public:
|
|
typedef T ComponentType;
|
|
static const int NUM_COMPONENTS = 4;
|
|
|
|
VTKM_EXEC_CONT_EXPORT Tuple() {}
|
|
VTKM_EXEC_CONT_EXPORT explicit Tuple(const ComponentType& value)
|
|
{
|
|
internal::assign_scalar_to_vector<NUM_COMPONENTS>()(this->Components,value);
|
|
}
|
|
VTKM_EXEC_CONT_EXPORT explicit Tuple(const ComponentType* values)
|
|
{
|
|
internal::copy_vector<NUM_COMPONENTS>()(this->Components, values);
|
|
}
|
|
VTKM_EXEC_CONT_EXPORT
|
|
Tuple(ComponentType x, ComponentType y, ComponentType z, ComponentType w)
|
|
{
|
|
this->Components[0] = x;
|
|
this->Components[1] = y;
|
|
this->Components[2] = z;
|
|
this->Components[3] = w;
|
|
}
|
|
VTKM_EXEC_CONT_EXPORT
|
|
Tuple(const Tuple<ComponentType, NUM_COMPONENTS> &src)
|
|
{
|
|
internal::copy_vector<NUM_COMPONENTS>()(this->Components, src.Components);
|
|
}
|
|
|
|
VTKM_EXEC_CONT_EXPORT
|
|
Tuple<ComponentType, NUM_COMPONENTS> &
|
|
operator=(const Tuple<ComponentType, NUM_COMPONENTS> &src)
|
|
{
|
|
internal::copy_vector<NUM_COMPONENTS>()(this->Components, src.Components);
|
|
return *this;
|
|
}
|
|
|
|
VTKM_EXEC_CONT_EXPORT const ComponentType &operator[](int idx) const
|
|
{
|
|
return this->Components[idx];
|
|
}
|
|
VTKM_EXEC_CONT_EXPORT ComponentType &operator[](int idx)
|
|
{
|
|
return this->Components[idx];
|
|
}
|
|
|
|
VTKM_EXEC_CONT_EXPORT
|
|
bool operator==(const Tuple<T,NUM_COMPONENTS> &other) const
|
|
{
|
|
return internal::equals<NUM_COMPONENTS>()(*this, other);
|
|
}
|
|
VTKM_EXEC_CONT_EXPORT
|
|
bool operator!=(const Tuple<T,NUM_COMPONENTS> &other) const
|
|
{
|
|
return !(this->operator==(other));
|
|
}
|
|
|
|
VTKM_EXEC_CONT_EXPORT
|
|
bool operator<(const Tuple<T,NUM_COMPONENTS> &other) const
|
|
{
|
|
return((this->Components[0] < other[0]) ||
|
|
( !(other[0] < this->Components[0]) &&
|
|
this->Components[1] < other[1]) ||
|
|
( !(other[0] < this->Components[0]) &&
|
|
!(other[1] < this->Components[1]) &&
|
|
(this->Components[2] < other[2]) ) ||
|
|
( !(other[0] < this->Components[0]) &&
|
|
!(other[1] < this->Components[1]) &&
|
|
!(other[2] < this->Components[2]) &&
|
|
(this->Components[3] < other[3])) );
|
|
}
|
|
|
|
protected:
|
|
ComponentType Components[NUM_COMPONENTS];
|
|
};
|
|
|
|
/// Vector4 corresponds to a 4-tuple
|
|
typedef vtkm::Tuple<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);
|
|
}
|
|
|
|
template<typename T, int Size>
|
|
VTKM_EXEC_CONT_EXPORT T dot(const vtkm::Tuple<T,Size> &a,
|
|
const vtkm::Tuple<T,Size> &b)
|
|
{
|
|
T result = a[0]*b[0];
|
|
for (int componentIndex = 1; componentIndex < Size; componentIndex++)
|
|
{
|
|
result += a[componentIndex]*b[componentIndex];
|
|
}
|
|
return result;
|
|
}
|
|
|
|
VTKM_EXEC_CONT_EXPORT vtkm::Id dot(vtkm::Id a, vtkm::Id b)
|
|
{
|
|
return a * b;
|
|
}
|
|
|
|
VTKM_EXEC_CONT_EXPORT vtkm::Scalar dot(vtkm::Scalar a, vtkm::Scalar b)
|
|
{
|
|
return a * b;
|
|
}
|
|
|
|
} // End of namespace vtkm
|
|
|
|
template<typename T, int Size>
|
|
VTKM_EXEC_CONT_EXPORT vtkm::Tuple<T,Size> operator+(const vtkm::Tuple<T,Size> &a,
|
|
const vtkm::Tuple<T,Size> &b)
|
|
{
|
|
vtkm::Tuple<T,Size> result;
|
|
for (int componentIndex = 0; componentIndex < Size; componentIndex++)
|
|
{
|
|
result[componentIndex] = a[componentIndex] + b[componentIndex];
|
|
}
|
|
return result;
|
|
}
|
|
template<typename T, int Size>
|
|
VTKM_EXEC_CONT_EXPORT vtkm::Tuple<T,Size> operator-(const vtkm::Tuple<T,Size> &a,
|
|
const vtkm::Tuple<T,Size> &b)
|
|
{
|
|
vtkm::Tuple<T,Size> result;
|
|
for (int componentIndex = 0; componentIndex < Size; componentIndex++)
|
|
{
|
|
result[componentIndex] = a[componentIndex] - b[componentIndex];
|
|
}
|
|
return result;
|
|
}
|
|
template<typename T, int Size>
|
|
VTKM_EXEC_CONT_EXPORT vtkm::Tuple<T,Size> operator*(const vtkm::Tuple<T,Size> &a,
|
|
const vtkm::Tuple<T,Size> &b)
|
|
{
|
|
vtkm::Tuple<T,Size> result;
|
|
for (int componentIndex = 0; componentIndex < Size; componentIndex++)
|
|
{
|
|
result[componentIndex] = a[componentIndex] * b[componentIndex];
|
|
}
|
|
return result;
|
|
}
|
|
template<typename T, int Size>
|
|
VTKM_EXEC_CONT_EXPORT vtkm::Tuple<T,Size> operator/(const vtkm::Tuple<T,Size> &a,
|
|
const vtkm::Tuple<T,Size> &b)
|
|
{
|
|
vtkm::Tuple<T,Size> result;
|
|
for (int componentIndex = 0; componentIndex < Size; componentIndex++)
|
|
{
|
|
result[componentIndex] = a[componentIndex] / b[componentIndex];
|
|
}
|
|
return result;
|
|
}
|
|
|
|
template<typename Ta, typename Tb, int Size>
|
|
VTKM_EXEC_CONT_EXPORT vtkm::Tuple<Ta,Size> operator*(const vtkm::Tuple<Ta,Size> &a,
|
|
const Tb &b)
|
|
{
|
|
vtkm::Tuple<Ta,Size> result;
|
|
for (int componentIndex = 0; componentIndex < Size; componentIndex++)
|
|
{
|
|
result[componentIndex] = a[componentIndex] * b;
|
|
}
|
|
return result;
|
|
}
|
|
template<typename Ta, typename Tb, int Size>
|
|
VTKM_EXEC_CONT_EXPORT vtkm::Tuple<Tb,Size> operator*(const Ta &a,
|
|
const vtkm::Tuple<Tb,Size> &b)
|
|
{
|
|
vtkm::Tuple<Tb,Size> result;
|
|
for (int componentIndex = 0; componentIndex < Size; componentIndex++)
|
|
{
|
|
result[componentIndex] = a * b[componentIndex];
|
|
}
|
|
return result;
|
|
}
|
|
|
|
#endif //vtk_m_Types_h
|