CubbyFlow Namespace Reference

Namespaces
namespace	Internal

Classes
class	AdvectionSolver2
	Abstract based class for 2-D grid-based advection solver. More...
class	AdvectionSolver3
	Abstract based class for 3-D grid-based advection solver. More...
class	AngularVelocity
class	AngularVelocity< 2 >
class	AngularVelocity< 3 >
class	Animation
	Abstract base class for animation-related class. More...
class	AnisotropicPointsToImplicit2
	2-D points-to-implicit converter using Anisotropic kernels. More...
class	AnisotropicPointsToImplicit3
	3-D points-to-implicit converter using Anisotropic kernels. More...
class	APICSolver2
	2-D Affine Particle-in-Cell (APIC) implementation More...
class	APICSolver3
	3-D Affine Particle-in-Cell (APIC) implementation More...
class	Array
class	ArrayBase
class	ArrayView
	Generic N-dimensional array class interface. More...
class	ArrayView< const T, N >
class	BccLatticePointGenerator
	Body-centered lattice points generator. More...
struct	BLAS
	Generic BLAS operator wrapper class. More...
class	BoundingBox
	N-D axis-aligned bounding box class. More...
struct	BoundingBoxRayIntersection
	Box-ray intersection result. More...
class	Box
	N-D box geometry. More...
class	BVH
	Bounding Volume Hierarchy (BVH) in N-D. More...
class	CellCenteredScalarGrid
	N-D Cell-centered scalar grid structure. More...
class	CellCenteredVectorGrid
	N-D Cell-centered vector grid structure. More...
struct	ClosestIntersectionQueryResult
	N-D closest intersection query result. More...
class	Collider
	Abstract base class for generic collider object. More...
class	ColliderSet
	Collection of N-D colliders. More...
class	CollocatedVectorGrid
	Abstract base class for N-D collocated vector grid structure. More...
class	ConstantScalarField
	N-D constant scalar field. More...
class	ConstantVectorField
	N-D constant vector field. More...
class	CubicArraySampler
	N-D cubic array sampler class. More...
class	CubicSemiLagrangian2
	Implementation of 2-D cubic semi-Lagrangian advection solver. More...
class	CubicSemiLagrangian3
	Implementation of 3-D cubic semi-Lagrangian advection solver. More...
class	CustomImplicitSurface
	Custom N-D implicit surface using arbitrary function. More...
class	CustomScalarField
	N-D scalar field with custom field function. More...
class	CustomVectorField
	N-D vector field with custom field function. More...
class	Cylinder3
	3-D cylinder geometry. More...
struct	DoAbsMax
	Takes absolute maximum value. More...
struct	DoAbsMin
	Takes absolute minimum value. More...
struct	DoCatmullRom
struct	DoCeil
	Performs std::ceil. More...
struct	DoClamp
	Clamps the input value with low/high. More...
struct	DoFloor
	Performs std::floor. More...
struct	DoMax
	Takes maximum value. More...
struct	DoMin
	Takes minimum value. More...
struct	DoMonotonicCatmullRom
class	ENOLevelSetSolver2
	Two-dimensional third-order ENO-based iterative level set solver. More...
class	ENOLevelSetSolver3
	Three-dimensional third-order ENO-based iterative level set solver. More...
class	FaceCenteredGrid
	N-D face-centered (a.k.a MAC or staggered) grid. More...
class	Factory
struct	FDMBLAS2
	BLAS operator wrapper for 2-D finite differencing. More...
struct	FDMBLAS3
	BLAS operator wrapper for 3-D finite differencing. More...
class	FDMCGSolver2
	2-D finite difference-type linear system solver using conjugate gradient. More...
class	FDMCGSolver3
	3-D finite difference-type linear system solver using conjugate gradient. More...
struct	FDMCompressedBLAS2
	BLAS operator wrapper for compressed 2-D finite differencing. More...
struct	FDMCompressedBLAS3
	BLAS operator wrapper for compressed 3-D finite differencing. More...
struct	FDMCompressedLinearSystem2
	Compressed linear system (Ax=b) for 2-D finite differencing. More...
struct	FDMCompressedLinearSystem3
	Compressed linear system (Ax=b) for 3-D finite differencing. More...
class	FDMGaussSeidelSolver2
	2-D finite difference-type linear system solver using Gauss-Seidel method. More...
class	FDMGaussSeidelSolver3
	3-D finite difference-type linear system solver using Gauss-Seidel method. More...
class	FDMICCGSolver2
	2-D finite difference-type linear system solver using incomplete Cholesky conjugate gradient (ICCG). More...
class	FDMICCGSolver3
	3-D finite difference-type linear system solver using incomplete Cholesky conjugate gradient (ICCG). More...
class	FDMJacobiSolver2
	2-D finite difference-type linear system solver using Jacobi method. More...
class	FDMJacobiSolver3
	3-D finite difference-type linear system solver using Jacobi method. More...
struct	FDMLinearSystem2
	Linear system (Ax=b) for 2-D finite differencing. More...
struct	FDMLinearSystem3
	Linear system (Ax=b) for 3-D finite differencing. More...
class	FDMLinearSystemSolver2
	Abstract base class for 2-D finite difference-type linear system solver. More...
class	FDMLinearSystemSolver3
	Abstract base class for 3-D finite difference-type linear system solver. More...
struct	FDMMatrixRow2
	The row of FDMMatrix2 where row corresponds to (i, j) grid point. More...
struct	FDMMatrixRow3
	The row of FDMMatrix3 where row corresponds to (i, j, k) grid point. More...
struct	FDMMGLinearSystem2
	Multigrid-syle 2-D linear system. More...
struct	FDMMGLinearSystem3
	Multigrid-syle 3-D linear system. More...
class	FDMMGPCGSolver2
	2-D finite difference-type linear system solver using Multigrid Preconditioned conjugate gradient (MGPCG). More...
class	FDMMGPCGSolver3
	3-D finite difference-type linear system solver using Multigrid Preconditioned conjugate gradient (MGPCG). More...
class	FDMMGSolver2
	2-D finite difference-type linear system solver using Multigrid. More...
class	FDMMGSolver3
	3-D finite difference-type linear system solver using Multigrid. More...
class	FDMMGUtils2
	Multigrid utilities for 2-D FDM system. More...
class	FDMMGUtils3
	Multigrid utilities for 2-D FDM system. More...
class	Field
	Abstract base class for N-D fields. More...
class	FLIPSolver2
	2-D Fluid-Implicit Particle (FLIP) implementation. More...
class	FLIPSolver3
	3-D Fluid-Implicit Particle (FLIP) implementation. More...
class	FMMLevelSetSolver2
	Two-dimensional fast marching method (FMM) implementation. More...
class	FMMLevelSetSolver3
	Three-dimensional fast marching method (FMM) implementation. More...
struct	Frame
	Representation of an animation frame. More...
struct	GetCurl
struct	GetCurl< 2 >
struct	GetCurl< 3 >
struct	GetFDMUtils
struct	GetFDMUtils< 2 >
struct	GetFDMUtils< 3 >
struct	GetScalarType
	Returns the type of the value itself. More...
struct	GetScalarType< Matrix< T, Rows, Cols > >
struct	GetUnroll
struct	GetUnroll< ReturnType, 1 >
struct	GetUnroll< ReturnType, 2 >
struct	GetUnroll< ReturnType, 3 >
struct	GetUnroll< void, 1 >
struct	GetUnroll< void, 2 >
struct	GetUnroll< void, 3 >
class	Grid
	Abstract base class for N-D cartesian grid structure. More...
class	GridBackwardEulerDiffusionSolver2
	2-D grid-based backward Euler diffusion solver. More...
class	GridBackwardEulerDiffusionSolver3
	3-D grid-based backward Euler diffusion solver. More...
class	GridBlockedBoundaryConditionSolver2
	Blocked 2-D boundary condition solver for grids. More...
class	GridBlockedBoundaryConditionSolver3
	Blocked 3-D boundary condition solver for grids. More...
class	GridBoundaryConditionSolver2
	Abstract base class for 2-D boundary condition solver for grids. More...
class	GridBoundaryConditionSolver3
	Abstract base class for 3-D boundary condition solver for grids. More...
class	GridDataPositionFunc
class	GridDiffusionSolver2
	Abstract base class for 2-D grid-based diffusion equation solver. More...
class	GridDiffusionSolver3
	Abstract base class for 3-D grid-based diffusion equation solver. More...
class	GridEmitter2
	Abstract base class for 2-D grid-based emitters. More...
class	GridEmitter3
	Abstract base class for 3-D grid-based emitters. More...
class	GridEmitterSet2
	2-D grid-based emitter set. More...
class	GridEmitterSet3
	3-D grid-based emitter set. More...
class	GridFluidSolver2
	Abstract base class for grid-based 2-D fluid solver. More...
class	GridFluidSolver3
	Abstract base class for grid-based 3-D fluid solver. More...
class	GridFluidSolverBuilderBase2
	Base class for grid-based fluid solver builder. More...
class	GridFluidSolverBuilderBase3
	Base class for grid-based fluid solver builder. More...
class	GridForwardEulerDiffusionSolver2
	2-D grid-based forward Euler diffusion solver. More...
class	GridForwardEulerDiffusionSolver3
	3-D grid-based forward Euler diffusion solver. More...
class	GridFractionalBoundaryConditionSolver2
	Fractional 2-D boundary condition solver for grids. More...
class	GridFractionalBoundaryConditionSolver3
	Fractional 3-D boundary condition solver for grids. More...
class	GridFractionalSinglePhasePressureSolver2
	2-D fractional single-phase pressure solver. More...
class	GridFractionalSinglePhasePressureSolver3
	3-D fractional single-phase pressure solver. More...
class	GridPointGenerator2
	2-D regular-grid point generator. More...
class	GridPointGenerator3
	3-D regular-grid point generator. More...
class	GridPressureSolver2
	Abstract base class for 2-D grid-based pressure solver. More...
class	GridPressureSolver3
	Abstract base class for 2-D grid-based pressure solver. More...
class	GridSinglePhasePressureSolver2
	2-D single-phase pressure solver. More...
class	GridSinglePhasePressureSolver3
	3-D single-phase pressure solver. More...
class	GridSmokeSolver2
	2-D grid-based smoke solver. More...
class	GridSmokeSolver3
	3-D grid-based smoke solver. More...
class	GridSystemData
	N-D grid system data. More...
class	ImplicitSurface
	Abstract base class for N-D implicit surface. More...
class	ImplicitSurfaceSet
	N-D implicit surface set. More...
class	ImplicitTriangleMesh3
	TriangleMesh3 to ImplicitSurface3 converter. More...
class	IntersectionQueryEngine
	Abstract base class for N-D intersection test query engine. More...
class	IterativeLevelSetSolver2
	Abstract base class for 2-D PDE-based iterative level set solver. More...
class	IterativeLevelSetSolver3
	Abstract base class for 3-D PDE-based iterative level set solver. More...
class	KdTree
	Generic k-d tree structure. More...
class	LevelSetLiquidSolver2
	Level set based 2-D liquid solver. More...
class	LevelSetLiquidSolver3
	Level set based 3-D liquid solver. More...
class	LevelSetSolver2
	Abstract base class for 2-D level set solver. More...
class	LevelSetSolver3
	Abstract base class for 3-D level set solver. More...
class	LinearArraySampler
	N-D array sampler using linear interpolation. More...
class	ListQueryEngine
	Ad-hoc list-based N-D intersection/nearest-neighbor query engine. More...
class	Logger
	Super simple logger implementation. More...
class	Logging
	Helper class for logging. More...
class	Matrix
class	Matrix< T, 1, 1 >
class	Matrix< T, 2, 1 >
class	Matrix< T, 3, 1 >
class	Matrix< T, 4, 1 >
class	Matrix< T, MATRIX_SIZE_DYNAMIC, 1 >
class	Matrix< T, MATRIX_SIZE_DYNAMIC, MATRIX_SIZE_DYNAMIC >
class	MatrixConstant
class	MatrixCSR
	Compressed Sparse Row (CSR) matrix class. More...
class	MatrixCSRMatrixMul
	Matrix expression for CSR matrix-matrix multiplication. More...
class	MatrixDenseBase
class	MatrixDiagonal
class	MatrixElemWiseBinaryOp
	Matrix expression for element-wise binary operation. More...
class	MatrixExpression
	Base class for matrix expression. More...
class	MatrixMul
class	MatrixOffDiagonal
class	MatrixScalarElemWiseBinaryOp
class	MatrixTernaryOp
class	MatrixTranspose
class	MatrixTri
class	MatrixUnaryOp
struct	MGMatrix
	Multi-grid matrix wrapper. More...
struct	MGParameters
	Multi-grid input parameter set. More...
struct	MGResult
	Multi-grid result type. More...
struct	MGVector
	Multi-grid vector wrapper. More...
class	NearestArraySampler
	N-D nearest array sampler class. More...
class	NearestNeighborQueryEngine
	Abstract base class for N-D nearest neighbor query engine. More...
struct	NearestNeighborQueryResult
	N-D nearest neighbor query result. More...
struct	NestedInitializerLists
struct	NestedInitializerLists< T, 0 >
struct	NoOp
	No-op operator. More...
struct	NullCGPreconditioner
	No-op pre-conditioner for conjugate gradient. More...
class	Octree
	Generic octree data structure. More...
class	Orientation
class	Orientation< 2 >
class	Orientation< 3 >
class	ParticleEmitter2
	Abstract base class for 2-D particle emitter. More...
class	ParticleEmitter3
	Abstract base class for 3-D particle emitter. More...
class	ParticleEmitterSet2
	2-D particle-based emitter set. More...
class	ParticleEmitterSet3
	3-D particle-based emitter set. More...
class	ParticleSystemData
	N-D particle system data. More...
class	ParticleSystemSolver2
	Basic 2-D particle system solver. More...
class	ParticleSystemSolver3
	Basic 3-D particle system solver. More...
class	ParticleSystemSolverBuilderBase2
	Base class for particle-based solver builder. More...
class	ParticleSystemSolverBuilderBase3
	Base class for particle-based solver builder. More...
class	PCISPHSolver2
	2-D PCISPH solver. More...
class	PCISPHSolver3
	3-D PCISPH solver. More...
class	PhysicsAnimation
	Abstract base class for physics-based animation. More...
class	PICSolver2
	2-D Particle-in-Cell (PIC) implementation. More...
class	PICSolver3
	3-D Particle-in-Cell (PIC) implementation. More...
class	Plane
	N-D plane geometry. More...
class	PointGenerator2
	Abstract base class for 2-D point generator. More...
class	PointGenerator3
	Abstract base class for 3-D point generator. More...
class	PointHashGridSearcher
	Hash grid-based N-D point searcher. More...
class	PointHashGridUtils
	Hash grid common utilities for N-D point searchers. More...
class	PointKdTreeSearcher
	KdTree-based N-D point searcher. More...
class	PointNeighborSearcher
	Abstract base class for N-D neighbor point searcher. More...
class	PointNeighborSearcherBuilder
	Abstract base class for N-D point neighbor searcher builders. More...
class	PointParallelHashGridSearcher
	Parallel version of hash grid-based N-D point searcher. More...
class	PointParticleEmitter2
	2-D point particle emitter. More...
class	PointParticleEmitter3
	3-D point particle emitter. More...
class	PointSimpleListSearcher
	Simple ad-hoc N-D point searcher. More...
class	PointsToImplicit2
	Abstract base class for 2-D points-to-implicit converters. More...
class	PointsToImplicit3
	Abstract base class for 3-D points-to-implicit converters. More...
class	Quadtree
	Generic quadtree data structure. More...
class	Quaternion
	Quaternion class defined as q = w + xi + yj + zk. More...
class	Ray
	Class for N-D ray. More...
struct	RDivides
	Reverse divides operator. More...
class	RigidBodyCollider
	N-D rigid body collider class. More...
struct	RMinus
	Reverse minus operator. More...
class	ScalarField
	Abstract base class for N-D scalar field. More...
class	ScalarGrid
	Abstract base class for N-D scalar grid structure. More...
class	ScalarGridBuilder
	Abstract base class for N-D scalar grid builder. More...
class	ScalarMatrixElemWiseBinaryOp
class	SemiLagrangian2
	Implementation of 2-D semi-Lagrangian advection solver. More...
class	SemiLagrangian3
	Implementation of 3-D semi-Lagrangian advection solver. More...
class	Serializable
	Abstract base class for any serializable class. More...
struct	SimilarTo
	True if similar. More...
class	Sphere
	N-D sphere geometry. More...
class	SphericalPointsToImplicit2
	2-D points-to-implicit converter based on simple sphere model. More...
class	SphericalPointsToImplicit3
	3-D points-to-implicit converter based on simple sphere model. More...
class	SPHPointsToImplicit2
	2-D points-to-implicit converter based on standard SPH kernel. More...
class	SPHPointsToImplicit3
	3-D points-to-implicit converter based on standard SPH kernel. More...
class	SPHSolver2
	2-D SPH solver. More...
class	SPHSolver3
	3-D SPH solver. More...
class	SPHSolverBuilderBase2
	Base class for SPH-based fluid solver builder. More...
class	SPHSolverBuilderBase3
	Base class for SPH-based fluid solver builder. More...
struct	SPHSpikyKernel
	Spiky N-D SPH kernel function object. More...
struct	SPHSpikyKernel< 2 >
struct	SPHSpikyKernel< 3 >
struct	SPHStdKernel
	Standard N-D SPH kernel function object. More...
struct	SPHStdKernel< 2 >
struct	SPHStdKernel< 3 >
class	SPHSystemData
	N-D SPH particle system data. More...
class	Surface
	Abstract base class for N-D surface. More...
class	SurfaceBuilderBase
	Base class for N-D surface builder. More...
struct	SurfaceRayIntersection
	Struct that represents ray-surface intersection point. More...
class	SurfaceSet
	N-D surface set. More...
class	SurfaceToImplicit
	N-D implicit surface wrapper for generic Surface instance. More...
class	Timer
	Simple timer class. More...
struct	TraitIsMatrixSizeDynamic
struct	TraitIsMatrixSizeSquare
struct	TraitIsMatrixSizeStatic
class	Transform
	Represents N-D rigid body transform. More...
class	Triangle3
	3-D triangle geometry. More...
class	TriangleMesh3
	3-D triangle mesh geometry. More...
class	TrianglePointGenerator
	Right triangle point generator. More...
struct	TypeCast
	Type casting operator. More...
class	UpwindLevelSetSolver2
class	UpwindLevelSetSolver3
	Three-dimensional first-order upwind-based iterative level set solver. More...
class	VectorField
	Abstract base class for N-D vector field. More...
class	VectorGrid
	Abstract base class for N-D vector grid structure. More...
class	VectorGridBuilder
	Abstract base class for N-D vector grid builder. More...
class	VertexCenteredScalarGrid
	N-D Vertex-centered scalar grid structure. More...
class	VertexCenteredVectorGrid
	N-D Vertex-centered vector grid structure. More...
class	VolumeGridEmitter2
	2-D grid-based volumetric emitter. More...
class	VolumeGridEmitter3
	3-D grid-based volumetric emitter. More...
class	VolumeParticleEmitter2
	2-D volumetric particle emitter. More...
class	VolumeParticleEmitter3
	3-D volumetric particle emitter. More...
class	ZhuBridsonPointsToImplicit2
	2-D points-to-implicit converter based on Zhu and Bridson's method. More...
class	ZhuBridsonPointsToImplicit3
	3-D points-to-implicit converter based on Zhu and Bridson's method. More...

Typedefs
using	AnimationPtr = std::shared_ptr< Animation >
	Shared pointer for the Animation type.
using	PhysicsAnimationPtr = std::shared_ptr< PhysicsAnimation >
template<class T >
using	Array1 = Array< T, 1 >
template<class T >
using	Array2 = Array< T, 2 >
template<class T >
using	Array3 = Array< T, 3 >
template<class T >
using	Array4 = Array< T, 4 >
template<typename T >
using	NearestArraySampler1 = NearestArraySampler< T, 1 >
template<typename T >
using	NearestArraySampler2 = NearestArraySampler< T, 2 >
template<typename T >
using	NearestArraySampler3 = NearestArraySampler< T, 3 >
template<typename T >
using	LinearArraySampler1 = LinearArraySampler< T, 1 >
template<typename T >
using	LinearArraySampler2 = LinearArraySampler< T, 2 >
template<typename T >
using	LinearArraySampler3 = LinearArraySampler< T, 3 >
template<typename T >
using	CatmullRomArraySampler1 = CubicArraySampler< T, 1, DoCatmullRom< T > >
template<typename T >
using	CatmullRomArraySampler2 = CubicArraySampler< T, 2, DoCatmullRom< T > >
template<typename T >
using	CatmullRomArraySampler3 = CubicArraySampler< T, 3, DoCatmullRom< T > >
template<typename T >
using	MonotonicCatmullRomArraySampler1 = CubicArraySampler< T, 1, DoMonotonicCatmullRom< T > >
template<typename T >
using	MonotonicCatmullRomArraySampler2 = CubicArraySampler< T, 2, DoMonotonicCatmullRom< T > >
template<typename T >
using	MonotonicCatmullRomArraySampler3 = CubicArraySampler< T, 3, DoMonotonicCatmullRom< T > >
template<class T >
using	ArrayView1 = ArrayView< T, 1 >
template<class T >
using	ArrayView2 = ArrayView< T, 2 >
template<class T >
using	ArrayView3 = ArrayView< T, 3 >
template<class T >
using	ArrayView4 = ArrayView< T, 4 >
template<class T >
using	ConstArrayView1 = ArrayView< const T, 1 >
template<class T >
using	ConstArrayView2 = ArrayView< const T, 2 >
template<class T >
using	ConstArrayView3 = ArrayView< const T, 3 >
template<class T >
using	ConstArrayView4 = ArrayView< const T, 4 >
using	GridEmitter2Ptr = std::shared_ptr< GridEmitter2 >
	Shared pointer type for the GridEmitter2.
using	GridEmitter3Ptr = std::shared_ptr< GridEmitter3 >
	Shared pointer type for the GridEmitter3.
using	GridEmitterSet2Ptr = std::shared_ptr< GridEmitterSet2 >
	Shared pointer type for the GridEmitterSet2.
using	GridEmitterSet3Ptr = std::shared_ptr< GridEmitterSet3 >
	Shared pointer type for the GridEmitterSet3.
using	ParticleEmitter2Ptr = std::shared_ptr< ParticleEmitter2 >
	Shared pointer for the ParticleEmitter2 type.
using	ParticleEmitter3Ptr = std::shared_ptr< ParticleEmitter3 >
	Shared pointer for the ParticleEmitter3 type.
using	ParticleEmitterSet2Ptr = std::shared_ptr< ParticleEmitterSet2 >
	Shared pointer type for the ParticleEmitterSet2.
using	ParticleEmitterSet3Ptr = std::shared_ptr< ParticleEmitterSet3 >
	Shared pointer type for the ParticleEmitterSet3.
using	PointParticleEmitter2Ptr = std::shared_ptr< PointParticleEmitter2 >
	Shared pointer for the PointParticleEmitter2 type.
using	PointParticleEmitter3Ptr = std::shared_ptr< PointParticleEmitter3 >
	Shared pointer for the PointParticleEmitter3 type.
using	VolumeGridEmitter2Ptr = std::shared_ptr< VolumeGridEmitter2 >
	Shared pointer type for the VolumeGridEmitter2.
using	VolumeGridEmitter3Ptr = std::shared_ptr< VolumeGridEmitter3 >
	Shared pointer type for the VolumeGridEmitter3.
using	VolumeParticleEmitter2Ptr = std::shared_ptr< VolumeParticleEmitter2 >
	Shared pointer for the VolumeParticleEmitter2 type.
using	VolumeParticleEmitter3Ptr = std::shared_ptr< VolumeParticleEmitter3 >
	Shared pointer for the VolumeParticleEmitter3 type.
using	FDMVector2 = Array2< double >
	Vector type for 2-D finite differencing.
using	FDMMatrix2 = Array2< FDMMatrixRow2 >
	Matrix type for 2-D finite differencing.
using	FDMVector3 = Array3< double >
	Vector type for 3-D finite differencing.
using	FDMMatrix3 = Array3< FDMMatrixRow3 >
	Matrix type for 3-D finite differencing.
using	FDMMGMatrix2 = MGMatrix< FDMBLAS2 >
	Multigrid-style 2-D FDM matrix.
using	FDMMGVector2 = MGVector< FDMBLAS2 >
	Multigrid-style 2-D FDM vector.
using	FDMMGMatrix3 = MGMatrix< FDMBLAS3 >
	Multigrid-style 3-D FDM matrix.
using	FDMMGVector3 = MGVector< FDMBLAS3 >
	Multigrid-style 3-D FDM vector.
using	ConstantScalarField2 = ConstantScalarField< 2 >
	2-D ConstantScalarField type.
using	ConstantScalarField3 = ConstantScalarField< 3 >
	3-D ConstantScalarField type.
using	ConstantScalarField2Ptr = std::shared_ptr< ConstantScalarField2 >
	Shared pointer for the ConstantScalarField2 type.
using	ConstantScalarField3Ptr = std::shared_ptr< ConstantScalarField3 >
	Shared pointer for the ConstantScalarField3 type.
using	ConstantVectorField2 = ConstantVectorField< 2 >
	2-D ConstantVectorField type.
using	ConstantVectorField3 = ConstantVectorField< 3 >
	3-D ConstantVectorField type.
using	ConstantVectorField2Ptr = std::shared_ptr< ConstantVectorField2 >
	Shared pointer for the ConstantVectorField2 type.
using	ConstantVectorField3Ptr = std::shared_ptr< ConstantVectorField3 >
	Shared pointer for the ConstantVectorField3 type.
using	CustomScalarField2 = CustomScalarField< 2 >
	2-D CustomScalarField type.
using	CustomScalarField3 = CustomScalarField< 3 >
	3-D CustomScalarField type.
using	CustomScalarField2Ptr = std::shared_ptr< CustomScalarField2 >
	Shared pointer type for the CustomScalarField2.
using	CustomScalarField3Ptr = std::shared_ptr< CustomScalarField3 >
	Shared pointer type for the CustomScalarField3.
using	CustomVectorField2 = CustomVectorField< 2 >
	2-D CustomVectorField type.
using	CustomVectorField3 = CustomVectorField< 3 >
	3-D CustomVectorField type.
using	CustomVectorField2Ptr = std::shared_ptr< CustomVectorField2 >
	Shared pointer type for the CustomVectorField2.
using	CustomVectorField3Ptr = std::shared_ptr< CustomVectorField3 >
	Shared pointer type for the CustomVectorField3.
using	Field2 = Field< 2 >
	2-D Field type.
using	Field3 = Field< 3 >
	3-D Field type.
using	Field2Ptr = std::shared_ptr< Field2 >
	Shared pointer type for Field2.
using	Field3Ptr = std::shared_ptr< Field3 >
	Shared pointer type for Field3.
using	ScalarField2 = ScalarField< 2 >
	2-D ScalarField type.
using	ScalarField3 = ScalarField< 3 >
	3-D ScalarField type.
using	ScalarField2Ptr = std::shared_ptr< ScalarField2 >
	Shared pointer for the ScalarField2 type.
using	ScalarField3Ptr = std::shared_ptr< ScalarField3 >
	Shared pointer for the ScalarField3 type.
using	VectorField2 = VectorField< 2 >
	2-D VectorField type.
using	VectorField3 = VectorField< 3 >
	3-D VectorField type.
using	VectorField2Ptr = std::shared_ptr< VectorField2 >
	Shared pointer for the VectorField2 type.
using	VectorField3Ptr = std::shared_ptr< VectorField3 >
	Shared pointer for the VectorField3 type.
template<typename T >
using	BoundingBox2 = BoundingBox< T, 2 >
template<typename T >
using	BoundingBox3 = BoundingBox< T, 3 >
using	BoundingBox2F = BoundingBox2< float >
using	BoundingBox2D = BoundingBox2< double >
using	BoundingBox3F = BoundingBox3< float >
using	BoundingBox3D = BoundingBox3< double >
using	BoundingBoxRayIntersectionF = BoundingBoxRayIntersection< float >
using	BoundingBoxRayIntersectionD = BoundingBoxRayIntersection< double >
using	Box2 = Box< 2 >
	2-D Box type.
using	Box3 = Box< 3 >
	3-D Box type.
using	Box2Ptr = std::shared_ptr< Box2 >
	Shared pointer type for the Box2.
using	Box3Ptr = std::shared_ptr< Box3 >
	Shared pointer type for the Box3.
template<typename T >
using	BVH2 = BVH< T, 2 >
	2-D BVH type.
template<typename T >
using	BVH3 = BVH< T, 3 >
	3-D BVH type.
using	Collider2 = Collider< 2 >
	2-D collider type.
using	Collider3 = Collider< 3 >
	3-D collider type.
using	Collider2Ptr = std::shared_ptr< Collider2 >
	Shared pointer type for the Collider2.
using	Collider3Ptr = std::shared_ptr< Collider3 >
	Shared pointer type for the Collider3.
using	ColliderSet2 = ColliderSet< 2 >
	2-D ColliderSet type.
using	ColliderSet3 = ColliderSet< 3 >
	3-D ColliderSet type.
using	ColliderSet2Ptr = std::shared_ptr< ColliderSet2 >
	Shared pointer for the ColliderSet2 type.
using	ColliderSet3Ptr = std::shared_ptr< ColliderSet3 >
	Shared pointer for the ColliderSet3 type.
using	CustomImplicitSurface2 = CustomImplicitSurface< 2 >
	2-D CustomImplicitSurface type.
using	CustomImplicitSurface3 = CustomImplicitSurface< 3 >
	3-D CustomImplicitSurface type.
using	CustomImplicitSurface2Ptr = std::shared_ptr< CustomImplicitSurface2 >
	Shared pointer type for the CustomImplicitSurface2.
using	CustomImplicitSurface3Ptr = std::shared_ptr< CustomImplicitSurface3 >
	Shared pointer type for the CustomImplicitSurface3.
using	Cylinder3Ptr = std::shared_ptr< Cylinder3 >
	Shared pointer type for the Cylinder3.
using	ImplicitSurface2 = ImplicitSurface< 2 >
	2-D ImplicitSurface type.
using	ImplicitSurface3 = ImplicitSurface< 3 >
	3-D ImplicitSurface type.
using	ImplicitSurface2Ptr = std::shared_ptr< ImplicitSurface2 >
	Shared pointer type for the ImplicitSurface2.
using	ImplicitSurface3Ptr = std::shared_ptr< ImplicitSurface3 >
	Shared pointer type for the ImplicitSurface3.
using	ImplicitSurfaceSet2 = ImplicitSurfaceSet< 2 >
	2-D ImplicitSurfaceSet type.
using	ImplicitSurfaceSet3 = ImplicitSurfaceSet< 3 >
	3-D ImplicitSurfaceSet type.
using	ImplicitSurfaceSet2Ptr = std::shared_ptr< ImplicitSurfaceSet2 >
	Shared pointer type for the ImplicitSurfaceSet2.
using	ImplicitSurfaceSet3Ptr = std::shared_ptr< ImplicitSurfaceSet3 >
	Shared pointer type for the ImplicitSurfaceSet3.
using	ImplicitTriangleMesh3Ptr = std::shared_ptr< ImplicitTriangleMesh3 >
	Shared pointer for the ImplicitTriangleMesh3 type.
using	Plane2 = Plane< 2 >
	2-D plane type.
using	Plane3 = Plane< 3 >
	3-D plane type.
using	Plane2Ptr = std::shared_ptr< Plane2 >
	Shared pointer for the Plane2 type.
using	Plane3Ptr = std::shared_ptr< Plane3 >
	Shared pointer for the Plane3 type.
template<typename T >
using	Ray2 = Ray< T, 2 >
template<typename T >
using	Ray3 = Ray< T, 3 >
using	Ray2F = Ray2< float >
using	Ray2D = Ray2< double >
using	Ray3F = Ray3< float >
using	Ray3D = Ray3< double >
using	AngularVelocity2 = AngularVelocity< 2 >
using	AngularVelocity3 = AngularVelocity< 3 >
using	RigidBodyCollider2 = RigidBodyCollider< 2 >
	2-D RigidBodyCollider type.
using	RigidBodyCollider3 = RigidBodyCollider< 3 >
	3-D RigidBodyCollider type.
using	RigidBodyCollider2Ptr = std::shared_ptr< RigidBodyCollider2 >
	Shared pointer for the RigidBodyCollider2 type.
using	RigidBodyCollider3Ptr = std::shared_ptr< RigidBodyCollider3 >
	Shared pointer for the RigidBodyCollider3 type.
using	Sphere2 = Sphere< 2 >
	2-D Sphere type.
using	Sphere3 = Sphere< 3 >
	3-D Sphere type.
using	Sphere2Ptr = std::shared_ptr< Sphere2 >
	Shared pointer for the Sphere2 type.
using	Sphere3Ptr = std::shared_ptr< Sphere3 >
	Shared pointer for the Sphere3 type.
using	SurfaceRayIntersection2 = SurfaceRayIntersection< 2 >
using	SurfaceRayIntersection3 = SurfaceRayIntersection< 3 >
using	Surface2 = Surface< 2 >
	2-D Surface type.
using	Surface3 = Surface< 3 >
	3-D Surface type.
using	Surface2Ptr = std::shared_ptr< Surface2 >
	Shared pointer for the Surface2 type.
using	Surface3Ptr = std::shared_ptr< Surface3 >
	Shared pointer for the Surface3 type.
template<typename T >
using	SurfaceBuilderBase2 = SurfaceBuilderBase< 2, T >
template<typename T >
using	SurfaceBuilderBase3 = SurfaceBuilderBase< 3, T >
using	SurfaceSet2 = SurfaceSet< 2 >
	2-D SurfaceSet type.
using	SurfaceSet3 = SurfaceSet< 3 >
	3-D SurfaceSet type.
using	SurfaceSet2Ptr = std::shared_ptr< SurfaceSet2 >
	Shared pointer for the SurfaceSet2 type.
using	SurfaceSet3Ptr = std::shared_ptr< SurfaceSet3 >
	Shared pointer for the SurfaceSet3 type.
