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

VTK-m Toolkit. 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.
 
 rendering
 VTK-m Rendering.
 
 source
 VTK-m Input source such as Wavelet.
 
 testing
 Internal testing classes.
 
 worklet
 VTK-m Worklets.
 

Classes

struct  Add
 
struct  AllMeasures
 
struct  ArcLength
 
struct  Area
 
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 Note: Requires Type T implement the & operator. More...
 
struct  BitwiseOr
 Binary Predicate that takes two arguments argument x, and y and returns the bitwise operation x|y Note: Requires Type T implement the | operator. More...
 
struct  BitwiseXor
 Binary Predicate that takes two arguments argument x, and y and returns the bitwise operation x^y Note: Requires Type T implement the ^ operator. 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
 
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  ListContains
 Checks to see if the given Type is in the list pointed to by ListTag. More...
 
struct  ListContains< vtkm::TypeListTagAll, Type >
 
struct  ListCrossProduct
 Generate a tag that is the cross product of two other tags. More...
 
struct  ListIndexOf
 Finds the index of the given type. More...
 
struct  ListSize
 Determines the number of types in the given list. More...
 
struct  ListTagAppend
 A tag that is constructed by appending Type to ListTag. More...
 
struct  ListTagAppendUnique
 Append Type to ListTag only if ListTag does not already contain Type. More...
 
struct  ListTagBase
 A basic tag for a list of typenames. More...
 
struct  ListTagEmpty
 A special tag for an empty list. More...
 
struct  ListTagIntersect
 A tag that consists of elements that are found in both tags. More...
 
struct  ListTagJoin
 A tag that is a construction of two other tags joined together. More...
 
struct  ListTagTransform
 A list tag that consists of each item in another list tag fed into a template that takes a single parameter. More...
 
struct  ListTagUniversal
 A special tag for a list that represents holding all potential values. More...
 
struct  ListTypeAt
 Finds the type at the given index. More...
 
struct  LogicalAnd
 Binary Predicate that takes two arguments argument x, and y and returns True if and only if x and y are True. More...
 
struct  LogicalNot
 Predicate that takes a single argument x, and returns True if and only if x is false. More...
 
struct  LogicalOr
 Binary Predicate that takes two arguments argument x, and y and returns True if and only if x or y is True. More...
 
class  Matrix
 Basic Matrix type. More...
 
struct  Maximum
 Binary Predicate that takes two arguments argument x, and y and returns the x if x > y otherwise returns y. More...
 
struct  MinAndMax
 Binary Predicate that takes two arguments argument x, and y and returns a vtkm::Vec<T,2> that represents the minimum and maximum values Note: Requires Type T implement the vtkm::Min and vtkm::Max functions. 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  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...
 
struct  TypeListTagAll
 A list of all basic types listed in vtkm/Types.h. More...
 
struct  TypeListTagCommon
 A list of the most commonly used types across multiple domains. More...
 
struct  TypeListTagField
 A list containing common types for values in fields. More...
 
struct  TypeListTagFieldScalar
 A list containing types used for scalar fields. More...
 
struct  TypeListTagFieldVec2
 A list containing types for values for fields with two dimensional vectors. More...
 
struct  TypeListTagFieldVec3
 A list containing types for values for fields with three dimensional vectors. More...
 
struct  TypeListTagFieldVec4
 A list containing types for values for fields with four dimensional vectors. More...
 
struct  TypeListTagFloatVec
 A list containing common types for floating-point vectors. More...
 
struct  TypeListTagId
 A list containing the type vtkm::Id. More...
 
struct  TypeListTagId2
 A list containing the type vtkm::Id2. More...
 
struct  TypeListTagId3
 A list containing the type vtkm::Id3. More...
 
struct  TypeListTagIdComponent
 A list containing the type vtkm::IdComponent. More...
 
struct  TypeListTagIndex
 A list containing types used to index arrays. More...
 
struct  TypeListTagScalarAll
 A list of all scalars defined in vtkm/Types.h. More...
 
struct  TypeListTagVecAll
 A list of all vector classes with standard types as components and lengths between 2 and 4. More...
 
