vtkm Namespace Reference

Groups connected points that have the same field value. More...

Namespaces
	cont
	VTK-m Control Environment.
	exec
	VTK-m Execution Environment.
	filter
	VTK-m Filters.
	interop
	VTK-m OpenGL Interoperability.
	io
	VTK-m File input and output classes.
	random
	rendering
	VTK-m Rendering.
	source
	VTK-m Input source such as Wavelet.
	testing
	Internal testing classes.
	VTK_M_NAMESPACE
	worklet
	VTK-m Worklets.

Classes
struct	Add
struct	Bitset
	A bitmap to serve different needs. More...
struct	BitwiseAnd
	Binary Predicate that takes two arguments argument x, and y and returns the bitwise operation x&y More...
struct	BitwiseOr
	Binary Predicate that takes two arguments argument x, and y and returns the bitwise operation x|y More...
struct	BitwiseXor
	Binary Predicate that takes two arguments argument x, and y and returns the bitwise operation x^y More...
struct	Bounds
	Represent an axis-aligned 3D bounds in space. More...
class	Box
	Implicit function for a box. More...
class	CellClassification
	Bit flags used in ghost arrays to identify what type a cell is. More...
struct	CellShapeIdToTag
	A traits-like class to get an CellShapeId known at compile time to a tag. More...
struct	CellShapeTagGeneric
	A special cell shape tag that holds a cell shape that is not known at compile time. More...
struct	CellTopologicalDimensionsTag
	vtkm::CellTraits::TopologyDimensionType is typedef to this with the template parameter set to TOPOLOGICAL_DIMENSIONS. More...
struct	CellTraits
	Information about a cell based on its tag. More...
struct	CellTraitsTagSizeFixed
	Tag for cell shapes with a fixed number of points. More...
struct	CellTraitsTagSizeVariable
	Tag for cell shapes that can have a variable number of points. More...
class	ChargedParticle
class	Cylinder
	Implicit function for a cylinder. More...
struct	Divide
struct	Equal
	Binary Predicate that takes two arguments argument x, and y and returns True if and only if x is equal to y. More...
class	Frustum
	Implicit function for a frustum. More...
class	ImplicitFunctionGeneral
	Implicit function that can switch among known implicit function types. More...
class	ImplicitFunctionGradientFunctor
	A helpful functor that calls the gradient method of a given ImplicitFunction. More...
class	ImplicitFunctionMultiplexer
	Implicit function that can switch among different types. More...
class	ImplicitFunctionValueFunctor
	A helpful functor that calls the value method of a given ImplicitFunction. More...
struct	IsZeroInitialized
	Predicate that takes a single argument x, and returns True if it is the identity of the Type T. More...
struct	LineSegment
	Represent a finite line segment with a pair of points. More...
struct	List
struct	LogicalAnd
	Binary Predicate that takes two arguments argument x, and y and returns True if and only if x and y are True. More...
struct	LogicalNot
	Predicate that takes a single argument x, and returns True if and only if x is false. More...
struct	LogicalOr
	Binary Predicate that takes two arguments argument x, and y and returns True if and only if x or y is True. More...
class	Matrix
	Basic Matrix type. More...
struct	Maximum
	Binary Predicate that takes two arguments argument x, and y and returns the x if x > y otherwise returns y. More...
struct	MinAndMax
	Binary Predicate that takes two arguments argument x, and y and returns a vtkm::Vec<T,2> that represents the minimum and maximum values. More...
struct	Minimum
	Binary Predicate that takes two arguments argument x, and y and returns the x if x < y otherwise returns y. More...
struct	Multiply
struct	Negate
struct	NewtonsMethodResult
struct	NotEqual
	Binary Predicate that takes two arguments argument x, and y and returns True if and only if x is not equal to y. More...
struct	NotZeroInitialized
	Predicate that takes a single argument x, and returns True if it isn't the identity of the Type T. More...
struct	Pair
	A vtkm::Pair is essentially the same as an STL pair object except that the methods (constructors and operators) are defined to work in both the control and execution environments (whereas std::pair is likely to work only in the control environment). More...
class	Particle
class	ParticleStatus
class	Plane
	Represent a plane with a base point (origin) and normal vector. More...
struct	Product
	Binary Predicate that takes two arguments argument x, and y and returns product (multiplication) of the two values. More...
struct	Range
	Represent a continuous scalar range of values. More...
struct	RangeId
	Represent a range of vtkm::Id values. More...
struct	RangeId2
	Represent 2D integer range. More...
struct	RangeId3
	Represent 3D integer range. More...
struct	Ray
	Represent an infinite or semi-infinite line segment with a point and a direction. More...
struct	ReadTheSourceCodeHereForHelpOnThisError
struct	ReadTheSourceCodeHereForHelpOnThisError< true >
struct	SortGreater
	Binary Predicate that takes two arguments argument x, and y and returns True if and only if x is greater than y. More...
struct	SortLess
	Binary Predicate that takes two arguments argument x, and y and returns True if and only if x is less than y. More...
class	Sphere
	Represent a sphere of the given Dimension. More...
struct	Subtract
struct	Sum
	Binary Predicate that takes two arguments argument x, and y and returns sum (addition) of the two values. More...
struct	TopologyElementTagCell
	A tag used to identify the cell elements in a topology. More...
struct	TopologyElementTagEdge
	A tag used to identify the edge elements in a topology. More...
struct	TopologyElementTagFace
	A tag used to identify the face elements in a topology. More...
struct	TopologyElementTagPoint
	A tag used to identify the point elements in a topology. More...
class	Tuple
	VTK-m replacement for std::tuple. More...
class	Tuple< T0 >
class	Tuple< T0, T1 >
class	Tuple< T0, T1, T2 >
class	Tuple< T0, T1, T2, T3 >
class	Tuple< T0, T1, T2, T3, T4 >
class	Tuple< T0, T1, T2, T3, T4, T5 >
class	Tuple< T0, T1, T2, T3, T4, T5, T6 >
class	Tuple< T0, T1, T2, T3, T4, T5, T6, T7 >
class	Tuple< T0, T1, T2, T3, T4, T5, T6, T7, T8 >
class	Tuple< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 >
class	Tuple< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 >
class	Tuple< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 >
class	Tuple< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 >
class	Tuple< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 >
class	Tuple< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 >
class	Tuple< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 >
class	Tuple< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 >
class	Tuple< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 >
class	Tuple< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 >
class	Tuple< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 >
class	Tuple< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, Ts... >
class	Tuple<>
struct	tuple_element
	Compatible with std::tuple_element for vtkm::Tuple. More...
class	TypeTraits
	The TypeTraits class provides helpful compile-time information about the basic types used in VTKm (and a few others for convenience). More...
struct	TypeTraits< const T >
struct	TypeTraits< vtkm::internal::ArrayPortalValueReference< PortalType > >
struct	TypeTraits< vtkm::internal::RecombineVec< PortalType > >
struct	TypeTraits< vtkm::Matrix< T, NumRow, NumCol > >
struct	TypeTraits< vtkm::Pair< T, U > >
	Traits for Pair types. More...
struct	TypeTraits< vtkm::Vec< T, Size > >
	Traits for basic C++ types. More...
struct	TypeTraits< vtkm::VecAxisAlignedPointCoordinates< NumDimensions > >
struct	TypeTraits< vtkm::VecC< T > >
	Traits for VecC types. More...
struct	TypeTraits< vtkm::VecCConst< T > >
	Traits for VecCConst types. More...
struct	TypeTraits< vtkm::VecFlat< T > >
struct	TypeTraits< vtkm::VecFromPortal< PortalType > >
struct	TypeTraits< vtkm::VecFromPortalPermute< IndexVecType, PortalType > >
struct	TypeTraits< vtkm::VecVariable< T, MaxSize > >
struct	TypeTraitsIntegerTag
	Tag used to identify types that store integer numbers. More...
struct	TypeTraitsMatrixTag
	Tag used to identify 2 dimensional types (matrices). More...
struct	TypeTraitsRealTag
	Tag used to identify types that store real (floating-point) numbers. More...
struct	TypeTraitsScalarTag
	Tag used to identify 0 dimensional types (scalars). More...
struct	TypeTraitsUnknownTag
	Tag used to identify types that aren't Real, Integer, Scalar or Vector. More...
struct	TypeTraitsVectorTag
	Tag used to identify 1 dimensional types (vectors). More...
class	Vec
	A short fixed-length array. More...
class	Vec< T, 0 >
class	Vec< T, 1 >
class	Vec< T, 2 >
class	Vec< T, 3 >
class	Vec< T, 4 >
class	VecAxisAlignedPointCoordinates
	An implicit vector for point coordinates in axis aligned cells. More...
class	VecC
	A Vec-like representation for short arrays. More...
class	VecCConst
	A const version of VecC. More...
class	VecFlat
	Treat a Vec or Vec-like object as a flat Vec. More...
class	VecFlat< T, false >
class	VecFlat< T, true >
class	VecFromPortal
	A short variable-length array from a window in an ArrayPortal. More...
class	VecFromPortalPermute
	A short vector from an ArrayPortal and a vector of indices. More...
class	VecFromPortalPermute< IndexVecType, const PortalType * >
struct	VecTraits
	The VecTraits class gives several static members that define how to use a given type as a vector. More...
struct	VecTraits< const T >
struct	VecTraits< vtkm::Bounds >
struct	VecTraits< vtkm::internal::ArrayPortalValueReference< PortalType > >
struct	VecTraits< vtkm::internal::RecombineVec< PortalType > >
struct	VecTraits< vtkm::Matrix< T, NumRow, NumCol > >
	A matrix has vector traits to implement component-wise operations. More...
struct	VecTraits< vtkm::Pair< T, U > >
	VecTraits for Pair types. More...
