VTK-m  1.5
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
vtkm Namespace Reference

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

Namespaces

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

Classes

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

Typedefs

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

Enumerations

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

Functions

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

Variables

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

Detailed Description

Groups connected points that have the same field value.

Worklet for volume algorithms that require a neighborhood.

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

VTK-m Toolkit.

Median algorithm for general image blur.

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

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

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

Default output field name is 'median'

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

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

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

Typedef Documentation

◆ AllMeasures

◆ ArcLength

◆ Area

◆ AtomicTypePreferred

The preferred type to use for atomic operations.

◆ AtomicTypesSupported

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

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

TODO: Adjust based on devices being compiled.

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

◆ BufferSizeType

using vtkm::BufferSizeType = typedef vtkm::Int64

◆ Circle

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

Circle is an alias for a 2-Dimensional sphere.

◆ Circle2d

◆ Float32

using vtkm::Float32 = typedef float

◆ Float64

using vtkm::Float64 = typedef double

◆ FloatDefault

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

◆ HashType

using vtkm::HashType = typedef vtkm::UInt32

◆ HasVecTraits

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

Determines whether the given type has VecTraits defined.

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

◆ Id

using vtkm::Id = typedef vtkm::Int32

Represents an ID (index into arrays).

◆ Id2

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

Id2 corresponds to a 2-dimensional index.

◆ Id3

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

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

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

◆ Id4

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

Id4 corresponds to a 4-dimensional index.

◆ IdComponent

using vtkm::IdComponent = typedef vtkm::Int32

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

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

◆ IdComponent2

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

◆ IdComponent3

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

◆ IdComponent4

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

◆ Int16

using vtkm::Int16 = typedef int16_t

◆ Int32

using vtkm::Int32 = typedef int32_t

◆ Int8

using vtkm::Int8 = typedef int8_t

◆ Line

template<typename CoordType , int Dim = 3>
using vtkm::Line = typedef Ray<CoordType, Dim, true>

Lines are two-sided rays:

◆ Line2

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

◆ Line2d

◆ Line3

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

◆ Line3d

◆ LineSegment2

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

◆ LineSegment2d

◆ LineSegment3

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

◆ LineSegment3d

◆ ListAppend

template<typename... Lists>
using vtkm::ListAppend = typedef brigand::append<internal::AsList<Lists>...>

Concatinates a set of lists into a single list.

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

◆ ListApply

template<typename List , template< typename... > class Target>
typedef typename detail::ListTagApplyImpl< internal::ListTagAsBrigandList< ListTag >, Target >::type vtkm::ListApply

Applies the list of types to a template.

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

◆ ListAt

template<typename List , vtkm::IdComponent Index>
using vtkm::ListAt = typedef brigand::at<internal::AsList<List>, std::integral_constant<vtkm::IdComponent, Index> >

Finds the type at the given index.

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

◆ ListCross

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

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

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

◆ ListEmpty

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

A special tag for an empty list.

◆ ListHas

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

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

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

◆ ListIndexOf

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

Finds the index of a given type.

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

◆ ListIntersect

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

Constructs a list containing types present in all lists.

◆ ListRemoveIf

template<typename List , template< typename > class Predicate>
using vtkm::ListRemoveIf = typedef brigand::remove_if<internal::AsList<List>, brigand::bind<Predicate, brigand::_1> >

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

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

◆ ListSize

template<typename List >
using vtkm::ListSize = typedef std::integral_constant<vtkm::IdComponent, vtkm::IdComponent{ brigand::size<internal::AsList<List> >::value }>

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

◆ ListTransform

template<typename List , template< typename > class Transform>
using vtkm::ListTransform = typedef typename detail::ListTransformImpl<internal::AsList<List>, Transform>::type

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

◆ ListUniversal

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

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

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

◆ Plane3d

◆ Ray2

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

◆ Ray2d

◆ Ray3

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

◆ Ray3d

◆ Sphere2

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

◆ Sphere2d

◆ Sphere3

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

◆ Sphere3d

◆ tuple_element_t

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

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

◆ tuple_size

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

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

◆ TupleElement

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

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

◆ TupleSize

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

Get the size of a tuple.

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

◆ TypeListAll

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

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

◆ TypeListCommon

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

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

◆ TypeListField

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

A list containing types used for scalar fields.

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

◆ TypeListFieldVec2

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

◆ TypeListFieldVec3

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

◆ TypeListFieldVec4

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

◆ TypeListFloatVec

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

A list containing the type vtkm::Id.

◆ TypeListId2

A list containing the type vtkm::Id2.

◆ TypeListId3

A list containing the type vtkm::Id3.

◆ TypeListId4

A list containing the type vtkm::Id4.

◆ TypeListIdComponent

A list containing the type vtkm::IdComponent.

◆ TypeListIndex

A list containing types used to index arrays.

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

◆ TypeListScalarAll

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

A scalar is a type that holds a single number.

◆ TypeListVecAll

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

◆ TypeListVecCommon

A list of the most commonly use Vec classes.

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

◆ UInt16

using vtkm::UInt16 = typedef uint16_t

◆ UInt32

using vtkm::UInt32 = typedef uint32_t

◆ UInt8

using vtkm::UInt8 = typedef uint8_t

◆ Vec2f

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

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

◆ Vec2f_32

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

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

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

◆ Vec2f_64

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

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

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

◆ Vec2i

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

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

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