using	SurfaceToImplicit2 = SurfaceToImplicit< 2 >
	2-D SurfaceToImplicit type.
using	SurfaceToImplicit3 = SurfaceToImplicit< 3 >
	3-D SurfaceToImplicit type.
using	SurfaceToImplicit2Ptr = std::shared_ptr< SurfaceToImplicit2 >
	Shared pointer for the SurfaceToImplicit2 type.
using	SurfaceToImplicit3Ptr = std::shared_ptr< SurfaceToImplicit3 >
	Shared pointer for the SurfaceToImplicit3 type.
using	Orientation2 = Orientation< 2 >
using	Orientation3 = Orientation< 3 >
using	Transform2 = Transform< 2 >
using	Transform3 = Transform< 3 >
using	Triangle3Ptr = std::shared_ptr< Triangle3 >
	Shared pointer for the Triangle3 type.
using	TriangleMesh3Ptr = std::shared_ptr< TriangleMesh3 >
	Shared pointer for the TriangleMesh3 type.
using	CellCenteredScalarGrid2 = CellCenteredScalarGrid< 2 >
	2-D CellCenteredScalarGrid type.
using	CellCenteredScalarGrid3 = CellCenteredScalarGrid< 3 >
	3-D CellCenteredScalarGrid type.
using	CellCenteredScalarGrid2Ptr = std::shared_ptr< CellCenteredScalarGrid2 >
	Shared pointer for the CellCenteredScalarGrid2 type.
using	CellCenteredScalarGrid3Ptr = std::shared_ptr< CellCenteredScalarGrid3 >
	Shared pointer for the CellCenteredScalarGrid3 type.
using	CellCenteredVectorGrid2 = CellCenteredVectorGrid< 2 >
	2-D CellCenteredVectorGrid type.
using	CellCenteredVectorGrid3 = CellCenteredVectorGrid< 3 >
	3-D CellCenteredVectorGrid type.
using	CellCenteredVectorGrid2Ptr = std::shared_ptr< CellCenteredVectorGrid2 >
	Shared pointer for the CellCenteredVectorGrid2 type.
using	CellCenteredVectorGrid3Ptr = std::shared_ptr< CellCenteredVectorGrid3 >
	Shared pointer for the CellCenteredVectorGrid3 type.
using	CollocatedVectorGrid2 = CollocatedVectorGrid< 2 >
	2-D CollocatedVectorGrid type.
using	CollocatedVectorGrid3 = CollocatedVectorGrid< 3 >
	3-D CollocatedVectorGrid type.
using	CollocatedVectorGrid2Ptr = std::shared_ptr< CollocatedVectorGrid2 >
	Shared pointer for the CollocatedVectorGrid2 type.
using	CollocatedVectorGrid3Ptr = std::shared_ptr< CollocatedVectorGrid3 >
	Shared pointer for the CollocatedVectorGrid3 type.
using	FaceCenteredGrid2 = FaceCenteredGrid< 2 >
	2-D FaceCenteredGrid type.
using	FaceCenteredGrid3 = FaceCenteredGrid< 3 >
	3-D FaceCenteredGrid type.
using	FaceCenteredGrid2Ptr = std::shared_ptr< FaceCenteredGrid2 >
	Shared pointer type for the FaceCenteredGrid2.
using	FaceCenteredGrid3Ptr = std::shared_ptr< FaceCenteredGrid3 >
	Shared pointer type for the FaceCenteredGrid3.
using	Grid2 = Grid< 2 >
	2-D Grid type.
using	Grid3 = Grid< 3 >
	3-D Grid type.
using	Grid2Ptr = std::shared_ptr< Grid2 >
	Shared pointer type for Grid.
using	Grid3Ptr = std::shared_ptr< Grid3 >
	Shared pointer type for Grid3.
using	GridSystemData2 = GridSystemData< 2 >
	2-D GridSystemData type.
using	GridSystemData3 = GridSystemData< 3 >
	3-D GridSystemData type.
using	GridSystemData2Ptr = std::shared_ptr< GridSystemData2 >
	Shared pointer type of GridSystemData2.
using	GridSystemData3Ptr = std::shared_ptr< GridSystemData3 >
	Shared pointer type of GridSystemData3.
using	ScalarGrid2 = ScalarGrid< 2 >
	2-D ScalarGrid type.
using	ScalarGrid3 = ScalarGrid< 3 >
	3-D ScalarGrid type.
using	ScalarGrid2Ptr = std::shared_ptr< ScalarGrid2 >
	Shared pointer for the ScalarGrid2 type.
using	ScalarGrid3Ptr = std::shared_ptr< ScalarGrid3 >
	Shared pointer for the ScalarGrid3 type.
using	ScalarGridBuilder2 = ScalarGridBuilder< 2 >
	2-D ScalarGridBuilder type.
using	ScalarGridBuilder3 = ScalarGridBuilder< 3 >
	3-D ScalarGridBuilder type.
using	ScalarGridBuilder2Ptr = std::shared_ptr< ScalarGridBuilder2 >
	Shared pointer for the ScalarGridBuilder2 type.
using	ScalarGridBuilder3Ptr = std::shared_ptr< ScalarGridBuilder3 >
	Shared pointer for the ScalarGridBuilder3 type.
using	VectorGrid2 = VectorGrid< 2 >
	2-D VectorGrid type.
using	VectorGrid3 = VectorGrid< 3 >
	3-D VectorGrid type.
using	VectorGrid2Ptr = std::shared_ptr< VectorGrid2 >
	Shared pointer for the VectorGrid2 type.
using	VectorGrid3Ptr = std::shared_ptr< VectorGrid3 >
	Shared pointer for the VectorGrid3 type.
using	VectorGridBuilder2 = VectorGridBuilder< 2 >
	2-D VectorGridBuilder type.
using	VectorGridBuilder3 = VectorGridBuilder< 3 >
	3-D VectorGridBuilder type.
using	VectorGridBuilder2Ptr = std::shared_ptr< VectorGridBuilder2 >
	Shared pointer for the VectorGridBuilder2 type.
using	VectorGridBuilder3Ptr = std::shared_ptr< VectorGridBuilder3 >
	Shared pointer for the VectorGridBuilder3 type.
using	VertexCenteredScalarGrid2 = VertexCenteredScalarGrid< 2 >
	2-D VertexCenteredScalarGrid type.
using	VertexCenteredScalarGrid3 = VertexCenteredScalarGrid< 3 >
	3-D VertexCenteredScalarGrid type.
using	VertexCenteredScalarGrid2Ptr = std::shared_ptr< VertexCenteredScalarGrid2 >
	Shared pointer for the VertexCenteredScalarGrid2 type.
using	VertexCenteredScalarGrid3Ptr = std::shared_ptr< VertexCenteredScalarGrid3 >
	Shared pointer for the VertexCenteredScalarGrid3 type.
using	VertexCenteredVectorGrid2 = VertexCenteredVectorGrid< 2 >
	2-D VertexCenteredVectorGrid type.
using	VertexCenteredVectorGrid3 = VertexCenteredVectorGrid< 3 >
	3-D VertexCenteredVectorGrid type.
using	VertexCenteredVectorGrid2Ptr = std::shared_ptr< VertexCenteredVectorGrid2 >
	Shared pointer for the VertexCenteredVectorGrid2 type.
using	VertexCenteredVectorGrid3Ptr = std::shared_ptr< VertexCenteredVectorGrid3 >
	Shared pointer for the VertexCenteredVectorGrid3 type.
using	QuaternionF = Quaternion< float >
	Float-type quaternion.
using	QuaternionD = Quaternion< double >
	Double-type quaternion.
template<typename T >
using	Matrix2x2 = Matrix< T, 2, 2 >
template<typename T >
using	Matrix3x3 = Matrix< T, 3, 3 >
template<typename T >
using	Matrix4x4 = Matrix< T, 4, 4 >
using	Matrix2x2B = Matrix2x2< int8_t >
using	Matrix2x2UB = Matrix2x2< uint8_t >
using	Matrix2x2S = Matrix2x2< int16_t >
using	Matrix2x2US = Matrix2x2< uint16_t >
using	Matrix2x2I = Matrix2x2< int32_t >
using	Matrix2x2UI = Matrix2x2< uint32_t >
using	Matrix2x2L = Matrix2x2< int64_t >
using	Matrix2x2UL = Matrix2x2< uint64_t >
using	Matrix2x2F = Matrix2x2< float >
using	Matrix2x2D = Matrix2x2< double >
using	Matrix2x2Z = Matrix2x2< ssize_t >
using	Matrix2x2UZ = Matrix2x2< size_t >
using	Matrix3x3B = Matrix3x3< int8_t >
using	Matrix3x3UB = Matrix3x3< uint8_t >
using	Matrix3x3S = Matrix3x3< int16_t >
using	Matrix3x3US = Matrix3x3< uint16_t >
using	Matrix3x3I = Matrix3x3< int32_t >
using	Matrix3x3UI = Matrix3x3< uint32_t >
using	Matrix3x3L = Matrix3x3< int64_t >
using	Matrix3x3UL = Matrix3x3< uint64_t >
using	Matrix3x3F = Matrix3x3< float >
using	Matrix3x3D = Matrix3x3< double >
using	Matrix3x3Z = Matrix3x3< ssize_t >
using	Matrix3x3UZ = Matrix3x3< size_t >
using	Matrix4x4B = Matrix4x4< int8_t >
using	Matrix4x4UB = Matrix4x4< uint8_t >
using	Matrix4x4S = Matrix4x4< int16_t >
using	Matrix4x4US = Matrix4x4< uint16_t >
using	Matrix4x4I = Matrix4x4< int32_t >
using	Matrix4x4UI = Matrix4x4< uint32_t >
using	Matrix4x4L = Matrix4x4< int64_t >
using	Matrix4x4UL = Matrix4x4< uint64_t >
using	Matrix4x4F = Matrix4x4< float >
using	Matrix4x4D = Matrix4x4< double >
using	Matrix4x4Z = Matrix4x4< ssize_t >
using	Matrix4x4UZ = Matrix4x4< size_t >
template<typename T , size_t Rows>
using	Vector = Matrix< T, Rows, 1 >
template<typename T >
using	Vector1 = Vector< T, 1 >
template<typename T >
using	Vector2 = Vector< T, 2 >
template<typename T >
using	Vector3 = Vector< T, 3 >
template<typename T >
using	Vector4 = Vector< T, 4 >
using	Vector1B = Vector1< int8_t >
using	Vector1UB = Vector1< uint8_t >
using	Vector1S = Vector1< int16_t >
using	Vector1US = Vector1< uint16_t >
using	Vector1I = Vector1< int32_t >
using	Vector1UI = Vector1< uint32_t >
using	Vector1L = Vector1< int64_t >
using	Vector1UL = Vector1< uint64_t >
using	Vector1F = Vector1< float >
using	Vector1D = Vector1< double >
using	Vector1Z = Vector1< ssize_t >
using	Vector1UZ = Vector1< size_t >
using	Vector2B = Vector2< int8_t >
using	Vector2UB = Vector2< uint8_t >
using	Vector2S = Vector2< int16_t >
using	Vector2US = Vector2< uint16_t >
using	Vector2I = Vector2< int32_t >
using	Vector2UI = Vector2< uint32_t >
using	Vector2L = Vector2< int64_t >
using	Vector2UL = Vector2< uint64_t >
using	Vector2F = Vector2< float >
using	Vector2D = Vector2< double >
using	Vector2Z = Vector2< ssize_t >
using	Vector2UZ = Vector2< size_t >
using	Vector3B = Vector3< int8_t >
using	Vector3UB = Vector3< uint8_t >
using	Vector3S = Vector3< int16_t >
using	Vector3US = Vector3< uint16_t >
using	Vector3I = Vector3< int32_t >
using	Vector3UI = Vector3< uint32_t >
using	Vector3L = Vector3< int64_t >
using	Vector3UL = Vector3< uint64_t >
using	Vector3F = Vector3< float >
using	Vector3D = Vector3< double >
using	Vector3Z = Vector3< ssize_t >
using	Vector3UZ = Vector3< size_t >
using	Vector4B = Vector4< int8_t >
using	Vector4UB = Vector4< uint8_t >
using	Vector4S = Vector4< int16_t >
using	Vector4US = Vector4< uint16_t >
using	Vector4I = Vector4< int32_t >
using	Vector4UI = Vector4< uint32_t >
using	Vector4L = Vector4< int64_t >
using	Vector4UL = Vector4< uint64_t >
using	Vector4F = Vector4< float >
using	Vector4D = Vector4< double >
using	Vector4Z = Vector4< ssize_t >
using	Vector4UZ = Vector4< size_t >
template<typename T >
using	MatrixMxN = Matrix< T, MATRIX_SIZE_DYNAMIC, MATRIX_SIZE_DYNAMIC >
using	MatrixMxNB = MatrixMxN< int8_t >
using	MatrixMxNUB = MatrixMxN< uint8_t >
using	MatrixMxNS = MatrixMxN< int16_t >
using	MatrixMxNUS = MatrixMxN< uint16_t >
using	MatrixMxNI = MatrixMxN< int32_t >
using	MatrixMxNUI = MatrixMxN< uint32_t >
using	MatrixMxNL = MatrixMxN< int64_t >
using	MatrixMxNUL = MatrixMxN< uint64_t >
using	MatrixMxNF = MatrixMxN< float >
using	MatrixMxND = MatrixMxN< double >
using	MatrixMxNZ = MatrixMxN< ssize_t >
using	MatrixMxNUZ = MatrixMxN< size_t >
template<typename T >
using	VectorN = Matrix< T, MATRIX_SIZE_DYNAMIC, 1 >
using	VectorNB = VectorN< int8_t >
using	VectorNUB = VectorN< uint8_t >
using	VectorNS = VectorN< int16_t >
using	VectorNUS = VectorN< uint16_t >
using	VectorNI = VectorN< int32_t >
using	VectorNUI = VectorN< uint32_t >
using	VectorNL = VectorN< int64_t >
using	VectorNUL = VectorN< uint64_t >
using	VectorNF = VectorN< float >
using	VectorND = VectorN< double >
using	VectorNZ = VectorN< ssize_t >
using	VectorNUZ = VectorN< size_t >
typedef MatrixCSR< float >	MatrixCSRF
	Float-type CSR matrix.
typedef MatrixCSR< double >	MatrixCSRD
	Double-type CSR matrix.
template<typename T , size_t Rows, size_t Cols, typename M1 >
using	MatrixNegate = MatrixUnaryOp< T, Rows, Cols, M1, std::negate< T > >
template<typename T , size_t Rows, size_t Cols, typename M1 >
using	MatrixCeil = MatrixUnaryOp< T, Rows, Cols, M1, DoCeil< T > >
template<typename T , size_t Rows, size_t Cols, typename M1 >
using	MatrixFloor = MatrixUnaryOp< T, Rows, Cols, M1, DoFloor< T > >
template<typename T , size_t Rows, size_t Cols, typename U , typename M1 >
using	MatrixTypeCast = MatrixUnaryOp< U, Rows, Cols, M1, TypeCast< T, U > >
template<typename T , size_t Rows, size_t Cols, typename E1 , typename E2 >
using	MatrixElemWiseAdd = MatrixElemWiseBinaryOp< T, Rows, Cols, E1, E2, std::plus< T > >
	Matrix expression for element-wise matrix-matrix addition.
template<typename T , size_t Rows, size_t Cols, typename E1 , typename E2 >
using	MatrixElemWiseSub = MatrixElemWiseBinaryOp< T, Rows, Cols, E1, E2, std::minus< T > >
	Matrix expression for element-wise matrix-matrix subtraction.
template<typename T , size_t Rows, size_t Cols, typename E1 , typename E2 >
using	MatrixElemWiseMul = MatrixElemWiseBinaryOp< T, Rows, Cols, E1, E2, std::multiplies< T > >
	Matrix expression for element-wise matrix-matrix multiplication.
template<typename T , size_t Rows, size_t Cols, typename E1 , typename E2 >
using	MatrixElemWiseDiv = MatrixElemWiseBinaryOp< T, Rows, Cols, E1, E2, std::divides< T > >
	Matrix expression for element-wise matrix-matrix division.
template<typename T , size_t Rows, size_t Cols, typename E1 , typename E2 >
using	MatrixElemWiseMin = MatrixElemWiseBinaryOp< T, Rows, Cols, E1, E2, DoMin< T > >
	Matrix expression for element-wise matrix-matrix min operation.
template<typename T , size_t Rows, size_t Cols, typename E1 , typename E2 >
using	MatrixElemWiseMax = MatrixElemWiseBinaryOp< T, Rows, Cols, E1, E2, DoMax< T > >
	Matrix expression for element-wise matrix-matrix max operation.
template<typename T , size_t Rows, size_t Cols, typename M1 >
using	MatrixScalarElemWiseAdd = MatrixScalarElemWiseBinaryOp< T, Rows, Cols, M1, std::plus< T > >
template<typename T , size_t Rows, size_t Cols, typename M1 >
using	MatrixScalarElemWiseSub = MatrixScalarElemWiseBinaryOp< T, Rows, Cols, M1, std::minus< T > >
template<typename T , size_t Rows, size_t Cols, typename M1 >
using	MatrixScalarElemWiseMul = MatrixScalarElemWiseBinaryOp< T, Rows, Cols, M1, std::multiplies< T > >
template<typename T , size_t Rows, size_t Cols, typename M1 >
using	MatrixScalarElemWiseDiv = MatrixScalarElemWiseBinaryOp< T, Rows, Cols, M1, std::divides< T > >
template<typename T , size_t Rows, size_t Cols, typename M2 >
using	ScalarMatrixElemWiseAdd = ScalarMatrixElemWiseBinaryOp< T, Rows, Cols, M2, std::plus< T > >
template<typename T , size_t Rows, size_t Cols, typename M2 >
using	ScalarMatrixElemWiseSub = ScalarMatrixElemWiseBinaryOp< T, Rows, Cols, M2, std::minus< T > >
template<typename T , size_t Rows, size_t Cols, typename M2 >
using	ScalarMatrixElemWiseMul = ScalarMatrixElemWiseBinaryOp< T, Rows, Cols, M2, std::multiplies< T > >
template<typename T , size_t Rows, size_t Cols, typename M2 >
using	ScalarMatrixElemWiseDiv = ScalarMatrixElemWiseBinaryOp< T, Rows, Cols, M2, std::divides< T > >
template<typename T , size_t Rows, size_t Cols, typename M1 , typename M2 , typename M3 >
using	MatrixClamp = MatrixTernaryOp< T, Rows, Cols, M1, M2, M3, DoClamp< T > >
using	ParticleSystemData2 = ParticleSystemData< 2 >
	2-D ParticleSystemData type.
using	ParticleSystemData3 = ParticleSystemData< 3 >
	3-D ParticleSystemData type.
using	ParticleSystemData2Ptr = std::shared_ptr< ParticleSystemData2 >
	Shared pointer type of ParticleSystemData2.
using	ParticleSystemData3Ptr = std::shared_ptr< ParticleSystemData3 >
	Shared pointer type of ParticleSystemData3.
using	SPHStdKernel2 = SPHStdKernel< 2 >
using	SPHStdKernel3 = SPHStdKernel< 3 >
using	SPHSpikyKernel2 = SPHSpikyKernel< 2 >
using	SPHSpikyKernel3 = SPHSpikyKernel< 3 >
using	SPHSystemData2 = SPHSystemData< 2 >
	2-D SPHSystemData type.
using	SPHSystemData3 = SPHSystemData< 3 >
	3-D SPHSystemData type.
using	SPHSystemData2Ptr = std::shared_ptr< SPHSystemData2 >
	Shared pointer for the SPHSystemData2 type.
using	SPHSystemData3Ptr = std::shared_ptr< SPHSystemData3 >
	Shared pointer for the SPHSystemData3 type.
using	BccLatticePointGeneratorPtr = std::shared_ptr< BccLatticePointGenerator >
	Shared pointer type for the BccLatticePointGenerator.
using	GridPointGenerator2Ptr = std::shared_ptr< GridPointGenerator2 >
	Shared pointer type for the GridPointGenerator2.
using	GridPointGenerator3Ptr = std::shared_ptr< GridPointGenerator3 >
	Shared pointer type for the GridPointGenerator3.
using	PointGenerator2Ptr = std::shared_ptr< PointGenerator2 >
	Shared pointer for the PointGenerator2 type.
using	PointGenerator3Ptr = std::shared_ptr< PointGenerator3 >
	Shared pointer for the PointGenerator3 type.
using	TrianglePointGeneratorPtr = std::shared_ptr< TrianglePointGenerator >
using	AnisotropicPointsToImplicit2Ptr = std::shared_ptr< AnisotropicPointsToImplicit2 >
	Shared pointer for the AnisotropicPointsToImplicit2 type.
using	AnisotropicPointsToImplicit3Ptr = std::shared_ptr< AnisotropicPointsToImplicit3 >
	Shared pointer for the AnisotropicPointsToImplicit3 type.
using	PointsToImplicit2Ptr = std::shared_ptr< PointsToImplicit2 >
	Shared pointer for the PointsToImplicit2 type.
using	PointsToImplicit3Ptr = std::shared_ptr< PointsToImplicit3 >
	Shared pointer for the PointsToImplicit3 type.
using	SphericalPointsToImplicit2Ptr = std::shared_ptr< SphericalPointsToImplicit2 >
	Shared pointer type for SphericalPointsToImplicit2.
using	SphericalPointsToImplicit3Ptr = std::shared_ptr< SphericalPointsToImplicit3 >
	Shared pointer type for SphericalPointsToImplicit3.
using	SPHPointsToImplicit2Ptr = std::shared_ptr< SPHPointsToImplicit2 >
	Shared pointer type for SPHPointsToImplicit2 class.
using	SPHPointsToImplicit3Ptr = std::shared_ptr< SPHPointsToImplicit3 >
	Shared pointer type for SPHPointsToImplicit3 class.
using	ZhuBridsonPointsToImplicit2Ptr = std::shared_ptr< ZhuBridsonPointsToImplicit2 >
	Shared pointer type for ZhuBridsonPointsToImplicit2 class.
using	ZhuBridsonPointsToImplicit3Ptr = std::shared_ptr< ZhuBridsonPointsToImplicit3 >
	Shared pointer type for ZhuBridsonPointsToImplicit3 class.
template<typename T >
using	ClosestIntersectionQueryResult2 = ClosestIntersectionQueryResult< T, 2 >
	2-D closest intersection query result.
template<typename T >
using	ClosestIntersectionQueryResult3 = ClosestIntersectionQueryResult< T, 3 >
	3-D closest intersection query result.
template<typename T , size_t N>
using	ClosestIntersectionDistanceFunc = std::function< double(const T &, const Vector< double, N > &)>
	N-D closest intersection distance measure function.
template<typename T >
using	ClosestIntersectionDistanceFunc2 = ClosestIntersectionDistanceFunc< T, 2 >
	2-D closestIntersectionDistanceFunc.
template<typename T >
using	ClosestIntersectionDistanceFunc3 = ClosestIntersectionDistanceFunc< T, 3 >
	3-D closestIntersectionDistanceFunc.
template<typename T , size_t N>
using	BoxIntersectionTestFunc = std::function< bool(const T &, const BoundingBox< double, N > &)>
	N-D box-item intersection test function.
template<typename T >
using	BoxIntersectionTestFunc2 = BoxIntersectionTestFunc< T, 2 >
	2-D box-item intersection test function.
template<typename T >
using	BoxIntersectionTestFunc3 = BoxIntersectionTestFunc< T, 3 >
	3-D box-item intersection test function.
template<typename T , size_t N>
using	RayIntersectionTestFunc = std::function< bool(const T &, const Ray< double, N > &)>
	N-D ray-item intersection test function.
template<typename T >
using	RayIntersectionTestFunc2 = RayIntersectionTestFunc< T, 2 >
	2-D ray-item intersection test function.
template<typename T >
using	RayIntersectionTestFunc3 = RayIntersectionTestFunc< T, 3 >
	3-D ray-item intersection test function.
template<typename T , size_t N>
using	GetRayIntersectionFunc = std::function< double(const T &, const Ray< double, N > &)>
	N-D ray-item closest intersection evaluation function.
template<typename T >
using	GetRayIntersectionFunc2 = GetRayIntersectionFunc< T, 2 >
	2-D ray-item closest intersection evaluation function.
template<typename T >
using	GetRayIntersectionFunc3 = GetRayIntersectionFunc< T, 3 >
	3-D ray-item closest intersection evaluation function.
template<typename T >
using	IntersectionVisitorFunc = std::function< void(const T &)>
	Visitor function which is invoked for each intersecting item.
template<typename T >
using	IntersectionQueryEngine2 = IntersectionQueryEngine< T, 2 >
	Abstract base class for 2-D intersection test query engine.
template<typename T >
using	IntersectionQueryEngine3 = IntersectionQueryEngine< T, 3 >
	Abstract base class for 3-D intersection test query engine.
template<typename T >
using	ListQueryEngine2 = ListQueryEngine< T, 2 >
	2-D ListQueryEngine type.
template<typename T >
using	ListQueryEngine3 = ListQueryEngine< T, 3 >
	3-D ListQueryEngine type.
template<typename T >
using	NearestNeighborQueryResult2 = NearestNeighborQueryResult< T, 2 >
	2-D nearest neighbor query result.
template<typename T >
using	NearestNeighborQueryResult3 = NearestNeighborQueryResult< T, 3 >
	3-D nearest neighbor query result.
template<typename T , size_t N>
using	NearestNeighborDistanceFunc = std::function< double(const T &, const Vector< double, N > &)>
	N-D nearest neighbor distance measure function.
template<typename T >
using	NearestNeighborDistanceFunc2 = NearestNeighborDistanceFunc< T, 2 >
	2-D nearest neighbor distance measure function.
template<typename T >
using	NearestNeighborDistanceFunc3 = NearestNeighborDistanceFunc< T, 3 >
	3-D nearest neighbor distance measure function.
template<typename T >
using	NearestNeighborQueryEngine2 = NearestNeighborQueryEngine< T, 2 >
	Abstract base class for 2-D nearest neighbor query engine.
template<typename T >
using	NearestNeighborQueryEngine3 = NearestNeighborQueryEngine< T, 3 >
	Abstract base class for 3-D nearest neighbor query engine.
using	PointHashGridSearcher2 = PointHashGridSearcher< 2 >
	2-D PointHashGridSearcher type.
using	PointHashGridSearcher3 = PointHashGridSearcher< 3 >
	3-D PointHashGridSearcher type.
using	PointHashGridSearcher2Ptr = std::shared_ptr< PointHashGridSearcher2 >
	Shared pointer for the PointHashGridSearcher2 type.
using	PointHashGridSearcher3Ptr = std::shared_ptr< PointHashGridSearcher3 >
	Shared pointer for the PointHashGridSearcher3 type.
using	PointKdTreeSearcher2 = PointKdTreeSearcher< 2 >
	2-D PointKdTreeSearcher type.
using	PointKdTreeSearcher3 = PointKdTreeSearcher< 3 >
	3-D PointKdTreeSearcher type.
using	PointKdTreeSearcher2Ptr = std::shared_ptr< PointKdTreeSearcher2 >
	Shared pointer for the PointKdTreeSearcher2 type.
using	PointKdTreeSearcher3Ptr = std::shared_ptr< PointKdTreeSearcher3 >
	Shared pointer for the PointKdTreeSearcher3 type.
using	PointNeighborSearcher2 = PointNeighborSearcher< 2 >
	2-D PointNeighborSearcher type.
using	PointNeighborSearcher3 = PointNeighborSearcher< 3 >
	3-D PointNeighborSearcher type.
using	PointNeighborSearcher2Ptr = std::shared_ptr< PointNeighborSearcher2 >
	Shared pointer for the PointNeighborSearcher2 type.
using	PointNeighborSearcher3Ptr = std::shared_ptr< PointNeighborSearcher3 >
	Shared pointer for the PointNeighborSearcher3 type.
using	PointNeighborSearcherBuilder2 = PointNeighborSearcherBuilder< 2 >
	2-D PointNeighborSearcherBuilder type.
using	PointNeighborSearcherBuilder3 = PointNeighborSearcherBuilder< 3 >
	3-D PointNeighborSearcherBuilder type.
using	PointNeighborSearcherBuilder2Ptr = std::shared_ptr< PointNeighborSearcherBuilder2 >
	Shared pointer for the PointNeighborSearcher2 type.
using	PointNeighborSearcherBuilder3Ptr = std::shared_ptr< PointNeighborSearcherBuilder3 >
	Shared pointer for the PointNeighborSearcher3 type.
using	PointParallelHashGridSearcher2 = PointParallelHashGridSearcher< 2 >
	2-D PointParallelHashGridSearcher type.
using	PointParallelHashGridSearcher3 = PointParallelHashGridSearcher< 3 >
	3-D PointParallelHashGridSearcher type.
using	PointParallelHashGridSearcher2Ptr = std::shared_ptr< PointParallelHashGridSearcher2 >
	Shared pointer for the PointParallelHashGridSearcher2 type.
using	PointParallelHashGridSearcher3Ptr = std::shared_ptr< PointParallelHashGridSearcher3 >
	Shared pointer for the PointParallelHashGridSearcher3 type.
using	PointSimpleListSearcher2 = PointSimpleListSearcher< 2 >
	2-D PointSimpleListSearcher type.
using	PointSimpleListSearcher3 = PointSimpleListSearcher< 3 >
	3-D PointSimpleListSearcher type.
using	PointSimpleListSearcher2Ptr = std::shared_ptr< PointSimpleListSearcher< 2 > >
	Shared pointer for the PointSimpleListSearcher2 type.
using	PointSimpleListSearcher3Ptr = std::shared_ptr< PointSimpleListSearcher< 3 > >
	Shared pointer for the PointSimpleListSearcher3 type.
using	AdvectionSolver2Ptr = std::shared_ptr< AdvectionSolver2 >
	Shared pointer type for the 2-D advection solver.
using	AdvectionSolver3Ptr = std::shared_ptr< AdvectionSolver3 >
	Shared pointer type for the 3-D advection solver.
using	CubicSemiLagrangian2Ptr = std::shared_ptr< CubicSemiLagrangian2 >
using	CubicSemiLagrangian3Ptr = std::shared_ptr< CubicSemiLagrangian3 >
using	SemiLagrangian2Ptr = std::shared_ptr< SemiLagrangian2 >
using	SemiLagrangian3Ptr = std::shared_ptr< SemiLagrangian3 >
using	FDMCGSolver2Ptr = std::shared_ptr< FDMCGSolver2 >
	Shared pointer type for the FDMCGSolver2.
using	FDMCGSolver3Ptr = std::shared_ptr< FDMCGSolver3 >
	Shared pointer type for the FDMCGSolver3.
using	FDMGaussSeidelSolver2Ptr = std::shared_ptr< FDMGaussSeidelSolver2 >
	Shared pointer type for the FDMGaussSeidelSolver2.
using	FDMGaussSeidelSolver3Ptr = std::shared_ptr< FDMGaussSeidelSolver3 >
	Shared pointer type for the FDMGaussSeidelSolver3.
using	FDMICCGSolver2Ptr = std::shared_ptr< FDMICCGSolver2 >
	Shared pointer type for the FDMICCGSolver2.
using	FDMICCGSolver3Ptr = std::shared_ptr< FDMICCGSolver3 >
	Shared pointer type for the FDMICCGSolver3.
using	FDMJacobiSolver2Ptr = std::shared_ptr< FDMJacobiSolver2 >
	Shared pointer type for the FDMJacobiSolver2.
using	FDMJacobiSolver3Ptr = std::shared_ptr< FDMJacobiSolver3 >
	Shared pointer type for the FDMJacobiSolver3.
using	FDMLinearSystemSolver2Ptr = std::shared_ptr< FDMLinearSystemSolver2 >
	Shared pointer type for the FDMLinearSystemSolver2.
using	FDMLinearSystemSolver3Ptr = std::shared_ptr< FDMLinearSystemSolver3 >
	Shared pointer type for the FDMLinearSystemSolver3.
using	FDMMGPCGSolver2Ptr = std::shared_ptr< FDMMGPCGSolver2 >
	Shared pointer type for the FDMMGPCGSolver2.
using	FDMMGPCGSolver3Ptr = std::shared_ptr< FDMMGPCGSolver3 >
	Shared pointer type for the FDMMGPCGSolver3.
using	FDMMGSolver2Ptr = std::shared_ptr< FDMMGSolver2 >
	Shared pointer type for the FDMMGSolver2.
using	FDMMGSolver3Ptr = std::shared_ptr< FDMMGSolver3 >
	Shared pointer type for the FDMMGSolver3.
using	GridBackwardEulerDiffusionSolver2Ptr = std::shared_ptr< GridBackwardEulerDiffusionSolver2 >
	Shared pointer type for the GridBackwardEulerDiffusionSolver2.
using	GridBackwardEulerDiffusionSolver3Ptr = std::shared_ptr< GridBackwardEulerDiffusionSolver3 >
	Shared pointer type for the GridBackwardEulerDiffusionSolver3.
using	GridBlockedBoundaryConditionSolver2Ptr = std::shared_ptr< GridBlockedBoundaryConditionSolver2 >
	Shared pointer type for the GridBlockedBoundaryConditionSolver2.
using	GridBlockedBoundaryConditionSolver3Ptr = std::shared_ptr< GridBlockedBoundaryConditionSolver3 >
	Shared pointer type for the GridBlockedBoundaryConditionSolver3.
using	GridBoundaryConditionSolver2Ptr = std::shared_ptr< GridBoundaryConditionSolver2 >
	Shared pointer type for the GridBoundaryConditionSolver2.
using	GridBoundaryConditionSolver3Ptr = std::shared_ptr< GridBoundaryConditionSolver3 >
	Shared pointer type for the GridBoundaryConditionSolver3.
using	GridDiffusionSolver2Ptr = std::shared_ptr< GridDiffusionSolver2 >
	Shared pointer type for the GridDiffusionSolver2.
using	GridDiffusionSolver3Ptr = std::shared_ptr< GridDiffusionSolver3 >
	Shared pointer type for the GridDiffusionSolver3.
