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.

	tmp

	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	CellShapeIdToTag< vtkm::CELL_SHAPE_EMPTY >

struct	CellShapeIdToTag< vtkm::CELL_SHAPE_HEXAHEDRON >

struct	CellShapeIdToTag< vtkm::CELL_SHAPE_LINE >

struct	CellShapeIdToTag< vtkm::CELL_SHAPE_POLY_LINE >

struct	CellShapeIdToTag< vtkm::CELL_SHAPE_POLYGON >

struct	CellShapeIdToTag< vtkm::CELL_SHAPE_PYRAMID >

struct	CellShapeIdToTag< vtkm::CELL_SHAPE_QUAD >

struct	CellShapeIdToTag< vtkm::CELL_SHAPE_TETRA >

struct	CellShapeIdToTag< vtkm::CELL_SHAPE_TRIANGLE >

struct	CellShapeIdToTag< vtkm::CELL_SHAPE_VERTEX >

struct	CellShapeIdToTag< vtkm::CELL_SHAPE_WEDGE >

struct	CellShapeTagEmpty

struct	CellShapeTagGeneric
	A special cell shape tag that holds a cell shape that is not known at compile time. More...

struct	CellShapeTagHexahedron

struct	CellShapeTagLine

struct	CellShapeTagPolygon

struct	CellShapeTagPolyLine

struct	CellShapeTagPyramid

struct	CellShapeTagQuad

struct	CellShapeTagTetra

struct	CellShapeTagTriangle

struct	CellShapeTagVertex

struct	CellShapeTagWedge

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	CellTraits< vtkm::CellShapeTagEmpty >

struct	CellTraits< vtkm::CellShapeTagHexahedron >

struct	CellTraits< vtkm::CellShapeTagLine >

struct	CellTraits< vtkm::CellShapeTagPolygon >

struct	CellTraits< vtkm::CellShapeTagPolyLine >

struct	CellTraits< vtkm::CellShapeTagPyramid >

struct	CellTraits< vtkm::CellShapeTagQuad >

struct	CellTraits< vtkm::CellShapeTagTetra >

struct	CellTraits< vtkm::CellShapeTagTriangle >

struct	CellTraits< vtkm::CellShapeTagVertex >

struct	CellTraits< vtkm::CellShapeTagWedge >

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
	A template used to hold a list of types. More...

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...

class	MultiPlane
	Implicit function for a MultiPlane. More...

struct	Multiply

struct	Negate

struct	NewtonsMethodResult
	An object returned from `NewtonsMethod()` that contains the result and other information about the final state. More...

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< bool >

struct	TypeTraits< char >

struct	TypeTraits< const T >

struct	TypeTraits< double >

struct	TypeTraits< float >
	Traits for basic C++ types. More...

struct	TypeTraits< int >

struct	TypeTraits< long >

struct	TypeTraits< long long >

struct	TypeTraits< short >

struct	TypeTraits< signed char >

struct	TypeTraits< unsigned char >

struct	TypeTraits< unsigned int >

struct	TypeTraits< unsigned long >

struct	TypeTraits< unsigned long long >

struct	TypeTraits< unsigned short >

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 Vec 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
	Traits that can be queried to treat any type as a `Vec`. More...

struct	VecTraits< const T & >

struct	VecTraits< const T * >

struct	VecTraits< const T >

struct	VecTraits< T & >

struct	VecTraits< 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::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 convenience type for an empty list. More...

using	ListUniversal = vtkm::List< detail::UniversalTypeTag >
	A special type 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 long, unsigned long > >

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
	Base type to use for 32-bit floating-point numbers. More...

using	Float64 = double
	Base type to use for 64-bit floating-point numbers. More...

using	Int8 = int8_t
	Base type to use for 8-bit signed integer numbers. More...

using	UInt8 = uint8_t
	Base type to use for 8-bit unsigned integer numbers. More...

using	Int16 = int16_t
	Base type to use for 16-bit signed integer numbers. More...

using	UInt16 = uint16_t
	Base type to use for 16-bit unsigned integer numbers. More...

using	Int32 = int32_t
	Base type to use for 32-bit signed integer numbers. More...

using	UInt32 = uint32_t
	Base type to use for 32-bit unsigned integer numbers. More...

using	IdComponent = vtkm::Int32
	Base type to use to index small lists. More...

