Calc.h

Go to the documentation of this file.

//
 
#ifndef _INC_Calc_H
#define _INC_Calc_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
#if _MSC_VER >= 1000
//#pragma warning(disable:4275) // stupid linkage warning.
#endif // _MSC_VER >= 1000
 
#include "../GrayLibBase.h"
#include "GrayCore/include/cUnitTestDecl.h"
#include "GrayCore/include/cTypes.h"
#include "GrayCore/include/cDebugAssert.h"
#include "GrayCore/include/cLogMgr.h"
 
#include <float.h>
#include <math.h>
 
namespace GrayLib
{
        UNITTEST2_PREDEF(Calc);
 
        typedef float RADIANf_t;        
 
        static const float k_FLT_MAX2 = ((float)INT_MAX);               
        static const float k_FLT_MIN2 = 0.0001f;                                
 
        typedef int Percent10_t;        
        static const Percent10_t k_Percent10_MAX = 1000;                
 
        template< typename TYPE = double >
        struct GRAYLIB_LINK cTypeF : public cTypeLimit<TYPE> // static
        {
 
                // static const TYPE k_NaN;             // #NAN // same for both float and double
                // static const TYPE k_InfPos;          // #INF INFINITY
                // static const TYPE k_InfNeg;          // #INF INFINITY
                // #IND ??
 
                static const TYPE k_MinPos;             
                static const TYPE k_MaxSqrt;    
                static const TYPE k_Epsilon;    
 
                static const TYPE k_PI;                 
                static const TYPE k_PI2;                
                static const TYPE k_PIHalf;             
 
                static const TYPE k_e;                  
                static const TYPE k_Log2e;              
                static const TYPE k_Log10e;             
                static const TYPE k_Ln2;                
                static const TYPE k_Ln10;               
        };
 
        struct GRAYLIB_LINK CalcI // static
        {
 
                template< typename TYPE >
                static inline int Sign(TYPE a)
                {
                        return((a > 0) ? 1 : ((a < 0) ? -1 : 0));
                }
                template< typename TYPE >
                static inline bool IsInRange(TYPE n, TYPE low, TYPE high) noexcept
                {
                        ASSERT(low <= high);
                        return(n >= low && n <= high);
                }
                template< typename TYPE >
                static inline bool IsInBetween(TYPE n, TYPE a, TYPE b) noexcept
                {
                        if (a <= b)
                                return IsInRange(n, a, b);
                        else
                                return IsInRange(n, b, a);
                }
                template< typename TYPE >
                static inline TYPE Min(TYPE a, TYPE b) noexcept
                {
                        return (a < b) ? a : b;
                }
                template< typename TYPE >
                static inline TYPE Max(TYPE a, TYPE b) noexcept
                {
                        return (a < b) ? b : a;
                }
                template< typename TYPE >
                static inline TYPE Max3(TYPE a, TYPE b, TYPE c) noexcept
                {
                        TYPE d = Max(a, b);
                        return Max(c, d);
                }
                template< typename TYPE >
                static inline TYPE Clamp(TYPE value, TYPE low, TYPE high)
                {
                        ASSERT(low <= high);
                        if (value < low)
                                return low;
                        if (value > high)
                                return high;
                        return value;
                }
                template< typename TYPE >
                static inline void ClampRef(TYPE& rValue, TYPE low, TYPE high)
                {
                        ASSERT(low <= high);
                        TYPE value = rValue;
                        if (value < low)
                                rValue = low;
                        else if (value > high)
                                rValue = high;
                }
                template< typename TYPE >
                static inline bool IsNear(TYPE n1, TYPE n2, TYPE nDiff = (TYPE)k_FLT_MIN2) noexcept
                {
                        // ASSERT( nDiff >= 0 );
                        return Abs(n1 - n2) <= nDiff ;
                }
                template< typename TYPE >
                static inline TYPE Sqr(TYPE a) noexcept
                {
                        return a * a ;
                }
 
                template< typename TYPE >
                static inline TYPE Abs(TYPE a) noexcept;                        
                template< typename TYPE >
                static inline TYPE Mod(TYPE a, TYPE b); 
 
                template< typename TYPE >
                static inline TYPE Wrap(TYPE nVal, TYPE nMod)
                {
                        ASSERT(nMod > 0);
                        TYPE nTmp = Mod(nVal, nMod);
                        if (nTmp < 0)
                        {
                                return nTmp + nMod;     // wrap back to positive.
                        }
                        return nTmp;
                }
 