using	GridFluidSolver2Ptr = std::shared_ptr< GridFluidSolver2 >
	Shared pointer type for the GridFluidSolver2.
using	GridFluidSolver3Ptr = std::shared_ptr< GridFluidSolver3 >
	Shared pointer type for the GridFluidSolver3.
using	GridForwardEulerDiffusionSolver2Ptr = std::shared_ptr< GridForwardEulerDiffusionSolver2 >
	Shared pointer type for the GridForwardEulerDiffusionSolver2.
using	GridForwardEulerDiffusionSolver3Ptr = std::shared_ptr< GridForwardEulerDiffusionSolver3 >
	Shared pointer type for the GridForwardEulerDiffusionSolver3.
using	GridFractionalBoundaryConditionSolver2Ptr = std::shared_ptr< GridFractionalBoundaryConditionSolver2 >
	Shared pointer type for the GridFractionalBoundaryConditionSolver2.
using	GridFractionalBoundaryConditionSolver3Ptr = std::shared_ptr< GridFractionalBoundaryConditionSolver3 >
	Shared pointer type for the GridFractionalBoundaryConditionSolver3.
using	GridFractionalSinglePhasePressureSolver2Ptr = std::shared_ptr< GridFractionalSinglePhasePressureSolver2 >
	Shared pointer type for the GridFractionalSinglePhasePressureSolver2.
using	GridFractionalSinglePhasePressureSolver3Ptr = std::shared_ptr< GridFractionalSinglePhasePressureSolver3 >
	Shared pointer type for the GridFractionalSinglePhasePressureSolver3.
using	GridPressureSolver2Ptr = std::shared_ptr< GridPressureSolver2 >
	Shared pointer type for the GridPressureSolver2.
using	GridPressureSolver3Ptr = std::shared_ptr< GridPressureSolver3 >
	Shared pointer type for the GridPressureSolver3.
using	GridSinglePhasePressureSolver2Ptr = std::shared_ptr< GridSinglePhasePressureSolver2 >
	Shared pointer type for the GridSinglePhasePressureSolver2.
using	GridSinglePhasePressureSolver3Ptr = std::shared_ptr< GridSinglePhasePressureSolver3 >
	Shared pointer type for the GridSinglePhasePressureSolver3.
using	GridSmokeSolver2Ptr = std::shared_ptr< GridSmokeSolver2 >
	Shared pointer type for the GridSmokeSolver2.
using	GridSmokeSolver3Ptr = std::shared_ptr< GridSmokeSolver3 >
	Shared pointer type for the GridSmokeSolver3.
using	APICSolver2Ptr = std::shared_ptr< APICSolver2 >
	Shared pointer type for the APICSolver2.
using	APICSolver3Ptr = std::shared_ptr< APICSolver3 >
	Shared pointer type for the APICSolver3.
using	FLIPSolver2Ptr = std::shared_ptr< FLIPSolver2 >
	Shared pointer type for the FLIPSolver2.
using	FLIPSolver3Ptr = std::shared_ptr< FLIPSolver3 >
	Shared pointer type for the FLIPSolver3.
using	PICSolver2Ptr = std::shared_ptr< PICSolver2 >
	Shared pointer type for the PICSolver2.
using	PICSolver3Ptr = std::shared_ptr< PICSolver3 >
	Shared pointer type for the PICSolver3.
using	ENOLevelSetSolver2Ptr = std::shared_ptr< ENOLevelSetSolver2 >
using	ENOLevelSetSolver3Ptr = std::shared_ptr< ENOLevelSetSolver3 >
using	FMMLevelSetSolver2Ptr = std::shared_ptr< FMMLevelSetSolver2 >
	Shared pointer type for the FMMLevelSetSolver2.
using	FMMLevelSetSolver3Ptr = std::shared_ptr< FMMLevelSetSolver3 >
	Shared pointer type for the FMMLevelSetSolver3.
using	IterativeLevelSetSolver2Ptr = std::shared_ptr< IterativeLevelSetSolver2 >
using	IterativeLevelSetSolver3Ptr = std::shared_ptr< IterativeLevelSetSolver3 >
using	LevelSetLiquidSolver2Ptr = std::shared_ptr< LevelSetLiquidSolver2 >
	Shared pointer type for the LevelSetLiquidSolver2.
using	LevelSetLiquidSolver3Ptr = std::shared_ptr< LevelSetLiquidSolver3 >
	Shared pointer type for the LevelSetLiquidSolver3.
using	LevelSetSolver2Ptr = std::shared_ptr< LevelSetSolver2 >
	Shared pointer type for the LevelSetSolver2.
using	LevelSetSolver3Ptr = std::shared_ptr< LevelSetSolver3 >
	Shared pointer type for the LevelSetSolver3.
using	UpwindLevelSetSolver2Ptr = std::shared_ptr< UpwindLevelSetSolver2 >
using	UpwindLevelSetSolver3Ptr = std::shared_ptr< UpwindLevelSetSolver3 >
using	ParticleSystemSolver2Ptr = std::shared_ptr< ParticleSystemSolver2 >
	Shared pointer type for the ParticleSystemSolver2.
using	ParticleSystemSolver3Ptr = std::shared_ptr< ParticleSystemSolver3 >
	Shared pointer type for the ParticleSystemSolver3.
using	PCISPHSolver2Ptr = std::shared_ptr< PCISPHSolver2 >
	Shared pointer type for the PCISPHSolver2.
using	PCISPHSolver3Ptr = std::shared_ptr< PCISPHSolver3 >
	Shared pointer type for the PCISPHSolver3.
using	SPHSolver2Ptr = std::shared_ptr< SPHSolver2 >
	Shared pointer type for the SPHSolver2.
using	SPHSolver3Ptr = std::shared_ptr< SPHSolver3 >
	Shared pointer type for the SPHSolver3.
template<typename BlasType >
using	MGRelaxFunc = std::function< void(const typename BlasType::MatrixType &A, const typename BlasType::VectorType &b, unsigned int numberOfIterations, double maxTolerance, typename BlasType::VectorType *x, typename BlasType::VectorType *buffer)>
	Multi-grid relax function type.
template<typename BlasType >
using	MGRestrictFunc = std::function< void(const typename BlasType::VectorType &finer, typename BlasType::VectorType *coarser)>
	Multi-grid restriction function type.
template<typename BlasType >
using	MGCorrectFunc = std::function< void(const typename BlasType::VectorType &coarser, typename BlasType::VectorType *finer)>
	Multi-grid correction function type.
template<typename T , size_t N>
using	NestedInitializerListsT = typename NestedInitializerLists< T, N >::Type
using	PointHashGridUtils2 = PointHashGridUtils< 2 >
using	PointHashGridUtils3 = PointHashGridUtils< 3 >

Enumerations
enum class	LogLevel : uint8_t {   All = 0 , Debug = 1 , Info = 2 , Warn = 3 ,   Error = 4 , Off = 5 }
enum class	ExecutionPolicy { Serial , Parallel }
	Execution policy tag. More...

Functions
Vector2UZ	TupleToVector2UZ (pybind11::tuple tuple)
Vector2UZ	TupleToVector2UZ (pybind11::list list)
Vector3UZ	TupleToVector3UZ (pybind11::tuple tuple)
Vector3UZ	TupleToVector3UZ (pybind11::list list)
pybind11::tuple	Vector2UZToTuple (const Vector2UZ &size)
pybind11::tuple	Vector3UZToTuple (const Vector3UZ &size)
template<typename T , size_t N>
Vector< T, N >	TupleToVector (pybind11::tuple tuple)
template<typename T , size_t N>
Vector< T, N >	TupleToVector (pybind11::list list)
template<typename T >
Quaternion< T >	TupleToQuaternion (pybind11::tuple tuple)
template<typename T >
Quaternion< T >	TupleToQuaternion (pybind11::list list)
Vector2F	TupleToVector2F (pybind11::tuple tuple)
Vector2F	TupleToVector2F (pybind11::list list)
Vector3F	TupleToVector3F (pybind11::tuple tuple)
Vector3F	TupleToVector3F (pybind11::list list)
Vector4F	TupleToVector4F (pybind11::tuple tuple)
Vector4F	TupleToVector4F (pybind11::list list)
QuaternionF	TupleToQuaternionF (pybind11::tuple tuple)
QuaternionF	TupleToQuaternionF (pybind11::list list)
Vector2D	TupleToVector2D (pybind11::tuple tuple)
Vector2D	TupleToVector2D (pybind11::list list)
Vector3D	TupleToVector3D (pybind11::tuple tuple)
Vector3D	TupleToVector3D (pybind11::list list)
Vector4D	TupleToVector4D (pybind11::tuple tuple)
Vector4D	TupleToVector4D (pybind11::list list)
template<typename T >
pybind11::tuple	Vector2ToTuple (const Vector< T, 2 > &vec)
template<typename T >
pybind11::tuple	Vector3ToTuple (const Vector< T, 3 > &vec)
template<typename T >
pybind11::tuple	Vector4ToTuple (const Vector< T, 4 > &vec)
QuaternionD	TupleToQuaternionD (pybind11::tuple tuple)
QuaternionD	TupleToQuaternionD (pybind11::list list)
Vector2UZ	ObjectToVector2UZ (const pybind11::object &obj)
Vector3UZ	ObjectToVector3UZ (const pybind11::object &obj)
Vector2F	ObjectToVector2F (const pybind11::object &obj)
Vector2D	ObjectToVector2D (const pybind11::object &obj)
Vector3F	ObjectToVector3F (const pybind11::object &obj)
Vector3D	ObjectToVector3D (const pybind11::object &obj)
Vector4F	ObjectToVector4F (const pybind11::object &obj)
Vector4D	ObjectToVector4D (const pybind11::object &obj)
QuaternionF	ObjectToQuaternionF (const pybind11::object &obj)
QuaternionD	ObjectToQuaternionD (const pybind11::object &obj)
void	ParseGridResizeParams (pybind11::args args, pybind11::kwargs kwargs, Vector2UZ &resolution, Vector2D &gridSpacing, Vector2D &gridOrigin)
template<typename T , size_t N>
void	Fill (ArrayView< T, N > a, const Vector< size_t, N > &begin, const Vector< size_t, N > &end, const T &val)
template<typename T , size_t N>
void	Fill (ArrayView< T, N > a, const T &val)
template<typename T >
void	Fill (ArrayView< T, 1 > a, size_t begin, size_t end, const T &val)
template<typename T , typename U , size_t N>
void	Copy (ArrayView< T, N > src, const Vector< size_t, N > &begin, const Vector< size_t, N > &end, ArrayView< U, N > dst)
template<typename T , typename U , size_t N>
void	Copy (ArrayView< T, N > src, ArrayView< U, N > dst)
template<typename T , typename U >
void	Copy (ArrayView< T, 1 > src, size_t begin, size_t end, ArrayView< U, 1 > dst)
template<typename T , typename U >
void	ExtrapolateToRegion (ArrayView2< T > input, ArrayView2< char > valid, unsigned int numberOfIterations, ArrayView2< U > output)
	Extrapolates 2-D input data from 'valid' (1) to 'invalid' (0) region.
template<typename T , typename U >
void	ExtrapolateToRegion (ArrayView3< T > input, ArrayView3< char > valid, unsigned int numberOfIterations, ArrayView3< U > output)
	Extrapolates 3-D input data from 'valid' (1) to 'invalid' (0) region.
Vector2D	Gradient2 (const ConstArrayView2< double > &data, const Vector2D &gridSpacing, size_t i, size_t j)
	Returns 2-D gradient vector from given 2-D scalar grid-like array data, gridSpacing, and array index (i, j).
std::array< Vector2D, 2 >	Gradient2 (const ConstArrayView2< Vector2D > &data, const Vector2D &gridSpacing, size_t i, size_t j)
	Returns 2-D gradient vectors from given 2-D vector grid-like array data, gridSpacing, and array index (i, j).
Vector3D	Gradient3 (const ConstArrayView3< double > &data, const Vector3D &gridSpacing, size_t i, size_t j, size_t k)
	Returns 3-D gradient vector from given 3-D scalar grid-like array data, gridSpacing, and array index (i, j, k).
std::array< Vector3D, 3 >	Gradient3 (const ConstArrayView3< Vector3D > &data, const Vector3D &gridSpacing, size_t i, size_t j, size_t k)
	Returns 3-D gradient vectors from given 3-D vector grid-like array data, gridSpacing, and array index (i, j, k).
double	Laplacian2 (const ConstArrayView2< double > &data, const Vector2D &gridSpacing, size_t i, size_t j)
	Returns Laplacian value from given 2-D scalar grid-like array data, gridSpacing, and array index (i, j).
Vector2D	Laplacian2 (const ConstArrayView2< Vector2D > &data, const Vector2D &gridSpacing, size_t i, size_t j)
	Returns 2-D Laplacian vectors from given 2-D vector grid-like array data, gridSpacing, and array index (i, j).
double	Laplacian3 (const ConstArrayView3< double > &data, const Vector3D &gridSpacing, size_t i, size_t j, size_t k)
	Returns Laplacian value from given 3-D scalar grid-like array data, gridSpacing, and array index (i, j, k).
Vector3D	Laplacian3 (const ConstArrayView3< Vector3D > &data, const Vector3D &gridSpacing, size_t i, size_t j, size_t k)
	Returns 3-D Laplacian vectors from given 3-D vector grid-like array data, gridSpacing, and array index (i, j, k).
double	Divergence2 (const ConstArrayView2< Vector2D > &data, const Vector2D &gridSpacing, size_t i, size_t j)
	Returns divergence value from given 2-D vector grid-like array data, gridSpacing, and array index (i, j).
double	Divergence3 (const ConstArrayView3< Vector3D > &data, const Vector3D &gridSpacing, size_t i, size_t j, size_t k)
	Returns diverence value from given 3-D vector grid-like array data, gridSpacing, and array index (i, j, k).
double	Curl2 (const ConstArrayView2< Vector2D > &data, const Vector2D &gridSpacing, size_t i, size_t j)
	Returns curl value from given 2-D vector grid-like array data, gridSpacing, and array index (i, j).
Vector3D	Curl3 (const ConstArrayView3< Vector3D > &data, const Vector3D &gridSpacing, size_t i, size_t j, size_t k)
	Returns curl value from given 3-D vector grid-like array data, gridSpacing, and array index (i, j, k).
void	MarchingCubes (const ConstArrayView3< double > &grid, const Vector3D &gridSize, const Vector3D &origin, TriangleMesh3 *mesh, double isoValue=0, int bndClose=DIRECTION_ALL, int bndConnectivity=DIRECTION_NONE)
	Computes marching cubes and extract triangle mesh from grid.
void	TriangleMeshToSDF (const TriangleMesh3 &mesh, ScalarGrid3 *sdf)
	Generates signed-distance field out of given triangle mesh. This function generates signed-distance field from a triangle mesh. The sign is determined by TriangleMesh3::IsInside (negative means inside).
template<typename BLASType >
void	CG (const typename BLASType::MatrixType &A, const typename BLASType::VectorType &b, unsigned int maxNumberOfIterations, double tolerance, typename BLASType::VectorType *x, typename BLASType::VectorType *r, typename BLASType::VectorType *d, typename BLASType::VectorType *q, typename BLASType::VectorType *s, unsigned int *lastNumberOfIterations, double *lastResidualNorm)
	Solves conjugate gradient.
template<typename BLASType , typename PrecondType >
void	PCG (const typename BLASType::MatrixType &A, const typename BLASType::VectorType &b, unsigned int maxNumberOfIterations, double tolerance, PrecondType *M, typename BLASType::VectorType *x, typename BLASType::VectorType *r, typename BLASType::VectorType *d, typename BLASType::VectorType *q, typename BLASType::VectorType *s, unsigned int *lastNumberOfIterations, double *lastResidualNorm)
	Solves pre-conditioned conjugate gradient.
template<typename T >
std::enable_if_t< std::is_arithmetic< T >::value, bool >	Similar (T x, T y, T eps=std::numeric_limits< T >::epsilon())
	Returns true if x and y are similar.
template<typename T >
std::enable_if_t< std::is_arithmetic< T >::value, T >	Sign (T x)
	Returns the sign of the value.
template<typename T >
std::enable_if_t< std::is_arithmetic< T >::value, T >	Min3 (T x, T y, T z)
	Returns the minimum value among three inputs.
template<typename T >
std::enable_if_t< std::is_arithmetic< T >::value, T >	Max3 (T x, T y, T z)
	Returns the maximum value among three inputs.
template<typename T >
std::enable_if_t< std::is_arithmetic< T >::value, T >	MinN (const T *x, size_t n)
	Returns minimum among n-elements.
template<typename T >
std::enable_if_t< std::is_arithmetic< T >::value, T >	MaxN (const T *x, size_t n)
	Returns maximum among n-elements.
template<typename T >
std::enable_if_t< std::is_arithmetic< T >::value, T >	AbsMin (T x, T y)
	Returns the absolute minimum value among the two inputs.
template<typename T >
std::enable_if_t< std::is_arithmetic< T >::value, T >	AbsMax (T x, T y)
	Returns the absolute maximum value among the two inputs.
template<typename T >
std::enable_if_t< std::is_arithmetic< T >::value, T >	AbsMinN (const T *x, size_t n)
	Returns absolute minimum among n-elements.
template<typename T >
std::enable_if_t< std::is_arithmetic< T >::value, T >	AbsMaxN (const T *x, size_t n)
	Returns absolute maximum among n-elements.
template<typename T >
std::enable_if_t< std::is_arithmetic< T >::value, size_t >	ArgMin2 (T x, T y)
template<typename T >
std::enable_if_t< std::is_arithmetic< T >::value, size_t >	ArgMax2 (T x, T y)
template<typename T >
std::enable_if_t< std::is_arithmetic< T >::value, size_t >	ArgMin3 (T x, T y, T z)
template<typename T >
std::enable_if_t< std::is_arithmetic< T >::value, size_t >	ArgMax3 (T x, T y, T z)
template<typename T >
std::enable_if_t< std::is_arithmetic< T >::value, T >	Square (T x)
	Returns the square of x.
template<typename T >
std::enable_if_t< std::is_arithmetic< T >::value, T >	Cubic (T x)
	Returns the cubic of x.
template<typename T >
std::enable_if_t< std::is_arithmetic< T >::value, T >	Clamp (T val, T low, T high)
	Returns the clamped value.
template<typename T >
std::enable_if_t< std::is_arithmetic< T >::value, T >	DegreesToRadians (T angleInDegrees)
	Converts degrees to radians.
template<typename T >
std::enable_if_t< std::is_arithmetic< T >::value, T >	RadiansToDegrees (T angleInRadians)
	Converts radians to degrees.
template<typename T >
std::enable_if_t< std::is_arithmetic< T >::value >	GetBarycentric (T x, size_t begin, size_t end, size_t &i, T &t)
	Computes the barycentric coordinate.
template<typename T >
std::enable_if_t< std::is_arithmetic< T >::value >	GetBarycentric (T x, size_t end, size_t &i, T &t)
template<typename T >
std::enable_if_t< std::is_arithmetic< T >::value >	GetBarycentric (T x, ssize_t begin, ssize_t end, ssize_t &i, T &t)
	Computes the barycentric coordinate.
template<typename T >
std::enable_if_t< std::is_arithmetic< T >::value >	GetBarycentric (T x, ssize_t end, ssize_t &i, T &t)
template<typename S , typename T >
std::enable_if_t< std::is_arithmetic< T >::value, S >	Lerp (const S &f0, const S &f1, T t)
	Computes linear interpolation.
template<typename S , typename T >
std::enable_if_t< std::is_arithmetic< T >::value, S >	BiLerp (const S &f00, const S &f10, const S &f01, const S &f11, T tx, T ty)
	Computes bilinear interpolation.
template<typename S , typename T >
std::enable_if_t< std::is_arithmetic< T >::value, S >	TriLerp (const S &f000, const S &f100, const S &f010, const S &f110, const S &f001, const S &f101, const S &f011, const S &f111, T tx, T ty, T tz)
	Computes trilinear interpolation.
template<typename S , typename T >
std::enable_if_t< std::is_arithmetic< T >::value, S >	CatmullRom (const S &f0, const S &f1, const S &f2, const S &f3, T t)
	Computes Catmull-Rom interpolation.
template<typename T >
std::enable_if_t< std::is_arithmetic< T >::value, T >	MonotonicCatmullRom (const T &f0, const T &f1, const T &f2, const T &f3, T t)
	Computes monotonic Catmull-Rom interpolation.
template<typename T >
std::array< T, 2 >	Upwind1 (T *d0, T dx)
	1st order upwind differencing. d0[1] is the origin.
template<typename T >
T	Upwind1 (T *d0, T dx, bool isDirectionPositive)
	1st order upwind differencing. d0[1] is the origin.
template<typename T >
T	CD2 (T *d0, T dx)
	2nd order central differencing. d0[1] is the origin.
template<typename T >
std::array< T, 2 >	ENO3 (T *d0, T dx)
	3rd order ENO. d0[3] is the origin.
template<typename T >
T	ENO3 (T *d0, T dx, bool isDirectionPositive)
	3rd order ENO. d0[3] is the origin.
template<typename T >
std::array< T, 2 >	WENO5 (T *v, T h, T eps=1.0e-8)
	5th order WENO. d0[3] is the origin.
template<typename T >
T	WENO5 (T *v, T h, bool is_velocity_positive, T eps=1.0e-8)
	5th order WENO. d0[3] is the origin.
template<typename T >
Quaternion< T >	Slerp (const Quaternion< T > &a, const Quaternion< T > &b, T t)
	Computes spherical linear interpolation.
template<typename T >
Vector< T, 3 >	operator* (const Quaternion< T > &q, const Vector< T, 3 > &v)
	Returns quaternion q * vector v.
template<typename T >
Quaternion< T >	operator* (const Quaternion< T > &a, const Quaternion< T > &b)
	Returns quaternion a times quaternion b.
template<typename T >
void	SVD (const MatrixMxN< T > &a, MatrixMxN< T > &u, VectorN< T > &w, MatrixMxN< T > &v)
	Singular value decomposition (SVD).
template<typename T , size_t M, size_t N>
void	SVD (const Matrix< T, M, N > &a, Matrix< T, M, N > &u, Vector< T, N > &w, Matrix< T, N, N > &v)
	Singular value decomposition (SVD).
template<typename T , size_t R1, size_t C1, size_t R2, size_t C2, typename M2 >
void	operator+= (Matrix< T, R1, C1 > &a, const MatrixExpression< T, R2, C2, M2 > &b)
template<typename T , size_t Rows, size_t Cols>
void	operator+= (Matrix< T, Rows, Cols > &a, const T &b)
template<typename T , size_t R1, size_t C1, size_t R2, size_t C2, typename M2 >
void	operator-= (Matrix< T, R1, C1 > &a, const MatrixExpression< T, R2, C2, M2 > &b)
template<typename T , size_t Rows, size_t Cols>
void	operator-= (Matrix< T, Rows, Cols > &a, const T &b)
template<typename T , size_t R1, size_t C1, size_t R2, size_t C2, typename M2 >
void	operator*= (Matrix< T, R1, C1 > &a, const MatrixExpression< T, R2, C2, M2 > &b)
template<typename T , size_t R1, size_t C1, size_t R2, size_t C2, typename M2 >
void	ElemIMul (Matrix< T, R1, C1 > &a, const MatrixExpression< T, R2, C2, M2 > &b)
template<typename T , size_t Rows, size_t Cols>
void	operator*= (Matrix< T, Rows, Cols > &a, const T &b)
template<typename T , size_t R1, size_t C1, size_t R2, size_t C2, typename M2 >
void	ElemIDiv (Matrix< T, R1, C1 > &a, const MatrixExpression< T, R2, C2, M2 > &b)
template<typename T , size_t Rows, size_t Cols>
void	operator/= (Matrix< T, Rows, Cols > &a, const T &b)
template<typename T , size_t Rows, size_t Cols, typename M1 , typename M2 >
constexpr std::enable_if_t< IsMatrixSizeStatic< Rows, Cols >(), bool >	operator== (const MatrixExpression< T, Rows, Cols, M1 > &a, const MatrixExpression< T, Rows, Cols, M2 > &b)
template<typename T , size_t R1, size_t C1, size_t R2, size_t C2, typename M1 , typename M2 >
bool	operator== (const MatrixExpression< T, R1, C1, M1 > &a, const MatrixExpression< T, R2, C2, M2 > &b)
template<typename T , size_t R1, size_t C1, size_t R2, size_t C2, typename M1 , typename M2 >
bool	operator!= (const MatrixExpression< T, R1, C1, M1 > &a, const MatrixExpression< T, R2, C2, M2 > &b)
template<typename T , size_t Rows, size_t Cols, typename M1 , typename BinaryOperation >
constexpr std::enable_if_t< TraitIsMatrixSizeStatic< Rows, Cols >::value, T >	Accumulate (const MatrixExpression< T, Rows, Cols, M1 > &a, const T &init, BinaryOperation op)
template<typename T , size_t Rows, size_t Cols, typename M1 >
constexpr std::enable_if_t< TraitIsMatrixSizeStatic< Rows, Cols >::value, T >	Accumulate (const MatrixExpression< T, Rows, Cols, M1 > &a, const T &init)
template<typename T , size_t Rows, size_t Cols, typename M1 >
constexpr std::enable_if_t< TraitIsMatrixSizeStatic< Rows, Cols >::value, T >	Accumulate (const MatrixExpression< T, Rows, Cols, M1 > &a)
template<typename T , size_t Rows, size_t Cols, typename M1 , typename BinaryOperation >
constexpr std::enable_if_t< TraitIsMatrixSizeDynamic< Rows, Cols >::value, T >	Accumulate (const MatrixExpression< T, Rows, Cols, M1 > &a, const T &init, BinaryOperation op)
template<typename T , size_t Rows, size_t Cols, typename M1 >
constexpr std::enable_if_t< TraitIsMatrixSizeDynamic< Rows, Cols >::value, T >	Accumulate (const MatrixExpression< T, Rows, Cols, M1 > &a, const T &init)
template<typename T , size_t Rows, size_t Cols, typename M1 >
constexpr std::enable_if_t< TraitIsMatrixSizeDynamic< Rows, Cols >::value, T >	Accumulate (const MatrixExpression< T, Rows, Cols, M1 > &a)
template<typename T , size_t Rows, size_t Cols, typename M1 >
constexpr T	Product (const MatrixExpression< T, Rows, Cols, M1 > &a, const T &init)
template<typename T , size_t Rows, size_t Cols, typename M1 , typename M2 , typename M3 , typename M4 >
std::enable_if_t< IsMatrixSizeStatic< Rows, Cols >(), Matrix< T, Rows, Cols > >	MonotonicCatmullRom (const MatrixExpression< T, Rows, Cols, M1 > &f0, const MatrixExpression< T, Rows, Cols, M2 > &f1, const MatrixExpression< T, Rows, Cols, M3 > &f2, const MatrixExpression< T, Rows, Cols, M4 > &f3, T f)
template<typename T >
MatrixCSR< T >	operator- (const MatrixCSR< T > &a)
template<typename T >
MatrixCSR< T >	operator+ (const MatrixCSR< T > &a, const MatrixCSR< T > &b)
template<typename T >
MatrixCSR< T >	operator+ (const MatrixCSR< T > &a, T b)
template<typename T >
MatrixCSR< T >	operator+ (T a, const MatrixCSR< T > &b)
template<typename T >
MatrixCSR< T >	operator- (const MatrixCSR< T > &a, const MatrixCSR< T > &b)
template<typename T >
MatrixCSR< T >	operator- (const MatrixCSR< T > &a, T b)
template<typename T >
MatrixCSR< T >	operator- (T a, const MatrixCSR< T > &b)
template<typename T >
MatrixCSR< T >	operator* (const MatrixCSR< T > &a, T b)
template<typename T >
MatrixCSR< T >	operator* (T a, const MatrixCSR< T > &b)
template<typename T , size_t R, size_t C, typename ME >
MatrixCSRMatrixMul< T, ME >	operator* (const MatrixCSR< T > &a, const MatrixExpression< T, R, C, ME > &b)
template<typename T >
MatrixCSR< T >	operator/ (const MatrixCSR< T > &a, T b)
template<typename T >
MatrixCSR< T >	operator/ (T a, const MatrixCSR< T > &b)
template<typename T , size_t Rows, size_t Cols, typename M1 >
constexpr auto	Ceil (const MatrixExpression< T, Rows, Cols, M1 > &a)
template<typename T , size_t Rows, size_t Cols, typename M1 >
constexpr auto	Floor (const MatrixExpression< T, Rows, Cols, M1 > &a)
template<typename T , size_t Rows, size_t Cols, typename M1 >
constexpr auto	operator- (const MatrixExpression< T, Rows, Cols, M1 > &m)
template<typename T , size_t Rows, size_t Cols, typename M1 , typename M2 >
constexpr auto	operator+ (const MatrixExpression< T, Rows, Cols, M1 > &a, const MatrixExpression< T, Rows, Cols, M2 > &b)
template<typename T , size_t Rows, size_t Cols, typename M1 , typename M2 >
constexpr auto	operator- (const MatrixExpression< T, Rows, Cols, M1 > &a, const MatrixExpression< T, Rows, Cols, M2 > &b)
template<typename T , size_t Rows, size_t Cols, typename M1 , typename M2 >
constexpr auto	ElemMul (const MatrixExpression< T, Rows, Cols, M1 > &a, const MatrixExpression< T, Rows, Cols, M2 > &b)
template<typename T , size_t Rows, size_t Cols, typename M1 , typename M2 >
constexpr auto	ElemDiv (const MatrixExpression< T, Rows, Cols, M1 > &a, const MatrixExpression< T, Rows, Cols, M2 > &b)
template<typename T , size_t Rows, size_t Cols, typename M1 , typename M2 >
constexpr auto	Min (const MatrixExpression< T, Rows, Cols, M1 > &a, const MatrixExpression< T, Rows, Cols, M2 > &b)
template<typename T , size_t Rows, size_t Cols, typename M1 , typename M2 >
constexpr auto	Max (const MatrixExpression< T, Rows, Cols, M1 > &a, const MatrixExpression< T, Rows, Cols, M2 > &b)
template<typename T , size_t Rows, size_t Cols, typename M1 >
constexpr auto	operator+ (const MatrixExpression< T, Rows, Cols, M1 > &a, const T &b)
template<typename T , size_t Rows, size_t Cols, typename M1 >
constexpr auto	operator- (const MatrixExpression< T, Rows, Cols, M1 > &a, const T &b)
template<typename T , size_t Rows, size_t Cols, typename M1 >
constexpr auto	operator* (const MatrixExpression< T, Rows, Cols, M1 > &a, const T &b)
template<typename T , size_t Rows, size_t Cols, typename M1 >
constexpr auto	operator/ (const MatrixExpression< T, Rows, Cols, M1 > &a, const T &b)
template<typename T , size_t Rows, size_t Cols, typename M2 >
constexpr auto	operator+ (const T &a, const MatrixExpression< T, Rows, Cols, M2 > &b)
template<typename T , size_t Rows, size_t Cols, typename M2 >
constexpr auto	operator- (const T &a, const MatrixExpression< T, Rows, Cols, M2 > &b)
template<typename T , size_t Rows, size_t Cols, typename M2 >
constexpr auto	operator* (const T &a, const MatrixExpression< T, Rows, Cols, M2 > &b)
template<typename T , size_t Rows, size_t Cols, typename M2 >
constexpr auto	operator/ (const T &a, const MatrixExpression< T, Rows, Cols, M2 > &b)
template<typename T , size_t Rows, size_t Cols, typename M1 , typename M2 , typename M3 >
auto	Clamp (const MatrixExpression< T, Rows, Cols, M1 > &a, const MatrixExpression< T, Rows, Cols, M2 > &low, const MatrixExpression< T, Rows, Cols, M3 > &high)
template<typename T , size_t R1, size_t C1, size_t R2, size_t C2, typename M1 , typename M2 >
auto	operator* (const MatrixExpression< T, R1, C1, M1 > &a, const MatrixExpression< T, R2, C2, M2 > &b)
template<size_t Rows, size_t Cols>
constexpr bool	IsMatrixSizeDynamic ()
template<size_t Rows, size_t Cols>
constexpr bool	IsMatrixSizeStatic ()
template<size_t Rows, size_t Cols>
constexpr bool	IsMatrixStaticSquare ()
template<typename T >
constexpr T	Zero ()
	Zero for type T.
template<>
constexpr float	Zero< float > ()
	Zero for float.
template<>
constexpr double	Zero< double > ()
	Zero for double.
template<typename T >
constexpr T	One ()
	One for type T.
template<>
constexpr float	One< float > ()
	One for float.
template<>
constexpr double	One< double > ()
	One for double.
template<typename T >
constexpr T	PI ()
	PI for type T.
template<>
constexpr float	PI< float > ()
	Pi for float.
template<>
constexpr double	PI< double > ()
	Pi for double.
template<typename T >
constexpr T	HalfPI ()
	PI/2 for type T.
template<>
constexpr float	HalfPI< float > ()
	PI/2 for float.
template<>
constexpr double	HalfPI< double > ()
	PI/2 for double.
template<typename T >
constexpr T	QuarterPI ()
	PI/4 for type T.
template<>
constexpr float	QuarterPI< float > ()
	PI/4 for float.
template<>
constexpr double	QuarterPI< double > ()
	PI/4 for double.
template<typename T >
constexpr T	TwoPI ()
	2*PI for type T.
template<>
constexpr float	TwoPI< float > ()
	2*PI for float.
template<>
constexpr double	TwoPI< double > ()
	2*PI for double.
template<typename T >
constexpr T	FourPI ()
	4*PI for type T.
template<>
constexpr float	FourPI< float > ()
	4*PI for float.
template<>
constexpr double	FourPI< double > ()
	4*PI for double.
template<typename T >
constexpr T	InvPI ()
	1/PI for type T.
template<>
constexpr float	InvPI< float > ()
	1/PI for float.
template<>
constexpr double	InvPI< double > ()
	1/PI for double.
template<typename T >
constexpr T	InvTwoPI ()
	1/2*PI for type T.
