|  | 
| template<> | 
| auto | cwiseAdd (const math::Vec3< math::half > &v, const float s) | 
|  | 
| template<typename Vec3T> | 
| std::ostream & | operator<< (std::ostream &os, const BBox< Vec3T > &b) | 
|  | 
| std::ostream & | operator<< (std::ostream &os, const Coord &xyz) | 
|  | 
| Coord | Abs (const Coord &xyz) | 
|  | 
| template<typename T> | 
| Vec3< typename promote< T, typename Coord::ValueType >::type > | operator+ (const Vec3< T > &v0, const Coord &v1) | 
|  | Allow a Coord to be added to or subtracted from a Vec3. 
 | 
|  | 
| template<typename T> | 
| Vec3< typename promote< T, typename Coord::ValueType >::type > | operator+ (const Coord &v1, const Vec3< T > &v0) | 
|  | 
| template<typename T> | 
| Vec3< typename promote< T, Coord::ValueType >::type > | operator- (const Vec3< T > &v0, const Coord &v1) | 
|  | Allow a Coord to be subtracted from a Vec3. 
 | 
|  | 
| template<typename T> | 
| Vec3< typename promote< T, Coord::ValueType >::type > | operator- (const Coord &v1, const Vec3< T > &v0) | 
|  | 
| std::ostream & | operator<< (std::ostream &os, const CoordBBox &b) | 
|  | 
| template<typename RayT, Index Log2Dim> | 
| std::ostream & | operator<< (std::ostream &os, const DDA< RayT, Log2Dim > &dda) | 
|  | Output streaming of the Ray class. 
 | 
|  | 
| std::string | dsSchemeToString (DScheme dss) | 
|  | 
| DScheme | stringToDScheme (const std::string &s) | 
|  | 
| std::string | dsSchemeToMenuName (DScheme dss) | 
|  | 
| std::string | biasedGradientSchemeToString (BiasedGradientScheme bgs) | 
|  | 
| BiasedGradientScheme | stringToBiasedGradientScheme (const std::string &s) | 
|  | 
| std::string | biasedGradientSchemeToMenuName (BiasedGradientScheme bgs) | 
|  | 
| std::string | temporalIntegrationSchemeToString (TemporalIntegrationScheme tis) | 
|  | 
| TemporalIntegrationScheme | stringToTemporalIntegrationScheme (const std::string &s) | 
|  | 
| std::string | temporalIntegrationSchemeToMenuName (TemporalIntegrationScheme tis) | 
|  | 
| template<typename ValueType> | 
| ValueType | WENO5 (const ValueType &v1, const ValueType &v2, const ValueType &v3, const ValueType &v4, const ValueType &v5, float scale2=0.01f) | 
|  | Implementation of nominally fifth-order finite-difference WENO. 
 | 
|  | 
| template<typename Real> | 
| Real | GodunovsNormSqrd (bool isOutside, Real dP_xm, Real dP_xp, Real dP_ym, Real dP_yp, Real dP_zm, Real dP_zp) | 
|  | 
| template<typename Real> | 
| Real | GodunovsNormSqrd (bool isOutside, const Vec3< Real > &gradient_m, const Vec3< Real > &gradient_p) | 
|  | 
| OPENVDB_API SharedPtr< SymmetricMap > | createSymmetricMap (const Mat3d &m) | 
|  | Utility methods. 
 | 
|  | 
| OPENVDB_API SharedPtr< FullyDecomposedMap > | createFullyDecomposedMap (const Mat4d &m) | 
|  | General decomposition of a Matrix into a Unitary (e.g. rotation) following a Symmetric (e.g. stretch & shear) 
 | 
|  | 
| OPENVDB_API SharedPtr< PolarDecomposedMap > | createPolarDecomposedMap (const Mat3d &m) | 
|  | Decomposes a general linear into translation following polar decomposition. 
 | 
|  | 
| OPENVDB_API SharedPtr< MapBase > | simplify (SharedPtr< AffineMap > affine) | 
|  | reduces an AffineMap to a ScaleMap or a ScaleTranslateMap when it can 
 | 
|  | 
| OPENVDB_API Mat4d | approxInverse (const Mat4d &mat) | 
|  | Returns the left pseudoInverse of the input matrix when the 3x3 part is symmetric otherwise it zeros the 3x3 and reverses the translation. 
 | 
|  | 
| template<class MatType> | 
| MatType | rotation (const Quat< typename MatType::value_type > &q, typename MatType::value_type eps=static_cast< typename MatType::value_type >(1.0e-8)) | 
|  | Return the rotation matrix specified by the given quaternion. 
 | 
|  | 
| template<class MatType> | 
| MatType | rotation (Axis axis, typename MatType::value_type angle) | 
|  | Return a matrix for rotation by angle radians about the given axis. 
 | 
|  | 
| template<class MatType> | 
| MatType | rotation (const Vec3< typename MatType::value_type > &_axis, typename MatType::value_type angle) | 
|  | Return a matrix for rotation by angle radians about the given axis. 
 | 
|  | 
| template<class MatType> | 
| Vec3< typename MatType::value_type > | eulerAngles (const MatType &mat, RotationOrder rotationOrder, typename MatType::value_type eps=static_cast< typename MatType::value_type >(1.0e-8)) | 
|  | Return the Euler angles composing the given rotation matrix. 
 | 
|  | 
| template<typename MatType, typename ValueType1, typename ValueType2> | 
| MatType | rotation (const Vec3< ValueType1 > &_v1, const Vec3< ValueType2 > &_v2, typename MatType::value_type eps=static_cast< typename MatType::value_type >(1.0e-8)) | 
|  | Return a rotation matrix that maps v1 onto v2 about the cross product of v1 and v2. 
 | 
|  | 
| template<class MatType> | 
| MatType | scale (const Vec3< typename MatType::value_type > &s) | 
|  | Return a matrix that scales by s. 
 | 
|  | 
| template<class MatType> | 
| Vec3< typename MatType::value_type > | getScale (const MatType &mat) | 
|  | Return a Vec3 representing the lengths of the passed matrix's upper 3×3's rows. 
 | 