◆ Vec2i_16

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

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

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

◆ Vec2i_32

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

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

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

◆ Vec2i_64

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

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

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

◆ Vec2i_8

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

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

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

◆ Vec2ui

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

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

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

◆ Vec2ui_16

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

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

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

◆ Vec2ui_32

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

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

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

◆ Vec2ui_64

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

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

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

◆ Vec2ui_8

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

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

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

◆ Vec3f

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

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

◆ Vec3f_32

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

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

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

◆ Vec3f_64

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

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

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

◆ Vec3i

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

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

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

◆ Vec3i_16

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

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

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

◆ Vec3i_32

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

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

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

◆ Vec3i_64

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

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

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

◆ Vec3i_8

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

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

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

◆ Vec3ui

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

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

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

◆ Vec3ui_16

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

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

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

◆ Vec3ui_32

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

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

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

◆ Vec3ui_64

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

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

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

◆ Vec3ui_8

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

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

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

◆ Vec4f

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

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

◆ Vec4f_32

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

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

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

◆ Vec4f_64

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

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

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

◆ Vec4i

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

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

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

◆ Vec4i_16

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

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

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

◆ Vec4i_32

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

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

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

◆ Vec4i_64

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

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

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

◆ Vec4i_8

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

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

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

◆ Vec4ui

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

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

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

◆ Vec4ui_16

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

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

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

◆ Vec4ui_32

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

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

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

◆ Vec4ui_64

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

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

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

◆ Vec4ui_8

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

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

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

◆ Volume

◆ WordTypeDefault

The default word size used for atomic bitwise operations.

Universally supported on all devices.

Enumeration Type Documentation

◆ CellClassification

Enumerator
NORMAL 
GHOST 
INVALID 
UNUSED0 
UNUSED1 
UNUSED3 
UNUSED4 
UNUSED5 

◆ CellShapeIdEnum

CellShapeId identifies the type of each cell.

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

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

◆ ColorSpace

enum vtkm::ColorSpace
strong
Enumerator
RGB 
HSV 
HSVWrap 
Lab 
Diverging 

◆ CopyFlag

enum vtkm::CopyFlag
strong
Enumerator
Off 
On 

◆ ErrorCode

enum vtkm::ErrorCode
strong
Enumerator
Success 
InvalidShapeId 
InvalidNumberOfPoints 
InvalidCellMetric 
WrongShapeIdForTagType 
InvalidPointId 
InvalidEdgeId 
InvalidFaceId 
SolutionDidNotConverge 
MatrixFactorizationFailed 
DegenerateCellDetected 
MalformedCellDetected 
OperationOnEmptyCell 
CellNotFound 
UnknownError 

◆ MemoryOrder

enum vtkm::MemoryOrder
strong

Specifies memory order semantics for atomic operations.

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

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

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

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

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

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

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

Enumerator
Relaxed 

An atomic operations with Relaxed memory order enforces no synchronization or ordering constraints on local reads and writes.

That is, a read or write to a local, non-atomic variable may be moved to before or after an atomic operation with Relaxed memory order.

Acquire 

A load operation with Acquire memory order will enforce that any local read or write operations listed in the program after the atomic will happen after the atomic.

Release 

A store operation with Release memory order will enforce that any local read or write operations listed in the program before the atomic will happen before the atomic.

AcquireAndRelease 

A read-modify-write operation with AcquireAndRelease memory order will enforce that any local read or write operations listed in the program before the atomic will happen before the atomic and likewise any read or write operations listed in the program after the atomic will happen after the atomic.

SequentiallyConsistent 

An atomic with SequentiallyConsistent memory order will enforce any appropriate semantics as Acquire, Release, and AcquireAndRelease.

Additionally, SequentiallyConsistent will enforce a consistent ordering of atomic operations across all threads. That is, all threads observe the modifications in the same order.

Function Documentation

◆ ACos() [1/2]

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

Compute the arc cosine of x.

◆ ACos() [2/2]

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

◆ ACosH() [1/2]

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

Compute the hyperbolic arc cosine of x.

◆ ACosH() [2/2]

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

◆ ASin() [1/2]

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

Compute the arc sine of x.

◆ ASin() [2/2]

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

◆ ASinH() [1/2]

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

Compute the hyperbolic arc sine of x.

◆ ASinH() [2/2]

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

◆ ATan() [1/2]

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

Compute the arc tangent of x.

◆ ATan() [2/2]

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

◆ ATanH() [1/2]

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

Compute the hyperbolic arc tangent of x.

◆ ATanH() [2/2]

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

◆ AtomicAdd() [1/2]

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

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

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

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

◆ AtomicAdd() [2/2]

template<typename T >
VTKM_EXEC_CONT T vtkm::AtomicAdd ( T *  pointer,
operand,
vtkm::MemoryOrder  order = vtkm::MemoryOrder::SequentiallyConsistent 
)
inline

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

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

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

◆ AtomicAnd() [1/2]

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

Atomic function to AND bits to a shared memory location.

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

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

◆ AtomicAnd() [2/2]

template<typename T >
VTKM_EXEC_CONT T vtkm::AtomicAnd ( T *  pointer,
operand,
vtkm::MemoryOrder  order = vtkm::MemoryOrder::SequentiallyConsistent 
)
inline

Atomic function to AND bits to a shared memory location.

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

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

◆ AtomicCompareExchange()