                // Numeric formulas
                static inline bool IsSignDiff(int a, int b) noexcept
                {
                        return ((a ^ b) < 0);
                }
 
                template< typename TYPE >
                static inline TYPE GetGreatestCommonDivisor(TYPE x, TYPE y)
                {
                        for (;;)
                        {
                                if (y == 0)
                                        return x;
                                x = Mod(x, y);
                                if (x == 0)
                                        return y;
                                y = Mod(y, x);
                        }
                }
 
                template <typename TYPE>
                static inline TYPE MulDiv(TYPE a, TYPE b, TYPE c)
                {
                        // ASSERT(c);
                        return((a*b) / c);
                }
 
                template <typename TYPE>
                static inline TYPE DivideUp(TYPE a, TYPE b)
                {
#define DIVIDEUP(a,b)    (((a) + ((b) - 1)) / (b))      // for use as a constant.
                        return DIVIDEUP(a, b);
                }
 
                template <typename TYPE>
                static inline TYPE AddC(TYPE a, TYPE b, bool& bCarry) noexcept
                {
                        TYPE nResult = a + b;
                        if (bCarry)             // Handle incoming carry.
                        {
                                nResult++;
                                bCarry = (nResult <= b); // handle the cases of 0xFFFF + 0xFFFF + 1 and 0xFFFF + 0 + 1
                        }
                        else
                        {
                                // If a rollover occurred, the result is less than either input.
                                bCarry = (nResult < b); // e.g. 0xFFFF + 1, 0 + 0, 0xFFFF + 0.
                        }
                        return nResult;
                }
 
                template <typename TYPE>
                static inline TYPE SubC(TYPE a, TYPE b, bool& bBorrow) noexcept
                {
                        TYPE nResult = a - b;
                        if (bBorrow)    // Handle an incoming borrow
                        {
                                nResult--;
                                bBorrow = (nResult >= a); // special handling for: 0xFFFF - 0xFFFF - 1, 0xFFFF - 0 - 1.
                        }
                        else
                        {
                                // If a reverse rollover occurred, the result is greater than the block from a.
                                bBorrow = (nResult > a); // Pass the borrow along
                        }
                        return nResult;
                }
 
                // TODO
                // http://stackoverflow.com/questions/13187629/gcc-intrinsic-for-extended-division-multiplication
                // Mul2 = multiply with high and low results. void extmul(size_t a, size_t b, size_t *lo, size_t *hi);
                // Div2 = divide with quotient and remainder returned. void extdiv(size_t a, size_t b, size_t *q, size_t *r);
 
                template <typename TYPE>
                static inline bool ToBool(TYPE nVal) noexcept
                {
                        return (nVal | ((TYPE)(-nVal))) >> ((sizeof(nVal) * 8) - 1);    // to 0 or 1
                }
 
                static int GRAYCALL Log2Est(UINT iVal);
 
                // return a percentage. e.g. iValDiff=0 returns a 50.0% chance.
                static Percent10_t GRAYCALL GetSCurve(int iValDiff, int iValVarianceHalf);
                static Percent10_t GRAYCALL GetBellCurve(int iValDiff, int iValVarianceHalf);
        };
 
#ifdef UNDER_CE // like _FNF(x)
#define _FFF(c) (float) c
#else
#define _FFF(c) c##f
#endif
 
        template<> inline float CalcI::Abs<float>(float a) noexcept
        {
                return ::fabsf(a);
        }
        template<> inline float CalcI::Mod<float>(float a, float b)
        {
                return ::fmodf(a, b);
        }
 
        template<> inline double CalcI::Abs<double>(double a) noexcept
        {
                return ::fabs(a);
        }
        template<> inline double CalcI::Mod<double>(double a, double b)
        {
                return ::fmod(a, b);
        }
 
        template<> inline int CalcI::Abs<int>(int a) noexcept
        {
                return labs(a);
        }
        template<> inline int CalcI::Mod<int>(int a, int b)
        {
                return a % b;
        }
 
        template<> inline UINT CalcI::Abs<UINT>(UINT a) noexcept
        {
                return ::labs(a);
        }
        template<> inline UINT CalcI::Mod<UINT>(UINT a, UINT b)
        {
                return(a % b);
        }
 