|  | 
| template<class MatType> | 
| MatType | unit (const MatType &mat, typename MatType::value_type eps=1.0e-8) | 
|  | Return a copy of the given matrix with its upper 3×3 rows normalized. 
 | 
|  | 
| template<class MatType> | 
| MatType | unit (const MatType &in, typename MatType::value_type eps, Vec3< typename MatType::value_type > &scaling) | 
|  | Return a copy of the given matrix with its upper 3×3 rows normalized, and return the length of each of these rows in scaling. 
 | 
|  | 
| template<class MatType> | 
| MatType | shear (Axis axis0, Axis axis1, typename MatType::value_type shear) | 
|  | Set the matrix to a shear along axis0 by a fraction of axis1. 
 | 
|  | 
| template<class MatType> | 
| MatType | skew (const Vec3< typename MatType::value_type > &skew) | 
|  | Return a matrix as the cross product of the given vector. 
 | 
|  | 
| template<class MatType> | 
| MatType | aim (const Vec3< typename MatType::value_type > &direction, const Vec3< typename MatType::value_type > &vertical) | 
|  | Return an orientation matrix such that z points along direction, and y is along the direction / vertical plane. 
 | 
|  | 
| template<class MatType> | 
| MatType | snapMatBasis (const MatType &source, Axis axis, const Vec3< typename MatType::value_type > &direction) | 
|  | This function snaps a specific axis to a specific direction, preserving scaling. 
 | 
|  | 
| template<class MatType> | 
| MatType & | padMat4 (MatType &dest) | 
|  | Write 0s along Mat4's last row and column, and a 1 on its diagonal. 
 | 
|  | 
| template<typename MatType> | 
| void | sqrtSolve (const MatType &aA, MatType &aB, double aTol=0.01) | 
|  | Solve for A=B*B, given A. 
 | 
|  | 
| template<typename MatType> | 
| void | powSolve (const MatType &aA, MatType &aB, double aPower, double aTol=0.01) | 
|  | 
| template<typename MatType> | 
| bool | isIdentity (const MatType &m) | 
|  | Determine if a matrix is an identity matrix. 
 | 
|  | 
| template<typename MatType> | 
| bool | isInvertible (const MatType &m) | 
|  | Determine if a matrix is invertible. 
 | 
|  | 
| template<typename MatType> | 
| bool | isSymmetric (const MatType &m) | 
|  | Determine if a matrix is symmetric. 
 | 
|  | 
| template<typename MatType> | 
| bool | isUnitary (const MatType &m) | 
|  | Determine if a matrix is unitary (i.e., rotation or reflection). 
 | 
|  | 
| template<typename MatType> | 
| bool | isDiagonal (const MatType &mat) | 
|  | Determine if a matrix is diagonal. 
 | 
|  | 
| template<typename MatType> | 
| MatType::ValueType | lInfinityNorm (const MatType &matrix) | 
|  | Return the L∞ norm of an N×N matrix. 
 | 
|  | 
| template<typename MatType> | 
| MatType::ValueType | lOneNorm (const MatType &matrix) | 
|  | Return the L1 norm of an N×N matrix. 
 | 
|  | 
| template<typename MatType> | 
| bool | polarDecomposition (const MatType &input, MatType &unitary, MatType &positive_hermitian, unsigned int MAX_ITERATIONS=100) | 
|  | Decompose an invertible 3×3 matrix into a unitary matrix followed by a symmetric matrix (positive semi-definite Hermitian), i.e., M = U * S. 
 | 
|  | 
| template<unsigned SIZE, typename T> | 
| bool | cwiseLessThan (const Mat< SIZE, T > &m0, const Mat< SIZE, T > &m1) | 
|  | 
| template<unsigned SIZE, typename T> | 
| bool | cwiseGreaterThan (const Mat< SIZE, T > &m0, const Mat< SIZE, T > &m1) | 
|  | 
| template<typename T0, typename T1> | 
| Mat3< typename promote< T0, T1 >::type > | operator* (const Mat3< T0 > &m0, const Mat3< T1 > &m1) | 
|  | Multiply m0 by m1 and return the resulting matrix. 
 | 
|  | 
| template<typename T> | 
| Mat3< T > | outerProduct (const Vec3< T > &v1, const Vec3< T > &v2) | 
|  | 
| template<typename T, typename T0> | 
| Mat3< T > | powLerp (const Mat3< T0 > &m1, const Mat3< T0 > &m2, T t) | 
|  | 
| template<typename T> | 
| bool | diagonalizeSymmetricMatrix (const Mat3< T > &input, Mat3< T > &Q, Vec3< T > &D, unsigned int MAX_ITERATIONS=250) | 
|  | Use Jacobi iterations to decompose a symmetric 3x3 matrix (diagonalize and compute eigenvectors) 
 | 
|  | 
| template<typename T> | 
| Mat3< T > | Abs (const Mat3< T > &m) | 
|  | 
| template<typename Type1, typename Type2> | 
| Mat3< Type1 > | cwiseAdd (const Mat3< Type1 > &m, const Type2 s) | 
|  | 
| template<typename T> | 
| bool | cwiseLessThan (const Mat3< T > &m0, const Mat3< T > &m1) | 
|  | 
| template<typename T> | 
| bool | cwiseGreaterThan (const Mat3< T > &m0, const Mat3< T > &m1) | 
|  | 
| template<typename T0, typename T1> | 
| Vec3< T1 > | transformNormal (const Mat4< T0 > &m, const Vec3< T1 > &n) | 
|  | 
| template<typename T> | 
| bool | isAffine (const Mat4< T > &m) | 
|  | 
| template<typename T> | 
| bool | hasTranslation (const Mat4< T > &m) | 
|  | 
| template<typename T> | 
| Mat4< T > | Abs (const Mat4< T > &m) | 
|  | 
| template<typename Type1, typename Type2> | 
| Mat4< Type1 > | cwiseAdd (const Mat4< Type1 > &m, const Type2 s) | 
|  | 
| template<typename T> | 
| bool | cwiseLessThan (const Mat4< T > &m0, const Mat4< T > &m1) | 
|  | 
| template<typename T> | 
| bool | cwiseGreaterThan (const Mat4< T > &m0, const Mat4< T > &m1) | 
|  | 
| std::string | operator+ (const std::string &s, bool) | 
|  | Needed to support the (zeroVal<ValueType>() + val)idiom whenValueTypeisstd::string.
 | 