template<typename T >
VTKM_EXEC_CONT T vtkm::AtomicCompareExchange ( T *  shared,
T *  expected,
desired,
vtkm::MemoryOrder  order = vtkm::MemoryOrder::SequentiallyConsistent 
)
inline

Atomic function that replaces a value given a condition.

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

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

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

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

◆ AtomicLoad()

template<typename T >
VTKM_EXEC_CONT T vtkm::AtomicLoad ( T *const  pointer,
vtkm::MemoryOrder  order = vtkm::MemoryOrder::Acquire 
)
inline

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

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

◆ AtomicNot()

template<typename T >
VTKM_EXEC_CONT T vtkm::AtomicNot ( T *  pointer,
vtkm::MemoryOrder  order = vtkm::MemoryOrder::SequentiallyConsistent 
)
inline

Atomic function to NOT bits to a shared memory location.

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

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

◆ AtomicOr() [1/2]

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

Atomic function to OR bits to a shared memory location.

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

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

◆ AtomicOr() [2/2]

template<typename T >
VTKM_EXEC_CONT T vtkm::AtomicOr ( T *  pointer,
operand,
vtkm::MemoryOrder  order = vtkm::MemoryOrder::SequentiallyConsistent 
)
inline

Atomic function to OR bits to a shared memory location.

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

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

◆ AtomicStore() [1/2]

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

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

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

◆ AtomicStore() [2/2]

template<typename T >
VTKM_EXEC_CONT void vtkm::AtomicStore ( T *  pointer,
value,
vtkm::MemoryOrder  order = vtkm::MemoryOrder::Release 
)
inline

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

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

◆ AtomicXor() [1/2]

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

Atomic function to XOR bits to a shared memory location.

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

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

◆ AtomicXor() [2/2]

template<typename T >
VTKM_EXEC_CONT T vtkm::AtomicXor ( T *  pointer,
operand,
vtkm::MemoryOrder  order = vtkm::MemoryOrder::SequentiallyConsistent 
)
inline

Atomic function to XOR bits to a shared memory location.

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

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

◆ BinarySearch() [1/4]

template<typename PortalT , typename T >
VTKM_EXEC_CONT vtkm::Id vtkm::BinarySearch ( const PortalT &  portal,
const T &  val 
)

Similar to std::lower_bound and std::upper_bound, but returns the index of any matching item (rather than a specific one).

Returns -1 when val is not found.

◆ BinarySearch() [2/4]

template<typename PortalT , typename T , typename Comp >
VTKM_EXEC_CONT vtkm::Id vtkm::BinarySearch ( const PortalT &  portal,
const T &  val,
Comp  comp 
)

Similar to std::lower_bound and std::upper_bound, but returns the index of any matching item (rather than a specific one).

Returns -1 when val is not found.

◆ BinarySearch() [3/4]

template<typename IterT , typename T >
VTKM_EXEC_CONT IterT vtkm::BinarySearch ( IterT  first,
IterT  last,
const T &  val 
)

Similar to std::lower_bound and std::upper_bound, but returns an iterator to any matching item (rather than a specific one).

Returns last when val is not found.

◆ BinarySearch() [4/4]

template<typename IterT , typename T , typename Comp >
VTKM_EXEC_CONT IterT vtkm::BinarySearch ( IterT  first,
IterT  last,
const T &  val,
Comp  comp 
)

Similar to std::lower_bound and std::upper_bound, but returns an iterator to any matching item (rather than a specific one).

Returns last when val is not found.

◆ Cbrt() [1/2]

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

Compute the cube root of x.

◆ Cbrt() [2/2]

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

◆ Ceil() [1/2]

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

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

◆ Ceil() [2/2]

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

◆ Clamp() [1/2]

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

Clamp x to the given range.

◆ Clamp() [2/2]

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

◆ Cos() [1/2]

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

Compute the cosine of x.

◆ Cos() [2/2]

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

◆ CosH() [1/2]

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

Compute the hyperbolic cosine of x.

◆ CosH() [2/2]

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

◆ CountSetBits() [1/2]

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

Count the total number of bits set in word.

◆ CountSetBits() [2/2]

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

Count the total number of bits set in word.

◆ Cross()

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

Find the cross product of two vectors.

◆ ErrorString()

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

◆ Exp() [1/2]

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

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

◆ Exp() [2/2]

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

◆ Exp2() [1/2]

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

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

◆ Exp2() [2/2]

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

◆ ExpM1() [1/2]

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

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

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

◆ ExpM1() [2/2]

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

◆ FindFirstSetBit() [1/2]

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

Bitwise operations.

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

◆ FindFirstSetBit() [2/2]

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

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

If no bits are set, returns 0.

◆ FloatDistance() [1/2]

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

◆ FloatDistance() [2/2]

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

◆ Floor() [1/2]

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

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

◆ Floor() [2/2]

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

◆ Frexp() [1/2]

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

Decompose floating poing value.

◆ Frexp() [2/2]

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

◆ Get() [1/2]

template<vtkm::IdComponent Index, typename... Ts>
VTKM_SUPPRESS_EXEC_WARNINGS VTKM_EXEC_CONT auto vtkm::Get ( const vtkm::Tuple< Ts... > &  tuple) -> decltype(tuple.template Get<Index>())

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

◆ get() [1/2]