        template<> inline UINT16 CalcI::MulDiv<UINT16>(UINT16 a, UINT16 b, UINT16 c)
        {
                return (UINT16)(((UINT32)a*(UINT32)b) / c);
        }
 
#ifdef USE_INT64
        template<> inline UINT32 CalcI::MulDiv<UINT32>(UINT32 a, UINT32 b, UINT32 c)
        {
                return (UINT32)(((UINT64)a*(UINT64)b) / c);
        }
#endif
 
#if 0 // defined(_MSC_VER) && defined(_M_AMD64)
        template<> inline UINT64 CalcI::MulDiv<UINT64>(UINT64 a, UINT64 b, UINT64 c)
        {
 
                UINT64 h;
                UINT64 l = _umul128(a, b, &h);
                if (h == 0)
                {
                        return l / c;
                }
                // TODO / c
                return 0;       
        }
#endif
 
        //****************************************************************************
 
        struct GRAYLIB_LINK Calc : public CalcI, public cTypeFloat // static
        {
 
                template< typename TYPE >
                static inline bool IsSignDiff(TYPE a, TYPE b) noexcept
                {
                        return ((a >= 0) ^ (b >= 0));   // sign change
                }
 
                template< typename TYPE >
                static inline TYPE WrapRadians(TYPE nRadians) noexcept
                {
                        return Wrap(nRadians, cTypeF<TYPE>::k_PI2); 
                }
                template< typename TYPE >
                static inline TYPE WrapRadiansSigned(TYPE nRadians) noexcept
                {
                        TYPE nTmp = WrapRadians(nRadians);
                        if (nTmp > cTypeF<TYPE>::k_PI)
                                nTmp -= cTypeF<TYPE>::k_PI2;
                        return nTmp;
                }
                template< typename TYPE >
                static inline TYPE GetDiffRadians(TYPE n1, TYPE n2) noexcept
                {
                        return WrapRadiansSigned(n1 - n2);
                }
                template< typename TYPE >
                static inline TYPE Degree2Radian(TYPE nDegree) noexcept
                {
                        return (nDegree * (cTypeF<TYPE>::k_PI / (TYPE) 180.0));
                }
                template< typename TYPE >
                static inline TYPE Radian2Degree(TYPE nRadians) noexcept
                {
                        return (nRadians * ((TYPE) 180.0 / cTypeF<TYPE>::k_PI));
                }
                template< typename TYPE >
                static inline TYPE Lerp(TYPE nVal1, TYPE nVal2, TYPE fRatio) noexcept
                {
                        return(nVal1 + ((nVal2 - nVal1) * fRatio));
                }
 
                template< typename TYPE >
                static inline TYPE Round(TYPE a)
                {
                        if (a < 0)
                                return Floor(a + (TYPE) 0.5);
                        else
                                return Ceil(a - (TYPE) 0.5);
                }
 
                template< typename TYPE >
                static inline bool IsInteger(TYPE a)
                {
                        return a == Floor(a);
                }
 
                template< typename TYPE >
                static inline TYPE Floor(TYPE a);
                template< typename TYPE >
                static inline TYPE Ceil(TYPE a);
                template< typename TYPE >
                static inline TYPE Sqrt(TYPE a)
                {
                        ASSERT(0);      // No used for int type, etc.
                        return 0;
                }
 
                template< typename TYPE >
                static inline TYPE Sin(TYPE a);
                template< typename TYPE >
                static inline TYPE Cos(TYPE a);
                template< typename TYPE >
                static inline TYPE Tan(TYPE a);
 
                template< typename TYPE >
                static inline void SinCos(TYPE a, TYPE& s, TYPE& c);
 
                template< typename TYPE >
                static inline TYPE ASin(TYPE a);
                template< typename TYPE >
                static inline TYPE ACos(TYPE a);
                template< typename TYPE >
                static inline TYPE ATan(TYPE a);
 
                // The signs of the x and y parameters are used to determine the quadrant of the return values within the range of -p to p.
                // The atan2 HLSL intrinsic function is well-defined for every point other than the origin, even if y equals 0 and x does not equal 0.
                template< typename TYPE >
                static inline TYPE ATan2(TYPE y, TYPE x);
 
                template< typename TYPE >
                static inline TYPE Exp(TYPE a);
                template< typename TYPE >
                static inline TYPE Log(TYPE a); 
 
                template< typename TYPE >
                static inline TYPE Pow(TYPE nBase, TYPE nExp); 
 
                template< typename TYPE >
                static inline TYPE Pow10(TYPE x)
                {
                        return Exp(cTypeF<TYPE>::k_Ln10 * x);
                }
                template< typename TYPE >
                static inline TYPE Pow2(TYPE x)
                {
                        return Exp(cTypeF<TYPE>::k_Ln2 * x);
                }
 
                template< typename TYPE >
                static inline TYPE Log10(TYPE a);                               // negative will throw ?
 