|  | 
| std::string | operator+ (const std::string &s, int) | 
|  | 
| std::string | operator+ (const std::string &s, float) | 
|  | 
| std::string | operator+ (const std::string &s, double) | 
|  | 
| template<typename Type1, typename Type2> | 
| auto | cwiseAdd (const Type1 &v, const Type2 s) | 
|  | Componentwise adder for POD types. 
 | 
|  | 
| template<typename Type1, typename Type2> | 
| bool | cwiseLessThan (const Type1 &a, const Type2 &b) | 
|  | Componentwise less than for POD types. 
 | 
|  | 
| template<typename Type1, typename Type2> | 
| bool | cwiseGreaterThan (const Type1 &a, const Type2 &b) | 
|  | Componentwise greater than for POD types. 
 | 
|  | 
| template<typename T> | 
| constexpr T | pi () | 
|  | Pi constant taken from Boost to match old behaviour. 
 | 
|  | 
| template<> | 
| constexpr float | pi () | 
|  | 
| template<> | 
| constexpr double | pi () | 
|  | 
| template<> | 
| constexpr long double | pi () | 
|  | 
| template<typename T> | 
| T | negative (const T &val) | 
|  | Return the unary negation of the given value. 
 | 
|  | 
| template<> | 
| bool | negative (const bool &val) | 
|  | Return the negation of the given boolean. 
 | 
|  | 
| template<> | 
| std::string | negative (const std::string &val) | 
|  | Return the "negation" of the given string. 
 | 
|  | 
| template<typename Type> | 
| Type | Clamp (Type x, Type min, Type max) | 
|  | Return x clamped to [min, max]. 
 | 
|  | 
| template<typename Type> | 
| Type | Clamp01 (Type x) | 
|  | Return x clamped to [0, 1]. 
 | 
|  | 
| template<typename Type> | 
| bool | ClampTest01 (Type &x) | 
|  | Return trueif x is outside [0,1].
 | 
|  | 
| template<typename Type> | 
| Type | SmoothUnitStep (Type x) | 
|  | Return 0 if x < 0, 1 if x > 1 or else (3 − 2 x) x². 
 | 
|  | 
| template<typename Type> | 
| Type | SmoothUnitStep (Type x, Type min, Type max) | 
|  | Return 0 if x < min, 1 if x > max or else (3 − 2 t) t², where t = (x − min)/(max − min). 
 | 
|  | 
| int32_t | Abs (int32_t i) | 
|  | Return the absolute value of the given quantity. 
 | 
|  | 
| int64_t | Abs (int64_t i) | 
|  | 
| float | Abs (float x) | 
|  | 
| double | Abs (double x) | 
|  | 
| long double | Abs (long double x) | 
|  | 
| uint32_t | Abs (uint32_t i) | 
|  | 
| uint64_t | Abs (uint64_t i) | 
|  | 
| bool | Abs (bool b) | 
|  | 
| template<typename T> | 
| std::enable_if< std::is_same< T, size_t >::value, T >::type | Abs (T i) | 
|  | 
| template<typename Type> | 
| bool | isZero (const Type &x) | 
|  | Return trueif x is exactly equal to zero.
 | 
|  | 
| template<typename Type> | 
| bool | isApproxZero (const Type &x) | 
|  | Return trueif x is equal to zero to within the default floating-point comparison tolerance.
 | 
|  | 
| template<typename Type> | 
| bool | isApproxZero (const Type &x, const Type &tolerance) | 
|  | Return trueif x is equal to zero to within the given tolerance.
 | 
|  | 
| template<typename Type> | 
| bool | isNegative (const Type &x) | 
|  | Return trueif x is less than zero.
 | 
|  | 
| template<> | 
| bool | isNegative< bool > (const bool &) | 
|  | 
| bool | isFinite (const float x) | 
|  | Return trueif x is finite.
 | 
|  | 
| template<typename Type, typename std::enable_if< std::is_arithmetic< Type >::value, int >::type = 0> | 
| bool | isFinite (const Type &x) | 
|  | Return trueif x is finite.
 | 
|  | 
| bool | isInfinite (const float x) | 
|  | Return trueif x is an infinity value (either positive infinity or negative infinity).
 | 
|  | 
| template<typename Type, typename std::enable_if< std::is_arithmetic< Type >::value, int >::type = 0> | 
| bool | isInfinite (const Type &x) | 
|  | Return trueif x is an infinity value (either positive infinity or negative infinity).
 | 
|  | 
| bool | isNan (const float x) | 
|  | Return trueif x is a NaN (Not-A-Number) value.
 | 
|  | 
| template<typename Type, typename std::enable_if< std::is_arithmetic< Type >::value, int >::type = 0> | 
| bool | isNan (const Type &x) | 
|  | Return trueif x is a NaN (Not-A-Number) value.
 | 
|  | 
| template<typename Type> | 
| bool | isApproxEqual (const Type &a, const Type &b, const Type &tolerance) | 
|  | Return trueif a is equal to b to within the given tolerance.
 | 
|  | 
| template<typename Type> | 
| bool | isApproxEqual (const Type &a, const Type &b) | 
|  | Return trueif a is equal to b to within the default floating-point comparison tolerance.
 | 
|  | 
| template<> | 
| bool | isApproxEqual< bool > (const bool &a, const bool &b) | 
|  | 
| template<> | 
| bool | isApproxEqual< bool > (const bool &a, const bool &b, const bool &) | 
|  | 
| template<> | 
| bool | isApproxEqual< std::string > (const std::string &a, const std::string &b) | 
|  | 
| template<> | 
| bool | isApproxEqual< std::string > (const std::string &a, const std::string &b, const std::string &) | 
|  | 
| template<typename Type> | 
| bool | isApproxLarger (const Type &a, const Type &b, const Type &tolerance) | 
|  | Return trueif a is larger than b to within the given tolerance, i.e., if b - a < tolerance.
 | 