template<>
constexpr float	InvTwoPI< float > ()
	1/2*PI for float.
template<>
constexpr double	InvTwoPI< double > ()
	1/2*PI for double.
template<typename T >
constexpr T	InvFourPI ()
	1/4*PI for type T.
template<>
constexpr float	InvFourPI< float > ()
	1/4*PI for float.
template<>
constexpr double	InvFourPI< double > ()
	1/4*PI for double.
template<class ForwardIter , class T , class Compare >
ForwardIter	BinaryFind (ForwardIter first, ForwardIter last, const T &value, Compare comp)
fbs::Vector2UZ	CubbyFlowToFlatbuffers (const Vector2UZ &vec)
fbs::Vector2D	CubbyFlowToFlatbuffers (const Vector2D &vec)
Vector2UZ	FlatbuffersToCubbyFlow (const fbs::Vector2UZ &vec)
Vector3UZ	FlatbuffersToCubbyFlow (const fbs::Vector3UZ &vec)
Vector2D	FlatbuffersToCubbyFlow (const fbs::Vector2D &vec)
Vector3D	FlatbuffersToCubbyFlow (const fbs::Vector3D &vec)
template<typename GridType , typename FbsFactoryFunc , typename FbsGridType >
void	SerializeGrid (flatbuffers::FlatBufferBuilder *builder, const std::vector< GridType > &gridList, FbsFactoryFunc func, std::vector< flatbuffers::Offset< FbsGridType > > *fbsGridList)
template<typename FbsGridList , typename GridType , typename FactoryFunc >
void	DeserializeGrid (FbsGridList *fbsGridList, FactoryFunc factoryFunc, std::vector< GridType > *gridList)
template<typename IndexType , size_t N, typename Func >
void	ForEachIndex (const Vector< IndexType, N > &begin, const Vector< IndexType, N > &end, const Func &func)
template<typename IndexType , typename Func >
void	ForEachIndex (const Vector< IndexType, 1 > &begin, const Vector< IndexType, 1 > &end, const Func &func)
template<typename IndexType , typename Func >
void	ForEachIndex (IndexType begin, IndexType end, const Func &func)
template<typename IndexType , size_t N, typename Func >
void	ForEachIndex (const Vector< IndexType, N > &size, const Func &func)
template<typename IndexType , typename Func >
void	ForEachIndex (const Vector< IndexType, 1 > &size, const Func &func)
template<typename IndexType , typename Func >
void	ForEachIndex (IndexType size, const Func &func)
template<typename IndexType , size_t N, typename Func >
void	ParallelForEachIndex (const Vector< IndexType, N > &begin, const Vector< IndexType, N > &end, const Func &func, ExecutionPolicy policy)
template<typename IndexType , typename Func >
void	ParallelForEachIndex (const Vector< IndexType, 1 > &begin, const Vector< IndexType, 1 > &end, const Func &func, ExecutionPolicy policy)
template<typename IndexType , typename Func >
void	ParallelForEachIndex (IndexType begin, IndexType end, const Func &func, ExecutionPolicy policy)
template<typename IndexType , size_t N, typename Func >
void	ParallelForEachIndex (const Vector< IndexType, N > &size, const Func &func, ExecutionPolicy policy)
template<typename IndexType , typename Func >
void	ParallelForEachIndex (const Vector< IndexType, 1 > &size, const Func &func, ExecutionPolicy policy)
template<typename IndexType , typename Func >
void	ParallelForEachIndex (IndexType size, const Func &func, ExecutionPolicy policy)
template<typename ReturnType >
std::function< ReturnType(size_t)>	Unroll1 (const std::function< ReturnType(const Vector1UZ &)> &func)
	Unrolls vector-based indexing to size_t-based function.
template<typename ReturnType >
std::function< ReturnType(size_t, size_t)>	Unroll2 (const std::function< ReturnType(const Vector2UZ &)> &func)
	Unrolls vector-based indexing to size_t-based function.
template<typename ReturnType >
std::function< ReturnType(size_t, size_t, size_t)>	Unroll3 (const std::function< ReturnType(const Vector3UZ &)> &func)
	Unrolls vector-based DataPositionFunc indexing to size_t-based function.
template<typename T >
bool	IsInsideSDF (T phi)
	Returns true if phi is inside the implicit surface (< 0).
template<typename T >
T	SmearedHeavisideSDF (T phi)
	Returns smeared Heaviside function.
template<typename T >
T	SmearedDeltaSDF (T phi)
	Returns smeared delta function.
template<typename T >
T	FractionInsideSDF (T phi0, T phi1)
	Returns the fraction occupied by the implicit surface.
template<typename T >
void	CycleArray (T *arr, int size)
template<typename T >
T	FractionInside (T phiBottomLeft, T phiBottomRight, T phiTopLeft, T phiTopRight)
	Returns the fraction occupied by the implicit surface.
template<typename T >
T	DistanceToZeroLevelSet (T phi0, T phi1)
template<typename BlasType >
MGResult	MGVCycle (const MGMatrix< BlasType > &A, MGParameters< BlasType > params, MGVector< BlasType > *x, MGVector< BlasType > *b, MGVector< BlasType > *buffer)
	Performs Multi-grid with V-cycle.
template<typename RandomIterator , typename T >
void	ParallelFill (const RandomIterator &begin, const RandomIterator &end, const T &value, ExecutionPolicy policy=ExecutionPolicy::Parallel)
	Fills from begin to end with value in parallel.
template<typename IndexType , typename Function >
void	ParallelFor (IndexType beginIndex, IndexType endIndex, const Function &function, ExecutionPolicy policy=ExecutionPolicy::Parallel)
	Makes a for-loop from beginIndex to endIndex in parallel.
template<typename IndexType , typename Function >
void	ParallelRangeFor (IndexType beginIndex, IndexType endIndex, const Function &function, ExecutionPolicy policy=ExecutionPolicy::Parallel)
	Makes a range-loop from beginIndex to endIndex in parallel.
template<typename IndexType , typename Function >
void	ParallelFor (IndexType beginIndexX, IndexType endIndexX, IndexType beginIndexY, IndexType endIndexY, const Function &function, ExecutionPolicy policy=ExecutionPolicy::Parallel)
	Makes a 2D nested for-loop in parallel.
template<typename IndexType , typename Function >
void	ParallelRangeFor (IndexType beginIndexX, IndexType endIndexX, IndexType beginIndexY, IndexType endIndexY, const Function &function, ExecutionPolicy policy=ExecutionPolicy::Parallel)
	Makes a 2D nested range-loop in parallel.
template<typename IndexType , typename Function >
void	ParallelFor (IndexType beginIndexX, IndexType endIndexX, IndexType beginIndexY, IndexType endIndexY, IndexType beginIndexZ, IndexType endIndexZ, const Function &function, ExecutionPolicy policy=ExecutionPolicy::Parallel)
	Makes a 3D nested for-loop in parallel.
template<typename IndexType , typename Function >
void	ParallelRangeFor (IndexType beginIndexX, IndexType endIndexX, IndexType beginIndexY, IndexType endIndexY, IndexType beginIndexZ, IndexType endIndexZ, const Function &function, ExecutionPolicy policy=ExecutionPolicy::Parallel)
	Makes a 3D nested range-loop in parallel.
template<typename IndexType , typename Value , typename Function , typename Reduce >
Value	ParallelReduce (IndexType beginIndex, IndexType endIndex, const Value &identity, const Function &function, const Reduce &reduce, ExecutionPolicy policy=ExecutionPolicy::Parallel)
	Performs reduce operation in parallel.
template<typename RandomIterator >
void	ParallelSort (RandomIterator begin, RandomIterator end, ExecutionPolicy policy=ExecutionPolicy::Parallel)
	Sorts a container in parallel.
template<typename RandomIterator , typename CompareFunction >
void	ParallelSort (RandomIterator begin, RandomIterator end, CompareFunction compare, ExecutionPolicy policy=ExecutionPolicy::Parallel)
	Sorts a container in parallel with a custom compare function.
void	SetMaxNumberOfThreads (unsigned int numThreads)
	Sets maximum number of threads to use.
unsigned int	GetMaxNumberOfThreads ()
	Returns maximum number of threads to use.
Vector2D	ComputeDragForce (double dragCoefficient, double radius, const Vector2D &velocity)
template<size_t N>
Vector< double, N >	ProjectAndApplyFriction (const Vector< double, N > &vel, const Vector< double, N > &normal, double frictionCoefficient)
double	ComputePressureFromEos (double density, double targetDensity, double eosScale, double eosExponent, double negativePressureScale)
template<typename T >
Vector3< T >	UniformSampleCone (T u1, T u2, const Vector3< T > &axis, T angle)
	Returns randomly sampled direction within a cone.
template<typename T >
Vector3< T >	UniformSampleHemisphere (T u1, T u2, const Vector3< T > &normal)
	Returns randomly sampled point within a unit hemisphere.
template<typename T >
Vector3< T >	CosineWeightedSampleHemisphere (T u1, T u2, const Vector3< T > &normal)
	Returns weighted sampled point on a hemisphere.
template<typename T >
Vector3< T >	UniformSampleSphere (T u1, T u2)
	Returns randomly a point on a sphere.
template<typename T >
Vector2< T >	UniformSampleDisk (T u1, T u2)
	Returns randomly a point on a disk.
template<typename RandomIterator , typename T >
void	SerialFill (const RandomIterator &begin, const RandomIterator &end, const T &value)
	Fills from begin to end with value.
template<typename IndexType , typename Function >
void	SerialFor (IndexType beginIndex, IndexType endIndex, const Function &function)
	Makes a for-loop from beginIndex to endIndex.
template<typename IndexType , typename Function >
void	SerialFor (IndexType beginIndexX, IndexType endIndexX, IndexType beginIndexY, IndexType endIndexY, const Function &function)
	Makes a 2D nested for-loop.
template<typename IndexType , typename Function >
void	SerialFor (IndexType beginIndexX, IndexType endIndexX, IndexType beginIndexY, IndexType endIndexY, IndexType beginIndexZ, IndexType endIndexZ, const Function &function)
	Makes a 3D nested for-loop.
template<typename RandomIterator >
void	SerialSort (RandomIterator begin, RandomIterator end)
	Sorts a container.
template<typename RandomIterator , typename SortingFunction >
void	SerialSort (RandomIterator begin, RandomIterator end, const SortingFunction &sortingFunction)
	Sorts a container with a custom compare function.
template<typename T >
void	Serialize (const ConstArrayView1< T > &array, std::vector< uint8_t > *buffer)
	Serializes data chunk using common schema.
template<typename T >
void	Deserialize (const std::vector< uint8_t > &buffer, Array1< T > *array)
	Deserializes buffer to data chunk using common schema.
void	Serialize (const Serializable *serializable, std::vector< uint8_t > *buffer)
	Serializes serializable object.
void	Serialize (const uint8_t *data, size_t size, std::vector< uint8_t > *buffer)
	Serializes data chunk using common schema.
void	Deserialize (const std::vector< uint8_t > &buffer, Serializable *serializable)
	Deserializes buffer to serializable object.
void	Deserialize (const std::vector< uint8_t > &buffer, std::vector< uint8_t > *data)
	Deserializes buffer to data chunk using common schema.

Variables
constexpr size_t	ZERO_SIZE = 0
	Zero size_t.
constexpr ssize_t	ZERO_SSIZE = 0
	Zero ssize_t.
constexpr size_t	ONE_SIZE = 1
	One size_t.
constexpr ssize_t	ONE_SSIZE = 1
	One ssize_t.
constexpr float	PI_FLOAT = 3.14159265358979323846264338327950288f
	Float-type PI.
constexpr double	PI_DOUBLE = 3.14159265358979323846264338327950288
	Double-type PI.
constexpr float	HALF_PI_FLOAT = 1.57079632679489661923132169163975144f
	Float-type PI/2.
constexpr double	HALF_PI_DOUBLE = 1.57079632679489661923132169163975144
	Double-type PI/2.
constexpr float	QUARTER_PI_FLOAT = 0.785398163397448309615660845819875721f
	Float-type PI/4.
constexpr double	QUARTER_PI_DOUBLE = 0.785398163397448309615660845819875721
	Double-type PI/4.
constexpr float	TWO_PI_FLOAT = static_cast<float>(2.0 * PI_DOUBLE)
	Float-type 2*PI.
constexpr double	TWO_PI_DOUBLE = 2.0 * PI_DOUBLE
	Double-type 2*PI.
constexpr float	FOUR_PI_FLOAT = static_cast<float>(4.0 * PI_DOUBLE)
	Float-type 4*PI.
constexpr double	FOUR_PI_DOUBLE = 4.0 * PI_DOUBLE
	Double-type 4*pi.
constexpr float	INV_PI_FLOAT = static_cast<float>(1.0 / PI_DOUBLE)
	Float-type 1/PI.
constexpr double	INV_PI_DOUBLE = 1.0 / PI_DOUBLE
	Double-type 1/PI.
constexpr float	INV_TWO_PI_FLOAT = static_cast<float>(0.5 / PI_DOUBLE)
	Float-type 1/2*PI.
constexpr double	INV_TWO_PI_DOUBLE = 0.5 / PI_DOUBLE
	Double-type 1/2*PI.
constexpr float	INV_FOUR_PI_FLOAT = static_cast<float>(0.25 / PI_DOUBLE)
	Float-type 1/4*PI.
constexpr double	INV_FOUR_PI_DOUBLE = 0.25 / PI_DOUBLE
	Double-type 1/4*PI.
constexpr float	GRAVITY_FLOAT = -9.8f
	Gravity.
constexpr double	GRAVITY = -9.8
constexpr float	WATER_DENSITY_FLOAT = 1000.0f
	Water density.
constexpr double	WATER_DENSITY = 1000.0
constexpr float	SPEED_OF_SOUND_IN_WATER_FLOAT = 1482.0f
	Speed of sound in water at 20 degrees Celsius.
constexpr double	SPEED_OF_SOUND_IN_WATER = 1482.0
constexpr int	DIRECTION_NONE = 0
	No direction.
constexpr int	DIRECTION_LEFT = 1 << 0
	Left direction.
constexpr int	DIRECTION_RIGHT = 1 << 1
	Right direction.
constexpr int	DIRECTION_DOWN = 1 << 2
	Down direction.
constexpr int	DIRECTION_UP = 1 << 3
	Up direction.
constexpr int	DIRECTION_BACK = 1 << 4
	Back direction.
constexpr int	DIRECTION_FRONT = 1 << 5
	Front direction.
constexpr int	DIRECTION_ALL
	All direction.
Logger	infoLogger
	Info-level logger.
Logger	warnLogger
	Warn-level logger.
Logger	errorLogger
	Error-level logger.
Logger	debugLogger
	Debug-level logger.

Typedef Documentation

AdvectionSolver2Ptr

using CubbyFlow::AdvectionSolver2Ptr = typedef std::shared_ptr<AdvectionSolver2>

Shared pointer type for the 2-D advection solver.

AdvectionSolver3Ptr

using CubbyFlow::AdvectionSolver3Ptr = typedef std::shared_ptr<AdvectionSolver3>

Shared pointer type for the 3-D advection solver.

AngularVelocity2

using CubbyFlow::AngularVelocity2 = typedef AngularVelocity<2>

AngularVelocity3

using CubbyFlow::AngularVelocity3 = typedef AngularVelocity<3>

AnimationPtr

using CubbyFlow::AnimationPtr = typedef std::shared_ptr<Animation>

Shared pointer for the Animation type.

AnisotropicPointsToImplicit2Ptr

using CubbyFlow::AnisotropicPointsToImplicit2Ptr = typedef std::shared_ptr<AnisotropicPointsToImplicit2>

Shared pointer for the AnisotropicPointsToImplicit2 type.

AnisotropicPointsToImplicit3Ptr

using CubbyFlow::AnisotropicPointsToImplicit3Ptr = typedef std::shared_ptr<AnisotropicPointsToImplicit3>

Shared pointer for the AnisotropicPointsToImplicit3 type.

APICSolver2Ptr

using CubbyFlow::APICSolver2Ptr = typedef std::shared_ptr<APICSolver2>

Shared pointer type for the APICSolver2.

APICSolver3Ptr

using CubbyFlow::APICSolver3Ptr = typedef std::shared_ptr<APICSolver3>

Shared pointer type for the APICSolver3.

Array1

template<class T >

using CubbyFlow::Array1 = typedef Array<T, 1>

Array2

template<class T >

using CubbyFlow::Array2 = typedef Array<T, 2>

Array3

template<class T >

using CubbyFlow::Array3 = typedef Array<T, 3>

Array4

template<class T >

using CubbyFlow::Array4 = typedef Array<T, 4>

ArrayView1

template<class T >

using CubbyFlow::ArrayView1 = typedef ArrayView<T, 1>

ArrayView2

template<class T >

using CubbyFlow::ArrayView2 = typedef ArrayView<T, 2>

ArrayView3

template<class T >

using CubbyFlow::ArrayView3 = typedef ArrayView<T, 3>

ArrayView4

template<class T >

using CubbyFlow::ArrayView4 = typedef ArrayView<T, 4>

BccLatticePointGeneratorPtr

using CubbyFlow::BccLatticePointGeneratorPtr = typedef std::shared_ptr<BccLatticePointGenerator>

Shared pointer type for the BccLatticePointGenerator.

BoundingBox2

template<typename T >

using CubbyFlow::BoundingBox2 = typedef BoundingBox<T, 2>

BoundingBox2D

using CubbyFlow::BoundingBox2D = typedef BoundingBox2<double>

BoundingBox2F

using CubbyFlow::BoundingBox2F = typedef BoundingBox2<float>

BoundingBox3

template<typename T >

using CubbyFlow::BoundingBox3 = typedef BoundingBox<T, 3>

BoundingBox3D

using CubbyFlow::BoundingBox3D = typedef BoundingBox3<double>

BoundingBox3F

using CubbyFlow::BoundingBox3F = typedef BoundingBox3<float>

BoundingBoxRayIntersectionD

using CubbyFlow::BoundingBoxRayIntersectionD = typedef BoundingBoxRayIntersection<double>

BoundingBoxRayIntersectionF

using CubbyFlow::BoundingBoxRayIntersectionF = typedef BoundingBoxRayIntersection<float>

Box2

using CubbyFlow::Box2 = typedef Box<2>

2-D Box type.

Box2Ptr

using CubbyFlow::Box2Ptr = typedef std::shared_ptr<Box2>

Shared pointer type for the Box2.

Box3

using CubbyFlow::Box3 = typedef Box<3>

3-D Box type.

Box3Ptr

using CubbyFlow::Box3Ptr = typedef std::shared_ptr<Box3>

Shared pointer type for the Box3.

BoxIntersectionTestFunc

template<typename T , size_t N>

using CubbyFlow::BoxIntersectionTestFunc = typedef std::function<bool(const T&, const BoundingBox<double, N>&)>

N-D box-item intersection test function.

BoxIntersectionTestFunc2

template<typename T >

using CubbyFlow::BoxIntersectionTestFunc2 = typedef BoxIntersectionTestFunc<T, 2>

2-D box-item intersection test function.

BoxIntersectionTestFunc3

template<typename T >

using CubbyFlow::BoxIntersectionTestFunc3 = typedef BoxIntersectionTestFunc<T, 3>

3-D box-item intersection test function.

BVH2

template<typename T >

using CubbyFlow::BVH2 = typedef BVH<T, 2>

2-D BVH type.

BVH3

template<typename T >

using CubbyFlow::BVH3 = typedef BVH<T, 3>

3-D BVH type.

CatmullRomArraySampler1

template<typename T >

using CubbyFlow::CatmullRomArraySampler1 = typedef CubicArraySampler<T, 1, DoCatmullRom<T> >

CatmullRomArraySampler2

template<typename T >

using CubbyFlow::CatmullRomArraySampler2 = typedef CubicArraySampler<T, 2, DoCatmullRom<T> >

CatmullRomArraySampler3

template<typename T >

using CubbyFlow::CatmullRomArraySampler3 = typedef CubicArraySampler<T, 3, DoCatmullRom<T> >

CellCenteredScalarGrid2

using CubbyFlow::CellCenteredScalarGrid2 = typedef CellCenteredScalarGrid<2>

2-D CellCenteredScalarGrid type.

CellCenteredScalarGrid2Ptr

using CubbyFlow::CellCenteredScalarGrid2Ptr = typedef std::shared_ptr<CellCenteredScalarGrid2>

Shared pointer for the CellCenteredScalarGrid2 type.

CellCenteredScalarGrid3

using CubbyFlow::CellCenteredScalarGrid3 = typedef CellCenteredScalarGrid<3>

3-D CellCenteredScalarGrid type.

CellCenteredScalarGrid3Ptr

using CubbyFlow::CellCenteredScalarGrid3Ptr = typedef std::shared_ptr<CellCenteredScalarGrid3>

Shared pointer for the CellCenteredScalarGrid3 type.

CellCenteredVectorGrid2

using CubbyFlow::CellCenteredVectorGrid2 = typedef CellCenteredVectorGrid<2>

2-D CellCenteredVectorGrid type.

CellCenteredVectorGrid2Ptr

using CubbyFlow::CellCenteredVectorGrid2Ptr = typedef std::shared_ptr<CellCenteredVectorGrid2>

Shared pointer for the CellCenteredVectorGrid2 type.

CellCenteredVectorGrid3

using CubbyFlow::CellCenteredVectorGrid3 = typedef CellCenteredVectorGrid<3>

3-D CellCenteredVectorGrid type.

CellCenteredVectorGrid3Ptr

using CubbyFlow::CellCenteredVectorGrid3Ptr = typedef std::shared_ptr<CellCenteredVectorGrid3>

Shared pointer for the CellCenteredVectorGrid3 type.

ClosestIntersectionDistanceFunc

template<typename T , size_t N>

using CubbyFlow::ClosestIntersectionDistanceFunc = typedef std::function<double(const T&, const Vector<double, N>&)>

N-D closest intersection distance measure function.

ClosestIntersectionDistanceFunc2

template<typename T >

using CubbyFlow::ClosestIntersectionDistanceFunc2 = typedef ClosestIntersectionDistanceFunc<T, 2>

2-D closestIntersectionDistanceFunc.

ClosestIntersectionDistanceFunc3

template<typename T >

using CubbyFlow::ClosestIntersectionDistanceFunc3 = typedef ClosestIntersectionDistanceFunc<T, 3>

3-D closestIntersectionDistanceFunc.

ClosestIntersectionQueryResult2

template<typename T >

using CubbyFlow::ClosestIntersectionQueryResult2 = typedef ClosestIntersectionQueryResult<T, 2>

2-D closest intersection query result.

ClosestIntersectionQueryResult3

template<typename T >

using CubbyFlow::ClosestIntersectionQueryResult3 = typedef ClosestIntersectionQueryResult<T, 3>

3-D closest intersection query result.

Collider2

using CubbyFlow::Collider2 = typedef Collider<2>

2-D collider type.

Collider2Ptr

using CubbyFlow::Collider2Ptr = typedef std::shared_ptr<Collider2>

Shared pointer type for the Collider2.

Collider3

using CubbyFlow::Collider3 = typedef Collider<3>

3-D collider type.

Collider3Ptr

using CubbyFlow::Collider3Ptr = typedef std::shared_ptr<Collider3>

Shared pointer type for the Collider3.

ColliderSet2

using CubbyFlow::ColliderSet2 = typedef ColliderSet<2>

2-D ColliderSet type.

ColliderSet2Ptr

using CubbyFlow::ColliderSet2Ptr = typedef std::shared_ptr<ColliderSet2>

Shared pointer for the ColliderSet2 type.

ColliderSet3

using CubbyFlow::ColliderSet3 = typedef ColliderSet<3>

3-D ColliderSet type.

ColliderSet3Ptr

using CubbyFlow::ColliderSet3Ptr = typedef std::shared_ptr<ColliderSet3>

Shared pointer for the ColliderSet3 type.

CollocatedVectorGrid2

using CubbyFlow::CollocatedVectorGrid2 = typedef CollocatedVectorGrid<2>

2-D CollocatedVectorGrid type.

CollocatedVectorGrid2Ptr

using CubbyFlow::CollocatedVectorGrid2Ptr = typedef std::shared_ptr<CollocatedVectorGrid2>

Shared pointer for the CollocatedVectorGrid2 type.

CollocatedVectorGrid3

using CubbyFlow::CollocatedVectorGrid3 = typedef CollocatedVectorGrid<3>

3-D CollocatedVectorGrid type.

CollocatedVectorGrid3Ptr

using CubbyFlow::CollocatedVectorGrid3Ptr = typedef std::shared_ptr<CollocatedVectorGrid3>

Shared pointer for the CollocatedVectorGrid3 type.

ConstantScalarField2

using CubbyFlow::ConstantScalarField2 = typedef ConstantScalarField<2>

2-D ConstantScalarField type.

ConstantScalarField2Ptr

using CubbyFlow::ConstantScalarField2Ptr = typedef std::shared_ptr<ConstantScalarField2>

Shared pointer for the ConstantScalarField2 type.

ConstantScalarField3

using CubbyFlow::ConstantScalarField3 = typedef ConstantScalarField<3>

3-D ConstantScalarField type.

ConstantScalarField3Ptr

using CubbyFlow::ConstantScalarField3Ptr = typedef std::shared_ptr<ConstantScalarField3>

Shared pointer for the ConstantScalarField3 type.

ConstantVectorField2

using CubbyFlow::ConstantVectorField2 = typedef ConstantVectorField<2>

2-D ConstantVectorField type.

ConstantVectorField2Ptr

using CubbyFlow::ConstantVectorField2Ptr = typedef std::shared_ptr<ConstantVectorField2>

Shared pointer for the ConstantVectorField2 type.

ConstantVectorField3

using CubbyFlow::ConstantVectorField3 = typedef ConstantVectorField<3>

3-D ConstantVectorField type.

ConstantVectorField3Ptr

using CubbyFlow::ConstantVectorField3Ptr = typedef std::shared_ptr<ConstantVectorField3>

Shared pointer for the ConstantVectorField3 type.

ConstArrayView1

template<class T >

using CubbyFlow::ConstArrayView1 = typedef ArrayView<const T, 1>

ConstArrayView2

template<class T >

using CubbyFlow::ConstArrayView2 = typedef ArrayView<const T, 2>

ConstArrayView3

template<class T >

using CubbyFlow::ConstArrayView3 = typedef ArrayView<const T, 3>

ConstArrayView4

template<class T >

using CubbyFlow::ConstArrayView4 = typedef ArrayView<const T, 4>

CubicSemiLagrangian2Ptr

using CubbyFlow::CubicSemiLagrangian2Ptr = typedef std::shared_ptr<CubicSemiLagrangian2>

CubicSemiLagrangian3Ptr

using CubbyFlow::CubicSemiLagrangian3Ptr = typedef std::shared_ptr<CubicSemiLagrangian3>

CustomImplicitSurface2

using CubbyFlow::CustomImplicitSurface2 = typedef CustomImplicitSurface<2>

2-D CustomImplicitSurface type.

CustomImplicitSurface2Ptr

using CubbyFlow::CustomImplicitSurface2Ptr = typedef std::shared_ptr<CustomImplicitSurface2>

Shared pointer type for the CustomImplicitSurface2.

CustomImplicitSurface3

using CubbyFlow::CustomImplicitSurface3 = typedef CustomImplicitSurface<3>

3-D CustomImplicitSurface type.

CustomImplicitSurface3Ptr

using CubbyFlow::CustomImplicitSurface3Ptr = typedef std::shared_ptr<CustomImplicitSurface3>

Shared pointer type for the CustomImplicitSurface3.

CustomScalarField2

using CubbyFlow::CustomScalarField2 = typedef CustomScalarField<2>

2-D CustomScalarField type.

CustomScalarField2Ptr

using CubbyFlow::CustomScalarField2Ptr = typedef std::shared_ptr<CustomScalarField2>

Shared pointer type for the CustomScalarField2.

CustomScalarField3

using CubbyFlow::CustomScalarField3 = typedef CustomScalarField<3>

3-D CustomScalarField type.

CustomScalarField3Ptr

using CubbyFlow::CustomScalarField3Ptr = typedef std::shared_ptr<CustomScalarField3>

Shared pointer type for the CustomScalarField3.

CustomVectorField2

using CubbyFlow::CustomVectorField2 = typedef CustomVectorField<2>

2-D CustomVectorField type.

CustomVectorField2Ptr

using CubbyFlow::CustomVectorField2Ptr = typedef std::shared_ptr<CustomVectorField2>

Shared pointer type for the CustomVectorField2.

CustomVectorField3

using CubbyFlow::CustomVectorField3 = typedef CustomVectorField<3>

3-D CustomVectorField type.

CustomVectorField3Ptr

using CubbyFlow::CustomVectorField3Ptr = typedef std::shared_ptr<CustomVectorField3>

Shared pointer type for the CustomVectorField3.

Cylinder3Ptr

using CubbyFlow::Cylinder3Ptr = typedef std::shared_ptr<Cylinder3>

Shared pointer type for the Cylinder3.

ENOLevelSetSolver2Ptr

using CubbyFlow::ENOLevelSetSolver2Ptr = typedef std::shared_ptr<ENOLevelSetSolver2>

ENOLevelSetSolver3Ptr

using CubbyFlow::ENOLevelSetSolver3Ptr = typedef std::shared_ptr<ENOLevelSetSolver3>

FaceCenteredGrid2

using CubbyFlow::FaceCenteredGrid2 = typedef FaceCenteredGrid<2>

2-D FaceCenteredGrid type.

FaceCenteredGrid2Ptr

using CubbyFlow::FaceCenteredGrid2Ptr = typedef std::shared_ptr<FaceCenteredGrid2>

Shared pointer type for the FaceCenteredGrid2.

FaceCenteredGrid3

using CubbyFlow::FaceCenteredGrid3 = typedef FaceCenteredGrid<3>

3-D FaceCenteredGrid type.

FaceCenteredGrid3Ptr

using CubbyFlow::FaceCenteredGrid3Ptr = typedef std::shared_ptr<FaceCenteredGrid3>

Shared pointer type for the FaceCenteredGrid3.

FDMCGSolver2Ptr

using CubbyFlow::FDMCGSolver2Ptr = typedef std::shared_ptr<FDMCGSolver2>

Shared pointer type for the FDMCGSolver2.

FDMCGSolver3Ptr

using CubbyFlow::FDMCGSolver3Ptr = typedef std::shared_ptr<FDMCGSolver3>

Shared pointer type for the FDMCGSolver3.

FDMGaussSeidelSolver2Ptr

using CubbyFlow::FDMGaussSeidelSolver2Ptr = typedef std::shared_ptr<FDMGaussSeidelSolver2>

Shared pointer type for the FDMGaussSeidelSolver2.

FDMGaussSeidelSolver3Ptr

using CubbyFlow::FDMGaussSeidelSolver3Ptr = typedef std::shared_ptr<FDMGaussSeidelSolver3>

Shared pointer type for the FDMGaussSeidelSolver3.

FDMICCGSolver2Ptr

using CubbyFlow::FDMICCGSolver2Ptr = typedef std::shared_ptr<FDMICCGSolver2>

Shared pointer type for the FDMICCGSolver2.

FDMICCGSolver3Ptr

using CubbyFlow::FDMICCGSolver3Ptr = typedef std::shared_ptr<FDMICCGSolver3>

Shared pointer type for the FDMICCGSolver3.

FDMJacobiSolver2Ptr

using CubbyFlow::FDMJacobiSolver2Ptr = typedef std::shared_ptr<FDMJacobiSolver2>

Shared pointer type for the FDMJacobiSolver2.

FDMJacobiSolver3Ptr

using CubbyFlow::FDMJacobiSolver3Ptr = typedef std::shared_ptr<FDMJacobiSolver3>

Shared pointer type for the FDMJacobiSolver3.

FDMLinearSystemSolver2Ptr

using CubbyFlow::FDMLinearSystemSolver2Ptr = typedef std::shared_ptr<FDMLinearSystemSolver2>

Shared pointer type for the FDMLinearSystemSolver2.

FDMLinearSystemSolver3Ptr

using CubbyFlow::FDMLinearSystemSolver3Ptr = typedef std::shared_ptr<FDMLinearSystemSolver3>

Shared pointer type for the FDMLinearSystemSolver3.

FDMMatrix2

using CubbyFlow::FDMMatrix2 = typedef Array2<FDMMatrixRow2>

Matrix type for 2-D finite differencing.

FDMMatrix3

using CubbyFlow::FDMMatrix3 = typedef Array3<FDMMatrixRow3>

Matrix type for 3-D finite differencing.

FDMMGMatrix2

using CubbyFlow::FDMMGMatrix2 = typedef MGMatrix<FDMBLAS2>

Multigrid-style 2-D FDM matrix.

FDMMGMatrix3

using CubbyFlow::FDMMGMatrix3 = typedef MGMatrix<FDMBLAS3>

Multigrid-style 3-D FDM matrix.

FDMMGPCGSolver2Ptr

using CubbyFlow::FDMMGPCGSolver2Ptr = typedef std::shared_ptr<FDMMGPCGSolver2>

Shared pointer type for the FDMMGPCGSolver2.

FDMMGPCGSolver3Ptr

using CubbyFlow::FDMMGPCGSolver3Ptr = typedef std::shared_ptr<FDMMGPCGSolver3>

Shared pointer type for the FDMMGPCGSolver3.

FDMMGSolver2Ptr

using CubbyFlow::FDMMGSolver2Ptr = typedef std::shared_ptr<FDMMGSolver2>

Shared pointer type for the FDMMGSolver2.

FDMMGSolver3Ptr

using CubbyFlow::FDMMGSolver3Ptr = typedef std::shared_ptr<FDMMGSolver3>

Shared pointer type for the FDMMGSolver3.

FDMMGVector2

using CubbyFlow::FDMMGVector2 = typedef MGVector<FDMBLAS2>

Multigrid-style 2-D FDM vector.

FDMMGVector3

using CubbyFlow::FDMMGVector3 = typedef MGVector<FDMBLAS3>

Multigrid-style 3-D FDM vector.

FDMVector2

using CubbyFlow::FDMVector2 = typedef Array2<double>

Vector type for 2-D finite differencing.

