math.h

 
#ifndef _aspose_system_math_h_
#define _aspose_system_math_h_
 
#include <system/primitive_types.h>
#include <system/decimal.h>
 
#include <cmath>
#include <type_traits>
 
#include <fwd.h>
 
namespace System
{
    struct Math
    {
        static const double ASPOSECPP_SHARED_API PI; // 3.1415926535897931
        static const double ASPOSECPP_SHARED_API E;  // 2.7182818284590451
        
        static ASPOSECPP_SHARED_API double Acos(double d);
        static ASPOSECPP_SHARED_API double Asin(double d);
        static ASPOSECPP_SHARED_API double Atan(double d);
        static ASPOSECPP_SHARED_API double Atan2(double y, double x);
        static ASPOSECPP_SHARED_API Decimal Ceiling(const Decimal& d);
        static ASPOSECPP_SHARED_API double Ceiling(double a);
        static ASPOSECPP_SHARED_API double Cos(double d);
        static ASPOSECPP_SHARED_API double Cosh(double value);
        static ASPOSECPP_SHARED_API Decimal Floor(const Decimal& d);
        static ASPOSECPP_SHARED_API double Floor(double d);
        static ASPOSECPP_SHARED_API double Sin(double a);
        static ASPOSECPP_SHARED_API double Tan(double a);
        static ASPOSECPP_SHARED_API double Sinh(double value);
        static ASPOSECPP_SHARED_API double Tanh(double value);
        static ASPOSECPP_SHARED_API double Round(double a);
        static ASPOSECPP_SHARED_API double Round(double value, int digits);
        static ASPOSECPP_SHARED_API double Round(double value, MidpointRounding mode);
        static ASPOSECPP_SHARED_API double Round(double value, int digits, MidpointRounding mode);
        static ASPOSECPP_SHARED_API Decimal Round(const Decimal& d);
        static ASPOSECPP_SHARED_API Decimal Round(const Decimal& value, int digits);
        static ASPOSECPP_SHARED_API Decimal Round(const Decimal& d, MidpointRounding mode);
        static ASPOSECPP_SHARED_API Decimal Round(const Decimal& d, int digits, MidpointRounding mode);
        static ASPOSECPP_SHARED_API Decimal Truncate(const Decimal& d);
        static ASPOSECPP_SHARED_API double Truncate(double d);
        static ASPOSECPP_SHARED_API double Sqrt(double d);
        static ASPOSECPP_SHARED_API double Log(double d);
        static ASPOSECPP_SHARED_API double Log10(double d);
        static ASPOSECPP_SHARED_API double Exp(double d);
        static ASPOSECPP_SHARED_API double Pow(double x, double y);
        static ASPOSECPP_SHARED_API double IEEERemainder(double x, double y);
        template<class T>
        static T Abs(T value)
        {
            static_assert(std::is_arithmetic<T>::value, "Math::Abs template argument must be an arithmetic type.");
 
            return std::abs(value);
        }
        static inline Decimal Abs(const Decimal &d)
        {
            return d < 0 ? -d : d;
        }
 
        static ASPOSECPP_SHARED_API double Log(double a, double newBase);
 
        template<typename T>
    static typename std::enable_if<std::is_integral<T>::value && !std::is_unsigned<T>::value, int>::type Sign(T value)
        {
            if (value == 0)
                return 0;
            else if (value > 0)
                return 1;
            else
                return -1;
        }
 
        template<typename T>
    static typename std::enable_if<std::is_floating_point<T>::value, int>::type Sign(T value)
        {
        if (value < 0)
                return -1;
            else if (value > 0)
                return 1;
            else if (value == 0)
               return 0;
 
            throw ArithmeticException(u"NaN");
        }
 
        static inline int Sign(const Decimal &value)
        {
           return value.CompareTo(Decimal::Zero);
        }
 
        static ASPOSECPP_SHARED_API int64_t BigMul(int a, int b);
 
        static ASPOSECPP_SHARED_API int DivRem(int a, int b, int &result);
        static ASPOSECPP_SHARED_API int64_t DivRem(int64_t a, int64_t b, int64_t &result);
 
    //  >= .Net 2.0
        //static float Round(float a);
 
    //  not a .Net
        static const double ASPOSECPP_SHARED_API PositiveInfinity;
        static const double ASPOSECPP_SHARED_API NegativeInfinity;
        static const double ASPOSECPP_SHARED_API NaN;
 
        template<class T>
        static T Modulus(T x, T y)
        {
            return std::fmod(x,y);
        }
 
        template<class T0, class T1, class = typename std::enable_if<!std::is_same<T0, T1>::value, void>::type>
        static auto Min(T0 val1, T1 val2) -> decltype(val1 + val2)
        {
            return Min_<decltype(val1 + val2)>(val1, val2);
        }
        template<class T0, class T1, class = typename std::enable_if<std::is_same<T0, T1>::value, void>::type>
        static T0 Min(T0 val1, T1 val2)
        {
            return Min_<decltype(val1 + val2)>(val1, val2);
        }
 
        template<class T0, class T1, class = typename std::enable_if<!std::is_same<T0, T1>::value, void>::type>
        static auto Max(T0 val1, T1 val2)  -> decltype(val1 + val2)
        {
            using T = decltype(val1 + val2);
            return Max_<T>(static_cast<T>(val1), static_cast<T>(val2));
        }
        template<class T0, class T1, class = typename std::enable_if<std::is_same<T0, T1>::value, void>::type>
        static T0 Max(T0 val1, T1 val2)
        {
            return Max_<T0>(val1, static_cast<T0>(val2));
        }
 
    private:
        template <class T>
        static T Min_(T val1, T val2)
        {
            return val1 <= val2 ? val1 : val2;
        }
 
        template <class T>
        static T Max_(T val1, T val2)
        {
            return val1 >= val2 ? val1 : val2;
        }
 
        enum { MaxRoundingDigits = 15 };
 
        static const double RoundPower10Double[];
        static const double DoubleRoundLimit; // 1e16d
        
        static ASPOSECPP_SHARED_API double RoundImpl(double value, int digits, MidpointRounding mode);
    }; // class Math
 
    template <>
    inline float Math::Min_(float val1, float val2)
    {
        if (val1 < val2)
            return val1;
        if (System::IsNaN<float>(val1))
            return val1;
        return val2;
    }
 
    template <>
    inline double Math::Min_(double val1, double val2)
    {
        if (val1 < val2)
            return val1;
        if (System::IsNaN<double>(val1))
            return val1;
        return val2;
    }
 
    template <>
    inline float Math::Max_(float val1, float val2)
    {
        if (val1 > val2)
            return val1;
        if (System::IsNaN<float>(val1))
            return val1;
        return val2;
    }
 
    template <>
    inline double Math::Max_(double val1, double val2)
    {
        if (val1 > val2)
            return val1;
        if (System::IsNaN<double>(val1))
            return val1;
        return val2;
    }
 
} // namespace System
 
#endif // _math_h_