|  | 
| template<typename T0, typename T1> | 
| bool | isExactlyEqual (const T0 &a, const T1 &b) | 
|  | Return trueif a is exactly equal to b.
 | 
|  | 
| template<typename Type> | 
| bool | isRelOrApproxEqual (const Type &a, const Type &b, const Type &absTol, const Type &relTol) | 
|  | 
| template<> | 
| bool | isRelOrApproxEqual (const bool &a, const bool &b, const bool &, const bool &) | 
|  | 
| int32_t | floatToInt32 (const float f) | 
|  | 
| int64_t | doubleToInt64 (const double d) | 
|  | 
| bool | isUlpsEqual (const double aLeft, const double aRight, const int64_t aUnitsInLastPlace) | 
|  | 
| bool | isUlpsEqual (const float aLeft, const float aRight, const int32_t aUnitsInLastPlace) | 
|  | 
| template<typename Type> | 
| Type | Pow2 (Type x) | 
|  | Return x2. 
 | 
|  | 
| template<typename Type> | 
| Type | Pow3 (Type x) | 
|  | Return x3. 
 | 
|  | 
| template<typename Type> | 
| Type | Pow4 (Type x) | 
|  | Return x4. 
 | 
|  | 
| template<typename Type> | 
| Type | Pow (Type x, int n) | 
|  | Return xn. 
 | 
|  | 
| float | Pow (float b, float e) | 
|  | Return be. 
 | 
|  | 
| double | Pow (double b, double e) | 
|  | 
| template<typename Type> | 
| const Type & | Max (const Type &a, const Type &b) | 
|  | Return the maximum of two values. 
 | 
|  | 
| template<typename Type> | 
| const Type & | Max (const Type &a, const Type &b, const Type &c) | 
|  | Return the maximum of three values. 
 | 
|  | 
| template<typename Type> | 
| const Type & | Max (const Type &a, const Type &b, const Type &c, const Type &d) | 
|  | Return the maximum of four values. 
 | 
|  | 
| template<typename Type> | 
| const Type & | Max (const Type &a, const Type &b, const Type &c, const Type &d, const Type &e) | 
|  | Return the maximum of five values. 
 | 
|  | 
| template<typename Type> | 
| const Type & | Max (const Type &a, const Type &b, const Type &c, const Type &d, const Type &e, const Type &f) | 
|  | Return the maximum of six values. 
 | 
|  | 
| template<typename Type> | 
| const Type & | Max (const Type &a, const Type &b, const Type &c, const Type &d, const Type &e, const Type &f, const Type &g) | 
|  | Return the maximum of seven values. 
 | 
|  | 
| template<typename Type> | 
| const Type & | Max (const Type &a, const Type &b, const Type &c, const Type &d, const Type &e, const Type &f, const Type &g, const Type &h) | 
|  | Return the maximum of eight values. 
 | 
|  | 
| template<typename Type> | 
| const Type & | Min (const Type &a, const Type &b) | 
|  | Return the minimum of two values. 
 | 
|  | 
| template<typename Type> | 
| const Type & | Min (const Type &a, const Type &b, const Type &c) | 
|  | Return the minimum of three values. 
 | 
|  | 
| template<typename Type> | 
| const Type & | Min (const Type &a, const Type &b, const Type &c, const Type &d) | 
|  | Return the minimum of four values. 
 | 
|  | 
| template<typename Type> | 
| const Type & | Min (const Type &a, const Type &b, const Type &c, const Type &d, const Type &e) | 
|  | Return the minimum of five values. 
 | 
|  | 
| template<typename Type> | 
| const Type & | Min (const Type &a, const Type &b, const Type &c, const Type &d, const Type &e, const Type &f) | 
|  | Return the minimum of six values. 
 | 
|  | 
| template<typename Type> | 
| const Type & | Min (const Type &a, const Type &b, const Type &c, const Type &d, const Type &e, const Type &f, const Type &g) | 
|  | Return the minimum of seven values. 
 | 
|  | 
| template<typename Type> | 
| const Type & | Min (const Type &a, const Type &b, const Type &c, const Type &d, const Type &e, const Type &f, const Type &g, const Type &h) | 
|  | Return the minimum of eight values. 
 | 
|  | 
| template<typename Type> | 
| Type | Exp (const Type &x) | 
|  | Return ex. 
 | 
|  | 
| float | Sin (const float &x) | 
|  | Return sin x. 
 | 
|  | 
| double | Sin (const double &x) | 
|  | 
| float | Cos (const float &x) | 
|  | Return cos x. 
 | 
|  | 
| double | Cos (const double &x) | 
|  | 
| template<typename Type> | 
| int | Sign (const Type &x) | 
|  | Return the sign of the given value as an integer (either -1, 0 or 1). 
 | 
|  | 
| template<typename Type> | 
| bool | SignChange (const Type &a, const Type &b) | 
|  | Return trueif a and b have different signs.
 | 
|  | 
| template<typename Type> | 
| bool | ZeroCrossing (const Type &a, const Type &b) | 
|  | Return trueif the interval [a, b] includes zero, i.e., if either a or b is zero or if they have different signs.
 | 
|  | 
| float | Sqrt (float x) | 
|  | Return the square root of a floating-point value. 
 | 
|  | 
| double | Sqrt (double x) | 
|  | 
| long double | Sqrt (long double x) | 
|  | 
| float | Cbrt (float x) | 
|  | Return the cube root of a floating-point value. 
 | 
|  | 
| double | Cbrt (double x) | 
|  | 
| long double | Cbrt (long double x) | 
|  | 
| int | Mod (int x, int y) | 
|  | Return the remainder of x / y. 
 | 
|  | 
| float | Mod (float x, float y) | 
|  | 
| double | Mod (double x, double y) | 
|  | 
| long double | Mod (long double x, long double y) | 
|  | 
| template<typename Type> | 
| Type | Remainder (Type x, Type y) | 
|  | 
| float | RoundUp (float x) | 
|  | Return x rounded up to the nearest integer. 
 | 