FDMVector3

using CubbyFlow::FDMVector3 = typedef Array3<double>

Vector type for 3-D finite differencing.

Field2

using CubbyFlow::Field2 = typedef Field<2>

2-D Field type.

Field2Ptr

using CubbyFlow::Field2Ptr = typedef std::shared_ptr<Field2>

Shared pointer type for Field2.

Field3

using CubbyFlow::Field3 = typedef Field<3>

3-D Field type.

Field3Ptr

using CubbyFlow::Field3Ptr = typedef std::shared_ptr<Field3>

Shared pointer type for Field3.

FLIPSolver2Ptr

using CubbyFlow::FLIPSolver2Ptr = typedef std::shared_ptr<FLIPSolver2>

Shared pointer type for the FLIPSolver2.

FLIPSolver3Ptr

using CubbyFlow::FLIPSolver3Ptr = typedef std::shared_ptr<FLIPSolver3>

Shared pointer type for the FLIPSolver3.

FMMLevelSetSolver2Ptr

using CubbyFlow::FMMLevelSetSolver2Ptr = typedef std::shared_ptr<FMMLevelSetSolver2>

Shared pointer type for the FMMLevelSetSolver2.

FMMLevelSetSolver3Ptr

using CubbyFlow::FMMLevelSetSolver3Ptr = typedef std::shared_ptr<FMMLevelSetSolver3>

Shared pointer type for the FMMLevelSetSolver3.

GetRayIntersectionFunc

template<typename T , size_t N>

using CubbyFlow::GetRayIntersectionFunc = typedef std::function<double(const T&, const Ray<double, N>&)>

N-D ray-item closest intersection evaluation function.

GetRayIntersectionFunc2

template<typename T >

using CubbyFlow::GetRayIntersectionFunc2 = typedef GetRayIntersectionFunc<T, 2>

2-D ray-item closest intersection evaluation function.

GetRayIntersectionFunc3

template<typename T >

using CubbyFlow::GetRayIntersectionFunc3 = typedef GetRayIntersectionFunc<T, 3>

3-D ray-item closest intersection evaluation function.

Grid2

using CubbyFlow::Grid2 = typedef Grid<2>

2-D Grid type.

Grid2Ptr

using CubbyFlow::Grid2Ptr = typedef std::shared_ptr<Grid2>

Shared pointer type for Grid.

Grid3

using CubbyFlow::Grid3 = typedef Grid<3>

3-D Grid type.

Grid3Ptr

using CubbyFlow::Grid3Ptr = typedef std::shared_ptr<Grid3>

Shared pointer type for Grid3.

GridBackwardEulerDiffusionSolver2Ptr

using CubbyFlow::GridBackwardEulerDiffusionSolver2Ptr = typedef std::shared_ptr<GridBackwardEulerDiffusionSolver2>

Shared pointer type for the GridBackwardEulerDiffusionSolver2.

GridBackwardEulerDiffusionSolver3Ptr

using CubbyFlow::GridBackwardEulerDiffusionSolver3Ptr = typedef std::shared_ptr<GridBackwardEulerDiffusionSolver3>

Shared pointer type for the GridBackwardEulerDiffusionSolver3.

GridBlockedBoundaryConditionSolver2Ptr

using CubbyFlow::GridBlockedBoundaryConditionSolver2Ptr = typedef std::shared_ptr<GridBlockedBoundaryConditionSolver2>

Shared pointer type for the GridBlockedBoundaryConditionSolver2.

GridBlockedBoundaryConditionSolver3Ptr

using CubbyFlow::GridBlockedBoundaryConditionSolver3Ptr = typedef std::shared_ptr<GridBlockedBoundaryConditionSolver3>

Shared pointer type for the GridBlockedBoundaryConditionSolver3.

GridBoundaryConditionSolver2Ptr

using CubbyFlow::GridBoundaryConditionSolver2Ptr = typedef std::shared_ptr<GridBoundaryConditionSolver2>

Shared pointer type for the GridBoundaryConditionSolver2.

GridBoundaryConditionSolver3Ptr

using CubbyFlow::GridBoundaryConditionSolver3Ptr = typedef std::shared_ptr<GridBoundaryConditionSolver3>

Shared pointer type for the GridBoundaryConditionSolver3.

GridDiffusionSolver2Ptr

using CubbyFlow::GridDiffusionSolver2Ptr = typedef std::shared_ptr<GridDiffusionSolver2>

Shared pointer type for the GridDiffusionSolver2.

GridDiffusionSolver3Ptr

using CubbyFlow::GridDiffusionSolver3Ptr = typedef std::shared_ptr<GridDiffusionSolver3>

Shared pointer type for the GridDiffusionSolver3.

GridEmitter2Ptr

using CubbyFlow::GridEmitter2Ptr = typedef std::shared_ptr<GridEmitter2>

Shared pointer type for the GridEmitter2.

GridEmitter3Ptr

using CubbyFlow::GridEmitter3Ptr = typedef std::shared_ptr<GridEmitter3>

Shared pointer type for the GridEmitter3.

GridEmitterSet2Ptr

using CubbyFlow::GridEmitterSet2Ptr = typedef std::shared_ptr<GridEmitterSet2>

Shared pointer type for the GridEmitterSet2.

GridEmitterSet3Ptr

using CubbyFlow::GridEmitterSet3Ptr = typedef std::shared_ptr<GridEmitterSet3>

Shared pointer type for the GridEmitterSet3.

GridFluidSolver2Ptr

using CubbyFlow::GridFluidSolver2Ptr = typedef std::shared_ptr<GridFluidSolver2>

Shared pointer type for the GridFluidSolver2.

GridFluidSolver3Ptr

using CubbyFlow::GridFluidSolver3Ptr = typedef std::shared_ptr<GridFluidSolver3>

Shared pointer type for the GridFluidSolver3.

GridForwardEulerDiffusionSolver2Ptr

using CubbyFlow::GridForwardEulerDiffusionSolver2Ptr = typedef std::shared_ptr<GridForwardEulerDiffusionSolver2>

Shared pointer type for the GridForwardEulerDiffusionSolver2.

GridForwardEulerDiffusionSolver3Ptr

using CubbyFlow::GridForwardEulerDiffusionSolver3Ptr = typedef std::shared_ptr<GridForwardEulerDiffusionSolver3>

Shared pointer type for the GridForwardEulerDiffusionSolver3.

GridFractionalBoundaryConditionSolver2Ptr

using CubbyFlow::GridFractionalBoundaryConditionSolver2Ptr = typedef std::shared_ptr<GridFractionalBoundaryConditionSolver2>

Shared pointer type for the GridFractionalBoundaryConditionSolver2.

GridFractionalBoundaryConditionSolver3Ptr

using CubbyFlow::GridFractionalBoundaryConditionSolver3Ptr = typedef std::shared_ptr<GridFractionalBoundaryConditionSolver3>

Shared pointer type for the GridFractionalBoundaryConditionSolver3.

GridFractionalSinglePhasePressureSolver2Ptr

using CubbyFlow::GridFractionalSinglePhasePressureSolver2Ptr = typedef std::shared_ptr<GridFractionalSinglePhasePressureSolver2>

Shared pointer type for the GridFractionalSinglePhasePressureSolver2.

GridFractionalSinglePhasePressureSolver3Ptr

using CubbyFlow::GridFractionalSinglePhasePressureSolver3Ptr = typedef std::shared_ptr<GridFractionalSinglePhasePressureSolver3>

Shared pointer type for the GridFractionalSinglePhasePressureSolver3.

GridPointGenerator2Ptr

using CubbyFlow::GridPointGenerator2Ptr = typedef std::shared_ptr<GridPointGenerator2>

Shared pointer type for the GridPointGenerator2.

GridPointGenerator3Ptr

using CubbyFlow::GridPointGenerator3Ptr = typedef std::shared_ptr<GridPointGenerator3>

Shared pointer type for the GridPointGenerator3.

GridPressureSolver2Ptr

using CubbyFlow::GridPressureSolver2Ptr = typedef std::shared_ptr<GridPressureSolver2>

Shared pointer type for the GridPressureSolver2.

GridPressureSolver3Ptr

using CubbyFlow::GridPressureSolver3Ptr = typedef std::shared_ptr<GridPressureSolver3>

Shared pointer type for the GridPressureSolver3.

GridSinglePhasePressureSolver2Ptr

using CubbyFlow::GridSinglePhasePressureSolver2Ptr = typedef std::shared_ptr<GridSinglePhasePressureSolver2>

Shared pointer type for the GridSinglePhasePressureSolver2.

GridSinglePhasePressureSolver3Ptr

using CubbyFlow::GridSinglePhasePressureSolver3Ptr = typedef std::shared_ptr<GridSinglePhasePressureSolver3>

Shared pointer type for the GridSinglePhasePressureSolver3.

GridSmokeSolver2Ptr

using CubbyFlow::GridSmokeSolver2Ptr = typedef std::shared_ptr<GridSmokeSolver2>

Shared pointer type for the GridSmokeSolver2.

GridSmokeSolver3Ptr

using CubbyFlow::GridSmokeSolver3Ptr = typedef std::shared_ptr<GridSmokeSolver3>

Shared pointer type for the GridSmokeSolver3.

GridSystemData2

using CubbyFlow::GridSystemData2 = typedef GridSystemData<2>

2-D GridSystemData type.

GridSystemData2Ptr

using CubbyFlow::GridSystemData2Ptr = typedef std::shared_ptr<GridSystemData2>

Shared pointer type of GridSystemData2.

GridSystemData3

using CubbyFlow::GridSystemData3 = typedef GridSystemData<3>

3-D GridSystemData type.

GridSystemData3Ptr

using CubbyFlow::GridSystemData3Ptr = typedef std::shared_ptr<GridSystemData3>

Shared pointer type of GridSystemData3.

ImplicitSurface2

using CubbyFlow::ImplicitSurface2 = typedef ImplicitSurface<2>

2-D ImplicitSurface type.

ImplicitSurface2Ptr

using CubbyFlow::ImplicitSurface2Ptr = typedef std::shared_ptr<ImplicitSurface2>

Shared pointer type for the ImplicitSurface2.

ImplicitSurface3

using CubbyFlow::ImplicitSurface3 = typedef ImplicitSurface<3>

3-D ImplicitSurface type.

ImplicitSurface3Ptr

using CubbyFlow::ImplicitSurface3Ptr = typedef std::shared_ptr<ImplicitSurface3>

Shared pointer type for the ImplicitSurface3.

ImplicitSurfaceSet2

using CubbyFlow::ImplicitSurfaceSet2 = typedef ImplicitSurfaceSet<2>

2-D ImplicitSurfaceSet type.

ImplicitSurfaceSet2Ptr

using CubbyFlow::ImplicitSurfaceSet2Ptr = typedef std::shared_ptr<ImplicitSurfaceSet2>

Shared pointer type for the ImplicitSurfaceSet2.

ImplicitSurfaceSet3

using CubbyFlow::ImplicitSurfaceSet3 = typedef ImplicitSurfaceSet<3>

3-D ImplicitSurfaceSet type.

ImplicitSurfaceSet3Ptr

using CubbyFlow::ImplicitSurfaceSet3Ptr = typedef std::shared_ptr<ImplicitSurfaceSet3>

Shared pointer type for the ImplicitSurfaceSet3.

ImplicitTriangleMesh3Ptr

using CubbyFlow::ImplicitTriangleMesh3Ptr = typedef std::shared_ptr<ImplicitTriangleMesh3>

Shared pointer for the ImplicitTriangleMesh3 type.

IntersectionQueryEngine2

template<typename T >

using CubbyFlow::IntersectionQueryEngine2 = typedef IntersectionQueryEngine<T, 2>

Abstract base class for 2-D intersection test query engine.

IntersectionQueryEngine3

template<typename T >

using CubbyFlow::IntersectionQueryEngine3 = typedef IntersectionQueryEngine<T, 3>

Abstract base class for 3-D intersection test query engine.

IntersectionVisitorFunc

template<typename T >

using CubbyFlow::IntersectionVisitorFunc = typedef std::function<void(const T&)>

Visitor function which is invoked for each intersecting item.

IterativeLevelSetSolver2Ptr

using CubbyFlow::IterativeLevelSetSolver2Ptr = typedef std::shared_ptr<IterativeLevelSetSolver2>

IterativeLevelSetSolver3Ptr

using CubbyFlow::IterativeLevelSetSolver3Ptr = typedef std::shared_ptr<IterativeLevelSetSolver3>

LevelSetLiquidSolver2Ptr

using CubbyFlow::LevelSetLiquidSolver2Ptr = typedef std::shared_ptr<LevelSetLiquidSolver2>

Shared pointer type for the LevelSetLiquidSolver2.

LevelSetLiquidSolver3Ptr

using CubbyFlow::LevelSetLiquidSolver3Ptr = typedef std::shared_ptr<LevelSetLiquidSolver3>

Shared pointer type for the LevelSetLiquidSolver3.

LevelSetSolver2Ptr

using CubbyFlow::LevelSetSolver2Ptr = typedef std::shared_ptr<LevelSetSolver2>

Shared pointer type for the LevelSetSolver2.

LevelSetSolver3Ptr

using CubbyFlow::LevelSetSolver3Ptr = typedef std::shared_ptr<LevelSetSolver3>

Shared pointer type for the LevelSetSolver3.

LinearArraySampler1

template<typename T >

using CubbyFlow::LinearArraySampler1 = typedef LinearArraySampler<T, 1>

LinearArraySampler2

template<typename T >

using CubbyFlow::LinearArraySampler2 = typedef LinearArraySampler<T, 2>

LinearArraySampler3

template<typename T >

using CubbyFlow::LinearArraySampler3 = typedef LinearArraySampler<T, 3>

ListQueryEngine2

template<typename T >

using CubbyFlow::ListQueryEngine2 = typedef ListQueryEngine<T, 2>

2-D ListQueryEngine type.

ListQueryEngine3

template<typename T >

using CubbyFlow::ListQueryEngine3 = typedef ListQueryEngine<T, 3>

3-D ListQueryEngine type.

Matrix2x2

template<typename T >

using CubbyFlow::Matrix2x2 = typedef Matrix<T, 2, 2>

Matrix2x2B

using CubbyFlow::Matrix2x2B = typedef Matrix2x2<int8_t>

Matrix2x2D

using CubbyFlow::Matrix2x2D = typedef Matrix2x2<double>

Matrix2x2F

using CubbyFlow::Matrix2x2F = typedef Matrix2x2<float>

Matrix2x2I

using CubbyFlow::Matrix2x2I = typedef Matrix2x2<int32_t>

Matrix2x2L

using CubbyFlow::Matrix2x2L = typedef Matrix2x2<int64_t>

Matrix2x2S

using CubbyFlow::Matrix2x2S = typedef Matrix2x2<int16_t>

Matrix2x2UB

using CubbyFlow::Matrix2x2UB = typedef Matrix2x2<uint8_t>

Matrix2x2UI

using CubbyFlow::Matrix2x2UI = typedef Matrix2x2<uint32_t>

Matrix2x2UL

using CubbyFlow::Matrix2x2UL = typedef Matrix2x2<uint64_t>

Matrix2x2US

using CubbyFlow::Matrix2x2US = typedef Matrix2x2<uint16_t>

Matrix2x2UZ

using CubbyFlow::Matrix2x2UZ = typedef Matrix2x2<size_t>

Matrix2x2Z

using CubbyFlow::Matrix2x2Z = typedef Matrix2x2<ssize_t>

Matrix3x3

template<typename T >

using CubbyFlow::Matrix3x3 = typedef Matrix<T, 3, 3>

Matrix3x3B

using CubbyFlow::Matrix3x3B = typedef Matrix3x3<int8_t>

Matrix3x3D

using CubbyFlow::Matrix3x3D = typedef Matrix3x3<double>

Matrix3x3F

using CubbyFlow::Matrix3x3F = typedef Matrix3x3<float>

Matrix3x3I

using CubbyFlow::Matrix3x3I = typedef Matrix3x3<int32_t>

Matrix3x3L

using CubbyFlow::Matrix3x3L = typedef Matrix3x3<int64_t>

Matrix3x3S

using CubbyFlow::Matrix3x3S = typedef Matrix3x3<int16_t>

Matrix3x3UB

using CubbyFlow::Matrix3x3UB = typedef Matrix3x3<uint8_t>

Matrix3x3UI

using CubbyFlow::Matrix3x3UI = typedef Matrix3x3<uint32_t>

Matrix3x3UL

using CubbyFlow::Matrix3x3UL = typedef Matrix3x3<uint64_t>

Matrix3x3US

using CubbyFlow::Matrix3x3US = typedef Matrix3x3<uint16_t>

Matrix3x3UZ

using CubbyFlow::Matrix3x3UZ = typedef Matrix3x3<size_t>

Matrix3x3Z

using CubbyFlow::Matrix3x3Z = typedef Matrix3x3<ssize_t>

Matrix4x4

template<typename T >

using CubbyFlow::Matrix4x4 = typedef Matrix<T, 4, 4>

Matrix4x4B

using CubbyFlow::Matrix4x4B = typedef Matrix4x4<int8_t>

Matrix4x4D

using CubbyFlow::Matrix4x4D = typedef Matrix4x4<double>

Matrix4x4F

using CubbyFlow::Matrix4x4F = typedef Matrix4x4<float>

Matrix4x4I

using CubbyFlow::Matrix4x4I = typedef Matrix4x4<int32_t>

Matrix4x4L

using CubbyFlow::Matrix4x4L = typedef Matrix4x4<int64_t>

Matrix4x4S

using CubbyFlow::Matrix4x4S = typedef Matrix4x4<int16_t>

Matrix4x4UB

using CubbyFlow::Matrix4x4UB = typedef Matrix4x4<uint8_t>

Matrix4x4UI

using CubbyFlow::Matrix4x4UI = typedef Matrix4x4<uint32_t>

Matrix4x4UL

using CubbyFlow::Matrix4x4UL = typedef Matrix4x4<uint64_t>

Matrix4x4US

using CubbyFlow::Matrix4x4US = typedef Matrix4x4<uint16_t>

Matrix4x4UZ

using CubbyFlow::Matrix4x4UZ = typedef Matrix4x4<size_t>

Matrix4x4Z

using CubbyFlow::Matrix4x4Z = typedef Matrix4x4<ssize_t>

MatrixCeil

template<typename T , size_t Rows, size_t Cols, typename M1 >

using CubbyFlow::MatrixCeil = typedef MatrixUnaryOp<T, Rows, Cols, M1, DoCeil<T> >

MatrixClamp

template<typename T , size_t Rows, size_t Cols, typename M1 , typename M2 , typename M3 >

using CubbyFlow::MatrixClamp = typedef MatrixTernaryOp<T, Rows, Cols, M1, M2, M3, DoClamp<T> >

MatrixCSRD

typedef MatrixCSR<double> CubbyFlow::MatrixCSRD

Double-type CSR matrix.

MatrixCSRF

typedef MatrixCSR<float> CubbyFlow::MatrixCSRF

Float-type CSR matrix.

MatrixElemWiseAdd

template<typename T , size_t Rows, size_t Cols, typename E1 , typename E2 >

using CubbyFlow::MatrixElemWiseAdd = typedef MatrixElemWiseBinaryOp<T, Rows, Cols, E1, E2, std::plus<T> >

Matrix expression for element-wise matrix-matrix addition.

MatrixElemWiseDiv

template<typename T , size_t Rows, size_t Cols, typename E1 , typename E2 >

using CubbyFlow::MatrixElemWiseDiv = typedef MatrixElemWiseBinaryOp<T, Rows, Cols, E1, E2, std::divides<T> >

Matrix expression for element-wise matrix-matrix division.

MatrixElemWiseMax

template<typename T , size_t Rows, size_t Cols, typename E1 , typename E2 >

using CubbyFlow::MatrixElemWiseMax = typedef MatrixElemWiseBinaryOp<T, Rows, Cols, E1, E2, DoMax<T> >

Matrix expression for element-wise matrix-matrix max operation.

MatrixElemWiseMin

template<typename T , size_t Rows, size_t Cols, typename E1 , typename E2 >

using CubbyFlow::MatrixElemWiseMin = typedef MatrixElemWiseBinaryOp<T, Rows, Cols, E1, E2, DoMin<T> >

Matrix expression for element-wise matrix-matrix min operation.

MatrixElemWiseMul

template<typename T , size_t Rows, size_t Cols, typename E1 , typename E2 >

using CubbyFlow::MatrixElemWiseMul = typedef MatrixElemWiseBinaryOp<T, Rows, Cols, E1, E2, std::multiplies<T> >

Matrix expression for element-wise matrix-matrix multiplication.

MatrixElemWiseSub

template<typename T , size_t Rows, size_t Cols, typename E1 , typename E2 >

using CubbyFlow::MatrixElemWiseSub = typedef MatrixElemWiseBinaryOp<T, Rows, Cols, E1, E2, std::minus<T> >

Matrix expression for element-wise matrix-matrix subtraction.

MatrixFloor

template<typename T , size_t Rows, size_t Cols, typename M1 >

using CubbyFlow::MatrixFloor = typedef MatrixUnaryOp<T, Rows, Cols, M1, DoFloor<T> >

MatrixMxN

template<typename T >

using CubbyFlow::MatrixMxN = typedef Matrix<T, MATRIX_SIZE_DYNAMIC, MATRIX_SIZE_DYNAMIC>

MatrixMxNB

using CubbyFlow::MatrixMxNB = typedef MatrixMxN<int8_t>

MatrixMxND

using CubbyFlow::MatrixMxND = typedef MatrixMxN<double>

MatrixMxNF

using CubbyFlow::MatrixMxNF = typedef MatrixMxN<float>

MatrixMxNI

using CubbyFlow::MatrixMxNI = typedef MatrixMxN<int32_t>

MatrixMxNL

using CubbyFlow::MatrixMxNL = typedef MatrixMxN<int64_t>

MatrixMxNS

using CubbyFlow::MatrixMxNS = typedef MatrixMxN<int16_t>

MatrixMxNUB

using CubbyFlow::MatrixMxNUB = typedef MatrixMxN<uint8_t>

MatrixMxNUI

using CubbyFlow::MatrixMxNUI = typedef MatrixMxN<uint32_t>

MatrixMxNUL

using CubbyFlow::MatrixMxNUL = typedef MatrixMxN<uint64_t>

MatrixMxNUS

using CubbyFlow::MatrixMxNUS = typedef MatrixMxN<uint16_t>

MatrixMxNUZ

using CubbyFlow::MatrixMxNUZ = typedef MatrixMxN<size_t>

MatrixMxNZ

using CubbyFlow::MatrixMxNZ = typedef MatrixMxN<ssize_t>

MatrixNegate

template<typename T , size_t Rows, size_t Cols, typename M1 >

using CubbyFlow::MatrixNegate = typedef MatrixUnaryOp<T, Rows, Cols, M1, std::negate<T> >

MatrixScalarElemWiseAdd

template<typename T , size_t Rows, size_t Cols, typename M1 >

using CubbyFlow::MatrixScalarElemWiseAdd = typedef MatrixScalarElemWiseBinaryOp<T, Rows, Cols, M1, std::plus<T> >

MatrixScalarElemWiseDiv

template<typename T , size_t Rows, size_t Cols, typename M1 >

using CubbyFlow::MatrixScalarElemWiseDiv = typedef MatrixScalarElemWiseBinaryOp<T, Rows, Cols, M1, std::divides<T> >

MatrixScalarElemWiseMul

template<typename T , size_t Rows, size_t Cols, typename M1 >

using CubbyFlow::MatrixScalarElemWiseMul = typedef MatrixScalarElemWiseBinaryOp<T, Rows, Cols, M1, std::multiplies<T> >

MatrixScalarElemWiseSub

template<typename T , size_t Rows, size_t Cols, typename M1 >

using CubbyFlow::MatrixScalarElemWiseSub = typedef MatrixScalarElemWiseBinaryOp<T, Rows, Cols, M1, std::minus<T> >

MatrixTypeCast

template<typename T , size_t Rows, size_t Cols, typename U , typename M1 >

using CubbyFlow::MatrixTypeCast = typedef MatrixUnaryOp<U, Rows, Cols, M1, TypeCast<T, U> >

MGCorrectFunc

template<typename BlasType >

using CubbyFlow::MGCorrectFunc = typedef std::function<void(const typename BlasType::VectorType& coarser, typename BlasType::VectorType* finer)>

Multi-grid correction function type.

MGRelaxFunc

template<typename BlasType >

using CubbyFlow::MGRelaxFunc = typedef std::function<void( const typename BlasType::MatrixType& A, const typename BlasType::VectorType& b, unsigned int numberOfIterations, double maxTolerance, typename BlasType::VectorType* x, typename BlasType::VectorType* buffer)>

Multi-grid relax function type.

MGRestrictFunc

template<typename BlasType >

using CubbyFlow::MGRestrictFunc = typedef std::function<void(const typename BlasType::VectorType& finer, typename BlasType::VectorType* coarser)>

Multi-grid restriction function type.

MonotonicCatmullRomArraySampler1

template<typename T >

using CubbyFlow::MonotonicCatmullRomArraySampler1 = typedef CubicArraySampler<T, 1, DoMonotonicCatmullRom<T> >

MonotonicCatmullRomArraySampler2

template<typename T >

using CubbyFlow::MonotonicCatmullRomArraySampler2 = typedef CubicArraySampler<T, 2, DoMonotonicCatmullRom<T> >

MonotonicCatmullRomArraySampler3

template<typename T >

using CubbyFlow::MonotonicCatmullRomArraySampler3 = typedef CubicArraySampler<T, 3, DoMonotonicCatmullRom<T> >

NearestArraySampler1

template<typename T >

using CubbyFlow::NearestArraySampler1 = typedef NearestArraySampler<T, 1>

NearestArraySampler2

template<typename T >

using CubbyFlow::NearestArraySampler2 = typedef NearestArraySampler<T, 2>

NearestArraySampler3

template<typename T >

using CubbyFlow::NearestArraySampler3 = typedef NearestArraySampler<T, 3>

NearestNeighborDistanceFunc

template<typename T , size_t N>

using CubbyFlow::NearestNeighborDistanceFunc = typedef std::function<double(const T&, const Vector<double, N>&)>

N-D nearest neighbor distance measure function.

NearestNeighborDistanceFunc2

template<typename T >

using CubbyFlow::NearestNeighborDistanceFunc2 = typedef NearestNeighborDistanceFunc<T, 2>

2-D nearest neighbor distance measure function.

NearestNeighborDistanceFunc3

template<typename T >

using CubbyFlow::NearestNeighborDistanceFunc3 = typedef NearestNeighborDistanceFunc<T, 3>

3-D nearest neighbor distance measure function.

NearestNeighborQueryEngine2

template<typename T >

using CubbyFlow::NearestNeighborQueryEngine2 = typedef NearestNeighborQueryEngine<T, 2>

Abstract base class for 2-D nearest neighbor query engine.

NearestNeighborQueryEngine3

template<typename T >

using CubbyFlow::NearestNeighborQueryEngine3 = typedef NearestNeighborQueryEngine<T, 3>

Abstract base class for 3-D nearest neighbor query engine.

NearestNeighborQueryResult2

template<typename T >

using CubbyFlow::NearestNeighborQueryResult2 = typedef NearestNeighborQueryResult<T, 2>

2-D nearest neighbor query result.

NearestNeighborQueryResult3

template<typename T >

using CubbyFlow::NearestNeighborQueryResult3 = typedef NearestNeighborQueryResult<T, 3>

3-D nearest neighbor query result.

NestedInitializerListsT

template<typename T , size_t N>

using CubbyFlow::NestedInitializerListsT = typedef typename NestedInitializerLists<T, N>::Type

Orientation2

using CubbyFlow::Orientation2 = typedef Orientation<2>

Orientation3

using CubbyFlow::Orientation3 = typedef Orientation<3>

ParticleEmitter2Ptr

using CubbyFlow::ParticleEmitter2Ptr = typedef std::shared_ptr<ParticleEmitter2>

Shared pointer for the ParticleEmitter2 type.

ParticleEmitter3Ptr

using CubbyFlow::ParticleEmitter3Ptr = typedef std::shared_ptr<ParticleEmitter3>

Shared pointer for the ParticleEmitter3 type.

ParticleEmitterSet2Ptr

using CubbyFlow::ParticleEmitterSet2Ptr = typedef std::shared_ptr<ParticleEmitterSet2>

Shared pointer type for the ParticleEmitterSet2.

ParticleEmitterSet3Ptr

using CubbyFlow::ParticleEmitterSet3Ptr = typedef std::shared_ptr<ParticleEmitterSet3>

Shared pointer type for the ParticleEmitterSet3.

ParticleSystemData2

using CubbyFlow::ParticleSystemData2 = typedef ParticleSystemData<2>

2-D ParticleSystemData type.

ParticleSystemData2Ptr

using CubbyFlow::ParticleSystemData2Ptr = typedef std::shared_ptr<ParticleSystemData2>

Shared pointer type of ParticleSystemData2.

ParticleSystemData3

using CubbyFlow::ParticleSystemData3 = typedef ParticleSystemData<3>

3-D ParticleSystemData type.

ParticleSystemData3Ptr

using CubbyFlow::ParticleSystemData3Ptr = typedef std::shared_ptr<ParticleSystemData3>

Shared pointer type of ParticleSystemData3.

ParticleSystemSolver2Ptr

using CubbyFlow::ParticleSystemSolver2Ptr = typedef std::shared_ptr<ParticleSystemSolver2>

Shared pointer type for the ParticleSystemSolver2.

ParticleSystemSolver3Ptr

using CubbyFlow::ParticleSystemSolver3Ptr = typedef std::shared_ptr<ParticleSystemSolver3>

Shared pointer type for the ParticleSystemSolver3.

PCISPHSolver2Ptr

using CubbyFlow::PCISPHSolver2Ptr = typedef std::shared_ptr<PCISPHSolver2>

Shared pointer type for the PCISPHSolver2.

PCISPHSolver3Ptr

using CubbyFlow::PCISPHSolver3Ptr = typedef std::shared_ptr<PCISPHSolver3>

Shared pointer type for the PCISPHSolver3.

PhysicsAnimationPtr

using CubbyFlow::PhysicsAnimationPtr = typedef std::shared_ptr<PhysicsAnimation>

PICSolver2Ptr

using CubbyFlow::PICSolver2Ptr = typedef std::shared_ptr<PICSolver2>

Shared pointer type for the PICSolver2.

PICSolver3Ptr

using CubbyFlow::PICSolver3Ptr = typedef std::shared_ptr<PICSolver3>

Shared pointer type for the PICSolver3.

Plane2

using CubbyFlow::Plane2 = typedef Plane<2>

2-D plane type.

Plane2Ptr

using CubbyFlow::Plane2Ptr = typedef std::shared_ptr<Plane2>

Shared pointer for the Plane2 type.

Plane3

using CubbyFlow::Plane3 = typedef Plane<3>

3-D plane type.

Plane3Ptr

using CubbyFlow::Plane3Ptr = typedef std::shared_ptr<Plane3>

Shared pointer for the Plane3 type.

PointGenerator2Ptr

using CubbyFlow::PointGenerator2Ptr = typedef std::shared_ptr<PointGenerator2>

Shared pointer for the PointGenerator2 type.

PointGenerator3Ptr

using CubbyFlow::PointGenerator3Ptr = typedef std::shared_ptr<PointGenerator3>

Shared pointer for the PointGenerator3 type.

PointHashGridSearcher2

using CubbyFlow::PointHashGridSearcher2 = typedef PointHashGridSearcher<2>

2-D PointHashGridSearcher type.

PointHashGridSearcher2Ptr

using CubbyFlow::PointHashGridSearcher2Ptr = typedef std::shared_ptr<PointHashGridSearcher2>

Shared pointer for the PointHashGridSearcher2 type.

PointHashGridSearcher3

using CubbyFlow::PointHashGridSearcher3 = typedef PointHashGridSearcher<3>

3-D PointHashGridSearcher type.

PointHashGridSearcher3Ptr

using CubbyFlow::PointHashGridSearcher3Ptr = typedef std::shared_ptr<PointHashGridSearcher3>

Shared pointer for the PointHashGridSearcher3 type.

PointHashGridUtils2

using CubbyFlow::PointHashGridUtils2 = typedef PointHashGridUtils<2>

PointHashGridUtils3

using CubbyFlow::PointHashGridUtils3 = typedef PointHashGridUtils<3>

PointKdTreeSearcher2

using CubbyFlow::PointKdTreeSearcher2 = typedef PointKdTreeSearcher<2>

2-D PointKdTreeSearcher type.

PointKdTreeSearcher2Ptr

using CubbyFlow::PointKdTreeSearcher2Ptr = typedef std::shared_ptr<PointKdTreeSearcher2>

Shared pointer for the PointKdTreeSearcher2 type.

PointKdTreeSearcher3

using CubbyFlow::PointKdTreeSearcher3 = typedef PointKdTreeSearcher<3>

3-D PointKdTreeSearcher type.

PointKdTreeSearcher3Ptr

using CubbyFlow::PointKdTreeSearcher3Ptr = typedef std::shared_ptr<PointKdTreeSearcher3>

Shared pointer for the PointKdTreeSearcher3 type.

PointNeighborSearcher2

using CubbyFlow::PointNeighborSearcher2 = typedef PointNeighborSearcher<2>

2-D PointNeighborSearcher type.

PointNeighborSearcher2Ptr

using CubbyFlow::PointNeighborSearcher2Ptr = typedef std::shared_ptr<PointNeighborSearcher2>

Shared pointer for the PointNeighborSearcher2 type.

PointNeighborSearcher3

using CubbyFlow::PointNeighborSearcher3 = typedef PointNeighborSearcher<3>

3-D PointNeighborSearcher type.

PointNeighborSearcher3Ptr

using CubbyFlow::PointNeighborSearcher3Ptr = typedef std::shared_ptr<PointNeighborSearcher3>

Shared pointer for the PointNeighborSearcher3 type.

PointNeighborSearcherBuilder2

using CubbyFlow::PointNeighborSearcherBuilder2 = typedef PointNeighborSearcherBuilder<2>