struct  TypeListTagVecCommon
 A list of the most commonly use Vec classes. 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...
 
struct  Volume
 

Typedefs

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
 
template<typename ListTag , template< typename... > class Target>
using ListTagApply = typename detail::ListTagApplyImpl< internal::ListTagAsBrigandList< ListTag >, Target >::type
 Applies the list of types to a template. More...
 
using Float32 = float
 
using Float64 = double
 
using Int8 = signed char
 
using UInt8 = unsigned char
 
using Int16 = short
 
using UInt16 = unsigned short
 
using Int32 = int
 
using UInt32 = unsigned int
 
using IdComponent = vtkm::Int32
 Represents a component ID (index of component in a vector). More...
 
using WordTypeDefault = vtkm::UInt32
 The default word size used for atomic bitwise operations. More...
 
using Id = vtkm::Int32
 Represents an ID (index into arrays). More...
 
using FloatDefault = vtkm::Float32
 The floating point type to use when no other precision is specified. More...
 
using Id2 = vtkm::Vec< vtkm::Id, 2 >
 Id2 corresponds to a 2-dimensional index. More...
 
using IdComponent2 = vtkm::Vec< vtkm::IdComponent, 2 >
 IdComponent2 corresponds to an index to a local (small) 2-d array or equivalent. More...
 
using Vec2f = vtkm::Vec< vtkm::FloatDefault, 2 >
 Vec2f corresponds to a 2-dimensional vector of floating point values. More...
 
using Vec2f_32 = vtkm::Vec< vtkm::Float32, 2 >
 Vec2f_32 corresponds to a 2-dimensional vector of 32-bit floating point values. More...
 
using Vec2f_64 = vtkm::Vec< vtkm::Float64, 2 >
 Vec2f_64 corresponds to a 2-dimensional vector of 64-bit floating point values. More...
 
using Vec2i = vtkm::Vec< vtkm::Id, 2 >
 Vec2i corresponds to a 2-dimensional vector of integer values. More...
 
using Vec2i_8 = vtkm::Vec< vtkm::Int8, 2 >
 Vec2i_8 corresponds to a 2-dimensional vector of 8-bit integer values. More...
 
using Vec2i_16 = vtkm::Vec< vtkm::Int16, 2 >
 Vec2i_16 corresponds to a 2-dimensional vector of 16-bit integer values. More...
 
using Vec2i_32 = vtkm::Vec< vtkm::Int32, 2 >
 Vec2i_32 corresponds to a 2-dimensional vector of 32-bit integer values. More...
 
using Vec2i_64 = vtkm::Vec< vtkm::Int64, 2 >
 Vec2i_64 corresponds to a 2-dimensional vector of 64-bit integer values. More...
 
using Vec2ui = vtkm::Vec< vtkm::UInt32, 2 >
 Vec2ui corresponds to a 2-dimensional vector of unsigned integer values. More...
 
using Vec2ui_8 = vtkm::Vec< vtkm::UInt8, 2 >
 Vec2ui_8 corresponds to a 2-dimensional vector of 8-bit unsigned integer values. More...
 
using Vec2ui_16 = vtkm::Vec< vtkm::UInt16, 2 >
 Vec2ui_16 corresponds to a 2-dimensional vector of 16-bit unsigned integer values. More...
 
using Vec2ui_32 = vtkm::Vec< vtkm::UInt32, 2 >
 Vec2ui_32 corresponds to a 2-dimensional vector of 32-bit unsigned integer values. More...
 
using Vec2ui_64 = vtkm::Vec< vtkm::UInt64, 2 >
 Vec2ui_64 corresponds to a 2-dimensional vector of 64-bit unsigned integer values. More...
 
using Id3 = vtkm::Vec< vtkm::Id, 3 >
 Id3 corresponds to a 3-dimensional index for 3d arrays. More...
 
using IdComponent3 = vtkm::Vec< vtkm::IdComponent, 3 >
 IdComponent2 corresponds to an index to a local (small) 3-d array or equivalent. More...
 
