Math.hpp

浏览该文件的文档.

 
 
#pragma once
 
#include "AstGlobal.h"
#include "AstUtil/MathDegree.hpp"
#include "AstUtil/Constants.h"
#include <cmath>
#include <cassert>
#include <algorithm>
 
AST_NAMESPACE_BEGIN
 
#ifdef A_GCC    //  GCC 内建 sincos 函数
// #pragma message("Using GCC built-in sincos function")
using ::sincos;
 
#else
 
A_ALWAYS_INLINE void sincos (double x, double *psin, double *pcos)
{
    *psin = sin(x);
    *pcos = cos(x);
}
 
#endif
 
 
class SinCos {
public:
    A_ALWAYS_INLINE
    double sin() const { return sin_; }
    A_ALWAYS_INLINE
    double& sin() { return sin_; }
    A_ALWAYS_INLINE
    double cos() const { return cos_; }
    A_ALWAYS_INLINE
    double& cos() { return cos_; }
public:
    double sin_;
    double cos_;
};
 
 
A_ALWAYS_INLINE SinCos sincos(double x)
{
    SinCos sc;
    sincos(x, &sc.sin_, &sc.cos_);
    return sc;
}
 
 
 
template<typename Scalar>
Scalar aMax(Scalar a, Scalar b)
{
    return a > b ? a : b;
}
 
template<typename Scalar>
Scalar aMin(Scalar a, Scalar b)
{
    return a < b ? a : b;
}
 
using std::max;
using std::min;
 
template<typename T>
A_CONSTEXPR_CXX14 const T& clamp(const T& val, const T& low, const T& high)
{
    #ifdef A_CXX14
    assert(low <= high && "low must be less than or equal to high");
    if(val < low){
        return low;
    }
    if(val > high){
        return high;
    }
    return val;
    #else
    return (val < low) ? low : ((val > high) ? high : val);
    #endif
}
 
 
A_ALWAYS_INLINE double asinSafe(double x)
{
    return std::asin(clamp(x, -1.0, 1.0));
}
 
A_ALWAYS_INLINE double acosSafe(double x)
{
    return std::acos(clamp(x, -1.0, 1.0));
}
 
A_ALWAYS_INLINE double sqrtSafe(double x)
{
    return std::sqrt((std::max)(x, 0.0));
}
 
template<typename Scalar>
Scalar square(Scalar x)
{
    return x * x;
}
 
 
A_ALWAYS_INLINE double aNormalizeAngleStart(double angle, double start)
{
    return angle - floor((angle - start) / kTwoPI) * kTwoPI;
}
 
 
A_ALWAYS_INLINE double aNormalizeAngle(double angle, double center)
{
    return aNormalizeAngleStart(angle, center - kPI);
}
 
 
A_ALWAYS_INLINE double aNormalizeAngle0To2Pi(double angle)
{
    return aNormalizeAngleStart(angle, 0);
}
 
A_ALWAYS_INLINE double aNormalizeAngleNegPiToPi(double angle)
{
    return aNormalizeAngleStart(angle, -kPI);
}
 
A_ALWAYS_INLINE double aNormalizeAngleNeg2PiTo0(double angle)
{
    return aNormalizeAngleStart(angle, -kTwoPI);
}
 
AST_NAMESPACE_END