BasicMath.h

Go to the documentation of this file.

#ifndef _ZFXMATH_INCLUDE_BASICMATH_H_
#define _ZFXMATH_INCLUDE_BASICMATH_H_

#include <assert.h>

namespace ZFXMath
{
    #undef DELTA
    #undef E
    #undef LOG2_E
    #undef LOG10_E
    #undef LOGE_2
    #undef LOGE_10
    #undef PI
    #undef SQRT_2

    const double EPSILON = 0.00001;

    const double E = 2.71828182845904523536;

    const double LOG2_E = 1.44269504088896340736;

    const double LOG10_E = 0.434294481903251827651;

    const double LOGE_2 = 0.693147180559945309417;

    const double LOGE_10 = 2.30258509299404568402;

    const double PI = 3.14159265358979323846;

    const double SQRT_2 = 1.41421356237309504880;

    template<class T> inline T RadToDeg(T& rad)
    {
        // rad * 180° / pi
        return rad * 57.295779513082320876798154814105;
    }

    template<class T> inline T DegToRad(T& degree)
    {
        // degree * pi / 180°
        return degree * 0.017453292519943295769236907684886;
    }

    template<class T> inline T Sin(const T& rad)
    {
        return ::sin(rad);
    }

    template<class T> inline T Cos(const T& rad)
    {
        return ::cos(rad);
    }

    template<class T> inline void SinCos( const T& rad, T& retSin, T& retCos )
    {
        retSin = Sin( rad );
        retCos = Cos( rad );
    }

    template<class T> inline T Tan(const T& rad)
    {
        return ::tan(rad);
    }

    template<class T> inline T ASin(const T& value)
    {
        return ::asin(value);
    }

    template<class T> inline T ACos(const T& value)
    {
        return ::acos(value);
    }

    template<class T> inline T ATan(const T& value)
    {
        return ::atan(value);
    }

    template<class T> inline T Sqrt(const T& value)
    {
        return ::sqrt(value);
    }

    template<class T> inline T Pow2(const T& base)
    {
        return base*base;
    }

    template<class T> inline T Pow(const T& base, const T& exp)
    {
        return ::pow(base,exp);
    }

    template<class T> inline T Mod(const T& value1, const T& value2)
    {
        return ::fmod(value1,value2);
        //return ( value1 - RoundDown(value1 / value2) * value2 );
    }

    template<class T> inline T Abs(const T& value)
    {
        return ((value < 0) ? -value : value); 
    }

    template<class T> inline T LogE(T& num)
    {
        return ::log(num);
    }

    template<class T> inline T Log10(T& num)
    {
        return ::log10(num);
    }

    template<class T> inline T Log(T& base, T& num)
    {
        return ( ::log(num) / ::log(base) );
    }

    template<class T> inline int Round(T& value)
    {
        return (int)(d<0 ? d-0.5 : d+0.5);
    }

    template<class T> inline T Round(T& value, int digits)
    {
        assert(digits >= -20 && digits <= 20);
        T v[] = {   -1e20, -1e19, -1e18, -1e17, -1e16, -1e15, -1e14, -1e13, -1e12,
                    -1e11, -1e10, -1e9, -1e8, -1e7, -1e6, -1e5, -1e4, -1e3, -1e2,
                    -10, 1, 10, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11,
                    1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19, 1e20 };
        return RoundDown(value / v[digits+20] + 0.5) * v[digits+20];
    }

    template<class T> inline int RoundUp(T& value)
    {
        //if(value - RoundDown(value) == 0)
        //  return (int)value;
        //else return (int)(value+1);
        return (int)::ceil(value);
    }

    template<class T> inline T RoundDown(T& value)
    {
        return (int)value;
    }

    template <class T> inline const bool IsEven(const T& value)
    {
        return (!(value&1));
    }

    template<class T> inline const T& Min(const T& value1, const T& value2)
    {
        return ( (value1 < value2) ? value1 : value2 );
    }

    template<class T> inline const T& Max(const T& value1, const T& value2)
    {
        return ( (value1 > value2) ? value1 : value2 );
    }

    template<class T> inline const T& Clamp(const T& value, const T& min, const T& max)
    {
        return ( (value < min) ? min : ( (value > max) ? max : value) );
    }

    template<class T> inline bool NearTo( const T& value, const T& nearto )
    {
        return Abs( nearto - value ) <= EPSILON;
    }