struct	VecTraits< vtkm::Range >
struct	VecTraits< vtkm::Vec< T, Size > >
struct	VecTraits< vtkm::VecAxisAlignedPointCoordinates< NumDimensions > >
struct	VecTraits< vtkm::VecC< T > >
struct	VecTraits< vtkm::VecCConst< T > >
struct	VecTraits< vtkm::VecFlat< T > >
struct	VecTraits< vtkm::VecFromPortal< PortalType > >
struct	VecTraits< vtkm::VecFromPortalPermute< IndexVecType, PortalType > >
struct	VecTraits< vtkm::VecVariable< T, MaxSize > >
struct	VecTraitsTagMultipleComponents
	A tag for vectors that are "true" vectors (i.e. More...
struct	VecTraitsTagSingleComponent
	A tag for vectors that are really just scalars (i.e. More...
struct	VecTraitsTagSizeStatic
	A tag for vectors where the number of components are known at compile time. More...
struct	VecTraitsTagSizeVariable
	A tag for vectors where the number of components are not determined until run time. More...
class	VecVariable
	A short variable-length array with maximum length. More...

Typedefs
using	AtomicTypePreferred = vtkm::UInt32
	The preferred type to use for atomic operations. More...
using	AtomicTypesSupported = vtkm::List< vtkm::UInt32, vtkm::UInt64 >
	A list of types that can be used with atomic operations. More...
using	BufferSizeType = vtkm::Int64
template<typename CoordType , int Dim = 3>
using	Line = Ray< CoordType, Dim, true >
	Lines are two-sided rays: More...
template<typename CoordType >
using	Ray2 = Ray< CoordType, 2 >
template<typename CoordType >
using	Ray3 = Ray< CoordType, 3 >
template<typename CoordType >
using	Line2 = Line< CoordType, 2 >
template<typename CoordType >
using	Line3 = Line< CoordType, 3 >
template<typename CoordType >
using	LineSegment2 = LineSegment< CoordType, 2 >
template<typename CoordType >
using	LineSegment3 = LineSegment< CoordType, 3 >
template<typename T >
using	Circle = Sphere< T, 2 >
	Circle is an alias for a 2-Dimensional sphere. More...
template<typename T >
using	Sphere2 = Sphere< T, 2 >
template<typename T >
using	Sphere3 = Sphere< T, 3 >
using	Ray2d = Ray2< vtkm::FloatDefault >
using	Ray3d = Ray3< vtkm::FloatDefault >
using	Line2d = Line2< vtkm::FloatDefault >
using	Line3d = Line3< vtkm::FloatDefault >
using	LineSegment2d = LineSegment2< vtkm::FloatDefault >
using	LineSegment3d = LineSegment3< vtkm::FloatDefault >
using	Plane3d = Plane< vtkm::FloatDefault >
using	Circle2d = Circle< vtkm::FloatDefault >
using	Sphere2d = Sphere2< vtkm::FloatDefault >
using	Sphere3d = Sphere3< vtkm::FloatDefault >
using	HashType = vtkm::UInt32
using	ListEmpty = vtkm::List<>
	A special tag for an empty list. More...
using	ListUniversal = vtkm::List< detail::UniversalTypeTag >
	A special tag for a list that represents holding all potential values. More...
template<typename List >
using	ListSize = typename detail::ListSizeImpl< List >::type
	Becomes an std::integral_constant containing the number of types in a list. More...
template<typename List , template< typename... > class Target>
using	ListApply = typename detail::ListApplyImpl< List, Target >::type
	Applies the list of types to a template. More...
template<typename... Lists>
using	ListAppend = typename detail::ListAppendImpl< Lists... >::type
	Concatinates a set of lists into a single list. More...
template<typename T , vtkm::IdComponent N>
using	ListFill = typename detail::ListFillImpl< T, N >::type
	Returns a list filled with N copies of type T. More...
template<typename List , vtkm::IdComponent Index>
using	ListAt = typename detail::ListAtImpl< List, Index >::type
	Finds the type at the given index. More...
template<typename List , typename T >
using	ListIndexOf = typename detail::ListIndexOfImpl< List, T >::type
	Finds the index of a given type. More...
template<typename List , typename T >
using	ListHas = typename detail::ListHasImpl< List, T >::type
	Checks to see if the given T is in the list pointed to by List. More...
template<typename List , template< typename > class Transform>
using	ListTransform = typename detail::ListTransformImpl< List, Transform >::type
	Constructs a list containing all types in a source list applied to a transform template. More...
template<typename List , template< typename > class Predicate>
using	ListRemoveIf = typename detail::ListRemoveIfImpl< List, Predicate >::type
	Takes an existing List and a predicate template that is applied to each type in the List. More...
template<typename List1 , typename List2 >
using	ListIntersect = typename detail::ListIntersectImpl< List1, List2 >::type
	Constructs a list containing types present in all lists. More...
template<typename List1 , typename List2 >
using	ListCross = typename detail::ListCrossImpl< List1, List2 >::type
	Generates a list that is the cross product of two input lists. More...
template<typename List , template< typename T1, typename T2 > class Operator, typename Initial >
using	ListReduce = typename detail::ListReduceImpl< List, Operator, Initial >::type
	Reduces a list to a single type using an operator. More...
template<typename List , template< typename > class Predicate = vtkm::internal::meta::Identity>
using	ListAll = vtkm::ListReduce< vtkm::ListTransform< List, Predicate >, vtkm::internal::meta::And, std::true_type >
	Determines whether all the types in the list are "true.". More...
template<typename List , template< typename > class Predicate = vtkm::internal::meta::Identity>
using	ListAny = vtkm::ListReduce< vtkm::ListTransform< List, Predicate >, vtkm::internal::meta::Or, std::false_type >
	Determines whether any of the types in the list are "true.". More...
using	TypeListId = vtkm::List< vtkm::Id >
	A list containing the type vtkm::Id. More...
using	TypeListId2 = vtkm::List< vtkm::Id2 >
	A list containing the type vtkm::Id2. More...
using	TypeListId3 = vtkm::List< vtkm::Id3 >
	A list containing the type vtkm::Id3. More...
using	TypeListId4 = vtkm::List< vtkm::Id4 >
	A list containing the type vtkm::Id4. More...
using	TypeListIdComponent = vtkm::List< vtkm::IdComponent >
	A list containing the type vtkm::IdComponent. More...
using	TypeListIndex = vtkm::List< vtkm::Id, vtkm::Id2, vtkm::Id3 >
	A list containing types used to index arrays. More...
using	TypeListFieldScalar = vtkm::List< vtkm::Float32, vtkm::Float64 >
	A list containing types used for scalar fields. More...
using	TypeListFieldVec2 = vtkm::List< vtkm::Vec2f_32, vtkm::Vec2f_64 >
	A list containing types for values for fields with two dimensional vectors. More...
using	TypeListFieldVec3 = vtkm::List< vtkm::Vec3f_32, vtkm::Vec3f_64 >
	A list containing types for values for fields with three dimensional vectors. More...
using	TypeListFieldVec4 = vtkm::List< vtkm::Vec4f_32, vtkm::Vec4f_64 >
	A list containing types for values for fields with four dimensional vectors. More...
using	TypeListFloatVec = vtkm::List< vtkm::Vec2f_32, vtkm::Vec2f_64, vtkm::Vec3f_32, vtkm::Vec3f_64, vtkm::Vec4f_32, vtkm::Vec4f_64 >
	A list containing common types for floating-point vectors. More...
using	TypeListField = vtkm::List< vtkm::Float32, vtkm::Float64, vtkm::Vec2f_32, vtkm::Vec2f_64, vtkm::Vec3f_32, vtkm::Vec3f_64, vtkm::Vec4f_32, vtkm::Vec4f_64 >
	A list containing common types for values in fields. More...
using	TypeListScalarAll = vtkm::List< vtkm::Int8, vtkm::UInt8, vtkm::Int16, vtkm::UInt16, vtkm::Int32, vtkm::UInt32, vtkm::Int64, vtkm::UInt64, vtkm::Float32, vtkm::Float64 >
	A list of all scalars defined in vtkm/Types.h. More...
using	TypeListBaseC = vtkm::ListAppend< vtkm::TypeListScalarAll, vtkm::List< bool, char, signed VTKM_UNUSED_INT_TYPE, unsigned VTKM_UNUSED_INT_TYPE > >
using	TypeListVecCommon = vtkm::List< vtkm::Vec2ui_8, vtkm::Vec2i_32, vtkm::Vec2i_64, vtkm::Vec2f_32, vtkm::Vec2f_64, vtkm::Vec3ui_8, vtkm::Vec3i_32, vtkm::Vec3i_64, vtkm::Vec3f_32, vtkm::Vec3f_64, vtkm::Vec4ui_8, vtkm::Vec4i_32, vtkm::Vec4i_64, vtkm::Vec4f_32, vtkm::Vec4f_64 >
	A list of the most commonly use Vec classes. More...
using	TypeListVecAll = vtkm::ListAppend< vtkm::TypeListVecCommon, vtkm::internal::TypeListVecUncommon >
	A list of all vector classes with standard types as components and lengths between 2 and 4. More...
using	TypeListAll = vtkm::ListAppend< vtkm::TypeListScalarAll, vtkm::TypeListVecAll >
	A list of all basic types listed in vtkm/Types.h. More...
using	TypeListCommon = vtkm::List< vtkm::UInt8, vtkm::Int32, vtkm::Int64, vtkm::Float32, vtkm::Float64, vtkm::Vec3f_32, vtkm::Vec3f_64 >
	A list of the most commonly used types across multiple domains. More...
using	Float32 = float
using	Float64 = double
using	Int8 = int8_t
using	UInt8 = uint8_t
using	Int16 = int16_t
using	UInt16 = uint16_t
using	Int32 = int32_t
using	UInt32 = uint32_t
using	IdComponent = vtkm::Int32
	Represents a component ID (index of component in a vector). More...
using	WordTypeDefault = vtkm::UInt32
	The default word size used for atomic bitwise operations. More...
using	Id = vtkm::Int32
	Represents an ID (index into arrays). More...
using	FloatDefault = vtkm::Float32
	The floating point type to use when no other precision is specified. More...
using	Id2 = vtkm::Vec< vtkm::Id, 2 >
	Id2 corresponds to a 2-dimensional index. More...
using	IdComponent2 = vtkm::Vec< vtkm::IdComponent, 2 >
	IdComponent2 corresponds to an index to a local (small) 2-d array or equivalent. More...
using	Vec2f = vtkm::Vec< vtkm::FloatDefault, 2 >
	Vec2f corresponds to a 2-dimensional vector of floating point values. More...
using	Vec2f_32 = vtkm::Vec< vtkm::Float32, 2 >
	Vec2f_32 corresponds to a 2-dimensional vector of 32-bit floating point values. More...
using	Vec2f_64 = vtkm::Vec< vtkm::Float64, 2 >
	Vec2f_64 corresponds to a 2-dimensional vector of 64-bit floating point values. More...
using	Vec2i = vtkm::Vec< vtkm::Id, 2 >
	Vec2i corresponds to a 2-dimensional vector of integer values. More...
using	Vec2i_8 = vtkm::Vec< vtkm::Int8, 2 >
	Vec2i_8 corresponds to a 2-dimensional vector of 8-bit integer values. More...
using	Vec2i_16 = vtkm::Vec< vtkm::Int16, 2 >
	Vec2i_16 corresponds to a 2-dimensional vector of 16-bit integer values. More...
using	Vec2i_32 = vtkm::Vec< vtkm::Int32, 2 >
	Vec2i_32 corresponds to a 2-dimensional vector of 32-bit integer values. More...
using	Vec2i_64 = vtkm::Vec< vtkm::Int64, 2 >
	Vec2i_64 corresponds to a 2-dimensional vector of 64-bit integer values. More...
using	Vec2ui = vtkm::Vec< vtkm::UInt32, 2 >
	Vec2ui corresponds to a 2-dimensional vector of unsigned integer values. More...
using	Vec2ui_8 = vtkm::Vec< vtkm::UInt8, 2 >
	Vec2ui_8 corresponds to a 2-dimensional vector of 8-bit unsigned integer values. More...
using	Vec2ui_16 = vtkm::Vec< vtkm::UInt16, 2 >
	Vec2ui_16 corresponds to a 2-dimensional vector of 16-bit unsigned integer values. More...
using	Vec2ui_32 = vtkm::Vec< vtkm::UInt32, 2 >
	Vec2ui_32 corresponds to a 2-dimensional vector of 32-bit unsigned integer values. More...
using	Vec2ui_64 = vtkm::Vec< vtkm::UInt64, 2 >
	Vec2ui_64 corresponds to a 2-dimensional vector of 64-bit unsigned integer values. More...
using	Id3 = vtkm::Vec< vtkm::Id, 3 >
	Id3 corresponds to a 3-dimensional index for 3d arrays. More...
using	IdComponent3 = vtkm::Vec< vtkm::IdComponent, 3 >
	IdComponent2 corresponds to an index to a local (small) 3-d array or equivalent. More...
using	Vec3f = vtkm::Vec< vtkm::FloatDefault, 3 >
	Vec3f corresponds to a 3-dimensional vector of floating point values. More...
using	Vec3f_32 = vtkm::Vec< vtkm::Float32, 3 >
	Vec3f_32 corresponds to a 3-dimensional vector of 32-bit floating point values. More...
using	Vec3f_64 = vtkm::Vec< vtkm::Float64, 3 >
	Vec3f_64 corresponds to a 3-dimensional vector of 64-bit floating point values. More...
using	Vec3i = vtkm::Vec< vtkm::Id, 3 >
	Vec3i corresponds to a 3-dimensional vector of integer values. More...
using	Vec3i_8 = vtkm::Vec< vtkm::Int8, 3 >
	Vec3i_8 corresponds to a 3-dimensional vector of 8-bit integer values. More...
using	Vec3i_16 = vtkm::Vec< vtkm::Int16, 3 >
	Vec3i_16 corresponds to a 3-dimensional vector of 16-bit integer values. More...
using	Vec3i_32 = vtkm::Vec< vtkm::Int32, 3 >
	Vec3i_32 corresponds to a 3-dimensional vector of 32-bit integer values. More...
using	Vec3i_64 = vtkm::Vec< vtkm::Int64, 3 >
	Vec3i_64 corresponds to a 3-dimensional vector of 64-bit integer values. More...
using	Vec3ui = vtkm::Vec< vtkm::UInt32, 3 >
	Vec3ui corresponds to a 3-dimensional vector of unsigned integer values. More...
using	Vec3ui_8 = vtkm::Vec< vtkm::UInt8, 3 >
	Vec3ui_8 corresponds to a 3-dimensional vector of 8-bit unsigned integer values. More...
using	Vec3ui_16 = vtkm::Vec< vtkm::UInt16, 3 >
	Vec3ui_16 corresponds to a 3-dimensional vector of 16-bit unsigned integer values. More...
using	Vec3ui_32 = vtkm::Vec< vtkm::UInt32, 3 >
	Vec3ui_32 corresponds to a 3-dimensional vector of 32-bit unsigned integer values. More...
using	Vec3ui_64 = vtkm::Vec< vtkm::UInt64, 3 >
	Vec3ui_64 corresponds to a 3-dimensional vector of 64-bit unsigned integer values. More...
using	Id4 = vtkm::Vec< vtkm::Id, 4 >
	Id4 corresponds to a 4-dimensional index. More...
using	IdComponent4 = vtkm::Vec< vtkm::IdComponent, 4 >
	IdComponent4 corresponds to an index to a local (small) 4-d array or equivalent. More...
using	Vec4f = vtkm::Vec< vtkm::FloatDefault, 4 >
	Vec4f corresponds to a 4-dimensional vector of floating point values. More...
using	Vec4f_32 = vtkm::Vec< vtkm::Float32, 4 >
	Vec4f_32 corresponds to a 4-dimensional vector of 32-bit floating point values. More...
using	Vec4f_64 = vtkm::Vec< vtkm::Float64, 4 >
	Vec4f_64 corresponds to a 4-dimensional vector of 64-bit floating point values. More...
using	Vec4i = vtkm::Vec< vtkm::Id, 4 >
	Vec4i corresponds to a 4-dimensional vector of integer values. More...
using	Vec4i_8 = vtkm::Vec< vtkm::Int8, 4 >
	Vec4i_8 corresponds to a 4-dimensional vector of 8-bit integer values. More...
using	Vec4i_16 = vtkm::Vec< vtkm::Int16, 4 >
	Vec4i_16 corresponds to a 4-dimensional vector of 16-bit integer values. More...
using	Vec4i_32 = vtkm::Vec< vtkm::Int32, 4 >
	Vec4i_32 corresponds to a 4-dimensional vector of 32-bit integer values. More...
using	Vec4i_64 = vtkm::Vec< vtkm::Int64, 4 >
	Vec4i_64 corresponds to a 4-dimensional vector of 64-bit integer values. More...
using	Vec4ui = vtkm::Vec< vtkm::UInt32, 4 >
	Vec4ui corresponds to a 4-dimensional vector of unsigned integer values. More...
using	Vec4ui_8 = vtkm::Vec< vtkm::UInt8, 4 >
	Vec4ui_8 corresponds to a 4-dimensional vector of 8-bit unsigned integer values. More...
using	Vec4ui_16 = vtkm::Vec< vtkm::UInt16, 4 >
	Vec4ui_16 corresponds to a 4-dimensional vector of 16-bit unsigned integer values. More...
using	Vec4ui_32 = vtkm::Vec< vtkm::UInt32, 4 >
	Vec4ui_32 corresponds to a 4-dimensional vector of 32-bit unsigned integer values. More...
using	Vec4ui_64 = vtkm::Vec< vtkm::UInt64, 4 >
	Vec4ui_64 corresponds to a 4-dimensional vector of 64-bit unsigned integer values. More...
template<typename T >
using	HasVecTraits = typename detail::HasVecTraitsImpl< T >::Type
	Determines whether the given type has VecTraits defined. More...

Enumerations
enum	MemoryOrder {   MemoryOrder::Relaxed, MemoryOrder::Acquire, MemoryOrder::Release, MemoryOrder::AcquireAndRelease,   MemoryOrder::SequentiallyConsistent }
	Specifies memory order semantics for atomic operations. More...
enum	CellShapeIdEnum {   CELL_SHAPE_EMPTY = lcl::ShapeId::EMPTY, CELL_SHAPE_VERTEX = lcl::ShapeId::VERTEX, CELL_SHAPE_LINE = lcl::ShapeId::LINE, CELL_SHAPE_POLY_LINE = 4,   CELL_SHAPE_TRIANGLE = lcl::ShapeId::TRIANGLE, CELL_SHAPE_POLYGON = lcl::ShapeId::POLYGON, CELL_SHAPE_QUAD = lcl::ShapeId::QUAD, CELL_SHAPE_TETRA = lcl::ShapeId::TETRA,   CELL_SHAPE_HEXAHEDRON = lcl::ShapeId::HEXAHEDRON, CELL_SHAPE_WEDGE = lcl::ShapeId::WEDGE, CELL_SHAPE_PYRAMID = lcl::ShapeId::PYRAMID, NUMBER_OF_CELL_SHAPES }
	CellShapeId identifies the type of each cell. More...
enum	ErrorCode {   ErrorCode::Success, ErrorCode::InvalidShapeId, ErrorCode::InvalidNumberOfPoints, ErrorCode::InvalidCellMetric,   ErrorCode::WrongShapeIdForTagType, ErrorCode::InvalidPointId, ErrorCode::InvalidEdgeId, ErrorCode::InvalidFaceId,   ErrorCode::SolutionDidNotConverge, ErrorCode::MatrixFactorizationFailed, ErrorCode::DegenerateCellDetected, ErrorCode::MalformedCellDetected,   ErrorCode::OperationOnEmptyCell, ErrorCode::CellNotFound, ErrorCode::UnknownError }
enum	ColorSpace {   ColorSpace::RGB, ColorSpace::HSV, ColorSpace::HSVWrap, ColorSpace::Lab,   ColorSpace::Diverging }
enum	CopyFlag { CopyFlag::Off = 0, CopyFlag::On = 1 }

Functions
template<typename T >
VTKM_EXEC_CONT T	AtomicLoad (T *const pointer, vtkm::MemoryOrder order=vtkm::MemoryOrder::Acquire)
	Atomic function to load a value from a shared memory location. More...
template<typename T >
VTKM_EXEC_CONT T	AtomicNot (T *pointer, vtkm::MemoryOrder order=vtkm::MemoryOrder::SequentiallyConsistent)
	Atomic function to NOT bits to a shared memory location. More...
template<typename T >
VTKM_EXEC_CONT bool	AtomicCompareExchange (T *shared, T *expected, T desired, vtkm::MemoryOrder order=vtkm::MemoryOrder::SequentiallyConsistent)
	Atomic function that replaces a value given a condition. More...
VTKM_CONT std::ostream &	operator<< (std::ostream &stream, const vtkm::Bounds &bounds)
	Helper function for printing bounds during testing. More...
	VTKM_DEFINE_CELL_TAG (Empty, CELL_SHAPE_EMPTY)
	VTKM_DEFINE_CELL_TAG (Vertex, CELL_SHAPE_VERTEX)
	VTKM_DEFINE_CELL_TAG (Line, CELL_SHAPE_LINE)
	VTKM_DEFINE_CELL_TAG (PolyLine, CELL_SHAPE_POLY_LINE)
	VTKM_DEFINE_CELL_TAG (Triangle, CELL_SHAPE_TRIANGLE)
	VTKM_DEFINE_CELL_TAG (Polygon, CELL_SHAPE_POLYGON)
	VTKM_DEFINE_CELL_TAG (Quad, CELL_SHAPE_QUAD)
	VTKM_DEFINE_CELL_TAG (Tetra, CELL_SHAPE_TETRA)
	VTKM_DEFINE_CELL_TAG (Hexahedron, CELL_SHAPE_HEXAHEDRON)
	VTKM_DEFINE_CELL_TAG (Wedge, CELL_SHAPE_WEDGE)
	VTKM_DEFINE_CELL_TAG (Pyramid, CELL_SHAPE_PYRAMID)
	VTKM_DEFINE_CELL_TRAITS (Empty, 0, 0)
	VTKM_DEFINE_CELL_TRAITS (Vertex, 0, 1)
	VTKM_DEFINE_CELL_TRAITS (Line, 1, 2)
	VTKM_DEFINE_CELL_TRAITS_VARIABLE (PolyLine, 1)
	VTKM_DEFINE_CELL_TRAITS (Triangle, 2, 3)
	VTKM_DEFINE_CELL_TRAITS_VARIABLE (Polygon, 2)
	VTKM_DEFINE_CELL_TRAITS (Quad, 2, 4)
	VTKM_DEFINE_CELL_TRAITS (Tetra, 3, 4)
	VTKM_DEFINE_CELL_TRAITS (Hexahedron, 3, 8)
	VTKM_DEFINE_CELL_TRAITS (Wedge, 3, 6)
	VTKM_DEFINE_CELL_TRAITS (Pyramid, 3, 5)
const VTKM_EXEC_CONT char *	ErrorString (vtkm::ErrorCode code) noexcept
template<typename CoordType , bool IsTwoSided>
VTKM_EXEC_CONT vtkm::Plane< CoordType >	make_PlaneFromPointAndLine (const vtkm::Vec< CoordType, 3 > &point, const vtkm::Ray< CoordType, 3, IsTwoSided > &ray, CoordType tol2=static_cast< CoordType >(1e-8f))
	Construct a plane from a point plus one of: a line, a ray, or a line segment. More...
template<typename CoordType >
VTKM_EXEC_CONT vtkm::Plane< CoordType >	make_PlaneFromPointAndLineSegment (const vtkm::Vec< CoordType, 3 > &point, const vtkm::LineSegment3< CoordType > &segment, CoordType tol2=static_cast< CoordType >(1e-8f))
template<typename CoordType >
VTKM_EXEC_CONT vtkm::Circle< CoordType >	make_CircleFrom3Points (const typename vtkm::Vec< CoordType, 2 > &p0, const typename vtkm::Vec< CoordType, 2 > &p1, const typename vtkm::Vec< CoordType, 2 > &p2, CoordType tol=static_cast< CoordType >(1e-6f))
	Construct a circle from 3 points. More...
template<typename CoordType >
VTKM_EXEC_CONT vtkm::Sphere< CoordType, 3 >	make_SphereFrom4Points (const vtkm::Vec< CoordType, 3 > &a0, const vtkm::Vec< CoordType, 3 > &a1, const vtkm::Vec< CoordType, 3 > &a2, const vtkm::Vec< CoordType, 3 > &a3, CoordType tol=static_cast< CoordType >(1e-6f))
	Construct a sphere from 4 points. More...
template<typename InVecType >
VTKM_EXEC_CONT vtkm::HashType	Hash (const InVecType &inVec)
	Returns a 32-bit hash on a group of integer-type values. More...
template<typename T , vtkm::IdComponent Size>
VTKM_EXEC_CONT std::enable_if<(std::is_floating_point< T >::value||std::is_signed< T >::value), vtkm::Vec< T, Size > >::type	operator- (vtkm::Vec< T, Size > x)
template<typename T >
VTKM_EXEC_CONT std::enable_if<(std::is_floating_point< T >::value||std::is_signed< T >::value), vtkm::Vec< T, 1 > >::type	operator- (const vtkm::Vec< T, 1 > &x)
template<typename T >
VTKM_EXEC_CONT std::enable_if<(std::is_floating_point< T >::value||std::is_signed< T >::value), vtkm::Vec< T, 2 > >::type	operator- (const vtkm::Vec< T, 2 > &x)
template<typename T >
VTKM_EXEC_CONT std::enable_if<(std::is_floating_point< T >::value||std::is_signed< T >::value), vtkm::Vec< T, 3 > >::type	operator- (const vtkm::Vec< T, 3 > &x)
template<typename T >
VTKM_EXEC_CONT std::enable_if<(std::is_floating_point< T >::value||std::is_signed< T >::value), vtkm::Vec< T, 4 > >::type	operator- (const vtkm::Vec< T, 4 > &x)
template<typename T , IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec< T, Size >	operator+ (vtkm::Vec< T, Size > a, const vtkm::Vec< T, Size > &b)
template<typename T , IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec< T, Size >	operator+ (vtkm::Vec< T, Size > a, T scalar)
template<typename T , IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec< T, Size >	operator+ (vtkm::Vec< T, Size > a, vtkm::Float64 scalar)
template<IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec< vtkm::Float64, Size >	operator+ (vtkm::Vec< vtkm::Float64, Size > a, vtkm::Float64 scalar)
template<typename T , IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec< T, Size >	operator+ (T scalar, vtkm::Vec< T, Size > a)
template<typename T , IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec< T, Size >	operator+ (vtkm::Float64 scalar, vtkm::Vec< T, Size > a)
template<IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec< vtkm::Float64, Size >	operator+ (vtkm::Float64 scalar, vtkm::Vec< vtkm::Float64, Size > a)
template<typename T , IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec< T, Size >	operator* (vtkm::Vec< T, Size > a, const vtkm::Vec< T, Size > &b)
template<typename T , IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec< T, Size >	operator* (vtkm::Vec< T, Size > a, T scalar)
template<typename T , IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec< T, Size >	operator* (vtkm::Vec< T, Size > a, vtkm::Float64 scalar)
template<IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec< vtkm::Float64, Size >	operator* (vtkm::Vec< vtkm::Float64, Size > a, vtkm::Float64 scalar)
template<typename T , IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec< T, Size >	operator* (T scalar, vtkm::Vec< T, Size > a)
template<typename T , IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec< T, Size >	operator* (vtkm::Float64 scalar, vtkm::Vec< T, Size > a)
template<IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec< vtkm::Float64, Size >	operator* (vtkm::Float64 scalar, vtkm::Vec< vtkm::Float64, Size > a)
template<typename T , IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec< T, Size >	operator- (vtkm::Vec< T, Size > a, const vtkm::Vec< T, Size > &b)
template<typename T , IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec< T, Size >	operator- (vtkm::Vec< T, Size > a, T scalar)
template<typename T , IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec< T, Size >	operator- (vtkm::Vec< T, Size > a, vtkm::Float64 scalar)
template<IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec< vtkm::Float64, Size >	operator- (vtkm::Vec< vtkm::Float64, Size > a, vtkm::Float64 scalar)
template<typename T , IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec< T, Size >	operator- (T scalar, vtkm::Vec< T, Size > a)
template<typename T , IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec< T, Size >	operator- (vtkm::Float64 scalar, vtkm::Vec< T, Size > a)
template<IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec< vtkm::Float64, Size >	operator- (vtkm::Float64 scalar, vtkm::Vec< vtkm::Float64, Size > a)
template<typename T , IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec< T, Size >	operator/ (vtkm::Vec< T, Size > a, const vtkm::Vec< T, Size > &b)
template<typename T , IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec< T, Size >	operator/ (vtkm::Vec< T, Size > a, T scalar)
template<typename T , IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec< T, Size >	operator/ (vtkm::Vec< T, Size > a, vtkm::Float64 scalar)
template<IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec< vtkm::Float64, Size >	operator/ (vtkm::Vec< vtkm::Float64, Size > a, vtkm::Float64 scalar)
template<typename T , IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec< T, Size >	operator/ (T scalar, vtkm::Vec< T, Size > a)
template<typename T , IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec< T, Size >	operator/ (vtkm::Float64 scalar, vtkm::Vec< T, Size > a)
template<IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec< vtkm::Float64, Size >	operator/ (vtkm::Float64 scalar, vtkm::Vec< vtkm::Float64, Size > a)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 1 >	operator+ (const vtkm::Vec< T, 1 > &a, const vtkm::Vec< T, 1 > &b)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 1 >	operator+ (const vtkm::Vec< T, 1 > &a, T scalar)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 1 >	operator+ (const vtkm::Vec< T, 1 > &a, vtkm::Float64 scalar)
VTKM_EXEC_CONT vtkm::Vec< vtkm::Float64, 1 >	operator+ (const vtkm::Vec< vtkm::Float64, 1 > &a, vtkm::Float64 scalar)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 1 >	operator+ (T scalar, const vtkm::Vec< T, 1 > &a)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 1 >	operator+ (vtkm::Float64 scalar, const vtkm::Vec< T, 1 > &a)
VTKM_EXEC_CONT vtkm::Vec< vtkm::Float64, 1 >	operator+ (vtkm::Float64 scalar, const vtkm::Vec< vtkm::Float64, 1 > &a)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 2 >	operator+ (const vtkm::Vec< T, 2 > &a, const vtkm::Vec< T, 2 > &b)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 2 >	operator+ (const vtkm::Vec< T, 2 > &a, T scalar)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 2 >	operator+ (const vtkm::Vec< T, 2 > &a, vtkm::Float64 scalar)
VTKM_EXEC_CONT vtkm::Vec< vtkm::Float64, 2 >	operator+ (const vtkm::Vec< vtkm::Float64, 2 > &a, vtkm::Float64 scalar)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 2 >	operator+ (T scalar, const vtkm::Vec< T, 2 > &a)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 2 >	operator+ (vtkm::Float64 scalar, const vtkm::Vec< T, 2 > &a)
VTKM_EXEC_CONT vtkm::Vec< vtkm::Float64, 2 >	operator+ (vtkm::Float64 scalar, const vtkm::Vec< vtkm::Float64, 2 > &a)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 3 >	operator+ (const vtkm::Vec< T, 3 > &a, const vtkm::Vec< T, 3 > &b)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 3 >	operator+ (const vtkm::Vec< T, 3 > &a, T scalar)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 3 >	operator+ (const vtkm::Vec< T, 3 > &a, vtkm::Float64 scalar)
VTKM_EXEC_CONT vtkm::Vec< vtkm::Float64, 3 >	operator+ (const vtkm::Vec< vtkm::Float64, 3 > &a, vtkm::Float64 scalar)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 3 >	operator+ (T scalar, const vtkm::Vec< T, 3 > &a)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 3 >	operator+ (vtkm::Float64 scalar, const vtkm::Vec< T, 3 > &a)
VTKM_EXEC_CONT vtkm::Vec< vtkm::Float64, 3 >	operator+ (vtkm::Float64 scalar, const vtkm::Vec< vtkm::Float64, 3 > &a)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 4 >	operator+ (const vtkm::Vec< T, 4 > &a, const vtkm::Vec< T, 4 > &b)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 4 >	operator+ (const vtkm::Vec< T, 4 > &a, T scalar)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 4 >	operator+ (const vtkm::Vec< T, 4 > &a, vtkm::Float64 scalar)
VTKM_EXEC_CONT vtkm::Vec< vtkm::Float64, 4 >	operator+ (const vtkm::Vec< vtkm::Float64, 4 > &a, vtkm::Float64 scalar)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 4 >	operator+ (T scalar, const vtkm::Vec< T, 4 > &a)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 4 >	operator+ (vtkm::Float64 scalar, const vtkm::Vec< T, 4 > &a)
VTKM_EXEC_CONT vtkm::Vec< vtkm::Float64, 4 >	operator+ (vtkm::Float64 scalar, const vtkm::Vec< vtkm::Float64, 4 > &a)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 1 >	operator* (const vtkm::Vec< T, 1 > &a, const vtkm::Vec< T, 1 > &b)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 1 >	operator* (const vtkm::Vec< T, 1 > &a, T scalar)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 1 >	operator* (const vtkm::Vec< T, 1 > &a, vtkm::Float64 scalar)
VTKM_EXEC_CONT vtkm::Vec< vtkm::Float64, 1 >	operator* (const vtkm::Vec< vtkm::Float64, 1 > &a, vtkm::Float64 scalar)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 1 >	operator* (T scalar, const vtkm::Vec< T, 1 > &a)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 1 >	operator* (vtkm::Float64 scalar, const vtkm::Vec< T, 1 > &a)
VTKM_EXEC_CONT vtkm::Vec< vtkm::Float64, 1 >	operator* (vtkm::Float64 scalar, const vtkm::Vec< vtkm::Float64, 1 > &a)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 2 >	operator* (const vtkm::Vec< T, 2 > &a, const vtkm::Vec< T, 2 > &b)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 2 >	operator* (const vtkm::Vec< T, 2 > &a, T scalar)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 2 >	operator* (const vtkm::Vec< T, 2 > &a, vtkm::Float64 scalar)
VTKM_EXEC_CONT vtkm::Vec< vtkm::Float64, 2 >	operator* (const vtkm::Vec< vtkm::Float64, 2 > &a, vtkm::Float64 scalar)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 2 >	operator* (T scalar, const vtkm::Vec< T, 2 > &a)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 2 >	operator* (vtkm::Float64 scalar, const vtkm::Vec< T, 2 > &a)
VTKM_EXEC_CONT vtkm::Vec< vtkm::Float64, 2 >	operator* (vtkm::Float64 scalar, const vtkm::Vec< vtkm::Float64, 2 > &a)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 3 >	operator* (const vtkm::Vec< T, 3 > &a, const vtkm::Vec< T, 3 > &b)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 3 >	operator* (const vtkm::Vec< T, 3 > &a, T scalar)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 3 >	operator* (const vtkm::Vec< T, 3 > &a, vtkm::Float64 scalar)
VTKM_EXEC_CONT vtkm::Vec< vtkm::Float64, 3 >	operator* (const vtkm::Vec< vtkm::Float64, 3 > &a, vtkm::Float64 scalar)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 3 >	operator* (T scalar, const vtkm::Vec< T, 3 > &a)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 3 >	operator* (vtkm::Float64 scalar, const vtkm::Vec< T, 3 > &a)
VTKM_EXEC_CONT vtkm::Vec< vtkm::Float64, 3 >	operator* (vtkm::Float64 scalar, const vtkm::Vec< vtkm::Float64, 3 > &a)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 4 >	operator* (const vtkm::Vec< T, 4 > &a, const vtkm::Vec< T, 4 > &b)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 4 >	operator* (const vtkm::Vec< T, 4 > &a, T scalar)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 4 >	operator* (const vtkm::Vec< T, 4 > &a, vtkm::Float64 scalar)
VTKM_EXEC_CONT vtkm::Vec< vtkm::Float64, 4 >	operator* (const vtkm::Vec< vtkm::Float64, 4 > &a, vtkm::Float64 scalar)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 4 >	operator* (T scalar, const vtkm::Vec< T, 4 > &a)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 4 >	operator* (vtkm::Float64 scalar, const vtkm::Vec< T, 4 > &a)
VTKM_EXEC_CONT vtkm::Vec< vtkm::Float64, 4 >	operator* (vtkm::Float64 scalar, const vtkm::Vec< vtkm::Float64, 4 > &a)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 1 >	operator- (const vtkm::Vec< T, 1 > &a, const vtkm::Vec< T, 1 > &b)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 1 >	operator- (const vtkm::Vec< T, 1 > &a, T scalar)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 1 >	operator- (const vtkm::Vec< T, 1 > &a, vtkm::Float64 scalar)
VTKM_EXEC_CONT vtkm::Vec< vtkm::Float64, 1 >	operator- (const vtkm::Vec< vtkm::Float64, 1 > &a, vtkm::Float64 scalar)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 1 >	operator- (T scalar, const vtkm::Vec< T, 1 > &a)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 1 >	operator- (vtkm::Float64 scalar, const vtkm::Vec< T, 1 > &a)
VTKM_EXEC_CONT vtkm::Vec< vtkm::Float64, 1 >	operator- (vtkm::Float64 scalar, const vtkm::Vec< vtkm::Float64, 1 > &a)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 2 >	operator- (const vtkm::Vec< T, 2 > &a, const vtkm::Vec< T, 2 > &b)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 2 >	operator- (const vtkm::Vec< T, 2 > &a, T scalar)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 2 >	operator- (const vtkm::Vec< T, 2 > &a, vtkm::Float64 scalar)
VTKM_EXEC_CONT vtkm::Vec< vtkm::Float64, 2 >	operator- (const vtkm::Vec< vtkm::Float64, 2 > &a, vtkm::Float64 scalar)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 2 >	operator- (T scalar, const vtkm::Vec< T, 2 > &a)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 2 >	operator- (vtkm::Float64 scalar, const vtkm::Vec< T, 2 > &a)
VTKM_EXEC_CONT vtkm::Vec< vtkm::Float64, 2 >	operator- (vtkm::Float64 scalar, const vtkm::Vec< vtkm::Float64, 2 > &a)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 3 >	operator- (const vtkm::Vec< T, 3 > &a, const vtkm::Vec< T, 3 > &b)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 3 >	operator- (const vtkm::Vec< T, 3 > &a, T scalar)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 3 >	operator- (const vtkm::Vec< T, 3 > &a, vtkm::Float64 scalar)
VTKM_EXEC_CONT vtkm::Vec< vtkm::Float64, 3 >	operator- (const vtkm::Vec< vtkm::Float64, 3 > &a, vtkm::Float64 scalar)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 3 >	operator- (T scalar, const vtkm::Vec< T, 3 > &a)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 3 >	operator- (vtkm::Float64 scalar, const vtkm::Vec< T, 3 > &a)
VTKM_EXEC_CONT vtkm::Vec< vtkm::Float64, 3 >	operator- (vtkm::Float64 scalar, const vtkm::Vec< vtkm::Float64, 3 > &a)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 4 >	operator- (const vtkm::Vec< T, 4 > &a, const vtkm::Vec< T, 4 > &b)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 4 >	operator- (const vtkm::Vec< T, 4 > &a, T scalar)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 4 >	operator- (const vtkm::Vec< T, 4 > &a, vtkm::Float64 scalar)
VTKM_EXEC_CONT vtkm::Vec< vtkm::Float64, 4 >	operator- (const vtkm::Vec< vtkm::Float64, 4 > &a, vtkm::Float64 scalar)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 4 >	operator- (T scalar, const vtkm::Vec< T, 4 > &a)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 4 >	operator- (vtkm::Float64 scalar, const vtkm::Vec< T, 4 > &a)
VTKM_EXEC_CONT vtkm::Vec< vtkm::Float64, 4 >	operator- (vtkm::Float64 scalar, const vtkm::Vec< vtkm::Float64, 4 > &a)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 1 >	operator/ (const vtkm::Vec< T, 1 > &a, const vtkm::Vec< T, 1 > &b)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 1 >	operator/ (const vtkm::Vec< T, 1 > &a, T scalar)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 1 >	operator/ (const vtkm::Vec< T, 1 > &a, vtkm::Float64 scalar)
VTKM_EXEC_CONT vtkm::Vec< vtkm::Float64, 1 >	operator/ (const vtkm::Vec< vtkm::Float64, 1 > &a, vtkm::Float64 scalar)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 1 >	operator/ (T scalar, const vtkm::Vec< T, 1 > &a)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 1 >	operator/ (vtkm::Float64 scalar, const vtkm::Vec< T, 1 > &a)
VTKM_EXEC_CONT vtkm::Vec< vtkm::Float64, 1 >	operator/ (vtkm::Float64 scalar, const vtkm::Vec< vtkm::Float64, 1 > &a)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 2 >	operator/ (const vtkm::Vec< T, 2 > &a, const vtkm::Vec< T, 2 > &b)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 2 >	operator/ (const vtkm::Vec< T, 2 > &a, T scalar)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 2 >	operator/ (const vtkm::Vec< T, 2 > &a, vtkm::Float64 scalar)
VTKM_EXEC_CONT vtkm::Vec< vtkm::Float64, 2 >	operator/ (const vtkm::Vec< vtkm::Float64, 2 > &a, vtkm::Float64 scalar)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 2 >	operator/ (T scalar, const vtkm::Vec< T, 2 > &a)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 2 >	operator/ (vtkm::Float64 scalar, const vtkm::Vec< T, 2 > &a)
VTKM_EXEC_CONT vtkm::Vec< vtkm::Float64, 2 >	operator/ (vtkm::Float64 scalar, const vtkm::Vec< vtkm::Float64, 2 > &a)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 3 >	operator/ (const vtkm::Vec< T, 3 > &a, const vtkm::Vec< T, 3 > &b)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 3 >	operator/ (const vtkm::Vec< T, 3 > &a, T scalar)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 3 >	operator/ (const vtkm::Vec< T, 3 > &a, vtkm::Float64 scalar)
VTKM_EXEC_CONT vtkm::Vec< vtkm::Float64, 3 >	operator/ (const vtkm::Vec< vtkm::Float64, 3 > &a, vtkm::Float64 scalar)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 3 >	operator/ (T scalar, const vtkm::Vec< T, 3 > &a)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 3 >	operator/ (vtkm::Float64 scalar, const vtkm::Vec< T, 3 > &a)
VTKM_EXEC_CONT vtkm::Vec< vtkm::Float64, 3 >	operator/ (vtkm::Float64 scalar, const vtkm::Vec< vtkm::Float64, 3 > &a)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 4 >	operator/ (const vtkm::Vec< T, 4 > &a, const vtkm::Vec< T, 4 > &b)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 4 >	operator/ (const vtkm::Vec< T, 4 > &a, T scalar)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 4 >	operator/ (const vtkm::Vec< T, 4 > &a, vtkm::Float64 scalar)
VTKM_EXEC_CONT vtkm::Vec< vtkm::Float64, 4 >	operator/ (const vtkm::Vec< vtkm::Float64, 4 > &a, vtkm::Float64 scalar)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 4 >	operator/ (T scalar, const vtkm::Vec< T, 4 > &a)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 4 >	operator/ (vtkm::Float64 scalar, const vtkm::Vec< T, 4 > &a)
VTKM_EXEC_CONT vtkm::Vec< vtkm::Float64, 4 >	operator/ (vtkm::Float64 scalar, const vtkm::Vec< vtkm::Float64, 4 > &a)
VTKM_EXEC_CONT vtkm::Float32	Sin (vtkm::Float32 x)
	Compute the sine of x. More...
VTKM_EXEC_CONT vtkm::Float64	Sin (vtkm::Float64 x)
VTKM_EXEC_CONT vtkm::Float32	Cos (vtkm::Float32 x)
	Compute the cosine of x. More...
VTKM_EXEC_CONT vtkm::Float64	Cos (vtkm::Float64 x)
VTKM_EXEC_CONT vtkm::Float32	Tan (vtkm::Float32 x)
	Compute the tangent of x. More...
VTKM_EXEC_CONT vtkm::Float64	Tan (vtkm::Float64 x)
VTKM_EXEC_CONT vtkm::Float32	ASin (vtkm::Float32 x)
	Compute the arc sine of x. More...
VTKM_EXEC_CONT vtkm::Float64	ASin (vtkm::Float64 x)
VTKM_EXEC_CONT vtkm::Float32	ACos (vtkm::Float32 x)
	Compute the arc cosine of x. More...
VTKM_EXEC_CONT vtkm::Float64	ACos (vtkm::Float64 x)
VTKM_EXEC_CONT vtkm::Float32	ATan (vtkm::Float32 x)
	Compute the arc tangent of x. More...
VTKM_EXEC_CONT vtkm::Float64	ATan (vtkm::Float64 x)
VTKM_EXEC_CONT vtkm::Float32	SinH (vtkm::Float32 x)
	Compute the hyperbolic sine of x. More...
VTKM_EXEC_CONT vtkm::Float64	SinH (vtkm::Float64 x)
VTKM_EXEC_CONT vtkm::Float32	CosH (vtkm::Float32 x)
	Compute the hyperbolic cosine of x. More...
VTKM_EXEC_CONT vtkm::Float64	CosH (vtkm::Float64 x)
VTKM_EXEC_CONT vtkm::Float32	TanH (vtkm::Float32 x)
	Compute the hyperbolic tangent of x. More...
VTKM_EXEC_CONT vtkm::Float64	TanH (vtkm::Float64 x)
VTKM_EXEC_CONT vtkm::Float32	ASinH (vtkm::Float32 x)
	Compute the hyperbolic arc sine of x. More...
VTKM_EXEC_CONT vtkm::Float64	ASinH (vtkm::Float64 x)
VTKM_EXEC_CONT vtkm::Float32	ACosH (vtkm::Float32 x)
	Compute the hyperbolic arc cosine of x. More...
VTKM_EXEC_CONT vtkm::Float64	ACosH (vtkm::Float64 x)
VTKM_EXEC_CONT vtkm::Float32	ATanH (vtkm::Float32 x)
	Compute the hyperbolic arc tangent of x. More...
VTKM_EXEC_CONT vtkm::Float64	ATanH (vtkm::Float64 x)
VTKM_EXEC_CONT vtkm::Float32	Sqrt (vtkm::Float32 x)
	Compute the square root of x. More...
VTKM_EXEC_CONT vtkm::Float64	Sqrt (vtkm::Float64 x)
VTKM_EXEC_CONT vtkm::Float32	Cbrt (vtkm::Float32 x)
	Compute the cube root of x. More...
VTKM_EXEC_CONT vtkm::Float64	Cbrt (vtkm::Float64 x)
VTKM_EXEC_CONT vtkm::Float32	Exp (vtkm::Float32 x)
	Computes e**x, the base-e exponential of x. More...
VTKM_EXEC_CONT vtkm::Float64	Exp (vtkm::Float64 x)
VTKM_EXEC_CONT vtkm::Float32	Exp2 (vtkm::Float32 x)
	Computes 2**x, the base-2 exponential of x. More...
VTKM_EXEC_CONT vtkm::Float64	Exp2 (vtkm::Float64 x)
VTKM_EXEC_CONT vtkm::Float32	ExpM1 (vtkm::Float32 x)
	Computes (e**x) - 1, the of base-e exponental of x then minus 1. More...
VTKM_EXEC_CONT vtkm::Float64	ExpM1 (vtkm::Float64 x)
VTKM_EXEC_CONT vtkm::Float32	Log (vtkm::Float32 x)
	Computes the natural logarithm of x. More...
VTKM_EXEC_CONT vtkm::Float64	Log (vtkm::Float64 x)
VTKM_EXEC_CONT vtkm::Float32	Log2 (vtkm::Float32 x)
	Computes the logarithm base 2 of x. More...
VTKM_EXEC_CONT vtkm::Float64	Log2 (vtkm::Float64 x)
VTKM_EXEC_CONT vtkm::Float32	Log10 (vtkm::Float32 x)
	Computes the logarithm base 10 of x. More...
VTKM_EXEC_CONT vtkm::Float64	Log10 (vtkm::Float64 x)
VTKM_EXEC_CONT vtkm::Float32	Log1P (vtkm::Float32 x)
	Computes the value of log(1+x) accurately for very small values of x. More...
VTKM_EXEC_CONT vtkm::Float64	Log1P (vtkm::Float64 x)
VTKM_EXEC_CONT vtkm::Float32	Clamp (vtkm::Float32 x, vtkm::Float32 lo, vtkm::Float32 hi)
	Clamp x to the given range. More...
VTKM_EXEC_CONT vtkm::Float64	Clamp (vtkm::Float64 x, vtkm::Float64 lo, vtkm::Float64 hi)
VTKM_EXEC_CONT vtkm::Float32	Ceil (vtkm::Float32 x)
	Round x to the smallest integer value not less than x. More...
VTKM_EXEC_CONT vtkm::Float64	Ceil (vtkm::Float64 x)
VTKM_EXEC_CONT vtkm::Float32	Floor (vtkm::Float32 x)
	Round x to the largest integer value not greater than x. More...
VTKM_EXEC_CONT vtkm::Float64	Floor (vtkm::Float64 x)
VTKM_EXEC_CONT vtkm::Float32	Round (vtkm::Float32 x)
	Round x to the nearest integral value. More...
VTKM_EXEC_CONT vtkm::Float64	Round (vtkm::Float64 x)
VTKM_EXEC_CONT vtkm::Float32	Frexp (vtkm::Float32 x, vtkm::Int32 *exponent)
	Decompose floating poing value. More...
VTKM_EXEC_CONT vtkm::Float64	Frexp (vtkm::Float64 x, vtkm::Int32 *exponent)
VTKM_EXEC_CONT vtkm::Float32	Ldexp (vtkm::Float32 x, vtkm::Int32 exponent)
VTKM_EXEC_CONT vtkm::Float64	Ldexp (vtkm::Float64 x, vtkm::Int32 exponent)
VTKM_EXEC_CONT vtkm::UInt64	FloatDistance (vtkm::Float64 x, vtkm::Float64 y)
VTKM_EXEC_CONT vtkm::UInt64	FloatDistance (vtkm::Float32 x, vtkm::Float32 y)
template<typename T >
VTKM_EXEC_CONT T	DifferenceOfProducts (T a, T b, T c, T d)
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 2 >	QuadraticRoots (T a, T b, T c)
VTKM_EXEC_CONT vtkm::Int32	FindFirstSetBit (vtkm::UInt32 word)
	Bitwise operations. More...
VTKM_EXEC_CONT vtkm::Int32	FindFirstSetBit (vtkm::UInt64 word)
	Find the first set bit in word, and return its position (1-64). More...
VTKM_EXEC_CONT vtkm::Int32	CountSetBits (vtkm::UInt32 word)
	Count the total number of bits set in word. More...
VTKM_EXEC_CONT vtkm::Int32	CountSetBits (vtkm::UInt64 word)
	Count the total number of bits set in word. More...
template<typename T , vtkm::IdComponent NumRow, vtkm::IdComponent NumCol>
const VTKM_EXEC_CONT vtkm::Vec< T, NumCol > &	MatrixGetRow (const vtkm::Matrix< T, NumRow, NumCol > &matrix, vtkm::IdComponent rowIndex)
	Returns a tuple containing the given row (indexed from 0) of the given matrix. More...
template<typename T , vtkm::IdComponent NumRow, vtkm::IdComponent NumCol>
VTKM_EXEC_CONT vtkm::Vec< T, NumRow >	MatrixGetColumn (const vtkm::Matrix< T, NumRow, NumCol > &matrix, vtkm::IdComponent columnIndex)
	Returns a tuple containing the given column (indexed from 0) of the given matrix. More...
template<typename T , vtkm::IdComponent NumRow, vtkm::IdComponent NumCol>
VTKM_EXEC_CONT void	MatrixSetRow (vtkm::Matrix< T, NumRow, NumCol > &matrix, vtkm::IdComponent rowIndex, const vtkm::Vec< T, NumCol > &rowValues)
	Convenience function for setting a row of a matrix. More...
template<typename T , vtkm::IdComponent NumRow, vtkm::IdComponent NumCol>
VTKM_EXEC_CONT void	MatrixSetColumn (vtkm::Matrix< T, NumRow, NumCol > &matrix, vtkm::IdComponent columnIndex, const vtkm::Vec< T, NumRow > &columnValues)
	Convenience function for setting a column of a matrix. More...
template<typename T , vtkm::IdComponent NumRow, vtkm::IdComponent NumCol, vtkm::IdComponent NumInternal>
VTKM_EXEC_CONT vtkm::Matrix< T, NumRow, NumCol >	MatrixMultiply (const vtkm::Matrix< T, NumRow, NumInternal > &leftFactor, const vtkm::Matrix< T, NumInternal, NumCol > &rightFactor)
	Standard matrix multiplication. More...
template<typename T , vtkm::IdComponent NumRow, vtkm::IdComponent NumCol>
VTKM_EXEC_CONT vtkm::Vec< T, NumRow >	MatrixMultiply (const vtkm::Matrix< T, NumRow, NumCol > &leftFactor, const vtkm::Vec< T, NumCol > &rightFactor)
	Standard matrix-vector multiplication. More...
template<typename T , vtkm::IdComponent NumRow, vtkm::IdComponent NumCol>
VTKM_EXEC_CONT vtkm::Vec< T, NumCol >	MatrixMultiply (const vtkm::Vec< T, NumRow > &leftFactor, const vtkm::Matrix< T, NumRow, NumCol > &rightFactor)
	Standard vector-matrix multiplication. More...
template<typename T , vtkm::IdComponent Size>
VTKM_EXEC_CONT vtkm::Matrix< T, Size, Size >	MatrixIdentity ()
	Returns the identity matrix. More...
template<typename T , vtkm::IdComponent Size>
VTKM_EXEC_CONT void	MatrixIdentity (vtkm::Matrix< T, Size, Size > &matrix)
	Fills the given matrix with the identity matrix. More...
template<typename T , vtkm::IdComponent NumRows, vtkm::IdComponent NumCols>
VTKM_EXEC_CONT vtkm::Matrix< T, NumCols, NumRows >	MatrixTranspose (const vtkm::Matrix< T, NumRows, NumCols > &matrix)
	Returns the transpose of the given matrix. More...
template<typename T , vtkm::IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec< T, Size >	SolveLinearSystem (const vtkm::Matrix< T, Size, Size > &A, const vtkm::Vec< T, Size > &b, bool &valid)
	Solve the linear system Ax = b for x. More...
template<typename T , vtkm::IdComponent Size>
VTKM_EXEC_CONT vtkm::Matrix< T, Size, Size >	MatrixInverse (const vtkm::Matrix< T, Size, Size > &A, bool &valid)
	Find and return the inverse of the given matrix. More...
template<typename T , vtkm::IdComponent Size>
VTKM_EXEC_CONT T	MatrixDeterminant (const vtkm::Matrix< T, Size, Size > &A)
	Compute the determinant of a matrix. More...
template<typename T >
VTKM_EXEC_CONT T	MatrixDeterminant (const vtkm::Matrix< T, 1, 1 > &A)
template<typename T >
VTKM_EXEC_CONT T	MatrixDeterminant (const vtkm::Matrix< T, 2, 2 > &A)
template<typename T >
VTKM_EXEC_CONT T	MatrixDeterminant (const vtkm::Matrix< T, 3, 3 > &A)
template<typename T , vtkm::IdComponent NumRow, vtkm::IdComponent NumCol>
VTKM_EXEC_CONT bool	operator== (const vtkm::Matrix< T, NumRow, NumCol > &a, const vtkm::Matrix< T, NumRow, NumCol > &b)
template<typename T , vtkm::IdComponent NumRow, vtkm::IdComponent NumCol>
VTKM_EXEC_CONT bool	operator!= (const vtkm::Matrix< T, NumRow, NumCol > &a, const vtkm::Matrix< T, NumRow, NumCol > &b)
template<typename T , vtkm::IdComponent NumRow, vtkm::IdComponent NumCol>
VTKM_CONT std::ostream &	operator<< (std::ostream &stream, const vtkm::Matrix< T, NumRow, NumCol > &mat)
	Helper function for printing out matricies during testing. More...
template<typename ScalarType , vtkm::IdComponent Size, typename JacobianFunctor , typename FunctionFunctor >
VTKM_SUPPRESS_EXEC_WARNINGS VTKM_EXEC_CONT NewtonsMethodResult< ScalarType, Size >	NewtonsMethod (JacobianFunctor jacobianEvaluator, FunctionFunctor functionEvaluator, vtkm::Vec< ScalarType, Size > desiredFunctionOutput, vtkm::Vec< ScalarType, Size > initialGuess=vtkm::Vec< ScalarType, Size >(ScalarType(0)), ScalarType convergeDifference=ScalarType(1e-3), vtkm::IdComponent maxIterations=10)
	Uses Newton's method (a.k.a. More...
template<typename T , typename U >
VTKM_EXEC_CONT vtkm::Pair< T, U >	operator+ (const vtkm::Pair< T, U > &a, const vtkm::Pair< T, U > &b)
	Pairwise Add. More...
template<typename T1 , typename T2 >
VTKM_EXEC_CONT vtkm::Pair< typename std::decay< T1 >::type, typename std::decay< T2 >::type >	make_Pair (T1 &&v1, T2 &&v2)
VTKM_CONT std::ostream &	operator<< (std::ostream &s, const vtkm::ParticleStatus &status)
VTKM_CONT std::ostream &	operator<< (std::ostream &stream, const vtkm::Range &range)
	Helper function for printing ranges during testing. More...
VTKM_CONT std::ostream &	operator<< (std::ostream &stream, const vtkm::RangeId3 &range)
	Helper function for printing range during testing. More...
template<typename T >
VTKM_EXEC_CONT void	Swap (T &a, T &b)
	Performs a swap operation. Safe to call from cuda code. More...
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 3 >	Transform3DPoint (const vtkm::Matrix< T, 4, 4 > &matrix, const vtkm::Vec< T, 3 > &point)
	Transform a 3D point by a transformation matrix. More...
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 3 >	Transform3DPointPerspective (const vtkm::Matrix< T, 4, 4 > &matrix, const vtkm::Vec< T, 3 > &point)
	Transform a 3D point by a transformation matrix with perspective. More...
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< T, 3 >	Transform3DVector (const vtkm::Matrix< T, 4, 4 > &matrix, const vtkm::Vec< T, 3 > &vector)
	Transform a 3D vector by a transformation matrix. More...
template<typename T >
VTKM_EXEC_CONT vtkm::Matrix< T, 4, 4 >	Transform3DScale (const T &scaleX, const T &scaleY, const T &scaleZ)
	Returns a scale matrix. More...
template<typename T >
VTKM_EXEC_CONT vtkm::Matrix< T, 4, 4 >	Transform3DScale (const vtkm::Vec< T, 3 > &scaleVec)
	Returns a scale matrix. More...
template<typename T >
VTKM_EXEC_CONT vtkm::Matrix< T, 4, 4 >	Transform3DScale (const T &scale)
	Returns a scale matrix. More...
template<typename T >
VTKM_EXEC_CONT vtkm::Matrix< T, 4, 4 >	Transform3DTranslate (const T &x, const T &y, const T &z)
	Returns a translation matrix. More...
template<typename T >
VTKM_EXEC_CONT vtkm::Matrix< T, 4, 4 >	Transform3DTranslate (const vtkm::Vec< T, 3 > &v)
template<typename T >
VTKM_EXEC_CONT vtkm::Matrix< T, 4, 4 >	Transform3DRotate (T angleDegrees, const vtkm::Vec< T, 3 > &axisOfRotation)
	Returns a rotation matrix. More...
template<typename T >
VTKM_EXEC_CONT vtkm::Matrix< T, 4, 4 >	Transform3DRotate (T angleDegrees, T x, T y, T z)
template<typename T >
VTKM_EXEC_CONT vtkm::Matrix< T, 4, 4 >	Transform3DRotateX (T angleDegrees)
	Returns a rotation matrix. More...
template<typename T >
VTKM_EXEC_CONT vtkm::Matrix< T, 4, 4 >	Transform3DRotateY (T angleDegrees)
	Returns a rotation matrix. More...
template<typename T >
VTKM_EXEC_CONT vtkm::Matrix< T, 4, 4 >	Transform3DRotateZ (T angleDegrees)
	Returns a rotation matrix. More...
template<typename... Ts>
VTKM_SUPPRESS_EXEC_WARNINGS VTKM_EXEC_CONT auto	MakeTuple (Ts &&... args) -> vtkm::Tuple< typename std::decay< Ts >::type... >
	Creates a new vtkm::Tuple with the given types. More...
template<typename... Ts>
VTKM_SUPPRESS_EXEC_WARNINGS VTKM_EXEC_CONT auto	make_tuple (Ts &&... args) -> decltype(vtkm::MakeTuple(std::forward< Ts >(args)...))
	Compatible with std::make_tuple for vtkm::Tuple. More...
template<typename T , typename... Ts>
constexpr VTKM_EXEC_CONT vtkm::Vec< T, vtkm::IdComponent(sizeof...(Ts)+1)>	make_Vec (T value0, Ts &&... args)
	Initializes and returns a Vec containing all the arguments. More...
template<typename T , vtkm::IdComponent Size>
VTKM_EXEC_CONT T	ReduceSum (const vtkm::Vec< T, Size > &a)
template<typename T >
VTKM_EXEC_CONT T	ReduceSum (const vtkm::Vec< T, 2 > &a)
template<typename T >
VTKM_EXEC_CONT T	ReduceSum (const vtkm::Vec< T, 3 > &a)
template<typename T >
VTKM_EXEC_CONT T	ReduceSum (const vtkm::Vec< T, 4 > &a)
template<typename T , vtkm::IdComponent Size>
VTKM_EXEC_CONT T	ReduceProduct (const vtkm::Vec< T, Size > &a)
template<typename T >
VTKM_EXEC_CONT T	ReduceProduct (const vtkm::Vec< T, 2 > &a)
template<typename T >
VTKM_EXEC_CONT T	ReduceProduct (const vtkm::Vec< T, 3 > &a)
template<typename T >
VTKM_EXEC_CONT T	ReduceProduct (const vtkm::Vec< T, 4 > &a)
template<typename T , vtkm::IdComponent Size>
VTKM_CONT std::ostream &	operator<< (std::ostream &stream, const vtkm::Vec< T, Size > &vec)
	Helper function for printing out vectors during testing. More...
template<typename T , typename U >
VTKM_EXEC_CONT std::ostream &	operator<< (std::ostream &stream, const vtkm::Pair< T, U > &vec)
	Helper function for printing out pairs during testing. More...
template<vtkm::IdComponent NumDimensions>
VTKM_CONT std::ostream &	operator<< (std::ostream &stream, const vtkm::VecAxisAlignedPointCoordinates< NumDimensions > &vec)
	Helper function for printing out vectors during testing. More...
template<typename T >
VTKM_EXEC_CONT vtkm::VecFlat< T >	make_VecFlat (const T &vec)
	Converts a Vec-like object to a VecFlat. More...
template<typename IndexVecType , typename PortalType >
VTKM_EXEC VecFromPortalPermute< IndexVecType, PortalType >	make_VecFromPortalPermute (const IndexVecType *index, const PortalType &portal)
template<typename IndexVecType , typename PortalType >
VTKM_EXEC VecFromPortalPermute< IndexVecType, const PortalType * >	make_VecFromPortalPermute (const IndexVecType *index, const PortalType *const portal)
template<typename ValueType , typename WeightType >
VTKM_EXEC_CONT ValueType	Lerp (const ValueType &value0, const ValueType &value1, const WeightType &weight)
	Returns the linear interpolation of two values based on weight. More...
template<typename ValueType , vtkm::IdComponent N, typename WeightType >
VTKM_EXEC_CONT vtkm::Vec< ValueType, N >	Lerp (const vtkm::Vec< ValueType, N > &value0, const vtkm::Vec< ValueType, N > &value1, const WeightType &weight)
template<typename ValueType , vtkm::IdComponent N>
VTKM_EXEC_CONT vtkm::Vec< ValueType, N >	Lerp (const vtkm::Vec< ValueType, N > &value0, const vtkm::Vec< ValueType, N > &value1, const vtkm::Vec< ValueType, N > &weight)
template<typename T >
VTKM_EXEC_CONT detail::FloatingPointReturnType< T >::Type	MagnitudeSquared (const T &x)
	Returns the square of the magnitude of a vector. More...
template<typename T >
VTKM_EXEC_CONT detail::FloatingPointReturnType< T >::Type	Magnitude (const T &x)
	Returns the magnitude of a vector. More...
template<typename T >
VTKM_EXEC_CONT detail::FloatingPointReturnType< T >::Type	RMagnitude (const T &x)
	Returns the reciprocal magnitude of a vector. More...
template<typename T >
VTKM_EXEC_CONT T	Normal (const T &x)
	Returns a normalized version of the given vector. More...
template<typename T >
VTKM_EXEC_CONT void	Normalize (T &x)
	Changes a vector to be normal. More...
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< typename detail::FloatingPointReturnType< T >::Type, 3 >	Cross (const vtkm::Vec< T, 3 > &x, const vtkm::Vec< T, 3 > &y)
	Find the cross product of two vectors. More...
template<typename T >
VTKM_EXEC_CONT vtkm::Vec< typename detail::FloatingPointReturnType< T >::Type, 3 >	TriangleNormal (const vtkm::Vec< T, 3 > &a, const vtkm::Vec< T, 3 > &b, const vtkm::Vec< T, 3 > &c)
	Find the normal of a triangle. More...
template<typename T , int N>
VTKM_EXEC_CONT vtkm::Vec< T, N >	Project (const vtkm::Vec< T, N > &v, const vtkm::Vec< T, N > &u)
	Project a vector onto another vector. More...
template<typename T , int N>
VTKM_EXEC_CONT T	ProjectedDistance (const vtkm::Vec< T, N > &v, const vtkm::Vec< T, N > &u)
	Project a vector onto another vector, returning only the projected distance. More...
template<typename T , int N>
VTKM_EXEC_CONT int	Orthonormalize (const vtkm::Vec< vtkm::Vec< T, N >, N > &inputs, vtkm::Vec< vtkm::Vec< T, N >, N > &outputs, T tol=static_cast< T >(1e-6))
	Perform Gram-Schmidt orthonormalization for 3-D vectors. More...

Variables
template<typename T , vtkm::IdComponent Size>
class VTKM_ALWAYS_EXPORT	Vec
template<typename T >
class VTKM_ALWAYS_EXPORT	VecC
template<typename T >
class VTKM_ALWAYS_EXPORT	VecCConst
template<typename TupleType >
using	TupleSize = std::integral_constant< vtkm::IdComponent, TupleType::Size >
	Get the size of a tuple. More...
template<typename TupleType >
using	tuple_size = std::integral_constant< std::size_t, static_cast< std::size_t >(TupleType::Size)>
	Compatible with std::tuple_size for vtkm::Tuple. More...
template<vtkm::IdComponent Index, typename TupleType >
using	TupleElement = typename detail::TupleElementImpl< Index, TupleType >::type
	Becomes the type of the given index for the given vtkm::Tuple. More...
template<std::size_t Index, typename TupleType >
using	tuple_element_t = typename tuple_element< Index, TupleType >::type
	Compatible with std::tuple_element_t for vtkm::Tuple. More...
template<vtkm::IdComponent Index, typename... Ts>
VTKM_SUPPRESS_EXEC_WARNINGS VTKM_EXEC_CONT auto	Get (const vtkm::Tuple< Ts... > &tuple) -> decltype(tuple.template Get< Index >())
	Retrieve the object from a vtkm::Tuple at the given index. More...
template<vtkm::IdComponent Index, typename... Ts>
VTKM_SUPPRESS_EXEC_WARNINGS VTKM_EXEC_CONT auto	Get (vtkm::Tuple< Ts... > &tuple) -> decltype(tuple.template Get< Index >())
	Get the size of a tuple. More...

Detailed Description

Groups connected points that have the same field value.

Worklet for volume algorithms that require a neighborhood.

VTK-m Toolkit.

Incorporates values of the parent of the current subtree in the subtree for the min and max hypersweeps.

Median algorithm for general image blur.

The ImageConnectivity filter finds groups of points that have the same field value and are connected together through their topology. Any point is considered to be connected to its Moore neighborhood: 8 neighboring points for 2D and 27 neighboring points for 3D. As the name implies, ImageConnectivity only works on data with a structured cell set. You will get an error if you use any other type of cell set. The active field passed to the filter must be associated with the points. The result of the filter is a point field of type vtkm::Id. Each entry in the point field will be a number that identifies to which region it belongs. By default, this output point field is named “component”.

The ImageMedian filter finds the median value for each pixel in an image. Currently the algorithm has the following restrictions.

• Only supports a neighborhood of 5x5x1 or 3x3x1

This means that volumes are basically treated as an image stack along the z axis

Default output field name is 'median'

vtkm is the namespace for the VTK-m Toolkit. It contains other sub namespaces, as well as basic data types and functions callable from all components in VTK-m toolkit.

WorkletCellNeighborhood executes on every point inside a volume providing access to the 3D neighborhood values. The neighborhood is always cubic in nature and is fixed at compile time.

WorkletPointNeighborhood executes on every point inside a volume providing access to the 3D neighborhood values. The neighborhood is always cubic in nature and is fixed at compile time.

Typedef Documentation

AtomicTypePreferred

using vtkm::AtomicTypePreferred = typedef vtkm::UInt32

The preferred type to use for atomic operations.

AtomicTypesSupported

using vtkm::AtomicTypesSupported = typedef vtkm::List<vtkm::UInt32, vtkm::UInt64>

A list of types that can be used with atomic operations.

TODO: Adjust based on devices being compiled.

BUG: vtkm::UInt64 is provided in this list even though it is not supported on CUDA before compute capability 3.5.

BufferSizeType

using vtkm::BufferSizeType = typedef vtkm::Int64

Circle

template<typename T >

using vtkm::Circle = typedef Sphere<T, 2>

Circle is an alias for a 2-Dimensional sphere.

Circle2d

using vtkm::Circle2d = typedef Circle<vtkm::FloatDefault>

Float32

using vtkm::Float32 = typedef float

Float64

using vtkm::Float64 = typedef double

FloatDefault

using vtkm::FloatDefault = typedef vtkm::Float32

The floating point type to use when no other precision is specified.

HashType

using vtkm::HashType = typedef vtkm::UInt32

HasVecTraits

template<typename T >

using vtkm::HasVecTraits = typedef typename detail::HasVecTraitsImpl<T>::Type

Determines whether the given type has VecTraits defined.

If the given type T has a valid VecTraits class, then HasVecTraits<T> will be set to std::true_type. Otherwise it will be set to std::false_type. For example, HasVecTraits<vtkm::Id> is the same as std::true_type whereas HasVecTraits<void *> is the same as std::false_type. This is useful to block the definition of methods using VecTraits when VecTraits are not defined.

Id

using vtkm::Id = typedef vtkm::Int32

Represents an ID (index into arrays).

Id2

using vtkm::Id2 = typedef vtkm::Vec<vtkm::Id, 2>

Id2 corresponds to a 2-dimensional index.

Id3

using vtkm::Id3 = typedef vtkm::Vec<vtkm::Id, 3>

Id3 corresponds to a 3-dimensional index for 3d arrays.

Note that the precision of each index may be less than vtkm::Id.

Id4

using vtkm::Id4 = typedef vtkm::Vec<vtkm::Id, 4>

Id4 corresponds to a 4-dimensional index.

IdComponent

using vtkm::IdComponent = typedef vtkm::Int32

Represents a component ID (index of component in a vector).

The number of components, being a value fixed at compile time, is generally assumed to be quite small. However, we are currently using a 32-bit width integer because modern processors tend to access them more efficiently than smaller widths.

IdComponent2

using vtkm::IdComponent2 = typedef vtkm::Vec<vtkm::IdComponent, 2>

IdComponent2 corresponds to an index to a local (small) 2-d array or equivalent.

IdComponent3

using vtkm::IdComponent3 = typedef vtkm::Vec<vtkm::IdComponent, 3>

IdComponent2 corresponds to an index to a local (small) 3-d array or equivalent.

IdComponent4

using vtkm::IdComponent4 = typedef vtkm::Vec<vtkm::IdComponent, 4>

IdComponent4 corresponds to an index to a local (small) 4-d array or equivalent.

Int16

using vtkm::Int16 = typedef int16_t

Int32

using vtkm::Int32 = typedef int32_t

Int8

using vtkm::Int8 = typedef int8_t

Line

template<typename CoordType , int Dim = 3>

using vtkm::Line = typedef Ray<CoordType, Dim, true>

Lines are two-sided rays:

Line2

template<typename CoordType >

using vtkm::Line2 = typedef Line<CoordType, 2>

Line2d

using vtkm::Line2d = typedef Line2<vtkm::FloatDefault>

Line3

template<typename CoordType >

using vtkm::Line3 = typedef Line<CoordType, 3>

Line3d

using vtkm::Line3d = typedef Line3<vtkm::FloatDefault>

LineSegment2

template<typename CoordType >

using vtkm::LineSegment2 = typedef LineSegment<CoordType, 2>

LineSegment2d

using vtkm::LineSegment2d = typedef LineSegment2<vtkm::FloatDefault>

LineSegment3

template<typename CoordType >

using vtkm::LineSegment3 = typedef LineSegment<CoordType, 3>

LineSegment3d

using vtkm::LineSegment3d = typedef LineSegment3<vtkm::FloatDefault>

ListAll

template<typename List , template< typename > class Predicate = vtkm::internal::meta::Identity>

using vtkm::ListAll = typedef vtkm::ListReduce<vtkm::ListTransform<List, Predicate>, vtkm::internal::meta::And, std::true_type>

Determines whether all the types in the list are "true.".

ListAll expects a vtkm::List with types that have a value that is either true or false (such as std::true_type and std::false_type. Resolves to std::true_type if all the types are true, std::false_type otherwise. If the list is empty, resolves to std::true_type.

ListAll also accepts an optional second argument that is a template that is a predicate applied to each item in the input list before checking for the value type.

using NumberList1 = vtkm::List<int, char>;
using NumberList2 = vtkm::List<int, float>;
 
// Resolves to std::true_type
using AllInt1 = vtkm::ListAll<NumberList1, std::is_integral>;
 
// Resolves to std::false_type (because float is not integral)
using AllInt2 = vtkm::ListAll<NumberList2, std::is_integral>;

ListAny

template<typename List , template< typename > class Predicate = vtkm::internal::meta::Identity>

using vtkm::ListAny = typedef vtkm::ListReduce<vtkm::ListTransform<List, Predicate>, vtkm::internal::meta::Or, std::false_type>

Determines whether any of the types in the list are "true.".

ListAny expects a vtkm::List with types that have a value that is either true or false (such as std::true_type and std::false_type. Resolves to std::true_type if any of the types are true, std::false_type otherwise. If the list is empty, resolves to std::false_type.

ListAny also accepts an optional second argument that is a template that is a predicate applied to each item in the input list before checking for the value type.

using NumberList1 = vtkm::List<int, float>;
using NumberList2 = vtkm::List<float, double>;
 
// Resolves to std::true_type
using AnyInt1 = vtkm::ListAny<NumberList1, std::is_integral>;
 
// Resolves to std::false_type
using AnyInt2 = vtkm::ListAny<NumberList2, std::is_integral>;

ListAppend

template<typename... Lists>

using vtkm::ListAppend = typedef typename detail::ListAppendImpl<Lists...>::type

Concatinates a set of lists into a single list.

Note that this does not work correctly with vtkm::ListUniversal.

ListApply

template<typename List , template< typename... > class Target>

using vtkm::ListApply = typedef typename detail::ListApplyImpl<List, Target>::type

Applies the list of types to a template.

Given a ListTag and a templated class, returns the class instantiated with the types represented by the ListTag.

ListAt

template<typename List , vtkm::IdComponent Index>

using vtkm::ListAt = typedef typename detail::ListAtImpl<List, Index>::type

Finds the type at the given index.

This becomes the type of the list at the given index.

ListCross

template<typename List1 , typename List2 >

using vtkm::ListCross = typedef typename detail::ListCrossImpl<List1, List2>::type

Generates a list that is the cross product of two input lists.

The resulting list has the form of vtkm::List<vtkm::List<A1,B1>, vtkm::List<A1,B2>,...>

ListEmpty

using vtkm::ListEmpty = typedef vtkm::List<>

A special tag for an empty list.

ListFill

template<typename T , vtkm::IdComponent N>

using vtkm::ListFill = typedef typename detail::ListFillImpl<T, N>::type

Returns a list filled with N copies of type T.

ListHas

template<typename List , typename T >

using vtkm::ListHas = typedef typename detail::ListHasImpl<List, T>::type

Checks to see if the given T is in the list pointed to by List.

Becomes std::true_type if the T is in List. std::false_type otherwise.

ListIndexOf

template<typename List , typename T >

using vtkm::ListIndexOf = typedef typename detail::ListIndexOfImpl<List, T>::type

Finds the index of a given type.

Becomes a std::integral_constant for the index of the given type. If the given type is not in the list, the value is set to -1.

ListIntersect

template<typename List1 , typename List2 >

using vtkm::ListIntersect = typedef typename detail::ListIntersectImpl<List1, List2>::type

Constructs a list containing types present in all lists.

ListReduce

template<typename List , template< typename T1, typename T2 > class Operator, typename Initial >

using vtkm::ListReduce = typedef typename detail::ListReduceImpl<List, Operator, Initial>::type

Reduces a list to a single type using an operator.

ListReduce takes a vtkm::List, an operator template, and an initial type. ListReduce first applies the initial type and the first item in the list to the operator and gets that type. That then applies the operator to that result and the next item in the list. This continues until a single value is left.

ListRemoveIf

template<typename List , template< typename > class Predicate>

using vtkm::ListRemoveIf = typedef typename detail::ListRemoveIfImpl<List, Predicate>::type

Takes an existing List and a predicate template that is applied to each type in the List.

Any type in the List that has a value element equal to true (the equivalent of std::true_type), that item will be removed from the list. For example the following type

vtkm::ListRemoveIf<vtkm::List<int, float, long long, double>, std::is_integral>

resolves to a List that is equivalent to vtkm::List<float, double> because std::is_integral<int> and std::is_integral<long long> resolve to std::true_type whereas std::is_integral<float> and std::is_integral<double> resolve to std::false_type.

ListSize

template<typename List >

using vtkm::ListSize = typedef typename detail::ListSizeImpl<List>::type

Becomes an std::integral_constant containing the number of types in a list.

ListTransform

template<typename List , template< typename > class Transform>

using vtkm::ListTransform = typedef typename detail::ListTransformImpl<List, Transform>::type

Constructs a list containing all types in a source list applied to a transform template.

ListUniversal

using vtkm::ListUniversal = typedef vtkm::List<detail::UniversalTypeTag>

A special tag for a list that represents holding all potential values.

Note: Can not be used with ForEach and some list transforms for obvious reasons.

Plane3d

using vtkm::Plane3d = typedef Plane<vtkm::FloatDefault>

Ray2

template<typename CoordType >

using vtkm::Ray2 = typedef Ray<CoordType, 2>

Ray2d

using vtkm::Ray2d = typedef Ray2<vtkm::FloatDefault>

Ray3

template<typename CoordType >

using vtkm::Ray3 = typedef Ray<CoordType, 3>

Ray3d

using vtkm::Ray3d = typedef Ray3<vtkm::FloatDefault>

Sphere2

template<typename T >

using vtkm::Sphere2 = typedef Sphere<T, 2>

Sphere2d

using vtkm::Sphere2d = typedef Sphere2<vtkm::FloatDefault>

Sphere3

template<typename T >

using vtkm::Sphere3 = typedef Sphere<T, 3>

Sphere3d

using vtkm::Sphere3d = typedef Sphere3<vtkm::FloatDefault>

tuple_element_t

template<std::size_t Index, typename TupleType >

using vtkm::tuple_element_t = typedef typename tuple_element<Index, TupleType>::type

Compatible with std::tuple_element_t for vtkm::Tuple.

tuple_size

template<typename TupleType >

using vtkm::tuple_size = typedef std::integral_constant<std::size_t, static_cast<std::size_t>(TupleType::Size)>

Compatible with std::tuple_size for vtkm::Tuple.

TupleElement

template<vtkm::IdComponent Index, typename TupleType >

using vtkm::TupleElement = typedef typename detail::TupleElementImpl<Index, TupleType>::type

Becomes the type of the given index for the given vtkm::Tuple.

TupleSize

template<typename TupleType >

using vtkm::TupleSize = typedef std::integral_constant<vtkm::IdComponent, TupleType::Size>

Get the size of a tuple.

Given a vtkm::Tuple type, because a std::integral_constant of the type.

TypeListAll

using vtkm::TypeListAll = typedef vtkm::ListAppend<vtkm::TypeListScalarAll, vtkm::TypeListVecAll>

A list of all basic types listed in vtkm/Types.h.

Does not include all possible VTK-m types like arbitrarily typed and sized Vecs (only up to length 4) or math types like matrices.

TypeListBaseC

using vtkm::TypeListBaseC = typedef vtkm::ListAppend< vtkm::TypeListScalarAll, vtkm::List<bool, char, signed VTKM_UNUSED_INT_TYPE, unsigned VTKM_UNUSED_INT_TYPE> >

TypeListCommon

using vtkm::TypeListCommon = typedef vtkm::List<vtkm::UInt8, vtkm::Int32, vtkm::Int64, vtkm::Float32, vtkm::Float64, vtkm::Vec3f_32, vtkm::Vec3f_64>

A list of the most commonly used types across multiple domains.

Includes integers, floating points, and 3 dimensional vectors of floating points.

TypeListField

using vtkm::TypeListField = typedef vtkm::List<vtkm::Float32, vtkm::Float64, vtkm::Vec2f_32, vtkm::Vec2f_64, vtkm::Vec3f_32, vtkm::Vec3f_64, vtkm::Vec4f_32, vtkm::Vec4f_64>

A list containing common types for values in fields.

Specifically contains floating point scalars and vectors of size 2, 3, and 4 with floating point components.

TypeListFieldScalar

using vtkm::TypeListFieldScalar = typedef vtkm::List<vtkm::Float32, vtkm::Float64>

A list containing types used for scalar fields.

Specifically, contains floating point numbers of different widths (i.e. vtkm::Float32 and vtkm::Float64).

TypeListFieldVec2

using vtkm::TypeListFieldVec2 = typedef vtkm::List<vtkm::Vec2f_32, vtkm::Vec2f_64>

A list containing types for values for fields with two dimensional vectors.

TypeListFieldVec3

using vtkm::TypeListFieldVec3 = typedef vtkm::List<vtkm::Vec3f_32, vtkm::Vec3f_64>

A list containing types for values for fields with three dimensional vectors.

TypeListFieldVec4

using vtkm::TypeListFieldVec4 = typedef vtkm::List<vtkm::Vec4f_32, vtkm::Vec4f_64>

A list containing types for values for fields with four dimensional vectors.

TypeListFloatVec

using vtkm::TypeListFloatVec = typedef vtkm::List<vtkm::Vec2f_32, vtkm::Vec2f_64, vtkm::Vec3f_32, vtkm::Vec3f_64, vtkm::Vec4f_32, vtkm::Vec4f_64>

A list containing common types for floating-point vectors.

Specifically contains floating point vectors of size 2, 3, and 4 with floating point components. Scalars are not included.

TypeListId

using vtkm::TypeListId = typedef vtkm::List<vtkm::Id>

A list containing the type vtkm::Id.

TypeListId2

using vtkm::TypeListId2 = typedef vtkm::List<vtkm::Id2>

A list containing the type vtkm::Id2.

TypeListId3

using vtkm::TypeListId3 = typedef vtkm::List<vtkm::Id3>

A list containing the type vtkm::Id3.

TypeListId4

using vtkm::TypeListId4 = typedef vtkm::List<vtkm::Id4>

A list containing the type vtkm::Id4.

TypeListIdComponent

using vtkm::TypeListIdComponent = typedef vtkm::List<vtkm::IdComponent>

A list containing the type vtkm::IdComponent.

TypeListIndex

using vtkm::TypeListIndex = typedef vtkm::List<vtkm::Id, vtkm::Id2, vtkm::Id3>

A list containing types used to index arrays.

Contains vtkm::Id, vtkm::Id2, and vtkm::Id3.

TypeListScalarAll

using vtkm::TypeListScalarAll = typedef vtkm::List<vtkm::Int8, vtkm::UInt8, vtkm::Int16, vtkm::UInt16, vtkm::Int32, vtkm::UInt32, vtkm::Int64, vtkm::UInt64, vtkm::Float32, vtkm::Float64>

A list of all scalars defined in vtkm/Types.h.

A scalar is a type that holds a single number. This should containing all true variations of scalars, but there might be some arithmetic C types not included. For example, this list contains signed char, and unsigned char, but not char as one of those types will behave the same as it. Two of the three types behave the same, but be aware that template resolution will treat them differently.

TypeListVecAll

using vtkm::TypeListVecAll = typedef vtkm::ListAppend<vtkm::TypeListVecCommon, vtkm::internal::TypeListVecUncommon>

A list of all vector classes with standard types as components and lengths between 2 and 4.

TypeListVecCommon

using vtkm::TypeListVecCommon = typedef vtkm::List<vtkm::Vec2ui_8, vtkm::Vec2i_32, vtkm::Vec2i_64, vtkm::Vec2f_32, vtkm::Vec2f_64, vtkm::Vec3ui_8, vtkm::Vec3i_32, vtkm::Vec3i_64, vtkm::Vec3f_32, vtkm::Vec3f_64, vtkm::Vec4ui_8, vtkm::Vec4i_32, vtkm::Vec4i_64, vtkm::Vec4f_32, vtkm::Vec4f_64>

A list of the most commonly use Vec classes.

Specifically, these are vectors of size 2, 3, or 4 containing either unsigned bytes, signed integers of 32 or 64 bits, or floating point values of 32 or 64 bits.

UInt16

using vtkm::UInt16 = typedef uint16_t

UInt32

using vtkm::UInt32 = typedef uint32_t

UInt8

using vtkm::UInt8 = typedef uint8_t

Vec2f

using vtkm::Vec2f = typedef vtkm::Vec<vtkm::FloatDefault, 2>

Vec2f corresponds to a 2-dimensional vector of floating point values.

Each floating point value is of the default precision (i.e. vtkm::FloatDefault). It is typedef for vtkm::Vec<vtkm::FloatDefault, 2>.

Vec2f_32

using vtkm::Vec2f_32 = typedef vtkm::Vec<vtkm::Float32, 2>

Vec2f_32 corresponds to a 2-dimensional vector of 32-bit floating point values.

It is typedef for vtkm::Vec<vtkm::Float32, 2>.

Vec2f_64

using vtkm::Vec2f_64 = typedef vtkm::Vec<vtkm::Float64, 2>

Vec2f_64 corresponds to a 2-dimensional vector of 64-bit floating point values.

It is typedef for vtkm::Vec<vtkm::Float64, 2>.

Vec2i

using vtkm::Vec2i = typedef vtkm::Vec<vtkm::Id, 2>

Vec2i corresponds to a 2-dimensional vector of integer values.

Each integer value is of the default precision (i.e. vtkm::Id).

Vec2i_16

using vtkm::Vec2i_16 = typedef vtkm::Vec<vtkm::Int16, 2>

Vec2i_16 corresponds to a 2-dimensional vector of 16-bit integer values.

It is typedef for vtkm::Vec<vtkm::Int32, 2>.

Vec2i_32

using vtkm::Vec2i_32 = typedef vtkm::Vec<vtkm::Int32, 2>

Vec2i_32 corresponds to a 2-dimensional vector of 32-bit integer values.

It is typedef for vtkm::Vec<vtkm::Int32, 2>.

Vec2i_64

using vtkm::Vec2i_64 = typedef vtkm::Vec<vtkm::Int64, 2>

Vec2i_64 corresponds to a 2-dimensional vector of 64-bit integer values.

It is typedef for vtkm::Vec<vtkm::Int64, 2>.

Vec2i_8

using vtkm::Vec2i_8 = typedef vtkm::Vec<vtkm::Int8, 2>

Vec2i_8 corresponds to a 2-dimensional vector of 8-bit integer values.

It is typedef for vtkm::Vec<vtkm::Int32, 2>.

Vec2ui

using vtkm::Vec2ui = typedef vtkm::Vec<vtkm::UInt32, 2>

Vec2ui corresponds to a 2-dimensional vector of unsigned integer values.

Each integer value is of the default precision (following vtkm::Id).

Vec2ui_16

using vtkm::Vec2ui_16 = typedef vtkm::Vec<vtkm::UInt16, 2>

Vec2ui_16 corresponds to a 2-dimensional vector of 16-bit unsigned integer values.

It is typedef for vtkm::Vec<vtkm::UInt32, 2>.

Vec2ui_32

using vtkm::Vec2ui_32 = typedef vtkm::Vec<vtkm::UInt32, 2>

Vec2ui_32 corresponds to a 2-dimensional vector of 32-bit unsigned integer values.

It is typedef for vtkm::Vec<vtkm::UInt32, 2>.

Vec2ui_64

using vtkm::Vec2ui_64 = typedef vtkm::Vec<vtkm::UInt64, 2>

Vec2ui_64 corresponds to a 2-dimensional vector of 64-bit unsigned integer values.

It is typedef for vtkm::Vec<vtkm::UInt64, 2>.

Vec2ui_8

using vtkm::Vec2ui_8 = typedef vtkm::Vec<vtkm::UInt8, 2>

Vec2ui_8 corresponds to a 2-dimensional vector of 8-bit unsigned integer values.

It is typedef for vtkm::Vec<vtkm::UInt32, 2>.

Vec3f

using vtkm::Vec3f = typedef vtkm::Vec<vtkm::FloatDefault, 3>

Vec3f corresponds to a 3-dimensional vector of floating point values.

Each floating point value is of the default precision (i.e. vtkm::FloatDefault). It is typedef for vtkm::Vec<vtkm::FloatDefault, 3>.

Vec3f_32

using vtkm::Vec3f_32 = typedef vtkm::Vec<vtkm::Float32, 3>

Vec3f_32 corresponds to a 3-dimensional vector of 32-bit floating point values.

It is typedef for vtkm::Vec<vtkm::Float32, 3>.

Vec3f_64

using vtkm::Vec3f_64 = typedef vtkm::Vec<vtkm::Float64, 3>

Vec3f_64 corresponds to a 3-dimensional vector of 64-bit floating point values.

It is typedef for vtkm::Vec<vtkm::Float64, 3>.

Vec3i

using vtkm::Vec3i = typedef vtkm::Vec<vtkm::Id, 3>

Vec3i corresponds to a 3-dimensional vector of integer values.

Each integer value is of the default precision (i.e. vtkm::Id).

Vec3i_16

using vtkm::Vec3i_16 = typedef vtkm::Vec<vtkm::Int16, 3>

Vec3i_16 corresponds to a 3-dimensional vector of 16-bit integer values.

It is typedef for vtkm::Vec<vtkm::Int32, 3>.

Vec3i_32

using vtkm::Vec3i_32 = typedef vtkm::Vec<vtkm::Int32, 3>

Vec3i_32 corresponds to a 3-dimensional vector of 32-bit integer values.

It is typedef for vtkm::Vec<vtkm::Int32, 3>.

Vec3i_64

using vtkm::Vec3i_64 = typedef vtkm::Vec<vtkm::Int64, 3>

Vec3i_64 corresponds to a 3-dimensional vector of 64-bit integer values.

It is typedef for vtkm::Vec<vtkm::Int64, 3>.

Vec3i_8

using vtkm::Vec3i_8 = typedef vtkm::Vec<vtkm::Int8, 3>

Vec3i_8 corresponds to a 3-dimensional vector of 8-bit integer values.

It is typedef for vtkm::Vec<vtkm::Int32, 3>.

Vec3ui

using vtkm::Vec3ui = typedef vtkm::Vec<vtkm::UInt32, 3>

Vec3ui corresponds to a 3-dimensional vector of unsigned integer values.

Each integer value is of the default precision (following vtkm::Id).

Vec3ui_16

using vtkm::Vec3ui_16 = typedef vtkm::Vec<vtkm::UInt16, 3>

Vec3ui_16 corresponds to a 3-dimensional vector of 16-bit unsigned integer values.

It is typedef for vtkm::Vec<vtkm::UInt32, 3>.

Vec3ui_32

using vtkm::Vec3ui_32 = typedef vtkm::Vec<vtkm::UInt32, 3>

Vec3ui_32 corresponds to a 3-dimensional vector of 32-bit unsigned integer values.

It is typedef for vtkm::Vec<vtkm::UInt32, 3>.

Vec3ui_64

using vtkm::Vec3ui_64 = typedef vtkm::Vec<vtkm::UInt64, 3>

Vec3ui_64 corresponds to a 3-dimensional vector of 64-bit unsigned integer values.

It is typedef for vtkm::Vec<vtkm::UInt64, 3>.

Vec3ui_8

using vtkm::Vec3ui_8 = typedef vtkm::Vec<vtkm::UInt8, 3>

Vec3ui_8 corresponds to a 3-dimensional vector of 8-bit unsigned integer values.

It is typedef for vtkm::Vec<vtkm::UInt32, 3>.

Vec4f

using vtkm::Vec4f = typedef vtkm::Vec<vtkm::FloatDefault, 4>

Vec4f corresponds to a 4-dimensional vector of floating point values.

Each floating point value is of the default precision (i.e. vtkm::FloatDefault). It is typedef for vtkm::Vec<vtkm::FloatDefault, 4>.

Vec4f_32

using vtkm::Vec4f_32 = typedef vtkm::Vec<vtkm::Float32, 4>

Vec4f_32 corresponds to a 4-dimensional vector of 32-bit floating point values.

It is typedef for vtkm::Vec<vtkm::Float32, 4>.

Vec4f_64

using vtkm::Vec4f_64 = typedef vtkm::Vec<vtkm::Float64, 4>

Vec4f_64 corresponds to a 4-dimensional vector of 64-bit floating point values.

It is typedef for vtkm::Vec<vtkm::Float64, 4>.

Vec4i

using vtkm::Vec4i = typedef vtkm::Vec<vtkm::Id, 4>

Vec4i corresponds to a 4-dimensional vector of integer values.

Each integer value is of the default precision (i.e. vtkm::Id).

Vec4i_16

using vtkm::Vec4i_16 = typedef vtkm::Vec<vtkm::Int16, 4>

Vec4i_16 corresponds to a 4-dimensional vector of 16-bit integer values.

It is typedef for vtkm::Vec<vtkm::Int32, 4>.

Vec4i_32

using vtkm::Vec4i_32 = typedef vtkm::Vec<vtkm::Int32, 4>

Vec4i_32 corresponds to a 4-dimensional vector of 32-bit integer values.

It is typedef for vtkm::Vec<vtkm::Int32, 4>.

Vec4i_64

using vtkm::Vec4i_64 = typedef vtkm::Vec<vtkm::Int64, 4>

Vec4i_64 corresponds to a 4-dimensional vector of 64-bit integer values.

It is typedef for vtkm::Vec<vtkm::Int64, 4>.

Vec4i_8

using vtkm::Vec4i_8 = typedef vtkm::Vec<vtkm::Int8, 4>

Vec4i_8 corresponds to a 4-dimensional vector of 8-bit integer values.

It is typedef for vtkm::Vec<vtkm::Int32, 4>.

Vec4ui

using vtkm::Vec4ui = typedef vtkm::Vec<vtkm::UInt32, 4>

Vec4ui corresponds to a 4-dimensional vector of unsigned integer values.

Each integer value is of the default precision (following vtkm::Id).

Vec4ui_16

using vtkm::Vec4ui_16 = typedef vtkm::Vec<vtkm::UInt16, 4>

Vec4ui_16 corresponds to a 4-dimensional vector of 16-bit unsigned integer values.

It is typedef for vtkm::Vec<vtkm::UInt32, 4>.

Vec4ui_32

using vtkm::Vec4ui_32 = typedef vtkm::Vec<vtkm::UInt32, 4>

Vec4ui_32 corresponds to a 4-dimensional vector of 32-bit unsigned integer values.

It is typedef for vtkm::Vec<vtkm::UInt32, 4>.

Vec4ui_64

using vtkm::Vec4ui_64 = typedef vtkm::Vec<vtkm::UInt64, 4>

Vec4ui_64 corresponds to a 4-dimensional vector of 64-bit unsigned integer values.

It is typedef for vtkm::Vec<vtkm::UInt64, 4>.

Vec4ui_8

using vtkm::Vec4ui_8 = typedef vtkm::Vec<vtkm::UInt8, 4>

Vec4ui_8 corresponds to a 4-dimensional vector of 8-bit unsigned integer values.

It is typedef for vtkm::Vec<vtkm::UInt32, 4>.

WordTypeDefault

using vtkm::WordTypeDefault = typedef vtkm::UInt32

The default word size used for atomic bitwise operations.

Universally supported on all devices.

Enumeration Type Documentation

CellShapeIdEnum

enum vtkm::CellShapeIdEnum

CellShapeId identifies the type of each cell.

Currently these are designed to match up with VTK cell types.

Enumerator
CELL_SHAPE_EMPTY
CELL_SHAPE_VERTEX
CELL_SHAPE_LINE
CELL_SHAPE_POLY_LINE
CELL_SHAPE_TRIANGLE
CELL_SHAPE_POLYGON
CELL_SHAPE_QUAD
CELL_SHAPE_TETRA
CELL_SHAPE_HEXAHEDRON
CELL_SHAPE_WEDGE
CELL_SHAPE_PYRAMID
NUMBER_OF_CELL_SHAPES

ColorSpace

enum vtkm::ColorSpace

strong

Enumerator
RGB
HSV
HSVWrap
Lab
Diverging

CopyFlag

enum vtkm::CopyFlag

strong

Enumerator
Off
On

ErrorCode

enum vtkm::ErrorCode

strong

Enumerator
Success
InvalidShapeId
InvalidNumberOfPoints
InvalidCellMetric
WrongShapeIdForTagType
InvalidPointId
InvalidEdgeId
InvalidFaceId
SolutionDidNotConverge
MatrixFactorizationFailed
DegenerateCellDetected
MalformedCellDetected
OperationOnEmptyCell
CellNotFound
UnknownError

MemoryOrder

enum vtkm::MemoryOrder

strong

Specifies memory order semantics for atomic operations.

The memory order parameter controls how all other memory operations are ordered around a specific atomic instruction.

Memory access is complicated. Compilers can reorder instructions to optimize scheduling, processors can speculatively read memory, and caches make assumptions about coherency that we may not normally be aware of. Because of this complexity, the order in which multiple updates to shared memory become visible to other threads is not guaranteed, nor is it guaranteed that each thread will see memory updates occur in the same order as any other thread. This can lead to surprising behavior and cause problems when using atomics to communicate between threads.

These problems are solved by using a standard set of memory orderings which describe common access patterns used for shared memory programming. Their goal is to provide guarantees that changes made in one thread will be visible to another thread at a specific and predictable point in execution, regardless of any hardware or compiler optimizations.

If unsure, use SequentiallyConsistent memory orderings. It will "do the right thing", but at the cost of increased and possibly unnecessary memory ordering restrictions. The other orderings are optimizations that are only applicable in very specific situations.

See https://en.cppreference.com/w/cpp/atomic/memory_order for a detailed description of the different orderings and their usage.

The memory order semantics follow those of other common atomic operations such as the std::memory_order identifiers used for std::atomic.

Note that when a memory order is specified, the enforced memory order is guaranteed to be as good or better than that requested.

Enumerator
Relaxed	An atomic operations with Relaxed memory order enforces no synchronization or ordering constraints on local reads and writes. That is, a read or write to a local, non-atomic variable may be moved to before or after an atomic operation with Relaxed memory order.
Acquire	A load operation with Acquire memory order will enforce that any local read or write operations listed in the program after the atomic will happen after the atomic.
Release	A store operation with Release memory order will enforce that any local read or write operations listed in the program before the atomic will happen before the atomic.
AcquireAndRelease	A read-modify-write operation with AcquireAndRelease memory order will enforce that any local read or write operations listed in the program before the atomic will happen before the atomic and likewise any read or write operations listed in the program after the atomic will happen after the atomic.
SequentiallyConsistent	An atomic with SequentiallyConsistent memory order will enforce any appropriate semantics as Acquire, Release, and AcquireAndRelease. Additionally, SequentiallyConsistent will enforce a consistent ordering of atomic operations across all threads. That is, all threads observe the modifications in the same order.

Function Documentation

ACos() [1/2]

VTKM_EXEC_CONT vtkm::Float32 vtkm::ACos ( vtkm::Float32  x )

inline

Compute the arc cosine of x.

ACos() [2/2]

VTKM_EXEC_CONT vtkm::Float64 vtkm::ACos ( vtkm::Float64  x )

inline

ACosH() [1/2]

VTKM_EXEC_CONT vtkm::Float32 vtkm::ACosH ( vtkm::Float32  x )

inline

Compute the hyperbolic arc cosine of x.

ACosH() [2/2]

VTKM_EXEC_CONT vtkm::Float64 vtkm::ACosH ( vtkm::Float64  x )

inline

ASin() [1/2]

VTKM_EXEC_CONT vtkm::Float32 vtkm::ASin ( vtkm::Float32  x )

inline

Compute the arc sine of x.

ASin() [2/2]

VTKM_EXEC_CONT vtkm::Float64 vtkm::ASin ( vtkm::Float64  x )

inline

ASinH() [1/2]

VTKM_EXEC_CONT vtkm::Float32 vtkm::ASinH ( vtkm::Float32  x )

inline

Compute the hyperbolic arc sine of x.

ASinH() [2/2]

VTKM_EXEC_CONT vtkm::Float64 vtkm::ASinH ( vtkm::Float64  x )

inline

ATan() [1/2]

VTKM_EXEC_CONT vtkm::Float32 vtkm::ATan ( vtkm::Float32  x )

inline

Compute the arc tangent of x.

ATan() [2/2]

VTKM_EXEC_CONT vtkm::Float64 vtkm::ATan ( vtkm::Float64  x )

inline

ATanH() [1/2]

VTKM_EXEC_CONT vtkm::Float32 vtkm::ATanH ( vtkm::Float32  x )

inline

Compute the hyperbolic arc tangent of x.

ATanH() [2/2]

VTKM_EXEC_CONT vtkm::Float64 vtkm::ATanH ( vtkm::Float64  x )

inline

AtomicAdd() [1/2]

template<typename T , typename std::enable_if< std::is_integral< T >::value >::type * = nullptr>

VTKM_EXEC_CONT T vtkm::AtomicAdd ( T *  pointer, detail::OppositeSign< T >  operand, vtkm::MemoryOrder  order = vtkm::MemoryOrder::SequentiallyConsistent  )

inline

Atomic function to add a value to a shared memory location.

Given a pointer and an operand, adds the operand to the value at the given memory location. The result of the addition is put into that memory location and the old value that was originally in the memory is returned. For example, if you call AtomicAdd on a memory location that holds a 5 with an operand of 3, the value of 8 is stored in the memory location and the value of 5 is returned.

If multiple threads call AtomicAdd simultaneously, they will not interfere with each other. The result will be consistent as if one was called before the other (although it is indeterminate which will be applied first).

AtomicAdd() [2/2]

template<typename T >

VTKM_EXEC_CONT T vtkm::AtomicAdd ( T *  pointer, T  operand, vtkm::MemoryOrder  order = vtkm::MemoryOrder::SequentiallyConsistent  )

inline

Atomic function to add a value to a shared memory location.

Given a pointer and an operand, adds the operand to the value at the given memory location. The result of the addition is put into that memory location and the old value that was originally in the memory is returned. For example, if you call AtomicAdd on a memory location that holds a 5 with an operand of 3, the value of 8 is stored in the memory location and the value of 5 is returned.

If multiple threads call AtomicAdd simultaneously, they will not interfere with each other. The result will be consistent as if one was called before the other (although it is indeterminate which will be applied first).

AtomicAnd() [1/2]

template<typename T >

VTKM_EXEC_CONT T vtkm::AtomicAnd ( T *  pointer, detail::OppositeSign< T >  operand, vtkm::MemoryOrder  order = vtkm::MemoryOrder::SequentiallyConsistent  )

inline

Atomic function to AND bits to a shared memory location.

Given a pointer and an operand, performs a bitwise AND of the operand and thevalue at the given memory location. The result of the AND is put into that memory location and the old value that was originally in the memory is returned. For example, if you call AtomicAnd on a memory location that holds a 0x6 with an operand of 0x3, the value of 0x2 is stored in the memory location and the value of 0x6 is returned.

If multiple threads call AtomicAnd simultaneously, they will not interfere with each other. The result will be consistent as if one was called before the other (although it is indeterminate which will be applied first).

AtomicAnd() [2/2]

template<typename T >

VTKM_EXEC_CONT T vtkm::AtomicAnd ( T *  pointer, T  operand, vtkm::MemoryOrder  order = vtkm::MemoryOrder::SequentiallyConsistent  )

inline

Atomic function to AND bits to a shared memory location.

Given a pointer and an operand, performs a bitwise AND of the operand and thevalue at the given memory location. The result of the AND is put into that memory location and the old value that was originally in the memory is returned. For example, if you call AtomicAnd on a memory location that holds a 0x6 with an operand of 0x3, the value of 0x2 is stored in the memory location and the value of 0x6 is returned.

If multiple threads call AtomicAnd simultaneously, they will not interfere with each other. The result will be consistent as if one was called before the other (although it is indeterminate which will be applied first).

AtomicCompareExchange()

template<typename T >

VTKM_EXEC_CONT bool vtkm::AtomicCompareExchange ( T *  shared, T *  expected, T  desired, vtkm::MemoryOrder  order = vtkm::MemoryOrder::SequentiallyConsistent  )

inline

Atomic function that replaces a value given a condition.

Given a pointer to a shared value, a pointer holding the expected value at that shared location, and a new desired value, AtomicCompareExchange compares the existing shared value to the expected value, and then conditionally replaces the shared value with the provided desired value. Otherwise, the expected value gets replaced with the shared value. Note that in either case, the function returns with expected replaced with the value originally in shared at the start of the call.

If the shared value and expected value are the same, then shared gets set to desired, and AtomicCompareAndExchange returns true.

If the shared value and expected value are different, then expected gets set to shared, and AtomicCompareAndExchange returns false. The value at shared is not changed in this case.

If multiple threads call AtomicCompareExchange simultaneously with the same shared pointer, the result will be consistent as if one was called before the other (although it is indeterminate which will be applied first). Note that the expected pointer should not be shared among threads. The expected pointer should be thread-local (often pointing to an object on the stack).

AtomicLoad()

template<typename T >

VTKM_EXEC_CONT T vtkm::AtomicLoad ( T *const  pointer, vtkm::MemoryOrder  order = vtkm::MemoryOrder::Acquire  )

inline

Atomic function to load a value from a shared memory location.

Given a pointer, returns the value in that pointer. If other threads are writing to that same location, the returned value will be consistent to what was present before or after that write.

AtomicNot()

template<typename T >

VTKM_EXEC_CONT T vtkm::AtomicNot ( T *  pointer, vtkm::MemoryOrder  order = vtkm::MemoryOrder::SequentiallyConsistent  )

inline

Atomic function to NOT bits to a shared memory location.

Given a pointer, performs a bitwise NOT of the value at the given memory location. The result of the NOT is put into that memory location and the old value that was originally in the memory is returned.

If multiple threads call AtomicNot simultaneously, they will not interfere with each other. The result will be consistent as if one was called before the other.

AtomicOr() [1/2]

template<typename T >

VTKM_EXEC_CONT T vtkm::AtomicOr ( T *  pointer, detail::OppositeSign< T >  operand, vtkm::MemoryOrder  order = vtkm::MemoryOrder::SequentiallyConsistent  )

inline

Atomic function to OR bits to a shared memory location.

Given a pointer and an operand, performs a bitwise OR of the operand and the value at the given memory location. The result of the OR is put into that memory location and the old value that was originally in the memory is returned. For example, if you call AtomicOr on a memory location that holds a 0x6 with an operand of 0x3, the value of 0x7 is stored in the memory location and the value of 0x6 is returned.

If multiple threads call AtomicOr simultaneously, they will not interfere with each other. The result will be consistent as if one was called before the other (although it is indeterminate which will be applied first).

AtomicOr() [2/2]

template<typename T >

VTKM_EXEC_CONT T vtkm::AtomicOr ( T *  pointer, T  operand, vtkm::MemoryOrder  order = vtkm::MemoryOrder::SequentiallyConsistent  )

inline

Atomic function to OR bits to a shared memory location.

Given a pointer and an operand, performs a bitwise OR of the operand and the value at the given memory location. The result of the OR is put into that memory location and the old value that was originally in the memory is returned. For example, if you call AtomicOr on a memory location that holds a 0x6 with an operand of 0x3, the value of 0x7 is stored in the memory location and the value of 0x6 is returned.

If multiple threads call AtomicOr simultaneously, they will not interfere with each other. The result will be consistent as if one was called before the other (although it is indeterminate which will be applied first).

AtomicStore() [1/2]

template<typename T >

VTKM_EXEC_CONT void vtkm::AtomicStore ( T *  pointer, detail::OppositeSign< T >  value, vtkm::MemoryOrder  order = vtkm::MemoryOrder::Release  )

inline

Atomic function to save a value to a shared memory location.

Given a pointer and a value, stores that value at the pointer's location. If two threads are simultaneously using AtomicStore at the same location, the resulting value will be one of the values or the other (as opposed to a mix of bits).

AtomicStore() [2/2]

template<typename T >

VTKM_EXEC_CONT void vtkm::AtomicStore ( T *  pointer, T  value, vtkm::MemoryOrder  order = vtkm::MemoryOrder::Release  )

inline

Atomic function to save a value to a shared memory location.

Given a pointer and a value, stores that value at the pointer's location. If two threads are simultaneously using AtomicStore at the same location, the resulting value will be one of the values or the other (as opposed to a mix of bits).

AtomicXor() [1/2]

template<typename T >

VTKM_EXEC_CONT T vtkm::AtomicXor ( T *  pointer, detail::OppositeSign< T >  operand, vtkm::MemoryOrder  order = vtkm::MemoryOrder::SequentiallyConsistent  )

inline

Atomic function to XOR bits to a shared memory location.

Given a pointer and an operand, performs a bitwise exclusive-OR of the operand and the value at the given memory location. The result of the XOR is put into that memory location and the old value that was originally in the memory is returned. For example, if you call AtomicXor on a memory location that holds a 0x6 with an operand of 0x3, the value of 0x5 is stored in the memory location and the value of 0x6 is returned.

If multiple threads call AtomicXor simultaneously, they will not interfere with each other. The result will be consistent as if one was called before the other.

AtomicXor() [2/2]

template<typename T >

VTKM_EXEC_CONT T vtkm::AtomicXor ( T *  pointer, T  operand, vtkm::MemoryOrder  order = vtkm::MemoryOrder::SequentiallyConsistent  )

inline

Atomic function to XOR bits to a shared memory location.

Given a pointer and an operand, performs a bitwise exclusive-OR of the operand and the value at the given memory location. The result of the XOR is put into that memory location and the old value that was originally in the memory is returned. For example, if you call AtomicXor on a memory location that holds a 0x6 with an operand of 0x3, the value of 0x5 is stored in the memory location and the value of 0x6 is returned.

If multiple threads call AtomicXor simultaneously, they will not interfere with each other. The result will be consistent as if one was called before the other.

Cbrt() [1/2]

VTKM_EXEC_CONT vtkm::Float32 vtkm::Cbrt ( vtkm::Float32  x )

inline

Compute the cube root of x.

Cbrt() [2/2]

VTKM_EXEC_CONT vtkm::Float64 vtkm::Cbrt ( vtkm::Float64  x )

inline

Ceil() [1/2]

VTKM_EXEC_CONT vtkm::Float32 vtkm::Ceil ( vtkm::Float32  x )

inline

Round x to the smallest integer value not less than x.

Ceil() [2/2]

VTKM_EXEC_CONT vtkm::Float64 vtkm::Ceil ( vtkm::Float64  x )

inline

Clamp() [1/2]

VTKM_EXEC_CONT vtkm::Float32 vtkm::Clamp ( vtkm::Float32  x, vtkm::Float32  lo, vtkm::Float32  hi  )

inline

Clamp x to the given range.

Clamp() [2/2]

VTKM_EXEC_CONT vtkm::Float64 vtkm::Clamp ( vtkm::Float64  x, vtkm::Float64  lo, vtkm::Float64  hi  )

inline

Cos() [1/2]

VTKM_EXEC_CONT vtkm::Float32 vtkm::Cos ( vtkm::Float32  x )

inline

Compute the cosine of x.

Cos() [2/2]

VTKM_EXEC_CONT vtkm::Float64 vtkm::Cos ( vtkm::Float64  x )

inline

CosH() [1/2]

VTKM_EXEC_CONT vtkm::Float32 vtkm::CosH ( vtkm::Float32  x )

inline

Compute the hyperbolic cosine of x.

CosH() [2/2]

VTKM_EXEC_CONT vtkm::Float64 vtkm::CosH ( vtkm::Float64  x )

inline

CountSetBits() [1/2]

VTKM_EXEC_CONT vtkm::Int32 vtkm::CountSetBits ( vtkm::UInt32  word )

inline

Count the total number of bits set in word.

CountSetBits() [2/2]

VTKM_EXEC_CONT vtkm::Int32 vtkm::CountSetBits ( vtkm::UInt64  word )

inline

Count the total number of bits set in word.

Cross()

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<typename detail::FloatingPointReturnType<T>::Type, 3> vtkm::Cross	(	const vtkm::Vec< T, 3 > &	x,
		const vtkm::Vec< T, 3 > &	y
	)

Find the cross product of two vectors.

DifferenceOfProducts()

template<typename T >

VTKM_EXEC_CONT T vtkm::DifferenceOfProducts ( T  a, T  b, T  c, T  d  )

inline

ErrorString()

const VTKM_EXEC_CONT char* vtkm::ErrorString ( vtkm::ErrorCode  code )

inlinenoexcept

Exp() [1/2]

VTKM_EXEC_CONT vtkm::Float32 vtkm::Exp ( vtkm::Float32  x )

inline

Computes e**x, the base-e exponential of x.

Exp() [2/2]

VTKM_EXEC_CONT vtkm::Float64 vtkm::Exp ( vtkm::Float64  x )

inline

Exp2() [1/2]

VTKM_EXEC_CONT vtkm::Float32 vtkm::Exp2 ( vtkm::Float32  x )

inline

Computes 2**x, the base-2 exponential of x.

Exp2() [2/2]

VTKM_EXEC_CONT vtkm::Float64 vtkm::Exp2 ( vtkm::Float64  x )

inline

ExpM1() [1/2]

VTKM_EXEC_CONT vtkm::Float32 vtkm::ExpM1 ( vtkm::Float32  x )

inline

Computes (e**x) - 1, the of base-e exponental of x then minus 1.

The accuracy of this function is good even for very small values of x.

ExpM1() [2/2]

VTKM_EXEC_CONT vtkm::Float64 vtkm::ExpM1 ( vtkm::Float64  x )

inline

FindFirstSetBit() [1/2]

VTKM_EXEC_CONT vtkm::Int32 vtkm::FindFirstSetBit ( vtkm::UInt32  word )

inline

Bitwise operations.

Find the first set bit in word, and return its position (1-32). If no bits are set, returns 0.

FindFirstSetBit() [2/2]

VTKM_EXEC_CONT vtkm::Int32 vtkm::FindFirstSetBit ( vtkm::UInt64  word )

inline

Find the first set bit in word, and return its position (1-64).

If no bits are set, returns 0.

FloatDistance() [1/2]

VTKM_EXEC_CONT vtkm::UInt64 vtkm::FloatDistance ( vtkm::Float32  x, vtkm::Float32  y  )

inline

FloatDistance() [2/2]

VTKM_EXEC_CONT vtkm::UInt64 vtkm::FloatDistance ( vtkm::Float64  x, vtkm::Float64  y  )

inline

Floor() [1/2]

VTKM_EXEC_CONT vtkm::Float32 vtkm::Floor ( vtkm::Float32  x )

inline

Round x to the largest integer value not greater than x.

Floor() [2/2]

VTKM_EXEC_CONT vtkm::Float64 vtkm::Floor ( vtkm::Float64  x )

inline

Frexp() [1/2]

VTKM_EXEC_CONT vtkm::Float32 vtkm::Frexp ( vtkm::Float32  x, vtkm::Int32 *  exponent  )

inline

Decompose floating poing value.

Frexp() [2/2]

VTKM_EXEC_CONT vtkm::Float64 vtkm::Frexp ( vtkm::Float64  x, vtkm::Int32 *  exponent  )

inline

Get() [1/2]

template<vtkm::IdComponent Index, typename... Ts>

VTKM_SUPPRESS_EXEC_WARNINGS VTKM_EXEC_CONT auto vtkm::Get

(

const vtkm::Tuple< Ts... > &

tuple

)

-> decltype(tuple.template Get<Index>())

Retrieve the object from a vtkm::Tuple at the given index.

get() [1/2]

template<std::size_t Index, typename... Ts>

VTKM_SUPPRESS_EXEC_WARNINGS VTKM_EXEC_CONT auto vtkm::get

(

const vtkm::Tuple< Ts... > &

tuple

)

-> decltype(vtkm::Get<static_cast<vtkm::IdComponent>(Index)>(tuple))

Compatible with std::get for vtkm::Tuple.

Get() [2/2]

template<vtkm::IdComponent Index, typename... Ts>

VTKM_SUPPRESS_EXEC_WARNINGS VTKM_EXEC_CONT auto vtkm::Get

(

vtkm::Tuple< Ts... > &

tuple

)

-> decltype(tuple.template Get<Index>())

Get the size of a tuple.

Given a vtkm::Tuple type, because a std::integral_constant of the type.

get() [2/2]

template<std::size_t Index, typename... Ts>

VTKM_SUPPRESS_EXEC_WARNINGS VTKM_EXEC_CONT auto vtkm::get

(

vtkm::Tuple< Ts... > &

tuple

)

-> decltype(vtkm::Get<static_cast<vtkm::IdComponent>(Index)>(tuple))

Compatible with std::get for vtkm::Tuple.

Hash()

template<typename InVecType >

VTKM_EXEC_CONT vtkm::HashType vtkm::Hash ( const InVecType &  inVec )

inline

Returns a 32-bit hash on a group of integer-type values.

The input to the hash is expected to be a vtkm::Vec or a Vec-like object. The values can be either 32-bit integers or 64-bit integers (signed or unsigned). Regardless, the resulting hash is an unsigned 32-bit integer.

The hash is designed to minimize the probability of collisions, but collisions are always possible. Thus, when using these hashes there should be a contingency for dealing with collisions.

Ldexp() [1/2]

VTKM_EXEC_CONT vtkm::Float32 vtkm::Ldexp ( vtkm::Float32  x, vtkm::Int32  exponent  )

inline

Ldexp() [2/2]

VTKM_EXEC_CONT vtkm::Float64 vtkm::Ldexp ( vtkm::Float64  x, vtkm::Int32  exponent  )

inline

Lerp() [1/3]

template<typename ValueType , typename WeightType >

VTKM_EXEC_CONT ValueType vtkm::Lerp ( const ValueType &  value0, const ValueType &  value1, const WeightType &  weight  )

inline

Returns the linear interpolation of two values based on weight.

Lerp interpolates return the linerar interpolation of v0 and v1 based on w. v0 and v1 are scalars or vectors of same length. w can either be a scalar or a vector of the same length as x and y. If w is outside [0,1] then lerp extrapolates. If w=0 => v0 is returned if w=1 => v1 is returned.

Lerp() [2/3]

template<typename ValueType , vtkm::IdComponent N>

VTKM_EXEC_CONT vtkm::Vec<ValueType, N> vtkm::Lerp	(	const vtkm::Vec< ValueType, N > &	value0,
		const vtkm::Vec< ValueType, N > &	value1,
		const vtkm::Vec< ValueType, N > &	weight
	)

Lerp() [3/3]

template<typename ValueType , vtkm::IdComponent N, typename WeightType >

VTKM_EXEC_CONT vtkm::Vec<ValueType, N> vtkm::Lerp	(	const vtkm::Vec< ValueType, N > &	value0,
		const vtkm::Vec< ValueType, N > &	value1,
		const WeightType &	weight
	)

ListForEach() [1/2]

template<typename Functor , typename... Args>

VTKM_EXEC_CONT void vtkm::ListForEach	(	Functor &&	,
		vtkm::ListEmpty	,
		Args &&	...
	)

For each typename represented by the list, call the functor with a default instance of that type.

ListForEach() [2/2]

template<typename Functor , typename... Ts, typename... Args>

VTKM_SUPPRESS_EXEC_WARNINGS VTKM_EXEC_CONT void vtkm::ListForEach	(	Functor &&	f,
		vtkm::List< Ts... >	,
		Args &&...	args
	)

For each typename represented by the list, call the functor with a default instance of that type.

Log() [1/2]

VTKM_EXEC_CONT vtkm::Float32 vtkm::Log ( vtkm::Float32  x )

inline

Computes the natural logarithm of x.

Log() [2/2]

VTKM_EXEC_CONT vtkm::Float64 vtkm::Log ( vtkm::Float64  x )

inline

Log10() [1/2]

VTKM_EXEC_CONT vtkm::Float32 vtkm::Log10 ( vtkm::Float32  x )

inline

Computes the logarithm base 10 of x.

Log10() [2/2]

VTKM_EXEC_CONT vtkm::Float64 vtkm::Log10 ( vtkm::Float64  x )

inline

Log1P() [1/2]

VTKM_EXEC_CONT vtkm::Float32 vtkm::Log1P ( vtkm::Float32  x )

inline

Computes the value of log(1+x) accurately for very small values of x.

Log1P() [2/2]

VTKM_EXEC_CONT vtkm::Float64 vtkm::Log1P ( vtkm::Float64  x )

inline

Log2() [1/2]

VTKM_EXEC_CONT vtkm::Float32 vtkm::Log2 ( vtkm::Float32  x )

inline

Computes the logarithm base 2 of x.

Log2() [2/2]

VTKM_EXEC_CONT vtkm::Float64 vtkm::Log2 ( vtkm::Float64  x )

inline

LowerBound() [1/4]

template<typename PortalT , typename T >

VTKM_EXEC_CONT vtkm::Id vtkm::LowerBound	(	const PortalT &	portal,
		const T &	val
	)

Implementation of std::lower_bound that is appropriate for both control and execution environments.

The overloads that take portals return indices instead of iterators.

LowerBound() [2/4]

template<typename PortalT , typename T , typename Comp >

VTKM_EXEC_CONT vtkm::Id vtkm::LowerBound	(	const PortalT &	portal,
		const T &	val,
		Comp	comp
	)

Implementation of std::lower_bound that is appropriate for both control and execution environments.

The overloads that take portals return indices instead of iterators.

LowerBound() [3/4]

template<typename IterT , typename T >

VTKM_EXEC_CONT IterT vtkm::LowerBound	(	IterT	first,
		IterT	last,
		const T &	val
	)

Implementation of std::lower_bound that is appropriate for both control and execution environments.

The overloads that take portals return indices instead of iterators.

LowerBound() [4/4]

template<typename IterT , typename T , typename Comp >

VTKM_EXEC_CONT IterT vtkm::LowerBound	(	IterT	first,
		IterT	last,
		const T &	val,
		Comp	comp
	)

Implementation of std::lower_bound that is appropriate for both control and execution environments.

The overloads that take portals return indices instead of iterators.

Magnitude()

template<typename T >

VTKM_EXEC_CONT detail::FloatingPointReturnType<T>::Type vtkm::Magnitude

(

const T &

x

)

Returns the magnitude of a vector.

It is usually much faster to compute MagnitudeSquared, so that should be substituted when possible (unless you are just going to take the square root, which would be besides the point). On some hardware it is also faster to find the reciprocal magnitude, so RMagnitude should be used if you actually plan to divide by the magnitude.

MagnitudeSquared()

template<typename T >

VTKM_EXEC_CONT detail::FloatingPointReturnType<T>::Type vtkm::MagnitudeSquared

(

const T &

x

)

Returns the square of the magnitude of a vector.

It is usually much faster to compute the square of the magnitude than the square, so you should use this function in place of Magnitude or RMagnitude when possible.

make_CircleFrom3Points()

template<typename CoordType >

VTKM_EXEC_CONT vtkm::Circle<CoordType> vtkm::make_CircleFrom3Points	(	const typename vtkm::Vec< CoordType, 2 > &	p0,
		const typename vtkm::Vec< CoordType, 2 > &	p1,
		const typename vtkm::Vec< CoordType, 2 > &	p2,
		CoordType	tol = static_cast< CoordType >(1e-6f)
	)

Construct a circle from 3 points.

make_Pair()

template<typename T1 , typename T2 >

VTKM_EXEC_CONT vtkm::Pair<typename std::decay<T1>::type, typename std::decay<T2>::type> vtkm::make_Pair	(	T1 &&	v1,
		T2 &&	v2
	)

make_PlaneFromPointAndLine()

template<typename CoordType , bool IsTwoSided>

VTKM_EXEC_CONT vtkm::Plane<CoordType> vtkm::make_PlaneFromPointAndLine	(	const vtkm::Vec< CoordType, 3 > &	point,
		const vtkm::Ray< CoordType, 3, IsTwoSided > &	ray,
		CoordType	tol2 = static_cast< CoordType >(1e-8f)
	)

Construct a plane from a point plus one of: a line, a ray, or a line segment.

The plane returned will contain the point and the line/ray/segment. The plane normal will be the cross product of the line/ray/segment's direction and the vector from the line/ray/segment's origin to the given point. If the point is collinear with the line/ray/line-segment, an invalid plane will be returned.

make_PlaneFromPointAndLineSegment()

template<typename CoordType >

VTKM_EXEC_CONT vtkm::Plane<CoordType> vtkm::make_PlaneFromPointAndLineSegment	(	const vtkm::Vec< CoordType, 3 > &	point,
		const vtkm::LineSegment3< CoordType > &	segment,
		CoordType	tol2 = static_cast< CoordType >(1e-8f)
	)

make_SphereFrom4Points()

template<typename CoordType >

VTKM_EXEC_CONT vtkm::Sphere<CoordType, 3> vtkm::make_SphereFrom4Points	(	const vtkm::Vec< CoordType, 3 > &	a0,
		const vtkm::Vec< CoordType, 3 > &	a1,
		const vtkm::Vec< CoordType, 3 > &	a2,
		const vtkm::Vec< CoordType, 3 > &	a3,
		CoordType	tol = static_cast< CoordType >(1e-6f)
	)

Construct a sphere from 4 points.

make_tuple()

template<typename... Ts>

VTKM_SUPPRESS_EXEC_WARNINGS VTKM_EXEC_CONT auto vtkm::make_tuple

(

Ts &&...

args

)

-> decltype(vtkm::MakeTuple(std::forward<Ts>(args)...))

Compatible with std::make_tuple for vtkm::Tuple.

make_Vec()

template<typename T , typename... Ts>

constexpr VTKM_EXEC_CONT vtkm::Vec<T, vtkm::IdComponent(sizeof...(Ts) + 1)> vtkm::make_Vec ( T  value0, Ts &&...  args  )

constexpr

Initializes and returns a Vec containing all the arguments.

The arguments should all be the same type or compile issues will occur.

make_VecFlat()

template<typename T >

VTKM_EXEC_CONT vtkm::VecFlat<T> vtkm::make_VecFlat

(

const T &

vec

)

Converts a Vec-like object to a VecFlat.

make_VecFromPortalPermute() [1/2]

template<typename IndexVecType , typename PortalType >

VTKM_EXEC VecFromPortalPermute<IndexVecType, PortalType> vtkm::make_VecFromPortalPermute ( const IndexVecType *  index, const PortalType &  portal  )

inline

make_VecFromPortalPermute() [2/2]

template<typename IndexVecType , typename PortalType >

VTKM_EXEC VecFromPortalPermute<IndexVecType, const PortalType*> vtkm::make_VecFromPortalPermute ( const IndexVecType *  index, const PortalType *const  portal  )

inline

MakeTuple()

template<typename... Ts>

VTKM_SUPPRESS_EXEC_WARNINGS VTKM_EXEC_CONT auto vtkm::MakeTuple

(

Ts &&...

args

)

-> vtkm::Tuple<typename std::decay<Ts>::type...>

Creates a new vtkm::Tuple with the given types.

MatrixDeterminant() [1/4]

template<typename T >

VTKM_EXEC_CONT T vtkm::MatrixDeterminant

(

const vtkm::Matrix< T, 1, 1 > &

A

)

MatrixDeterminant() [2/4]

template<typename T >

VTKM_EXEC_CONT T vtkm::MatrixDeterminant

(

const vtkm::Matrix< T, 2, 2 > &

A

)

MatrixDeterminant() [3/4]

template<typename T >

VTKM_EXEC_CONT T vtkm::MatrixDeterminant

(

const vtkm::Matrix< T, 3, 3 > &

A

)

MatrixDeterminant() [4/4]

template<typename T , vtkm::IdComponent Size>

VTKM_EXEC_CONT T vtkm::MatrixDeterminant

(

const vtkm::Matrix< T, Size, Size > &

A

)

Compute the determinant of a matrix.

MatrixGetColumn()

template<typename T , vtkm::IdComponent NumRow, vtkm::IdComponent NumCol>

VTKM_EXEC_CONT vtkm::Vec<T, NumRow> vtkm::MatrixGetColumn	(	const vtkm::Matrix< T, NumRow, NumCol > &	matrix,
		vtkm::IdComponent	columnIndex
	)

Returns a tuple containing the given column (indexed from 0) of the given matrix.

Might not be as efficient as the MatrixGetRow function.

MatrixGetRow()

template<typename T , vtkm::IdComponent NumRow, vtkm::IdComponent NumCol>

const VTKM_EXEC_CONT vtkm::Vec<T, NumCol>& vtkm::MatrixGetRow	(	const vtkm::Matrix< T, NumRow, NumCol > &	matrix,
		vtkm::IdComponent	rowIndex
	)

Returns a tuple containing the given row (indexed from 0) of the given matrix.

MatrixIdentity() [1/2]

template<typename T , vtkm::IdComponent Size>

VTKM_EXEC_CONT vtkm::Matrix<T, Size, Size> vtkm::MatrixIdentity

(

)

Returns the identity matrix.

MatrixIdentity() [2/2]

template<typename T , vtkm::IdComponent Size>

VTKM_EXEC_CONT void vtkm::MatrixIdentity

(

vtkm::Matrix< T, Size, Size > &

matrix

)

Fills the given matrix with the identity matrix.

MatrixInverse()

template<typename T , vtkm::IdComponent Size>

VTKM_EXEC_CONT vtkm::Matrix<T, Size, Size> vtkm::MatrixInverse	(	const vtkm::Matrix< T, Size, Size > &	A,
		bool &	valid
	)

Find and return the inverse of the given matrix.

If the matrix is singular, the inverse will not be correct and valid will be set to false.

MatrixMultiply() [1/3]

template<typename T , vtkm::IdComponent NumRow, vtkm::IdComponent NumCol>

VTKM_EXEC_CONT vtkm::Vec<T, NumRow> vtkm::MatrixMultiply	(	const vtkm::Matrix< T, NumRow, NumCol > &	leftFactor,
		const vtkm::Vec< T, NumCol > &	rightFactor
	)

Standard matrix-vector multiplication.

MatrixMultiply() [2/3]

template<typename T , vtkm::IdComponent NumRow, vtkm::IdComponent NumCol, vtkm::IdComponent NumInternal>

VTKM_EXEC_CONT vtkm::Matrix<T, NumRow, NumCol> vtkm::MatrixMultiply	(	const vtkm::Matrix< T, NumRow, NumInternal > &	leftFactor,
		const vtkm::Matrix< T, NumInternal, NumCol > &	rightFactor
	)

Standard matrix multiplication.

MatrixMultiply() [3/3]

template<typename T , vtkm::IdComponent NumRow, vtkm::IdComponent NumCol>

VTKM_EXEC_CONT vtkm::Vec<T, NumCol> vtkm::MatrixMultiply	(	const vtkm::Vec< T, NumRow > &	leftFactor,
		const vtkm::Matrix< T, NumRow, NumCol > &	rightFactor
	)

Standard vector-matrix multiplication.

MatrixSetColumn()

template<typename T , vtkm::IdComponent NumRow, vtkm::IdComponent NumCol>

VTKM_EXEC_CONT void vtkm::MatrixSetColumn	(	vtkm::Matrix< T, NumRow, NumCol > &	matrix,
		vtkm::IdComponent	columnIndex,
		const vtkm::Vec< T, NumRow > &	columnValues
	)

Convenience function for setting a column of a matrix.

MatrixSetRow()

template<typename T , vtkm::IdComponent NumRow, vtkm::IdComponent NumCol>

VTKM_EXEC_CONT void vtkm::MatrixSetRow	(	vtkm::Matrix< T, NumRow, NumCol > &	matrix,
		vtkm::IdComponent	rowIndex,
		const vtkm::Vec< T, NumCol > &	rowValues
	)

Convenience function for setting a row of a matrix.

MatrixTranspose()

template<typename T , vtkm::IdComponent NumRows, vtkm::IdComponent NumCols>

VTKM_EXEC_CONT vtkm::Matrix<T, NumCols, NumRows> vtkm::MatrixTranspose

(

const vtkm::Matrix< T, NumRows, NumCols > &

matrix

)

Returns the transpose of the given matrix.

NewtonsMethod()

template<typename ScalarType , vtkm::IdComponent Size, typename JacobianFunctor , typename FunctionFunctor >

VTKM_SUPPRESS_EXEC_WARNINGS VTKM_EXEC_CONT NewtonsMethodResult<ScalarType, Size> vtkm::NewtonsMethod	(	JacobianFunctor	jacobianEvaluator,
		FunctionFunctor	functionEvaluator,
		vtkm::Vec< ScalarType, Size >	desiredFunctionOutput,
		vtkm::Vec< ScalarType, Size >	initialGuess = vtkm::Vec<ScalarType, Size>(ScalarType(0)),
		ScalarType	convergeDifference = ScalarType(1e-3),
		vtkm::IdComponent	maxIterations = 10
	)

Uses Newton's method (a.k.a.

Newton-Raphson method) to solve a nonlinear system of equations. This function assumes that the number of variables equals the number of equations. Newton's method operates on an iterative evaluate and search. Evaluations are performed using the functors passed into the NewtonsMethod. The first functor returns the NxN matrix of the Jacobian at a given input point. The second functor returns the N tuple that is the function evaluation at the given input point. The input point that evaluates to the desired output, or the closest point found, is returned.

Normal()

template<typename T >

VTKM_EXEC_CONT T vtkm::Normal

(

const T &

x

)

Returns a normalized version of the given vector.

The resulting vector points in the same direction but has unit length.

Normalize()

template<typename T >

VTKM_EXEC_CONT void vtkm::Normalize

(

T &

x

)

Changes a vector to be normal.

The given vector is scaled to be unit length.

operator!=()

template<typename T , vtkm::IdComponent NumRow, vtkm::IdComponent NumCol>

VTKM_EXEC_CONT bool vtkm::operator!=	(	const vtkm::Matrix< T, NumRow, NumCol > &	a,
		const vtkm::Matrix< T, NumRow, NumCol > &	b
	)

operator*() [1/35]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 1> vtkm::operator* ( const vtkm::Vec< T, 1 > &  a, const vtkm::Vec< T, 1 > &  b  )

inline

operator*() [2/35]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 1> vtkm::operator* ( const vtkm::Vec< T, 1 > &  a, T  scalar  )

inline

operator*() [3/35]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 1> vtkm::operator* ( const vtkm::Vec< T, 1 > &  a, vtkm::Float64  scalar  )

inline

operator*() [4/35]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 2> vtkm::operator* ( const vtkm::Vec< T, 2 > &  a, const vtkm::Vec< T, 2 > &  b  )

inline

operator*() [5/35]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 2> vtkm::operator* ( const vtkm::Vec< T, 2 > &  a, T  scalar  )

inline

operator*() [6/35]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 2> vtkm::operator* ( const vtkm::Vec< T, 2 > &  a, vtkm::Float64  scalar  )

inline

operator*() [7/35]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 3> vtkm::operator* ( const vtkm::Vec< T, 3 > &  a, const vtkm::Vec< T, 3 > &  b  )

inline

operator*() [8/35]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 3> vtkm::operator* ( const vtkm::Vec< T, 3 > &  a, T  scalar  )

inline

operator*() [9/35]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 3> vtkm::operator* ( const vtkm::Vec< T, 3 > &  a, vtkm::Float64  scalar  )

inline

operator*() [10/35]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 4> vtkm::operator* ( const vtkm::Vec< T, 4 > &  a, const vtkm::Vec< T, 4 > &  b  )

inline

operator*() [11/35]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 4> vtkm::operator* ( const vtkm::Vec< T, 4 > &  a, T  scalar  )

inline

operator*() [12/35]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 4> vtkm::operator* ( const vtkm::Vec< T, 4 > &  a, vtkm::Float64  scalar  )

inline

operator*() [13/35]

VTKM_EXEC_CONT vtkm::Vec<vtkm::Float64, 1> vtkm::operator* ( const vtkm::Vec< vtkm::Float64, 1 > &  a, vtkm::Float64  scalar  )

inline

operator*() [14/35]

VTKM_EXEC_CONT vtkm::Vec<vtkm::Float64, 2> vtkm::operator* ( const vtkm::Vec< vtkm::Float64, 2 > &  a, vtkm::Float64  scalar  )

inline

operator*() [15/35]

VTKM_EXEC_CONT vtkm::Vec<vtkm::Float64, 3> vtkm::operator* ( const vtkm::Vec< vtkm::Float64, 3 > &  a, vtkm::Float64  scalar  )

inline

operator*() [16/35]

VTKM_EXEC_CONT vtkm::Vec<vtkm::Float64, 4> vtkm::operator* ( const vtkm::Vec< vtkm::Float64, 4 > &  a, vtkm::Float64  scalar  )

inline

operator*() [17/35]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 1> vtkm::operator* ( T  scalar, const vtkm::Vec< T, 1 > &  a  )

inline

operator*() [18/35]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 2> vtkm::operator* ( T  scalar, const vtkm::Vec< T, 2 > &  a  )

inline

operator*() [19/35]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 3> vtkm::operator* ( T  scalar, const vtkm::Vec< T, 3 > &  a  )

inline

operator*() [20/35]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 4> vtkm::operator* ( T  scalar, const vtkm::Vec< T, 4 > &  a  )

inline

operator*() [21/35]

template<typename T , IdComponent Size>

VTKM_EXEC_CONT vtkm::Vec<T, Size> vtkm::operator* ( T  scalar, vtkm::Vec< T, Size >  a  )

inline

operator*() [22/35]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 1> vtkm::operator* ( vtkm::Float64  scalar, const vtkm::Vec< T, 1 > &  a  )

inline

operator*() [23/35]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 2> vtkm::operator* ( vtkm::Float64  scalar, const vtkm::Vec< T, 2 > &  a  )

inline

operator*() [24/35]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 3> vtkm::operator* ( vtkm::Float64  scalar, const vtkm::Vec< T, 3 > &  a  )

inline

operator*() [25/35]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 4> vtkm::operator* ( vtkm::Float64  scalar, const vtkm::Vec< T, 4 > &  a  )

inline

operator*() [26/35]

VTKM_EXEC_CONT vtkm::Vec<vtkm::Float64, 1> vtkm::operator* ( vtkm::Float64  scalar, const vtkm::Vec< vtkm::Float64, 1 > &  a  )

inline

operator*() [27/35]

VTKM_EXEC_CONT vtkm::Vec<vtkm::Float64, 2> vtkm::operator* ( vtkm::Float64  scalar, const vtkm::Vec< vtkm::Float64, 2 > &  a  )

inline

operator*() [28/35]

VTKM_EXEC_CONT vtkm::Vec<vtkm::Float64, 3> vtkm::operator* ( vtkm::Float64  scalar, const vtkm::Vec< vtkm::Float64, 3 > &  a  )

inline

operator*() [29/35]

VTKM_EXEC_CONT vtkm::Vec<vtkm::Float64, 4> vtkm::operator* ( vtkm::Float64  scalar, const vtkm::Vec< vtkm::Float64, 4 > &  a  )

inline

operator*() [30/35]

template<typename T , IdComponent Size>

VTKM_EXEC_CONT vtkm::Vec<T, Size> vtkm::operator* ( vtkm::Float64  scalar, vtkm::Vec< T, Size >  a  )

inline

operator*() [31/35]

template<IdComponent Size>

VTKM_EXEC_CONT vtkm::Vec<vtkm::Float64, Size> vtkm::operator* ( vtkm::Float64  scalar, vtkm::Vec< vtkm::Float64, Size >  a  )

inline

operator*() [32/35]

template<typename T , IdComponent Size>

VTKM_EXEC_CONT vtkm::Vec<T, Size> vtkm::operator* ( vtkm::Vec< T, Size >  a, const vtkm::Vec< T, Size > &  b  )

inline

operator*() [33/35]

template<typename T , IdComponent Size>

VTKM_EXEC_CONT vtkm::Vec<T, Size> vtkm::operator* ( vtkm::Vec< T, Size >  a, T  scalar  )

inline

operator*() [34/35]

template<typename T , IdComponent Size>

VTKM_EXEC_CONT vtkm::Vec<T, Size> vtkm::operator* ( vtkm::Vec< T, Size >  a, vtkm::Float64  scalar  )

inline

operator*() [35/35]

template<IdComponent Size>

VTKM_EXEC_CONT vtkm::Vec<vtkm::Float64, Size> vtkm::operator* ( vtkm::Vec< vtkm::Float64, Size >  a, vtkm::Float64  scalar  )

inline

operator+() [1/36]

template<typename T , typename U >

VTKM_EXEC_CONT vtkm::Pair<T, U> vtkm::operator+	(	const vtkm::Pair< T, U > &	a,
		const vtkm::Pair< T, U > &	b
	)

Pairwise Add.

This is done by adding the two objects separately. Useful for Reduce operation on a zipped array

operator+() [2/36]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 1> vtkm::operator+ ( const vtkm::Vec< T, 1 > &  a, const vtkm::Vec< T, 1 > &  b  )

inline

operator+() [3/36]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 1> vtkm::operator+ ( const vtkm::Vec< T, 1 > &  a, T  scalar  )

inline

operator+() [4/36]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 1> vtkm::operator+ ( const vtkm::Vec< T, 1 > &  a, vtkm::Float64  scalar  )

inline

operator+() [5/36]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 2> vtkm::operator+ ( const vtkm::Vec< T, 2 > &  a, const vtkm::Vec< T, 2 > &  b  )

inline

operator+() [6/36]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 2> vtkm::operator+ ( const vtkm::Vec< T, 2 > &  a, T  scalar  )

inline

operator+() [7/36]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 2> vtkm::operator+ ( const vtkm::Vec< T, 2 > &  a, vtkm::Float64  scalar  )

inline

operator+() [8/36]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 3> vtkm::operator+ ( const vtkm::Vec< T, 3 > &  a, const vtkm::Vec< T, 3 > &  b  )

inline

operator+() [9/36]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 3> vtkm::operator+ ( const vtkm::Vec< T, 3 > &  a, T  scalar  )

inline

operator+() [10/36]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 3> vtkm::operator+ ( const vtkm::Vec< T, 3 > &  a, vtkm::Float64  scalar  )

inline

operator+() [11/36]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 4> vtkm::operator+ ( const vtkm::Vec< T, 4 > &  a, const vtkm::Vec< T, 4 > &  b  )

inline

operator+() [12/36]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 4> vtkm::operator+ ( const vtkm::Vec< T, 4 > &  a, T  scalar  )

inline

operator+() [13/36]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 4> vtkm::operator+ ( const vtkm::Vec< T, 4 > &  a, vtkm::Float64  scalar  )

inline

operator+() [14/36]

VTKM_EXEC_CONT vtkm::Vec<vtkm::Float64, 1> vtkm::operator+ ( const vtkm::Vec< vtkm::Float64, 1 > &  a, vtkm::Float64  scalar  )

inline

operator+() [15/36]

VTKM_EXEC_CONT vtkm::Vec<vtkm::Float64, 2> vtkm::operator+ ( const vtkm::Vec< vtkm::Float64, 2 > &  a, vtkm::Float64  scalar  )

inline

operator+() [16/36]

VTKM_EXEC_CONT vtkm::Vec<vtkm::Float64, 3> vtkm::operator+ ( const vtkm::Vec< vtkm::Float64, 3 > &  a, vtkm::Float64  scalar  )

inline

operator+() [17/36]

VTKM_EXEC_CONT vtkm::Vec<vtkm::Float64, 4> vtkm::operator+ ( const vtkm::Vec< vtkm::Float64, 4 > &  a, vtkm::Float64  scalar  )

inline

operator+() [18/36]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 1> vtkm::operator+ ( T  scalar, const vtkm::Vec< T, 1 > &  a  )

inline

operator+() [19/36]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 2> vtkm::operator+ ( T  scalar, const vtkm::Vec< T, 2 > &  a  )

inline

operator+() [20/36]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 3> vtkm::operator+ ( T  scalar, const vtkm::Vec< T, 3 > &  a  )

inline

operator+() [21/36]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 4> vtkm::operator+ ( T  scalar, const vtkm::Vec< T, 4 > &  a  )

inline

operator+() [22/36]

template<typename T , IdComponent Size>

VTKM_EXEC_CONT vtkm::Vec<T, Size> vtkm::operator+ ( T  scalar, vtkm::Vec< T, Size >  a  )

inline

operator+() [23/36]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 1> vtkm::operator+ ( vtkm::Float64  scalar, const vtkm::Vec< T, 1 > &  a  )

inline

operator+() [24/36]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 2> vtkm::operator+ ( vtkm::Float64  scalar, const vtkm::Vec< T, 2 > &  a  )

inline

operator+() [25/36]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 3> vtkm::operator+ ( vtkm::Float64  scalar, const vtkm::Vec< T, 3 > &  a  )

inline

operator+() [26/36]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 4> vtkm::operator+ ( vtkm::Float64  scalar, const vtkm::Vec< T, 4 > &  a  )

inline

operator+() [27/36]

VTKM_EXEC_CONT vtkm::Vec<vtkm::Float64, 1> vtkm::operator+ ( vtkm::Float64  scalar, const vtkm::Vec< vtkm::Float64, 1 > &  a  )

inline

operator+() [28/36]

VTKM_EXEC_CONT vtkm::Vec<vtkm::Float64, 2> vtkm::operator+ ( vtkm::Float64  scalar, const vtkm::Vec< vtkm::Float64, 2 > &  a  )

inline

operator+() [29/36]

VTKM_EXEC_CONT vtkm::Vec<vtkm::Float64, 3> vtkm::operator+ ( vtkm::Float64  scalar, const vtkm::Vec< vtkm::Float64, 3 > &  a  )

inline

operator+() [30/36]

VTKM_EXEC_CONT vtkm::Vec<vtkm::Float64, 4> vtkm::operator+ ( vtkm::Float64  scalar, const vtkm::Vec< vtkm::Float64, 4 > &  a  )

inline

operator+() [31/36]

template<typename T , IdComponent Size>

VTKM_EXEC_CONT vtkm::Vec<T, Size> vtkm::operator+ ( vtkm::Float64  scalar, vtkm::Vec< T, Size >  a  )

inline

operator+() [32/36]

template<IdComponent Size>

VTKM_EXEC_CONT vtkm::Vec<vtkm::Float64, Size> vtkm::operator+ ( vtkm::Float64  scalar, vtkm::Vec< vtkm::Float64, Size >  a  )

inline

operator+() [33/36]

template<typename T , IdComponent Size>

VTKM_EXEC_CONT vtkm::Vec<T, Size> vtkm::operator+ ( vtkm::Vec< T, Size >  a, const vtkm::Vec< T, Size > &  b  )

inline

operator+() [34/36]

template<typename T , IdComponent Size>

VTKM_EXEC_CONT vtkm::Vec<T, Size> vtkm::operator+ ( vtkm::Vec< T, Size >  a, T  scalar  )

inline

operator+() [35/36]

template<typename T , IdComponent Size>

VTKM_EXEC_CONT vtkm::Vec<T, Size> vtkm::operator+ ( vtkm::Vec< T, Size >  a, vtkm::Float64  scalar  )

inline

operator+() [36/36]

template<IdComponent Size>

VTKM_EXEC_CONT vtkm::Vec<vtkm::Float64, Size> vtkm::operator+ ( vtkm::Vec< vtkm::Float64, Size >  a, vtkm::Float64  scalar  )

inline

operator-() [1/40]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 1> vtkm::operator- ( const vtkm::Vec< T, 1 > &  a, const vtkm::Vec< T, 1 > &  b  )

inline

operator-() [2/40]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 1> vtkm::operator- ( const vtkm::Vec< T, 1 > &  a, T  scalar  )

inline

operator-() [3/40]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 1> vtkm::operator- ( const vtkm::Vec< T, 1 > &  a, vtkm::Float64  scalar  )

inline

operator-() [4/40]

template<typename T >

VTKM_EXEC_CONT std::enable_if<(std::is_floating_point<T>::value || std::is_signed<T>::value), vtkm::Vec<T, 1> >::type vtkm::operator- ( const vtkm::Vec< T, 1 > &  x )

inline

operator-() [5/40]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 2> vtkm::operator- ( const vtkm::Vec< T, 2 > &  a, const vtkm::Vec< T, 2 > &  b  )

inline

operator-() [6/40]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 2> vtkm::operator- ( const vtkm::Vec< T, 2 > &  a, T  scalar  )

inline

operator-() [7/40]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 2> vtkm::operator- ( const vtkm::Vec< T, 2 > &  a, vtkm::Float64  scalar  )

inline

operator-() [8/40]

template<typename T >

VTKM_EXEC_CONT std::enable_if<(std::is_floating_point<T>::value || std::is_signed<T>::value), vtkm::Vec<T, 2> >::type vtkm::operator- ( const vtkm::Vec< T, 2 > &  x )

inline

operator-() [9/40]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 3> vtkm::operator- ( const vtkm::Vec< T, 3 > &  a, const vtkm::Vec< T, 3 > &  b  )

inline

operator-() [10/40]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 3> vtkm::operator- ( const vtkm::Vec< T, 3 > &  a, T  scalar  )

inline

operator-() [11/40]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 3> vtkm::operator- ( const vtkm::Vec< T, 3 > &  a, vtkm::Float64  scalar  )

inline

operator-() [12/40]

template<typename T >

VTKM_EXEC_CONT std::enable_if<(std::is_floating_point<T>::value || std::is_signed<T>::value), vtkm::Vec<T, 3> >::type vtkm::operator- ( const vtkm::Vec< T, 3 > &  x )

inline

operator-() [13/40]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 4> vtkm::operator- ( const vtkm::Vec< T, 4 > &  a, const vtkm::Vec< T, 4 > &  b  )

inline

operator-() [14/40]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 4> vtkm::operator- ( const vtkm::Vec< T, 4 > &  a, T  scalar  )

inline

operator-() [15/40]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 4> vtkm::operator- ( const vtkm::Vec< T, 4 > &  a, vtkm::Float64  scalar  )

inline

operator-() [16/40]

template<typename T >

VTKM_EXEC_CONT std::enable_if<(std::is_floating_point<T>::value || std::is_signed<T>::value), vtkm::Vec<T, 4> >::type vtkm::operator- ( const vtkm::Vec< T, 4 > &  x )

inline

operator-() [17/40]

VTKM_EXEC_CONT vtkm::Vec<vtkm::Float64, 1> vtkm::operator- ( const vtkm::Vec< vtkm::Float64, 1 > &  a, vtkm::Float64  scalar  )

inline

operator-() [18/40]

VTKM_EXEC_CONT vtkm::Vec<vtkm::Float64, 2> vtkm::operator- ( const vtkm::Vec< vtkm::Float64, 2 > &  a, vtkm::Float64  scalar  )

inline

operator-() [19/40]

VTKM_EXEC_CONT vtkm::Vec<vtkm::Float64, 3> vtkm::operator- ( const vtkm::Vec< vtkm::Float64, 3 > &  a, vtkm::Float64  scalar  )

inline

operator-() [20/40]

VTKM_EXEC_CONT vtkm::Vec<vtkm::Float64, 4> vtkm::operator- ( const vtkm::Vec< vtkm::Float64, 4 > &  a, vtkm::Float64  scalar  )

inline

operator-() [21/40]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 1> vtkm::operator- ( T  scalar, const vtkm::Vec< T, 1 > &  a  )

inline

operator-() [22/40]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 2> vtkm::operator- ( T  scalar, const vtkm::Vec< T, 2 > &  a  )

inline

operator-() [23/40]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 3> vtkm::operator- ( T  scalar, const vtkm::Vec< T, 3 > &  a  )

inline

operator-() [24/40]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 4> vtkm::operator- ( T  scalar, const vtkm::Vec< T, 4 > &  a  )

inline

operator-() [25/40]

template<typename T , IdComponent Size>

VTKM_EXEC_CONT vtkm::Vec<T, Size> vtkm::operator- ( T  scalar, vtkm::Vec< T, Size >  a  )

inline

operator-() [26/40]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 1> vtkm::operator- ( vtkm::Float64  scalar, const vtkm::Vec< T, 1 > &  a  )

inline

operator-() [27/40]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 2> vtkm::operator- ( vtkm::Float64  scalar, const vtkm::Vec< T, 2 > &  a  )

inline

operator-() [28/40]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 3> vtkm::operator- ( vtkm::Float64  scalar, const vtkm::Vec< T, 3 > &  a  )

inline

operator-() [29/40]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 4> vtkm::operator- ( vtkm::Float64  scalar, const vtkm::Vec< T, 4 > &  a  )

inline

operator-() [30/40]

VTKM_EXEC_CONT vtkm::Vec<vtkm::Float64, 1> vtkm::operator- ( vtkm::Float64  scalar, const vtkm::Vec< vtkm::Float64, 1 > &  a  )

inline

operator-() [31/40]

VTKM_EXEC_CONT vtkm::Vec<vtkm::Float64, 2> vtkm::operator- ( vtkm::Float64  scalar, const vtkm::Vec< vtkm::Float64, 2 > &  a  )

inline

operator-() [32/40]

VTKM_EXEC_CONT vtkm::Vec<vtkm::Float64, 3> vtkm::operator- ( vtkm::Float64  scalar, const vtkm::Vec< vtkm::Float64, 3 > &  a  )

inline

operator-() [33/40]

VTKM_EXEC_CONT vtkm::Vec<vtkm::Float64, 4> vtkm::operator- ( vtkm::Float64  scalar, const vtkm::Vec< vtkm::Float64, 4 > &  a  )

inline

operator-() [34/40]

template<typename T , IdComponent Size>

VTKM_EXEC_CONT vtkm::Vec<T, Size> vtkm::operator- ( vtkm::Float64  scalar, vtkm::Vec< T, Size >  a  )

inline

operator-() [35/40]

template<IdComponent Size>

VTKM_EXEC_CONT vtkm::Vec<vtkm::Float64, Size> vtkm::operator- ( vtkm::Float64  scalar, vtkm::Vec< vtkm::Float64, Size >  a  )

inline

operator-() [36/40]

template<typename T , IdComponent Size>

VTKM_EXEC_CONT vtkm::Vec<T, Size> vtkm::operator- ( vtkm::Vec< T, Size >  a, const vtkm::Vec< T, Size > &  b  )

inline

operator-() [37/40]

template<typename T , IdComponent Size>

VTKM_EXEC_CONT vtkm::Vec<T, Size> vtkm::operator- ( vtkm::Vec< T, Size >  a, T  scalar  )

inline

operator-() [38/40]

template<typename T , IdComponent Size>

VTKM_EXEC_CONT vtkm::Vec<T, Size> vtkm::operator- ( vtkm::Vec< T, Size >  a, vtkm::Float64  scalar  )

inline

operator-() [39/40]

template<typename T , vtkm::IdComponent Size>

VTKM_EXEC_CONT std::enable_if<(std::is_floating_point<T>::value || std::is_signed<T>::value), vtkm::Vec<T, Size> >::type vtkm::operator- ( vtkm::Vec< T, Size >  x )

inline

operator-() [40/40]

template<IdComponent Size>

VTKM_EXEC_CONT vtkm::Vec<vtkm::Float64, Size> vtkm::operator- ( vtkm::Vec< vtkm::Float64, Size >  a, vtkm::Float64  scalar  )

inline

operator/() [1/35]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 1> vtkm::operator/ ( const vtkm::Vec< T, 1 > &  a, const vtkm::Vec< T, 1 > &  b  )

inline

operator/() [2/35]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 1> vtkm::operator/ ( const vtkm::Vec< T, 1 > &  a, T  scalar  )

inline

operator/() [3/35]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 1> vtkm::operator/ ( const vtkm::Vec< T, 1 > &  a, vtkm::Float64  scalar  )

inline

operator/() [4/35]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 2> vtkm::operator/ ( const vtkm::Vec< T, 2 > &  a, const vtkm::Vec< T, 2 > &  b  )

inline

operator/() [5/35]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 2> vtkm::operator/ ( const vtkm::Vec< T, 2 > &  a, T  scalar  )

inline

operator/() [6/35]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 2> vtkm::operator/ ( const vtkm::Vec< T, 2 > &  a, vtkm::Float64  scalar  )

inline

operator/() [7/35]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 3> vtkm::operator/ ( const vtkm::Vec< T, 3 > &  a, const vtkm::Vec< T, 3 > &  b  )

inline

operator/() [8/35]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 3> vtkm::operator/ ( const vtkm::Vec< T, 3 > &  a, T  scalar  )

inline

operator/() [9/35]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 3> vtkm::operator/ ( const vtkm::Vec< T, 3 > &  a, vtkm::Float64  scalar  )

inline

operator/() [10/35]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 4> vtkm::operator/ ( const vtkm::Vec< T, 4 > &  a, const vtkm::Vec< T, 4 > &  b  )

inline

operator/() [11/35]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 4> vtkm::operator/ ( const vtkm::Vec< T, 4 > &  a, T  scalar  )

inline

operator/() [12/35]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 4> vtkm::operator/ ( const vtkm::Vec< T, 4 > &  a, vtkm::Float64  scalar  )

inline

operator/() [13/35]

VTKM_EXEC_CONT vtkm::Vec<vtkm::Float64, 1> vtkm::operator/ ( const vtkm::Vec< vtkm::Float64, 1 > &  a, vtkm::Float64  scalar  )

inline

operator/() [14/35]

VTKM_EXEC_CONT vtkm::Vec<vtkm::Float64, 2> vtkm::operator/ ( const vtkm::Vec< vtkm::Float64, 2 > &  a, vtkm::Float64  scalar  )

inline

operator/() [15/35]

VTKM_EXEC_CONT vtkm::Vec<vtkm::Float64, 3> vtkm::operator/ ( const vtkm::Vec< vtkm::Float64, 3 > &  a, vtkm::Float64  scalar  )

inline

operator/() [16/35]

VTKM_EXEC_CONT vtkm::Vec<vtkm::Float64, 4> vtkm::operator/ ( const vtkm::Vec< vtkm::Float64, 4 > &  a, vtkm::Float64  scalar  )

inline

operator/() [17/35]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 1> vtkm::operator/ ( T  scalar, const vtkm::Vec< T, 1 > &  a  )

inline

operator/() [18/35]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 2> vtkm::operator/ ( T  scalar, const vtkm::Vec< T, 2 > &  a  )

inline

operator/() [19/35]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 3> vtkm::operator/ ( T  scalar, const vtkm::Vec< T, 3 > &  a  )

inline

operator/() [20/35]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 4> vtkm::operator/ ( T  scalar, const vtkm::Vec< T, 4 > &  a  )

inline

operator/() [21/35]

template<typename T , IdComponent Size>

VTKM_EXEC_CONT vtkm::Vec<T, Size> vtkm::operator/ ( T  scalar, vtkm::Vec< T, Size >  a  )

inline

operator/() [22/35]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 1> vtkm::operator/ ( vtkm::Float64  scalar, const vtkm::Vec< T, 1 > &  a  )

inline

operator/() [23/35]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 2> vtkm::operator/ ( vtkm::Float64  scalar, const vtkm::Vec< T, 2 > &  a  )

inline

operator/() [24/35]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 3> vtkm::operator/ ( vtkm::Float64  scalar, const vtkm::Vec< T, 3 > &  a  )

inline

operator/() [25/35]

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 4> vtkm::operator/ ( vtkm::Float64  scalar, const vtkm::Vec< T, 4 > &  a  )

inline

operator/() [26/35]

VTKM_EXEC_CONT vtkm::Vec<vtkm::Float64, 1> vtkm::operator/ ( vtkm::Float64  scalar, const vtkm::Vec< vtkm::Float64, 1 > &  a  )

inline

operator/() [27/35]

VTKM_EXEC_CONT vtkm::Vec<vtkm::Float64, 2> vtkm::operator/ ( vtkm::Float64  scalar, const vtkm::Vec< vtkm::Float64, 2 > &  a  )

inline

operator/() [28/35]

VTKM_EXEC_CONT vtkm::Vec<vtkm::Float64, 3> vtkm::operator/ ( vtkm::Float64  scalar, const vtkm::Vec< vtkm::Float64, 3 > &  a  )

inline

operator/() [29/35]

VTKM_EXEC_CONT vtkm::Vec<vtkm::Float64, 4> vtkm::operator/ ( vtkm::Float64  scalar, const vtkm::Vec< vtkm::Float64, 4 > &  a  )

inline

operator/() [30/35]

template<typename T , IdComponent Size>

VTKM_EXEC_CONT vtkm::Vec<T, Size> vtkm::operator/ ( vtkm::Float64  scalar, vtkm::Vec< T, Size >  a  )

inline

operator/() [31/35]

template<IdComponent Size>

VTKM_EXEC_CONT vtkm::Vec<vtkm::Float64, Size> vtkm::operator/ ( vtkm::Float64  scalar, vtkm::Vec< vtkm::Float64, Size >  a  )

inline

operator/() [32/35]

template<typename T , IdComponent Size>

VTKM_EXEC_CONT vtkm::Vec<T, Size> vtkm::operator/ ( vtkm::Vec< T, Size >  a, const vtkm::Vec< T, Size > &  b  )

inline

operator/() [33/35]

template<typename T , IdComponent Size>

VTKM_EXEC_CONT vtkm::Vec<T, Size> vtkm::operator/ ( vtkm::Vec< T, Size >  a, T  scalar  )

inline

operator/() [34/35]

template<typename T , IdComponent Size>

VTKM_EXEC_CONT vtkm::Vec<T, Size> vtkm::operator/ ( vtkm::Vec< T, Size >  a, vtkm::Float64  scalar  )

inline

operator/() [35/35]

template<IdComponent Size>

VTKM_EXEC_CONT vtkm::Vec<vtkm::Float64, Size> vtkm::operator/ ( vtkm::Vec< vtkm::Float64, Size >  a, vtkm::Float64  scalar  )

inline

operator<<() [1/8]

VTKM_CONT std::ostream& vtkm::operator<< ( std::ostream &  s, const vtkm::ParticleStatus &  status  )

inline

operator<<() [2/8]

VTKM_CONT std::ostream& vtkm::operator<< ( std::ostream &  stream, const vtkm::Bounds &  bounds  )

inline

Helper function for printing bounds during testing.

operator<<() [3/8]

template<typename T , vtkm::IdComponent NumRow, vtkm::IdComponent NumCol>

VTKM_CONT std::ostream& vtkm::operator<<	(	std::ostream &	stream,
		const vtkm::Matrix< T, NumRow, NumCol > &	mat
	)

Helper function for printing out matricies during testing.

operator<<() [4/8]

template<typename T , typename U >

VTKM_EXEC_CONT std::ostream& vtkm::operator<< ( std::ostream &  stream, const vtkm::Pair< T, U > &  vec  )

inline

Helper function for printing out pairs during testing.

operator<<() [5/8]

VTKM_CONT std::ostream& vtkm::operator<< ( std::ostream &  stream, const vtkm::Range &  range  )

inline

Helper function for printing ranges during testing.

operator<<() [6/8]

VTKM_CONT std::ostream& vtkm::operator<< ( std::ostream &  stream, const vtkm::RangeId3 &  range  )

inline

Helper function for printing range during testing.

operator<<() [7/8]

template<typename T , vtkm::IdComponent Size>

VTKM_CONT std::ostream& vtkm::operator<< ( std::ostream &  stream, const vtkm::Vec< T, Size > &  vec  )

inline

Helper function for printing out vectors during testing.

operator<<() [8/8]

template<vtkm::IdComponent NumDimensions>

VTKM_CONT std::ostream& vtkm::operator<< ( std::ostream &  stream, const vtkm::VecAxisAlignedPointCoordinates< NumDimensions > &  vec  )

inline

Helper function for printing out vectors during testing.

operator==()

template<typename T , vtkm::IdComponent NumRow, vtkm::IdComponent NumCol>

VTKM_EXEC_CONT bool vtkm::operator==	(	const vtkm::Matrix< T, NumRow, NumCol > &	a,
		const vtkm::Matrix< T, NumRow, NumCol > &	b
	)

Orthonormalize()

template<typename T , int N>

VTKM_EXEC_CONT int vtkm::Orthonormalize	(	const vtkm::Vec< vtkm::Vec< T, N >, N > &	inputs,
		vtkm::Vec< vtkm::Vec< T, N >, N > &	outputs,
		T	tol = static_cast<T>(1e-6)
	)

Perform Gram-Schmidt orthonormalization for 3-D vectors.

See https://en.wikipedia.org/wiki/Gram%E2%80%93Schmidt_process for details. The first output vector will always be parallel to the first input vector. The remaining output vectors will be orthogonal and unit length and have the same handedness as their corresponding input vectors.

This method is geometric. It does not require a matrix solver. However, unlike the algebraic eigensolver techniques which do use matrix inversion, this method may return zero-length output vectors if some input vectors are collinear. The number of non-zero (to within the specified tolerance, tol ) output vectors is the return value.

Project()

template<typename T , int N>

VTKM_EXEC_CONT vtkm::Vec<T, N> vtkm::Project	(	const vtkm::Vec< T, N > &	v,
		const vtkm::Vec< T, N > &	u
	)

Project a vector onto another vector.

This method computes the orthogonal projection of the vector v onto u; that is, it projects its first argument onto its second.

Note that if the vector u has zero length, the output vector will have all its entries equal to NaN.

ProjectedDistance()

template<typename T , int N>

VTKM_EXEC_CONT T vtkm::ProjectedDistance	(	const vtkm::Vec< T, N > &	v,
		const vtkm::Vec< T, N > &	u
	)

Project a vector onto another vector, returning only the projected distance.

This method computes the orthogonal projection of the vector v onto u; that is, it projects its first argument onto its second.

Note that if the vector u has zero length, the output will be NaN.

QuadraticRoots()

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 2> vtkm::QuadraticRoots ( T  a, T  b, T  c  )

inline

ReduceProduct() [1/4]

template<typename T >

VTKM_EXEC_CONT T vtkm::ReduceProduct ( const vtkm::Vec< T, 2 > &  a )

inline

ReduceProduct() [2/4]

template<typename T >

VTKM_EXEC_CONT T vtkm::ReduceProduct ( const vtkm::Vec< T, 3 > &  a )

inline

ReduceProduct() [3/4]

template<typename T >

VTKM_EXEC_CONT T vtkm::ReduceProduct ( const vtkm::Vec< T, 4 > &  a )

inline

ReduceProduct() [4/4]

template<typename T , vtkm::IdComponent Size>

VTKM_EXEC_CONT T vtkm::ReduceProduct ( const vtkm::Vec< T, Size > &  a )

inline

ReduceSum() [1/4]

template<typename T >

VTKM_EXEC_CONT T vtkm::ReduceSum ( const vtkm::Vec< T, 2 > &  a )

inline

ReduceSum() [2/4]

template<typename T >

VTKM_EXEC_CONT T vtkm::ReduceSum ( const vtkm::Vec< T, 3 > &  a )

inline

ReduceSum() [3/4]

template<typename T >

VTKM_EXEC_CONT T vtkm::ReduceSum ( const vtkm::Vec< T, 4 > &  a )

inline

ReduceSum() [4/4]

template<typename T , vtkm::IdComponent Size>

VTKM_EXEC_CONT T vtkm::ReduceSum ( const vtkm::Vec< T, Size > &  a )

inline

RMagnitude()

template<typename T >

VTKM_EXEC_CONT detail::FloatingPointReturnType<T>::Type vtkm::RMagnitude

(

const T &

x

)

Returns the reciprocal magnitude of a vector.

On some hardware RMagnitude is faster than Magnitude, but neither is as fast as MagnitudeSquared.

Round() [1/2]

VTKM_EXEC_CONT vtkm::Float32 vtkm::Round ( vtkm::Float32  x )

inline

Round x to the nearest integral value.

Round() [2/2]

VTKM_EXEC_CONT vtkm::Float64 vtkm::Round ( vtkm::Float64  x )

inline

Sin() [1/2]

VTKM_EXEC_CONT vtkm::Float32 vtkm::Sin ( vtkm::Float32  x )

inline

Compute the sine of x.

Sin() [2/2]

VTKM_EXEC_CONT vtkm::Float64 vtkm::Sin ( vtkm::Float64  x )

inline

SinH() [1/2]

VTKM_EXEC_CONT vtkm::Float32 vtkm::SinH ( vtkm::Float32  x )

inline

Compute the hyperbolic sine of x.

SinH() [2/2]

VTKM_EXEC_CONT vtkm::Float64 vtkm::SinH ( vtkm::Float64  x )

inline

SolveLinearSystem()

template<typename T , vtkm::IdComponent Size>

VTKM_EXEC_CONT vtkm::Vec<T, Size> vtkm::SolveLinearSystem	(	const vtkm::Matrix< T, Size, Size > &	A,
		const vtkm::Vec< T, Size > &	b,
		bool &	valid
	)

Solve the linear system Ax = b for x.

If a single solution is found, valid is set to true, false otherwise.

Sqrt() [1/2]

VTKM_EXEC_CONT vtkm::Float32 vtkm::Sqrt ( vtkm::Float32  x )

inline

Compute the square root of x.

Sqrt() [2/2]

VTKM_EXEC_CONT vtkm::Float64 vtkm::Sqrt ( vtkm::Float64  x )

inline

Swap()

template<typename T >

VTKM_EXEC_CONT void vtkm::Swap ( T &  a, T &  b  )

inline

Performs a swap operation. Safe to call from cuda code.

Tan() [1/2]

VTKM_EXEC_CONT vtkm::Float32 vtkm::Tan ( vtkm::Float32  x )

inline

Compute the tangent of x.

Tan() [2/2]

VTKM_EXEC_CONT vtkm::Float64 vtkm::Tan ( vtkm::Float64  x )

inline

TanH() [1/2]

VTKM_EXEC_CONT vtkm::Float32 vtkm::TanH ( vtkm::Float32  x )

inline

Compute the hyperbolic tangent of x.

TanH() [2/2]

VTKM_EXEC_CONT vtkm::Float64 vtkm::TanH ( vtkm::Float64  x )

inline

Transform3DPoint()

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 3> vtkm::Transform3DPoint	(	const vtkm::Matrix< T, 4, 4 > &	matrix,
		const vtkm::Vec< T, 3 > &	point
	)

Transform a 3D point by a transformation matrix.

Given a 4x4 transformation matrix and a 3D point, returns the point transformed by the given matrix in homogeneous coordinates.

This method ignores any change in the fourth component of the transformed homogeneous coordinate, assuming that it is always 1 (that is, the last row of the matrix is 0, 0, 0, 1). This will be true for affine transformations (such as translate, scale, and rotate), but not for perspective transformations.

Transform3DPointPerspective()

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 3> vtkm::Transform3DPointPerspective	(	const vtkm::Matrix< T, 4, 4 > &	matrix,
		const vtkm::Vec< T, 3 > &	point
	)

Transform a 3D point by a transformation matrix with perspective.

Given a 4x4 transformation matrix and a 3D point, returns the point transformed by the given matrix in homogeneous coordinates.

Unlike Transform3DPoint, this method honors the fourth component of the transformed homogeneous coordinate. This makes it applicable for perspective transformations, but requires some more computations.

Transform3DRotate() [1/2]

template<typename T >

VTKM_EXEC_CONT vtkm::Matrix<T, 4, 4> vtkm::Transform3DRotate	(	T	angleDegrees,
		const vtkm::Vec< T, 3 > &	axisOfRotation
	)

Returns a rotation matrix.

Given an angle (in degrees) and an axis of rotation, returns a transformation matrix that rotates around the given axis. The rotation follows the right-hand rule, so if the vector points toward the user, the rotation will be counterclockwise.

Transform3DRotate() [2/2]

template<typename T >

VTKM_EXEC_CONT vtkm::Matrix<T, 4, 4> vtkm::Transform3DRotate	(	T	angleDegrees,
		T	x,
		T	y,
		T	z
	)

Transform3DRotateX()

template<typename T >

VTKM_EXEC_CONT vtkm::Matrix<T, 4, 4> vtkm::Transform3DRotateX

(

T

angleDegrees

)

Returns a rotation matrix.

Returns a transformation matrix that rotates around the x axis.

Transform3DRotateY()

template<typename T >

VTKM_EXEC_CONT vtkm::Matrix<T, 4, 4> vtkm::Transform3DRotateY

(

T

angleDegrees

)

Returns a rotation matrix.

Returns a transformation matrix that rotates around the y axis.

Transform3DRotateZ()

template<typename T >

VTKM_EXEC_CONT vtkm::Matrix<T, 4, 4> vtkm::Transform3DRotateZ

(

T

angleDegrees

)

Returns a rotation matrix.

Returns a transformation matrix that rotates around the z axis.

Transform3DScale() [1/3]

template<typename T >

VTKM_EXEC_CONT vtkm::Matrix<T, 4, 4> vtkm::Transform3DScale

(

const T &

scale

)

Returns a scale matrix.

Given a uniform scale factor, returns a transformation matrix for those scales.

Transform3DScale() [2/3]

template<typename T >

VTKM_EXEC_CONT vtkm::Matrix<T, 4, 4> vtkm::Transform3DScale	(	const T &	scaleX,
		const T &	scaleY,
		const T &	scaleZ
	)

Returns a scale matrix.

Given a scale factor for the x, y, and z directions, returns a transformation matrix for those scales.

Transform3DScale() [3/3]

template<typename T >

VTKM_EXEC_CONT vtkm::Matrix<T, 4, 4> vtkm::Transform3DScale

(

const vtkm::Vec< T, 3 > &

scaleVec

)

Returns a scale matrix.

Given a scale factor for the x, y, and z directions (defined in a Vec), returns a transformation matrix for those scales.

Transform3DTranslate() [1/2]

template<typename T >

VTKM_EXEC_CONT vtkm::Matrix<T, 4, 4> vtkm::Transform3DTranslate	(	const T &	x,
		const T &	y,
		const T &	z
	)

Returns a translation matrix.

Transform3DTranslate() [2/2]

template<typename T >

VTKM_EXEC_CONT vtkm::Matrix<T, 4, 4> vtkm::Transform3DTranslate

(

const vtkm::Vec< T, 3 > &

v

)

Transform3DVector()

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<T, 3> vtkm::Transform3DVector	(	const vtkm::Matrix< T, 4, 4 > &	matrix,
		const vtkm::Vec< T, 3 > &	vector
	)

Transform a 3D vector by a transformation matrix.

Given a 4x4 transformation matrix and a 3D vector, returns the vector transformed by the given matrix in homogeneous coordinates. Unlike points, vectors do not get translated.

TriangleNormal()

template<typename T >

VTKM_EXEC_CONT vtkm::Vec<typename detail::FloatingPointReturnType<T>::Type, 3> vtkm::TriangleNormal	(	const vtkm::Vec< T, 3 > &	a,
		const vtkm::Vec< T, 3 > &	b,
		const vtkm::Vec< T, 3 > &	c
	)

Find the normal of a triangle.

Given three coordinates in space, which, unless degenerate, uniquely define a triangle and the plane the triangle is on, returns a vector perpendicular to that triangle/plane.

Note that the returned vector might not be a unit vector. In fact, the length is equal to twice the area of the triangle. If you want a unit vector, send the result through the Normal function.

UpperBound() [1/4]

template<typename PortalT , typename T >

VTKM_EXEC_CONT vtkm::Id vtkm::UpperBound	(	const PortalT &	portal,
		const T &	val
	)

Implementation of std::upper_bound that is appropriate for both control and execution environments.

The overloads that take portals return indices instead of iterators.

UpperBound() [2/4]

template<typename PortalT , typename T , typename Comp >

VTKM_EXEC_CONT vtkm::Id vtkm::UpperBound	(	const PortalT &	portal,
		const T &	val,
		Comp	comp
	)

Implementation of std::upper_bound that is appropriate for both control and execution environments.

The overloads that take portals return indices instead of iterators.

UpperBound() [3/4]

template<typename IterT , typename T >

VTKM_EXEC_CONT IterT vtkm::UpperBound	(	IterT	first,
		IterT	last,
		const T &	val
	)

Implementation of std::upper_bound that is appropriate for both control and execution environments.

The overloads that take portals return indices instead of iterators.

UpperBound() [4/4]

template<typename IterT , typename T , typename Comp >

VTKM_EXEC_CONT IterT vtkm::UpperBound	(	IterT	first,
		IterT	last,
		const T &	val,
		Comp	comp
	)

Implementation of std::upper_bound that is appropriate for both control and execution environments.

The overloads that take portals return indices instead of iterators.

VTKM_DEFINE_CELL_TAG() [1/11]

vtkm::VTKM_DEFINE_CELL_TAG	(	Empty	,
		CELL_SHAPE_EMPTY
	)

VTKM_DEFINE_CELL_TAG() [2/11]

vtkm::VTKM_DEFINE_CELL_TAG	(	Hexahedron	,
		CELL_SHAPE_HEXAHEDRON
	)

VTKM_DEFINE_CELL_TAG() [3/11]

vtkm::VTKM_DEFINE_CELL_TAG	(	Line	,
		CELL_SHAPE_LINE
	)

VTKM_DEFINE_CELL_TAG() [4/11]

vtkm::VTKM_DEFINE_CELL_TAG	(	Polygon	,
		CELL_SHAPE_POLYGON
	)

VTKM_DEFINE_CELL_TAG() [5/11]

vtkm::VTKM_DEFINE_CELL_TAG	(	PolyLine	,
		CELL_SHAPE_POLY_LINE
	)

VTKM_DEFINE_CELL_TAG() [6/11]

vtkm::VTKM_DEFINE_CELL_TAG	(	Pyramid	,
		CELL_SHAPE_PYRAMID
	)

VTKM_DEFINE_CELL_TAG() [7/11]

vtkm::VTKM_DEFINE_CELL_TAG	(	Quad	,
		CELL_SHAPE_QUAD
	)

VTKM_DEFINE_CELL_TAG() [8/11]

vtkm::VTKM_DEFINE_CELL_TAG	(	Tetra	,
		CELL_SHAPE_TETRA
	)

VTKM_DEFINE_CELL_TAG() [9/11]

vtkm::VTKM_DEFINE_CELL_TAG	(	Triangle	,
		CELL_SHAPE_TRIANGLE
	)

VTKM_DEFINE_CELL_TAG() [10/11]

vtkm::VTKM_DEFINE_CELL_TAG	(	Vertex	,
		CELL_SHAPE_VERTEX
	)

VTKM_DEFINE_CELL_TAG() [11/11]

vtkm::VTKM_DEFINE_CELL_TAG	(	Wedge	,
		CELL_SHAPE_WEDGE
	)

VTKM_DEFINE_CELL_TRAITS() [1/9]

vtkm::VTKM_DEFINE_CELL_TRAITS	(	Empty	,
		0	,
		0
	)

VTKM_DEFINE_CELL_TRAITS() [2/9]

vtkm::VTKM_DEFINE_CELL_TRAITS	(	Hexahedron	,
		3	,
		8
	)

VTKM_DEFINE_CELL_TRAITS() [3/9]

vtkm::VTKM_DEFINE_CELL_TRAITS	(	Line	,
		1	,
		2
	)

VTKM_DEFINE_CELL_TRAITS() [4/9]

vtkm::VTKM_DEFINE_CELL_TRAITS	(	Pyramid	,
		3	,
		5
	)

VTKM_DEFINE_CELL_TRAITS() [5/9]

vtkm::VTKM_DEFINE_CELL_TRAITS	(	Quad	,
		2	,
		4
	)

VTKM_DEFINE_CELL_TRAITS() [6/9]

vtkm::VTKM_DEFINE_CELL_TRAITS	(	Tetra	,
		3	,
		4
	)

VTKM_DEFINE_CELL_TRAITS() [7/9]

vtkm::VTKM_DEFINE_CELL_TRAITS	(	Triangle	,
		2	,
		3
	)

VTKM_DEFINE_CELL_TRAITS() [8/9]

vtkm::VTKM_DEFINE_CELL_TRAITS	(	Vertex	,
		0	,
		1
	)

VTKM_DEFINE_CELL_TRAITS() [9/9]

vtkm::VTKM_DEFINE_CELL_TRAITS	(	Wedge	,
		3	,
		6
	)

VTKM_DEFINE_CELL_TRAITS_VARIABLE() [1/2]

vtkm::VTKM_DEFINE_CELL_TRAITS_VARIABLE	(	Polygon	,
		2
	)

VTKM_DEFINE_CELL_TRAITS_VARIABLE() [2/2]

vtkm::VTKM_DEFINE_CELL_TRAITS_VARIABLE	(	PolyLine	,
		1
	)

Variable Documentation

Vec

template<typename T , vtkm::IdComponent Size>

class VTKM_ALWAYS_EXPORT vtkm::Vec

VecC

template<typename T >

class VTKM_ALWAYS_EXPORT vtkm::VecC

VecCConst

template<typename T >

class VTKM_ALWAYS_EXPORT vtkm::VecCConst