template<std::size_t Index, typename... Ts>
VTKM_SUPPRESS_EXEC_WARNINGS VTKM_EXEC_CONT auto vtkm::get ( const vtkm::Tuple< Ts... > &  tuple) -> decltype(vtkm::Get<static_cast<vtkm::IdComponent>(Index)>(tuple))

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

◆ Get() [2/2]

template<vtkm::IdComponent Index, typename... Ts>
VTKM_SUPPRESS_EXEC_WARNINGS VTKM_EXEC_CONT auto vtkm::Get ( vtkm::Tuple< Ts... > &  tuple) -> decltype(tuple.template Get<Index>())

Get the size of a tuple.

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

◆ get() [2/2]

template<std::size_t Index, typename... Ts>
VTKM_SUPPRESS_EXEC_WARNINGS VTKM_EXEC_CONT auto vtkm::get ( vtkm::Tuple< Ts... > &  tuple) -> decltype(vtkm::Get<static_cast<vtkm::IdComponent>(Index)>(tuple))

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

◆ Hash()

template<typename InVecType >
VTKM_EXEC_CONT vtkm::HashType vtkm::Hash ( const InVecType &  inVec)
inline

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

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

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

◆ Ldexp() [1/2]

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

◆ Ldexp() [2/2]

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

◆ Lerp() [1/3]

template<typename ValueType , typename WeightType >
VTKM_EXEC_CONT ValueType vtkm::Lerp ( const ValueType &  value0,
const ValueType &  value1,
const WeightType &  weight 
)
inline

Returns the linear interpolation of two values based on weight.

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

◆ Lerp() [2/3]

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

◆ Lerp() [3/3]

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

◆ ListForEach()

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

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

◆ Log() [1/2]

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

Computes the natural logarithm of x.

◆ Log() [2/2]

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

◆ Log10() [1/2]

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

Computes the logarithm base 10 of x.

◆ Log10() [2/2]

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

◆ Log1P() [1/2]

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

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

◆ Log1P() [2/2]

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

◆ Log2() [1/2]

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

Computes the logarithm base 2 of x.

◆ Log2() [2/2]

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

◆ LowerBound() [1/4]

template<typename PortalT , typename T >
VTKM_EXEC_CONT vtkm::Id vtkm::LowerBound ( const PortalT &  portal,
const T &  val 
)

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

The overloads that take portals return indices instead of iterators.

◆ LowerBound() [2/4]

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

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

The overloads that take portals return indices instead of iterators.

◆ LowerBound() [3/4]

template<typename IterT , typename T >
VTKM_EXEC_CONT IterT vtkm::LowerBound ( IterT  first,
IterT  last,
const T &  val 
)

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

The overloads that take portals return indices instead of iterators.

◆ LowerBound() [4/4]

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

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

The overloads that take portals return indices instead of iterators.

◆ Magnitude()

template<typename T >
VTKM_EXEC_CONT detail::FloatingPointReturnType<T>::Type vtkm::Magnitude ( const T &  x)

Returns the magnitude of a vector.

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

◆ MagnitudeSquared()

template<typename T >
VTKM_EXEC_CONT detail::FloatingPointReturnType<T>::Type vtkm::MagnitudeSquared ( const T &  x)

Returns the square of the magnitude of a vector.

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

◆ make_ArrayPortalRef() [1/2]

template<typename T >
ArrayPortalRef<T> vtkm::make_ArrayPortalRef ( const ArrayPortalVirtual< T > *  portal,
vtkm::Id  numValues 
)
inlinenoexcept

◆ make_ArrayPortalRef() [2/2]

template<typename T >
vtkm::cont::ArrayPortalRef<T> vtkm::make_ArrayPortalRef ( std::shared_ptr< vtkm::ArrayPortalVirtual< T >>  portal,
vtkm::Id  numValues 
)
inline

◆ make_CircleFrom3Points()

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

Construct a circle from 3 points.

◆ make_Pair()

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

◆ make_PlaneFromPointAndLine()

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

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

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

◆ make_PlaneFromPointAndLineSegment()

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

◆ make_SphereFrom4Points()

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

Construct a sphere from 4 points.

◆ make_tuple()

template<typename... Ts>
VTKM_SUPPRESS_EXEC_WARNINGS VTKM_EXEC_CONT auto vtkm::make_tuple ( Ts &&...  args) -> decltype(vtkm::MakeTuple(std::forward<Ts>(args)...))

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

◆ make_Vec()