|  | 
| double | RoundUp (double x) | 
|  | 
| long double | RoundUp (long double x) | 
|  | 
| template<typename Type> | 
| Type | RoundUp (Type x, Type base) | 
|  | Return x rounded up to the nearest multiple of base. 
 | 
|  | 
| float | RoundDown (float x) | 
|  | Return x rounded down to the nearest integer. 
 | 
|  | 
| double | RoundDown (double x) | 
|  | 
| long double | RoundDown (long double x) | 
|  | 
| template<typename Type> | 
| Type | RoundDown (Type x, Type base) | 
|  | Return x rounded down to the nearest multiple of base. 
 | 
|  | 
| float | Round (float x) | 
|  | Return x rounded to the nearest integer. 
 | 
|  | 
| double | Round (double x) | 
|  | 
| long double | Round (long double x) | 
|  | 
| template<typename Type> | 
| Type | EuclideanRemainder (Type x) | 
|  | 
| template<typename Type> | 
| Type | IntegerPart (Type x) | 
|  | Return the integer part of x. 
 | 
|  | 
| template<typename Type> | 
| Type | FractionalPart (Type x) | 
|  | Return the fractional part of x. 
 | 
|  | 
| int | Floor (float x) | 
|  | Return the floor of x. 
 | 
|  | 
| int | Floor (double x) | 
|  | 
| int | Floor (long double x) | 
|  | 
| int | Ceil (float x) | 
|  | Return the ceiling of x. 
 | 
|  | 
| int | Ceil (double x) | 
|  | 
| int | Ceil (long double x) | 
|  | 
| template<typename Type> | 
| Type | Chop (Type x, Type delta) | 
|  | Return x if it is greater or equal in magnitude than delta. Otherwise, return zero. 
 | 
|  | 
| template<typename Type> | 
| Type | Truncate (Type x, unsigned int digits) | 
|  | Return x truncated to the given number of decimal digits. 
 | 
|  | 
| template<typename T> | 
| auto | PrintCast (const T &val) -> typename std::enable_if<!std::is_same< T, int8_t >::value &&!std::is_same< T, uint8_t >::value, const T & >::type | 
|  | 8-bit integer values print to std::ostreams as characters. Cast them so that they print as integers instead. 
 | 
|  | 
| int32_t | PrintCast (int8_t val) | 
|  | 
| uint32_t | PrintCast (uint8_t val) | 
|  | 
| template<typename Type> | 
| Type | Inv (Type x) | 
|  | Return the inverse of x. 
 | 
|  | 
| template<typename Vec3T> | 
| size_t | MinIndex (const Vec3T &v) | 
|  | Return the index [0,1,2] of the smallest value in a 3D vector. 
 | 
|  | 
| template<typename Vec3T> | 
| size_t | MaxIndex (const Vec3T &v) | 
|  | Return the index [0,1,2] of the largest value in a 3D vector. 
 | 
|  | 
| OPENVDB_API Vec3d | closestPointOnTriangleToPoint (const Vec3d &a, const Vec3d &b, const Vec3d &c, const Vec3d &p, Vec3d &uvw) | 
|  | Closest Point on Triangle to Point. Given a triangle abcand a pointp, return the point onabcclosest topand the corresponding barycentric coordinates.
 | 
|  | 
| OPENVDB_API Vec3d | closestPointOnSegmentToPoint (const Vec3d &a, const Vec3d &b, const Vec3d &p, double &t) | 
|  | Closest Point on Line Segment to Point. Given segment aband pointp, return the point onabclosest topandtthe parametric distance tob.
 | 
|  | 
| template<typename T> | 
| Quat< T > | slerp (const Quat< T > &q1, const Quat< T > &q2, T t, T tolerance=0.00001) | 
|  | Linear interpolation between the two quaternions. 
 | 
|  | 
| template<typename S, typename T> | 
| Quat< T > | operator* (S scalar, const Quat< T > &q) | 
|  | Multiply each element of the given quaternion by scalar and return the result. 
 | 
|  | 
| template<typename T, typename T0> | 
| Mat3< T > | slerp (const Mat3< T0 > &m1, const Mat3< T0 > &m2, T t) | 
|  | Interpolate between m1 and m2. Converts to quaternion form and uses slerp m1 and m2 must be rotation matrices! 
 | 
|  | 
| template<typename T, typename T0> | 
| Mat3< T > | bezLerp (const Mat3< T0 > &m1, const Mat3< T0 > &m2, const Mat3< T0 > &m3, const Mat3< T0 > &m4, T t) | 
|  | 
| template<typename RealT> | 
| std::ostream & | operator<< (std::ostream &os, const Ray< RealT > &r) | 
|  | Output streaming of the Ray class. 
 | 
|  | 
| OPENVDB_API void | calculateBounds (const Transform &t, const Vec3d &minWS, const Vec3d &maxWS, Vec3d &minIS, Vec3d &maxIS) | 
|  | Calculate an axis-aligned bounding box in index space from an axis-aligned bounding box in world space. 
 | 
|  | 
| OPENVDB_API std::ostream & | operator<< (std::ostream &, const Transform &) | 
|  | 
| template<typename ResolvedMapType, typename OpType> | 
| void | doProcessTypedMap (Transform &transform, OpType &op) | 
|  | Helper function used internally by processTypedMap() 
 | 
|  | 
| template<typename ResolvedMapType, typename OpType> | 
| void | doProcessTypedMap (const Transform &transform, OpType &op) | 
|  | Helper function used internally by processTypedMap() 
 | 
|  | 
| template<typename TransformType, typename OpType> | 
| bool | processTypedMap (TransformType &transform, OpType &op) | 
|  | Utility function that, given a generic map pointer, calls a functor on the fully-resoved map. 
 | 