using	WordTypeDefault = vtkm::UInt32
	The default word size used for atomic bitwise operations. More...

using	Int64 = signed long long
	Base type to use for 64-bit signed integer numbers. More...

using	UInt64 = unsigned long long
	Base type to use for 64-bit signed integer numbers. More...

using	Id = vtkm::Int64
	Base type to use to index 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::UInt64, 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::UInt64, 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::UInt64, 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 = std::true_type

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 }
	Identifies whether an operation was successful or what type of error it had. More...

enum	ColorSpace { ColorSpace::RGB, ColorSpace::HSV, ColorSpace::HSVWrap, ColorSpace::Lab, ColorSpace::Diverging }

enum	CopyFlag { CopyFlag::Off = 0, CopyFlag::On = 1 }
	Identifier used to specify whether a function should deep copy data. More...

Functions
template<typename T >
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 >
T	AtomicNot (T *pointer, vtkm::MemoryOrder order=vtkm::MemoryOrder::SequentiallyConsistent)
	Atomic function to NOT bits to a shared memory location. More...

template<typename T >
bool	AtomicCompareExchange (T shared, T expected, T desired, vtkm::MemoryOrder order=vtkm::MemoryOrder::SequentiallyConsistent)
	Atomic function that replaces a value given a condition. More...

std::ostream &	operator<< (std::ostream &stream, const vtkm::Bounds &bounds)
	Helper function for printing bounds during testing. More...

const char *	ErrorString (vtkm::ErrorCode code) noexcept
	Convert a `vtkm::ErrorCode` into a human-readable string. More...

template<typename CoordType , bool IsTwoSided>
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::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::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::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::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)

template<typename Functor , typename... Ts, typename... Args>
void	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. More...

template<typename Functor , typename... Args>
void	ListForEach (Functor &&, vtkm::ListEmpty, Args &&...)

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

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

vtkm::UInt64	FloatDistance (vtkm::Float64 x, vtkm::Float64 y)
	Computes the number of representables between two floating point numbers. More...

vtkm::UInt64	FloatDistance (vtkm::Float32 x, vtkm::Float32 y)
	Computes the number of representables between two floating point numbers. More...

template<typename T >
T	DifferenceOfProducts (T a, T b, T c, T d)

template<typename T >
vtkm::Vec< T, 2 >	QuadraticRoots (T a, T b, T c)
	Solves ax² + bx + c = 0. More...

vtkm::Int32	FindFirstSetBit (vtkm::UInt32 word)
	Bitwise operations. More...

vtkm::Int32	FindFirstSetBit (vtkm::UInt64 word)
	Find the first set bit in word, and return its position (1-64). More...

vtkm::Int32	CountSetBits (vtkm::UInt32 word)
	Count the total number of bits set in word. More...

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::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::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>
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>
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::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::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::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::Matrix< T, Size, Size >	MatrixIdentity ()
	Returns the identity matrix. More...

template<typename T , vtkm::IdComponent Size>
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::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::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::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>
T	MatrixDeterminant (const vtkm::Matrix< T, Size, Size > &A)
	Compute the determinant of a matrix. More...

template<typename T >
T	MatrixDeterminant (const vtkm::Matrix< T, 1, 1 > &A)

template<typename T >
T	MatrixDeterminant (const vtkm::Matrix< T, 2, 2 > &A)

template<typename T >
T	MatrixDeterminant (const vtkm::Matrix< T, 3, 3 > &A)

template<typename T , vtkm::IdComponent NumRow, vtkm::IdComponent NumCol>
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>
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>
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 >
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::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::Pair< typename std::decay< T1 >::type, typename std::decay< T2 >::type >	make_Pair (T1 &&v1, T2 &&v2)

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

std::ostream &	operator<< (std::ostream &stream, const vtkm::Range &range)
	Helper function for printing ranges during testing. More...

std::ostream &	operator<< (std::ostream &stream, const vtkm::RangeId3 &range)
	Helper function for printing range during testing. More...

template<typename T >
void	Swap (T &a, T &b)
	Performs a swap operation. Safe to call from cuda code. More...

template<typename T >
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::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::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::Matrix< T, 4, 4 >	Transform3DScale (const T &scaleX, const T &scaleY, const T &scaleZ)
	Returns a scale matrix. More...

template<typename T >
vtkm::Matrix< T, 4, 4 >	Transform3DScale (const vtkm::Vec< T, 3 > &scaleVec)
	Returns a scale matrix. More...

