viskores Namespace Reference

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

Namespaces
	cont
	Viskores Control Environment.
	exec
	Viskores Execution Environment.
	filter
	Viskores Filters.
	interop
	Viskores OpenGL Interoperability.
	io
	Viskores File input and output classes.
	random
	rendering
	Viskores Rendering.
	source
	Viskores Input source such as Wavelet.
	testing
	Internal testing classes.
	tmp
	worklet
	Viskores 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< viskores::CELL_SHAPE_EMPTY >
struct	CellShapeIdToTag< viskores::CELL_SHAPE_HEXAHEDRON >
struct	CellShapeIdToTag< viskores::CELL_SHAPE_LINE >
struct	CellShapeIdToTag< viskores::CELL_SHAPE_POLY_LINE >
struct	CellShapeIdToTag< viskores::CELL_SHAPE_POLYGON >
struct	CellShapeIdToTag< viskores::CELL_SHAPE_PYRAMID >
struct	CellShapeIdToTag< viskores::CELL_SHAPE_QUAD >
struct	CellShapeIdToTag< viskores::CELL_SHAPE_TETRA >
struct	CellShapeIdToTag< viskores::CELL_SHAPE_TRIANGLE >
struct	CellShapeIdToTag< viskores::CELL_SHAPE_VERTEX >
struct	CellShapeIdToTag< viskores::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
	viskores::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< viskores::CellShapeTagEmpty >
struct	CellTraits< viskores::CellShapeTagHexahedron >
struct	CellTraits< viskores::CellShapeTagLine >
struct	CellTraits< viskores::CellShapeTagPolygon >
struct	CellTraits< viskores::CellShapeTagPolyLine >
struct	CellTraits< viskores::CellShapeTagPyramid >
struct	CellTraits< viskores::CellShapeTagQuad >
struct	CellTraits< viskores::CellShapeTagTetra >
struct	CellTraits< viskores::CellShapeTagTriangle >
struct	CellTraits< viskores::CellShapeTagVertex >
struct	CellTraits< viskores::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 viskores::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 viskores::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 viskores::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
	Viskores 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 viskores::Tuple. More...
class	TypeTraits
	The TypeTraits class provides helpful compile-time information about the basic types used in Viskores (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< viskores::internal::ArrayPortalValueReference< PortalType > >
struct	TypeTraits< viskores::internal::RecombineVec< PortalType > >
struct	TypeTraits< viskores::Matrix< T, NumRow, NumCol > >
struct	TypeTraits< viskores::Pair< T, U > >
	Traits for Pair types. More...
struct	TypeTraits< viskores::Vec< T, Size > >
	Traits for Vec types. More...
struct	TypeTraits< viskores::VecAxisAlignedPointCoordinates< NumDimensions > >
struct	TypeTraits< viskores::VecC< T > >
	Traits for VecC types. More...
struct	TypeTraits< viskores::VecCConst< T > >
	Traits for VecCConst types. More...
struct	TypeTraits< viskores::VecFlat< T > >
struct	TypeTraits< viskores::VecFromPortal< PortalType > >
struct	TypeTraits< viskores::VecFromPortalPermute< IndexVecType, PortalType > >
struct	TypeTraits< viskores::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< viskores::Bounds >
struct	VecTraits< viskores::internal::ArrayPortalValueReference< PortalType > >
struct	VecTraits< viskores::internal::RecombineVec< PortalType > >
struct	VecTraits< viskores::Matrix< T, NumRow, NumCol > >
	A matrix has vector traits to implement component-wise operations. More...
struct	VecTraits< viskores::Range >
struct	VecTraits< viskores::Vec< T, Size > >
struct	VecTraits< viskores::VecAxisAlignedPointCoordinates< NumDimensions > >
struct	VecTraits< viskores::VecC< T > >
struct	VecTraits< viskores::VecCConst< T > >
struct	VecTraits< viskores::VecFlat< T > >
struct	VecTraits< viskores::VecFromPortal< PortalType > >
struct	VecTraits< viskores::VecFromPortalPermute< IndexVecType, PortalType > >
struct	VecTraits< viskores::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 = viskores::UInt32
	The preferred type to use for atomic operations. More...
using	AtomicTypesSupported = viskores::List< viskores::UInt32, viskores::UInt64 >
	A list of types that can be used with atomic operations. More...
using	BufferSizeType = viskores::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< viskores::FloatDefault >
using	Ray3d = Ray3< viskores::FloatDefault >
using	Line2d = Line2< viskores::FloatDefault >
using	Line3d = Line3< viskores::FloatDefault >
using	LineSegment2d = LineSegment2< viskores::FloatDefault >
using	LineSegment3d = LineSegment3< viskores::FloatDefault >
using	Plane3d = Plane< viskores::FloatDefault >
using	Circle2d = Circle< viskores::FloatDefault >
using	Sphere2d = Sphere2< viskores::FloatDefault >
using	Sphere3d = Sphere3< viskores::FloatDefault >
using	HashType = viskores::UInt32
using	ListEmpty = viskores::List<>
	A convenience type for an empty list. More...
using	ListUniversal = viskores::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 , viskores::IdComponent N>
using	ListFill = typename detail::ListFillImpl< T, N >::type
	Returns a list filled with N copies of type T. More...
template<typename List , viskores::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 = viskores::internal::meta::Identity>
using	ListAll = viskores::ListReduce< viskores::ListTransform< List, Predicate >, viskores::internal::meta::And, std::true_type >
	Determines whether all the types in the list are "true.". More...
template<typename List , template< typename > class Predicate = viskores::internal::meta::Identity>
using	ListAny = viskores::ListReduce< viskores::ListTransform< List, Predicate >, viskores::internal::meta::Or, std::false_type >
	Determines whether any of the types in the list are "true.". More...
using	TypeListId = viskores::List< viskores::Id >
	A list containing the type viskores::Id. More...
using	TypeListId2 = viskores::List< viskores::Id2 >
	A list containing the type viskores::Id2. More...
using	TypeListId3 = viskores::List< viskores::Id3 >
	A list containing the type viskores::Id3. More...
using	TypeListId4 = viskores::List< viskores::Id4 >
	A list containing the type viskores::Id4. More...
using	TypeListIdComponent = viskores::List< viskores::IdComponent >
	A list containing the type viskores::IdComponent. More...
using	TypeListIndex = viskores::List< viskores::Id, viskores::Id2, viskores::Id3 >
	A list containing types used to index arrays. More...
using	TypeListFieldScalar = viskores::List< viskores::Float32, viskores::Float64 >
	A list containing types used for scalar fields. More...
using	TypeListFieldVec2 = viskores::List< viskores::Vec2f_32, viskores::Vec2f_64 >
	A list containing types for values for fields with two dimensional vectors. More...
using	TypeListFieldVec3 = viskores::List< viskores::Vec3f_32, viskores::Vec3f_64 >
	A list containing types for values for fields with three dimensional vectors. More...
using	TypeListFieldVec4 = viskores::List< viskores::Vec4f_32, viskores::Vec4f_64 >
	A list containing types for values for fields with four dimensional vectors. More...
using	TypeListFloatVec = viskores::List< viskores::Vec2f_32, viskores::Vec2f_64, viskores::Vec3f_32, viskores::Vec3f_64, viskores::Vec4f_32, viskores::Vec4f_64 >
	A list containing common types for floating-point vectors. More...
using	TypeListField = viskores::List< viskores::Float32, viskores::Float64, viskores::Vec2f_32, viskores::Vec2f_64, viskores::Vec3f_32, viskores::Vec3f_64, viskores::Vec4f_32, viskores::Vec4f_64 >
	A list containing common types for values in fields. More...
using	TypeListScalarAll = viskores::List< viskores::Int8, viskores::UInt8, viskores::Int16, viskores::UInt16, viskores::Int32, viskores::UInt32, viskores::Int64, viskores::UInt64, viskores::Float32, viskores::Float64 >
	A list of all scalars defined in viskores/Types.h. More...
using	TypeListBaseC = viskores::ListAppend< viskores::TypeListScalarAll, viskores::List< bool, char, signed long, unsigned long > >
using	TypeListVecCommon = viskores::List< viskores::Vec2ui_8, viskores::Vec2i_32, viskores::Vec2i_64, viskores::Vec2f_32, viskores::Vec2f_64, viskores::Vec3ui_8, viskores::Vec3i_32, viskores::Vec3i_64, viskores::Vec3f_32, viskores::Vec3f_64, viskores::Vec4ui_8, viskores::Vec4i_32, viskores::Vec4i_64, viskores::Vec4f_32, viskores::Vec4f_64 >
	A list of the most commonly use Vec classes. More...
using	TypeListVecAll = viskores::ListAppend< viskores::TypeListVecCommon, viskores::internal::TypeListVecUncommon >
	A list of all vector classes with standard types as components and lengths between 2 and 4. More...
using	TypeListAll = viskores::ListAppend< viskores::TypeListScalarAll, viskores::TypeListVecAll >
	A list of all basic types listed in viskores/Types.h. More...
using	TypeListCommon = viskores::List< viskores::UInt8, viskores::Int32, viskores::Int64, viskores::Float32, viskores::Float64, viskores::Vec3f_32, viskores::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 = viskores::Int32
	Base type to use to index small lists. More...
using	WordTypeDefault = viskores::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 = viskores::Int64
	Base type to use to index arrays. More...
using	FloatDefault = viskores::Float32
	The floating point type to use when no other precision is specified. More...
using	Id2 = viskores::Vec< viskores::Id, 2 >
	Id2 corresponds to a 2-dimensional index. More...
using	IdComponent2 = viskores::Vec< viskores::IdComponent, 2 >
	IdComponent2 corresponds to an index to a local (small) 2-d array or equivalent. More...
using	Vec2f = viskores::Vec< viskores::FloatDefault, 2 >
	Vec2f corresponds to a 2-dimensional vector of floating point values. More...
using	Vec2f_32 = viskores::Vec< viskores::Float32, 2 >
	Vec2f_32 corresponds to a 2-dimensional vector of 32-bit floating point values. More...
using	Vec2f_64 = viskores::Vec< viskores::Float64, 2 >
	Vec2f_64 corresponds to a 2-dimensional vector of 64-bit floating point values. More...
using	Vec2i = viskores::Vec< viskores::Id, 2 >
	Vec2i corresponds to a 2-dimensional vector of integer values. More...
using	Vec2i_8 = viskores::Vec< viskores::Int8, 2 >
	Vec2i_8 corresponds to a 2-dimensional vector of 8-bit integer values. More...
using	Vec2i_16 = viskores::Vec< viskores::Int16, 2 >
	Vec2i_16 corresponds to a 2-dimensional vector of 16-bit integer values. More...
using	Vec2i_32 = viskores::Vec< viskores::Int32, 2 >
	Vec2i_32 corresponds to a 2-dimensional vector of 32-bit integer values. More...
using	Vec2i_64 = viskores::Vec< viskores::Int64, 2 >
	Vec2i_64 corresponds to a 2-dimensional vector of 64-bit integer values. More...
using	Vec2ui = viskores::Vec< viskores::UInt64, 2 >
	Vec2ui corresponds to a 2-dimensional vector of unsigned integer values. More...
using	Vec2ui_8 = viskores::Vec< viskores::UInt8, 2 >
	Vec2ui_8 corresponds to a 2-dimensional vector of 8-bit unsigned integer values. More...
using	Vec2ui_16 = viskores::Vec< viskores::UInt16, 2 >
	Vec2ui_16 corresponds to a 2-dimensional vector of 16-bit unsigned integer values. More...
using	Vec2ui_32 = viskores::Vec< viskores::UInt32, 2 >
	Vec2ui_32 corresponds to a 2-dimensional vector of 32-bit unsigned integer values. More...
using	Vec2ui_64 = viskores::Vec< viskores::UInt64, 2 >
	Vec2ui_64 corresponds to a 2-dimensional vector of 64-bit unsigned integer values. More...
using	Id3 = viskores::Vec< viskores::Id, 3 >
	Id3 corresponds to a 3-dimensional index for 3d arrays. More...
using	IdComponent3 = viskores::Vec< viskores::IdComponent, 3 >
	IdComponent2 corresponds to an index to a local (small) 3-d array or equivalent. More...
using	Vec3f = viskores::Vec< viskores::FloatDefault, 3 >
	Vec3f corresponds to a 3-dimensional vector of floating point values. More...
using	Vec3f_32 = viskores::Vec< viskores::Float32, 3 >
	Vec3f_32 corresponds to a 3-dimensional vector of 32-bit floating point values. More...
using	Vec3f_64 = viskores::Vec< viskores::Float64, 3 >
	Vec3f_64 corresponds to a 3-dimensional vector of 64-bit floating point values. More...
using	Vec3i = viskores::Vec< viskores::Id, 3 >
	Vec3i corresponds to a 3-dimensional vector of integer values. More...
using	Vec3i_8 = viskores::Vec< viskores::Int8, 3 >
	Vec3i_8 corresponds to a 3-dimensional vector of 8-bit integer values. More...
using	Vec3i_16 = viskores::Vec< viskores::Int16, 3 >
	Vec3i_16 corresponds to a 3-dimensional vector of 16-bit integer values. More...
using	Vec3i_32 = viskores::Vec< viskores::Int32, 3 >
	Vec3i_32 corresponds to a 3-dimensional vector of 32-bit integer values. More...
using	Vec3i_64 = viskores::Vec< viskores::Int64, 3 >
	Vec3i_64 corresponds to a 3-dimensional vector of 64-bit integer values. More...
using	Vec3ui = viskores::Vec< viskores::UInt64, 3 >
	Vec3ui corresponds to a 3-dimensional vector of unsigned integer values. More...
using	Vec3ui_8 = viskores::Vec< viskores::UInt8, 3 >
	Vec3ui_8 corresponds to a 3-dimensional vector of 8-bit unsigned integer values. More...
using	Vec3ui_16 = viskores::Vec< viskores::UInt16, 3 >
	Vec3ui_16 corresponds to a 3-dimensional vector of 16-bit unsigned integer values. More...
using	Vec3ui_32 = viskores::Vec< viskores::UInt32, 3 >
	Vec3ui_32 corresponds to a 3-dimensional vector of 32-bit unsigned integer values. More...
using	Vec3ui_64 = viskores::Vec< viskores::UInt64, 3 >
	Vec3ui_64 corresponds to a 3-dimensional vector of 64-bit unsigned integer values. More...
using	Id4 = viskores::Vec< viskores::Id, 4 >
	Id4 corresponds to a 4-dimensional index. More...
using	IdComponent4 = viskores::Vec< viskores::IdComponent, 4 >
	IdComponent4 corresponds to an index to a local (small) 4-d array or equivalent. More...
using	Vec4f = viskores::Vec< viskores::FloatDefault, 4 >
	Vec4f corresponds to a 4-dimensional vector of floating point values. More...
using	Vec4f_32 = viskores::Vec< viskores::Float32, 4 >
	Vec4f_32 corresponds to a 4-dimensional vector of 32-bit floating point values. More...
using	Vec4f_64 = viskores::Vec< viskores::Float64, 4 >
	Vec4f_64 corresponds to a 4-dimensional vector of 64-bit floating point values. More...
using	Vec4i = viskores::Vec< viskores::Id, 4 >
	Vec4i corresponds to a 4-dimensional vector of integer values. More...
using	Vec4i_8 = viskores::Vec< viskores::Int8, 4 >
	Vec4i_8 corresponds to a 4-dimensional vector of 8-bit integer values. More...
using	Vec4i_16 = viskores::Vec< viskores::Int16, 4 >
	Vec4i_16 corresponds to a 4-dimensional vector of 16-bit integer values. More...
using	Vec4i_32 = viskores::Vec< viskores::Int32, 4 >
	Vec4i_32 corresponds to a 4-dimensional vector of 32-bit integer values. More...
using	Vec4i_64 = viskores::Vec< viskores::Int64, 4 >
	Vec4i_64 corresponds to a 4-dimensional vector of 64-bit integer values. More...
using	Vec4ui = viskores::Vec< viskores::UInt64, 4 >
	Vec4ui corresponds to a 4-dimensional vector of unsigned integer values. More...
using	Vec4ui_8 = viskores::Vec< viskores::UInt8, 4 >
	Vec4ui_8 corresponds to a 4-dimensional vector of 8-bit unsigned integer values. More...
using	Vec4ui_16 = viskores::Vec< viskores::UInt16, 4 >
	Vec4ui_16 corresponds to a 4-dimensional vector of 16-bit unsigned integer values. More...
using	Vec4ui_32 = viskores::Vec< viskores::UInt32, 4 >
	Vec4ui_32 corresponds to a 4-dimensional vector of 32-bit unsigned integer values. More...
using	Vec4ui_64 = viskores::Vec< viskores::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, viskores::MemoryOrder order=viskores::MemoryOrder::Acquire)
	Atomic function to load a value from a shared memory location. More...