using Vec3f = vtkm::Vec< vtkm::FloatDefault, 3 >
 Vec3f corresponds to a 3-dimensional vector of floating point values. More...
 
using Vec3f_32 = vtkm::Vec< vtkm::Float32, 3 >
 Vec3f_32 corresponds to a 3-dimensional vector of 32-bit floating point values. More...
 
using Vec3f_64 = vtkm::Vec< vtkm::Float64, 3 >
 Vec3f_64 corresponds to a 3-dimensional vector of 64-bit floating point values. More...
 
using Vec3i = vtkm::Vec< vtkm::Id, 3 >
 Vec3i corresponds to a 3-dimensional vector of integer values. More...
 
using Vec3i_8 = vtkm::Vec< vtkm::Int8, 3 >
 Vec3i_8 corresponds to a 3-dimensional vector of 8-bit integer values. More...
 
using Vec3i_16 = vtkm::Vec< vtkm::Int16, 3 >
 Vec3i_16 corresponds to a 3-dimensional vector of 16-bit integer values. More...
 
using Vec3i_32 = vtkm::Vec< vtkm::Int32, 3 >
 Vec3i_32 corresponds to a 3-dimensional vector of 32-bit integer values. More...
 
using Vec3i_64 = vtkm::Vec< vtkm::Int64, 3 >
 Vec3i_64 corresponds to a 3-dimensional vector of 64-bit integer values. More...
 
using Vec3ui = vtkm::Vec< vtkm::UInt32, 3 >
 Vec3ui corresponds to a 3-dimensional vector of unsigned integer values. More...
 
using Vec3ui_8 = vtkm::Vec< vtkm::UInt8, 3 >
 Vec3ui_8 corresponds to a 3-dimensional vector of 8-bit unsigned integer values. More...
 
using Vec3ui_16 = vtkm::Vec< vtkm::UInt16, 3 >
 Vec3ui_16 corresponds to a 3-dimensional vector of 16-bit unsigned integer values. More...
 
using Vec3ui_32 = vtkm::Vec< vtkm::UInt32, 3 >
 Vec3ui_32 corresponds to a 3-dimensional vector of 32-bit unsigned integer values. More...
 
using Vec3ui_64 = vtkm::Vec< vtkm::UInt64, 3 >
 Vec3ui_64 corresponds to a 3-dimensional vector of 64-bit unsigned integer values. More...
 
using Id4 = vtkm::Vec< vtkm::Id, 4 >
 Id4 corresponds to a 4-dimensional index. More...
 
using IdComponent4 = vtkm::Vec< vtkm::IdComponent, 4 >
 IdComponent4 corresponds to an index to a local (small) 4-d array or equivalent. More...
 
using Vec4f = vtkm::Vec< vtkm::FloatDefault, 4 >
 Vec4f corresponds to a 4-dimensional vector of floating point values. More...
 
using Vec4f_32 = vtkm::Vec< vtkm::Float32, 4 >
 Vec4f_32 corresponds to a 4-dimensional vector of 32-bit floating point values. More...
 
using Vec4f_64 = vtkm::Vec< vtkm::Float64, 4 >
 Vec4f_64 corresponds to a 4-dimensional vector of 64-bit floating point values. More...
 
using Vec4i = vtkm::Vec< vtkm::Id, 4 >
 Vec4i corresponds to a 4-dimensional vector of integer values. More...
 
using Vec4i_8 = vtkm::Vec< vtkm::Int8, 4 >
 Vec4i_8 corresponds to a 4-dimensional vector of 8-bit integer values. More...
 
using Vec4i_16 = vtkm::Vec< vtkm::Int16, 4 >
 Vec4i_16 corresponds to a 4-dimensional vector of 16-bit integer values. More...
 
using Vec4i_32 = vtkm::Vec< vtkm::Int32, 4 >
 Vec4i_32 corresponds to a 4-dimensional vector of 32-bit integer values. More...
 
using Vec4i_64 = vtkm::Vec< vtkm::Int64, 4 >
 Vec4i_64 corresponds to a 4-dimensional vector of 64-bit integer values. More...
 