template<typename T >
vtkm::Matrix< T, 4, 4 >	Transform3DScale (const T &scale)
	Returns a scale matrix. More...

template<typename T >
vtkm::Matrix< T, 4, 4 >	Transform3DTranslate (const T &x, const T &y, const T &z)
	Returns a translation matrix. More...

template<typename T >
vtkm::Matrix< T, 4, 4 >	Transform3DTranslate (const vtkm::Vec< T, 3 > &v)

template<typename T >
vtkm::Matrix< T, 4, 4 >	Transform3DRotate (T angleDegrees, const vtkm::Vec< T, 3 > &axisOfRotation)
	Returns a rotation matrix. More...

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

template<typename T >
vtkm::Matrix< T, 4, 4 >	Transform3DRotateX (T angleDegrees)
	Returns a rotation matrix. More...

template<typename T >
vtkm::Matrix< T, 4, 4 >	Transform3DRotateY (T angleDegrees)
	Returns a rotation matrix. More...

template<typename T >
vtkm::Matrix< T, 4, 4 >	Transform3DRotateZ (T angleDegrees)
	Returns a rotation matrix. More...

template<typename T , typename... Ts>
constexpr 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>
T	ReduceSum (const vtkm::Vec< T, Size > &a)

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

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

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

template<typename T , vtkm::IdComponent Size>
T	ReduceProduct (const vtkm::Vec< T, Size > &a)

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

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

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

template<typename T , vtkm::IdComponent Size>
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 >
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>
std::ostream &	operator<< (std::ostream &stream, const vtkm::VecAxisAlignedPointCoordinates< NumDimensions > &vec)
	Helper function for printing out vectors during testing. More...

template<typename T >
vtkm::VecFlat< T >	make_VecFlat (const T &vec)
	Converts a `Vec`-like object to a `VecFlat`. More...

template<typename IndexVecType , typename PortalType >
VecFromPortalPermute< IndexVecType, PortalType >	make_VecFromPortalPermute (const IndexVecType *index, const PortalType &portal)

template<typename IndexVecType , typename PortalType >
VecFromPortalPermute< IndexVecType, const PortalType * >	make_VecFromPortalPermute (const IndexVecType index, const PortalType const portal)

template<typename ValueType , typename WeightType >
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::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::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 >
detail::FloatingPointReturnType< T >::Type	MagnitudeSquared (const T &x)
	Returns the square of the magnitude of a vector. More...

template<typename T >
detail::FloatingPointReturnType< T >::Type	Magnitude (const T &x)
	Returns the magnitude of a vector. More...

template<typename T >
detail::FloatingPointReturnType< T >::Type	RMagnitude (const T &x)
	Returns the reciprocal magnitude of a vector. More...

template<typename T >
T	Normal (const T &x)
	Returns a normalized version of the given vector. More...

template<typename T >
void	Normalize (T &x)
	Changes a vector to be normal. More...

template<typename T >
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::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::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>
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>
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))
	Convert a set of vectors to an orthonormal basis. More...

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>
auto	Get (const vtkm::Tuple< Ts... > &tuple)
	Retrieve the object from a `vtkm::Tuple` at the given index. More...

template<vtkm::IdComponent Index, typename... Ts>
auto	Get (vtkm::Tuple< Ts... > &tuple)
	Retrieve the object from a `vtkm::Tuple` at the given index. More...

template<std::size_t Index, typename... Ts>
auto	get (const vtkm::Tuple< Ts... > &tuple) -> decltype(vtkm::Get< static_cast< vtkm::IdComponent >(Index)>(tuple))
	Compatible with `std::get` for `vtkm::Tuple`. More...

template<std::size_t Index, typename... Ts>
auto	get (vtkm::Tuple< Ts... > &tuple) -> decltype(vtkm::Get< static_cast< vtkm::IdComponent >(Index)>(tuple))
	Compatible with `std::get` for `vtkm::Tuple`. More...

template<typename... Ts>
auto	MakeTuple (Ts &&... args) -> vtkm::Tuple< typename std::decay< Ts >::type... >
	Creates a new `vtkm::Tuple` with the given types. More...

template<typename... Ts>
auto	make_tuple (Ts &&... args) -> decltype(vtkm::MakeTuple(std::forward< Ts >(args)...))
	Compatible with `std::make_tuple` for `vtkm::Tuple`. More...