2-D PointNeighborSearcherBuilder type.

PointNeighborSearcherBuilder2Ptr

using CubbyFlow::PointNeighborSearcherBuilder2Ptr = typedef std::shared_ptr<PointNeighborSearcherBuilder2>

Shared pointer for the PointNeighborSearcher2 type.

PointNeighborSearcherBuilder3

using CubbyFlow::PointNeighborSearcherBuilder3 = typedef PointNeighborSearcherBuilder<3>

3-D PointNeighborSearcherBuilder type.

PointNeighborSearcherBuilder3Ptr

using CubbyFlow::PointNeighborSearcherBuilder3Ptr = typedef std::shared_ptr<PointNeighborSearcherBuilder3>

Shared pointer for the PointNeighborSearcher3 type.

PointParallelHashGridSearcher2

using CubbyFlow::PointParallelHashGridSearcher2 = typedef PointParallelHashGridSearcher<2>

2-D PointParallelHashGridSearcher type.

PointParallelHashGridSearcher2Ptr

using CubbyFlow::PointParallelHashGridSearcher2Ptr = typedef std::shared_ptr<PointParallelHashGridSearcher2>

Shared pointer for the PointParallelHashGridSearcher2 type.

PointParallelHashGridSearcher3

using CubbyFlow::PointParallelHashGridSearcher3 = typedef PointParallelHashGridSearcher<3>

3-D PointParallelHashGridSearcher type.

PointParallelHashGridSearcher3Ptr

using CubbyFlow::PointParallelHashGridSearcher3Ptr = typedef std::shared_ptr<PointParallelHashGridSearcher3>

Shared pointer for the PointParallelHashGridSearcher3 type.

PointParticleEmitter2Ptr

using CubbyFlow::PointParticleEmitter2Ptr = typedef std::shared_ptr<PointParticleEmitter2>

Shared pointer for the PointParticleEmitter2 type.

PointParticleEmitter3Ptr

using CubbyFlow::PointParticleEmitter3Ptr = typedef std::shared_ptr<PointParticleEmitter3>

Shared pointer for the PointParticleEmitter3 type.

PointSimpleListSearcher2

using CubbyFlow::PointSimpleListSearcher2 = typedef PointSimpleListSearcher<2>

2-D PointSimpleListSearcher type.

PointSimpleListSearcher2Ptr

using CubbyFlow::PointSimpleListSearcher2Ptr = typedef std::shared_ptr<PointSimpleListSearcher<2> >

Shared pointer for the PointSimpleListSearcher2 type.

PointSimpleListSearcher3

using CubbyFlow::PointSimpleListSearcher3 = typedef PointSimpleListSearcher<3>

3-D PointSimpleListSearcher type.

PointSimpleListSearcher3Ptr

using CubbyFlow::PointSimpleListSearcher3Ptr = typedef std::shared_ptr<PointSimpleListSearcher<3> >

Shared pointer for the PointSimpleListSearcher3 type.

PointsToImplicit2Ptr

using CubbyFlow::PointsToImplicit2Ptr = typedef std::shared_ptr<PointsToImplicit2>

Shared pointer for the PointsToImplicit2 type.

PointsToImplicit3Ptr

using CubbyFlow::PointsToImplicit3Ptr = typedef std::shared_ptr<PointsToImplicit3>

Shared pointer for the PointsToImplicit3 type.

QuaternionD

using CubbyFlow::QuaternionD = typedef Quaternion<double>

Double-type quaternion.

QuaternionF

using CubbyFlow::QuaternionF = typedef Quaternion<float>

Float-type quaternion.

Ray2

template<typename T >

using CubbyFlow::Ray2 = typedef Ray<T, 2>

Ray2D

using CubbyFlow::Ray2D = typedef Ray2<double>

Ray2F

using CubbyFlow::Ray2F = typedef Ray2<float>

Ray3

template<typename T >

using CubbyFlow::Ray3 = typedef Ray<T, 3>

Ray3D

using CubbyFlow::Ray3D = typedef Ray3<double>

Ray3F

using CubbyFlow::Ray3F = typedef Ray3<float>

RayIntersectionTestFunc

template<typename T , size_t N>

using CubbyFlow::RayIntersectionTestFunc = typedef std::function<bool(const T&, const Ray<double, N>&)>

N-D ray-item intersection test function.

RayIntersectionTestFunc2

template<typename T >

using CubbyFlow::RayIntersectionTestFunc2 = typedef RayIntersectionTestFunc<T, 2>

2-D ray-item intersection test function.

RayIntersectionTestFunc3

template<typename T >

using CubbyFlow::RayIntersectionTestFunc3 = typedef RayIntersectionTestFunc<T, 3>

3-D ray-item intersection test function.

RigidBodyCollider2

using CubbyFlow::RigidBodyCollider2 = typedef RigidBodyCollider<2>

2-D RigidBodyCollider type.

RigidBodyCollider2Ptr

using CubbyFlow::RigidBodyCollider2Ptr = typedef std::shared_ptr<RigidBodyCollider2>

Shared pointer for the RigidBodyCollider2 type.

RigidBodyCollider3

using CubbyFlow::RigidBodyCollider3 = typedef RigidBodyCollider<3>

3-D RigidBodyCollider type.

RigidBodyCollider3Ptr

using CubbyFlow::RigidBodyCollider3Ptr = typedef std::shared_ptr<RigidBodyCollider3>

Shared pointer for the RigidBodyCollider3 type.

ScalarField2

using CubbyFlow::ScalarField2 = typedef ScalarField<2>

2-D ScalarField type.

ScalarField2Ptr

using CubbyFlow::ScalarField2Ptr = typedef std::shared_ptr<ScalarField2>

Shared pointer for the ScalarField2 type.

ScalarField3

using CubbyFlow::ScalarField3 = typedef ScalarField<3>

3-D ScalarField type.

ScalarField3Ptr

using CubbyFlow::ScalarField3Ptr = typedef std::shared_ptr<ScalarField3>

Shared pointer for the ScalarField3 type.

ScalarGrid2

using CubbyFlow::ScalarGrid2 = typedef ScalarGrid<2>

2-D ScalarGrid type.

ScalarGrid2Ptr

using CubbyFlow::ScalarGrid2Ptr = typedef std::shared_ptr<ScalarGrid2>

Shared pointer for the ScalarGrid2 type.

ScalarGrid3

using CubbyFlow::ScalarGrid3 = typedef ScalarGrid<3>

3-D ScalarGrid type.

ScalarGrid3Ptr

using CubbyFlow::ScalarGrid3Ptr = typedef std::shared_ptr<ScalarGrid3>

Shared pointer for the ScalarGrid3 type.

ScalarGridBuilder2

using CubbyFlow::ScalarGridBuilder2 = typedef ScalarGridBuilder<2>

2-D ScalarGridBuilder type.

ScalarGridBuilder2Ptr

using CubbyFlow::ScalarGridBuilder2Ptr = typedef std::shared_ptr<ScalarGridBuilder2>

Shared pointer for the ScalarGridBuilder2 type.

ScalarGridBuilder3

using CubbyFlow::ScalarGridBuilder3 = typedef ScalarGridBuilder<3>

3-D ScalarGridBuilder type.

ScalarGridBuilder3Ptr

using CubbyFlow::ScalarGridBuilder3Ptr = typedef std::shared_ptr<ScalarGridBuilder3>

Shared pointer for the ScalarGridBuilder3 type.

ScalarMatrixElemWiseAdd

template<typename T , size_t Rows, size_t Cols, typename M2 >

using CubbyFlow::ScalarMatrixElemWiseAdd = typedef ScalarMatrixElemWiseBinaryOp<T, Rows, Cols, M2, std::plus<T> >

ScalarMatrixElemWiseDiv

template<typename T , size_t Rows, size_t Cols, typename M2 >

using CubbyFlow::ScalarMatrixElemWiseDiv = typedef ScalarMatrixElemWiseBinaryOp<T, Rows, Cols, M2, std::divides<T> >

ScalarMatrixElemWiseMul

template<typename T , size_t Rows, size_t Cols, typename M2 >

using CubbyFlow::ScalarMatrixElemWiseMul = typedef ScalarMatrixElemWiseBinaryOp<T, Rows, Cols, M2, std::multiplies<T> >

ScalarMatrixElemWiseSub

template<typename T , size_t Rows, size_t Cols, typename M2 >

using CubbyFlow::ScalarMatrixElemWiseSub = typedef ScalarMatrixElemWiseBinaryOp<T, Rows, Cols, M2, std::minus<T> >

SemiLagrangian2Ptr

using CubbyFlow::SemiLagrangian2Ptr = typedef std::shared_ptr<SemiLagrangian2>

SemiLagrangian3Ptr

using CubbyFlow::SemiLagrangian3Ptr = typedef std::shared_ptr<SemiLagrangian3>

Sphere2

using CubbyFlow::Sphere2 = typedef Sphere<2>

2-D Sphere type.

Sphere2Ptr

using CubbyFlow::Sphere2Ptr = typedef std::shared_ptr<Sphere2>

Shared pointer for the Sphere2 type.

Sphere3

using CubbyFlow::Sphere3 = typedef Sphere<3>

3-D Sphere type.

Sphere3Ptr

using CubbyFlow::Sphere3Ptr = typedef std::shared_ptr<Sphere3>

Shared pointer for the Sphere3 type.

SphericalPointsToImplicit2Ptr

using CubbyFlow::SphericalPointsToImplicit2Ptr = typedef std::shared_ptr<SphericalPointsToImplicit2>

Shared pointer type for SphericalPointsToImplicit2.

SphericalPointsToImplicit3Ptr

using CubbyFlow::SphericalPointsToImplicit3Ptr = typedef std::shared_ptr<SphericalPointsToImplicit3>

Shared pointer type for SphericalPointsToImplicit3.

SPHPointsToImplicit2Ptr

using CubbyFlow::SPHPointsToImplicit2Ptr = typedef std::shared_ptr<SPHPointsToImplicit2>

Shared pointer type for SPHPointsToImplicit2 class.

SPHPointsToImplicit3Ptr

using CubbyFlow::SPHPointsToImplicit3Ptr = typedef std::shared_ptr<SPHPointsToImplicit3>

Shared pointer type for SPHPointsToImplicit3 class.

SPHSolver2Ptr

using CubbyFlow::SPHSolver2Ptr = typedef std::shared_ptr<SPHSolver2>

Shared pointer type for the SPHSolver2.

SPHSolver3Ptr

using CubbyFlow::SPHSolver3Ptr = typedef std::shared_ptr<SPHSolver3>

Shared pointer type for the SPHSolver3.

SPHSpikyKernel2

using CubbyFlow::SPHSpikyKernel2 = typedef SPHSpikyKernel<2>

SPHSpikyKernel3

using CubbyFlow::SPHSpikyKernel3 = typedef SPHSpikyKernel<3>

SPHStdKernel2

using CubbyFlow::SPHStdKernel2 = typedef SPHStdKernel<2>

SPHStdKernel3

using CubbyFlow::SPHStdKernel3 = typedef SPHStdKernel<3>

SPHSystemData2

using CubbyFlow::SPHSystemData2 = typedef SPHSystemData<2>

2-D SPHSystemData type.

SPHSystemData2Ptr

using CubbyFlow::SPHSystemData2Ptr = typedef std::shared_ptr<SPHSystemData2>

Shared pointer for the SPHSystemData2 type.

SPHSystemData3

using CubbyFlow::SPHSystemData3 = typedef SPHSystemData<3>

3-D SPHSystemData type.

SPHSystemData3Ptr

using CubbyFlow::SPHSystemData3Ptr = typedef std::shared_ptr<SPHSystemData3>

Shared pointer for the SPHSystemData3 type.

Surface2

using CubbyFlow::Surface2 = typedef Surface<2>

2-D Surface type.

Surface2Ptr

using CubbyFlow::Surface2Ptr = typedef std::shared_ptr<Surface2>

Shared pointer for the Surface2 type.

Surface3

using CubbyFlow::Surface3 = typedef Surface<3>

3-D Surface type.

Surface3Ptr

using CubbyFlow::Surface3Ptr = typedef std::shared_ptr<Surface3>

Shared pointer for the Surface3 type.

SurfaceBuilderBase2

template<typename T >

using CubbyFlow::SurfaceBuilderBase2 = typedef SurfaceBuilderBase<2, T>

SurfaceBuilderBase3

template<typename T >

using CubbyFlow::SurfaceBuilderBase3 = typedef SurfaceBuilderBase<3, T>

SurfaceRayIntersection2

using CubbyFlow::SurfaceRayIntersection2 = typedef SurfaceRayIntersection<2>

SurfaceRayIntersection3

using CubbyFlow::SurfaceRayIntersection3 = typedef SurfaceRayIntersection<3>

SurfaceSet2

using CubbyFlow::SurfaceSet2 = typedef SurfaceSet<2>

2-D SurfaceSet type.

SurfaceSet2Ptr

using CubbyFlow::SurfaceSet2Ptr = typedef std::shared_ptr<SurfaceSet2>

Shared pointer for the SurfaceSet2 type.

SurfaceSet3

using CubbyFlow::SurfaceSet3 = typedef SurfaceSet<3>

3-D SurfaceSet type.

SurfaceSet3Ptr

using CubbyFlow::SurfaceSet3Ptr = typedef std::shared_ptr<SurfaceSet3>

Shared pointer for the SurfaceSet3 type.

SurfaceToImplicit2

using CubbyFlow::SurfaceToImplicit2 = typedef SurfaceToImplicit<2>

2-D SurfaceToImplicit type.

SurfaceToImplicit2Ptr

using CubbyFlow::SurfaceToImplicit2Ptr = typedef std::shared_ptr<SurfaceToImplicit2>

Shared pointer for the SurfaceToImplicit2 type.

SurfaceToImplicit3

using CubbyFlow::SurfaceToImplicit3 = typedef SurfaceToImplicit<3>

3-D SurfaceToImplicit type.

SurfaceToImplicit3Ptr

using CubbyFlow::SurfaceToImplicit3Ptr = typedef std::shared_ptr<SurfaceToImplicit3>

Shared pointer for the SurfaceToImplicit3 type.

Transform2

using CubbyFlow::Transform2 = typedef Transform<2>

Transform3

using CubbyFlow::Transform3 = typedef Transform<3>

Triangle3Ptr

using CubbyFlow::Triangle3Ptr = typedef std::shared_ptr<Triangle3>

Shared pointer for the Triangle3 type.

TriangleMesh3Ptr

using CubbyFlow::TriangleMesh3Ptr = typedef std::shared_ptr<TriangleMesh3>

Shared pointer for the TriangleMesh3 type.

TrianglePointGeneratorPtr

using CubbyFlow::TrianglePointGeneratorPtr = typedef std::shared_ptr<TrianglePointGenerator>

UpwindLevelSetSolver2Ptr

using CubbyFlow::UpwindLevelSetSolver2Ptr = typedef std::shared_ptr<UpwindLevelSetSolver2>

UpwindLevelSetSolver3Ptr

using CubbyFlow::UpwindLevelSetSolver3Ptr = typedef std::shared_ptr<UpwindLevelSetSolver3>

Vector

template<typename T , size_t Rows>

using CubbyFlow::Vector = typedef Matrix<T, Rows, 1>

Vector1

template<typename T >

using CubbyFlow::Vector1 = typedef Vector<T, 1>

Vector1B

using CubbyFlow::Vector1B = typedef Vector1<int8_t>

Vector1D

using CubbyFlow::Vector1D = typedef Vector1<double>

Vector1F

using CubbyFlow::Vector1F = typedef Vector1<float>

Vector1I

using CubbyFlow::Vector1I = typedef Vector1<int32_t>

Vector1L

using CubbyFlow::Vector1L = typedef Vector1<int64_t>

Vector1S

using CubbyFlow::Vector1S = typedef Vector1<int16_t>

Vector1UB

using CubbyFlow::Vector1UB = typedef Vector1<uint8_t>

Vector1UI

using CubbyFlow::Vector1UI = typedef Vector1<uint32_t>

Vector1UL

using CubbyFlow::Vector1UL = typedef Vector1<uint64_t>

Vector1US

using CubbyFlow::Vector1US = typedef Vector1<uint16_t>

Vector1UZ

using CubbyFlow::Vector1UZ = typedef Vector1<size_t>

Vector1Z

using CubbyFlow::Vector1Z = typedef Vector1<ssize_t>

Vector2

template<typename T >

using CubbyFlow::Vector2 = typedef Vector<T, 2>

Vector2B

using CubbyFlow::Vector2B = typedef Vector2<int8_t>

Vector2D

using CubbyFlow::Vector2D = typedef Vector2<double>

Vector2F

using CubbyFlow::Vector2F = typedef Vector2<float>

Vector2I

using CubbyFlow::Vector2I = typedef Vector2<int32_t>

Vector2L

using CubbyFlow::Vector2L = typedef Vector2<int64_t>

Vector2S

using CubbyFlow::Vector2S = typedef Vector2<int16_t>

Vector2UB

using CubbyFlow::Vector2UB = typedef Vector2<uint8_t>

Vector2UI

using CubbyFlow::Vector2UI = typedef Vector2<uint32_t>

Vector2UL

using CubbyFlow::Vector2UL = typedef Vector2<uint64_t>

Vector2US

using CubbyFlow::Vector2US = typedef Vector2<uint16_t>

Vector2UZ

using CubbyFlow::Vector2UZ = typedef Vector2<size_t>

Vector2Z

using CubbyFlow::Vector2Z = typedef Vector2<ssize_t>

Vector3

template<typename T >

using CubbyFlow::Vector3 = typedef Vector<T, 3>

Vector3B

using CubbyFlow::Vector3B = typedef Vector3<int8_t>

Vector3D

using CubbyFlow::Vector3D = typedef Vector3<double>

Vector3F

using CubbyFlow::Vector3F = typedef Vector3<float>

Vector3I

using CubbyFlow::Vector3I = typedef Vector3<int32_t>

Vector3L

using CubbyFlow::Vector3L = typedef Vector3<int64_t>

Vector3S

using CubbyFlow::Vector3S = typedef Vector3<int16_t>

Vector3UB

using CubbyFlow::Vector3UB = typedef Vector3<uint8_t>

Vector3UI

using CubbyFlow::Vector3UI = typedef Vector3<uint32_t>

Vector3UL

using CubbyFlow::Vector3UL = typedef Vector3<uint64_t>

Vector3US

using CubbyFlow::Vector3US = typedef Vector3<uint16_t>

Vector3UZ

using CubbyFlow::Vector3UZ = typedef Vector3<size_t>

Vector3Z

using CubbyFlow::Vector3Z = typedef Vector3<ssize_t>

Vector4

template<typename T >

using CubbyFlow::Vector4 = typedef Vector<T, 4>

Vector4B

using CubbyFlow::Vector4B = typedef Vector4<int8_t>

Vector4D

using CubbyFlow::Vector4D = typedef Vector4<double>

Vector4F

using CubbyFlow::Vector4F = typedef Vector4<float>

Vector4I

using CubbyFlow::Vector4I = typedef Vector4<int32_t>

Vector4L

using CubbyFlow::Vector4L = typedef Vector4<int64_t>

Vector4S

using CubbyFlow::Vector4S = typedef Vector4<int16_t>

Vector4UB

using CubbyFlow::Vector4UB = typedef Vector4<uint8_t>

Vector4UI

using CubbyFlow::Vector4UI = typedef Vector4<uint32_t>

Vector4UL

using CubbyFlow::Vector4UL = typedef Vector4<uint64_t>

Vector4US

using CubbyFlow::Vector4US = typedef Vector4<uint16_t>

Vector4UZ

using CubbyFlow::Vector4UZ = typedef Vector4<size_t>

Vector4Z

using CubbyFlow::Vector4Z = typedef Vector4<ssize_t>

VectorField2

using CubbyFlow::VectorField2 = typedef VectorField<2>

2-D VectorField type.

VectorField2Ptr

using CubbyFlow::VectorField2Ptr = typedef std::shared_ptr<VectorField2>

Shared pointer for the VectorField2 type.

VectorField3

using CubbyFlow::VectorField3 = typedef VectorField<3>

3-D VectorField type.

VectorField3Ptr

using CubbyFlow::VectorField3Ptr = typedef std::shared_ptr<VectorField3>

Shared pointer for the VectorField3 type.

VectorGrid2

using CubbyFlow::VectorGrid2 = typedef VectorGrid<2>

2-D VectorGrid type.

VectorGrid2Ptr

using CubbyFlow::VectorGrid2Ptr = typedef std::shared_ptr<VectorGrid2>

Shared pointer for the VectorGrid2 type.

VectorGrid3

using CubbyFlow::VectorGrid3 = typedef VectorGrid<3>

3-D VectorGrid type.

VectorGrid3Ptr

using CubbyFlow::VectorGrid3Ptr = typedef std::shared_ptr<VectorGrid3>

Shared pointer for the VectorGrid3 type.

VectorGridBuilder2

using CubbyFlow::VectorGridBuilder2 = typedef VectorGridBuilder<2>

2-D VectorGridBuilder type.

VectorGridBuilder2Ptr

using CubbyFlow::VectorGridBuilder2Ptr = typedef std::shared_ptr<VectorGridBuilder2>

Shared pointer for the VectorGridBuilder2 type.

VectorGridBuilder3

using CubbyFlow::VectorGridBuilder3 = typedef VectorGridBuilder<3>

3-D VectorGridBuilder type.

VectorGridBuilder3Ptr

using CubbyFlow::VectorGridBuilder3Ptr = typedef std::shared_ptr<VectorGridBuilder3>

Shared pointer for the VectorGridBuilder3 type.

VectorN

template<typename T >

using CubbyFlow::VectorN = typedef Matrix<T, MATRIX_SIZE_DYNAMIC, 1>

VectorNB

using CubbyFlow::VectorNB = typedef VectorN<int8_t>

VectorND

using CubbyFlow::VectorND = typedef VectorN<double>

VectorNF

using CubbyFlow::VectorNF = typedef VectorN<float>

VectorNI

using CubbyFlow::VectorNI = typedef VectorN<int32_t>

VectorNL

using CubbyFlow::VectorNL = typedef VectorN<int64_t>

VectorNS

using CubbyFlow::VectorNS = typedef VectorN<int16_t>

VectorNUB

using CubbyFlow::VectorNUB = typedef VectorN<uint8_t>

VectorNUI

using CubbyFlow::VectorNUI = typedef VectorN<uint32_t>

VectorNUL

using CubbyFlow::VectorNUL = typedef VectorN<uint64_t>

VectorNUS

using CubbyFlow::VectorNUS = typedef VectorN<uint16_t>

VectorNUZ

using CubbyFlow::VectorNUZ = typedef VectorN<size_t>

VectorNZ

using CubbyFlow::VectorNZ = typedef VectorN<ssize_t>

VertexCenteredScalarGrid2

using CubbyFlow::VertexCenteredScalarGrid2 = typedef VertexCenteredScalarGrid<2>

2-D VertexCenteredScalarGrid type.

VertexCenteredScalarGrid2Ptr

using CubbyFlow::VertexCenteredScalarGrid2Ptr = typedef std::shared_ptr<VertexCenteredScalarGrid2>

Shared pointer for the VertexCenteredScalarGrid2 type.

VertexCenteredScalarGrid3

using CubbyFlow::VertexCenteredScalarGrid3 = typedef VertexCenteredScalarGrid<3>

3-D VertexCenteredScalarGrid type.

VertexCenteredScalarGrid3Ptr

using CubbyFlow::VertexCenteredScalarGrid3Ptr = typedef std::shared_ptr<VertexCenteredScalarGrid3>

Shared pointer for the VertexCenteredScalarGrid3 type.

VertexCenteredVectorGrid2

using CubbyFlow::VertexCenteredVectorGrid2 = typedef VertexCenteredVectorGrid<2>

2-D VertexCenteredVectorGrid type.

VertexCenteredVectorGrid2Ptr

using CubbyFlow::VertexCenteredVectorGrid2Ptr = typedef std::shared_ptr<VertexCenteredVectorGrid2>

Shared pointer for the VertexCenteredVectorGrid2 type.

VertexCenteredVectorGrid3

using CubbyFlow::VertexCenteredVectorGrid3 = typedef VertexCenteredVectorGrid<3>

3-D VertexCenteredVectorGrid type.

VertexCenteredVectorGrid3Ptr

using CubbyFlow::VertexCenteredVectorGrid3Ptr = typedef std::shared_ptr<VertexCenteredVectorGrid3>

Shared pointer for the VertexCenteredVectorGrid3 type.

VolumeGridEmitter2Ptr

using CubbyFlow::VolumeGridEmitter2Ptr = typedef std::shared_ptr<VolumeGridEmitter2>

Shared pointer type for the VolumeGridEmitter2.

VolumeGridEmitter3Ptr

using CubbyFlow::VolumeGridEmitter3Ptr = typedef std::shared_ptr<VolumeGridEmitter3>

Shared pointer type for the VolumeGridEmitter3.

VolumeParticleEmitter2Ptr

using CubbyFlow::VolumeParticleEmitter2Ptr = typedef std::shared_ptr<VolumeParticleEmitter2>

Shared pointer for the VolumeParticleEmitter2 type.

VolumeParticleEmitter3Ptr

using CubbyFlow::VolumeParticleEmitter3Ptr = typedef std::shared_ptr<VolumeParticleEmitter3>

Shared pointer for the VolumeParticleEmitter3 type.

ZhuBridsonPointsToImplicit2Ptr

using CubbyFlow::ZhuBridsonPointsToImplicit2Ptr = typedef std::shared_ptr<ZhuBridsonPointsToImplicit2>

Shared pointer type for ZhuBridsonPointsToImplicit2 class.

ZhuBridsonPointsToImplicit3Ptr

using CubbyFlow::ZhuBridsonPointsToImplicit3Ptr = typedef std::shared_ptr<ZhuBridsonPointsToImplicit3>

Shared pointer type for ZhuBridsonPointsToImplicit3 class.

Enumeration Type Documentation

ExecutionPolicy

enum class CubbyFlow::ExecutionPolicy

strong

Execution policy tag.

Enumerator
Serial
Parallel

LogLevel

enum class CubbyFlow::LogLevel : uint8_t

strong

Level of the log. All < Debug < Info < Warn < Error < Off.

Enumerator
All
Debug
Info
Warn
Error
Off

Function Documentation

AbsMax()

template<typename T >

std::enable_if_t< std::is_arithmetic< T >::value, T > CubbyFlow::AbsMax	(	T	x,
		T	y
	)

Returns the absolute maximum value among the two inputs.

Parameters

[in]	x	The first value.
[in]	y	The second value.

Template Parameters

T	Value type.

Returns

The absolute maximum.

AbsMaxN()

template<typename T >

std::enable_if_t< std::is_arithmetic< T >::value, T > CubbyFlow::AbsMaxN	(	const T *	x,
		size_t	n
	)

Returns absolute maximum among n-elements.

AbsMin()

template<typename T >

std::enable_if_t< std::is_arithmetic< T >::value, T > CubbyFlow::AbsMin	(	T	x,
		T	y
	)

Returns the absolute minimum value among the two inputs.

Parameters

[in]	x	The first value.
[in]	y	The second value.

Template Parameters

T	Value type.

Returns

The absolute minimum.

AbsMinN()

template<typename T >

std::enable_if_t< std::is_arithmetic< T >::value, T > CubbyFlow::AbsMinN	(	const T *	x,
		size_t	n
	)

Returns absolute minimum among n-elements.

Accumulate() [1/6]

template<typename T , size_t Rows, size_t Cols, typename M1 >

constexpr std::enable_if_t< TraitIsMatrixSizeStatic< Rows, Cols >::value, T > CubbyFlow::Accumulate ( const MatrixExpression< T, Rows, Cols, M1 > &  a )

constexpr

Accumulate() [2/6]

template<typename T , size_t Rows, size_t Cols, typename M1 >

constexpr std::enable_if_t< TraitIsMatrixSizeDynamic< Rows, Cols >::value, T > CubbyFlow::Accumulate ( const MatrixExpression< T, Rows, Cols, M1 > &  a )

constexpr

Accumulate() [3/6]

template<typename T , size_t Rows, size_t Cols, typename M1 >

constexpr std::enable_if_t< TraitIsMatrixSizeStatic< Rows, Cols >::value, T > CubbyFlow::Accumulate ( const MatrixExpression< T, Rows, Cols, M1 > &  a, const T &  init  )

constexpr

Accumulate() [4/6]

template<typename T , size_t Rows, size_t Cols, typename M1 >

constexpr std::enable_if_t< TraitIsMatrixSizeDynamic< Rows, Cols >::value, T > CubbyFlow::Accumulate ( const MatrixExpression< T, Rows, Cols, M1 > &  a, const T &  init  )

constexpr

Accumulate() [5/6]

template<typename T , size_t Rows, size_t Cols, typename M1 , typename BinaryOperation >

constexpr std::enable_if_t< TraitIsMatrixSizeStatic< Rows, Cols >::value, T > CubbyFlow::Accumulate ( const MatrixExpression< T, Rows, Cols, M1 > &  a, const T &  init, BinaryOperation  op  )

constexpr

Accumulate() [6/6]

template<typename T , size_t Rows, size_t Cols, typename M1 , typename BinaryOperation >

constexpr std::enable_if_t< TraitIsMatrixSizeDynamic< Rows, Cols >::value, T > CubbyFlow::Accumulate ( const MatrixExpression< T, Rows, Cols, M1 > &  a, const T &  init, BinaryOperation  op  )

constexpr

ArgMax2()

template<typename T >

std::enable_if_t< std::is_arithmetic< T >::value, size_t > CubbyFlow::ArgMax2	(	T	x,
		T	y
	)

ArgMax3()

template<typename T >

std::enable_if_t< std::is_arithmetic< T >::value, size_t > CubbyFlow::ArgMax3	(	T	x,
		T	y,
		T	z
	)

ArgMin2()

template<typename T >

std::enable_if_t< std::is_arithmetic< T >::value, size_t > CubbyFlow::ArgMin2	(	T	x,
		T	y
	)

ArgMin3()

template<typename T >

std::enable_if_t< std::is_arithmetic< T >::value, size_t > CubbyFlow::ArgMin3	(	T	x,
		T	y,
		T	z
	)

BiLerp()

template<typename S , typename T >

std::enable_if_t< std::is_arithmetic< T >::value, S > CubbyFlow::BiLerp	(	const S &	f00,
		const S &	f10,
		const S &	f01,
		const S &	f11,
		T	tx,
		T	ty
	)

Computes bilinear interpolation.

BinaryFind()

template<class ForwardIter , class T , class Compare >

ForwardIter CubbyFlow::BinaryFind	(	ForwardIter	first,
		ForwardIter	last,
		const T &	value,
		Compare	comp
	)

CatmullRom()

template<typename S , typename T >

std::enable_if_t< std::is_arithmetic< T >::value, S > CubbyFlow::CatmullRom	(	const S &	f0,
		const S &	f1,
		const S &	f2,
		const S &	f3,
		T	t
	)

Computes Catmull-Rom interpolation.

CD2()

template<typename T >

T CubbyFlow::CD2	(	T *	d0,
		T	dx
	)

2nd order central differencing. d0[1] is the origin.

  |------|------|
d0[0]  d0[1]  d0[2]

Ceil()

template<typename T , size_t Rows, size_t Cols, typename M1 >

constexpr auto CubbyFlow::Ceil ( const MatrixExpression< T, Rows, Cols, M1 > &  a )

constexpr

CG()

template<typename BLASType >

void CubbyFlow::CG	(	const typename BLASType::MatrixType &	A,
		const typename BLASType::VectorType &	b,
		unsigned int	maxNumberOfIterations,
		double	tolerance,
		typename BLASType::VectorType *	x,
		typename BLASType::VectorType *	r,
		typename BLASType::VectorType *	d,
		typename BLASType::VectorType *	q,
		typename BLASType::VectorType *	s,
		unsigned int *	lastNumberOfIterations,
		double *	lastResidualNorm
	)

Solves conjugate gradient.

Clamp() [1/2]

template<typename T , size_t Rows, size_t Cols, typename M1 , typename M2 , typename M3 >

auto CubbyFlow::Clamp	(	const MatrixExpression< T, Rows, Cols, M1 > &	a,
		const MatrixExpression< T, Rows, Cols, M2 > &	low,
		const MatrixExpression< T, Rows, Cols, M3 > &	high
	)

Clamp() [2/2]

template<typename T >

std::enable_if_t< std::is_arithmetic< T >::value, T > CubbyFlow::Clamp	(	T	val,
		T	low,
		T	high
	)

Returns the clamped value.

Parameters

[in]	val	The value.
[in]	low	The low value.
[in]	high	The high value.

Template Parameters

T	Value type.

Returns

The clamped value.

ComputeDragForce()

Vector3D CubbyFlow::ComputeDragForce ( double  dragCoefficient, double  radius, const Vector2D &  velocity  )

inline

ComputePressureFromEos()

double CubbyFlow::ComputePressureFromEos ( double  density, double  targetDensity, double  eosScale, double  eosExponent, double  negativePressureScale  )

inline

Copy() [1/3]

template<typename T , typename U >

void CubbyFlow::Copy	(	ArrayView< T, 1 >	src,
		size_t	begin,
		size_t	end,
		ArrayView< U, 1 >	dst
	)

Copy() [2/3]

template<typename T , typename U , size_t N>

void CubbyFlow::Copy	(	ArrayView< T, N >	src,
		ArrayView< U, N >	dst
	)

Copy() [3/3]

template<typename T , typename U , size_t N>

void CubbyFlow::Copy	(	ArrayView< T, N >	src,
		const Vector< size_t, N > &	begin,
		const Vector< size_t, N > &	end,
		ArrayView< U, N >	dst
	)

CosineWeightedSampleHemisphere()

template<typename T >

Vector3< T > CubbyFlow::CosineWeightedSampleHemisphere	(	T	u1,
		T	u2,
		const Vector3< T > &	normal
	)

Returns weighted sampled point on a hemisphere.

For a given hemisphere, defined by center normal vector, this function returns a point on the hemisphere, where the probability is cosine-weighted.

Parameters

[in]	u1	First random sample.
[in]	u2	Second random sample.
[in]	normal	The center normal of the hemisphere.

