8 #ifndef OPENVDB_MATH_HAS_BEEN_INCLUDED
9 #define OPENVDB_MATH_HAS_BEEN_INCLUDED
13 #include <hboost/numeric/conversion/conversion_traits.hpp>
20 #include <type_traits>
27 #if defined(__INTEL_COMPILER)
28 #define OPENVDB_NO_FP_EQUALITY_WARNING_BEGIN \
29 _Pragma("warning (push)") \
30 _Pragma("warning (disable:1572)")
31 #define OPENVDB_NO_FP_EQUALITY_WARNING_END \
32 _Pragma("warning (pop)")
33 #elif defined(__clang__)
34 #define OPENVDB_NO_FP_EQUALITY_WARNING_BEGIN \
35 PRAGMA(clang diagnostic push) \
36 PRAGMA(clang diagnostic ignored "-Wfloat-equal")
37 #define OPENVDB_NO_FP_EQUALITY_WARNING_END \
38 PRAGMA(clang diagnostic pop)
47 #define OPENVDB_NO_FP_EQUALITY_WARNING_BEGIN
48 #define OPENVDB_NO_FP_EQUALITY_WARNING_END
55 #define OPENVDB_IS_POD(Type) \
56 static_assert(std::is_standard_layout<Type>::value, \
57 #Type" must be a POD type (satisfy StandardLayoutType.)"); \
58 static_assert(std::is_trivial<Type>::value, \
59 #Type" must be a POD type (satisfy TrivialType.)");
69 template<
typename T>
inline T zeroVal() {
return T(0); }
71 template<>
inline std::string zeroVal<std::string>() {
return ""; }
88 template<
typename Type1,
typename Type2>
97 template<
typename Type1,
typename Type2>
106 template<
typename Type1,
typename Type2>
118 template <
typename T>
inline constexpr
T pi() {
return 3.141592653589793238462643383279502884e+00; }
119 template <>
inline constexpr
float pi() {
return 3.141592653589793238462643383279502884e+00F; }
120 template <>
inline constexpr
double pi() {
return 3.141592653589793238462643383279502884e+00; }
121 template <>
inline constexpr
long double pi() {
return 3.141592653589793238462643383279502884e+00L; }
130 #if defined(_MSC_VER)
131 #pragma warning(push)
132 #pragma warning(disable:4146)
135 #if defined(_MSC_VER)
154 template<
typename T>
struct Delta {
static T value() {
return zeroVal<T>(); } };
156 template<>
struct Delta<double> {
static double value() {
return 1e-9; } };
164 template<
typename FloatType =
double,
typename EngineType = std::mt19937>
169 std::uniform_real_distribution<FloatType> mRand;
180 Rand01(
unsigned int seed): mEngine(static_cast<typename EngineType::result_type>(seed)) {}
185 mEngine.seed(static_cast<typename EngineType::result_type>(seed));
189 const EngineType&
engine()
const {
return mEngine; }
200 template<
typename IntType =
int,
typename EngineType = std::mt19937>
204 using Distr = std::uniform_int_distribution<IntType>;
214 mRand(std::
min(imin, imax), std::
max(imin, imax))
220 RandInt(
unsigned int seed, IntType imin, IntType imax):
221 mEngine(static_cast<typename EngineType::result_type>(seed)),
222 mRand(std::
min(imin, imax), std::
max(imin, imax))
234 mEngine.seed(static_cast<typename EngineType::result_type>(seed));
238 const EngineType&
engine()
const {
return mEngine; }
248 return mRand(mEngine,
typename Distr::param_type(lo, hi));
258 template<
typename Type>
262 assert( !(min>max) );
263 return x > min ? x < max ? x : max :
min;
268 template<
typename Type>
274 template<
typename Type>
278 if (x >=
Type(0) && x <=
Type(1))
return false;
284 template<
typename Type>
288 return x > 0 ? x < 1 ? (3-2*
x)*x*x :
Type(1) :
Type(0);
293 template<
typename Type>
307 inline int32_t
Abs(int32_t i) {
return abs(i); }
308 inline int64_t
Abs(int64_t i)
311 return (i < int64_t(0) ? -i : i);
316 inline float Abs(
float x) {
return std::fabs(x); }
317 inline double Abs(
double x) {
return std::fabs(x); }
318 inline long double Abs(
long double x) {
return std::fabs(x); }
319 inline uint32_t
Abs(uint32_t i) {
return i; }
320 inline uint64_t
Abs(uint64_t i) {
return i; }
321 inline bool Abs(
bool b) {
return b; }
323 template <
typename T>
336 template<
typename Type>
341 return x == zeroVal<Type>();
348 template<
typename Type>
353 return !(x > tolerance) && !(x < -tolerance);
357 template<
typename Type>
361 return !(x > tolerance) && !(x < -tolerance);
366 template<
typename Type>
396 isNan(
const float x) {
return std::isnan(x); }
401 isNan(
const Type&
x) {
return std::isnan(static_cast<double>(x)); }
405 template<
typename Type>
414 template<
typename Type>
422 #define OPENVDB_EXACT_IS_APPROX_EQUAL(T) \
423 template<> inline bool isApproxEqual<T>(const T& a, const T& b) { return a == b; } \
424 template<> inline bool isApproxEqual<T>(const T& a, const T& b, const T&) { return a == b; } \
433 template<typename
Type>
437 return (b - a < tolerance);
442 template<
typename T0,
typename T1>
452 template<
typename Type>
458 if (!(
Abs(a - b) > absTol))
return true;
465 relError =
Abs((a - b) / b);
467 relError =
Abs((a - b) / a);
469 return (relError <= relTol);
486 union FloatOrInt32 {
float floatValue; int32_t int32Value; };
487 const FloatOrInt32* foi =
reinterpret_cast<const FloatOrInt32*
>(&aFloatValue);
488 return foi->int32Value;
495 union DoubleOrInt64 {
double doubleValue; int64_t int64Value; };
496 const DoubleOrInt64* dol =
reinterpret_cast<const DoubleOrInt64*
>(&aDoubleValue);
497 return dol->int64Value;
506 isUlpsEqual(
const double aLeft,
const double aRight,
const int64_t aUnitsInLastPlace)
511 longLeft = INT64_C(0x8000000000000000) - longLeft;
517 longRight = INT64_C(0x8000000000000000) - longRight;
520 int64_t difference = labs(longLeft - longRight);
521 return (difference <= aUnitsInLastPlace);
525 isUlpsEqual(
const float aLeft,
const float aRight,
const int32_t aUnitsInLastPlace)
530 intLeft = 0x80000000 - intLeft;
536 intRight = 0x80000000 - intRight;
539 int32_t difference =
abs(intLeft - intRight);
540 return (difference <= aUnitsInLastPlace);
550 template<
typename Type>
554 template<
typename Type>
558 template<
typename Type>
562 template<
typename Type>
571 while (n--) ans *=
x;
580 assert( b >= 0.0
f &&
"Pow(float,float): base is negative" );
587 assert( b >= 0.0 &&
"Pow(double,double): base is negative" );
596 template<
typename Type>
604 template<
typename Type>
612 template<
typename Type>
620 template<
typename Type>
628 template<
typename Type>
636 template<
typename Type>
645 template<
typename Type>
657 template<
typename Type>
662 template<
typename Type>
667 template<
typename Type>
675 template<
typename Type>
683 template<
typename Type>
691 template<
typename Type>
700 template<
typename Type>
712 template<
typename Type>
738 template <
typename Type>
744 template <
typename Type>
748 return ( (a<zeroVal<Type>()) ^ (b<zeroVal<Type>()) );
754 template <
typename Type>
772 inline float Cbrt(
float x) {
return std::cbrt(x); }
773 inline double Cbrt(
double x) {
return std::cbrt(x); }
774 inline long double Cbrt(
long double x) {
return std::cbrt(x); }
780 inline int Mod(
int x,
int y) {
return (x % y); }
795 template<
typename Type>
800 return remainder ? x-remainder+base :
x;
811 template<
typename Type>
816 return remainder ? x-remainder :
x;
830 template<
typename Type>
836 template<
typename Type>
844 template<
typename Type>
866 template<
typename Type>
871 template<
typename Type>
875 Type tenth =
static_cast<Type>(
Pow(
size_t(10), digits));
895 template<
typename Type>
923 template <
typename S,
typename T>
925 using type =
typename hboost::numeric::conversion_traits<S, T>::supertype;
936 template<
typename Vec3T>
940 static const size_t hashTable[8] = { 2, 1, 9, 1, 2, 9, 0, 0 };
941 const size_t hashKey =
942 ((v[0] < v[1]) << 2) + ((v[0] < v[2]) << 1) + (v[1] < v[2]);
943 return hashTable[hashKey];
954 template<
typename Vec3T>
958 static const size_t hashTable[8] = { 2, 1, 9, 1, 2, 9, 0, 0 };
959 const size_t hashKey =
960 ((v[0] > v[1]) << 2) + ((v[0] > v[2]) << 1) + (v[1] > v[2]);
961 return hashTable[hashKey];
968 #endif // OPENVDB_MATH_MATH_HAS_BEEN_INCLUDED
void setSeed(unsigned int seed)
Set the seed value for the random number generator.
int32_t floatToInt32(const float aFloatValue)
SYS_API double cos(double x)
GLboolean GLboolean GLboolean b
SYS_API double fmod(double x, double y)
Type Inv(Type x)
Return the inverse of x.
Type Truncate(Type x, unsigned int digits)
Return x truncated to the given number of decimal digits.
int Ceil(float x)
Return the ceiling of x.
Simple generator of random numbers over the range [0, 1)
bool cwiseGreaterThan(const Mat< SIZE, T > &m0, const Mat< SIZE, T > &m1)
Type Pow(Type x, int n)
Return xn.
Type IntegerPart(Type x)
Return the integer part of x.
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...
bool isExactlyEqual(const T0 &a, const T1 &b)
Return true if a is exactly equal to b.
Type Pow2(Type x)
Return x2.
IMATH_HOSTDEVICE constexpr int floor(T x) IMATH_NOEXCEPT
T negative(const T &val)
Return the unary negation of the given value.
size_t MaxIndex(const Vec3T &v)
Return the index [0,1,2] of the largest value in a 3D vector.
Type FractionalPart(Type x)
Return the fractional part of x.
Mat3< Type1 > cwiseAdd(const Mat3< Type1 > &m, const Type2 s)
vfloat4 sqrt(const vfloat4 &a)
#define OPENVDB_USE_VERSION_NAMESPACE
const EngineType & engine() const
Return a const reference to the random number generator.
float Cos(const float &x)
Return cos x.
SYS_API float powf(float x, float y)
ImageBuf OIIO_API min(Image_or_Const A, Image_or_Const B, ROI roi={}, int nthreads=0)
Rand01(unsigned int seed)
Initialize the generator.
bool SignChange(const Type &a, const Type &b)
Return true if a and b have different signs.
float RoundDown(float x)
Return x rounded down to the nearest integer.
RandInt(const EngineType &engine, IntType imin, IntType imax)
Initialize the generator.
bool zeroVal< bool >()
Return the bool value that corresponds to zero.
bool isNegative(const Type &x)
Return true if x is less than zero.
int64_t doubleToInt64(const double aDoubleValue)
Tolerance for floating-point comparison.
float RoundUp(float x)
Return x rounded up to the nearest integer.
float Cbrt(float x)
Return the cube root of a floating-point value.
Simple random integer generator.
ImageBuf OIIO_API pow(const ImageBuf &A, cspan< float > B, ROI roi={}, int nthreads=0)
bool isNegative< bool >(const bool &)
size_t MinIndex(const Vec3T &v)
Return the index [0,1,2] of the smallest value in a 3D vector.
bool isApproxEqual(const Type &a, const Type &b, const Type &tolerance)
Return true if a is equal to b to within the given tolerance.
Coord Abs(const Coord &xyz)
float Round(float x)
Return x rounded to the nearest integer.
bool isInfinite(const float x)
Return true if x is an infinity value (either positive infinity or negative infinity).
Type Pow4(Type x)
Return x4.
GLboolean GLboolean GLboolean GLboolean a
GLsizei const GLchar *const * string
Delta for small floating-point offsets.
float Sqrt(float x)
Return the square root of a floating-point value.
bool isNan(const float x)
Return true if x is a NaN (Not-A-Number) value.
Type Pow3(Type x)
Return x3.
bool cwiseLessThan(const Mat< SIZE, T > &m0, const Mat< SIZE, T > &m1)
bool isRelOrApproxEqual(const Type &a, const Type &b, const Type &absTol, const Type &relTol)
typedef int(WINAPI *PFNWGLRELEASEPBUFFERDCARBPROC)(HPBUFFERARB hPbuffer
#define OPENVDB_NO_FP_EQUALITY_WARNING_BEGIN
bool isUlpsEqual(const double aLeft, const double aRight, const int64_t aUnitsInLastPlace)
bool isApproxZero(const Type &x)
Return true if x is equal to zero to within the default floating-point comparison tolerance...
Type Clamp(Type x, Type min, Type max)
Return x clamped to [min, max].
#define OPENVDB_EXACT_IS_APPROX_EQUAL(T)
RandInt(unsigned int seed, IntType imin, IntType imax)
Initialize the generator.
GLfloat GLfloat GLfloat GLfloat h
IMATH_HOSTDEVICE constexpr int ceil(T x) IMATH_NOEXCEPT
int Sign(const Type &x)
Return the sign of the given value as an integer (either -1, 0 or 1).
Library and file format version numbers.
void setSeed(unsigned int seed)
Set the seed value for the random number generator.
ImageBuf OIIO_API max(Image_or_Const A, Image_or_Const B, ROI roi={}, int nthreads=0)
const Type & Min(const Type &a, const Type &b)
Return the minimum of two values.
GLsizei const GLfloat * value
const EngineType & engine() const
Return a const reference to the random number generator.
Type Chop(Type x, Type delta)
Return x if it is greater or equal in magnitude than delta. Otherwise, return zero.
constexpr T pi()
Pi constant taken from Boost to match old behaviour.
Type EuclideanRemainder(Type x)
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.
INT64 INT64 INT64 remainder
int Floor(float x)
Return the floor of x.
bool ClampTest01(Type &x)
Return true if x is outside [0,1].
IMATH_INTERNAL_NAMESPACE_HEADER_ENTER IMATH_HOSTDEVICE constexpr T abs(T a) IMATH_NOEXCEPT
IntType operator()()
Return a randomly-generated integer in the current range.
float Sin(const float &x)
Return sin x.
T zeroVal()
Return the value of type T that corresponds to zero.
Rand01(const EngineType &engine)
Initialize the generator.
Type SmoothUnitStep(Type x)
Return 0 if x < 0, 1 if x > 1 or else (3 − 2 x) x .
void setRange(IntType imin, IntType imax)
Change the range over which integers are distributed to [imin, imax].
#define OPENVDB_VERSION_NAME
The version namespace name for this library version.
Type Remainder(Type x, Type y)
Return the remainder of x / y.
const Type & Max(const Type &a, const Type &b)
Return the maximum of two values.
SYS_API double sin(double x)
int Mod(int x, int y)
Return the remainder of x / y.
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...
bool isZero(const Type &x)
Return true if x is exactly equal to zero.
bool isFinite(const float x)
Return true if x is finite.
Type Exp(const Type &x)
Return ex.
IntType operator()(IntType imin, IntType imax)
Return a randomly-generated integer in the new range [imin, imax], without changing the current range...
FloatType operator()()
Return a uniformly distributed random number in the range [0, 1).
Type Clamp01(Type x)
Return x clamped to [0, 1].
#define OPENVDB_NO_FP_EQUALITY_WARNING_END
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...