    template<class T> inline T Sign(const T& value)
    {
        return (T)((t < 0) ? (-1) : (t > 0 ? 1 : 0));
    }

    template<class T1, class T2> inline T1 Interpolate( const T1& v1, const T1& v2, const T2& lerp )
    {
        return v1 + ( v2 - v1 ) * lerp;
    }

    template<class T> 
    T Fac( T value )
    {
        assert( value >= 0 );
        T res = 1;
        while( value > 1 )
        {
            res *= value;
            value--;
        }
        return res;
    }


    template<class T> 
    T Frac( T value )
    {
        return value - RoundDown( value );
    }

    double Noise( unsigned int x )
    {
        x = ( x << 13 ) ^ x;
        return ( 1.0 - ( ( x * ( x * x * 15731 + 789221 ) + 1376312589) & 0x7FFFFFFF ) / 1073741824.0 );    
    }


    double Noise( unsigned int x, unsigned int y )
    {
        unsigned int n = x + y * 57;
        n = ( n << 13 ) ^ n;
        unsigned int result = ( ( n * ( n * n * 15731 + 789221 ) + 1376312589 ) & 0x7FFFFFFF);

        return ( 1.0 - double(result) / 1073741824.0 );
    }

    double SmoothNoise( unsigned int x )
    {
        double sides   = ( Noise( x - 1 ) + Noise( x + 1 ) ) /  4.0;
        double center  =   Noise( x ) / 2.0;
        return sides + center;
    }

    double SmoothNoise( unsigned int x, unsigned int y )
    {
        double corners = ( Noise(x-1, y-1)+Noise(x+1, y-1)+Noise(x-1, y+1)+Noise(x+1, y+1) ) / 16.0;
        double sides   = ( Noise(x-1, y)  +Noise(x+1, y)  +Noise(x, y-1)  +Noise(x, y+1) ) /  8.0;
        double center  =   Noise(x, y) / 4.0;
        return corners + sides + center;
    }

    double InterpolatedNoise( double x, double y )
    {
        int     integer_X    = int(x);
        double  fractional_X = x - integer_X;

        int     integer_Y    = int(y);
        double  fractional_Y = y - integer_Y;

        double v1 = Noise( integer_X,     integer_Y );
        double v2 = Noise( integer_X + 1, integer_Y);
        double v3 = Noise( integer_X,     integer_Y + 1 );
        double v4 = Noise( integer_X + 1, integer_Y + 1 );

        double i1 = Interpolate( v1, v2, fractional_X );
        double i2 = Interpolate( v3, v4, fractional_X );

        return Interpolate( i1, i2, fractional_Y );
    }

    double SmoothInterpolatedNoise( double x, double y )
    {
        int     integer_X    = int(x);
        double  fractional_X = x - integer_X;

        int     integer_Y    = int(y);
        double  fractional_Y = y - integer_Y;

        double v1 = SmoothNoise( integer_X,     integer_Y );
        double v2 = SmoothNoise( integer_X + 1, integer_Y);
        double v3 = SmoothNoise( integer_X,     integer_Y + 1 );
        double v4 = SmoothNoise( integer_X + 1, integer_Y + 1 );

        double i1 = Interpolate( v1, v2, fractional_X );
        double i2 = Interpolate( v3, v4, fractional_X );

        return Interpolate( i1, i2, fractional_Y );
    }



    struct ARGB
    {
        union
        {
            unsigned long   argb;
            struct
            {
#ifdef LITTLE_ENDIAN
                unsigned char B : 8;
                unsigned char G : 8;
                unsigned char R : 8;
                unsigned char A : 8;
#else
                unsigned char A : 8;
                unsigned char R : 8;
                unsigned char G : 8;
                unsigned char B : 8;
#endif
            };
        };

        ARGB() {}

        template<class T>
        ARGB( const T& r, const T& g, const T& b, const T& a )
        {
            R = (unsigned char) ( r * 255.0 );
            G = (unsigned char) ( g * 255.0 );
            B = (unsigned char) ( b * 255.0 );
            A = (unsigned char) ( a * 255.0 );
        }

        ARGB( unsigned char r, unsigned char g, unsigned char b, unsigned char a )
        {
            R = r;
            G = g;
            B = b;
            A = a;
        }

        operator unsigned long ()   { return argb; }
        operator const unsigned long () const { return argb; }

    };


}

#endif //_ZFXMATH_INCLUDE_BASICMATH_H_

---