Template Parameters

T	Real number type.

Returns

Sampled point.

CubbyFlowToFlatbuffers() [1/2]

fbs::Vector3D CubbyFlow::CubbyFlowToFlatbuffers ( const Vector2D &  vec )

inline

CubbyFlowToFlatbuffers() [2/2]

fbs::Vector3UZ CubbyFlow::CubbyFlowToFlatbuffers ( const Vector2UZ &  vec )

inline

Cubic()

template<typename T >

std::enable_if_t< std::is_arithmetic< T >::value, T > CubbyFlow::Cubic

(

T

x

)

Returns the cubic of x.

Parameters

[in]

x

The input.

Template Parameters

T	Value type.

Returns

The cubic of x.

Curl2()

double CubbyFlow::Curl2	(	const ConstArrayView2< Vector2D > &	data,
		const Vector2D &	gridSpacing,
		size_t	i,
		size_t	j
	)

Returns curl value from given 2-D vector grid-like array data, gridSpacing, and array index (i, j).

Curl3()

Vector3D CubbyFlow::Curl3	(	const ConstArrayView3< Vector3D > &	data,
		const Vector3D &	gridSpacing,
		size_t	i,
		size_t	j,
		size_t	k
	)

Returns curl value from given 3-D vector grid-like array data, gridSpacing, and array index (i, j, k).

CycleArray()

template<typename T >

void CubbyFlow::CycleArray	(	T *	arr,
		int	size
	)

DegreesToRadians()

template<typename T >

std::enable_if_t< std::is_arithmetic< T >::value, T > CubbyFlow::DegreesToRadians

(

T

angleInDegrees

)

Converts degrees to radians.

Parameters

[in]

angleInDegrees

The angle in degrees.

Template Parameters

T	Value type.

Returns

Angle in radians.

Deserialize() [1/3]

template<typename T >

void CubbyFlow::Deserialize	(	const std::vector< uint8_t > &	buffer,
		Array1< T > *	array
	)

Deserializes buffer to data chunk using common schema.

Deserialize() [2/3]

void CubbyFlow::Deserialize	(	const std::vector< uint8_t > &	buffer,
		Serializable *	serializable
	)

Deserializes buffer to serializable object.

Deserialize() [3/3]

void CubbyFlow::Deserialize	(	const std::vector< uint8_t > &	buffer,
		std::vector< uint8_t > *	data
	)

Deserializes buffer to data chunk using common schema.

DeserializeGrid()

template<typename FbsGridList , typename GridType , typename FactoryFunc >

void CubbyFlow::DeserializeGrid	(	FbsGridList *	fbsGridList,
		FactoryFunc	factoryFunc,
		std::vector< GridType > *	gridList
	)

DistanceToZeroLevelSet()

template<typename T >

T CubbyFlow::DistanceToZeroLevelSet	(	T	phi0,
		T	phi1
	)

Divergence2()

double CubbyFlow::Divergence2	(	const ConstArrayView2< Vector2D > &	data,
		const Vector2D &	gridSpacing,
		size_t	i,
		size_t	j
	)

Returns divergence value from given 2-D vector grid-like array data, gridSpacing, and array index (i, j).

Divergence3()

double CubbyFlow::Divergence3	(	const ConstArrayView3< Vector3D > &	data,
		const Vector3D &	gridSpacing,
		size_t	i,
		size_t	j,
		size_t	k
	)

Returns diverence value from given 3-D vector grid-like array data, gridSpacing, and array index (i, j, k).

ElemDiv()

template<typename T , size_t Rows, size_t Cols, typename M1 , typename M2 >

constexpr auto CubbyFlow::ElemDiv ( const MatrixExpression< T, Rows, Cols, M1 > &  a, const MatrixExpression< T, Rows, Cols, M2 > &  b  )

constexpr

ElemIDiv()

template<typename T , size_t R1, size_t C1, size_t R2, size_t C2, typename M2 >

void CubbyFlow::ElemIDiv	(	Matrix< T, R1, C1 > &	a,
		const MatrixExpression< T, R2, C2, M2 > &	b
	)

ElemIMul()

template<typename T , size_t R1, size_t C1, size_t R2, size_t C2, typename M2 >

void CubbyFlow::ElemIMul	(	Matrix< T, R1, C1 > &	a,
		const MatrixExpression< T, R2, C2, M2 > &	b
	)

ElemMul()

template<typename T , size_t Rows, size_t Cols, typename M1 , typename M2 >

constexpr auto CubbyFlow::ElemMul ( const MatrixExpression< T, Rows, Cols, M1 > &  a, const MatrixExpression< T, Rows, Cols, M2 > &  b  )

constexpr

ENO3() [1/2]

template<typename T >

std::array< T, 2 > CubbyFlow::ENO3	(	T *	d0,
		T	dx
	)

3rd order ENO. d0[3] is the origin.

  |------|------|------|------|------|------|
d0[0]  d0[1]  d0[2]  d0[3]  d0[4]  d0[5]  d0[6]

Returns two solutions for each side.

ENO3() [2/2]

template<typename T >

T CubbyFlow::ENO3	(	T *	d0,
		T	dx,
		bool	isDirectionPositive
	)

3rd order ENO. d0[3] is the origin.

  |------|------|------|------|------|------|
d0[0]  d0[1]  d0[2]  d0[3]  d0[4]  d0[5]  d0[6]

ExtrapolateToRegion() [1/2]

template<typename T , typename U >

void CubbyFlow::ExtrapolateToRegion	(	ArrayView2< T >	input,
		ArrayView2< char >	valid,
		unsigned int	numberOfIterations,
		ArrayView2< U >	output
	)

Extrapolates 2-D input data from 'valid' (1) to 'invalid' (0) region.

This function extrapolates 2-D input data from 'valid' (1) to 'invalid' (0) region. It iterates multiple times to propagate the 'valid' values to nearby 'invalid' region. The maximum distance of the propagation is equal to numberOfIterations. The input parameters 'valid' and 'data' should be collocated.

Parameters

input	- data to extrapolate
valid	- set 1 if valid, else 0.
numberOfIterations	- number of iterations for propagation
output	- extrapolated output

ExtrapolateToRegion() [2/2]

template<typename T , typename U >

void CubbyFlow::ExtrapolateToRegion	(	ArrayView3< T >	input,
		ArrayView3< char >	valid,
		unsigned int	numberOfIterations,
		ArrayView3< U >	output
	)

Extrapolates 3-D input data from 'valid' (1) to 'invalid' (0) region.

This function extrapolates 3-D input data from 'valid' (1) to 'invalid' (0) region. It iterates multiple times to propagate the 'valid' values to nearby 'invalid' region. The maximum distance of the propagation is equal to numberOfIterations. The input parameters 'valid' and 'data' should be collocated.

Parameters

input	- data to extrapolate
valid	- set 1 if valid, else 0.
numberOfIterations	- number of iterations for propagation
output	- extrapolated output

Fill() [1/3]

template<typename T >

void CubbyFlow::Fill	(	ArrayView< T, 1 >	a,
		size_t	begin,
		size_t	end,
		const T &	val
	)

Fill() [2/3]

template<typename T , size_t N>

void CubbyFlow::Fill	(	ArrayView< T, N >	a,
		const T &	val
	)

Fill() [3/3]

template<typename T , size_t N>

void CubbyFlow::Fill	(	ArrayView< T, N >	a,
		const Vector< size_t, N > &	begin,
		const Vector< size_t, N > &	end,
		const T &	val
	)

FlatbuffersToCubbyFlow() [1/4]

Vector2D CubbyFlow::FlatbuffersToCubbyFlow ( const fbs::Vector2D &  vec )

inline

FlatbuffersToCubbyFlow() [2/4]

Vector2UZ CubbyFlow::FlatbuffersToCubbyFlow ( const fbs::Vector2UZ &  vec )

inline

FlatbuffersToCubbyFlow() [3/4]

Vector3D CubbyFlow::FlatbuffersToCubbyFlow ( const fbs::Vector3D &  vec )

inline

FlatbuffersToCubbyFlow() [4/4]

Vector3UZ CubbyFlow::FlatbuffersToCubbyFlow ( const fbs::Vector3UZ &  vec )

inline

Floor()

template<typename T , size_t Rows, size_t Cols, typename M1 >

constexpr auto CubbyFlow::Floor ( const MatrixExpression< T, Rows, Cols, M1 > &  a )

constexpr

ForEachIndex() [1/6]

template<typename IndexType , typename Func >

void CubbyFlow::ForEachIndex	(	const Vector< IndexType, 1 > &	begin,
		const Vector< IndexType, 1 > &	end,
		const Func &	func
	)

ForEachIndex() [2/6]

template<typename IndexType , typename Func >

void CubbyFlow::ForEachIndex	(	const Vector< IndexType, 1 > &	size,
		const Func &	func
	)

ForEachIndex() [3/6]

template<typename IndexType , size_t N, typename Func >

void CubbyFlow::ForEachIndex	(	const Vector< IndexType, N > &	begin,
		const Vector< IndexType, N > &	end,
		const Func &	func
	)

ForEachIndex() [4/6]

template<typename IndexType , size_t N, typename Func >

void CubbyFlow::ForEachIndex	(	const Vector< IndexType, N > &	size,
		const Func &	func
	)

ForEachIndex() [5/6]

template<typename IndexType , typename Func >

void CubbyFlow::ForEachIndex	(	IndexType	begin,
		IndexType	end,
		const Func &	func
	)

ForEachIndex() [6/6]

template<typename IndexType , typename Func >

void CubbyFlow::ForEachIndex	(	IndexType	size,
		const Func &	func
	)

FourPI()

template<typename T >

constexpr T CubbyFlow::FourPI ( )

constexpr

4*PI for type T.

FourPI< double >()

template<>

constexpr double CubbyFlow::FourPI< double > ( )

constexpr

4*PI for double.

FourPI< float >()

template<>

constexpr float CubbyFlow::FourPI< float > ( )

constexpr

4*PI for float.

FractionInside()

template<typename T >

T CubbyFlow::FractionInside	(	T	phiBottomLeft,
		T	phiBottomRight,
		T	phiTopLeft,
		T	phiTopRight
	)

Returns the fraction occupied by the implicit surface.

Given four signed distance values (square corners), determine what fraction of the square is "inside". The original implementation can be found from Christopher Batty's variational fluid code at https://github.com/christopherbatty/Fluid3D.

Template Parameters

T	Value type.

Parameters

phiBottomLeft	The level set value on the bottom-left corner.
phiBottomRight	The level set value on the bottom-right corner.
phiTopLeft	The level set value on the top-left corner.
phiTopRight	The level set value on the top-right corner.

Returns

The fraction occupied by the implicit surface.

FractionInsideSDF()

template<typename T >

T CubbyFlow::FractionInsideSDF	(	T	phi0,
		T	phi1
	)

Returns the fraction occupied by the implicit surface.

The input parameters, phi0 and phi1, are the level set values, measured from two nearby points. This function computes how much the implicit surface occupies the line between two points. For example, if both phi0 and phi1 are negative, it means the points are both inside the surface, thus the function will return 1. If both are positive, it will return 0 because both are outside the surface. If the signs are different, then only one of the points is inside the surface and the function will return a value between 0 and 1.

Parameters

[in]	phi0	The level set value from the first point.
[in]	phi1	The level set value from the second point.

Template Parameters

T	Value type.

Returns

The fraction occupied by the implicit surface.

GetBarycentric() [1/4]

template<typename T >

std::enable_if_t< std::is_arithmetic< T >::value > CubbyFlow::GetBarycentric	(	T	x,
		size_t	begin,
		size_t	end,
		size_t &	i,
		T &	t
	)

Computes the barycentric coordinate.

This function computes the barycentric coordinate for given array range as shown below:

begin              end
|----|-x--|----|----|
     i
t = x - i

For instance, if begin = 4, end = 8, and x = 5.4, output i will be 5 and t will be 0.4.

Parameters

[in]	x	The input value.
[in]	begin	Beginning index of the range.
[in]	end	End index of the range (exclusive).
[out]	i	The output index between iBegin and iEnd - 2.
[out]	t	The offset from i.

Template Parameters

T	Value type.

GetBarycentric() [2/4]

template<typename T >

std::enable_if_t< std::is_arithmetic< T >::value > CubbyFlow::GetBarycentric	(	T	x,
		size_t	end,
		size_t &	i,
		T &	t
	)

GetBarycentric() [3/4]

template<typename T >

std::enable_if_t< std::is_arithmetic< T >::value > CubbyFlow::GetBarycentric	(	T	x,
		ssize_t	begin,
		ssize_t	end,
		ssize_t &	i,
		T &	t
	)

Computes the barycentric coordinate.

This function computes the barycentric coordinate for given array range as shown below:

begin              end
|----|-x--|----|----|
     i
t = x - i

For instance, if begin = 4, end = 8, and x = 5.4, output i will be 5 and t will be 0.4.

Parameters

[in]	x	The input value.
[in]	begin	Beginning index of the range.
[in]	end	End index of the range (exclusive).
[out]	i	The output index between iBegin and iEnd - 2.
[out]	t	The offset from i.

Template Parameters

T	Value type.

GetBarycentric() [4/4]

template<typename T >

std::enable_if_t< std::is_arithmetic< T >::value > CubbyFlow::GetBarycentric	(	T	x,
		ssize_t	end,
		ssize_t &	i,
		T &	t
	)

GetMaxNumberOfThreads()

unsigned int CubbyFlow::GetMaxNumberOfThreads

(

)

Returns maximum number of threads to use.

Gradient2() [1/2]

Vector2D CubbyFlow::Gradient2	(	const ConstArrayView2< double > &	data,
		const Vector2D &	gridSpacing,
		size_t	i,
		size_t	j
	)

Returns 2-D gradient vector from given 2-D scalar grid-like array data, gridSpacing, and array index (i, j).

Gradient2() [2/2]

std::array< Vector2D, 2 > CubbyFlow::Gradient2	(	const ConstArrayView2< Vector2D > &	data,
		const Vector2D &	gridSpacing,
		size_t	i,
		size_t	j
	)

Returns 2-D gradient vectors from given 2-D vector grid-like array data, gridSpacing, and array index (i, j).

Gradient3() [1/2]

Vector3D CubbyFlow::Gradient3	(	const ConstArrayView3< double > &	data,
		const Vector3D &	gridSpacing,
		size_t	i,
		size_t	j,
		size_t	k
	)

Returns 3-D gradient vector from given 3-D scalar grid-like array data, gridSpacing, and array index (i, j, k).

Gradient3() [2/2]

std::array< Vector3D, 3 > CubbyFlow::Gradient3	(	const ConstArrayView3< Vector3D > &	data,
		const Vector3D &	gridSpacing,
		size_t	i,
		size_t	j,
		size_t	k
	)

Returns 3-D gradient vectors from given 3-D vector grid-like array data, gridSpacing, and array index (i, j, k).

HalfPI()

template<typename T >

constexpr T CubbyFlow::HalfPI ( )

constexpr

PI/2 for type T.

HalfPI< double >()

template<>

constexpr double CubbyFlow::HalfPI< double > ( )

constexpr

PI/2 for double.

HalfPI< float >()

template<>

constexpr float CubbyFlow::HalfPI< float > ( )

constexpr

PI/2 for float.

InvFourPI()

template<typename T >

constexpr T CubbyFlow::InvFourPI ( )

constexpr

1/4*PI for type T.

InvFourPI< double >()

template<>

constexpr double CubbyFlow::InvFourPI< double > ( )

constexpr

1/4*PI for double.

InvFourPI< float >()

template<>

constexpr float CubbyFlow::InvFourPI< float > ( )

constexpr

1/4*PI for float.

InvPI()

template<typename T >

constexpr T CubbyFlow::InvPI ( )

constexpr

1/PI for type T.

InvPI< double >()

template<>

constexpr double CubbyFlow::InvPI< double > ( )

constexpr

1/PI for double.

InvPI< float >()

template<>

constexpr float CubbyFlow::InvPI< float > ( )

constexpr

1/PI for float.

InvTwoPI()

template<typename T >

constexpr T CubbyFlow::InvTwoPI ( )

constexpr

1/2*PI for type T.

InvTwoPI< double >()

template<>

constexpr double CubbyFlow::InvTwoPI< double > ( )

constexpr

1/2*PI for double.

InvTwoPI< float >()

template<>

constexpr float CubbyFlow::InvTwoPI< float > ( )

constexpr

1/2*PI for float.

IsInsideSDF()

template<typename T >

bool CubbyFlow::IsInsideSDF

(

T

phi

)

Returns true if phi is inside the implicit surface (< 0).

Parameters

[in]

phi

The level set value.

Template Parameters

T	Value type.

Returns

True if inside the implicit surface, false otherwise.

IsMatrixSizeDynamic()

template<size_t Rows, size_t Cols>

constexpr bool CubbyFlow::IsMatrixSizeDynamic ( )

constexpr

IsMatrixSizeStatic()

template<size_t Rows, size_t Cols>

constexpr bool CubbyFlow::IsMatrixSizeStatic ( )

constexpr

IsMatrixStaticSquare()

template<size_t Rows, size_t Cols>

constexpr bool CubbyFlow::IsMatrixStaticSquare ( )

constexpr

Laplacian2() [1/2]

double CubbyFlow::Laplacian2	(	const ConstArrayView2< double > &	data,
		const Vector2D &	gridSpacing,
		size_t	i,
		size_t	j
	)

Returns Laplacian value from given 2-D scalar grid-like array data, gridSpacing, and array index (i, j).

Laplacian2() [2/2]

Vector2D CubbyFlow::Laplacian2	(	const ConstArrayView2< Vector2D > &	data,
		const Vector2D &	gridSpacing,
		size_t	i,
		size_t	j
	)

Returns 2-D Laplacian vectors from given 2-D vector grid-like array data, gridSpacing, and array index (i, j).

Laplacian3() [1/2]

double CubbyFlow::Laplacian3	(	const ConstArrayView3< double > &	data,
		const Vector3D &	gridSpacing,
		size_t	i,
		size_t	j,
		size_t	k
	)

Returns Laplacian value from given 3-D scalar grid-like array data, gridSpacing, and array index (i, j, k).

Laplacian3() [2/2]

Vector3D CubbyFlow::Laplacian3	(	const ConstArrayView3< Vector3D > &	data,
		const Vector3D &	gridSpacing,
		size_t	i,
		size_t	j,
		size_t	k
	)

Returns 3-D Laplacian vectors from given 3-D vector grid-like array data, gridSpacing, and array index (i, j, k).

Lerp()

template<typename S , typename T >

std::enable_if_t< std::is_arithmetic< T >::value, S > CubbyFlow::Lerp	(	const S &	f0,
		const S &	f1,
		T	t
	)

Computes linear interpolation.

Parameters

[in]	f0	The first value.
[in]	f1	The second value.
[in]	t	Relative offset [0, 1] from the first value.

Template Parameters

S	Input value type.
T	Offset type.

Returns

The interpolated value.

MarchingCubes()

void CubbyFlow::MarchingCubes	(	const ConstArrayView3< double > &	grid,
		const Vector3D &	gridSize,
		const Vector3D &	origin,
		TriangleMesh3 *	mesh,
		double	isoValue = 0,
		int	bndClose = DIRECTION_ALL,
		int	bndConnectivity = DIRECTION_NONE
	)

Computes marching cubes and extract triangle mesh from grid.

This function computes the marching cube algorithm to extract triangle mesh from the scalar grid field. The triangle mesh will be the iso-surface, and the iso value can be specified. For the boundaries (the walls), it can be specified whether to close or open with bndClose (default: close all). Another boundary flag bndConnectivity can be used for specifying topological connectivity of the boundary meshes (default: disconnect all).

Parameters

[in]	grid	The grid.
[in]	gridSize	The grid size.
[in]	origin	The origin.
[out]	mesh	The output triangle mesh.
[in]	isoValue	The iso-surface value.
[in]	bndClose	The boundary open flag.
[in]	bndConnectivity	The boundary connectivity flag.

Max()

template<typename T , size_t Rows, size_t Cols, typename M1 , typename M2 >

constexpr auto CubbyFlow::Max ( const MatrixExpression< T, Rows, Cols, M1 > &  a, const MatrixExpression< T, Rows, Cols, M2 > &  b  )

constexpr

Max3()

template<typename T >

std::enable_if_t< std::is_arithmetic< T >::value, T > CubbyFlow::Max3	(	T	x,
		T	y,
		T	z
	)

Returns the maximum value among three inputs.

Parameters

[in]	x	The first value.
[in]	y	The second value.
[in]	z	The three value.

Template Parameters

T	Value type.

Returns

The maximum value.

MaxN()

template<typename T >

std::enable_if_t< std::is_arithmetic< T >::value, T > CubbyFlow::MaxN	(	const T *	x,
		size_t	n
	)

Returns maximum among n-elements.

MGVCycle()

template<typename BlasType >

MGResult CubbyFlow::MGVCycle	(	const MGMatrix< BlasType > &	A,
		MGParameters< BlasType >	params,
		MGVector< BlasType > *	x,
		MGVector< BlasType > *	b,
		MGVector< BlasType > *	buffer
	)

Performs Multi-grid with V-cycle.

For given linear system matrix A and RHS vector b, this function computes the solution x using Multi-grid method with V-cycle.

Min()

template<typename T , size_t Rows, size_t Cols, typename M1 , typename M2 >

constexpr auto CubbyFlow::Min ( const MatrixExpression< T, Rows, Cols, M1 > &  a, const MatrixExpression< T, Rows, Cols, M2 > &  b  )

constexpr

Min3()

template<typename T >

std::enable_if_t< std::is_arithmetic< T >::value, T > CubbyFlow::Min3	(	T	x,
		T	y,
		T	z
	)

Returns the minimum value among three inputs.

Parameters

[in]	x	The first value.
[in]	y	The second value.
[in]	z	The three value.

Template Parameters

T	Value type.

Returns

The minimum value.

MinN()

template<typename T >

std::enable_if_t< std::is_arithmetic< T >::value, T > CubbyFlow::MinN	(	const T *	x,
		size_t	n
	)

Returns minimum among n-elements.

MonotonicCatmullRom() [1/2]

template<typename T , size_t Rows, size_t Cols, typename M1 , typename M2 , typename M3 , typename M4 >

std::enable_if_t< IsMatrixSizeStatic< Rows, Cols >(), Matrix< T, Rows, Cols > > CubbyFlow::MonotonicCatmullRom	(	const MatrixExpression< T, Rows, Cols, M1 > &	f0,
		const MatrixExpression< T, Rows, Cols, M2 > &	f1,
		const MatrixExpression< T, Rows, Cols, M3 > &	f2,
		const MatrixExpression< T, Rows, Cols, M4 > &	f3,
		T	f
	)

MonotonicCatmullRom() [2/2]

template<typename T >

std::enable_if_t< std::is_arithmetic< T >::value, T > CubbyFlow::MonotonicCatmullRom	(	const T &	f0,
		const T &	f1,
		const T &	f2,
		const T &	f3,
		T	t
	)

Computes monotonic Catmull-Rom interpolation.

ObjectToQuaternionD()

QuaternionD CubbyFlow::ObjectToQuaternionD ( const pybind11::object &  obj )

inline

ObjectToQuaternionF()

QuaternionF CubbyFlow::ObjectToQuaternionF ( const pybind11::object &  obj )

inline

ObjectToVector2D()

Vector2D CubbyFlow::ObjectToVector2D ( const pybind11::object &  obj )

inline

ObjectToVector2F()

Vector2F CubbyFlow::ObjectToVector2F ( const pybind11::object &  obj )

inline

ObjectToVector2UZ()

Vector2UZ CubbyFlow::ObjectToVector2UZ ( const pybind11::object &  obj )

inline

ObjectToVector3D()

Vector3D CubbyFlow::ObjectToVector3D ( const pybind11::object &  obj )

inline

ObjectToVector3F()

Vector3F CubbyFlow::ObjectToVector3F ( const pybind11::object &  obj )

inline

ObjectToVector3UZ()

Vector3UZ CubbyFlow::ObjectToVector3UZ ( const pybind11::object &  obj )

inline

ObjectToVector4D()

Vector4D CubbyFlow::ObjectToVector4D ( const pybind11::object &  obj )

inline

ObjectToVector4F()

Vector4F CubbyFlow::ObjectToVector4F ( const pybind11::object &  obj )

inline

One()

template<typename T >

constexpr T CubbyFlow::One ( )

constexpr

One for type T.

One< double >()

template<>

constexpr double CubbyFlow::One< double > ( )

constexpr

One for double.

One< float >()

template<>

constexpr float CubbyFlow::One< float > ( )

constexpr

One for float.

operator!=()

template<typename T , size_t R1, size_t C1, size_t R2, size_t C2, typename M1 , typename M2 >

bool CubbyFlow::operator!=	(	const MatrixExpression< T, R1, C1, M1 > &	a,
		const MatrixExpression< T, R2, C2, M2 > &	b
	)

operator*() [1/8]

template<typename T , size_t R, size_t C, typename ME >

MatrixCSRMatrixMul< T, ME > CubbyFlow::operator*	(	const MatrixCSR< T > &	a,
		const MatrixExpression< T, R, C, ME > &	b
	)

operator*() [2/8]

template<typename T >

MatrixCSR< T > CubbyFlow::operator*	(	const MatrixCSR< T > &	a,
		T	b
	)

operator*() [3/8]

template<typename T , size_t R1, size_t C1, size_t R2, size_t C2, typename M1 , typename M2 >

auto CubbyFlow::operator*	(	const MatrixExpression< T, R1, C1, M1 > &	a,
		const MatrixExpression< T, R2, C2, M2 > &	b
	)

operator*() [4/8]

template<typename T , size_t Rows, size_t Cols, typename M1 >

constexpr auto CubbyFlow::operator* ( const MatrixExpression< T, Rows, Cols, M1 > &  a, const T &  b  )

constexpr

operator*() [5/8]

template<typename T >

Quaternion< T > CubbyFlow::operator*	(	const Quaternion< T > &	a,
		const Quaternion< T > &	b
	)

Returns quaternion a times quaternion b.

operator*() [6/8]

template<typename T >

Vector< T, 3 > CubbyFlow::operator*	(	const Quaternion< T > &	q,
		const Vector< T, 3 > &	v
	)

Returns quaternion q * vector v.

operator*() [7/8]

template<typename T , size_t Rows, size_t Cols, typename M2 >

constexpr auto CubbyFlow::operator* ( const T &  a, const MatrixExpression< T, Rows, Cols, M2 > &  b  )

constexpr

operator*() [8/8]

template<typename T >

MatrixCSR< T > CubbyFlow::operator*	(	T	a,
		const MatrixCSR< T > &	b
	)

operator*=() [1/2]

template<typename T , size_t R1, size_t C1, size_t R2, size_t C2, typename M2 >

void CubbyFlow::operator*=	(	Matrix< T, R1, C1 > &	a,
		const MatrixExpression< T, R2, C2, M2 > &	b
	)

operator*=() [2/2]

template<typename T , size_t Rows, size_t Cols>

void CubbyFlow::operator*=	(	Matrix< T, Rows, Cols > &	a,
		const T &	b
	)

operator+() [1/6]

template<typename T >

MatrixCSR< T > CubbyFlow::operator+	(	const MatrixCSR< T > &	a,
		const MatrixCSR< T > &	b
	)

operator+() [2/6]

template<typename T >

MatrixCSR< T > CubbyFlow::operator+	(	const MatrixCSR< T > &	a,
		T	b
	)

operator+() [3/6]

template<typename T , size_t Rows, size_t Cols, typename M1 , typename M2 >

constexpr auto CubbyFlow::operator+ ( const MatrixExpression< T, Rows, Cols, M1 > &  a, const MatrixExpression< T, Rows, Cols, M2 > &  b  )

constexpr

operator+() [4/6]

template<typename T , size_t Rows, size_t Cols, typename M1 >

constexpr auto CubbyFlow::operator+ ( const MatrixExpression< T, Rows, Cols, M1 > &  a, const T &  b  )

constexpr

operator+() [5/6]

template<typename T , size_t Rows, size_t Cols, typename M2 >

constexpr auto CubbyFlow::operator+ ( const T &  a, const MatrixExpression< T, Rows, Cols, M2 > &  b  )

constexpr

operator+() [6/6]

template<typename T >

MatrixCSR< T > CubbyFlow::operator+	(	T	a,
		const MatrixCSR< T > &	b
	)

operator+=() [1/2]

template<typename T , size_t R1, size_t C1, size_t R2, size_t C2, typename M2 >

void CubbyFlow::operator+=	(	Matrix< T, R1, C1 > &	a,
		const MatrixExpression< T, R2, C2, M2 > &	b
	)

operator+=() [2/2]

template<typename T , size_t Rows, size_t Cols>

void CubbyFlow::operator+=	(	Matrix< T, Rows, Cols > &	a,
		const T &	b
	)

operator-() [1/8]

template<typename T >

MatrixCSR< T > CubbyFlow::operator-

(

const MatrixCSR< T > &

a

)

operator-() [2/8]

template<typename T >

MatrixCSR< T > CubbyFlow::operator-	(	const MatrixCSR< T > &	a,
		const MatrixCSR< T > &	b
	)

operator-() [3/8]

template<typename T >

MatrixCSR< T > CubbyFlow::operator-	(	const MatrixCSR< T > &	a,
		T	b
	)

operator-() [4/8]

template<typename T , size_t Rows, size_t Cols, typename M1 , typename M2 >

constexpr auto CubbyFlow::operator- ( const MatrixExpression< T, Rows, Cols, M1 > &  a, const MatrixExpression< T, Rows, Cols, M2 > &  b  )

constexpr

operator-() [5/8]

template<typename T , size_t Rows, size_t Cols, typename M1 >

constexpr auto CubbyFlow::operator- ( const MatrixExpression< T, Rows, Cols, M1 > &  a, const T &  b  )

constexpr

operator-() [6/8]

template<typename T , size_t Rows, size_t Cols, typename M1 >

constexpr auto CubbyFlow::operator- ( const MatrixExpression< T, Rows, Cols, M1 > &  m )

constexpr

operator-() [7/8]

template<typename T , size_t Rows, size_t Cols, typename M2 >

constexpr auto CubbyFlow::operator- ( const T &  a, const MatrixExpression< T, Rows, Cols, M2 > &  b  )

constexpr

operator-() [8/8]

template<typename T >

MatrixCSR< T > CubbyFlow::operator-	(	T	a,
		const MatrixCSR< T > &	b
	)

operator-=() [1/2]

template<typename T , size_t R1, size_t C1, size_t R2, size_t C2, typename M2 >

void CubbyFlow::operator-=	(	Matrix< T, R1, C1 > &	a,
		const MatrixExpression< T, R2, C2, M2 > &	b
	)

operator-=() [2/2]

template<typename T , size_t Rows, size_t Cols>

void CubbyFlow::operator-=	(	Matrix< T, Rows, Cols > &	a,
		const T &	b
	)

operator/() [1/4]

template<typename T >

MatrixCSR< T > CubbyFlow::operator/	(	const MatrixCSR< T > &	a,
		T	b
	)

operator/() [2/4]

template<typename T , size_t Rows, size_t Cols, typename M1 >

constexpr auto CubbyFlow::operator/ ( const MatrixExpression< T, Rows, Cols, M1 > &  a, const T &  b  )

constexpr

operator/() [3/4]

template<typename T , size_t Rows, size_t Cols, typename M2 >

constexpr auto CubbyFlow::operator/ ( const T &  a, const MatrixExpression< T, Rows, Cols, M2 > &  b  )

constexpr

operator/() [4/4]

template<typename T >

MatrixCSR< T > CubbyFlow::operator/	(	T	a,
		const MatrixCSR< T > &	b
	)

operator/=()

template<typename T , size_t Rows, size_t Cols>

void CubbyFlow::operator/=	(	Matrix< T, Rows, Cols > &	a,
		const T &	b
	)

operator==() [1/2]

template<typename T , size_t R1, size_t C1, size_t R2, size_t C2, typename M1 , typename M2 >

bool CubbyFlow::operator==	(	const MatrixExpression< T, R1, C1, M1 > &	a,
		const MatrixExpression< T, R2, C2, M2 > &	b
	)

operator==() [2/2]

template<typename T , size_t Rows, size_t Cols, typename M1 , typename M2 >

constexpr std::enable_if_t< IsMatrixSizeStatic< Rows, Cols >(), bool > CubbyFlow::operator== ( const MatrixExpression< T, Rows, Cols, M1 > &  a, const MatrixExpression< T, Rows, Cols, M2 > &  b  )

constexpr

ParallelFill()

template<typename RandomIterator , typename T >

void CubbyFlow::ParallelFill	(	const RandomIterator &	begin,
		const RandomIterator &	end,
		const T &	value,
		ExecutionPolicy	policy = ExecutionPolicy::Parallel
	)

Fills from begin to end with value in parallel.

This function fills a container specified by begin and end iterators in parallel. The order of the filling is not guaranteed due to the nature of parallel execution.

Parameters

[in]	begin	The begin iterator of a container.
[in]	end	The end iterator of a container.
[in]	value	The value to fill a container.
[in]	policy	The execution policy (parallel or serial).

Template Parameters

RandomIterator	Random iterator type.
T	Value type of a container.

ParallelFor() [1/3]

template<typename IndexType , typename Function >

void CubbyFlow::ParallelFor	(	IndexType	beginIndex,
		IndexType	endIndex,
		const Function &	function,
		ExecutionPolicy	policy = ExecutionPolicy::Parallel
	)

Makes a for-loop from beginIndex to endIndex in parallel.

This function makes a for-loop specified by begin and end indices in parallel. The order of the visit is not guaranteed due to the nature of parallel execution.

Parameters

[in]	beginIndex	The begin index.
[in]	endIndex	The end index.
[in]	function	The function to call for each index.
[in]	policy	The execution policy (parallel or serial).

Template Parameters

IndexType	Index type.
Function	Function type.

ParallelFor() [2/3]

template<typename IndexType , typename Function >

void CubbyFlow::ParallelFor	(	IndexType	beginIndexX,
		IndexType	endIndexX,
		IndexType	beginIndexY,
		IndexType	endIndexY,
		const Function &	function,
		ExecutionPolicy	policy = ExecutionPolicy::Parallel
	)

