8#ifndef OPENVDB_MATH_HAS_BEEN_INCLUDED 
    9#define OPENVDB_MATH_HAS_BEEN_INCLUDED 
   12#include <openvdb/version.h> 
   28#if defined(__INTEL_COMPILER) 
   29    #define OPENVDB_NO_FP_EQUALITY_WARNING_BEGIN \ 
   30        _Pragma("warning (push)")    \ 
   31        _Pragma("warning (disable:1572)") 
   32    #define OPENVDB_NO_FP_EQUALITY_WARNING_END \ 
   33        _Pragma("warning (pop)") 
   34#elif defined(__clang__) 
   35    #define OPENVDB_NO_FP_EQUALITY_WARNING_BEGIN \ 
   36        PRAGMA(clang diagnostic push) \ 
   37        PRAGMA(clang diagnostic ignored "-Wfloat-equal") 
   38    #define OPENVDB_NO_FP_EQUALITY_WARNING_END \ 
   39        PRAGMA(clang diagnostic pop) 
   48    #define OPENVDB_NO_FP_EQUALITY_WARNING_BEGIN 
   49    #define OPENVDB_NO_FP_EQUALITY_WARNING_END 
   56#define OPENVDB_IS_POD(Type) \ 
   57static_assert(std::is_standard_layout<Type>::value, \ 
   58    #Type" must be a POD type (satisfy StandardLayoutType.)"); \ 
   59static_assert(std::is_trivial<Type>::value, \ 
   60    #Type" must be a POD type (satisfy TrivialType.)"); 
 
   70template<
typename T> 
inline constexpr T 
zeroVal() { 
return T(0); }
 
   82inline std::string 
operator+(
const std::string& s, 
bool) { 
return s; }
 
   83inline std::string 
operator+(
const std::string& s, 
int) { 
return s; }
 
   84inline std::string 
operator+(
const std::string& s, 
float) { 
return s; }
 
   85inline std::string 
operator+(
const std::string& s, 
double) { 
return s; }
 
   89template<
typename Type1, 
typename Type2>
 
   90inline auto cwiseAdd(
const Type1& v, 
const Type2 s)
 
 
   98template<
typename Type1, 
typename Type2>
 
  107template<
typename Type1, 
typename Type2>
 
  119template <
typename T> 
inline constexpr T 
pi() { 
return 3.141592653589793238462643383279502884e+00; }
 
  120template <> 
inline constexpr float pi() { 
return 3.141592653589793238462643383279502884e+00F; }
 
  121template <> 
inline constexpr double pi() { 
return 3.141592653589793238462643383279502884e+00; }
 
  122template <> 
inline constexpr long double pi() { 
return 3.141592653589793238462643383279502884e+00L; }
 
  128template<
typename T> 
inline T 
negative(
const T& val)
 
  133#pragma warning(disable:4146) 
 
  141template<> 
inline bool negative(
const bool& val) { 
return !val; }
 
  143template<> 
inline std::string 
negative(
const std::string& val) { 
return val; }
 
  156template<> 
struct Delta<float>    { 
static float value() { 
return  1e-5f; } };
 
  157template<> 
struct Delta<double>   { 
static double value() { 
return 1e-9; } };
 
  165template<
typename FloatType = 
double, 
typename EngineType = std::mt19937>
 
  170    std::uniform_real_distribution<FloatType> mRand;
 
  181    Rand01(
unsigned int seed): mEngine(static_cast<typename EngineType::result_type>(seed)) {}
 
  186        mEngine.seed(
static_cast<typename EngineType::result_type
>(seed));
 
 
  190    const EngineType& 
engine()
 const { 
return mEngine; }
 
 
  201template<
typename IntType = 
int, 
typename EngineType = std::mt19937>
 
  205    using Distr = std::uniform_int_distribution<IntType>;
 
  215        mRand(
std::min(imin, imax), 
std::max(imin, imax))
 
 
  221    RandInt(
unsigned int seed, IntType imin, IntType imax):
 
  222        mEngine(static_cast<typename EngineType::result_type>(seed)),
 
  223        mRand(
std::min(imin, imax), 
std::max(imin, imax))
 
 
  229        mRand = Distr(std::min(imin, imax), std::max(imin, imax));
 
 
  235        mEngine.seed(
static_cast<typename EngineType::result_type
>(seed));
 
 
  239    const EngineType& 
engine()
 const { 
return mEngine; }
 
  248        const IntType lo = std::min(imin, imax), hi = std::max(imin, imax);
 
  249        return mRand(mEngine, 
typename Distr::param_type(lo, hi));
 
 
 
  259template<
typename Type>
 
  264    return x > min ? x < max ? x : max : min;
 
 
  269template<
typename Type>
 
  271Clamp01(Type x) { 
return x > Type(0) ? x < Type(1) ? x : Type(1) : Type(0); }
 
  275template<
typename Type>
 
  279    if (x >= Type(0) && x <= Type(1)) 
return false;
 
  280    x = x < Type(0) ? Type(0) : Type(1);
 
 
  285template<
typename Type>
 
  289    return x > 0 ? x < 1 ? (3-2*x)*x*x : Type(1) : Type(0);
 
 
  294template<
typename Type>
 
  308inline int32_t 
Abs(int32_t i) { 
return std::abs(i); }
 
  309inline int64_t 
Abs(int64_t i)
 
  311    static_assert(
sizeof(
decltype(std::abs(i))) == 
sizeof(int64_t),
 
  312                  "std::abs(int64) broken");
 
 
  315inline float Abs(
float x) { 
return std::fabs(x); }
 
  316inline double Abs(
double x) { 
return std::fabs(x); }
 
  317inline long double Abs(
long double x) { 
return std::fabs(x); }
 
  318inline uint32_t 
Abs(uint32_t i) { 
return i; }
 
  319inline uint64_t 
Abs(uint64_t i) { 
return i; }
 
  320inline bool Abs(
bool b) { 
return b; }
 
  323inline typename std::enable_if<std::is_same<T, size_t>::value, T>::type
 
  335template<
typename Type>
 
  347template<
typename Type>
 
  352    return !(x > tolerance) && !(x < -tolerance);
 
 
  356template<
typename Type>
 
  360    return !(x > tolerance) && !(x < -tolerance);
 
 
  365template<
typename Type>
 
  375isFinite(
const float x) { 
return std::isfinite(x); }
 
  378template<typename Type, typename std::enable_if<std::is_arithmetic<Type>::value, 
int>::type = 0>
 
  380isFinite(
const Type& x) { 
return std::isfinite(
static_cast<double>(x)); }
 
  388template<typename Type, typename std::enable_if<std::is_arithmetic<Type>::value, 
int>::type = 0>
 
  390isInfinite(
const Type& x) { 
return std::isinf(
static_cast<double>(x)); }
 
  395isNan(
const float x) { 
return std::isnan(x); }
 
  398template<typename Type, typename std::enable_if<std::is_arithmetic<Type>::value, 
int>::type = 0>
 
  400isNan(
const Type& x) { 
return std::isnan(
static_cast<double>(x)); }
 
  404template<
typename Type>
 
  413template<
typename Type>
 
  421#define OPENVDB_EXACT_IS_APPROX_EQUAL(T) \ 
  422    template<> inline bool isApproxEqual<T>(const T& a, const T& b) { return a == b; } \ 
  423    template<> inline bool isApproxEqual<T>(const T& a, const T& b, const T&) { return a == b; } \ 
 
  432template<typename Type>
 
  436    return (b - a < tolerance);
 
 
  441template<
typename T0, 
typename T1>
 
  451template<
typename Type>
 
  457    if (!(
Abs(a - b) > absTol)) 
return true;
 
  464        relError = 
Abs((a - b) / b);
 
  466        relError = 
Abs((a - b) / a);
 
  468    return (relError <= relTol);
 
 
  482    static_assert(
sizeof(int32_t) == 
sizeof f, 
"`float` has an unexpected size.");
 
  484    std::memcpy(&ret, &f, 
sizeof(int32_t));
 
 
  492    static_assert(
sizeof(int64_t) == 
sizeof d, 
"`double` has an unexpected size.");
 
  494    std::memcpy(&ret, &d, 
sizeof(int64_t));
 
 
  503isUlpsEqual(
const double aLeft, 
const double aRight, 
const int64_t aUnitsInLastPlace)
 
  508        longLeft = INT64_C(0x8000000000000000) - longLeft;
 
  514        longRight = INT64_C(0x8000000000000000) - longRight;
 
  517    int64_t difference = 
Abs(longLeft - longRight);
 
  518    return (difference <= aUnitsInLastPlace);
 
 
  522isUlpsEqual(
const float aLeft, 
const float aRight, 
const int32_t aUnitsInLastPlace)
 
  527        intLeft = 0x80000000 - intLeft;
 
  533        intRight = 0x80000000 - intRight;
 
  536    int32_t difference = 
Abs(intLeft - intRight);
 
  537    return (difference <= aUnitsInLastPlace);
 
 
  547template<
typename Type>
 
  548inline Type 
Pow2(Type x) { 
return x*x; }
 
  551template<
typename Type>
 
  552inline Type 
Pow3(Type x) { 
return x*x*x; }
 
  555template<
typename Type>
 
  559template<
typename Type>
 
  568    while (n--) ans *= x;
 
 
  577    OPENVDB_ASSERT( b >= 0.0f && 
"Pow(float,float): base is negative" );
 
 
  584    OPENVDB_ASSERT( b >= 0.0 && 
"Pow(double,double): base is negative" );
 
  585    return std::pow(b,e);
 
 
  593template<
typename Type>
 
  595Max(
const Type& a, 
const Type& b)
 
  597    return std::max(a,b);
 
 
  601template<
typename Type>
 
  603Max(
const Type& a, 
const Type& b, 
const Type& c)
 
  605    return std::max(std::max(a,b), c);
 
 
  609template<
typename Type>
 
  611Max(
const Type& a, 
const Type& b, 
const Type& c, 
const Type& d)
 
  613    return std::max(std::max(a,b), std::max(c,d));
 
 
  617template<
typename Type>
 
  619Max(
const Type& a, 
const Type& b, 
const Type& c, 
const Type& d, 
const Type& e)
 
  621    return std::max(std::max(a,b), 
Max(c,d,e));
 
 
  625template<
typename Type>
 
  627Max(
const Type& a, 
const Type& b, 
const Type& c, 
const Type& d, 
const Type& e, 
const Type& f)
 
  629    return std::max(
Max(a,b,c), 
Max(d,e,f));
 
 
  633template<
typename Type>
 
  635Max(
const Type& a, 
const Type& b, 
const Type& c, 
const Type& d,
 
  636    const Type& e, 
const Type& f, 
const Type& g)
 
  638    return std::max(
Max(a,b,c,d), 
Max(e,f,g));
 
 
  642template<
typename Type>
 
  644Max(
const Type& a, 
const Type& b, 
const Type& c, 
const Type& d,
 
  645    const Type& e, 
const Type& f, 
const Type& g, 
const Type& h)
 
  647    return std::max(
Max(a,b,c,d), 
Max(e,f,g,h));
 
 
  654template<
typename Type>
 
  656Min(
const Type& a, 
const Type& b) { 
return std::min(a, b); }
 
  659template<
typename Type>
 
  661Min(
const Type& a, 
const Type& b, 
const Type& c) { 
return std::min(std::min(a, b), c); }
 
  664template<
typename Type>
 
  666Min(
const Type& a, 
const Type& b, 
const Type& c, 
const Type& d)
 
  668    return std::min(std::min(a, b), std::min(c, d));
 
 
  672template<
typename Type>
 
  674Min(
const Type& a, 
const Type& b, 
const Type& c, 
const Type& d, 
const Type& e)
 
  676    return std::min(std::min(a,b), 
Min(c,d,e));
 
 
  680template<
typename Type>
 
  682Min(
const Type& a, 
const Type& b, 
const Type& c, 
const Type& d, 
const Type& e, 
const Type& f)
 
  684    return std::min(
Min(a,b,c), 
Min(d,e,f));
 
 
  688template<
typename Type>
 
  690Min(
const Type& a, 
const Type& b, 
const Type& c, 
const Type& d,
 
  691    const Type& e, 
const Type& f, 
const Type& g)
 
  693    return std::min(
Min(a,b,c,d), 
Min(e,f,g));
 
 
  697template<
typename Type>
 
  699Min(
const Type& a, 
const Type& b, 
const Type& c, 
const Type& d,
 
  700    const Type& e, 
const Type& f, 
const Type& g, 
const Type& h)
 
  702    return std::min(
Min(a,b,c,d), 
Min(e,f,g,h));
 
 
  709template<
typename Type>
 
  710inline Type 
Exp(
const Type& x) { 
return std::exp(x); }
 
  716inline float Sin(
const float& x) { 
return std::sin(x); }
 
  718inline double Sin(
const double& x) { 
return std::sin(x); }
 
  725inline float Cos(
const float& x) { 
return std::cos(x); }
 
  727inline double Cos(
const double& x) { 
return std::cos(x); }
 
  735template <
typename Type>
 
  741template <
typename Type>
 
  751template <
typename Type>
 
  755    return a * b <= zeroVal<Type>();
 
 
  761inline float Sqrt(
float x) { 
return std::sqrt(x); }
 
  762inline double Sqrt(
double x) { 
return std::sqrt(x); }
 
  763inline long double Sqrt(
long double x) { 
return std::sqrt(x); }
 
  769inline float Cbrt(
float x) { 
return std::cbrt(x); }
 
  770inline double Cbrt(
double x) { 
return std::cbrt(x); }
 
  771inline long double Cbrt(
long double x) { 
return std::cbrt(x); }
 
  777inline int Mod(
int x, 
int y) { 
return (x % y); }
 
  778inline float Mod(
float x, 
float y) { 
return std::fmod(x, y); }
 
  779inline double Mod(
double x, 
double y) { 
return std::fmod(x, y); }
 
  780inline long double Mod(
long double x, 
long double y) { 
return std::fmod(x, y); }
 
  781template<
typename Type> 
inline Type 
Remainder(Type x, Type y) { 
return Mod(x, y); }
 
  787inline float RoundUp(
float x) { 
return std::ceil(x); }
 
  788inline double RoundUp(
double x) { 
return std::ceil(x); }
 
  789inline long double RoundUp(
long double x) { 
return std::ceil(x); }
 
  792template<
typename Type>
 
  797    return remainder ? x-remainder+base : x;
 
 
  803inline float RoundDown(
float x) { 
return std::floor(x); }
 
  804inline double RoundDown(
double x) { 
return std::floor(x); }
 
  805inline long double RoundDown(
long double x) { 
return std::floor(x); }
 
  808template<
typename Type>
 
  813    return remainder ? x-remainder : x;
 
 
  827template<
typename Type>
 
  833template<
typename Type>
 
  841template<
typename Type>
 
  863template<
typename Type>
 
  868template<
typename Type>
 
  872    Type tenth = 
static_cast<Type
>(
Pow(
size_t(10), digits));
 
 
  882inline auto PrintCast(
const T& val) -> 
typename std::enable_if<!std::is_same<T, int8_t>::value
 
  883    && !std::is_same<T, uint8_t>::value, 
const T&>::type { 
return val; }
 
 
  884inline int32_t 
PrintCast(int8_t val) { 
return int32_t(val); }
 
  885inline uint32_t 
PrintCast(uint8_t val) { 
return uint32_t(val); }
 
  892template<
typename Type>
 
  919template <
typename S, 
typename T, 
typename = std::enable_if_t<std::is_arithmetic_v<S>&& std::is_arithmetic_v<T>>>
 
  921    using type = 
typename std::common_type_t<S,T>;
 
 
  928template<
typename Vec3T>
 
  933    for (
size_t i = 1; i < 3; ++i) {
 
  935        if (v[i] <= v[r]) r = i;
 
 
  944template<
typename Vec3T>
 
  949    for (
size_t i = 1; i < 3; ++i) {
 
  951        if (v[i] >= v[r]) r = i;
 
 
#define OPENVDB_ASSERT(X)
Definition Assert.h:41
#define OPENVDB_EXACT_IS_APPROX_EQUAL(T)
Definition Math.h:421
#define OPENVDB_NO_FP_EQUALITY_WARNING_END
Definition Math.h:49
#define OPENVDB_NO_FP_EQUALITY_WARNING_BEGIN
Definition Math.h:48
Simple generator of random numbers over the range [0, 1)
Definition Math.h:167
void setSeed(unsigned int seed)
Set the seed value for the random number generator.
Definition Math.h:184
Rand01(const EngineType &engine)
Initialize the generator.
Definition Math.h:177
const std::mt19937 & engine() const
Definition Math.h:190
FloatType operator()()
Return a uniformly distributed random number in the range [0, 1).
Definition Math.h:193
Rand01(unsigned int seed)
Initialize the generator.
Definition Math.h:181
FloatType ValueType
Definition Math.h:173
Simple random integer generator.
Definition Math.h:203
void setSeed(unsigned int seed)
Set the seed value for the random number generator.
Definition Math.h:233
RandInt(unsigned int seed, IntType imin, IntType imax)
Initialize the generator.
Definition Math.h:221
void setRange(IntType imin, IntType imax)
Change the range over which integers are distributed to [imin, imax].
Definition Math.h:227
IntType operator()()
Return a randomly-generated integer in the current range.
Definition Math.h:242
const std::mt19937 & engine() const
Definition Math.h:239
RandInt(const EngineType &engine, IntType imin, IntType imax)
Initialize the generator.
Definition Math.h:213
IntType operator()(IntType imin, IntType imax)
Return a randomly-generated integer in the new range [imin, imax], without changing the current range...
Definition Math.h:246
int Sign(const Type &x)
Return the sign of the given value as an integer (either -1, 0 or 1).
Definition Math.h:736
bool isApproxLarger(const Type &a, const Type &b, const Type &tolerance)
Return true if a is larger than b to within the given tolerance, i.e., if b - a < tolerance.
Definition Math.h:434
size_t MaxIndex(const Vec3T &v)
Return the index [0,1,2] of the largest value in a 3D vector.
Definition Math.h:946
float RoundUp(float x)
Return x rounded up to the nearest integer.
Definition Math.h:787
Type SmoothUnitStep(Type x)
Return 0 if x < 0, 1 if x > 1 or else (3 − 2 x) x².
Definition Math.h:287
int Ceil(float x)
Return the ceiling of x.
Definition Math.h:856
bool isApproxZero(const Type &x)
Return true if x is equal to zero to within the default floating-point comparison tolerance.
Definition Math.h:349
bool isInfinite(const float x)
Return true if x is an infinity value (either positive infinity or negative infinity).
Definition Math.h:385
Type IntegerPart(Type x)
Return the integer part of x.
Definition Math.h:835
bool cwiseLessThan(const Mat< SIZE, T > &m0, const Mat< SIZE, T > &m1)
Definition Mat.h:1015
constexpr T pi()
Pi constant taken from Boost to match old behaviour.
Definition Math.h:119
Type Pow(Type x, int n)
Return xn.
Definition Math.h:561
float Sqrt(float x)
Return the square root of a floating-point value.
Definition Math.h:761
bool isApproxEqual(const Type &a, const Type &b, const Type &tolerance)
Return true if a is equal to b to within the given tolerance.
Definition Math.h:406
bool isRelOrApproxEqual(const Type &a, const Type &b, const Type &absTol, const Type &relTol)
Definition Math.h:453
const Type & Max(const Type &a, const Type &b)
Return the maximum of two values.
Definition Math.h:595
size_t MinIndex(const Vec3T &v)
Return the index [0,1,2] of the smallest value in a 3D vector.
Definition Math.h:930
bool isFinite(const float x)
Return true if x is finite.
Definition Math.h:375
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 i...
Definition Math.h:882
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.
Definition Coord.h:528
Type Pow4(Type x)
Return x4.
Definition Math.h:556
Type EuclideanRemainder(Type x)
Definition Math.h:829
Type Remainder(Type x, Type y)
Definition Math.h:781
Type Inv(Type x)
Return the inverse of x.
Definition Math.h:894
Type Exp(const Type &x)
Return ex.
Definition Math.h:710
bool isNegative(const Type &x)
Return true if x is less than zero.
Definition Math.h:367
bool isNan(const float x)
Return true if x is a NaN (Not-A-Number) value.
Definition Math.h:395
int64_t doubleToInt64(const double d)
Definition Math.h:489
Type Clamp01(Type x)
Return x clamped to [0, 1].
Definition Math.h:271
float Cos(const float &x)
Return cos x.
Definition Math.h:725
bool isUlpsEqual(const double aLeft, const double aRight, const int64_t aUnitsInLastPlace)
Definition Math.h:503
RandInt< int, std::mt19937 > RandomInt
Definition Math.h:253
float RoundDown(float x)
Return x rounded down to the nearest integer.
Definition Math.h:803
auto cwiseAdd(const math::Vec3< math::half > &v, const float s)
Definition Types.h:694
const Type & Min(const Type &a, const Type &b)
Return the minimum of two values.
Definition Math.h:656
Coord Abs(const Coord &xyz)
Definition Coord.h:518
int Mod(int x, int y)
Return the remainder of x / y.
Definition Math.h:777
Type Truncate(Type x, unsigned int digits)
Return x truncated to the given number of decimal digits.
Definition Math.h:870
T negative(const T &val)
Return the unary negation of the given value.
Definition Math.h:128
bool isExactlyEqual(const T0 &a, const T1 &b)
Return true if a is exactly equal to b.
Definition Math.h:443
float Round(float x)
Return x rounded to the nearest integer.
Definition Math.h:819
Type Pow3(Type x)
Return x3.
Definition Math.h:552
Type Clamp(Type x, Type min, Type max)
Return x clamped to [min, max].
Definition Math.h:261
bool isZero(const Type &x)
Return true if x is exactly equal to zero.
Definition Math.h:337
Type Chop(Type x, Type delta)
Return x if it is greater or equal in magnitude than delta. Otherwise, return zero.
Definition Math.h:864
Type FractionalPart(Type x)
Return the fractional part of x.
Definition Math.h:843
Axis
Definition Math.h:901
@ Z_AXIS
Definition Math.h:904
@ X_AXIS
Definition Math.h:902
@ Y_AXIS
Definition Math.h:903
bool cwiseGreaterThan(const Mat< SIZE, T > &m0, const Mat< SIZE, T > &m1)
Definition Mat.h:1029
bool ClampTest01(Type &x)
Return true if x is outside [0,1].
Definition Math.h:277
float Sin(const float &x)
Return sin x.
Definition Math.h:716
int32_t floatToInt32(const float f)
Definition Math.h:479
Type Pow2(Type x)
Return x2.
Definition Math.h:548
RotationOrder
Definition Math.h:908
@ YXZ_ROTATION
Definition Math.h:911
@ ZXY_ROTATION
Definition Math.h:913
@ YZX_ROTATION
Definition Math.h:912
@ ZXZ_ROTATION
Definition Math.h:916
@ XZX_ROTATION
Definition Math.h:915
@ XYZ_ROTATION
Definition Math.h:909
@ ZYX_ROTATION
Definition Math.h:914
@ XZY_ROTATION
Definition Math.h:910
float Cbrt(float x)
Return the cube root of a floating-point value.
Definition Math.h:769
int Floor(float x)
Return the floor of x.
Definition Math.h:848
bool SignChange(const Type &a, const Type &b)
Return true if a and b have different signs.
Definition Math.h:743
bool ZeroCrossing(const Type &a, const Type &b)
Return true if the interval [a, b] includes zero, i.e., if either a or b is zero or if they have diff...
Definition Math.h:753
Rand01< double, std::mt19937 > Random01
Definition Math.h:196
constexpr T zeroVal()
Return the value of type T that corresponds to zero.
Definition Math.h:70
Definition Exceptions.h:13
static double value()
Definition Math.h:157
static float value()
Definition Math.h:156
Delta for small floating-point offsets.
Definition Math.h:155
static T value()
Definition Math.h:155
static double value()
Definition Math.h:150
static float value()
Definition Math.h:149
Tolerance for floating-point comparison.
Definition Math.h:148
static T value()
Definition Math.h:148
#define OPENVDB_VERSION_NAME
The version namespace name for this library version.
Definition version.h.in:121
#define OPENVDB_USE_VERSION_NAMESPACE
Definition version.h.in:218