Math.hpp

浏览该文件的文档.

 
 
#pragma once
 
#include "AstGlobal.h"
#include "AstUtil/MathDegree.hpp"
#include "AstUtil/Constants.hpp"
#include <cmath>
#include <cstddef>      // for size_t
#include <cassert>
#include <algorithm>
#include <type_traits>
#include <limits>       // for std::numeric_limits<double>::quiet_NaN()
 
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;
}
 
A_ALWAYS_INLINE size_t aDiscretizedCount(double span, double step)
{
    if (step <= 0.0 || span < 0.0)
        return 0;
    return static_cast<size_t>(std::ceil(span / step)) + 1;
}
 
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);
}
 
 
namespace propagate_nan
{
    A_ALWAYS_INLINE double (min)(double a, double b)
    {
        if(a <= b)
            return a;
        if(b <= a)
            return b;
        return std::numeric_limits<double>::quiet_NaN();
    }
 
    A_ALWAYS_INLINE double (max)(double a, double b)
    {
        if(a >= b)
            return a;
        if(b >= a)
            return b;
        return std::numeric_limits<double>::quiet_NaN();
    }
 
    // SWIG 无法解析 has_minus 中的 decltype SFINAE 检测，以下内部模板暂不暴露给 SWIG
#ifndef SWIG
    // -------------------- 类型标记：类型是否允许使用减法，需要用户通过类型特化 allow_efficient_minus 来明确允许 --------------------
    template <typename T>
    struct allow_efficient_minus : std::false_type {};
 
    // -------------------- 工具：检测是否存在 operator- --------------------
    template <typename T>
    struct has_minus
    {
        template <typename U>
        static auto test(int) -> decltype(std::declval<U>() - std::declval<U>(), std::true_type());
        template <typename U>
        static std::false_type test(...);
 
        static constexpr bool value = decltype(test<T>(0))::value;
    };
 
    // -------------------- 类型标记：是否使用减法 --------------------
    template <typename T>
    struct use_efficient_minus
    {
        static constexpr bool value = allow_efficient_minus<T>::value && has_minus<T>::value;
    };
 
    template<typename T>
    typename std::enable_if<!use_efficient_minus<T>::value,const T&>::type 
    (min)(const T& a, const T& b)
    {
        // 不支持 operator- 的类型，直接比较大小
        if(a <= b)
            return a;
        if(b <= a)
            return b;
        if(a != a)
            return a;
        return b;
    }
    template <typename T>
    typename std::enable_if<use_efficient_minus<T>::value, const T&>::type 
    (min)(const T& a, const T& b) {
        // 支持 operator- 的类型，使用减法比较大小
        auto diff = a - b;         // 注意：这里会构造临时对象
        if (diff <= 0) return a;   // a <= b
        if (diff >= 0) return b;   // a >= b
        if(a != a)
            return a;
        return b;
    }
    
    template<typename T>
    typename std::enable_if<!use_efficient_minus<T>::value,const T&>::type 
    (max)(const T& a, const T& b)
    {
        // 不支持 operator- 的类型，直接比较大小
        if(a >= b)
            return a;
        if(b >= a)
            return b;
        if(a != a)
            return a;
        return b;
    }
    template <typename T>
    typename std::enable_if<use_efficient_minus<T>::value, const T&>::type 
    (max)(const T& a, const T& b) 
    {
        // 支持 operator- 的类型，使用减法比较大小
        auto diff = a - b;        // 注意：这里会构造临时对象
        if (diff >= 0) return a;   // a >= b
        if (diff <= 0) return b;   // a <= b
        if(a != a)
            return a;
        return b;
    }
#endif  // !SWIG
}
 
AST_NAMESPACE_END