template<typename T , typename... Ts>
constexpr VTKM_EXEC_CONT vtkm::Vec<T, vtkm::IdComponent(sizeof...(Ts) + 1)> vtkm::make_Vec ( 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_VecFromPortalPermute() [1/2]

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

◆ make_VecFromPortalPermute() [2/2]

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

◆ MakeTuple()

template<typename... Ts>
VTKM_SUPPRESS_EXEC_WARNINGS VTKM_EXEC_CONT auto vtkm::MakeTuple ( Ts &&...  args) -> vtkm::Tuple<typename std::decay<Ts>::type...>

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

◆ MatrixDeterminant() [1/4]

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

◆ MatrixDeterminant() [2/4]

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

◆ MatrixDeterminant() [3/4]

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

◆ MatrixDeterminant() [4/4]

template<typename T , vtkm::IdComponent Size>
VTKM_EXEC_CONT T vtkm::MatrixDeterminant ( const vtkm::Matrix< T, Size, Size > &  A)

Compute the determinant of a matrix.

◆ MatrixGetColumn()

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

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

Might not be as efficient as the MatrixGetRow function.

◆ MatrixGetRow()

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

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

◆ MatrixIdentity() [1/2]

template<typename T , vtkm::IdComponent Size>
VTKM_EXEC_CONT vtkm::Matrix<T, Size, Size> vtkm::MatrixIdentity ( )

Returns the identity matrix.

◆ MatrixIdentity() [2/2]

template<typename T , vtkm::IdComponent Size>
VTKM_EXEC_CONT void vtkm::MatrixIdentity ( vtkm::Matrix< T, Size, Size > &  matrix)

Fills the given matrix with the identity matrix.

◆ MatrixInverse()

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

Find and return the inverse of the given matrix.

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

◆ MatrixMultiply() [1/3]

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

Standard matrix-vector multiplication.

◆ MatrixMultiply() [2/3]

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

Standard matrix multiplication.

◆ MatrixMultiply() [3/3]

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

Standard vector-matrix multiplication.

◆ MatrixSetColumn()

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

Convenience function for setting a column of a matrix.

◆ MatrixSetRow()

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

Convenience function for setting a row of a matrix.

◆ MatrixTranspose()

template<typename T , vtkm::IdComponent NumRows, vtkm::IdComponent NumCols>
VTKM_EXEC_CONT vtkm::Matrix<T, NumCols, NumRows> vtkm::MatrixTranspose ( const vtkm::Matrix< T, NumRows, NumCols > &  matrix)

Returns the transpose of the given matrix.

◆ NewtonsMethod()

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

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

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

◆ Normal()

template<typename T >
VTKM_EXEC_CONT T vtkm::Normal ( const T &  x)

Returns a normalized version of the given vector.

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

◆ Normalize()

template<typename T >
VTKM_EXEC_CONT void vtkm::Normalize ( T &  x)

Changes a vector to be normal.

The given vector is scaled to be unit length.

◆ operator!=()

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

◆ operator*() [1/35]

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

◆ operator*() [2/35]

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

◆ operator*() [3/35]

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

◆ operator*() [4/35]

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

◆ operator*() [5/35]

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

◆ operator*() [6/35]

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

◆ operator*() [7/35]

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

◆ operator*() [8/35]

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

◆ operator*() [9/35]

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

◆ operator*() [10/35]

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

◆ operator*() [11/35]

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

◆ operator*() [12/35]

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

◆ operator*() [13/35]

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

◆ operator*() [14/35]

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

◆ operator*() [15/35]

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

◆ operator*() [16/35]

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

◆ operator*() [17/35]

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

◆ operator*() [18/35]

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

◆ operator*() [19/35]

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

◆ operator*() [20/35]

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

◆ operator*() [21/35]

template<typename T , IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec<T, Size> vtkm::operator* ( scalar,
vtkm::Vec< T, Size >  a 
)
inline

◆ operator*() [22/35]

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

◆ operator*() [23/35]

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

◆ operator*() [24/35]

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

◆ operator*() [25/35]

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

◆ operator*() [26/35]

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

◆ operator*() [27/35]

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

◆ operator*() [28/35]

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

◆ operator*() [29/35]

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

◆ operator*() [30/35]

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

◆ operator*() [31/35]

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

◆ operator*() [32/35]

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

◆ operator*() [33/35]

template<typename T , IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec<T, Size> vtkm::operator* ( vtkm::Vec< T, Size >  a,
scalar 
)
inline

◆ operator*() [34/35]

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

◆ operator*() [35/35]

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

◆ operator+() [1/36]

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

Pairwise Add.

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

◆ operator+() [2/36]

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

◆ operator+() [3/36]

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

◆ operator+() [4/36]

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

◆ operator+() [5/36]

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

◆ operator+() [6/36]

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

◆ operator+() [7/36]

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

◆ operator+() [8/36]

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

◆ operator+() [9/36]

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

◆ operator+() [10/36]

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

◆ operator+() [11/36]

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

◆ operator+() [12/36]

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

◆ operator+() [13/36]

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

◆ operator+() [14/36]

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

◆ operator+() [15/36]

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

◆ operator+() [16/36]

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

◆ operator+() [17/36]

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

◆ operator+() [18/36]

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

◆ operator+() [19/36]

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

◆ operator+() [20/36]

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

◆ operator+() [21/36]

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

◆ operator+() [22/36]

template<typename T , IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec<T, Size> vtkm::operator+ ( scalar,
vtkm::Vec< T, Size >  a 
)
inline

◆ operator+() [23/36]

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

◆ operator+() [24/36]

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

◆ operator+() [25/36]

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

◆ operator+() [26/36]

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

◆ operator+() [27/36]

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

◆ operator+() [28/36]

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

◆ operator+() [29/36]

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

◆ operator+() [30/36]

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

◆ operator+() [31/36]

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

◆ operator+() [32/36]

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

◆ operator+() [33/36]

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

◆ operator+() [34/36]

template<typename T , IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec<T, Size> vtkm::operator+ ( vtkm::Vec< T, Size >  a,
scalar 
)
inline

◆ operator+() [35/36]

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

◆ operator+() [36/36]

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

◆ operator-() [1/40]

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

◆ operator-() [2/40]

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

◆ operator-() [3/40]

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

◆ operator-() [4/40]

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

◆ operator-() [5/40]

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

◆ operator-() [6/40]

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

◆ operator-() [7/40]

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

◆ operator-() [8/40]

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

◆ operator-() [9/40]

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

◆ operator-() [10/40]

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

◆ operator-() [11/40]

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

◆ operator-() [12/40]

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

◆ operator-() [13/40]

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

◆ operator-() [14/40]

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

◆ operator-() [15/40]

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

◆ operator-() [16/40]

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

◆ operator-() [17/40]

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

◆ operator-() [18/40]

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

◆ operator-() [19/40]

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

◆ operator-() [20/40]

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

◆ operator-() [21/40]

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

◆ operator-() [22/40]

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

◆ operator-() [23/40]

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

◆ operator-() [24/40]

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

◆ operator-() [25/40]

template<typename T , IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec<T, Size> vtkm::operator- ( scalar,
vtkm::Vec< T, Size >  a 
)
inline

◆ operator-() [26/40]

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

◆ operator-() [27/40]

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

◆ operator-() [28/40]

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

◆ operator-() [29/40]

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

◆ operator-() [30/40]

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

◆ operator-() [31/40]

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

◆ operator-() [32/40]

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

◆ operator-() [33/40]

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

◆ operator-() [34/40]

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

◆ operator-() [35/40]

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

◆ operator-() [36/40]

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

◆ operator-() [37/40]

template<typename T , IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec<T, Size> vtkm::operator- ( vtkm::Vec< T, Size >  a,
scalar 
)
inline

◆ operator-() [38/40]

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

◆ operator-() [39/40]

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

◆ operator-() [40/40]

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

◆ operator/() [1/35]

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

◆ operator/() [2/35]

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

◆ operator/() [3/35]

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

◆ operator/() [4/35]

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

◆ operator/() [5/35]

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

◆ operator/() [6/35]

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

◆ operator/() [7/35]

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

◆ operator/() [8/35]

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

◆ operator/() [9/35]

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

◆ operator/() [10/35]

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

◆ operator/() [11/35]

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

◆ operator/() [12/35]

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

◆ operator/() [13/35]

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

◆ operator/() [14/35]

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

◆ operator/() [15/35]

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

◆ operator/() [16/35]

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

◆ operator/() [17/35]

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

◆ operator/() [18/35]

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

◆ operator/() [19/35]

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

◆ operator/() [20/35]

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

◆ operator/() [21/35]

template<typename T , IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec<T, Size> vtkm::operator/ ( scalar,
vtkm::Vec< T, Size >  a 
)
inline

◆ operator/() [22/35]

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

◆ operator/() [23/35]

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

◆ operator/() [24/35]

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

◆ operator/() [25/35]

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

◆ operator/() [26/35]

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

◆ operator/() [27/35]

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

◆ operator/() [28/35]

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

◆ operator/() [29/35]

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

◆ operator/() [30/35]

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

◆ operator/() [31/35]

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

◆ operator/() [32/35]

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

◆ operator/() [33/35]

template<typename T , IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec<T, Size> vtkm::operator/ ( vtkm::Vec< T, Size >  a,
scalar 
)
inline

◆ operator/() [34/35]

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

◆ operator/() [35/35]

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

◆ operator<<() [1/6]

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

◆ operator<<() [2/6]

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

Helper function for printing out matricies during testing.

◆ operator<<() [3/6]

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

Helper function for printing out pairs during testing.

◆ operator<<() [4/6]

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

Helper function for printing ranges during testing.

◆ operator<<() [5/6]

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

Helper function for printing range during testing.

◆ operator<<() [6/6]

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

Helper function for printing out vectors during testing.

◆ operator==()

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

◆ Orthonormalize()

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

Perform Gram-Schmidt orthonormalization for 3-D vectors.

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

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

◆ Project()

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

Project a vector onto another vector.

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

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

◆ ProjectedDistance()

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

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

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

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

◆ ReduceProduct() [1/4]

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

◆ ReduceProduct() [2/4]

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

◆ ReduceProduct() [3/4]

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

◆ ReduceProduct() [4/4]

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

◆ ReduceSum() [1/4]

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

◆ ReduceSum() [2/4]

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

◆ ReduceSum() [3/4]

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

◆ ReduceSum() [4/4]

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

◆ RMagnitude()

template<typename T >
VTKM_EXEC_CONT detail::FloatingPointReturnType<T>::Type vtkm::RMagnitude ( const T &  x)

Returns the reciprocal magnitude of a vector.

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

◆ Round() [1/2]

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

Round x to the nearest integral value.

◆ Round() [2/2]

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

◆ Sin() [1/2]

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

Compute the sine of x.

◆ Sin() [2/2]

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

◆ SinH() [1/2]

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

Compute the hyperbolic sine of x.

◆ SinH() [2/2]

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

◆ SolveLinearSystem()

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

Solve the linear system Ax = b for x.

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

◆ Sqrt() [1/2]

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

Compute the square root of x.

◆ Sqrt() [2/2]

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

◆ Swap()

template<typename T >
VTKM_EXEC_CONT void vtkm::Swap ( T &  a,
T &  b 
)

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

◆ Tan() [1/2]

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

Compute the tangent of x.

◆ Tan() [2/2]

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

◆ TanH() [1/2]

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

Compute the hyperbolic tangent of x.

◆ TanH() [2/2]

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

◆ Transform3DPoint()

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

Transform a 3D point by a transformation matrix.

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

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

◆ Transform3DPointPerspective()

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

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

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

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

◆ Transform3DRotate() [1/2]

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

Returns a rotation matrix.

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

◆ Transform3DRotate() [2/2]

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

◆ Transform3DRotateX()

template<typename T >
VTKM_EXEC_CONT vtkm::Matrix<T, 4, 4> vtkm::Transform3DRotateX ( angleDegrees)

Returns a rotation matrix.

Returns a transformation matrix that rotates around the x axis.

◆ Transform3DRotateY()

template<typename T >
VTKM_EXEC_CONT vtkm::Matrix<T, 4, 4> vtkm::Transform3DRotateY ( angleDegrees)

Returns a rotation matrix.

Returns a transformation matrix that rotates around the y axis.

◆ Transform3DRotateZ()

template<typename T >
VTKM_EXEC_CONT vtkm::Matrix<T, 4, 4> vtkm::Transform3DRotateZ ( angleDegrees)

Returns a rotation matrix.

Returns a transformation matrix that rotates around the z axis.

◆ Transform3DScale() [1/3]

template<typename T >
VTKM_EXEC_CONT vtkm::Matrix<T, 4, 4> vtkm::Transform3DScale ( const T &  scale)

Returns a scale matrix.

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

◆ Transform3DScale() [2/3]

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

Returns a scale matrix.

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

◆ Transform3DScale() [3/3]

template<typename T >
VTKM_EXEC_CONT vtkm::Matrix<T, 4, 4> vtkm::Transform3DScale ( const vtkm::Vec< T, 3 > &  scaleVec)

Returns a scale matrix.

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

◆ Transform3DTranslate() [1/2]

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

Returns a translation matrix.

◆ Transform3DTranslate() [2/2]

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

◆ Transform3DVector()

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

Transform a 3D vector by a transformation matrix.

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

◆ TriangleNormal()

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

Find the normal of a triangle.

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

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

◆ UpperBound() [1/4]

template<typename PortalT , typename T >
VTKM_EXEC_CONT vtkm::Id vtkm::UpperBound ( const PortalT &  portal,
const T &  val 
)

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

The overloads that take portals return indices instead of iterators.

◆ UpperBound() [2/4]

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

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

The overloads that take portals return indices instead of iterators.

◆ UpperBound() [3/4]

template<typename IterT , typename T >
VTKM_EXEC_CONT IterT vtkm::UpperBound ( IterT  first,
IterT  last,
const T &  val 
)

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

The overloads that take portals return indices instead of iterators.

◆ UpperBound() [4/4]

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

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

The overloads that take portals return indices instead of iterators.

◆ VTK_M_OLD_TYPE_LIST_DEFINITION() [1/14]

vtkm::VTK_M_OLD_TYPE_LIST_DEFINITION ( All  )

◆ VTK_M_OLD_TYPE_LIST_DEFINITION() [2/14]

vtkm::VTK_M_OLD_TYPE_LIST_DEFINITION ( Common  )

◆ VTK_M_OLD_TYPE_LIST_DEFINITION() [3/14]

vtkm::VTK_M_OLD_TYPE_LIST_DEFINITION ( Field  )

◆ VTK_M_OLD_TYPE_LIST_DEFINITION() [4/14]

vtkm::VTK_M_OLD_TYPE_LIST_DEFINITION ( FieldScalar  )

◆ VTK_M_OLD_TYPE_LIST_DEFINITION() [5/14]

vtkm::VTK_M_OLD_TYPE_LIST_DEFINITION ( FieldVec2  )

◆ VTK_M_OLD_TYPE_LIST_DEFINITION() [6/14]

vtkm::VTK_M_OLD_TYPE_LIST_DEFINITION ( FieldVec3  )

◆ VTK_M_OLD_TYPE_LIST_DEFINITION() [7/14]

vtkm::VTK_M_OLD_TYPE_LIST_DEFINITION ( FieldVec4  )

◆ VTK_M_OLD_TYPE_LIST_DEFINITION() [8/14]

vtkm::VTK_M_OLD_TYPE_LIST_DEFINITION ( FloatVec  )

◆ VTK_M_OLD_TYPE_LIST_DEFINITION() [9/14]

vtkm::VTK_M_OLD_TYPE_LIST_DEFINITION ( Id  )

◆ VTK_M_OLD_TYPE_LIST_DEFINITION() [10/14]

vtkm::VTK_M_OLD_TYPE_LIST_DEFINITION ( Id2  )

◆ VTK_M_OLD_TYPE_LIST_DEFINITION() [11/14]

vtkm::VTK_M_OLD_TYPE_LIST_DEFINITION ( Index  )

◆ VTK_M_OLD_TYPE_LIST_DEFINITION() [12/14]

vtkm::VTK_M_OLD_TYPE_LIST_DEFINITION ( ScalarAll  )

◆ VTK_M_OLD_TYPE_LIST_DEFINITION() [13/14]

vtkm::VTK_M_OLD_TYPE_LIST_DEFINITION ( VecAll  )

◆ VTK_M_OLD_TYPE_LIST_DEFINITION() [14/14]

vtkm::VTK_M_OLD_TYPE_LIST_DEFINITION ( VecCommon  )

◆ VTKM_DEFINE_CELL_TAG() [1/11]

vtkm::VTKM_DEFINE_CELL_TAG ( Empty  ,
CELL_SHAPE_EMPTY   
)

◆ VTKM_DEFINE_CELL_TAG() [2/11]

vtkm::VTKM_DEFINE_CELL_TAG ( Hexahedron  ,
CELL_SHAPE_HEXAHEDRON   
)

◆ VTKM_DEFINE_CELL_TAG() [3/11]

vtkm::VTKM_DEFINE_CELL_TAG ( Line  ,
CELL_SHAPE_LINE   
)

◆ VTKM_DEFINE_CELL_TAG() [4/11]

vtkm::VTKM_DEFINE_CELL_TAG ( Polygon  ,
CELL_SHAPE_POLYGON   
)

◆ VTKM_DEFINE_CELL_TAG() [5/11]

vtkm::VTKM_DEFINE_CELL_TAG ( PolyLine  ,
CELL_SHAPE_POLY_LINE   
)

◆ VTKM_DEFINE_CELL_TAG() [6/11]

vtkm::VTKM_DEFINE_CELL_TAG ( Pyramid  ,
CELL_SHAPE_PYRAMID   
)

◆ VTKM_DEFINE_CELL_TAG() [7/11]

vtkm::VTKM_DEFINE_CELL_TAG ( Quad  ,
CELL_SHAPE_QUAD   
)

◆ VTKM_DEFINE_CELL_TAG() [8/11]

vtkm::VTKM_DEFINE_CELL_TAG ( Tetra  ,
CELL_SHAPE_TETRA   
)

◆ VTKM_DEFINE_CELL_TAG() [9/11]

vtkm::VTKM_DEFINE_CELL_TAG ( Triangle  ,
CELL_SHAPE_TRIANGLE   
)

◆ VTKM_DEFINE_CELL_TAG() [10/11]

vtkm::VTKM_DEFINE_CELL_TAG ( Vertex  ,
CELL_SHAPE_VERTEX   
)

◆ VTKM_DEFINE_CELL_TAG() [11/11]

vtkm::VTKM_DEFINE_CELL_TAG ( Wedge  ,
CELL_SHAPE_WEDGE   
)

◆ VTKM_DEFINE_CELL_TRAITS() [1/9]

vtkm::VTKM_DEFINE_CELL_TRAITS ( Empty  ,
,
 
)

◆ VTKM_DEFINE_CELL_TRAITS() [2/9]

vtkm::VTKM_DEFINE_CELL_TRAITS ( Hexahedron  ,
,
 
)

◆ VTKM_DEFINE_CELL_TRAITS() [3/9]

vtkm::VTKM_DEFINE_CELL_TRAITS ( Line  ,
,
 
)

◆ VTKM_DEFINE_CELL_TRAITS() [4/9]

vtkm::VTKM_DEFINE_CELL_TRAITS ( Pyramid  ,
,
 
)

◆ VTKM_DEFINE_CELL_TRAITS() [5/9]

vtkm::VTKM_DEFINE_CELL_TRAITS ( Quad  ,
,
 
)

◆ VTKM_DEFINE_CELL_TRAITS() [6/9]

vtkm::VTKM_DEFINE_CELL_TRAITS ( Tetra  ,
,
 
)

◆ VTKM_DEFINE_CELL_TRAITS() [7/9]

vtkm::VTKM_DEFINE_CELL_TRAITS ( Triangle  ,
,
 
)

◆ VTKM_DEFINE_CELL_TRAITS() [8/9]

vtkm::VTKM_DEFINE_CELL_TRAITS ( Vertex  ,
,
 
)

◆ VTKM_DEFINE_CELL_TRAITS() [9/9]

vtkm::VTKM_DEFINE_CELL_TRAITS ( Wedge  ,
,
 
)

◆ VTKM_DEFINE_CELL_TRAITS_VARIABLE() [1/2]

vtkm::VTKM_DEFINE_CELL_TRAITS_VARIABLE ( Polygon  ,
 
)

◆ VTKM_DEFINE_CELL_TRAITS_VARIABLE() [2/2]

vtkm::VTKM_DEFINE_CELL_TRAITS_VARIABLE ( PolyLine  ,
 
)

◆ VTKM_DEPRECATED()

template<typename ListTag , vtkm::IdComponent Index>
struct vtkm::VTKM_DEPRECATED ( 1.  6,
"ListTypeAt::type replaced by ListAt."   
)

Generate a tag that is the cross product of two other tags.

The resulting tag has the form of Tag< brigand::list<A1,B1>, brigand::list<A1,B2> .... >

Checks to see if the given Type is in the list pointed to by ListTag.

There is a static boolean named value that is set to true if the type is contained in the list and false otherwise.

Finds the type at the given index.

This struct contains subtype type that resolves to the type at the given index.

Variable Documentation

◆ Vec

template<typename T , vtkm::IdComponent Size>
class VTKM_ALWAYS_EXPORT vtkm::Vec

◆ VecC

template<typename T >
class VTKM_ALWAYS_EXPORT vtkm::VecC

◆ VecCConst

template<typename T >
class VTKM_ALWAYS_EXPORT vtkm::VecCConst
vtkm::ListRemoveIf
brigand::remove_if< internal::AsList< List >, brigand::bind< Predicate, brigand::_1 > > ListRemoveIf
Takes an existing List and a predicate template that is applied to each type in the List.
Definition: List.h:502