|  | 
| template<int SIZE, typename T0, typename T1> | 
| bool | operator< (const Tuple< SIZE, T0 > &t0, const Tuple< SIZE, T1 > &t1) | 
|  | 
| template<int SIZE, typename T0, typename T1> | 
| bool | operator> (const Tuple< SIZE, T0 > &t0, const Tuple< SIZE, T1 > &t1) | 
|  | 
| template<int SIZE, typename T> | 
| Tuple< SIZE, T > | Abs (const Tuple< SIZE, T > &t) | 
|  | 
| template<int SIZE, typename T> | 
| bool | isNan (const Tuple< SIZE, T > &t) | 
|  | Return trueif a Nan is present in the tuple.
 | 
|  | 
| template<int SIZE, typename T> | 
| bool | isInfinite (const Tuple< SIZE, T > &t) | 
|  | Return trueif an Inf is present in the tuple.
 | 
|  | 
| template<int SIZE, typename T> | 
| bool | isFinite (const Tuple< SIZE, T > &t) | 
|  | Return trueif no Nan or Inf values are present.
 | 
|  | 
| template<int SIZE, typename T> | 
| bool | isZero (const Tuple< SIZE, T > &t) | 
|  | Return trueif all elements are exactly equal to zero.
 | 
|  | 
| template<int SIZE, typename T> | 
| std::ostream & | operator<< (std::ostream &ostr, const Tuple< SIZE, T > &classname) | 
|  | Write a Tuple to an output stream. 
 | 
|  | 
| template<typename S, typename T> | 
| Vec2< typename promote< S, T >::type > | operator* (S scalar, const Vec2< T > &v) | 
|  | Multiply each element of the given vector by scalar and return the result. 
 | 
|  | 
| template<typename S, typename T> | 
| Vec2< typename promote< S, T >::type > | operator* (const Vec2< T > &v, S scalar) | 
|  | Multiply each element of the given vector by scalar and return the result. 
 | 
|  | 
| template<typename T0, typename T1> | 
| Vec2< typename promote< T0, T1 >::type > | operator* (const Vec2< T0 > &v0, const Vec2< T1 > &v1) | 
|  | Multiply corresponding elements of v0 and v1 and return the result. 
 | 
|  | 
| template<typename S, typename T> | 
| Vec2< typename promote< S, T >::type > | operator/ (S scalar, const Vec2< T > &v) | 
|  | Divide scalar by each element of the given vector and return the result. 
 | 
|  | 
| template<typename S, typename T> | 
| Vec2< typename promote< S, T >::type > | operator/ (const Vec2< T > &v, S scalar) | 
|  | Divide each element of the given vector by scalar and return the result. 
 | 
|  | 
| template<typename T0, typename T1> | 
| Vec2< typename promote< T0, T1 >::type > | operator/ (const Vec2< T0 > &v0, const Vec2< T1 > &v1) | 
|  | Divide corresponding elements of v0 and v1 and return the result. 
 | 
|  | 
| template<typename T0, typename T1> | 
| Vec2< typename promote< T0, T1 >::type > | operator+ (const Vec2< T0 > &v0, const Vec2< T1 > &v1) | 
|  | Add corresponding elements of v0 and v1 and return the result. 
 | 
|  | 
| template<typename S, typename T> | 
| Vec2< typename promote< S, T >::type > | operator+ (const Vec2< T > &v, S scalar) | 
|  | Add scalar to each element of the given vector and return the result. 
 | 
|  | 
| template<typename T0, typename T1> | 
| Vec2< typename promote< T0, T1 >::type > | operator- (const Vec2< T0 > &v0, const Vec2< T1 > &v1) | 
|  | Subtract corresponding elements of v0 and v1 and return the result. 
 | 
|  | 
| template<typename S, typename T> | 
| Vec2< typename promote< S, T >::type > | operator- (const Vec2< T > &v, S scalar) | 
|  | Subtract scalar from each element of the given vector and return the result. 
 | 
|  | 
| template<typename T> | 
| T | angle (const Vec2< T > &v1, const Vec2< T > &v2) | 
|  | 
| template<typename T> | 
| bool | isApproxEqual (const Vec2< T > &a, const Vec2< T > &b) | 
|  | 
| template<typename T> | 
| bool | isApproxEqual (const Vec2< T > &a, const Vec2< T > &b, const Vec2< T > &eps) | 
|  | 
| template<typename T> | 
| Vec2< T > | Abs (const Vec2< T > &v) | 
|  | 
| template<typename T> | 
| void | orthonormalize (Vec2< T > &v1, Vec2< T > &v2) | 
|  | 
| template<typename T> | 
| Vec2< T > | minComponent (const Vec2< T > &v1, const Vec2< T > &v2) | 
|  | Return component-wise minimum of the two vectors. 
 | 
|  | 
| template<typename T> | 
| Vec2< T > | maxComponent (const Vec2< T > &v1, const Vec2< T > &v2) | 
|  | Return component-wise maximum of the two vectors. 
 | 
|  | 
| template<typename T> | 
| Vec2< T > | Exp (Vec2< T > v) | 
|  | Return a vector with the exponent applied to each of the components of the input vector. 
 | 
|  | 
| template<typename T> | 
| Vec2< T > | Log (Vec2< T > v) | 
|  | Return a vector with log applied to each of the components of the input vector. 
 | 
|  | 
| template<typename T0, typename T1> | 
| bool | operator== (const Vec3< T0 > &v0, const Vec3< T1 > &v1) | 
|  | Equality operator, does exact floating point comparisons. 
 | 
|  | 
| template<typename T0, typename T1> | 
| bool | operator!= (const Vec3< T0 > &v0, const Vec3< T1 > &v1) | 
|  | Inequality operator, does exact floating point comparisons. 
 | 
|  | 
| template<typename S, typename T> | 
| Vec3< typename promote< S, T >::type > | operator* (S scalar, const Vec3< T > &v) | 
|  | Multiply each element of the given vector by scalar and return the result. 
 | 
|  | 
| template<typename S, typename T> | 
| Vec3< typename promote< S, T >::type > | operator* (const Vec3< T > &v, S scalar) | 
|  | Multiply each element of the given vector by scalar and return the result. 
 | 
|  | 
| template<typename T0, typename T1> | 
| Vec3< typename promote< T0, T1 >::type > | operator* (const Vec3< T0 > &v0, const Vec3< T1 > &v1) | 
|  | Multiply corresponding elements of v0 and v1 and return the result. 
 | 