template<typename... Ts, typename Function , typename... Args>
auto	Apply (const vtkm::Tuple< Ts... > &tuple, Function &&f, Args &&... args) -> decltype(tuple.Apply(std::forward< Function >(f), std::forward< Args >(args)...))
	Call a function with the values of a `vtkm::Tuple` as arguments. More...

template<typename... Ts, typename Function , typename... Args>
auto	Apply (vtkm::Tuple< Ts... > &tuple, Function &&f, Args &&... args) -> decltype(tuple.Apply(std::forward< Function >(f), std::forward< Args >(args)...))
	Call a function with the values of a `vtkm::Tuple` as arguments. More...

template<typename... Ts, typename Function >
void	ForEach (const vtkm::Tuple< Ts... > &tuple, Function &&f)
	Call a function with each value of the given tuple. More...

template<typename... Ts, typename Function >
void	ForEach (vtkm::Tuple< Ts... > &tuple, Function &&f)
	Call a function with each value of the given tuple. More...

template<typename TupleType , typename Function >
auto	Transform (const TupleType &&tuple, Function &&f) -> decltype(Apply(tuple, detail::TupleTransformFunctor(), std::forward< Function >(f)))
	Construct a new `vtkm::Tuple` by applying a function to each value. More...

template<typename TupleType , typename Function >
auto	Transform (TupleType &&tuple, Function &&f) -> decltype(Apply(tuple, detail::TupleTransformFunctor(), std::forward< Function >(f)))
	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.

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" (which can be changed with the SetOutputFieldName method).

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

Base type to use for 32-bit floating-point numbers.

◆ Float64

using vtkm::Float64 = typedef double

Base type to use for 64-bit floating-point numbers.

◆ 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 std::true_type

◆ Id

using vtkm::Id = typedef vtkm::Int64

Base type to use to index arrays.

This type represents an ID (index into arrays). It should be used whenever indexing data that could grow arbitrarily large.

◆ 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

Base type to use to index small lists.

This type 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

Base type to use for 16-bit signed integer numbers.

◆ Int32

using vtkm::Int32 = typedef int32_t

Base type to use for 32-bit signed integer numbers.

◆ Int64

using vtkm::Int64 = typedef signed long long

Base type to use for 64-bit signed integer numbers.

◆ Int8

using vtkm::Int8 = typedef int8_t

Base type to use for 8-bit signed integer numbers.

◆ 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 convenience type 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 type for a list that represents holding all potential values.

Note: This list cannot 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, becomes 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 long , unsigned long > >

◆ 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

Base type to use for 16-bit unsigned integer numbers.

◆ UInt32

using vtkm::UInt32 = typedef uint32_t

Base type to use for 32-bit unsigned integer numbers.

◆ UInt64

using vtkm::UInt64 = typedef unsigned long long

Base type to use for 64-bit signed integer numbers.

◆ UInt8

using vtkm::UInt8 = typedef uint8_t

Base type to use for 8-bit unsigned integer numbers.

◆ 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::UInt64, 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::UInt64, 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::UInt64, 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	Placeholder for empty or invalid cells.
CELL_SHAPE_VERTEX	Vertex cells of a single point.
CELL_SHAPE_LINE	A line cell connecting two points.
CELL_SHAPE_POLY_LINE	A sequence of line segments. A polyline has 2 or more points, and the points are connected in order by line segments forming a piecewise linear curve.
CELL_SHAPE_TRIANGLE	A triangle.
CELL_SHAPE_POLYGON	A general polygon shape. All polygons have points ordered in counterclockwise order around the front side. Some operations may be invalid if the polygon is not a convex shape.
CELL_SHAPE_QUAD	A four-sided polygon.
CELL_SHAPE_TETRA	A tetrahedron. A tetrahedron is a 3D polyhedron with 4 points and 4 triangular faces.
CELL_SHAPE_HEXAHEDRON	A hexahedron.
CELL_SHAPE_WEDGE	A wedge. Wedges are simple prisms that can be formed by extruding a triangle. They have 2 triangular faces and 3 quadrilateral faces.
CELL_SHAPE_PYRAMID	A pyramid with a quadrilateral base and four triangular faces.0.
NUMBER_OF_CELL_SHAPES

◆ ColorSpace

enum vtkm::ColorSpace

strong

Enumerator
RGB
HSV
HSVWrap
Lab
Diverging