Makes a 2D nested for-loop in parallel.

This function makes a 2D nested for-loop specified by begin and end indices for each dimension. X will be the inner-most loop while Y is the outer-most. The order of the visit is not guaranteed due to the nature of parallel execution.

Parameters

[in]	beginIndexX	The begin index in X dimension.
[in]	endIndexX	The end index in X dimension.
[in]	beginIndexY	The begin index in Y dimension.
[in]	endIndexY	The end index in Y dimension.
[in]	function	The function to call for each index (i, j).
[in]	policy	The execution policy (parallel or serial).

Template Parameters

IndexType	Index type.
Function	Function type.

ParallelFor() [3/3]

template<typename IndexType , typename Function >

void CubbyFlow::ParallelFor	(	IndexType	beginIndexX,
		IndexType	endIndexX,
		IndexType	beginIndexY,
		IndexType	endIndexY,
		IndexType	beginIndexZ,
		IndexType	endIndexZ,
		const Function &	function,
		ExecutionPolicy	policy = ExecutionPolicy::Parallel
	)

Makes a 3D nested for-loop in parallel.

This function makes a 3D nested for-loop specified by begin and end indices for each dimension. X will be the inner-most loop while Z is the outer-most. The order of the visit is not guaranteed due to the nature of parallel execution.

Parameters

[in]	beginIndexX	The begin index in X dimension.
[in]	endIndexX	The end index in X dimension.
[in]	beginIndexY	The begin index in Y dimension.
[in]	endIndexY	The end index in Y dimension.
[in]	beginIndexZ	The begin index in Z dimension.
[in]	endIndexZ	The end index in Z dimension.
[in]	function	The function to call for each index (i, j, k).
[in]	policy	The execution policy (parallel or serial).

Template Parameters

IndexType	Index type.
Function	Function type.

ParallelForEachIndex() [1/6]

template<typename IndexType , typename Func >

void CubbyFlow::ParallelForEachIndex	(	const Vector< IndexType, 1 > &	begin,
		const Vector< IndexType, 1 > &	end,
		const Func &	func,
		ExecutionPolicy	policy
	)

ParallelForEachIndex() [2/6]

template<typename IndexType , typename Func >

void CubbyFlow::ParallelForEachIndex	(	const Vector< IndexType, 1 > &	size,
		const Func &	func,
		ExecutionPolicy	policy
	)

ParallelForEachIndex() [3/6]

template<typename IndexType , size_t N, typename Func >

void CubbyFlow::ParallelForEachIndex	(	const Vector< IndexType, N > &	begin,
		const Vector< IndexType, N > &	end,
		const Func &	func,
		ExecutionPolicy	policy
	)

ParallelForEachIndex() [4/6]

template<typename IndexType , size_t N, typename Func >

void CubbyFlow::ParallelForEachIndex	(	const Vector< IndexType, N > &	size,
		const Func &	func,
		ExecutionPolicy	policy
	)

ParallelForEachIndex() [5/6]

template<typename IndexType , typename Func >

void CubbyFlow::ParallelForEachIndex	(	IndexType	begin,
		IndexType	end,
		const Func &	func,
		ExecutionPolicy	policy
	)

ParallelForEachIndex() [6/6]

template<typename IndexType , typename Func >

void CubbyFlow::ParallelForEachIndex	(	IndexType	size,
		const Func &	func,
		ExecutionPolicy	policy
	)

ParallelRangeFor() [1/3]

template<typename IndexType , typename Function >

void CubbyFlow::ParallelRangeFor	(	IndexType	beginIndex,
		IndexType	endIndex,
		const Function &	function,
		ExecutionPolicy	policy = ExecutionPolicy::Parallel
	)

Makes a range-loop from beginIndex to endIndex in parallel.

This function makes a for-loop specified by begin and end indices in parallel. Unlike parallelFor function, the input function object takes range instead of single index. The order of the visit is not guaranteed due to the nature of parallel execution.

Parameters

[in]	beginIndex	The begin index.
[in]	endIndex	The end index.
[in]	function	The function to call for each index range.
[in]	policy	The execution policy (parallel or serial).

Template Parameters

IndexType	Index type.
Function	Function type.

ParallelRangeFor() [2/3]

template<typename IndexType , typename Function >

void CubbyFlow::ParallelRangeFor	(	IndexType	beginIndexX,
		IndexType	endIndexX,
		IndexType	beginIndexY,
		IndexType	endIndexY,
		const Function &	function,
		ExecutionPolicy	policy = ExecutionPolicy::Parallel
	)

Makes a 2D nested range-loop in parallel.

This function makes a 2D nested for-loop specified by begin and end indices for each dimension. X will be the inner-most loop while Y is the outer-most. Unlike parallelFor function, the input function object takes range instead of single index. The order of the visit is not guaranteed due to the nature of parallel execution.

Parameters

[in]	beginIndexX	The begin index in X dimension.
[in]	endIndexX	The end index in X dimension.
[in]	beginIndexY	The begin index in Y dimension.
[in]	endIndexY	The end index in Y dimension.
[in]	function	The function to call for each index range.
[in]	policy	The execution policy (parallel or serial).

Template Parameters

IndexType	Index type.
Function	Function type.

ParallelRangeFor() [3/3]

template<typename IndexType , typename Function >

void CubbyFlow::ParallelRangeFor	(	IndexType	beginIndexX,
		IndexType	endIndexX,
		IndexType	beginIndexY,
		IndexType	endIndexY,
		IndexType	beginIndexZ,
		IndexType	endIndexZ,
		const Function &	function,
		ExecutionPolicy	policy = ExecutionPolicy::Parallel
	)

Makes a 3D nested range-loop in parallel.

This function makes a 3D nested for-loop specified by begin and end indices for each dimension. X will be the inner-most loop while Z is the outer-most. Unlike parallelFor function, the input function object takes range instead of single index. The order of the visit is not guaranteed due to the nature of parallel execution.

Parameters

[in]	beginIndexX	The begin index in X dimension.
[in]	endIndexX	The end index in X dimension.
[in]	beginIndexY	The begin index in Y dimension.
[in]	endIndexY	The end index in Y dimension.
[in]	beginIndexZ	The begin index in Z dimension.
[in]	endIndexZ	The end index in Z dimension.
[in]	function	The function to call for each index (i, j, k).
[in]	policy	The execution policy (parallel or serial).

Template Parameters

IndexType	Index type.
Function	Function type.

ParallelReduce()

template<typename IndexType , typename Value , typename Function , typename Reduce >

Value CubbyFlow::ParallelReduce	(	IndexType	beginIndex,
		IndexType	endIndex,
		const Value &	identity,
		const Function &	function,
		const Reduce &	reduce,
		ExecutionPolicy	policy = ExecutionPolicy::Parallel
	)

Performs reduce operation in parallel.

This function reduces the series of values into a single value using the provided reduce function.

Parameters

[in]	beginIndex	The begin index.
[in]	endIndex	The end index.
[in]	identity	Identity value for the reduce operation.
[in]	function	The function for reducing subrange.
[in]	reduce	The reduce operator.
[in]	policy	The execution policy (parallel or serial).

Template Parameters

IndexType	Index type.
Value	Value type.
Function	Reduce function type.

ParallelSort() [1/2]

template<typename RandomIterator , typename CompareFunction >

void CubbyFlow::ParallelSort	(	RandomIterator	begin,
		RandomIterator	end,
		CompareFunction	compare,
		ExecutionPolicy	policy = ExecutionPolicy::Parallel
	)

Sorts a container in parallel with a custom compare function.

This function sorts a container specified by begin and end iterators. It takes extra compare function which returns true if the first argument is less than the second argument.

Parameters

[in]	begin	The begin random access iterator.
[in]	end	The end random access iterator.
[in]	compare	The compare function.
[in]	policy	The execution policy (parallel or serial).

Template Parameters

RandomIterator	Iterator type.
CompareFunction	Compare function type.

ParallelSort() [2/2]

template<typename RandomIterator >

void CubbyFlow::ParallelSort	(	RandomIterator	begin,
		RandomIterator	end,
		ExecutionPolicy	policy = ExecutionPolicy::Parallel
	)

Sorts a container in parallel.

This function sorts a container specified by begin and end iterators.

Parameters

[in]	begin	The begin random access iterator.
[in]	end	The end random access iterator.
[in]	policy	The execution policy (parallel or serial).

Template Parameters

RandomIterator

Iterator type.

ParseGridResizeParams()

void CubbyFlow::ParseGridResizeParams ( pybind11::args  args, pybind11::kwargs  kwargs, Vector2UZ &  resolution, Vector2D &  gridSpacing, Vector2D &  gridOrigin  )

inline

PCG()

template<typename BLASType , typename PrecondType >

void CubbyFlow::PCG	(	const typename BLASType::MatrixType &	A,
		const typename BLASType::VectorType &	b,
		unsigned int	maxNumberOfIterations,
		double	tolerance,
		PrecondType *	M,
		typename BLASType::VectorType *	x,
		typename BLASType::VectorType *	r,
		typename BLASType::VectorType *	d,
		typename BLASType::VectorType *	q,
		typename BLASType::VectorType *	s,
		unsigned int *	lastNumberOfIterations,
		double *	lastResidualNorm
	)

Solves pre-conditioned conjugate gradient.

PI()

template<typename T >

constexpr T CubbyFlow::PI ( )

constexpr

PI for type T.

PI< double >()

template<>

constexpr double CubbyFlow::PI< double > ( )

constexpr

Pi for double.

PI< float >()

template<>

constexpr float CubbyFlow::PI< float > ( )

constexpr

Pi for float.

Product()

template<typename T , size_t Rows, size_t Cols, typename M1 >

constexpr T CubbyFlow::Product ( const MatrixExpression< T, Rows, Cols, M1 > &  a, const T &  init  )

constexpr

ProjectAndApplyFriction()

template<size_t N>

Vector< double, N > CubbyFlow::ProjectAndApplyFriction	(	const Vector< double, N > &	vel,
		const Vector< double, N > &	normal,
		double	frictionCoefficient
	)

QuarterPI()

template<typename T >

constexpr T CubbyFlow::QuarterPI ( )

constexpr

PI/4 for type T.

QuarterPI< double >()

template<>

constexpr double CubbyFlow::QuarterPI< double > ( )

constexpr

PI/4 for double.

QuarterPI< float >()

template<>

constexpr float CubbyFlow::QuarterPI< float > ( )

constexpr

PI/4 for float.

RadiansToDegrees()

template<typename T >

std::enable_if_t< std::is_arithmetic< T >::value, T > CubbyFlow::RadiansToDegrees

(

T

angleInRadians

)

Converts radians to degrees.

Parameters

[in]

angleInRadians

The angle in radians.

Template Parameters

T	Value type.

Returns

Angle in degrees.

SerialFill()

template<typename RandomIterator , typename T >

void CubbyFlow::SerialFill	(	const RandomIterator &	begin,
		const RandomIterator &	end,
		const T &	value
	)

Fills from begin to end with value.

This function fills a container specified by begin and end iterators with single thread. The order of the filling is deterministic.

Parameters

[in]	begin	The begin iterator of a container.
[in]	end	The end iterator of a container.
[in]	value	The value to fill a container.

Template Parameters

RandomIterator	Random iterator type.
T	Value type of a container.

SerialFor() [1/3]

template<typename IndexType , typename Function >

void CubbyFlow::SerialFor	(	IndexType	beginIndex,
		IndexType	endIndex,
		const Function &	function
	)

Makes a for-loop from beginIndex to endIndex.

This function makes a for-loop specified by begin and end indices with single thread. The order of the visit is deterministic.

Parameters

[in]	beginIndex	The begin index.
[in]	endIndex	The end index.
[in]	function	The function to call for each index.

Template Parameters

IndexType	Index type.
Function	Function type.

SerialFor() [2/3]

template<typename IndexType , typename Function >

void CubbyFlow::SerialFor	(	IndexType	beginIndexX,
		IndexType	endIndexX,
		IndexType	beginIndexY,
		IndexType	endIndexY,
		const Function &	function
	)

Makes a 2D nested for-loop.

This function makes a 2D nested for-loop specified by begin and end indices for each dimension. X will be the inner-most loop while Y is the outer-most. The order of the visit is deterministic.

Parameters

[in]	beginIndexX	The begin index in X dimension.
[in]	endIndexX	The end index in X dimension.
[in]	beginIndexY	The begin index in Y dimension.
[in]	endIndexY	The end index in Y dimension.
[in]	function	The function to call for each index (i, j).

Template Parameters

IndexType	Index type.
Function	Function type.

SerialFor() [3/3]

template<typename IndexType , typename Function >

void CubbyFlow::SerialFor	(	IndexType	beginIndexX,
		IndexType	endIndexX,
		IndexType	beginIndexY,
		IndexType	endIndexY,
		IndexType	beginIndexZ,
		IndexType	endIndexZ,
		const Function &	function
	)

Makes a 3D nested for-loop.

This function makes a 3D nested for-loop specified by begin and end indices for each dimension. X will be the inner-most loop while Z is the outer-most. The order of the visit is deterministic.

Parameters

[in]	beginIndexX	The begin index in X dimension.
[in]	endIndexX	The end index in X dimension.
[in]	beginIndexY	The begin index in Y dimension.
[in]	endIndexY	The end index in Y dimension.
[in]	beginIndexZ	The begin index in Z dimension.
[in]	endIndexZ	The end index in Z dimension.
[in]	function	The function to call for each index (i, j, k).

Template Parameters

IndexType	Index type.
Function	Function type.

Serialize() [1/3]

template<typename T >

void CubbyFlow::Serialize	(	const ConstArrayView1< T > &	array,
		std::vector< uint8_t > *	buffer
	)

Serializes data chunk using common schema.

Serialize() [2/3]

void CubbyFlow::Serialize	(	const Serializable *	serializable,
		std::vector< uint8_t > *	buffer
	)

Serializes serializable object.

Serialize() [3/3]

void CubbyFlow::Serialize	(	const uint8_t *	data,
		size_t	size,
		std::vector< uint8_t > *	buffer
	)

Serializes data chunk using common schema.

SerializeGrid()

template<typename GridType , typename FbsFactoryFunc , typename FbsGridType >

void CubbyFlow::SerializeGrid	(	flatbuffers::FlatBufferBuilder *	builder,
		const std::vector< GridType > &	gridList,
		FbsFactoryFunc	func,
		std::vector< flatbuffers::Offset< FbsGridType > > *	fbsGridList
	)

SerialSort() [1/2]

template<typename RandomIterator >

void CubbyFlow::SerialSort	(	RandomIterator	begin,
		RandomIterator	end
	)

Sorts a container.

This function sorts a container specified by begin and end iterators.

Parameters

[in]	begin	The begin random access iterator.
[in]	end	The end random access iterator.

Template Parameters

RandomIterator

Iterator type.

SerialSort() [2/2]

template<typename RandomIterator , typename SortingFunction >

void CubbyFlow::SerialSort	(	RandomIterator	begin,
		RandomIterator	end,
		const SortingFunction &	sortingFunction
	)

Sorts a container with a custom compare function.

This function sorts a container specified by begin and end iterators. It takes extra compare function which returns true if the first argument is less than the second argument.

Parameters

[in]	begin	The begin random access iterator.
[in]	end	The end random access iterator.
[in]	sortingFunction	The sorting function.

Template Parameters

RandomIterator	Iterator type.
SortingFunction	Sorting function type.

SetMaxNumberOfThreads()

void CubbyFlow::SetMaxNumberOfThreads

(

unsigned int

numThreads

)

Sets maximum number of threads to use.

Sign()

template<typename T >

std::enable_if_t< std::is_arithmetic< T >::value, T > CubbyFlow::Sign

(

T

x

)

Returns the sign of the value.

Parameters

[in]

x

Input value.

Template Parameters

T	Value type.

Returns

The sign.

Similar()

template<typename T >

std::enable_if_t< std::is_arithmetic< T >::value, bool > CubbyFlow::Similar	(	T	x,
		T	y,
		T	eps = std::numeric_limits< T >::epsilon()
	)

Returns true if x and y are similar.

Parameters

[in]	x	The first value.
[in]	y	The second value.
[in]	eps	The tolerance.

Template Parameters

T	Value type.

Returns

True if similar.

Slerp()

template<typename T >

Quaternion< T > CubbyFlow::Slerp	(	const Quaternion< T > &	a,
		const Quaternion< T > &	b,
		T	t
	)

Computes spherical linear interpolation.

SmearedDeltaSDF()

template<typename T >

T CubbyFlow::SmearedDeltaSDF

(

T

phi

)

Returns smeared delta function.

This function returns smeared (or smooth) delta function between 0 and 1. If phi is less than -1.5, it will return 0. If phi is greater than 1.5, it will also return 0. Between -1.5 and 1.5, the function will return smooth delta function. Integral of this function is smearedHeavisideSdf.

Parameters

[in]

phi

The level set value.

Template Parameters

T	Value type.

Returns

Smeared delta function.

SmearedHeavisideSDF()

template<typename T >

T CubbyFlow::SmearedHeavisideSDF

(

T

phi

)

Returns smeared Heaviside function.

This function returns smeared (or smooth) Heaviside (or step) function between 0 and 1. If phi is less than -1.5, it will return 0. If phi is greater than 1.5, it will return 1. Between -1.5 and 1.5, the function will return smooth profile between 0 and 1. Derivative of this function is smearedDeltaSdf.

Parameters

[in]

phi

The level set value.

Template Parameters

T	Value type.

Returns

Smeared Heaviside function.

Square()

template<typename T >

std::enable_if_t< std::is_arithmetic< T >::value, T > CubbyFlow::Square

(

T

x

)

Returns the square of x.

Parameters

[in]

x

The input.

Template Parameters

T	Value type.

Returns

The squared value.

SVD() [1/2]

template<typename T , size_t M, size_t N>

void CubbyFlow::SVD	(	const Matrix< T, M, N > &	a,
		Matrix< T, M, N > &	u,
		Vector< T, N > &	w,
		Matrix< T, N, N > &	v
	)

Singular value decomposition (SVD).

This function decompose the input matrix a to u * w * v^T.

Template Parameters

T	Real-value type.

Parameters

a	The input matrix to decompose.
u	Left-most output matrix.
w	The vector of singular values.
v	Right-most output matrix.

SVD() [2/2]

template<typename T >

void CubbyFlow::SVD	(	const MatrixMxN< T > &	a,
		MatrixMxN< T > &	u,
		VectorN< T > &	w,
		MatrixMxN< T > &	v
	)

Singular value decomposition (SVD).

This function decompose the input matrix a to u * w * v^T.

Template Parameters

T	Real-value type.

Parameters

a	The input matrix to decompose.
u	Left-most output matrix.
w	The vector of singular values.
v	Right-most output matrix.

TriangleMeshToSDF()

void CubbyFlow::TriangleMeshToSDF	(	const TriangleMesh3 &	mesh,
		ScalarGrid3 *	sdf
	)

Generates signed-distance field out of given triangle mesh. This function generates signed-distance field from a triangle mesh. The sign is determined by TriangleMesh3::IsInside (negative means inside).

Parameters

[in]	mesh	The mesh.
[in,out]	sdf	The output signed-distance field.

TriLerp()

template<typename S , typename T >

std::enable_if_t< std::is_arithmetic< T >::value, S > CubbyFlow::TriLerp	(	const S &	f000,
		const S &	f100,
		const S &	f010,
		const S &	f110,
		const S &	f001,
		const S &	f101,
		const S &	f011,
		const S &	f111,
		T	tx,
		T	ty,
		T	tz
	)

Computes trilinear interpolation.

TupleToQuaternion() [1/2]

template<typename T >

Quaternion< T > CubbyFlow::TupleToQuaternion ( pybind11::list  list )

inline

TupleToQuaternion() [2/2]

template<typename T >

Quaternion< T > CubbyFlow::TupleToQuaternion ( pybind11::tuple  tuple )

inline

TupleToQuaternionD() [1/2]

QuaternionD CubbyFlow::TupleToQuaternionD ( pybind11::list  list )

inline

TupleToQuaternionD() [2/2]

QuaternionD CubbyFlow::TupleToQuaternionD ( pybind11::tuple  tuple )

inline

TupleToQuaternionF() [1/2]

QuaternionF CubbyFlow::TupleToQuaternionF ( pybind11::list  list )

inline

TupleToQuaternionF() [2/2]

QuaternionF CubbyFlow::TupleToQuaternionF ( pybind11::tuple  tuple )

inline

TupleToVector() [1/2]

template<typename T , size_t N>

Vector< T, N > CubbyFlow::TupleToVector ( pybind11::list  list )

inline

TupleToVector() [2/2]

template<typename T , size_t N>

Vector< T, N > CubbyFlow::TupleToVector ( pybind11::tuple  tuple )

inline

TupleToVector2D() [1/2]

Vector2D CubbyFlow::TupleToVector2D ( pybind11::list  list )

inline

TupleToVector2D() [2/2]

Vector2D CubbyFlow::TupleToVector2D ( pybind11::tuple  tuple )

inline

TupleToVector2F() [1/2]

Vector2F CubbyFlow::TupleToVector2F ( pybind11::list  list )

inline

TupleToVector2F() [2/2]

Vector2F CubbyFlow::TupleToVector2F ( pybind11::tuple  tuple )

inline

TupleToVector2UZ() [1/2]

Vector2UZ CubbyFlow::TupleToVector2UZ ( pybind11::list  list )

inline

TupleToVector2UZ() [2/2]

Vector2UZ CubbyFlow::TupleToVector2UZ ( pybind11::tuple  tuple )

inline

TupleToVector3D() [1/2]

Vector3D CubbyFlow::TupleToVector3D ( pybind11::list  list )

inline

TupleToVector3D() [2/2]

Vector3D CubbyFlow::TupleToVector3D ( pybind11::tuple  tuple )

inline

TupleToVector3F() [1/2]

Vector3F CubbyFlow::TupleToVector3F ( pybind11::list  list )

inline

TupleToVector3F() [2/2]

Vector3F CubbyFlow::TupleToVector3F ( pybind11::tuple  tuple )

inline

TupleToVector3UZ() [1/2]

Vector3UZ CubbyFlow::TupleToVector3UZ ( pybind11::list  list )

inline

TupleToVector3UZ() [2/2]

Vector3UZ CubbyFlow::TupleToVector3UZ ( pybind11::tuple  tuple )

inline

TupleToVector4D() [1/2]

Vector4D CubbyFlow::TupleToVector4D ( pybind11::list  list )

inline

TupleToVector4D() [2/2]

Vector4D CubbyFlow::TupleToVector4D ( pybind11::tuple  tuple )

inline

TupleToVector4F() [1/2]

Vector4F CubbyFlow::TupleToVector4F ( pybind11::list  list )

inline

TupleToVector4F() [2/2]

Vector4F CubbyFlow::TupleToVector4F ( pybind11::tuple  tuple )

inline

TwoPI()

template<typename T >

constexpr T CubbyFlow::TwoPI ( )

constexpr

2*PI for type T.

TwoPI< double >()

template<>

constexpr double CubbyFlow::TwoPI< double > ( )

constexpr

2*PI for double.

TwoPI< float >()

template<>

constexpr float CubbyFlow::TwoPI< float > ( )

constexpr

2*PI for float.

UniformSampleCone()

template<typename T >

Vector3< T > CubbyFlow::UniformSampleCone	(	T	u1,
		T	u2,
		const Vector3< T > &	axis,
		T	angle
	)

Returns randomly sampled direction within a cone.

For a given cone, defined by axis and angle, this function returns a sampled direction vector within the cone.

Parameters

[in]	u1	First random sample.
[in]	u2	Second random sample.
[in]	axis	The axis of the cone.
[in]	angle	The angle of the cone.

Template Parameters

T	Real number type.

Returns

Sampled direction vector.

UniformSampleDisk()

template<typename T >

Vector2< T > CubbyFlow::UniformSampleDisk	(	T	u1,
		T	u2
	)

Returns randomly a point on a disk.

For a given disk, this function returns a point on the disk.

Parameters

[in]	u1	First random sample.
[in]	u2	Second random sample.

Template Parameters

T	Real number type.

Returns

Sampled point.

UniformSampleHemisphere()

template<typename T >

Vector3< T > CubbyFlow::UniformSampleHemisphere	(	T	u1,
		T	u2,
		const Vector3< T > &	normal
	)

Returns randomly sampled point within a unit hemisphere.

For a given unit hemisphere, defined by center normal vector, this function returns a point within the hemisphere.

Parameters

[in]	u1	First random sample.
[in]	u2	Second random sample.
[in]	normal	The center normal of the hemisphere.

Template Parameters

T	Real number type.

Returns

Sampled point.

UniformSampleSphere()

template<typename T >

Vector3< T > CubbyFlow::UniformSampleSphere	(	T	u1,
		T	u2
	)

Returns randomly a point on a sphere.

For a given sphere, defined by center normal vector, this function returns a point on the sphere.

Parameters

[in]	u1	First random sample.
[in]	u2	Second random sample.

Template Parameters

T	Real number type.

Returns

Sampled point.

Unroll1()

template<typename ReturnType >

std::function< ReturnType(size_t)> CubbyFlow::Unroll1

(

const std::function< ReturnType(const Vector1UZ &)> &

func

)

Unrolls vector-based indexing to size_t-based function.

Unroll2()

template<typename ReturnType >

std::function< ReturnType(size_t, size_t)> CubbyFlow::Unroll2

(

const std::function< ReturnType(const Vector2UZ &)> &

func

)

Unrolls vector-based indexing to size_t-based function.

Unroll3()

template<typename ReturnType >

std::function< ReturnType(size_t, size_t, size_t)> CubbyFlow::Unroll3

(

const std::function< ReturnType(const Vector3UZ &)> &

func

)

Unrolls vector-based DataPositionFunc indexing to size_t-based function.

Upwind1() [1/2]

template<typename T >

std::array< T, 2 > CubbyFlow::Upwind1	(	T *	d0,
		T	dx
	)

1st order upwind differencing. d0[1] is the origin.

  |------|------|
d0[0]  d0[1]  d0[2]

Returns two solutions for each side.

Upwind1() [2/2]

template<typename T >

T CubbyFlow::Upwind1	(	T *	d0,
		T	dx,
		bool	isDirectionPositive
	)

1st order upwind differencing. d0[1] is the origin.

  |------|------|
d0[0]  d0[1]  d0[2]

Vector2ToTuple()

template<typename T >

pybind11::tuple CubbyFlow::Vector2ToTuple ( const Vector< T, 2 > &  vec )

inline

Vector2UZToTuple()

pybind11::tuple CubbyFlow::Vector2UZToTuple ( const Vector2UZ &  size )

inline

Vector3ToTuple()

template<typename T >

pybind11::tuple CubbyFlow::Vector3ToTuple ( const Vector< T, 3 > &  vec )

inline

Vector3UZToTuple()

pybind11::tuple CubbyFlow::Vector3UZToTuple ( const Vector3UZ &  size )

inline

Vector4ToTuple()

template<typename T >

pybind11::tuple CubbyFlow::Vector4ToTuple ( const Vector< T, 4 > &  vec )

inline

WENO5() [1/2]

template<typename T >

T CubbyFlow::WENO5	(	T *	v,
		T	h,
		bool	is_velocity_positive,
		T	eps = 1.0e-8
	)

5th order WENO. d0[3] is the origin.

  |------|------|------|------|------|------|
d0[0]  d0[1]  d0[2]  d0[3]  d0[4]  d0[5]  d0[6]

WENO5() [2/2]

template<typename T >

std::array< T, 2 > CubbyFlow::WENO5	(	T *	v,
		T	h,
		T	eps = 1.0e-8
	)

5th order WENO. d0[3] is the origin.

  |------|------|------|------|------|------|
d0[0]  d0[1]  d0[2]  d0[3]  d0[4]  d0[5]  d0[6]

Returns two solutions for each side.

Zero()

template<typename T >

constexpr T CubbyFlow::Zero ( )

constexpr

Zero for type T.

Zero< double >()

template<>

constexpr double CubbyFlow::Zero< double > ( )

constexpr

Zero for double.

Zero< float >()

template<>

constexpr float CubbyFlow::Zero< float > ( )

constexpr

Zero for float.

Variable Documentation

debugLogger

Logger CubbyFlow::debugLogger

extern

Debug-level logger.

DIRECTION_ALL

constexpr int CubbyFlow::DIRECTION_ALL

constexpr

Initial value:

= DIRECTION_LEFT | DIRECTION_RIGHT |
                              DIRECTION_DOWN | DIRECTION_UP | DIRECTION_BACK |
                              DIRECTION_FRONT

All direction.

DIRECTION_BACK

constexpr int CubbyFlow::DIRECTION_BACK = 1 << 4

constexpr

Back direction.

DIRECTION_DOWN

constexpr int CubbyFlow::DIRECTION_DOWN = 1 << 2

constexpr

Down direction.

DIRECTION_FRONT

constexpr int CubbyFlow::DIRECTION_FRONT = 1 << 5

constexpr

Front direction.

DIRECTION_LEFT

constexpr int CubbyFlow::DIRECTION_LEFT = 1 << 0

constexpr

Left direction.

DIRECTION_NONE

constexpr int CubbyFlow::DIRECTION_NONE = 0

constexpr

No direction.

DIRECTION_RIGHT

constexpr int CubbyFlow::DIRECTION_RIGHT = 1 << 1

constexpr

Right direction.

DIRECTION_UP

constexpr int CubbyFlow::DIRECTION_UP = 1 << 3

constexpr

Up direction.

errorLogger

Logger CubbyFlow::errorLogger

extern

Error-level logger.

FOUR_PI_DOUBLE

constexpr double CubbyFlow::FOUR_PI_DOUBLE = 4.0 * PI_DOUBLE

constexpr

Double-type 4*pi.

FOUR_PI_FLOAT

constexpr float CubbyFlow::FOUR_PI_FLOAT = static_cast<float>(4.0 * PI_DOUBLE)

constexpr

Float-type 4*PI.

GRAVITY

constexpr double CubbyFlow::GRAVITY = -9.8

constexpr

GRAVITY_FLOAT

constexpr float CubbyFlow::GRAVITY_FLOAT = -9.8f

constexpr

Gravity.

HALF_PI_DOUBLE

constexpr double CubbyFlow::HALF_PI_DOUBLE = 1.57079632679489661923132169163975144

constexpr

Double-type PI/2.

HALF_PI_FLOAT

constexpr float CubbyFlow::HALF_PI_FLOAT = 1.57079632679489661923132169163975144f

constexpr

Float-type PI/2.

infoLogger

Logger CubbyFlow::infoLogger

extern

Info-level logger.

INV_FOUR_PI_DOUBLE

constexpr double CubbyFlow::INV_FOUR_PI_DOUBLE = 0.25 / PI_DOUBLE

constexpr

Double-type 1/4*PI.

INV_FOUR_PI_FLOAT

constexpr float CubbyFlow::INV_FOUR_PI_FLOAT = static_cast<float>(0.25 / PI_DOUBLE)

constexpr

Float-type 1/4*PI.

INV_PI_DOUBLE

constexpr double CubbyFlow::INV_PI_DOUBLE = 1.0 / PI_DOUBLE

constexpr

Double-type 1/PI.

INV_PI_FLOAT

constexpr float CubbyFlow::INV_PI_FLOAT = static_cast<float>(1.0 / PI_DOUBLE)

constexpr

Float-type 1/PI.

INV_TWO_PI_DOUBLE

constexpr double CubbyFlow::INV_TWO_PI_DOUBLE = 0.5 / PI_DOUBLE

constexpr

Double-type 1/2*PI.

INV_TWO_PI_FLOAT

constexpr float CubbyFlow::INV_TWO_PI_FLOAT = static_cast<float>(0.5 / PI_DOUBLE)

constexpr

Float-type 1/2*PI.

ONE_SIZE

constexpr size_t CubbyFlow::ONE_SIZE = 1

constexpr

One size_t.

ONE_SSIZE

constexpr ssize_t CubbyFlow::ONE_SSIZE = 1

constexpr

One ssize_t.

PI_DOUBLE

constexpr double CubbyFlow::PI_DOUBLE = 3.14159265358979323846264338327950288

constexpr

Double-type PI.

PI_FLOAT

constexpr float CubbyFlow::PI_FLOAT = 3.14159265358979323846264338327950288f

constexpr

Float-type PI.

QUARTER_PI_DOUBLE

constexpr double CubbyFlow::QUARTER_PI_DOUBLE = 0.785398163397448309615660845819875721

constexpr

Double-type PI/4.

QUARTER_PI_FLOAT

constexpr float CubbyFlow::QUARTER_PI_FLOAT = 0.785398163397448309615660845819875721f

constexpr

Float-type PI/4.

SPEED_OF_SOUND_IN_WATER

constexpr double CubbyFlow::SPEED_OF_SOUND_IN_WATER = 1482.0

constexpr

SPEED_OF_SOUND_IN_WATER_FLOAT

constexpr float CubbyFlow::SPEED_OF_SOUND_IN_WATER_FLOAT = 1482.0f

constexpr

Speed of sound in water at 20 degrees Celsius.

TWO_PI_DOUBLE

constexpr double CubbyFlow::TWO_PI_DOUBLE = 2.0 * PI_DOUBLE

constexpr

Double-type 2*PI.

TWO_PI_FLOAT

constexpr float CubbyFlow::TWO_PI_FLOAT = static_cast<float>(2.0 * PI_DOUBLE)

constexpr

Float-type 2*PI.

warnLogger

Logger CubbyFlow::warnLogger

extern

Warn-level logger.

WATER_DENSITY

constexpr double CubbyFlow::WATER_DENSITY = 1000.0

constexpr

WATER_DENSITY_FLOAT

constexpr float CubbyFlow::WATER_DENSITY_FLOAT = 1000.0f

constexpr

Water density.

ZERO_SIZE

constexpr size_t CubbyFlow::ZERO_SIZE = 0

constexpr

Zero size_t.

ZERO_SSIZE

constexpr ssize_t CubbyFlow::ZERO_SSIZE = 0

constexpr

Zero ssize_t.