template<typename T >
T	AtomicNot (T *pointer, viskores::MemoryOrder order=viskores::MemoryOrder::SequentiallyConsistent)
	Atomic function to NOT bits to a shared memory location. More...
template<typename T >
bool	AtomicCompareExchange (T *shared, T *expected, T desired, viskores::MemoryOrder order=viskores::MemoryOrder::SequentiallyConsistent)
	Atomic function that replaces a value given a condition. More...
std::ostream &	operator<< (std::ostream &stream, const viskores::Bounds &bounds)
	Helper function for printing bounds during testing. More...
const char *	ErrorString (viskores::ErrorCode code) noexcept
	Convert a viskores::ErrorCode into a human-readable string. More...
template<typename CoordType , bool IsTwoSided>
viskores::Plane< CoordType >	make_PlaneFromPointAndLine (const viskores::Vec< CoordType, 3 > &point, const viskores::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 >
viskores::Plane< CoordType >	make_PlaneFromPointAndLineSegment (const viskores::Vec< CoordType, 3 > &point, const viskores::LineSegment3< CoordType > &segment, CoordType tol2=static_cast< CoordType >(1e-8f))
template<typename CoordType >
viskores::Circle< CoordType >	make_CircleFrom3Points (const typename viskores::Vec< CoordType, 2 > &p0, const typename viskores::Vec< CoordType, 2 > &p1, const typename viskores::Vec< CoordType, 2 > &p2, CoordType tol=static_cast< CoordType >(1e-6f))
	Construct a circle from 3 points. More...
template<typename CoordType >
viskores::Sphere< CoordType, 3 >	make_SphereFrom4Points (const viskores::Vec< CoordType, 3 > &a0, const viskores::Vec< CoordType, 3 > &a1, const viskores::Vec< CoordType, 3 > &a2, const viskores::Vec< CoordType, 3 > &a3, CoordType tol=static_cast< CoordType >(1e-6f))
	Construct a sphere from 4 points. More...
template<typename InVecType >
viskores::HashType	Hash (const InVecType &inVec)
	Returns a 32-bit hash on a group of integer-type values. More...
template<typename T , viskores::IdComponent Size>
VISKORES_EXEC_CONT std::enable_if<(std::is_floating_point< T >::value||std::is_signed< T >::value), viskores::Vec< T, Size > >::type	operator- (viskores::Vec< T, Size > x)
template<typename T >
VISKORES_EXEC_CONT std::enable_if<(std::is_floating_point< T >::value||std::is_signed< T >::value), viskores::Vec< T, 1 > >::type	operator- (const viskores::Vec< T, 1 > &x)
template<typename T >
VISKORES_EXEC_CONT std::enable_if<(std::is_floating_point< T >::value||std::is_signed< T >::value), viskores::Vec< T, 2 > >::type	operator- (const viskores::Vec< T, 2 > &x)
template<typename T >
VISKORES_EXEC_CONT std::enable_if<(std::is_floating_point< T >::value||std::is_signed< T >::value), viskores::Vec< T, 3 > >::type	operator- (const viskores::Vec< T, 3 > &x)
template<typename T >
VISKORES_EXEC_CONT std::enable_if<(std::is_floating_point< T >::value||std::is_signed< T >::value), viskores::Vec< T, 4 > >::type	operator- (const viskores::Vec< T, 4 > &x)
template<typename T , IdComponent Size>
VISKORES_EXEC_CONT viskores::Vec< T, Size >	operator+ (viskores::Vec< T, Size > a, const viskores::Vec< T, Size > &b)
template<typename T , IdComponent Size>
VISKORES_EXEC_CONT viskores::Vec< T, Size >	operator+ (viskores::Vec< T, Size > a, T scalar)
template<typename T , IdComponent Size>
VISKORES_EXEC_CONT viskores::Vec< T, Size >	operator+ (viskores::Vec< T, Size > a, viskores::Float64 scalar)
template<IdComponent Size>
VISKORES_EXEC_CONT viskores::Vec< viskores::Float64, Size >	operator+ (viskores::Vec< viskores::Float64, Size > a, viskores::Float64 scalar)
template<typename T , IdComponent Size>
VISKORES_EXEC_CONT viskores::Vec< T, Size >	operator+ (T scalar, viskores::Vec< T, Size > a)
template<typename T , IdComponent Size>
VISKORES_EXEC_CONT viskores::Vec< T, Size >	operator+ (viskores::Float64 scalar, viskores::Vec< T, Size > a)
template<IdComponent Size>
VISKORES_EXEC_CONT viskores::Vec< viskores::Float64, Size >	operator+ (viskores::Float64 scalar, viskores::Vec< viskores::Float64, Size > a)
template<typename T , IdComponent Size>
VISKORES_EXEC_CONT viskores::Vec< T, Size >	operator* (viskores::Vec< T, Size > a, const viskores::Vec< T, Size > &b)
template<typename T , IdComponent Size>
VISKORES_EXEC_CONT viskores::Vec< T, Size >	operator* (viskores::Vec< T, Size > a, T scalar)
template<typename T , IdComponent Size>
VISKORES_EXEC_CONT viskores::Vec< T, Size >	operator* (viskores::Vec< T, Size > a, viskores::Float64 scalar)
template<IdComponent Size>
VISKORES_EXEC_CONT viskores::Vec< viskores::Float64, Size >	operator* (viskores::Vec< viskores::Float64, Size > a, viskores::Float64 scalar)
template<typename T , IdComponent Size>
VISKORES_EXEC_CONT viskores::Vec< T, Size >	operator* (T scalar, viskores::Vec< T, Size > a)
template<typename T , IdComponent Size>
VISKORES_EXEC_CONT viskores::Vec< T, Size >	operator* (viskores::Float64 scalar, viskores::Vec< T, Size > a)
template<IdComponent Size>
VISKORES_EXEC_CONT viskores::Vec< viskores::Float64, Size >	operator* (viskores::Float64 scalar, viskores::Vec< viskores::Float64, Size > a)
template<typename T , IdComponent Size>
VISKORES_EXEC_CONT viskores::Vec< T, Size >	operator- (viskores::Vec< T, Size > a, const viskores::Vec< T, Size > &b)
template<typename T , IdComponent Size>
VISKORES_EXEC_CONT viskores::Vec< T, Size >	operator- (viskores::Vec< T, Size > a, T scalar)
template<typename T , IdComponent Size>
VISKORES_EXEC_CONT viskores::Vec< T, Size >	operator- (viskores::Vec< T, Size > a, viskores::Float64 scalar)
template<IdComponent Size>
VISKORES_EXEC_CONT viskores::Vec< viskores::Float64, Size >	operator- (viskores::Vec< viskores::Float64, Size > a, viskores::Float64 scalar)
template<typename T , IdComponent Size>
VISKORES_EXEC_CONT viskores::Vec< T, Size >	operator- (T scalar, viskores::Vec< T, Size > a)
template<typename T , IdComponent Size>
VISKORES_EXEC_CONT viskores::Vec< T, Size >	operator- (viskores::Float64 scalar, viskores::Vec< T, Size > a)
template<IdComponent Size>
VISKORES_EXEC_CONT viskores::Vec< viskores::Float64, Size >	operator- (viskores::Float64 scalar, viskores::Vec< viskores::Float64, Size > a)
template<typename T , IdComponent Size>
VISKORES_EXEC_CONT viskores::Vec< T, Size >	operator/ (viskores::Vec< T, Size > a, const viskores::Vec< T, Size > &b)
template<typename T , IdComponent Size>
VISKORES_EXEC_CONT viskores::Vec< T, Size >	operator/ (viskores::Vec< T, Size > a, T scalar)
template<typename T , IdComponent Size>
VISKORES_EXEC_CONT viskores::Vec< T, Size >	operator/ (viskores::Vec< T, Size > a, viskores::Float64 scalar)
template<IdComponent Size>
VISKORES_EXEC_CONT viskores::Vec< viskores::Float64, Size >	operator/ (viskores::Vec< viskores::Float64, Size > a, viskores::Float64 scalar)
template<typename T , IdComponent Size>
VISKORES_EXEC_CONT viskores::Vec< T, Size >	operator/ (T scalar, viskores::Vec< T, Size > a)
template<typename T , IdComponent Size>
VISKORES_EXEC_CONT viskores::Vec< T, Size >	operator/ (viskores::Float64 scalar, viskores::Vec< T, Size > a)
template<IdComponent Size>
VISKORES_EXEC_CONT viskores::Vec< viskores::Float64, Size >	operator/ (viskores::Float64 scalar, viskores::Vec< viskores::Float64, Size > a)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 1 >	operator+ (const viskores::Vec< T, 1 > &a, const viskores::Vec< T, 1 > &b)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 1 >	operator+ (const viskores::Vec< T, 1 > &a, T scalar)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 1 >	operator+ (const viskores::Vec< T, 1 > &a, viskores::Float64 scalar)
VISKORES_EXEC_CONT viskores::Vec< viskores::Float64, 1 >	operator+ (const viskores::Vec< viskores::Float64, 1 > &a, viskores::Float64 scalar)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 1 >	operator+ (T scalar, const viskores::Vec< T, 1 > &a)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 1 >	operator+ (viskores::Float64 scalar, const viskores::Vec< T, 1 > &a)
VISKORES_EXEC_CONT viskores::Vec< viskores::Float64, 1 >	operator+ (viskores::Float64 scalar, const viskores::Vec< viskores::Float64, 1 > &a)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 2 >	operator+ (const viskores::Vec< T, 2 > &a, const viskores::Vec< T, 2 > &b)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 2 >	operator+ (const viskores::Vec< T, 2 > &a, T scalar)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 2 >	operator+ (const viskores::Vec< T, 2 > &a, viskores::Float64 scalar)
VISKORES_EXEC_CONT viskores::Vec< viskores::Float64, 2 >	operator+ (const viskores::Vec< viskores::Float64, 2 > &a, viskores::Float64 scalar)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 2 >	operator+ (T scalar, const viskores::Vec< T, 2 > &a)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 2 >	operator+ (viskores::Float64 scalar, const viskores::Vec< T, 2 > &a)
VISKORES_EXEC_CONT viskores::Vec< viskores::Float64, 2 >	operator+ (viskores::Float64 scalar, const viskores::Vec< viskores::Float64, 2 > &a)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 3 >	operator+ (const viskores::Vec< T, 3 > &a, const viskores::Vec< T, 3 > &b)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 3 >	operator+ (const viskores::Vec< T, 3 > &a, T scalar)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 3 >	operator+ (const viskores::Vec< T, 3 > &a, viskores::Float64 scalar)
VISKORES_EXEC_CONT viskores::Vec< viskores::Float64, 3 >	operator+ (const viskores::Vec< viskores::Float64, 3 > &a, viskores::Float64 scalar)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 3 >	operator+ (T scalar, const viskores::Vec< T, 3 > &a)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 3 >	operator+ (viskores::Float64 scalar, const viskores::Vec< T, 3 > &a)
VISKORES_EXEC_CONT viskores::Vec< viskores::Float64, 3 >	operator+ (viskores::Float64 scalar, const viskores::Vec< viskores::Float64, 3 > &a)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 4 >	operator+ (const viskores::Vec< T, 4 > &a, const viskores::Vec< T, 4 > &b)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 4 >	operator+ (const viskores::Vec< T, 4 > &a, T scalar)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 4 >	operator+ (const viskores::Vec< T, 4 > &a, viskores::Float64 scalar)
VISKORES_EXEC_CONT viskores::Vec< viskores::Float64, 4 >	operator+ (const viskores::Vec< viskores::Float64, 4 > &a, viskores::Float64 scalar)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 4 >	operator+ (T scalar, const viskores::Vec< T, 4 > &a)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 4 >	operator+ (viskores::Float64 scalar, const viskores::Vec< T, 4 > &a)
VISKORES_EXEC_CONT viskores::Vec< viskores::Float64, 4 >	operator+ (viskores::Float64 scalar, const viskores::Vec< viskores::Float64, 4 > &a)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 1 >	operator* (const viskores::Vec< T, 1 > &a, const viskores::Vec< T, 1 > &b)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 1 >	operator* (const viskores::Vec< T, 1 > &a, T scalar)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 1 >	operator* (const viskores::Vec< T, 1 > &a, viskores::Float64 scalar)
VISKORES_EXEC_CONT viskores::Vec< viskores::Float64, 1 >	operator* (const viskores::Vec< viskores::Float64, 1 > &a, viskores::Float64 scalar)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 1 >	operator* (T scalar, const viskores::Vec< T, 1 > &a)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 1 >	operator* (viskores::Float64 scalar, const viskores::Vec< T, 1 > &a)
VISKORES_EXEC_CONT viskores::Vec< viskores::Float64, 1 >	operator* (viskores::Float64 scalar, const viskores::Vec< viskores::Float64, 1 > &a)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 2 >	operator* (const viskores::Vec< T, 2 > &a, const viskores::Vec< T, 2 > &b)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 2 >	operator* (const viskores::Vec< T, 2 > &a, T scalar)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 2 >	operator* (const viskores::Vec< T, 2 > &a, viskores::Float64 scalar)
VISKORES_EXEC_CONT viskores::Vec< viskores::Float64, 2 >	operator* (const viskores::Vec< viskores::Float64, 2 > &a, viskores::Float64 scalar)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 2 >	operator* (T scalar, const viskores::Vec< T, 2 > &a)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 2 >	operator* (viskores::Float64 scalar, const viskores::Vec< T, 2 > &a)
VISKORES_EXEC_CONT viskores::Vec< viskores::Float64, 2 >	operator* (viskores::Float64 scalar, const viskores::Vec< viskores::Float64, 2 > &a)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 3 >	operator* (const viskores::Vec< T, 3 > &a, const viskores::Vec< T, 3 > &b)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 3 >	operator* (const viskores::Vec< T, 3 > &a, T scalar)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 3 >	operator* (const viskores::Vec< T, 3 > &a, viskores::Float64 scalar)
VISKORES_EXEC_CONT viskores::Vec< viskores::Float64, 3 >	operator* (const viskores::Vec< viskores::Float64, 3 > &a, viskores::Float64 scalar)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 3 >	operator* (T scalar, const viskores::Vec< T, 3 > &a)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 3 >	operator* (viskores::Float64 scalar, const viskores::Vec< T, 3 > &a)
VISKORES_EXEC_CONT viskores::Vec< viskores::Float64, 3 >	operator* (viskores::Float64 scalar, const viskores::Vec< viskores::Float64, 3 > &a)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 4 >	operator* (const viskores::Vec< T, 4 > &a, const viskores::Vec< T, 4 > &b)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 4 >	operator* (const viskores::Vec< T, 4 > &a, T scalar)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 4 >	operator* (const viskores::Vec< T, 4 > &a, viskores::Float64 scalar)
VISKORES_EXEC_CONT viskores::Vec< viskores::Float64, 4 >	operator* (const viskores::Vec< viskores::Float64, 4 > &a, viskores::Float64 scalar)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 4 >	operator* (T scalar, const viskores::Vec< T, 4 > &a)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 4 >	operator* (viskores::Float64 scalar, const viskores::Vec< T, 4 > &a)
VISKORES_EXEC_CONT viskores::Vec< viskores::Float64, 4 >	operator* (viskores::Float64 scalar, const viskores::Vec< viskores::Float64, 4 > &a)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 1 >	operator- (const viskores::Vec< T, 1 > &a, const viskores::Vec< T, 1 > &b)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 1 >	operator- (const viskores::Vec< T, 1 > &a, T scalar)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 1 >	operator- (const viskores::Vec< T, 1 > &a, viskores::Float64 scalar)
VISKORES_EXEC_CONT viskores::Vec< viskores::Float64, 1 >	operator- (const viskores::Vec< viskores::Float64, 1 > &a, viskores::Float64 scalar)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 1 >	operator- (T scalar, const viskores::Vec< T, 1 > &a)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 1 >	operator- (viskores::Float64 scalar, const viskores::Vec< T, 1 > &a)
VISKORES_EXEC_CONT viskores::Vec< viskores::Float64, 1 >	operator- (viskores::Float64 scalar, const viskores::Vec< viskores::Float64, 1 > &a)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 2 >	operator- (const viskores::Vec< T, 2 > &a, const viskores::Vec< T, 2 > &b)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 2 >	operator- (const viskores::Vec< T, 2 > &a, T scalar)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 2 >	operator- (const viskores::Vec< T, 2 > &a, viskores::Float64 scalar)
VISKORES_EXEC_CONT viskores::Vec< viskores::Float64, 2 >	operator- (const viskores::Vec< viskores::Float64, 2 > &a, viskores::Float64 scalar)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 2 >	operator- (T scalar, const viskores::Vec< T, 2 > &a)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 2 >	operator- (viskores::Float64 scalar, const viskores::Vec< T, 2 > &a)
VISKORES_EXEC_CONT viskores::Vec< viskores::Float64, 2 >	operator- (viskores::Float64 scalar, const viskores::Vec< viskores::Float64, 2 > &a)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 3 >	operator- (const viskores::Vec< T, 3 > &a, const viskores::Vec< T, 3 > &b)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 3 >	operator- (const viskores::Vec< T, 3 > &a, T scalar)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 3 >	operator- (const viskores::Vec< T, 3 > &a, viskores::Float64 scalar)
VISKORES_EXEC_CONT viskores::Vec< viskores::Float64, 3 >	operator- (const viskores::Vec< viskores::Float64, 3 > &a, viskores::Float64 scalar)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 3 >	operator- (T scalar, const viskores::Vec< T, 3 > &a)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 3 >	operator- (viskores::Float64 scalar, const viskores::Vec< T, 3 > &a)
VISKORES_EXEC_CONT viskores::Vec< viskores::Float64, 3 >	operator- (viskores::Float64 scalar, const viskores::Vec< viskores::Float64, 3 > &a)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 4 >	operator- (const viskores::Vec< T, 4 > &a, const viskores::Vec< T, 4 > &b)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 4 >	operator- (const viskores::Vec< T, 4 > &a, T scalar)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 4 >	operator- (const viskores::Vec< T, 4 > &a, viskores::Float64 scalar)
VISKORES_EXEC_CONT viskores::Vec< viskores::Float64, 4 >	operator- (const viskores::Vec< viskores::Float64, 4 > &a, viskores::Float64 scalar)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 4 >	operator- (T scalar, const viskores::Vec< T, 4 > &a)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 4 >	operator- (viskores::Float64 scalar, const viskores::Vec< T, 4 > &a)
VISKORES_EXEC_CONT viskores::Vec< viskores::Float64, 4 >	operator- (viskores::Float64 scalar, const viskores::Vec< viskores::Float64, 4 > &a)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 1 >	operator/ (const viskores::Vec< T, 1 > &a, const viskores::Vec< T, 1 > &b)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 1 >	operator/ (const viskores::Vec< T, 1 > &a, T scalar)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 1 >	operator/ (const viskores::Vec< T, 1 > &a, viskores::Float64 scalar)
VISKORES_EXEC_CONT viskores::Vec< viskores::Float64, 1 >	operator/ (const viskores::Vec< viskores::Float64, 1 > &a, viskores::Float64 scalar)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 1 >	operator/ (T scalar, const viskores::Vec< T, 1 > &a)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 1 >	operator/ (viskores::Float64 scalar, const viskores::Vec< T, 1 > &a)
VISKORES_EXEC_CONT viskores::Vec< viskores::Float64, 1 >	operator/ (viskores::Float64 scalar, const viskores::Vec< viskores::Float64, 1 > &a)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 2 >	operator/ (const viskores::Vec< T, 2 > &a, const viskores::Vec< T, 2 > &b)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 2 >	operator/ (const viskores::Vec< T, 2 > &a, T scalar)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 2 >	operator/ (const viskores::Vec< T, 2 > &a, viskores::Float64 scalar)
VISKORES_EXEC_CONT viskores::Vec< viskores::Float64, 2 >	operator/ (const viskores::Vec< viskores::Float64, 2 > &a, viskores::Float64 scalar)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 2 >	operator/ (T scalar, const viskores::Vec< T, 2 > &a)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 2 >	operator/ (viskores::Float64 scalar, const viskores::Vec< T, 2 > &a)
VISKORES_EXEC_CONT viskores::Vec< viskores::Float64, 2 >	operator/ (viskores::Float64 scalar, const viskores::Vec< viskores::Float64, 2 > &a)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 3 >	operator/ (const viskores::Vec< T, 3 > &a, const viskores::Vec< T, 3 > &b)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 3 >	operator/ (const viskores::Vec< T, 3 > &a, T scalar)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 3 >	operator/ (const viskores::Vec< T, 3 > &a, viskores::Float64 scalar)
VISKORES_EXEC_CONT viskores::Vec< viskores::Float64, 3 >	operator/ (const viskores::Vec< viskores::Float64, 3 > &a, viskores::Float64 scalar)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 3 >	operator/ (T scalar, const viskores::Vec< T, 3 > &a)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 3 >	operator/ (viskores::Float64 scalar, const viskores::Vec< T, 3 > &a)
VISKORES_EXEC_CONT viskores::Vec< viskores::Float64, 3 >	operator/ (viskores::Float64 scalar, const viskores::Vec< viskores::Float64, 3 > &a)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 4 >	operator/ (const viskores::Vec< T, 4 > &a, const viskores::Vec< T, 4 > &b)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 4 >	operator/ (const viskores::Vec< T, 4 > &a, T scalar)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 4 >	operator/ (const viskores::Vec< T, 4 > &a, viskores::Float64 scalar)
VISKORES_EXEC_CONT viskores::Vec< viskores::Float64, 4 >	operator/ (const viskores::Vec< viskores::Float64, 4 > &a, viskores::Float64 scalar)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 4 >	operator/ (T scalar, const viskores::Vec< T, 4 > &a)
template<typename T >
VISKORES_EXEC_CONT viskores::Vec< T, 4 >	operator/ (viskores::Float64 scalar, const viskores::Vec< T, 4 > &a)
VISKORES_EXEC_CONT viskores::Vec< viskores::Float64, 4 >	operator/ (viskores::Float64 scalar, const viskores::Vec< viskores::Float64, 4 > &a)
template<typename Functor , typename... Ts, typename... Args>
void	ListForEach (Functor &&f, viskores::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 &&, viskores::ListEmpty, Args &&...)
viskores::Float32	Ldexp (viskores::Float32 x, viskores::Int32 exponent)
viskores::Float64	Ldexp (viskores::Float64 x, viskores::Int32 exponent)
viskores::UInt64	FloatDistance (viskores::Float64 x, viskores::Float64 y)
	Computes the number of representables between two floating point numbers. More...
viskores::UInt64	FloatDistance (viskores::Float32 x, viskores::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 >
viskores::Vec< T, 2 >	QuadraticRoots (T a, T b, T c)
	Solves ax² + bx + c = 0. More...
viskores::Int32	FindFirstSetBit (viskores::UInt32 word)
	Bitwise operations. More...
viskores::Int32	FindFirstSetBit (viskores::UInt64 word)
	Find the first set bit in word, and return its position (1-64). More...
viskores::Int32	CountSetBits (viskores::UInt32 word)
	Count the total number of bits set in word. More...
viskores::Int32	CountSetBits (viskores::UInt64 word)
	Count the total number of bits set in word. More...
template<typename T , viskores::IdComponent NumRow, viskores::IdComponent NumCol>
const viskores::Vec< T, NumCol > &	MatrixGetRow (const viskores::Matrix< T, NumRow, NumCol > &matrix, viskores::IdComponent rowIndex)
	Returns a tuple containing the given row (indexed from 0) of the given matrix. More...
template<typename T , viskores::IdComponent NumRow, viskores::IdComponent NumCol>
viskores::Vec< T, NumRow >	MatrixGetColumn (const viskores::Matrix< T, NumRow, NumCol > &matrix, viskores::IdComponent columnIndex)
	Returns a tuple containing the given column (indexed from 0) of the given matrix. More...
template<typename T , viskores::IdComponent NumRow, viskores::IdComponent NumCol>
void	MatrixSetRow (viskores::Matrix< T, NumRow, NumCol > &matrix, viskores::IdComponent rowIndex, const viskores::Vec< T, NumCol > &rowValues)
	Convenience function for setting a row of a matrix. More...
template<typename T , viskores::IdComponent NumRow, viskores::IdComponent NumCol>
void	MatrixSetColumn (viskores::Matrix< T, NumRow, NumCol > &matrix, viskores::IdComponent columnIndex, const viskores::Vec< T, NumRow > &columnValues)
	Convenience function for setting a column of a matrix. More...
template<typename T , viskores::IdComponent NumRow, viskores::IdComponent NumCol, viskores::IdComponent NumInternal>
viskores::Matrix< T, NumRow, NumCol >	MatrixMultiply (const viskores::Matrix< T, NumRow, NumInternal > &leftFactor, const viskores::Matrix< T, NumInternal, NumCol > &rightFactor)
	Standard matrix multiplication. More...
template<typename T , viskores::IdComponent NumRow, viskores::IdComponent NumCol>
viskores::Vec< T, NumRow >	MatrixMultiply (const viskores::Matrix< T, NumRow, NumCol > &leftFactor, const viskores::Vec< T, NumCol > &rightFactor)
	Standard matrix-vector multiplication. More...
template<typename T , viskores::IdComponent NumRow, viskores::IdComponent NumCol>
viskores::Vec< T, NumCol >	MatrixMultiply (const viskores::Vec< T, NumRow > &leftFactor, const viskores::Matrix< T, NumRow, NumCol > &rightFactor)
	Standard vector-matrix multiplication. More...
template<typename T , viskores::IdComponent Size>
viskores::Matrix< T, Size, Size >	MatrixIdentity ()
	Returns the identity matrix. More...
template<typename T , viskores::IdComponent Size>
void	MatrixIdentity (viskores::Matrix< T, Size, Size > &matrix)
	Fills the given matrix with the identity matrix. More...
template<typename T , viskores::IdComponent NumRows, viskores::IdComponent NumCols>
viskores::Matrix< T, NumCols, NumRows >	MatrixTranspose (const viskores::Matrix< T, NumRows, NumCols > &matrix)
	Returns the transpose of the given matrix. More...
template<typename T , viskores::IdComponent Size>
viskores::Vec< T, Size >	SolveLinearSystem (const viskores::Matrix< T, Size, Size > &A, const viskores::Vec< T, Size > &b, bool &valid)
	Solve the linear system Ax = b for x. More...
template<typename T , viskores::IdComponent Size>
viskores::Matrix< T, Size, Size >	MatrixInverse (const viskores::Matrix< T, Size, Size > &A, bool &valid)
	Find and return the inverse of the given matrix. More...
template<typename T , viskores::IdComponent Size>
T	MatrixDeterminant (const viskores::Matrix< T, Size, Size > &A)
	Compute the determinant of a matrix. More...
template<typename T >
T	MatrixDeterminant (const viskores::Matrix< T, 1, 1 > &A)
template<typename T >
T	MatrixDeterminant (const viskores::Matrix< T, 2, 2 > &A)
template<typename T >
T	MatrixDeterminant (const viskores::Matrix< T, 3, 3 > &A)
template<typename T , viskores::IdComponent NumRow, viskores::IdComponent NumCol>
bool	operator== (const viskores::Matrix< T, NumRow, NumCol > &a, const viskores::Matrix< T, NumRow, NumCol > &b)
template<typename T , viskores::IdComponent NumRow, viskores::IdComponent NumCol>
bool	operator!= (const viskores::Matrix< T, NumRow, NumCol > &a, const viskores::Matrix< T, NumRow, NumCol > &b)
template<typename T , viskores::IdComponent NumRow, viskores::IdComponent NumCol>
std::ostream &	operator<< (std::ostream &stream, const viskores::Matrix< T, NumRow, NumCol > &mat)
	Helper function for printing out matricies during testing. More...
template<typename ScalarType , viskores::IdComponent Size, typename JacobianFunctor , typename FunctionFunctor >
NewtonsMethodResult< ScalarType, Size >	NewtonsMethod (JacobianFunctor jacobianEvaluator, FunctionFunctor functionEvaluator, viskores::Vec< ScalarType, Size > desiredFunctionOutput, viskores::Vec< ScalarType, Size > initialGuess=viskores::Vec< ScalarType, Size >(ScalarType(0)), ScalarType convergeDifference=ScalarType(1e-3), viskores::IdComponent maxIterations=10)
	Uses Newton's method (a.k.a. More...
template<typename T , typename U >
viskores::Pair< T, U >	operator+ (const viskores::Pair< T, U > &a, const viskores::Pair< T, U > &b)
	Pairwise Add. More...
template<typename T1 , typename T2 >
viskores::Pair< typename std::decay< T1 >::type, typename std::decay< T2 >::type >	make_Pair (T1 &&v1, T2 &&v2)
std::ostream &	operator<< (std::ostream &s, const viskores::ParticleStatus &status)
std::ostream &	operator<< (std::ostream &stream, const viskores::Range &range)
	Helper function for printing ranges during testing. More...
std::ostream &	operator<< (std::ostream &stream, const viskores::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 >
viskores::Vec< T, 3 >	Transform3DPoint (const viskores::Matrix< T, 4, 4 > &matrix, const viskores::Vec< T, 3 > &point)
	Transform a 3D point by a transformation matrix. More...
template<typename T >
viskores::Vec< T, 3 >	Transform3DPointPerspective (const viskores::Matrix< T, 4, 4 > &matrix, const viskores::Vec< T, 3 > &point)
	Transform a 3D point by a transformation matrix with perspective. More...
template<typename T >
viskores::Vec< T, 3 >	Transform3DVector (const viskores::Matrix< T, 4, 4 > &matrix, const viskores::Vec< T, 3 > &vector)
	Transform a 3D vector by a transformation matrix. More...
template<typename T >
viskores::Matrix< T, 4, 4 >	Transform3DScale (const T &scaleX, const T &scaleY, const T &scaleZ)
	Returns a scale matrix. More...
template<typename T >
viskores::Matrix< T, 4, 4 >	Transform3DScale (const viskores::Vec< T, 3 > &scaleVec)
	Returns a scale matrix. More...
template<typename T >
viskores::Matrix< T, 4, 4 >	Transform3DScale (const T &scale)
	Returns a scale matrix. More...
template<typename T >
viskores::Matrix< T, 4, 4 >	Transform3DTranslate (const T &x, const T &y, const T &z)
	Returns a translation matrix. More...
template<typename T >
viskores::Matrix< T, 4, 4 >	Transform3DTranslate (const viskores::Vec< T, 3 > &v)
template<typename T >
viskores::Matrix< T, 4, 4 >	Transform3DRotate (T angleDegrees, const viskores::Vec< T, 3 > &axisOfRotation)
	Returns a rotation matrix. More...
template<typename T >
viskores::Matrix< T, 4, 4 >	Transform3DRotate (T angleDegrees, T x, T y, T z)
template<typename T >
viskores::Matrix< T, 4, 4 >	Transform3DRotateX (T angleDegrees)
	Returns a rotation matrix. More...
template<typename T >
viskores::Matrix< T, 4, 4 >	Transform3DRotateY (T angleDegrees)
	Returns a rotation matrix. More...
template<typename T >
viskores::Matrix< T, 4, 4 >	Transform3DRotateZ (T angleDegrees)
	Returns a rotation matrix. More...
template<typename T , typename... Ts>
constexpr viskores::Vec< T, viskores::IdComponent(sizeof...(Ts)+1)>	make_Vec (T value0, Ts &&... args)
	Initializes and returns a Vec containing all the arguments. More...
template<typename T , viskores::IdComponent Size>
T	ReduceSum (const viskores::Vec< T, Size > &a)
template<typename T >
T	ReduceSum (const viskores::Vec< T, 2 > &a)
template<typename T >
T	ReduceSum (const viskores::Vec< T, 3 > &a)
template<typename T >
T	ReduceSum (const viskores::Vec< T, 4 > &a)
template<typename T , viskores::IdComponent Size>
T	ReduceProduct (const viskores::Vec< T, Size > &a)
template<typename T >
T	ReduceProduct (const viskores::Vec< T, 2 > &a)
template<typename T >
T	ReduceProduct (const viskores::Vec< T, 3 > &a)
template<typename T >
T	ReduceProduct (const viskores::Vec< T, 4 > &a)
template<typename T , viskores::IdComponent Size>
std::ostream &	operator<< (std::ostream &stream, const viskores::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 viskores::Pair< T, U > &vec)
	Helper function for printing out pairs during testing. More...
template<viskores::IdComponent NumDimensions>
std::ostream &	operator<< (std::ostream &stream, const viskores::VecAxisAlignedPointCoordinates< NumDimensions > &vec)
	Helper function for printing out vectors during testing. More...
template<typename T >
viskores::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 , viskores::IdComponent N, typename WeightType >
viskores::Vec< ValueType, N >	Lerp (const viskores::Vec< ValueType, N > &value0, const viskores::Vec< ValueType, N > &value1, const WeightType &weight)
template<typename ValueType , viskores::IdComponent N>
viskores::Vec< ValueType, N >	Lerp (const viskores::Vec< ValueType, N > &value0, const viskores::Vec< ValueType, N > &value1, const viskores::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 >
viskores::Vec< typename detail::FloatingPointReturnType< T >::Type, 3 >	Cross (const viskores::Vec< T, 3 > &x, const viskores::Vec< T, 3 > &y)
	Find the cross product of two vectors. More...
template<typename T >
viskores::Vec< typename detail::FloatingPointReturnType< T >::Type, 3 >	TriangleNormal (const viskores::Vec< T, 3 > &a, const viskores::Vec< T, 3 > &b, const viskores::Vec< T, 3 > &c)
	Find the normal of a triangle. More...
template<typename T , int N>
viskores::Vec< T, N >	Project (const viskores::Vec< T, N > &v, const viskores::Vec< T, N > &u)
	Project a vector onto another vector. More...
template<typename T , int N>
T	ProjectedDistance (const viskores::Vec< T, N > &v, const viskores::Vec< T, N > &u)
	Project a vector onto another vector, returning only the projected distance. More...
template<typename T , int N>
int	Orthonormalize (const viskores::Vec< viskores::Vec< T, N >, N > &inputs, viskores::Vec< viskores::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< viskores::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 viskores::Tuple. More...
template<viskores::IdComponent Index, typename TupleType >
using	TupleElement = typename detail::TupleElementImpl< Index, TupleType >::type
	Becomes the type of the given index for the given viskores::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 viskores::Tuple. More...
template<viskores::IdComponent Index, typename... Ts>
auto	Get (const viskores::Tuple< Ts... > &tuple)
	Retrieve the object from a viskores::Tuple at the given index. More...
template<viskores::IdComponent Index, typename... Ts>
auto	Get (viskores::Tuple< Ts... > &tuple)
	Retrieve the object from a viskores::Tuple at the given index. More...
template<std::size_t Index, typename... Ts>
auto	get (const viskores::Tuple< Ts... > &tuple) -> decltype(viskores::Get< static_cast< viskores::IdComponent >(Index)>(tuple))
	Compatible with std::get for viskores::Tuple. More...
template<std::size_t Index, typename... Ts>
auto	get (viskores::Tuple< Ts... > &tuple) -> decltype(viskores::Get< static_cast< viskores::IdComponent >(Index)>(tuple))
	Compatible with std::get for viskores::Tuple. More...
template<typename... Ts>
auto	MakeTuple (Ts &&... args) -> viskores::Tuple< typename std::decay< Ts >::type... >
	Creates a new viskores::Tuple with the given types. More...
template<typename... Ts>
auto	make_tuple (Ts &&... args) -> decltype(viskores::MakeTuple(std::forward< Ts >(args)...))
	Compatible with std::make_tuple for viskores::Tuple. More...
template<typename... Ts, typename Function , typename... Args>
auto	Apply (const viskores::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 viskores::Tuple as arguments. More...
template<typename... Ts, typename Function , typename... Args>
auto	Apply (viskores::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 viskores::Tuple as arguments. More...
template<typename... Ts, typename Function >
void	ForEach (const viskores::Tuple< Ts... > &tuple, Function &&f)
	Call a function with each value of the given tuple. More...
template<typename... Ts, typename Function >
void	ForEach (viskores::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 viskores::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.

Viskores 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 viskores::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'

viskores is the namespace for the Viskores Toolkit. It contains other sub namespaces, as well as basic data types and functions callable from all components in Viskores 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 viskores::AtomicTypePreferred = typedef viskores::UInt32

The preferred type to use for atomic operations.

AtomicTypesSupported

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

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

TODO: Adjust based on devices being compiled.

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

BufferSizeType

using viskores::BufferSizeType = typedef viskores::Int64

Circle

template<typename T >

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

Circle is an alias for a 2-Dimensional sphere.

Circle2d

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

Float32

using viskores::Float32 = typedef float

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

Float64

using viskores::Float64 = typedef double

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

FloatDefault

using viskores::FloatDefault = typedef viskores::Float32

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

HashType

using viskores::HashType = typedef viskores::UInt32

HasVecTraits

template<typename T >

using viskores::HasVecTraits = typedef std::true_type

Id

using viskores::Id = typedef viskores::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 viskores::Id2 = typedef viskores::Vec<viskores::Id, 2>

Id2 corresponds to a 2-dimensional index.

Id3

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

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

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

Id4

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

Id4 corresponds to a 4-dimensional index.

IdComponent

using viskores::IdComponent = typedef viskores::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 viskores::IdComponent2 = typedef viskores::Vec<viskores::IdComponent, 2>

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

IdComponent3

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

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

IdComponent4

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

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

Int16

using viskores::Int16 = typedef int16_t

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

Int32

using viskores::Int32 = typedef int32_t

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

Int64

using viskores::Int64 = typedef signed long long

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

Int8

using viskores::Int8 = typedef int8_t

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

Line

template<typename CoordType , int Dim = 3>

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

Lines are two-sided rays:

Line2

template<typename CoordType >

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

Line2d

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

Line3

template<typename CoordType >

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

Line3d

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

LineSegment2

template<typename CoordType >

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

LineSegment2d

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

LineSegment3

template<typename CoordType >

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

LineSegment3d

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

ListAll

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

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

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

ListAll expects a viskores::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 = viskores::List<int, char>;
using NumberList2 = viskores::List<int, float>;
 
// Resolves to std::true_type
using AllInt1 = viskores::ListAll<NumberList1, std::is_integral>;
 
// Resolves to std::false_type (because float is not integral)
using AllInt2 = viskores::ListAll<NumberList2, std::is_integral>;

ListAny

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

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

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

ListAny expects a viskores::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 = viskores::List<int, float>;
using NumberList2 = viskores::List<float, double>;
 
// Resolves to std::true_type
using AnyInt1 = viskores::ListAny<NumberList1, std::is_integral>;
 
// Resolves to std::false_type
using AnyInt2 = viskores::ListAny<NumberList2, std::is_integral>;

ListAppend

template<typename... Lists>

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

Concatinates a set of lists into a single list.

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

ListApply

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

using viskores::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 , viskores::IdComponent Index>

using viskores::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 viskores::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 viskores::List<viskores::List<A1,B1>, viskores::List<A1,B2>,...>

ListEmpty

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

A convenience type for an empty list.

ListFill

template<typename T , viskores::IdComponent N>

using viskores::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 viskores::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 viskores::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 viskores::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 viskores::ListReduce = typedef typename detail::ListReduceImpl<List, Operator, Initial>::type

Reduces a list to a single type using an operator.

ListReduce takes a viskores::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 viskores::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

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

resolves to a List that is equivalent to viskores::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 viskores::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 viskores::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 viskores::ListUniversal = typedef viskores::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 viskores::Plane3d = typedef Plane<viskores::FloatDefault>

Ray2

template<typename CoordType >

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

Ray2d

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

Ray3

template<typename CoordType >

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

Ray3d

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

Sphere2

template<typename T >

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

Sphere2d

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

Sphere3

template<typename T >

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

Sphere3d

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

tuple_element_t

template<std::size_t Index, typename TupleType >

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

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

tuple_size

template<typename TupleType >

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

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

TupleElement

template<viskores::IdComponent Index, typename TupleType >

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

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

TupleSize

template<typename TupleType >

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

Get the size of a tuple.

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

TypeListAll

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

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

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

TypeListBaseC

using viskores::TypeListBaseC = typedef viskores::ListAppend< viskores::TypeListScalarAll, viskores::List<bool, char, signed long , unsigned long > >

TypeListCommon

using viskores::TypeListCommon = typedef viskores::List<viskores::UInt8, viskores::Int32, viskores::Int64, viskores::Float32, viskores::Float64, viskores::Vec3f_32, viskores::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 viskores::TypeListField = typedef viskores::List<viskores::Float32, viskores::Float64, viskores::Vec2f_32, viskores::Vec2f_64, viskores::Vec3f_32, viskores::Vec3f_64, viskores::Vec4f_32, viskores::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 viskores::TypeListFieldScalar = typedef viskores::List<viskores::Float32, viskores::Float64>

A list containing types used for scalar fields.

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

TypeListFieldVec2

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

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

TypeListFieldVec3

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

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

TypeListFieldVec4

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

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

TypeListFloatVec

using viskores::TypeListFloatVec = typedef viskores::List<viskores::Vec2f_32, viskores::Vec2f_64, viskores::Vec3f_32, viskores::Vec3f_64, viskores::Vec4f_32, viskores::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 viskores::TypeListId = typedef viskores::List<viskores::Id>

A list containing the type viskores::Id.

TypeListId2

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

A list containing the type viskores::Id2.

TypeListId3

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

A list containing the type viskores::Id3.

TypeListId4

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

A list containing the type viskores::Id4.

TypeListIdComponent

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

A list containing the type viskores::IdComponent.

TypeListIndex

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

A list containing types used to index arrays.

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

TypeListScalarAll

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

A list of all scalars defined in viskores/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 viskores::TypeListVecAll = typedef viskores::ListAppend<viskores::TypeListVecCommon, viskores::internal::TypeListVecUncommon>

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

TypeListVecCommon

using viskores::TypeListVecCommon = typedef viskores::List<viskores::Vec2ui_8, viskores::Vec2i_32, viskores::Vec2i_64, viskores::Vec2f_32, viskores::Vec2f_64, viskores::Vec3ui_8, viskores::Vec3i_32, viskores::Vec3i_64, viskores::Vec3f_32, viskores::Vec3f_64, viskores::Vec4ui_8, viskores::Vec4i_32, viskores::Vec4i_64, viskores::Vec4f_32, viskores::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 viskores::UInt16 = typedef uint16_t

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

UInt32

using viskores::UInt32 = typedef uint32_t

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

UInt64

using viskores::UInt64 = typedef unsigned long long

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

UInt8

using viskores::UInt8 = typedef uint8_t

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

Vec2f

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

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

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

Vec2f_32

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

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

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

Vec2f_64

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

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

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

Vec2i

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

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

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

Vec2i_16

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

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

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

Vec2i_32

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

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

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

Vec2i_64

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

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

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

Vec2i_8

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

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

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

Vec2ui

using viskores::Vec2ui = typedef viskores::Vec<viskores::UInt64, 2>

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

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

Vec2ui_16

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

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

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

Vec2ui_32

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

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

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

Vec2ui_64

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

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

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

Vec2ui_8

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

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

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

Vec3f

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

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

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

Vec3f_32

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

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

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

Vec3f_64

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

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

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

Vec3i

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

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

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

Vec3i_16

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

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

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

Vec3i_32

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

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

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

Vec3i_64

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

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

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

Vec3i_8

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

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

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

Vec3ui

using viskores::Vec3ui = typedef viskores::Vec<viskores::UInt64, 3>

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

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

Vec3ui_16

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

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

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

Vec3ui_32

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

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

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

Vec3ui_64

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

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

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

Vec3ui_8

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

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

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

Vec4f

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

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

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

Vec4f_32

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

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

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

Vec4f_64

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

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

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

Vec4i

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

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

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

Vec4i_16

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

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

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

Vec4i_32

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

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

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

Vec4i_64

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

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

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

Vec4i_8

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

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

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

Vec4ui

using viskores::Vec4ui = typedef viskores::Vec<viskores::UInt64, 4>

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

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

Vec4ui_16

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

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

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

Vec4ui_32

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

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

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

Vec4ui_64

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

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

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

Vec4ui_8

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

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

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

WordTypeDefault

using viskores::WordTypeDefault = typedef viskores::UInt32

The default word size used for atomic bitwise operations.

Universally supported on all devices.

Enumeration Type Documentation

CellShapeIdEnum

enum viskores::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 viskores::ColorSpace

strong

Enumerator
RGB
HSV
HSVWrap
Lab
Diverging

CopyFlag

enum viskores::CopyFlag

strong

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

Enumerator
Off
On

ErrorCode

enum viskores::ErrorCode

strong

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

Most errors in Viskores 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 viskores::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 viskores::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 Viskores 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 viskores::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 (viskores::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 viskores::MemoryOrder

strong

Specifies memory order semantics for atomic operations.

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

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

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

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

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

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

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

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

Function Documentation

ACos() [1/2]

viskores::Float32 viskores::ACos ( viskores::Float32  x )

inline

Compute the arc cosine of x.

ACos() [2/2]

viskores::Float64 viskores::ACos ( viskores::Float64  x )

inline

Compute the arc cosine of x.

ACosH() [1/2]

viskores::Float32 viskores::ACosH ( viskores::Float32  x )

inline

Compute the hyperbolic arc cosine of x.

ACosH() [2/2]

viskores::Float64 viskores::ACosH ( viskores::Float64  x )

inline

Compute the hyperbolic arc cosine of x.

Apply() [1/2]

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

auto viskores::Apply	(	const viskores::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 viskores::Tuple as arguments.

If a viskores::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 viskores::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 viskores::Apply().

Apply() [2/2]

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

auto viskores::Apply	(	viskores::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 viskores::Tuple as arguments.

If a viskores::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 viskores::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 viskores::Apply().

ASin() [1/2]

viskores::Float32 viskores::ASin ( viskores::Float32  x )

inline

Compute the arc sine of x.

ASin() [2/2]

viskores::Float64 viskores::ASin ( viskores::Float64  x )

inline

Compute the arc sine of x.

ASinH() [1/2]

viskores::Float32 viskores::ASinH ( viskores::Float32  x )

inline

Compute the hyperbolic arc sine of x.

ASinH() [2/2]

viskores::Float64 viskores::ASinH ( viskores::Float64  x )

inline

Compute the hyperbolic arc sine of x.

ATan() [1/2]

viskores::Float32 viskores::ATan ( viskores::Float32  x )

inline

Compute the arc tangent of x.

ATan() [2/2]

viskores::Float64 viskores::ATan ( viskores::Float64  x )

inline

Compute the arc tangent of x.

ATanH() [1/2]

viskores::Float32 viskores::ATanH ( viskores::Float32  x )

inline

Compute the hyperbolic arc tangent of x.

ATanH() [2/2]

viskores::Float64 viskores::ATanH ( viskores::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 viskores::AtomicAdd ( T *  pointer, detail::OppositeSign< T >  operand, viskores::MemoryOrder  order = viskores::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 viskores::AtomicAdd ( T *  pointer, T  operand, viskores::MemoryOrder  order = viskores::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 viskores::AtomicAnd ( T *  pointer, detail::OppositeSign< T >  operand, viskores::MemoryOrder  order = viskores::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 viskores::AtomicAnd ( T *  pointer, T  operand, viskores::MemoryOrder  order = viskores::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 viskores::AtomicCompareExchange ( T *  shared, T *  expected, T  desired, viskores::MemoryOrder  order = viskores::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 viskores::AtomicLoad ( T *const  pointer, viskores::MemoryOrder  order = viskores::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 viskores::AtomicNot ( T *  pointer, viskores::MemoryOrder  order = viskores::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 viskores::AtomicOr ( T *  pointer, detail::OppositeSign< T >  operand, viskores::MemoryOrder  order = viskores::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 viskores::AtomicOr ( T *  pointer, T  operand, viskores::MemoryOrder  order = viskores::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 viskores::AtomicStore ( T *  pointer, detail::OppositeSign< T >  value, viskores::MemoryOrder  order = viskores::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 viskores::AtomicStore ( T *  pointer, T  value, viskores::MemoryOrder  order = viskores::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 viskores::AtomicXor ( T *  pointer, detail::OppositeSign< T >  operand, viskores::MemoryOrder  order = viskores::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 viskores::AtomicXor ( T *  pointer, T  operand, viskores::MemoryOrder  order = viskores::MemoryOrder::SequentiallyConsistent  )

inline

Atomic function to XOR bits to a shared memory location.

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

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

Cbrt() [1/2]

viskores::Float32 viskores::Cbrt ( viskores::Float32  x )

inline

Compute the cube root of x.

Cbrt() [2/2]

viskores::Float64 viskores::Cbrt ( viskores::Float64  x )

inline

Compute the cube root of x.

Ceil() [1/2]

viskores::Float32 viskores::Ceil ( viskores::Float32  x )

inline

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

Ceil() [2/2]

viskores::Float64 viskores::Ceil ( viskores::Float64  x )

inline

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

Clamp() [1/2]

viskores::Float32 viskores::Clamp ( viskores::Float32  x, viskores::Float32  lo, viskores::Float32  hi  )

inline

Clamp x to the given range.

Clamp() [2/2]

viskores::Float64 viskores::Clamp ( viskores::Float64  x, viskores::Float64  lo, viskores::Float64  hi  )

inline

Clamp x to the given range.

Cos() [1/2]

viskores::Float32 viskores::Cos ( viskores::Float32  x )

inline

Compute the cosine of x.

Cos() [2/2]

viskores::Float64 viskores::Cos ( viskores::Float64  x )

inline

Compute the cosine of x.

CosH() [1/2]

viskores::Float32 viskores::CosH ( viskores::Float32  x )

inline

Compute the hyperbolic cosine of x.

CosH() [2/2]

viskores::Float64 viskores::CosH ( viskores::Float64  x )

inline

Compute the hyperbolic cosine of x.

CountSetBits() [1/2]

viskores::Int32 viskores::CountSetBits ( viskores::UInt32  word )

inline

Count the total number of bits set in word.

CountSetBits() [2/2]

viskores::Int32 viskores::CountSetBits ( viskores::UInt64  word )

inline

Count the total number of bits set in word.

Cross()

template<typename T >

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

Find the cross product of two vectors.

If Viskores 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 viskores::DifferenceOfProducts ( T  a, T  b, T  c, T  d  )

inline

ErrorString()

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

inlinenoexcept

Convert a viskores::ErrorCode into a human-readable string.

This method is useful when reporting the results of a function that failed.

Exp() [1/2]

viskores::Float32 viskores::Exp ( viskores::Float32  x )

inline

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

Exp() [2/2]

viskores::Float64 viskores::Exp ( viskores::Float64  x )

inline

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

Exp2() [1/2]

viskores::Float32 viskores::Exp2 ( viskores::Float32  x )

inline

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

Exp2() [2/2]

viskores::Float64 viskores::Exp2 ( viskores::Float64  x )

inline

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

ExpM1() [1/2]

viskores::Float32 viskores::ExpM1 ( viskores::Float32  x )

inline

Computes (e^x) - 1, the of base-e exponental of x then minus 1. The accuracy of this function is good even for very small values of x.

ExpM1() [2/2]

viskores::Float64 viskores::ExpM1 ( viskores::Float64  x )

inline

Computes (e^x) - 1, the of base-e exponental of x then minus 1. The accuracy of this function is good even for very small values of x.

FindFirstSetBit() [1/2]

viskores::Int32 viskores::FindFirstSetBit ( viskores::UInt32  word )

inline

Bitwise operations.

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

FindFirstSetBit() [2/2]

viskores::Int32 viskores::FindFirstSetBit ( viskores::UInt64  word )

inline

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

If no bits are set, returns 0.

FloatDistance() [1/2]

viskores::UInt64 viskores::FloatDistance ( viskores::Float32  x, viskores::Float32  y  )

inline

Computes the number of representables between two floating point numbers.

This function is non-negative and symmetric in its arguments. If either argument is non-finite, the value returned is the maximum value allowed by 64-bit unsigned integers: 2^64-1.

FloatDistance() [2/2]

viskores::UInt64 viskores::FloatDistance ( viskores::Float64  x, viskores::Float64  y  )

inline

Computes the number of representables between two floating point numbers.

This function is non-negative and symmetric in its arguments. If either argument is non-finite, the value returned is the maximum value allowed by 64-bit unsigned integers: 2^64-1.

Floor() [1/2]

viskores::Float32 viskores::Floor ( viskores::Float32  x )

inline

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

Floor() [2/2]

viskores::Float64 viskores::Floor ( viskores::Float64  x )

inline

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

ForEach() [1/2]

template<typename... Ts, typename Function >

void viskores::ForEach	(	const viskores::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 viskores::Tuple.

ForEach() [2/2]

template<typename... Ts, typename Function >

void viskores::ForEach	(	viskores::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 viskores::Tuple.

Frexp() [1/2]

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

inline

Decompose floating poing value

Frexp() [2/2]

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

inline

Decompose floating poing value

Get() [1/2]

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

auto viskores::Get

(

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

tuple

)

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

get() [1/2]

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

auto viskores::get

(

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

tuple

)

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

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

Get() [2/2]

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

auto viskores::Get

(

viskores::Tuple< Ts... > &

tuple

)

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

get() [2/2]

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

auto viskores::get

(

viskores::Tuple< Ts... > &

tuple

)

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

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

Hash()

template<typename InVecType >

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

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

inline

Ldexp() [2/2]

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

inline

Lerp() [1/3]

template<typename ValueType , typename WeightType >

ValueType viskores::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 , viskores::IdComponent N>

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

Lerp() [3/3]

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

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

ListForEach() [1/2]

template<typename Functor , typename... Args>

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

ListForEach() [2/2]

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

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

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

Log() [1/2]

viskores::Float32 viskores::Log ( viskores::Float32  x )

inline

Computes the natural logarithm of x.

Log() [2/2]

viskores::Float64 viskores::Log ( viskores::Float64  x )

inline

Computes the natural logarithm of x.

Log10() [1/2]

viskores::Float32 viskores::Log10 ( viskores::Float32  x )

inline

Computes the logarithm base 10 of x.

Log10() [2/2]

viskores::Float64 viskores::Log10 ( viskores::Float64  x )

inline

Computes the logarithm base 10 of x.

Log1P() [1/2]

viskores::Float32 viskores::Log1P ( viskores::Float32  x )

inline

Computes the value of log(1+x). This method is more accurate for very small values of x than the viskores::Log function.

Log1P() [2/2]

viskores::Float64 viskores::Log1P ( viskores::Float64  x )

inline

Computes the value of log(1+x). This method is more accurate for very small values of x than the viskores::Log function.

Log2() [1/2]

viskores::Float32 viskores::Log2 ( viskores::Float32  x )

inline

Computes the logarithm base 2 of x.

Log2() [2/2]

viskores::Float64 viskores::Log2 ( viskores::Float64  x )

inline

Computes the logarithm base 2 of x.

LowerBound() [1/4]

template<typename PortalT , typename T >

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

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

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

Construct a circle from 3 points.

make_Pair()

template<typename T1 , typename T2 >

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

make_PlaneFromPointAndLine()

template<typename CoordType , bool IsTwoSided>

viskores::Plane<CoordType> viskores::make_PlaneFromPointAndLine	(	const viskores::Vec< CoordType, 3 > &	point,
		const viskores::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 >

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

make_SphereFrom4Points()

template<typename CoordType >

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

Construct a sphere from 4 points.

make_tuple()

template<typename... Ts>

auto viskores::make_tuple

(

Ts &&...

args

)

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

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

make_Vec()

template<typename T , typename... Ts>

constexpr viskores::Vec<T, viskores::IdComponent(sizeof...(Ts) + 1)> viskores::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 >

viskores::VecFlat<T> viskores::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> viskores::make_VecFromPortalPermute ( const IndexVecType *  index, const PortalType &  portal  )

inline

make_VecFromPortalPermute() [2/2]

template<typename IndexVecType , typename PortalType >

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

inline

MakeTuple()

template<typename... Ts>

auto viskores::MakeTuple

(

Ts &&...

args

)

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

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

MatrixDeterminant() [1/4]

template<typename T >

T viskores::MatrixDeterminant

(

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

A

)

MatrixDeterminant() [2/4]

template<typename T >

T viskores::MatrixDeterminant

(

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

A

)

MatrixDeterminant() [3/4]

template<typename T >

T viskores::MatrixDeterminant

(

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

A

)

MatrixDeterminant() [4/4]

template<typename T , viskores::IdComponent Size>

T viskores::MatrixDeterminant

(

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

A

)

Compute the determinant of a matrix.

MatrixGetColumn()

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

viskores::Vec<T, NumRow> viskores::MatrixGetColumn	(	const viskores::Matrix< T, NumRow, NumCol > &	matrix,
		viskores::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 , viskores::IdComponent NumRow, viskores::IdComponent NumCol>

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

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

MatrixIdentity() [1/2]

template<typename T , viskores::IdComponent Size>

viskores::Matrix<T, Size, Size> viskores::MatrixIdentity

(

)

Returns the identity matrix.

MatrixIdentity() [2/2]

template<typename T , viskores::IdComponent Size>

void viskores::MatrixIdentity

(

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

matrix

)

Fills the given matrix with the identity matrix.

MatrixInverse()

template<typename T , viskores::IdComponent Size>

viskores::Matrix<T, Size, Size> viskores::MatrixInverse	(	const viskores::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 , viskores::IdComponent NumRow, viskores::IdComponent NumCol>

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

Standard matrix-vector multiplication.

MatrixMultiply() [2/3]

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

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

Standard matrix multiplication.

MatrixMultiply() [3/3]

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

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

Standard vector-matrix multiplication.

MatrixSetColumn()

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

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

Convenience function for setting a column of a matrix.

MatrixSetRow()

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

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

Convenience function for setting a row of a matrix.

MatrixTranspose()

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

viskores::Matrix<T, NumCols, NumRows> viskores::MatrixTranspose

(

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

matrix

)

Returns the transpose of the given matrix.

NewtonsMethod()

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

NewtonsMethodResult<ScalarType, Size> viskores::NewtonsMethod	(	JacobianFunctor	jacobianEvaluator,
		FunctionFunctor	functionEvaluator,
		viskores::Vec< ScalarType, Size >	desiredFunctionOutput,
		viskores::Vec< ScalarType, Size >	initialGuess = viskores::Vec<ScalarType, Size>(ScalarType(0)),
		ScalarType	convergeDifference = ScalarType(1e-3),
		viskores::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 viskores::Vec and returns a viskores::Matrix containing the math function's Jacobian vector at that point.
[in]	functionEvaluator	A functor whose operation takes a viskores::Vec and returns the evaluation of the math function at that point as another viskores::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 viskores::NewtonsMethodResult containing the best found result and state about its validity.

Normal()

template<typename T >

T viskores::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 viskores::Normalize

(

T &

x

)

Changes a vector to be normal.

The given vector is scaled to be unit length.

operator!=()

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

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

operator*() [1/35]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 1> viskores::operator* ( const viskores::Vec< T, 1 > &  a, const viskores::Vec< T, 1 > &  b  )

inline

operator*() [2/35]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 1> viskores::operator* ( const viskores::Vec< T, 1 > &  a, T  scalar  )

inline

operator*() [3/35]

template<typename T >

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

inline

operator*() [4/35]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 2> viskores::operator* ( const viskores::Vec< T, 2 > &  a, const viskores::Vec< T, 2 > &  b  )

inline

operator*() [5/35]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 2> viskores::operator* ( const viskores::Vec< T, 2 > &  a, T  scalar  )

inline

operator*() [6/35]

template<typename T >

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

inline

operator*() [7/35]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 3> viskores::operator* ( const viskores::Vec< T, 3 > &  a, const viskores::Vec< T, 3 > &  b  )

inline

operator*() [8/35]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 3> viskores::operator* ( const viskores::Vec< T, 3 > &  a, T  scalar  )

inline

operator*() [9/35]

template<typename T >

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

inline

operator*() [10/35]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 4> viskores::operator* ( const viskores::Vec< T, 4 > &  a, const viskores::Vec< T, 4 > &  b  )

inline

operator*() [11/35]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 4> viskores::operator* ( const viskores::Vec< T, 4 > &  a, T  scalar  )

inline

operator*() [12/35]

template<typename T >

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

inline

operator*() [13/35]

VISKORES_EXEC_CONT viskores::Vec<viskores::Float64, 1> viskores::operator* ( const viskores::Vec< viskores::Float64, 1 > &  a, viskores::Float64  scalar  )

inline

operator*() [14/35]

VISKORES_EXEC_CONT viskores::Vec<viskores::Float64, 2> viskores::operator* ( const viskores::Vec< viskores::Float64, 2 > &  a, viskores::Float64  scalar  )

inline

operator*() [15/35]

VISKORES_EXEC_CONT viskores::Vec<viskores::Float64, 3> viskores::operator* ( const viskores::Vec< viskores::Float64, 3 > &  a, viskores::Float64  scalar  )

inline

operator*() [16/35]

VISKORES_EXEC_CONT viskores::Vec<viskores::Float64, 4> viskores::operator* ( const viskores::Vec< viskores::Float64, 4 > &  a, viskores::Float64  scalar  )

inline

operator*() [17/35]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 1> viskores::operator* ( T  scalar, const viskores::Vec< T, 1 > &  a  )

inline

operator*() [18/35]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 2> viskores::operator* ( T  scalar, const viskores::Vec< T, 2 > &  a  )

inline

operator*() [19/35]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 3> viskores::operator* ( T  scalar, const viskores::Vec< T, 3 > &  a  )

inline

operator*() [20/35]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 4> viskores::operator* ( T  scalar, const viskores::Vec< T, 4 > &  a  )

inline

operator*() [21/35]

template<typename T , IdComponent Size>

VISKORES_EXEC_CONT viskores::Vec<T, Size> viskores::operator* ( T  scalar, viskores::Vec< T, Size >  a  )

inline

operator*() [22/35]

template<typename T >

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

inline

operator*() [23/35]

template<typename T >

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

inline

operator*() [24/35]

template<typename T >

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

inline

operator*() [25/35]

template<typename T >

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

inline

operator*() [26/35]

VISKORES_EXEC_CONT viskores::Vec<viskores::Float64, 1> viskores::operator* ( viskores::Float64  scalar, const viskores::Vec< viskores::Float64, 1 > &  a  )

inline

operator*() [27/35]

VISKORES_EXEC_CONT viskores::Vec<viskores::Float64, 2> viskores::operator* ( viskores::Float64  scalar, const viskores::Vec< viskores::Float64, 2 > &  a  )

inline

operator*() [28/35]

VISKORES_EXEC_CONT viskores::Vec<viskores::Float64, 3> viskores::operator* ( viskores::Float64  scalar, const viskores::Vec< viskores::Float64, 3 > &  a  )

inline

operator*() [29/35]

VISKORES_EXEC_CONT viskores::Vec<viskores::Float64, 4> viskores::operator* ( viskores::Float64  scalar, const viskores::Vec< viskores::Float64, 4 > &  a  )

inline

operator*() [30/35]

template<typename T , IdComponent Size>

VISKORES_EXEC_CONT viskores::Vec<T, Size> viskores::operator* ( viskores::Float64  scalar, viskores::Vec< T, Size >  a  )

inline

operator*() [31/35]

template<IdComponent Size>

VISKORES_EXEC_CONT viskores::Vec<viskores::Float64, Size> viskores::operator* ( viskores::Float64  scalar, viskores::Vec< viskores::Float64, Size >  a  )

inline

operator*() [32/35]

template<typename T , IdComponent Size>

VISKORES_EXEC_CONT viskores::Vec<T, Size> viskores::operator* ( viskores::Vec< T, Size >  a, const viskores::Vec< T, Size > &  b  )

inline

operator*() [33/35]

template<typename T , IdComponent Size>

VISKORES_EXEC_CONT viskores::Vec<T, Size> viskores::operator* ( viskores::Vec< T, Size >  a, T  scalar  )

inline

operator*() [34/35]

template<typename T , IdComponent Size>

VISKORES_EXEC_CONT viskores::Vec<T, Size> viskores::operator* ( viskores::Vec< T, Size >  a, viskores::Float64  scalar  )

inline

operator*() [35/35]

template<IdComponent Size>

VISKORES_EXEC_CONT viskores::Vec<viskores::Float64, Size> viskores::operator* ( viskores::Vec< viskores::Float64, Size >  a, viskores::Float64  scalar  )

inline

operator+() [1/36]

template<typename T , typename U >

viskores::Pair<T, U> viskores::operator+	(	const viskores::Pair< T, U > &	a,
		const viskores::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 >

VISKORES_EXEC_CONT viskores::Vec<T, 1> viskores::operator+ ( const viskores::Vec< T, 1 > &  a, const viskores::Vec< T, 1 > &  b  )

inline

operator+() [3/36]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 1> viskores::operator+ ( const viskores::Vec< T, 1 > &  a, T  scalar  )

inline

operator+() [4/36]

template<typename T >

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

inline

operator+() [5/36]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 2> viskores::operator+ ( const viskores::Vec< T, 2 > &  a, const viskores::Vec< T, 2 > &  b  )

inline

operator+() [6/36]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 2> viskores::operator+ ( const viskores::Vec< T, 2 > &  a, T  scalar  )

inline

operator+() [7/36]

template<typename T >

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

inline

operator+() [8/36]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 3> viskores::operator+ ( const viskores::Vec< T, 3 > &  a, const viskores::Vec< T, 3 > &  b  )

inline

operator+() [9/36]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 3> viskores::operator+ ( const viskores::Vec< T, 3 > &  a, T  scalar  )

inline

operator+() [10/36]

template<typename T >

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

inline

operator+() [11/36]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 4> viskores::operator+ ( const viskores::Vec< T, 4 > &  a, const viskores::Vec< T, 4 > &  b  )

inline

operator+() [12/36]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 4> viskores::operator+ ( const viskores::Vec< T, 4 > &  a, T  scalar  )

inline

operator+() [13/36]

template<typename T >

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

inline

operator+() [14/36]

VISKORES_EXEC_CONT viskores::Vec<viskores::Float64, 1> viskores::operator+ ( const viskores::Vec< viskores::Float64, 1 > &  a, viskores::Float64  scalar  )

inline

operator+() [15/36]

VISKORES_EXEC_CONT viskores::Vec<viskores::Float64, 2> viskores::operator+ ( const viskores::Vec< viskores::Float64, 2 > &  a, viskores::Float64  scalar  )

inline

operator+() [16/36]

VISKORES_EXEC_CONT viskores::Vec<viskores::Float64, 3> viskores::operator+ ( const viskores::Vec< viskores::Float64, 3 > &  a, viskores::Float64  scalar  )

inline

operator+() [17/36]

VISKORES_EXEC_CONT viskores::Vec<viskores::Float64, 4> viskores::operator+ ( const viskores::Vec< viskores::Float64, 4 > &  a, viskores::Float64  scalar  )

inline

operator+() [18/36]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 1> viskores::operator+ ( T  scalar, const viskores::Vec< T, 1 > &  a  )

inline

operator+() [19/36]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 2> viskores::operator+ ( T  scalar, const viskores::Vec< T, 2 > &  a  )

inline

operator+() [20/36]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 3> viskores::operator+ ( T  scalar, const viskores::Vec< T, 3 > &  a  )

inline

operator+() [21/36]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 4> viskores::operator+ ( T  scalar, const viskores::Vec< T, 4 > &  a  )

inline

operator+() [22/36]

template<typename T , IdComponent Size>

VISKORES_EXEC_CONT viskores::Vec<T, Size> viskores::operator+ ( T  scalar, viskores::Vec< T, Size >  a  )

inline

operator+() [23/36]

template<typename T >

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

inline

operator+() [24/36]

template<typename T >

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

inline

operator+() [25/36]

template<typename T >

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

inline

operator+() [26/36]

template<typename T >

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

inline

operator+() [27/36]

VISKORES_EXEC_CONT viskores::Vec<viskores::Float64, 1> viskores::operator+ ( viskores::Float64  scalar, const viskores::Vec< viskores::Float64, 1 > &  a  )

inline

operator+() [28/36]

VISKORES_EXEC_CONT viskores::Vec<viskores::Float64, 2> viskores::operator+ ( viskores::Float64  scalar, const viskores::Vec< viskores::Float64, 2 > &  a  )

inline

operator+() [29/36]

VISKORES_EXEC_CONT viskores::Vec<viskores::Float64, 3> viskores::operator+ ( viskores::Float64  scalar, const viskores::Vec< viskores::Float64, 3 > &  a  )

inline

operator+() [30/36]

VISKORES_EXEC_CONT viskores::Vec<viskores::Float64, 4> viskores::operator+ ( viskores::Float64  scalar, const viskores::Vec< viskores::Float64, 4 > &  a  )

inline

operator+() [31/36]

template<typename T , IdComponent Size>

VISKORES_EXEC_CONT viskores::Vec<T, Size> viskores::operator+ ( viskores::Float64  scalar, viskores::Vec< T, Size >  a  )

inline

operator+() [32/36]

template<IdComponent Size>

VISKORES_EXEC_CONT viskores::Vec<viskores::Float64, Size> viskores::operator+ ( viskores::Float64  scalar, viskores::Vec< viskores::Float64, Size >  a  )

inline

operator+() [33/36]

template<typename T , IdComponent Size>

VISKORES_EXEC_CONT viskores::Vec<T, Size> viskores::operator+ ( viskores::Vec< T, Size >  a, const viskores::Vec< T, Size > &  b  )

inline

operator+() [34/36]

template<typename T , IdComponent Size>

VISKORES_EXEC_CONT viskores::Vec<T, Size> viskores::operator+ ( viskores::Vec< T, Size >  a, T  scalar  )

inline

operator+() [35/36]

template<typename T , IdComponent Size>

VISKORES_EXEC_CONT viskores::Vec<T, Size> viskores::operator+ ( viskores::Vec< T, Size >  a, viskores::Float64  scalar  )

inline

operator+() [36/36]

template<IdComponent Size>

VISKORES_EXEC_CONT viskores::Vec<viskores::Float64, Size> viskores::operator+ ( viskores::Vec< viskores::Float64, Size >  a, viskores::Float64  scalar  )

inline

operator-() [1/40]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 1> viskores::operator- ( const viskores::Vec< T, 1 > &  a, const viskores::Vec< T, 1 > &  b  )

inline

operator-() [2/40]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 1> viskores::operator- ( const viskores::Vec< T, 1 > &  a, T  scalar  )

inline

operator-() [3/40]

template<typename T >

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

inline

operator-() [4/40]

template<typename T >

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

inline

operator-() [5/40]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 2> viskores::operator- ( const viskores::Vec< T, 2 > &  a, const viskores::Vec< T, 2 > &  b  )

inline

operator-() [6/40]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 2> viskores::operator- ( const viskores::Vec< T, 2 > &  a, T  scalar  )

inline

operator-() [7/40]

template<typename T >

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

inline

operator-() [8/40]

template<typename T >

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

inline

operator-() [9/40]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 3> viskores::operator- ( const viskores::Vec< T, 3 > &  a, const viskores::Vec< T, 3 > &  b  )

inline

operator-() [10/40]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 3> viskores::operator- ( const viskores::Vec< T, 3 > &  a, T  scalar  )

inline

operator-() [11/40]

template<typename T >

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

inline

operator-() [12/40]

template<typename T >

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

inline

operator-() [13/40]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 4> viskores::operator- ( const viskores::Vec< T, 4 > &  a, const viskores::Vec< T, 4 > &  b  )

inline

operator-() [14/40]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 4> viskores::operator- ( const viskores::Vec< T, 4 > &  a, T  scalar  )

inline

operator-() [15/40]

template<typename T >

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

inline

operator-() [16/40]

template<typename T >

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

inline

operator-() [17/40]

VISKORES_EXEC_CONT viskores::Vec<viskores::Float64, 1> viskores::operator- ( const viskores::Vec< viskores::Float64, 1 > &  a, viskores::Float64  scalar  )

inline

operator-() [18/40]

VISKORES_EXEC_CONT viskores::Vec<viskores::Float64, 2> viskores::operator- ( const viskores::Vec< viskores::Float64, 2 > &  a, viskores::Float64  scalar  )

inline

operator-() [19/40]

VISKORES_EXEC_CONT viskores::Vec<viskores::Float64, 3> viskores::operator- ( const viskores::Vec< viskores::Float64, 3 > &  a, viskores::Float64  scalar  )

inline

operator-() [20/40]

VISKORES_EXEC_CONT viskores::Vec<viskores::Float64, 4> viskores::operator- ( const viskores::Vec< viskores::Float64, 4 > &  a, viskores::Float64  scalar  )

inline

operator-() [21/40]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 1> viskores::operator- ( T  scalar, const viskores::Vec< T, 1 > &  a  )

inline

operator-() [22/40]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 2> viskores::operator- ( T  scalar, const viskores::Vec< T, 2 > &  a  )

inline

operator-() [23/40]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 3> viskores::operator- ( T  scalar, const viskores::Vec< T, 3 > &  a  )

inline

operator-() [24/40]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 4> viskores::operator- ( T  scalar, const viskores::Vec< T, 4 > &  a  )

inline

operator-() [25/40]

template<typename T , IdComponent Size>

VISKORES_EXEC_CONT viskores::Vec<T, Size> viskores::operator- ( T  scalar, viskores::Vec< T, Size >  a  )

inline

operator-() [26/40]

template<typename T >

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

inline

operator-() [27/40]

template<typename T >

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

inline

operator-() [28/40]

template<typename T >

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

inline

operator-() [29/40]

template<typename T >

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

inline

operator-() [30/40]

VISKORES_EXEC_CONT viskores::Vec<viskores::Float64, 1> viskores::operator- ( viskores::Float64  scalar, const viskores::Vec< viskores::Float64, 1 > &  a  )

inline

operator-() [31/40]

VISKORES_EXEC_CONT viskores::Vec<viskores::Float64, 2> viskores::operator- ( viskores::Float64  scalar, const viskores::Vec< viskores::Float64, 2 > &  a  )

inline

operator-() [32/40]

VISKORES_EXEC_CONT viskores::Vec<viskores::Float64, 3> viskores::operator- ( viskores::Float64  scalar, const viskores::Vec< viskores::Float64, 3 > &  a  )

inline

operator-() [33/40]

VISKORES_EXEC_CONT viskores::Vec<viskores::Float64, 4> viskores::operator- ( viskores::Float64  scalar, const viskores::Vec< viskores::Float64, 4 > &  a  )

inline

operator-() [34/40]

template<typename T , IdComponent Size>

VISKORES_EXEC_CONT viskores::Vec<T, Size> viskores::operator- ( viskores::Float64  scalar, viskores::Vec< T, Size >  a  )

inline

operator-() [35/40]

template<IdComponent Size>

VISKORES_EXEC_CONT viskores::Vec<viskores::Float64, Size> viskores::operator- ( viskores::Float64  scalar, viskores::Vec< viskores::Float64, Size >  a  )

inline

operator-() [36/40]

template<typename T , IdComponent Size>

VISKORES_EXEC_CONT viskores::Vec<T, Size> viskores::operator- ( viskores::Vec< T, Size >  a, const viskores::Vec< T, Size > &  b  )

inline

operator-() [37/40]

template<typename T , IdComponent Size>

VISKORES_EXEC_CONT viskores::Vec<T, Size> viskores::operator- ( viskores::Vec< T, Size >  a, T  scalar  )

inline

operator-() [38/40]

template<typename T , IdComponent Size>

VISKORES_EXEC_CONT viskores::Vec<T, Size> viskores::operator- ( viskores::Vec< T, Size >  a, viskores::Float64  scalar  )

inline

operator-() [39/40]

template<typename T , viskores::IdComponent Size>

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

inline

operator-() [40/40]

template<IdComponent Size>

VISKORES_EXEC_CONT viskores::Vec<viskores::Float64, Size> viskores::operator- ( viskores::Vec< viskores::Float64, Size >  a, viskores::Float64  scalar  )

inline

operator/() [1/35]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 1> viskores::operator/ ( const viskores::Vec< T, 1 > &  a, const viskores::Vec< T, 1 > &  b  )

inline

operator/() [2/35]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 1> viskores::operator/ ( const viskores::Vec< T, 1 > &  a, T  scalar  )

inline

operator/() [3/35]

template<typename T >

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

inline

operator/() [4/35]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 2> viskores::operator/ ( const viskores::Vec< T, 2 > &  a, const viskores::Vec< T, 2 > &  b  )

inline

operator/() [5/35]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 2> viskores::operator/ ( const viskores::Vec< T, 2 > &  a, T  scalar  )

inline

operator/() [6/35]

template<typename T >

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

inline

operator/() [7/35]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 3> viskores::operator/ ( const viskores::Vec< T, 3 > &  a, const viskores::Vec< T, 3 > &  b  )

inline

operator/() [8/35]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 3> viskores::operator/ ( const viskores::Vec< T, 3 > &  a, T  scalar  )

inline

operator/() [9/35]

template<typename T >

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

inline

operator/() [10/35]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 4> viskores::operator/ ( const viskores::Vec< T, 4 > &  a, const viskores::Vec< T, 4 > &  b  )

inline

operator/() [11/35]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 4> viskores::operator/ ( const viskores::Vec< T, 4 > &  a, T  scalar  )

inline

operator/() [12/35]

template<typename T >

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

inline

operator/() [13/35]

VISKORES_EXEC_CONT viskores::Vec<viskores::Float64, 1> viskores::operator/ ( const viskores::Vec< viskores::Float64, 1 > &  a, viskores::Float64  scalar  )

inline

operator/() [14/35]

VISKORES_EXEC_CONT viskores::Vec<viskores::Float64, 2> viskores::operator/ ( const viskores::Vec< viskores::Float64, 2 > &  a, viskores::Float64  scalar  )

inline

operator/() [15/35]

VISKORES_EXEC_CONT viskores::Vec<viskores::Float64, 3> viskores::operator/ ( const viskores::Vec< viskores::Float64, 3 > &  a, viskores::Float64  scalar  )

inline

operator/() [16/35]

VISKORES_EXEC_CONT viskores::Vec<viskores::Float64, 4> viskores::operator/ ( const viskores::Vec< viskores::Float64, 4 > &  a, viskores::Float64  scalar  )

inline

operator/() [17/35]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 1> viskores::operator/ ( T  scalar, const viskores::Vec< T, 1 > &  a  )

inline

operator/() [18/35]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 2> viskores::operator/ ( T  scalar, const viskores::Vec< T, 2 > &  a  )

inline

operator/() [19/35]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 3> viskores::operator/ ( T  scalar, const viskores::Vec< T, 3 > &  a  )

inline

operator/() [20/35]

template<typename T >

VISKORES_EXEC_CONT viskores::Vec<T, 4> viskores::operator/ ( T  scalar, const viskores::Vec< T, 4 > &  a  )

inline

operator/() [21/35]

template<typename T , IdComponent Size>

VISKORES_EXEC_CONT viskores::Vec<T, Size> viskores::operator/ ( T  scalar, viskores::Vec< T, Size >  a  )

inline

operator/() [22/35]

template<typename T >

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

inline

operator/() [23/35]

template<typename T >

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

inline

operator/() [24/35]

template<typename T >

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

inline

operator/() [25/35]

template<typename T >

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

inline

operator/() [26/35]

VISKORES_EXEC_CONT viskores::Vec<viskores::Float64, 1> viskores::operator/ ( viskores::Float64  scalar, const viskores::Vec< viskores::Float64, 1 > &  a  )

inline

operator/() [27/35]

VISKORES_EXEC_CONT viskores::Vec<viskores::Float64, 2> viskores::operator/ ( viskores::Float64  scalar, const viskores::Vec< viskores::Float64, 2 > &  a  )

inline

operator/() [28/35]

VISKORES_EXEC_CONT viskores::Vec<viskores::Float64, 3> viskores::operator/ ( viskores::Float64  scalar, const viskores::Vec< viskores::Float64, 3 > &  a  )

inline

operator/() [29/35]

VISKORES_EXEC_CONT viskores::Vec<viskores::Float64, 4> viskores::operator/ ( viskores::Float64  scalar, const viskores::Vec< viskores::Float64, 4 > &  a  )

inline

operator/() [30/35]

template<typename T , IdComponent Size>

VISKORES_EXEC_CONT viskores::Vec<T, Size> viskores::operator/ ( viskores::Float64  scalar, viskores::Vec< T, Size >  a  )

inline

operator/() [31/35]

template<IdComponent Size>

VISKORES_EXEC_CONT viskores::Vec<viskores::Float64, Size> viskores::operator/ ( viskores::Float64  scalar, viskores::Vec< viskores::Float64, Size >  a  )

inline

operator/() [32/35]

template<typename T , IdComponent Size>

VISKORES_EXEC_CONT viskores::Vec<T, Size> viskores::operator/ ( viskores::Vec< T, Size >  a, const viskores::Vec< T, Size > &  b  )

inline

operator/() [33/35]

template<typename T , IdComponent Size>

VISKORES_EXEC_CONT viskores::Vec<T, Size> viskores::operator/ ( viskores::Vec< T, Size >  a, T  scalar  )

inline

operator/() [34/35]

template<typename T , IdComponent Size>

VISKORES_EXEC_CONT viskores::Vec<T, Size> viskores::operator/ ( viskores::Vec< T, Size >  a, viskores::Float64  scalar  )

inline

operator/() [35/35]

template<IdComponent Size>

VISKORES_EXEC_CONT viskores::Vec<viskores::Float64, Size> viskores::operator/ ( viskores::Vec< viskores::Float64, Size >  a, viskores::Float64  scalar  )

inline

operator<<() [1/8]

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

inline

operator<<() [2/8]

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

inline

Helper function for printing bounds during testing.

operator<<() [3/8]

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

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

Helper function for printing out matricies during testing.

operator<<() [4/8]

template<typename T , typename U >

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

inline

Helper function for printing out pairs during testing.

operator<<() [5/8]

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

inline

Helper function for printing ranges during testing.

operator<<() [6/8]

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

inline

Helper function for printing range during testing.

operator<<() [7/8]

template<typename T , viskores::IdComponent Size>

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

inline

Helper function for printing out vectors during testing.

operator<<() [8/8]

template<viskores::IdComponent NumDimensions>

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

inline

Helper function for printing out vectors during testing.

operator==()

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

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

Orthonormalize()

template<typename T , int N>

int viskores::Orthonormalize	(	const viskores::Vec< viskores::Vec< T, N >, N > &	inputs,
		viskores::Vec< viskores::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>

viskores::Vec<T, N> viskores::Project	(	const viskores::Vec< T, N > &	v,
		const viskores::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 viskores::ProjectedDistance	(	const viskores::Vec< T, N > &	v,
		const viskores::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 >

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

inline

Solves ax² + bx + c = 0.

Only returns the real roots. If there are real roots, the first element of the pair is less than or equal to the second. If there are no real roots, both elements are NaNs. If Viskores is compiled with FMA support, each root is accurate to 3 ulps; otherwise the discriminant is prone to catastrophic subtractive cancellation and no accuracy guarantees can be provided.

ReduceProduct() [1/4]

template<typename T >

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

inline

ReduceProduct() [2/4]

template<typename T >

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

inline

ReduceProduct() [3/4]

template<typename T >

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

inline

ReduceProduct() [4/4]

template<typename T , viskores::IdComponent Size>

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

inline

ReduceSum() [1/4]

template<typename T >

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

inline

ReduceSum() [2/4]

template<typename T >

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

inline

ReduceSum() [3/4]

template<typename T >

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

inline

ReduceSum() [4/4]

template<typename T , viskores::IdComponent Size>

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

inline

RMagnitude()

template<typename T >

detail::FloatingPointReturnType<T>::Type viskores::RMagnitude

(

const T &

x

)

Returns the reciprocal magnitude of a vector.

On some hardware RMagnitude is faster than Magnitude, but neither is as fast as MagnitudeSquared. This function works on scalars as well as vectors, in which case it just returns the reciprocal of the scalar.

Round() [1/2]

viskores::Float32 viskores::Round ( viskores::Float32  x )

inline

Round x to the nearest integral value.

Round() [2/2]

viskores::Float64 viskores::Round ( viskores::Float64  x )

inline

Round x to the nearest integral value.

Sin() [1/2]

viskores::Float32 viskores::Sin ( viskores::Float32  x )

inline

Compute the sine of x.

Sin() [2/2]

viskores::Float64 viskores::Sin ( viskores::Float64  x )

inline

Compute the sine of x.

SinH() [1/2]

viskores::Float32 viskores::SinH ( viskores::Float32  x )

inline

Compute the hyperbolic sine of x.

SinH() [2/2]

viskores::Float64 viskores::SinH ( viskores::Float64  x )

inline

Compute the hyperbolic sine of x.

SolveLinearSystem()

template<typename T , viskores::IdComponent Size>

viskores::Vec<T, Size> viskores::SolveLinearSystem	(	const viskores::Matrix< T, Size, Size > &	A,
		const viskores::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]

viskores::Float32 viskores::Sqrt ( viskores::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]

viskores::Float64 viskores::Sqrt ( viskores::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 viskores::Swap ( T &  a, T &  b  )

inline

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

Tan() [1/2]

viskores::Float32 viskores::Tan ( viskores::Float32  x )

inline

Compute the tangent of x.

Tan() [2/2]

viskores::Float64 viskores::Tan ( viskores::Float64  x )

inline

Compute the tangent of x.

TanH() [1/2]

viskores::Float32 viskores::TanH ( viskores::Float32  x )

inline

Compute the hyperbolic tangent of x.

TanH() [2/2]

viskores::Float64 viskores::TanH ( viskores::Float64  x )

inline

Compute the hyperbolic tangent of x.

Transform() [1/2]

template<typename TupleType , typename Function >

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

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

The viskores::Transform function builds a new viskores::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 viskores::Transform	(	TupleType &&	tuple,
		Function &&	f
	)		-> decltype(Apply(tuple, detail::TupleTransformFunctor(), std::forward<Function>(f)))

Get the size of a tuple.

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

Transform3DPoint()

template<typename T >

viskores::Vec<T, 3> viskores::Transform3DPoint	(	const viskores::Matrix< T, 4, 4 > &	matrix,
		const viskores::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 >

viskores::Vec<T, 3> viskores::Transform3DPointPerspective	(	const viskores::Matrix< T, 4, 4 > &	matrix,
		const viskores::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 >

viskores::Matrix<T, 4, 4> viskores::Transform3DRotate	(	T	angleDegrees,
		const viskores::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 >

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

Transform3DRotateX()

template<typename T >

viskores::Matrix<T, 4, 4> viskores::Transform3DRotateX

(

T

angleDegrees

)

Returns a rotation matrix.

Returns a transformation matrix that rotates around the x axis.

Transform3DRotateY()

template<typename T >

viskores::Matrix<T, 4, 4> viskores::Transform3DRotateY

(

T

angleDegrees

)

Returns a rotation matrix.

Returns a transformation matrix that rotates around the y axis.

Transform3DRotateZ()

template<typename T >

viskores::Matrix<T, 4, 4> viskores::Transform3DRotateZ

(

T

angleDegrees

)

Returns a rotation matrix.

Returns a transformation matrix that rotates around the z axis.

Transform3DScale() [1/3]

template<typename T >

viskores::Matrix<T, 4, 4> viskores::Transform3DScale

(

const T &

scale

)

Returns a scale matrix.

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

Transform3DScale() [2/3]

template<typename T >

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

Returns a scale matrix.

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

Transform3DScale() [3/3]

template<typename T >

viskores::Matrix<T, 4, 4> viskores::Transform3DScale

(

const viskores::Vec< T, 3 > &

scaleVec

)

Returns a scale matrix.

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

Transform3DTranslate() [1/2]

template<typename T >

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

Returns a translation matrix.

Transform3DTranslate() [2/2]

template<typename T >

viskores::Matrix<T, 4, 4> viskores::Transform3DTranslate

(

const viskores::Vec< T, 3 > &

v

)

Transform3DVector()

template<typename T >

viskores::Vec<T, 3> viskores::Transform3DVector	(	const viskores::Matrix< T, 4, 4 > &	matrix,
		const viskores::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 >

viskores::Vec<typename detail::FloatingPointReturnType<T>::Type, 3> viskores::TriangleNormal	(	const viskores::Vec< T, 3 > &	a,
		const viskores::Vec< T, 3 > &	b,
		const viskores::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 viskores::Normal() or viskores::Normalize() function.

UpperBound() [1/4]

template<typename PortalT , typename T >

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

viskores::Id viskores::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 viskores::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 viskores::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.