◆ CopyFlag

enum vtkm::CopyFlag

strong

Identifier used to specify whether a function should deep copy data.

Enumerator
Off
On

◆ ErrorCode

enum vtkm::ErrorCode

strong

Identifies whether an operation was successful or what type of error it had.

Most errors in VTK-m are reported by throwing an exception. However, there are some places, most notably the execution environment, where it is not possible to throw an exception. For those cases, it is typical for a function to return an ErrorCode identifier. The calling code can check to see if the operation was a success or what kind of error was encountered otherwise.

Use the vtkm::ErrorString() function to get a descriptive string of the error type.

Enumerator
Success	A successful operation. This code is returned when the operation was successful. Calling code should check the error code against this identifier when checking the status.
InvalidShapeId	A unknown shape identifier was encountered. All cell shapes must be listed in `vtkm::CellShapeIdEnum`.
InvalidNumberOfPoints	The wrong number of points was provided for a given cell type. For example, if a triangle has 4 points associated with it, you are likely to get this error.
InvalidCellMetric	A cell metric was requested for a cell that does not support that metric.
WrongShapeIdForTagType	This is an internal error from the lightweight cell library.
InvalidPointId	A bad point identifier was detected while operating on a cell.
InvalidEdgeId	A bad edge identifier was detected while operating on a cell.
InvalidFaceId	A bad face identifier was detected while operating on a cell.
SolutionDidNotConverge	An iterative operation did not find an appropriate solution. This error code might be returned with some results of an iterative solution. However, solution did not appear to resolve, so the results might not be accurate.
MatrixFactorizationFailed	A solution was not found for a linear system. Some VTK-m computations use linear algebra to solve a system of equations. If the equations does not give a valid result, this error can be returned.
DegenerateCellDetected	An operation detected a degenerate cell. A degenerate cell has two or more vertices combined into one, which changes the structure of the cell. For example, if 2 vertices of a tetrahedron are at the same point, the cell degenerates to a triangle. Degenerate cells have the potential to interfere with some computations on cells.
MalformedCellDetected	An operation detected on a malformed cell. Most cell shapes have some assumptions about their geometry (e.g. not self intersecting). If an operation detects an expected behavior is violated, this error is returned. (Note that `vtkm::DegenerateCellDetected` has its own error coe.)
OperationOnEmptyCell	An operation was attempted on a cell with an empty shape. There is a special "empty" cell shape type (`vtkm::CellShapeTagEmpty`) that can be used as a placeholder for a cell with no information. Math operations such as interpolation cannot be performed on empty cells, and attempting to do so will result in this error.
CellNotFound	A cell matching some given criteria could not be found. This error code is most often used in a cell locator where no cell in the given region could be found.
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.

Compute the hyperbolic arc cosine of x.

◆ Apply() [1/2]

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

auto vtkm::Apply	(	const vtkm::Tuple< Ts... > &	tuple,
		Function &&	f,
		Args &&...	args
	)		-> decltype(tuple.Apply(std::forward<Function>(f), std::forward<Args>(args)...))

Call a function with the values of a vtkm::Tuple as arguments.

If a vtkm::Tuple<A, B, C> is given with values a, b, and c, then f will be called as f(a, b, c).

Additional arguments can optionally be given to vtkm::Apply(). These arguments will be added to the beginning of the arguments to the function.

The returned value of the function (if any) will be returned from vtkm::Apply().

◆ Apply() [2/2]

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

auto vtkm::Apply	(	vtkm::Tuple< Ts... > &	tuple,
		Function &&	f,
		Args &&...	args
	)		-> decltype(tuple.Apply(std::forward<Function>(f), std::forward<Args>(args)...))

Call a function with the values of a vtkm::Tuple as arguments.

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

inline

Compute the hyperbolic arc tangent of x.

◆ AtomicAdd() [1/2]

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

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 >

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 >

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 >

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 >

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 >

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 >

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 >

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 >

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 >

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 >

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 >

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 >

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

inline

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

inline

Count the total number of bits set in word.

◆ Cross()

template<typename T >

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.

If VTK-m is compiled with FMA support, it uses Kahan's difference of products algorithm to achieve a maximum error of 1.5 ulps in each component.

◆ DifferenceOfProducts()

template<typename T >

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

inline

◆ ErrorString()

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

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

inline

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

◆ Floor() [2/2]

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

inline

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