|  | 
| template<typename S, typename T> | 
| Vec3< typename promote< S, T >::type > | operator/ (S scalar, const Vec3< T > &v) | 
|  | Divide scalar by each element of the given vector and return the result. 
 | 
|  | 
| template<typename S, typename T> | 
| Vec3< typename promote< S, T >::type > | operator/ (const Vec3< T > &v, S scalar) | 
|  | Divide each element of the given vector by scalar and return the result. 
 | 
|  | 
| template<typename T0, typename T1> | 
| Vec3< typename promote< T0, T1 >::type > | operator/ (const Vec3< T0 > &v0, const Vec3< T1 > &v1) | 
|  | Divide corresponding elements of v0 and v1 and return the result. 
 | 
|  | 
| template<typename T0, typename T1> | 
| Vec3< typename promote< T0, T1 >::type > | operator+ (const Vec3< T0 > &v0, const Vec3< T1 > &v1) | 
|  | Add corresponding elements of v0 and v1 and return the result. 
 | 
|  | 
| template<typename S, typename T> | 
| Vec3< typename promote< S, T >::type > | operator+ (const Vec3< T > &v, S scalar) | 
|  | Add scalar to each element of the given vector and return the result. 
 | 
|  | 
| template<typename T0, typename T1> | 
| Vec3< typename promote< T0, T1 >::type > | operator- (const Vec3< T0 > &v0, const Vec3< T1 > &v1) | 
|  | Subtract corresponding elements of v0 and v1 and return the result. 
 | 
|  | 
| template<typename S, typename T> | 
| Vec3< typename promote< S, T >::type > | operator- (const Vec3< T > &v, S scalar) | 
|  | Subtract scalar from each element of the given vector and return the result. 
 | 
|  | 
| template<typename T> | 
| T | angle (const Vec3< T > &v1, const Vec3< T > &v2) | 
|  | 
| template<typename T> | 
| bool | isApproxEqual (const Vec3< T > &a, const Vec3< T > &b) | 
|  | 
| template<typename T> | 
| bool | isApproxEqual (const Vec3< T > &a, const Vec3< T > &b, const Vec3< T > &eps) | 
|  | 
| template<typename T> | 
| Vec3< T > | Abs (const Vec3< T > &v) | 
|  | 
| template<typename T> | 
| void | orthonormalize (Vec3< T > &v1, Vec3< T > &v2, Vec3< T > &v3) | 
|  | 
| template<typename T> | 
| Vec3< T > | minComponent (const Vec3< T > &v1, const Vec3< T > &v2) | 
|  | Return component-wise minimum of the two vectors. 
 | 
|  | 
| template<typename T> | 
| Vec3< T > | maxComponent (const Vec3< T > &v1, const Vec3< T > &v2) | 
|  | Return component-wise maximum of the two vectors. 
 | 
|  | 
| template<typename T> | 
| Vec3< T > | Exp (Vec3< T > v) | 
|  | Return a vector with the exponent applied to each of the components of the input vector. 
 | 
|  | 
| template<typename T> | 
| Vec3< T > | Log (Vec3< T > v) | 
|  | Return a vector with log applied to each of the components of the input vector. 
 | 
|  | 
| template<typename T0, typename T1> | 
| bool | operator== (const Vec4< T0 > &v0, const Vec4< T1 > &v1) | 
|  | Equality operator, does exact floating point comparisons. 
 | 
|  | 
| template<typename T0, typename T1> | 
| bool | operator!= (const Vec4< T0 > &v0, const Vec4< T1 > &v1) | 
|  | Inequality operator, does exact floating point comparisons. 
 | 
|  | 
| template<typename S, typename T> | 
| Vec4< typename promote< S, T >::type > | operator* (S scalar, const Vec4< T > &v) | 
|  | Multiply each element of the given vector by scalar and return the result. 
 | 
|  | 
| template<typename S, typename T> | 
| Vec4< typename promote< S, T >::type > | operator* (const Vec4< T > &v, S scalar) | 
|  | Multiply each element of the given vector by scalar and return the result. 
 | 
|  | 
| template<typename T0, typename T1> | 
| Vec4< typename promote< T0, T1 >::type > | operator* (const Vec4< T0 > &v0, const Vec4< T1 > &v1) | 
|  | Multiply corresponding elements of v0 and v1 and return the result. 
 | 
|  | 
| template<typename S, typename T> | 
| Vec4< typename promote< S, T >::type > | operator/ (S scalar, const Vec4< T > &v) | 
|  | Divide scalar by each element of the given vector and return the result. 
 | 
|  | 
| template<typename S, typename T> | 
| Vec4< typename promote< S, T >::type > | operator/ (const Vec4< T > &v, S scalar) | 
|  | Divide each element of the given vector by scalar and return the result. 
 | 
|  | 
| template<typename T0, typename T1> | 
| Vec4< typename promote< T0, T1 >::type > | operator/ (const Vec4< T0 > &v0, const Vec4< T1 > &v1) | 
|  | Divide corresponding elements of v0 and v1 and return the result. 
 | 
|  | 
| template<typename T0, typename T1> | 
| Vec4< typename promote< T0, T1 >::type > | operator+ (const Vec4< T0 > &v0, const Vec4< T1 > &v1) | 
|  | Add corresponding elements of v0 and v1 and return the result. 
 | 
|  | 
| template<typename S, typename T> | 
| Vec4< typename promote< S, T >::type > | operator+ (const Vec4< T > &v, S scalar) | 
|  | Add scalar to each element of the given vector and return the result. 
 | 
|  | 
| template<typename T0, typename T1> | 
| Vec4< typename promote< T0, T1 >::type > | operator- (const Vec4< T0 > &v0, const Vec4< T1 > &v1) | 
|  | Subtract corresponding elements of v0 and v1 and return the result. 
 | 
|  | 
| template<typename S, typename T> | 
| Vec4< typename promote< S, T >::type > | operator- (const Vec4< T > &v, S scalar) | 
|  | Subtract scalar from each element of the given vector and return the result. 
 | 