using Vec4ui = vtkm::Vec< vtkm::UInt32, 4 >
 Vec4ui corresponds to a 4-dimensional vector of unsigned integer values. More...
 
using Vec4ui_8 = vtkm::Vec< vtkm::UInt8, 4 >
 Vec4ui_8 corresponds to a 4-dimensional vector of 8-bit unsigned integer values. More...
 
using Vec4ui_16 = vtkm::Vec< vtkm::UInt16, 4 >
 Vec4ui_16 corresponds to a 4-dimensional vector of 16-bit unsigned integer values. More...
 
using Vec4ui_32 = vtkm::Vec< vtkm::UInt32, 4 >
 Vec4ui_32 corresponds to a 4-dimensional vector of 32-bit unsigned integer values. More...
 
using Vec4ui_64 = vtkm::Vec< vtkm::UInt64, 4 >
 Vec4ui_64 corresponds to a 4-dimensional vector of 64-bit unsigned integer values. More...
 
template<typename T >
using HasVecTraits = typename detail::HasVecTraitsImpl< T >::Type
 Determines whether the given type has VecTraits defined. More...
 

Enumerations

enum  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 = 0, CELL_SHAPE_VERTEX = 1, CELL_SHAPE_LINE = 3, CELL_SHAPE_POLY_LINE = 4,
  CELL_SHAPE_TRIANGLE = 5, CELL_SHAPE_POLYGON = 7, CELL_SHAPE_QUAD = 9, CELL_SHAPE_TETRA = 10,
  CELL_SHAPE_HEXAHEDRON = 12, CELL_SHAPE_WEDGE = 13, CELL_SHAPE_PYRAMID = 14, NUMBER_OF_CELL_SHAPES
}
 CellShapeId identifies the type of each cell. More...
 
enum  CopyFlag { CopyFlag::Off = 0, CopyFlag::On = 1 }
 

Functions

 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 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 Functor , typename ListTag , typename... Args>
VTKM_CONT void ListForEach (Functor &&f, ListTag, Args &&...args)
 For each typename represented by the list tag, call the functor with a default instance of that type. 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::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>
VTKM_EXEC_CONT const vtkm::Vec< T, NumCol > & MatrixGetRow (const vtkm::Matrix< T, NumRow, NumCol > &matrix, vtkm::IdComponent rowIndex)
 Returns a tuple containing the given row (indexed from 0) of the given matrix. More...
 
template<typename T , vtkm::IdComponent NumRow, vtkm::IdComponent NumCol>
VTKM_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 &stream, const vtkm::Range &range)
 Helper function for printing ranges 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 T , typename... Ts>
VTKM_EXEC_CONT constexpr vtkm::Vec< T, vtkm::IdComponent(sizeof...(Ts)+1)> make_Vec (T value0, Ts &&...args)
 Initializes and returns a Vec containing all the arguments. More...
 
template<typename T , vtkm::IdComponent Size>
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_EXEC_CONT vtkm::Vec< T, Size > operator* (T scalar, const vtkm::Vec< T, Size > &vec)
 
template<typename T , vtkm::IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec< T, Size > operator* (const vtkm::Vec< T, Size > &vec, T scalar)
 
template<typename T , vtkm::IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec< T, Size > operator* (vtkm::Float64 scalar, const vtkm::Vec< T, Size > &vec)
 
template<typename T , vtkm::IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec< T, Size > operator* (const vtkm::Vec< T, Size > &vec, vtkm::Float64 scalar)
 
template<vtkm::IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec< vtkm::Float64, Size > operator* (vtkm::Float64 scalar, const vtkm::Vec< vtkm::Float64, Size > &vec)
 
template<vtkm::IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec< vtkm::Float64, Size > operator* (const vtkm::Vec< vtkm::Float64, Size > &vec, vtkm::Float64 scalar)
 
template<typename T , vtkm::IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec< T, Size > operator/ (const vtkm::Vec< T, Size > &vec, T scalar)
 
template<typename T , vtkm::IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec< T, Size > operator/ (const vtkm::Vec< T, Size > &vec, vtkm::Float64 scalar)
 
