35 #ifndef OPENVDB_MATH_HAS_BEEN_INCLUDED
36 #define OPENVDB_MATH_HAS_BEEN_INCLUDED
45 #include <boost/numeric/conversion/conversion_traits.hpp>
46 #include <boost/math/special_functions/cbrt.hpp>
47 #include <boost/random/mersenne_twister.hpp>
48 #include <boost/random/uniform_01.hpp>
49 #include <boost/random/uniform_int.hpp>
50 #include <boost/version.hpp>
51 #include <openvdb/Platform.h>
52 #include <openvdb/version.h>
59 #if defined(__INTEL_COMPILER)
60 #define OPENVDB_NO_FP_EQUALITY_WARNING_BEGIN \
61 _Pragma("warning (push)") \
62 _Pragma("warning (disable:1572)")
63 #define OPENVDB_NO_FP_EQUALITY_WARNING_END \
64 _Pragma("warning (pop)")
73 #define OPENVDB_NO_FP_EQUALITY_WARNING_BEGIN
74 #define OPENVDB_NO_FP_EQUALITY_WARNING_END
85 template<
typename T>
inline T
zeroVal() {
return T(0); }
87 template<>
inline std::string zeroVal<std::string>() {
return ""; }
93 inline std::string
operator+(
const std::string& s,
bool) {
return s; }
96 inline std::string
operator+(
const std::string& s,
int) {
return s; }
97 inline std::string
operator+(
const std::string& s,
float) {
return s; }
98 inline std::string
operator+(
const std::string& s,
double) {
return s; }
107 template<
typename T>
inline T
negative(
const T& val) {
return T(-val); }
109 template<>
inline bool negative(
const bool& val) {
return !val; }
111 template<>
inline std::string
negative(
const std::string& val) {
return val; }
115 template<
typename T>
struct Tolerance {
static T value() {
return zeroVal<T>(); } };
122 template<
typename T>
struct Delta {
static T value() {
return zeroVal<T>(); } };
124 template<>
struct Delta<float> {
static float value() {
return 1e-5f; } };
125 template<>
struct Delta<double> {
static double value() {
return 1e-9; } };
142 template<
typename FloatType =
double,
typename EngineType = boost::mt19937>
147 boost::uniform_01<FloatType> mRand;
154 Rand01(
unsigned int seed): mEngine(static_cast<typename EngineType::result_type>(seed)) {}
165 template<
typename EngineType = boost::mt19937>
169 #if BOOST_VERSION >= 104700
170 typedef boost::random::uniform_int_distribution<int> Distr;
172 typedef boost::uniform_int<int> Distr;
181 RandInt(
unsigned int seed,
int imin,
int imax):
182 mEngine(static_cast<typename EngineType::result_type>(seed)),
183 mRand(std::
min(imin, imax), std::
max(imin, imax))
196 #if BOOST_VERSION >= 104700
197 return mRand(mEngine, Distr::param_type(lo, hi));
199 return Distr(lo, hi)(mEngine);
210 template<
typename Type>
215 return x > min ? x < max ? x : max :
min;
220 template<
typename Type>
222 Clamp01(Type x) {
return x > Type(0) ? x < Type(1) ? x : Type(1) : Type(0); }
226 template<
typename Type>
230 if (x >= Type(0) && x <= Type(1))
return false;
231 x = x < Type(0) ? Type(0) : Type(1);
238 template<
typename Type>
243 const Type t = (x-
min)/(max-min);
244 return t > 0 ? t < 1 ? (3-2*t)*t*t : Type(1) : Type(0);
252 inline int32_t
Abs(int32_t i) {
return abs(i); }
254 inline int64_t
Abs(int64_t i)
257 return (i < int64_t(0) ? -i : i);
262 inline float Abs(
float x) {
return fabs(x); }
263 inline double Abs(
double x) {
return fabs(x); }
264 inline long double Abs(
long double x) {
return fabs(x); }
265 inline uint32_t
Abs(uint32_t i) {
return i; }
266 inline uint64_t
Abs(uint64_t i) {
return i; }
268 #if defined(__APPLE__) || defined(MACOSX)
269 inline size_t Abs(
size_t i) {
return i; }
281 template<
typename Type>
286 return x == zeroVal<Type>();
293 template<
typename Type>
298 return x < tolerance && x > -tolerance;
302 template<
typename Type>
306 return x < tolerance && x > -tolerance;
311 template<
typename Type>
321 template<
typename Type>
326 return !(
Abs(a - b) > tolerance);
331 template<
typename Type>
335 return !(
Abs(a - b) > tolerance);
338 #define OPENVDB_EXACT_IS_APPROX_EQUAL(T) \
339 template<> inline bool isApproxEqual<T>(const T& a, const T& b) { return a == b; } \
340 template<> inline bool isApproxEqual<T>(const T& a, const T& b, const T&) { return a == b; } \
349 template<typename Type>
353 return (b - a < tolerance);
358 template<
typename T0,
typename T1>
368 template<
typename Type>
374 if (!(
Abs(a - b) > absTol))
return true;
381 relError =
Abs((a - b) / b);
383 relError =
Abs((a - b) / a);
385 return (relError <= relTol);
402 union FloatOrInt32 {
float floatValue; int32_t int32Value; };
403 const FloatOrInt32* foi =
reinterpret_cast<const FloatOrInt32*
>(&aFloatValue);
404 return foi->int32Value;
411 union DoubleOrInt64 {
double doubleValue; int64_t int64Value; };
412 const DoubleOrInt64* dol =
reinterpret_cast<const DoubleOrInt64*
>(&aDoubleValue);
413 return dol->int64Value;
422 isUlpsEqual(
const double aLeft,
const double aRight,
const int64_t aUnitsInLastPlace)
427 longLeft = INT64_C(0x8000000000000000) - longLeft;
433 longRight = INT64_C(0x8000000000000000) - longRight;
436 int64_t difference = labs(longLeft - longRight);
437 return (difference <= aUnitsInLastPlace);
441 isUlpsEqual(
const float aLeft,
const float aRight,
const int32_t aUnitsInLastPlace)
446 intLeft = 0x80000000 - intLeft;
452 intRight = 0x80000000 - intRight;
455 int32_t difference = abs(intLeft - intRight);
456 return (difference <= aUnitsInLastPlace);
466 template<
typename Type>
467 inline Type
Pow2(Type x) {
return x*x; }
470 template<
typename Type>
471 inline Type
Pow3(Type x) {
return x*x*x; }
474 template<
typename Type>
478 template<
typename Type>
487 while (n--) ans *= x;
496 assert( b >= 0.0f &&
"Pow(float,float): base is negative" );
503 assert( b >= 0.0 &&
"Pow(double,double): base is negative" );
512 template<
typename Type>
514 Max(
const Type& a,
const Type& b)
520 template<
typename Type>
522 Max(
const Type& a,
const Type& b,
const Type& c)
528 template<
typename Type>
530 Max(
const Type& a,
const Type& b,
const Type& c,
const Type& d)
536 template<
typename Type>
538 Max(
const Type& a,
const Type& b,
const Type& c,
const Type& d,
const Type& e)
544 template<
typename Type>
546 Max(
const Type& a,
const Type& b,
const Type& c,
const Type& d,
const Type& e,
const Type& f)
552 template<
typename Type>
554 Max(
const Type& a,
const Type& b,
const Type& c,
const Type& d,
555 const Type& e,
const Type& f,
const Type& g)
561 template<
typename Type>
563 Max(
const Type& a,
const Type& b,
const Type& c,
const Type& d,
564 const Type& e,
const Type& f,
const Type& g,
const Type& h)
573 template<
typename Type>
578 template<
typename Type>
583 template<
typename Type>
585 Min(
const Type& a,
const Type& b,
const Type& c,
const Type& d)
591 template<
typename Type>
593 Min(
const Type& a,
const Type& b,
const Type& c,
const Type& d,
const Type& e)
599 template<
typename Type>
601 Min(
const Type& a,
const Type& b,
const Type& c,
const Type& d,
const Type& e,
const Type& f)
607 template<
typename Type>
609 Min(
const Type& a,
const Type& b,
const Type& c,
const Type& d,
610 const Type& e,
const Type& f,
const Type& g)
616 template<
typename Type>
618 Min(
const Type& a,
const Type& b,
const Type& c,
const Type& d,
619 const Type& e,
const Type& f,
const Type& g,
const Type& h)
629 template <
typename Type>
630 inline int Sign(
const Type &x) {
return (zeroVal<Type>() < x) - (x < zeroVal<Type>()); }
635 template <
typename Type>
639 return ( (a<zeroVal<Type>()) ^ (b<zeroVal<Type>()) );
645 template <
typename Type>
649 return a * b <= zeroVal<Type>();
654 inline float Sqrt(
float x) {
return sqrtf(x); }
656 inline double Sqrt(
double x) {
return sqrt(x); }
657 inline long double Sqrt(
long double x) {
return sqrtl(x); }
662 inline float Cbrt(
float x) {
return boost::math::cbrt(x); }
664 inline double Cbrt(
double x) {
return boost::math::cbrt(x); }
665 inline long double Cbrt(
long double x) {
return boost::math::cbrt(x); }
670 inline int Mod(
int x,
int y) {
return (x % y); }
672 inline float Mod(
float x,
float y) {
return fmodf(x,y); }
673 inline double Mod(
double x,
double y) {
return fmod(x,y); }
674 inline long double Mod(
long double x,
long double y) {
return fmodl(x,y); }
675 template<
typename Type>
inline Type
Remainder(Type x, Type y) {
return Mod(x,y); }
680 inline float RoundUp(
float x) {
return ceilf(x); }
682 inline double RoundUp(
double x) {
return ceil(x); }
683 inline long double RoundUp(
long double x) {
return ceill(x); }
685 template<
typename Type>
691 return remainder ? x-remainder+base : x;
696 inline float RoundDown(
float x) {
return floorf(x); }
699 inline long double RoundDown(
long double x) {
return floorl(x); }
702 template<
typename Type>
708 return remainder ? x-remainder : x;
713 template<
typename Type>
721 template<
typename Type>
734 inline int Ceil(
float x) {
return (
int)
RoundUp(x); }
742 template<
typename Type>
743 inline Type
Chop(Type x, Type delta) {
return (
Abs(x) < delta ? zeroVal<Type>() : x); }
747 template<
typename Type>
751 Type tenth =
Pow(10,digits);
760 template<
typename Type>
788 template <
typename S,
typename T>
790 typedef typename boost::numeric::conversion_traits<S, T>::supertype
type;
801 template<
typename Vec3T>
805 static const size_t hashTable[8] = { 2, 1, 9, 1, 2, 9, 0, 0 };
806 const size_t hashKey =
807 ((v[0] < v[1]) << 2) + ((v[0] < v[2]) << 1) + (v[1] < v[2]);
808 return hashTable[hashKey];
819 template<
typename Vec3T>
823 static const size_t hashTable[8] = { 2, 1, 9, 1, 2, 9, 0, 0 };
824 const size_t hashKey =
825 ((v[0] > v[1]) << 2) + ((v[0] > v[2]) << 1) + (v[1] > v[2]);
826 return hashTable[hashKey];
833 #endif // OPENVDB_MATH_MATH_HAS_BEEN_INCLUDED
int operator()()
Return a randomly-generated integer in the current range.
Definition: Math.h:190
bool isApproxZero(const Type &x)
Return true if x is equal to zero to within the default floating-point comparison tolerance...
Definition: Math.h:295
Tolerance for floating-point comparison.
Definition: Math.h:116
FloatType operator()()
Return a uniformly distributed random number in the range [0, 1).
Definition: Math.h:157
OPENVDB_API Hermite min(const Hermite &, const Hermite &)
min and max operations done directly on the compressed data.
static float value()
Definition: Math.h:124
OPENVDB_DEPRECATED double randUniform()
Definition: Math.h:137
int Mod(int x, int y)
Return the remainder of x / y.
Definition: Math.h:671
int Floor(float x)
Return the floor of x.
Definition: Math.h:727
int32_t floatToInt32(const float aFloatValue)
Definition: Math.h:400
int operator()(int imin, int imax)
Return a randomly-generated integer in the new range [imin, imax], without changing the current range...
Definition: Math.h:193
Type Clamp(Type x, Type min, Type max)
Return x clamped to [min, max].
Definition: Math.h:212
size_t MaxIndex(const Vec3T &v)
Return the index [0,1,2] of the largest value in a 3D vector.
Definition: Math.h:821
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:647
int32_t Abs(int32_t i)
Return the absolute value of the given quantity.
Definition: Math.h:253
T zeroVal()
Return the value of type T that corresponds to zero.
Definition: Math.h:85
Type Inv(Type x)
Return the inverse of x.
Definition: Math.h:762
Type Pow2(Type x)
Return .
Definition: Math.h:467
Delta for small floating-point offsets.
Definition: Math.h:123
bool ClampTest01(Type &x)
Return true if x is outside [0,1].
Definition: Math.h:228
FloatType ValueType
Definition: Math.h:150
Type Round(Type x)
Return x rounded down to the nearest integer.
Definition: Math.h:700
float Sqrt(float x)
Return the square root of a floating-point value.
Definition: Math.h:655
Type Clamp01(Type x)
Return x clamped to [0, 1].
Definition: Math.h:222
Simple random integer generator.
Definition: Math.h:166
float RoundDown(float x)
Return x rounded down to the nearest integer.
Definition: Math.h:697
RotationOrder
Definition: Math.h:776
int Sign(const Type &x)
Return the sign of the given value as an integer (either -1, 0 or 1).
Definition: Math.h:630
static float value()
Definition: Math.h:117
#define OPENVDB_VERSION_NAME
Definition: version.h:45
bool isNegative< bool >(const bool &)
Return false, since bool values are never less than zero.
Definition: Math.h:316
Simple generator of random numbers over the range [0, 1)
Definition: Math.h:143
float Cbrt(float x)
Return the cube root of a floating-point value.
Definition: Math.h:663
Type IntegerPart(Type x)
Return the integer part of x.
Definition: Math.h:715
static double value()
Definition: Math.h:118
bool isExactlyEqual(const T0 &a, const T1 &b)
Return true if a is exactly equal to b.
Definition: Math.h:360
Rand01< double, boost::mt19937 > Random01
Definition: Math.h:160
void setRange(int imin, int imax)
Change the range over which integers are distributed to [imin, imax].
Definition: Math.h:187
#define OPENVDB_NO_FP_EQUALITY_WARNING_END
Definition: Math.h:74
size_t MinIndex(const Vec3T &v)
Return the index [0,1,2] of the smallest value in a 3D vector.
Definition: Math.h:803
Type Pow(Type x, int n)
Return .
Definition: Math.h:480
OPENVDB_API Hermite max(const Hermite &, const Hermite &)
min and max operations done directly on the compressed data.
Rand01(unsigned int seed)
Initialize the generator.
Definition: Math.h:154
float RoundUp(float x)
Return x rounded up to the nearest integer.
Definition: Math.h:681
Type Remainder(Type x, Type y)
Return the remainder of x / y.
Definition: Math.h:675
RandInt(unsigned int seed, int imin, int imax)
Initialize the generator.
Definition: Math.h:181
#define OPENVDB_NO_FP_EQUALITY_WARNING_BEGIN
Definition: Math.h:73
bool zeroVal< bool >()
Return the bool value that corresponds to zero.
Definition: Math.h:89
int Ceil(float x)
Return the ceiling of x.
Definition: Math.h:735
const Type & Min(const Type &a, const Type &b)
Return the minimum of two values.
Definition: Math.h:575
bool SignChange(const Type &a, const Type &b)
Return true if a and b have different signs.
Definition: Math.h:637
bool isZero(const Type &x)
Return true if x is exactly equal to zero.
Definition: Math.h:283
bool isRelOrApproxEqual(const Type &a, const Type &b, const Type &absTol, const Type &relTol)
Definition: Math.h:370
OPENVDB_DEPRECATED void randSeed(unsigned int seed)
Definition: Math.h:133
Type Chop(Type x, Type delta)
Return x if it is greater in magnitude than delta. Otherwise, return zero.
Definition: Math.h:743
bool isApproxEqual(const Hermite &lhs, const Hermite &rhs)
Definition: Hermite.h:470
Type Pow3(Type x)
Return .
Definition: Math.h:471
bool isNegative(const Type &x)
Return true if x is less than zero.
Definition: Math.h:313
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:382
Axis
Definition: Math.h:769
#define OPENVDB_USE_VERSION_NAMESPACE
Definition: version.h:67
Type SmoothUnitStep(Type x, Type min, Type max)
Return 0 if x < min, 1 if x > max or else , where .
Definition: Math.h:240
T negative(const T &val)
Return the unary negation of the given value.
Definition: Math.h:107
int64_t doubleToInt64(const double aDoubleValue)
Definition: Math.h:409
RandInt< boost::mt19937 > RandomInt
Definition: Math.h:204
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:351
static double value()
Definition: Math.h:125
Type Truncate(Type x, unsigned int digits)
Return x truncated to the given number of decimal digits.
Definition: Math.h:749
#define OPENVDB_EXACT_IS_APPROX_EQUAL(T)
Definition: Math.h:338
const Type & Max(const Type &a, const Type &b)
Return the maximum of two values.
Definition: Math.h:514
Type FractionalPart(Type x)
Return the fractional part of x.
Definition: Math.h:722
Type Pow4(Type x)
Return .
Definition: Math.h:475
bool isUlpsEqual(const double aLeft, const double aRight, const int64_t aUnitsInLastPlace)
Definition: Math.h:422