math.h

Go to the documentation of this file.

//
// Copyright 2016 Pixar
//
// Licensed under the Apache License, Version 2.0 (the "Apache License")
// with the following modification; you may not use this file except in
// compliance with the Apache License and the following modification to it:
// Section 6. Trademarks. is deleted and replaced with:
//
// 6. Trademarks. This License does not grant permission to use the trade
//    names, trademarks, service marks, or product names of the Licensor
//    and its affiliates, except as required to comply with Section 4(c) of
//    the License and to reproduce the content of the NOTICE file.
//
// You may obtain a copy of the Apache License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the Apache License with the above modification is
// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the Apache License for the specific
// language governing permissions and limitations under the Apache 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>

PXR_NAMESPACE_OPEN_SCOPE

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);
}

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