template<vtkm::IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec< vtkm::Float64, Size > operator/ (const vtkm::Vec< vtkm::Float64, Size > &vec, vtkm::Float64 scalar)
 
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- (const vtkm::Vec< T, Size > &x)
 
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
 

Detailed Description

VTK-m Toolkit.

Worklet for volume algorithms that require a neighborhood.

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.

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

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

Circle is an alias for a 2-Dimensional sphere.

using vtkm::Float32 = typedef float
using vtkm::Float64 = typedef double

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

using vtkm::HashType = typedef vtkm::UInt32
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.

using vtkm::Id = typedef vtkm::Int32

Represents an ID (index into arrays).

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

Id2 corresponds to a 2-dimensional index.

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.

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

Id4 corresponds to a 4-dimensional index.

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 corresponds to an index to a local (small) 2-d array or equivalent.

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

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

using vtkm::Int16 = typedef short
using vtkm::Int32 = typedef int
using vtkm::Int8 = typedef signed char
template<typename CoordType , int Dim = 3>
using vtkm::Line = typedef Ray<CoordType, Dim, true>

Lines are two-sided rays:

template<typename CoordType >
using vtkm::Line2 = typedef Line<CoordType, 2>
template<typename CoordType >
using vtkm::Line3 = typedef Line<CoordType, 3>
template<typename CoordType >
using vtkm::LineSegment2 = typedef LineSegment<CoordType, 2>
template<typename CoordType >
using vtkm::LineSegment3 = typedef LineSegment<CoordType, 3>
template<typename ListTag , template< typename... > class Target>
using vtkm::ListTagApply = typedef typename detail::ListTagApplyImpl<internal::ListTagAsBrigandList<ListTag>, Target>::type

Applies the list of types to a template.

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

template<typename CoordType >
using vtkm::Ray2 = typedef Ray<CoordType, 2>
template<typename CoordType >
using vtkm::Ray3 = typedef Ray<CoordType, 3>
template<typename T >
using vtkm::Sphere2 = typedef Sphere<T, 2>
template<typename T >
using vtkm::Sphere3 = typedef Sphere<T, 3>
using vtkm::UInt16 = typedef unsigned short
using vtkm::UInt32 = typedef unsigned int
using vtkm::UInt8 = typedef unsigned char

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

The default word size used for atomic bitwise operations.

Universally supported on all devices.

Enumeration Type Documentation

Enumerator
NORMAL 
GHOST 
INVALID 
UNUSED0 
UNUSED1 
UNUSED3 
UNUSED4 
UNUSED5 

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 
enum vtkm::CopyFlag
strong
Enumerator
Off 
On 

Function Documentation

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

Compute the arc cosine of x.

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

Compute the hyperbolic arc cosine of x.

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

Compute the arc sine of x.

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

Compute the hyperbolic arc sine of x.

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

Compute the arc tangent of x.

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

Compute the hyperbolic arc tangent of x.

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

Compute the cube root of x.

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

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

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

Clamp x to the given range.

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

Compute the cosine of x.

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

Compute the hyperbolic cosine of x.

VTKM_EXEC_CONT vtkm::Float64 vtkm::CosH ( vtkm::Float64  x)
inline
VTKM_EXEC_CONT vtkm::Int32 vtkm::CountSetBits ( vtkm::UInt32  word)
inline

Count the total number of bits set in word.

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

Count the total number of bits set in word.

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.

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

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

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

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

VTKM_EXEC_CONT vtkm::Float64 vtkm::Exp2 ( vtkm::Float64  x)
inline
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.

VTKM_EXEC_CONT vtkm::Float64 vtkm::ExpM1 ( vtkm::Float64  x)
inline
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.

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.

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

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

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

Decompose floating poing value.

VTKM_EXEC_CONT vtkm::Float64 vtkm::Frexp ( vtkm::Float64  x,
vtkm::Int32 exponent 
)
inline
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.

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

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 
)
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 
)
template<typename Functor , typename ListTag , typename... Args>
VTKM_CONT void vtkm::ListForEach ( Functor &&  f,
ListTag  ,
Args &&...  args 
)

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

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