◆ ForEach() [1/2]

template<typename... Ts, typename Function >

void vtkm::ForEach	(	const vtkm::Tuple< Ts... > &	tuple,
		Function &&	f
	)

Call a function with each value of the given tuple.

The function calls will be done in the order of the values in the vtkm::Tuple.

◆ ForEach() [2/2]

template<typename... Ts, typename Function >

void vtkm::ForEach	(	vtkm::Tuple< Ts... > &	tuple,
		Function &&	f
	)

Call a function with each value of the given tuple.

The function calls will be done in the order of the values in the vtkm::Tuple.

◆ Frexp() [1/2]

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

inline

Decompose floating poing value

◆ Frexp() [2/2]

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

inline

Decompose floating poing value

◆ Get() [1/2]

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

auto vtkm::Get ( const vtkm::Tuple< Ts... > & tuple )

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

◆ get() [1/2]

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

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>

auto vtkm::Get ( vtkm::Tuple< Ts... > & tuple )

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

◆ get() [2/2]

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

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::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::Float32 vtkm::Ldexp	(	vtkm::Float32	x,
		vtkm::Int32	exponent
	)

inline

◆ Ldexp() [2/2]

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

inline

◆ Lerp() [1/3]

template<typename ValueType , typename WeightType >

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

inline

Returns the linear interpolation of two values based on weight.

Lerp returns the linear interpolation of two values based on a weight. If weight is outside [0,1] then Lerp extrapolates. If weight=0 then value0 is returned. If weight=1 then value1 is returned.

◆ Lerp() [2/3]

template<typename ValueType , vtkm::IdComponent N>

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::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>

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

◆ ListForEach() [2/2]

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

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

Computes the logarithm base 2 of x.

◆ LowerBound() [1/4]

template<typename PortalT , typename T >

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::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 >

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 >

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 >

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 >

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 magnitude, so you should use this function in place of Magnitude or RMagnitude when possible.

◆ make_CircleFrom3Points()

template<typename CoordType >

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::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::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::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::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>

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::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::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 >

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

inline

◆ make_VecFromPortalPermute() [2/2]

template<typename IndexVecType , typename PortalType >

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

inline

◆ MakeTuple()

template<typename... Ts>

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 >

T vtkm::MatrixDeterminant ( const vtkm::Matrix< T, 1, 1 > & A )

◆ MatrixDeterminant() [2/4]

template<typename T >

T vtkm::MatrixDeterminant ( const vtkm::Matrix< T, 2, 2 > & A )

◆ MatrixDeterminant() [3/4]

template<typename T >

T vtkm::MatrixDeterminant ( const vtkm::Matrix< T, 3, 3 > & A )

◆ MatrixDeterminant() [4/4]

template<typename T , vtkm::IdComponent Size>

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::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::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::Matrix<T, Size, Size> vtkm::MatrixIdentity ( )

Returns the identity matrix.

◆ MatrixIdentity() [2/2]

template<typename T , vtkm::IdComponent Size>

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::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::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::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::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>

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>

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::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 >

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.

Parameters

[in]	jacobianEvaluator	A functor whose operation takes a `vtkm::Vec` and returns a `vtkm::Matrix` containing the math function's Jacobian vector at that point.
[in]	functionEvaluator	A functor whose operation takes a `vtkm::Vec` and returns the evaluation of the math function at that point as another `vtkm::Vec`.
[in]	desiredFunctionOutput	The desired output of the function.
[in]	initialGuess	The initial guess to search from. If not specified, the origin is used.
[in]	convergeDifference	The convergence distance. If the iterative method changes all values less than this amount. Once all values change less, it considers the solution found. If not specified, set to 0.001.
[in]	maxIterations	The maximum amount of iterations to run before giving up and returning the best solution found. If not specified, set to 10.

Returns: A vtkm::NewtonsMethodResult containing the best found result and state about its validity.

◆ Normal()

template<typename T >

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 >

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>

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::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]

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

inline

◆ operator<<() [2/8]

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>

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 >

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]

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

inline

Helper function for printing ranges during testing.

◆ operator<<() [6/8]

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>

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>

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>

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

◆ Orthonormalize()

