math.h

Go to the documentation of this file.

//
// Copyright 2016 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
#ifndef PXR_BASE_GF_MATH_H
#define PXR_BASE_GF_MATH_H
 
 
#include "pxr/pxr.h"
#include "pxr/base/arch/math.h"
#include "pxr/base/gf/api.h"
#include "pxr/base/gf/traits.h"
 
#include <type_traits>
#include <typeinfo>
 
PXR_NAMESPACE_OPEN_SCOPE
 
class TfType;
 
inline bool GfIsClose(double a, double b, double epsilon) {
    return fabs(a-b) < epsilon;
}
 
inline double   GfRadiansToDegrees(double radians) {
    return radians * (180.0 / M_PI);
}
 
inline double   GfDegreesToRadians(double degrees) {
    return degrees * (M_PI / 180.0);
}
 
GF_API
double GfSmoothStep(double min, double max, double val, 
    double slope0 = 0.0, double slope1 = 0.0);
 
GF_API
double GfSmoothRamp(double tmin, double tmax, double t, double w0, double w1); 
 
template <class T>
inline double GfSqr(const T& x) {
    return x * x;
}
 
template <typename T>
inline T
GfSgn(T v) {
    return (v < 0) ? -1 : ((v > 0) ? 1 : 0);
}
 
inline double GfSqrt(double f) { return std::sqrt(f); }
inline float GfSqrt(float f) { return std::sqrt(f); }
 
inline double GfExp(double f) { return std::exp(f); }
inline float GfExp(float f) { return std::exp(f); }
 
inline double GfLog(double f) { return std::log(f); }
inline float GfLog(float f) { return std::log(f); }
 
inline double GfFloor(double f) { return std::floor(f); }
inline float GfFloor(float f) { return std::floor(f); }
 
inline double GfCeil(double f) { return std::ceil(f); }
inline float GfCeil(float f) { return std::ceil(f); }
 
inline double GfAbs(double f) { return std::fabs(f); }
inline float GfAbs(float f) { return std::fabs(f); }
 
inline double GfRound(double f) { return std::rint(f); }
inline float GfRound(float f) { return std::rint(f); }
 
inline double GfPow(double f, double p) { return std::pow(f, p); }
inline float GfPow(float f, float p) { return std::pow(f, p); }
 
inline double GfSin(double v) { return std::sin(v); }
inline float GfSin(float v) { return std::sin(v); }
inline double GfCos(double v) { return std::cos(v); }
inline float GfCos(float v) { return std::cos(v); }
inline void GfSinCos(double v, double *s, double *c) { ArchSinCos(v, s, c); }
inline void GfSinCos(float v, float *s, float *c) { ArchSinCosf(v, s, c); }
 
inline double GfClamp(double value, double min, double max) {
    if (value < min) return min;
    if (value > max) return max;
    return value;
}
 
inline float GfClamp(float value, float min, float max) {
    if (value < min) return min;
    if (value > max) return max;
    return value;
}    
 
GF_API
double GfMod(double a, double b);
// \ingroup group_gf_BasicMath
GF_API
float GfMod(float a, float b);
 
template <class T>
inline T GfLerp( double alpha, const T& a, const T& b) {
    return (1-alpha)* a + alpha * b;
}
 
template <class T>
inline T GfMin(T a1, T a2) {
    return (a1 < a2 ? a1 : a2);
}
template <class T>
inline T GfMin(T a1, T a2, T a3) {
    return GfMin(GfMin(a1, a2), a3);
}
template <class T>
inline T GfMin(T a1, T a2, T a3, T a4) {
    return GfMin(GfMin(a1, a2, a3), a4);
}
template <class T>
inline T GfMin(T a1, T a2, T a3, T a4, T a5) {
    return GfMin(GfMin(a1, a2, a3, a4), a5);
}
 
template <class T>
inline T GfMax(T a1, T a2) {
    return (a1 < a2 ? a2 : a1);
}
template <class T>
inline T GfMax(T a1, T a2, T a3) {
    return GfMax(GfMax(a1, a2), a3);
}
template <class T>
inline T GfMax(T a1, T a2, T a3, T a4) {
    return GfMax(GfMax(a1, a2, a3), a4);
}
template <class T>
inline T GfMax(T a1, T a2, T a3, T a4, T a5) {
    return GfMax(GfMax(a1, a2, a3, a4), a5);
}
 
template <typename Left, typename Right,
          std::enable_if_t<GfIsArithmetic<Left>::value &&
                           GfIsArithmetic<Right>::value, int> = 0>
inline decltype(std::declval<Left>() * std::declval<Right>())
GfDot(Left left, Right right) {
    return left * right;
}
 
template <typename Left, typename Right,
          std::enable_if_t<GfIsArithmetic<Left>::value &&
                           GfIsArithmetic<Right>::value, int> = 0>
inline decltype(std::declval<Left>() * std::declval<Right>())
GfCompMult(Left left, Right right) {
    return left * right;
}
 
template <typename Left, typename Right,
          std::enable_if_t<GfIsArithmetic<Left>::value &&
                           GfIsArithmetic<Right>::value, int> = 0>
inline decltype(std::declval<Left>() / std::declval<Right>())
GfCompDiv(Left left, Right right) {
    return left / right;
}
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_BASE_GF_MATH_H