Computes the natural logarithm of x.

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

Computes the logarithm base 10 of x.

VTKM_EXEC_CONT vtkm::Float64 vtkm::Log10 ( vtkm::Float64  x)
inline
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.

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

Computes the logarithm base 2 of x.

VTKM_EXEC_CONT vtkm::Float64 vtkm::Log2 ( vtkm::Float64  x)
inline
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.

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.

template<typename T >
ArrayPortalRef<T> vtkm::make_ArrayPortalRef ( const ArrayPortalVirtual< T > *  portal,
vtkm::Id  numValues 
)
inlinenoexcept
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.

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

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

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

Initializes and returns a Vec containing all the arguments.

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

template<typename IndexVecType , typename PortalType >
VTKM_EXEC VecFromPortalPermute<IndexVecType, PortalType> vtkm::make_VecFromPortalPermute ( const IndexVecType *  index,
const PortalType &  portal 
)
inline
template<typename IndexVecType , typename PortalType >
VTKM_EXEC VecFromPortalPermute<IndexVecType, const PortalType*> vtkm::make_VecFromPortalPermute ( const IndexVecType *  index,
const PortalType *const  portal 
)
inline
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.

template<typename T >
VTKM_EXEC_CONT T vtkm::MatrixDeterminant ( const vtkm::Matrix< T, 1, 1 > &  A)
template<typename T >
VTKM_EXEC_CONT T vtkm::MatrixDeterminant ( const vtkm::Matrix< T, 2, 2 > &  A)
template<typename T >
VTKM_EXEC_CONT T vtkm::MatrixDeterminant ( const vtkm::Matrix< T, 3, 3 > &  A)
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.

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

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

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

Returns the identity matrix.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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 
)
template<typename T , vtkm::IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec<T, Size> vtkm::operator* ( scalar,
const vtkm::Vec< T, Size > &  vec 
)
inline
template<typename T , vtkm::IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec<T, Size> vtkm::operator* ( const vtkm::Vec< T, Size > &  vec,
scalar 
)
inline
template<typename T , vtkm::IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec<T, Size> vtkm::operator* ( vtkm::Float64  scalar,
const vtkm::Vec< T, Size > &  vec 
)
inline
template<typename T , vtkm::IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec<T, Size> vtkm::operator* ( const vtkm::Vec< T, Size > &  vec,
vtkm::Float64  scalar 
)
inline
template<vtkm::IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec<vtkm::Float64, Size> vtkm::operator* ( vtkm::Float64  scalar,
const vtkm::Vec< vtkm::Float64, Size > &  vec 
)
inline
template<vtkm::IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec<vtkm::Float64, Size> vtkm::operator* ( const vtkm::Vec< vtkm::Float64, Size > &  vec,
vtkm::Float64  scalar 
)
inline
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

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- ( const vtkm::Vec< T, Size > &  x)
inline
template<typename T , vtkm::IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec<T, Size> vtkm::operator/ ( const vtkm::Vec< T, Size > &  vec,
scalar 
)
inline
template<typename T , vtkm::IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec<T, Size> vtkm::operator/ ( const vtkm::Vec< T, Size > &  vec,
vtkm::Float64  scalar 
)
inline
template<vtkm::IdComponent Size>
VTKM_EXEC_CONT vtkm::Vec<vtkm::Float64, Size> vtkm::operator/ ( const vtkm::Vec< vtkm::Float64, Size > &  vec,
vtkm::Float64  scalar 
)
inline
VTKM_CONT std::ostream& vtkm::operator<< ( std::ostream &  stream,
const vtkm::Range range 
)
inline

Helper function for printing ranges during testing.

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.

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.

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.

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

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.

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.