template<typename T , int N>

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)`
	)

Convert a set of vectors to an orthonormal basis.

This function performs Gram-Schmidt orthonormalization for 3-D vectors. 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.

See https://en.wikipedia.org/wiki/Gram%E2%80%93Schmidt_process for details.

◆ Project()

template<typename T , int N>

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>

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::Vec<T, 2> vtkm::QuadraticRoots	(	T	a,
		T	b,
		T	c
	)

◆ SolveLinearSystem()

template<typename T , vtkm::IdComponent Size>

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::Float32 vtkm::Sqrt ( vtkm::Float32 x )

inline

Compute the square root of x. On some hardware it is faster to find the reciprocal square root, so RSqrt should be used if you actually plan to divide by the square root.

◆ Sqrt() [2/2]

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

inline

Compute the square root of x. On some hardware it is faster to find the reciprocal square root, so RSqrt should be used if you actually plan to divide by the square root.

◆ Swap()

template<typename T >

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

inline

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

◆ Tan() [1/2]

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

inline

Compute the tangent of x.

◆ Tan() [2/2]

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

inline

Compute the tangent of x.

◆ TanH() [1/2]

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

inline

Compute the hyperbolic tangent of x.

◆ TanH() [2/2]

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

inline

Compute the hyperbolic tangent of x.

◆ Transform() [1/2]

template<typename TupleType , typename Function >

auto vtkm::Transform	(	const TupleType &&	tuple,
		Function &&	f
	)		-> decltype(Apply(tuple, detail::TupleTransformFunctor(), std::forward<Function>(f)))

Construct a new vtkm::Tuple by applying a function to each value.

The vtkm::Transform function builds a new vtkm::Tuple by calling a function or functor on each of the items in the given tuple. The return value is placed in the corresponding part of the resulting Tuple, and the type is automatically created from the return type of the function.

◆ Transform() [2/2]

template<typename TupleType , typename Function >

auto vtkm::Transform	(	TupleType &&	tuple,
		Function &&	f
	)		-> decltype(Apply(tuple, detail::TupleTransformFunctor(), std::forward<Function>(f)))

Get the size of a tuple.

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

◆ Transform3DPoint()

template<typename T >

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::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::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::Matrix<T, 4, 4> vtkm::Transform3DRotate	(	T	angleDegrees,
		T	x,
		T	y,
		T	z
	)

◆ Transform3DTranslate() [1/2]

template<typename T >

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::Matrix<T, 4, 4> vtkm::Transform3DTranslate ( const vtkm::Vec< T, 3 > & v )

◆ Transform3DVector()

template<typename T >

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::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 vtkm::Normal() or vtkm::Normalize() function.

◆ UpperBound() [1/4]

template<typename PortalT , typename T >

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::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 >

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 >

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.

Namespaces

Classes

Typedefs

Enumerations

Functions

Detailed Description

Typedef Documentation

◆ AtomicTypePreferred

◆ AtomicTypesSupported

◆ BufferSizeType

◆ Circle

◆ Circle2d

◆ Float32

◆ Float64

◆ FloatDefault

◆ HashType

◆ HasVecTraits

◆ Id

◆ Id2

◆ Id3

◆ Id4

◆ IdComponent

◆ IdComponent2

◆ IdComponent3

◆ IdComponent4

◆ Int16

◆ Int32

◆ Int64

◆ Int8

◆ Line

◆ Line2

◆ Line2d

◆ Line3

◆ Line3d

◆ LineSegment2

◆ LineSegment2d

◆ LineSegment3

◆ LineSegment3d

◆ ListAll

◆ ListAny

◆ ListAppend

◆ ListApply

◆ ListAt

◆ ListCross

◆ ListEmpty

◆ ListFill

◆ ListHas

◆ ListIndexOf

◆ ListIntersect

◆ ListReduce

◆ ListRemoveIf

◆ ListSize

◆ ListTransform

◆ ListUniversal

◆ Plane3d

◆ Ray2

◆ Ray2d

◆ Ray3

◆ Ray3d

◆ Sphere2

◆ Sphere2d

◆ Sphere3

◆ Sphere3d

◆ tuple_element_t

◆ tuple_size

◆ TupleElement

◆ TupleSize

◆ TypeListAll

◆ TypeListBaseC

◆ TypeListCommon

◆ TypeListField

◆ TypeListFieldScalar

◆ TypeListFieldVec2

◆ TypeListFieldVec3

◆ TypeListFieldVec4

◆ TypeListFloatVec

◆ TypeListId

◆ TypeListId2

◆ TypeListId3

◆ TypeListId4