                template< typename TYPE >
                static inline TYPE Log2(TYPE a)
                {
                        // negative will throw ?
                        return Log(a) * cTypeF<TYPE>::k_Log2e;
                }
 
                template< typename TYPE >
                static inline TYPE LogN(TYPE x, TYPE b = 10)
                {
                        return Log(x) / Log(b);
                }
 
                UNITTEST_FRIEND(Calc);
        };
 
        //***********************************************************
 
        template<> inline float Calc::Floor<float>(float a)
        {
                return _FFF(::floor)(a);
        }
        template<> inline float Calc::Ceil<float>(float a)
        {
                return _FFF(::ceil)(a);
        }
        template<> inline float Calc::Sqrt<float>(float a)
        {
                return _FFF(::sqrt)(a);
        }
        template<> inline float Calc::Sin<float>(float a)
        {
                // RADIANf_t
                return _FFF(::sin)(a);
        }
        template<> inline float Calc::Cos<float>(float a)
        {
                // RADIANf_t
                return _FFF(::cos)(a);
        }
        template<> inline float Calc::Tan<float>(float a)
        {
                // RADIANf_t
                return _FFF(::tan)(a);
        }
        template<> inline void Calc::SinCos<float>(float a, float& s, float& c)
        {
#if defined(_MSC_VER) && !defined(USE_64BIT)
                __asm
                {
                        fld[a]
                        mov eax, [c]
                        fsincos
                        mov ecx, [s]
                        fstp[eax]
                        fstp[ecx]
                }
#else
                s = _FFF(::sin)(a);
                c = _FFF(::cos)(a);
#endif
        }
        template<> inline float Calc::ASin<float>(float a)
        {
                return _FFF(::asin)(a);
        }
        template<> inline float Calc::ACos<float>(float a)
        {
                return _FFF(::acos)(a);
        }
        template<> inline float Calc::ATan<float>(float a)
        {
                return _FFF(::atan)(a);
        }
        template<> inline float Calc::ATan2<float>(float y, float x)
        {
                return _FFF(::atan2)(y, x);
        }
        template<> inline float Calc::Log<float>(float a)
        {
                return _FFF(::log)(a);
        }
        template<> inline float Calc::Log10<float>(float a)
        {
                return _FFF(::log10)(a);
        }
        template<> inline float Calc::Exp<float>(float a)
        {
                return _FFF(::exp)(a);
        }
        template<> inline float Calc::Pow<float>(float a, float nExp)
        {
                return _FFF(::pow)(a, nExp);
        }
 
#undef _FFF
 
        //***********************************************************
 
        template<> inline double Calc::Floor<double>(double a)
        {
                return ::floor(a);
        }
        template<> inline double Calc::Ceil<double>(double a)
        {
                return ::ceil(a);
        }
        template<> inline double Calc::Sqrt<double>(double a)
        {
                return ::sqrt(a);
        }
        template<> inline double Calc::Sin<double>(double a)
        {
                return ::sin(a);
        }
        template<> inline double Calc::Cos<double>(double a)
        {
                return ::cos(a);
        }
        template<> inline double Calc::Tan<double>(double a)
        {
                return ::tan(a);
        }
        template<> inline void Calc::SinCos<double>(double a, double& s, double& c)
        {
#if defined(_MSC_VER) && !defined(USE_64BIT)
                __asm
                {
                        fld   qword ptr[a]
                        mov   eax, dword ptr[c]
                        mov   ebx, dword ptr[s]
                        fsincos
                        fstp  qword ptr[eax]
                        fstp  qword ptr[ebx]
                }
#else
                s = ::sin(a);
                c = ::cos(a);
#endif
        }
        template<> inline double Calc::ASin<double>(double a)
        {
                return ::asin(a);
        }
        template<> inline double Calc::ACos<double>(double a)
        {
                return ::acos(a);
        }
        template<> inline double Calc::ATan<double>(double a)
        {
                return ::atan(a);
        }
        template<> inline double Calc::ATan2<double>(double y, double x)
        {
                return ::atan2(y, x);
        }
        template<> inline double Calc::Log<double>(double a)
        {
                return ::log(a);
        }
        template<> inline double Calc::Log10<double>(double a)
        {
                return ::log10(a);
        }
        template<> inline double Calc::Exp<double>(double a)
        {
                return ::exp(a);
        }
        template<> inline double Calc::Pow<double>(double a, double nExp)
        {
                return ::pow(a, nExp);
        }
} 
#endif // _INC_Calc_H