template<typename T , vtkm::IdComponent Size>
VTKM_EXEC_CONT T vtkm::ReduceProduct ( const vtkm::Vec< T, Size > &  a)
inline
template<typename T >
VTKM_EXEC_CONT T vtkm::ReduceProduct ( const vtkm::Vec< T, 2 > &  a)
inline
template<typename T >
VTKM_EXEC_CONT T vtkm::ReduceProduct ( const vtkm::Vec< T, 3 > &  a)
inline
template<typename T >
VTKM_EXEC_CONT T vtkm::ReduceProduct ( const vtkm::Vec< T, 4 > &  a)
inline
template<typename T , vtkm::IdComponent Size>
VTKM_EXEC_CONT T vtkm::ReduceSum ( const vtkm::Vec< T, Size > &  a)
inline
template<typename T >
VTKM_EXEC_CONT T vtkm::ReduceSum ( const vtkm::Vec< T, 2 > &  a)
inline
template<typename T >
VTKM_EXEC_CONT T vtkm::ReduceSum ( const vtkm::Vec< T, 3 > &  a)
inline
template<typename T >
VTKM_EXEC_CONT T vtkm::ReduceSum ( const vtkm::Vec< T, 4 > &  a)
inline
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.

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

Round x to the nearest integral value.

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

Compute the sine of x.

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

Compute the hyperbolic sine of x.

VTKM_EXEC_CONT vtkm::Float64 vtkm::SinH ( vtkm::Float64  x)
inline
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.

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

Compute the square root of x.

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

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

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

Compute the tangent of x.

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

Compute the hyperbolic tangent of x.

VTKM_EXEC_CONT vtkm::Float64 vtkm::TanH ( vtkm::Float64  x)
inline
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.

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.

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.

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

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.

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.

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.

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.

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.

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.

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

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.

vtkm::VTKM_DEFINE_CELL_TAG ( Empty  ,
CELL_SHAPE_EMPTY   
)
vtkm::VTKM_DEFINE_CELL_TAG ( Vertex  ,
CELL_SHAPE_VERTEX   
)
vtkm::VTKM_DEFINE_CELL_TAG ( Line  ,
CELL_SHAPE_LINE   
)
vtkm::VTKM_DEFINE_CELL_TAG ( PolyLine  ,
CELL_SHAPE_POLY_LINE   
)
vtkm::VTKM_DEFINE_CELL_TAG ( Triangle  ,
CELL_SHAPE_TRIANGLE   
)
vtkm::VTKM_DEFINE_CELL_TAG ( Polygon  ,
CELL_SHAPE_POLYGON   
)
vtkm::VTKM_DEFINE_CELL_TAG ( Quad  ,
CELL_SHAPE_QUAD   
)
vtkm::VTKM_DEFINE_CELL_TAG ( Tetra  ,
CELL_SHAPE_TETRA   
)
vtkm::VTKM_DEFINE_CELL_TAG ( Hexahedron  ,
CELL_SHAPE_HEXAHEDRON   
)
vtkm::VTKM_DEFINE_CELL_TAG ( Wedge  ,
CELL_SHAPE_WEDGE   
)
vtkm::VTKM_DEFINE_CELL_TAG ( Pyramid  ,
CELL_SHAPE_PYRAMID   
)
vtkm::VTKM_DEFINE_CELL_TRAITS ( Empty  ,
,
 
)
vtkm::VTKM_DEFINE_CELL_TRAITS ( Vertex  ,
,
 
)
vtkm::VTKM_DEFINE_CELL_TRAITS ( Line  ,
,
 
)
vtkm::VTKM_DEFINE_CELL_TRAITS ( Triangle  ,
,
 
)
vtkm::VTKM_DEFINE_CELL_TRAITS ( Quad  ,
,
 
)
vtkm::VTKM_DEFINE_CELL_TRAITS ( Tetra  ,
,
 
)
vtkm::VTKM_DEFINE_CELL_TRAITS ( Hexahedron  ,
,
 
)
vtkm::VTKM_DEFINE_CELL_TRAITS ( Wedge  ,
,
 
)
vtkm::VTKM_DEFINE_CELL_TRAITS ( Pyramid  ,
,
 
)
vtkm::VTKM_DEFINE_CELL_TRAITS_VARIABLE ( PolyLine  ,
 
)
vtkm::VTKM_DEFINE_CELL_TRAITS_VARIABLE ( Polygon  ,
 
)

Variable Documentation

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