|  | 
| template<typename T> | 
| bool | isApproxEqual (const Vec4< T > &a, const Vec4< T > &b) | 
|  | 
| template<typename T> | 
| bool | isApproxEqual (const Vec4< T > &a, const Vec4< T > &b, const Vec4< T > &eps) | 
|  | 
| template<typename T> | 
| Vec4< T > | Abs (const Vec4< T > &v) | 
|  | 
| template<typename T> | 
| Vec4< T > | minComponent (const Vec4< T > &v1, const Vec4< T > &v2) | 
|  | Return component-wise minimum of the two vectors. 
 | 
|  | 
| template<typename T> | 
| Vec4< T > | maxComponent (const Vec4< T > &v1, const Vec4< T > &v2) | 
|  | Return component-wise maximum of the two vectors. 
 | 
|  | 
| template<typename T> | 
| Vec4< T > | Exp (Vec4< T > v) | 
|  | Return a vector with the exponent applied to each of the components of the input vector. 
 | 
|  | 
| template<typename T> | 
| Vec4< T > | Log (Vec4< T > v) | 
|  | Return a vector with log applied to each of the components of the input vector. 
 | 
|  | 
| template<typename T0, typename T1> | 
| bool | operator== (const Mat3< T0 > &m0, const Mat3< T1 > &m1) | 
|  | Equality operator, does exact floating point comparisons. 
 | 
|  | 
| template<typename T0, typename T1> | 
| bool | operator!= (const Mat3< T0 > &m0, const Mat3< T1 > &m1) | 
|  | Inequality operator, does exact floating point comparisons. 
 | 
|  | 
| template<typename S, typename T> | 
| Mat3< typename promote< S, T >::type > | operator* (S scalar, const Mat3< T > &m) | 
|  | Multiply each element of the given matrix by scalar and return the result. 
 | 
|  | 
| template<typename S, typename T> | 
| Mat3< typename promote< S, T >::type > | operator* (const Mat3< T > &m, S scalar) | 
|  | Multiply each element of the given matrix by scalar and return the result. 
 | 
|  | 
| template<typename T0, typename T1> | 
| Mat3< typename promote< T0, T1 >::type > | operator+ (const Mat3< T0 > &m0, const Mat3< T1 > &m1) | 
|  | Add corresponding elements of m0 and m1 and return the result. 
 | 
|  | 
| template<typename T0, typename T1> | 
| Mat3< typename promote< T0, T1 >::type > | operator- (const Mat3< T0 > &m0, const Mat3< T1 > &m1) | 
|  | Subtract corresponding elements of m0 and m1 and return the result. 
 | 
|  | 
| template<typename T, typename MT> | 
| Vec3< typename promote< T, MT >::type > | operator* (const Mat3< MT > &_m, const Vec3< T > &_v) | 
|  | Multiply _m by _v and return the resulting vector. 
 | 
|  | 
| template<typename T, typename MT> | 
| Vec3< typename promote< T, MT >::type > | operator* (const Vec3< T > &_v, const Mat3< MT > &_m) | 
|  | Multiply _v by _m and return the resulting vector. 
 | 
|  | 
| template<typename T, typename MT> | 
| Vec3< T > & | operator*= (Vec3< T > &_v, const Mat3< MT > &_m) | 
|  | Multiply _v by _m and replace _v with the resulting vector. 
 | 
|  | 
| template<typename T0, typename T1> | 
| bool | operator== (const Mat4< T0 > &m0, const Mat4< T1 > &m1) | 
|  | Equality operator, does exact floating point comparisons. 
 | 
|  | 
| template<typename T0, typename T1> | 
| bool | operator!= (const Mat4< T0 > &m0, const Mat4< T1 > &m1) | 
|  | Inequality operator, does exact floating point comparisons. 
 | 
|  | 
| template<typename S, typename T> | 
| Mat4< typename promote< S, T >::type > | operator* (S scalar, const Mat4< T > &m) | 
|  | Multiply each element of the given matrix by scalar and return the result. 
 | 
|  | 
| template<typename S, typename T> | 
| Mat4< typename promote< S, T >::type > | operator* (const Mat4< T > &m, S scalar) | 
|  | Multiply each element of the given matrix by scalar and return the result. 
 | 
|  | 
| template<typename T, typename MT> | 
| Vec4< typename promote< T, MT >::type > | operator* (const Mat4< MT > &_m, const Vec4< T > &_v) | 
|  | Multiply _m by _v and return the resulting vector. 
 | 
|  | 
| template<typename T, typename MT> | 
| Vec4< typename promote< T, MT >::type > | operator* (const Vec4< T > &_v, const Mat4< MT > &_m) | 
|  | Multiply _v by _m and return the resulting vector. 
 | 
|  | 
| template<typename T, typename MT> | 
| Vec3< typename promote< T, MT >::type > | operator* (const Mat4< MT > &_m, const Vec3< T > &_v) | 
|  | Multiply _m by _v and return the resulting vector. 
 | 
|  | 
| template<typename T, typename MT> | 
| Vec3< typename promote< T, MT >::type > | operator* (const Vec3< T > &_v, const Mat4< MT > &_m) | 
|  | Multiply _v by _m and return the resulting vector. 
 | 
|  | 
| template<typename T0, typename T1> | 
| Mat4< typename promote< T0, T1 >::type > | operator+ (const Mat4< T0 > &m0, const Mat4< T1 > &m1) | 
|  | Add corresponding elements of m0 and m1 and return the result. 
 | 
|  | 
| template<typename T0, typename T1> | 
| Mat4< typename promote< T0, T1 >::type > | operator- (const Mat4< T0 > &m0, const Mat4< T1 > &m1) | 
|  | Subtract corresponding elements of m0 and m1 and return the result. 
 | 
|  | 
| template<typename T0, typename T1> | 
| Mat4< typename promote< T0, T1 >::type > | operator* (const Mat4< T0 > &m0, const Mat4< T1 > &m1) | 
|  | Multiply m0 by m1 and return the resulting matrix. 
 | 
|  |