K3dMath.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2007 by Jan Koci   *
 *   honza.koci@email.cz   *
 *   http://kengine.sourceforge.net/tutorial/
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#pragma once

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <cmath>

#define TINY (0.0000001)

class K3dMath
{
                static float ConvertHalfPiSin ( const float fAngle, bool &rbNeg );              
                static float ConvertHalfPiCos ( const float fAngle, bool &rbNeg );
                // Convert to TWO_PI
                static float ConvertTwoPi ( const float fAngle );

        public:
                K3dMath();// {}
                ~K3dMath(); //{}


                // Get if this number is odd or even
                static bool IsOddNumber ( int i )
                {
                        if ( i%2 )
                        {
                                return  true;
                        }
                        else
                        {
                                return false;
                        }
                }

                static float ACos ( const float fValue );
                static float ASin ( const float fValue );
                static float ATan ( const float fValue );
                static float ATan2 ( const float fY, const  float fX );
                static float Ceil ( const float fValue );
                static float Cos ( const float fValue );
                static float Exp ( const float fValue );
                static float FAbs ( const float fValue );
                static float Floor ( const float fValue );
                static float FMod ( const float fX, const  float fY );
                static float InvSqrt ( const float fValue );
                static float Log ( const float fValue );
                static float Pow ( const float fBase, const  float fExponent );
                static float Sin ( const float fValue );
                static float Sqr ( const float fValue );
                static float Sqrt ( const float fValue );
                static float Tan ( const float fValue );

                static int Sign ( const int iValue );
                static int Sign ( const float fValue );

                static float FastSin0 ( const float fAngle );
                static float FastSin1 ( const float fAngle );
                static float FastCos0 ( const float fAngle );
                static float FastCos1 ( const float fAngle );
                static float FastTan0 ( const float fAngle );
                static float FastTan1 ( const float fAngle );
                static float FastASin ( const float fValue );
                static float FastACos ( const float fValue );
                static float FastATan0 ( const float fValue );
                static float FastATan1 ( const float fValue );
                static float UnitRandom ( const float fSeed = ( float ) 0.0 );
                static float SymmetricRandom ( const float fSeed = ( float ) 0.0 );
                static float IntervalRandom ( const float fMin, const float fMax, const float fSeed = ( float ) 0.0 );
                static float Positive ( const float fValue );
                static int Positive ( const int iValue );
                static float Negative ( const float fValue );
                static int Negative ( const int iValue );
                static bool EqualRange ( const float _f0, const float _f1, const float _fRange );

                static const float EPSILON;
                static const float MAX_REAL;
                static const float K_PI;
                static const float TWO_PI;
                static const float HALF_PI;
                static const float QUARTER_PI;
                static const float THREE_HALF_PI;
                static const float INV_PI;
                static const float INV_TWO_PI;
                static const float K_DEG_TO_RAD;
                static const float K_RAD_TO_DEG;
                static const float K_FI;



};

inline float K3dMath::ACos ( const float fValue )
{
        if ( - ( float ) 1.0 < fValue )
        {
                if ( fValue < ( float ) 1.0 )
                        return ( float ) acos ( ( double ) fValue );
                else
                        return ( float ) 0.0;
        }
        else
        {
                return K_PI;
        }
}

inline float K3dMath::ASin ( const float fValue )
{
        if ( - ( float ) 1.0 < fValue )
        {
                if ( fValue < ( float ) 1.0 )
                        return ( float ) asin ( ( double ) fValue );
                else
                        return -HALF_PI;
        }
        else
        {
                return HALF_PI;
        }
}

inline float K3dMath::ATan ( const float fValue )
{
        return ( float ) atan ( ( double ) fValue );
}

inline float K3dMath::ATan2 ( const float fY, const float fX )
{
        return ( float ) atan2 ( ( double ) fY, ( double ) fX );
}

inline float K3dMath::Ceil ( const float fValue )
{
        return ( float ) ceil ( ( double ) fValue );
}

inline float K3dMath::Cos ( const float fValue )
{
        return ( float ) cos ( ( double ) fValue );
}

inline float K3dMath::Exp ( const float fValue )
{
        return ( float ) exp ( ( double ) fValue );
}

inline float K3dMath::FAbs ( const float fValue )
{
        return ( float ) fabs ( ( double ) fValue );
}

inline float K3dMath::Floor ( const float fValue )
{
        return ( float ) floor ( ( double ) fValue );
}

inline float K3dMath::FMod ( const float fX, const float fY )
{
        return ( float ) fmod ( ( double ) fX, ( double ) fY );
}

inline float K3dMath::InvSqrt ( const float fValue )
{
        return ( float ) ( 1.0/sqrt ( ( double ) fValue ) );
}

inline float K3dMath::Log ( const float fValue )
{
        return ( float ) log ( ( double ) fValue );
}

inline float K3dMath::Pow ( const float fBase, const float fExponent )
{
        return ( float ) pow ( ( double ) fBase, ( double ) fExponent );
}

inline float K3dMath::Sin ( const float fValue )
{
        return ( float ) sin ( ( double ) fValue );
}

inline float K3dMath::Sqr ( const float fValue )
{
        return fValue*fValue;
}

inline float K3dMath::Sqrt ( const float fValue )
{
        return ( float ) sqrt ( ( double ) fValue );
}

inline float K3dMath::Tan ( const float fValue )
{
        return ( float ) tan ( ( double ) fValue );
}

inline int K3dMath::Sign ( const int iValue )
{
        if ( iValue > 0 )
                return 1;

        if ( iValue < 0 )
                return -1;

        return 0;
}

inline int K3dMath::Sign ( const float fValue )
{
        if ( fValue > ( float ) 0.0 )
                return 1;

        if ( fValue < ( float ) 0.0 )
                return -1;

        return 0;
}

inline float K3dMath::ConvertHalfPiSin ( const float fAngle, bool &rbNeg )
{
        float fA;
        fA = fAngle;

        // If angle bigger than zero

        // Convert to max two pi
        if ( fA > TWO_PI )
        {
                while ( fA > TWO_PI )
                {
                        fA -= TWO_PI;
                }
        }

        if ( fA > THREE_HALF_PI )
        {
                fA -= THREE_HALF_PI;
                fA = HALF_PI - fA;
                rbNeg = 1;
                return fA;
        }

        if ( fA > K_PI )
        {
                fA -= K_PI;
                rbNeg = 1;
                return fA;
        }

        if ( fA > HALF_PI )
        {
                fA -=HALF_PI;
                fA = HALF_PI - fA;
                return fA;
        }

        // If angle less than zero

        // Convert to max two pi
        if ( fA < -TWO_PI )
        {
                while ( fA < -TWO_PI )
                {
                        fA += TWO_PI;
                }
        }

        if ( fA < -THREE_HALF_PI )
        {
                fA += THREE_HALF_PI;
                fA = HALF_PI + fA;
                return fA;
        }

        if ( fA < -K_PI )
        {
                fA += K_PI;
                rbNeg = 1;
                return fA;
        }

        if ( fA < -HALF_PI )
        {
                fA +=HALF_PI;
                fA = HALF_PI + fA;
                rbNeg = 1;
                return fA;
        }

        return fA;
}

inline float K3dMath::ConvertHalfPiCos ( const float fAngle, bool &rbNeg )
{
        float fA;
        fA = fAngle;

        // If angle bigger than zero

        // Convert to max two pi
        if ( fA > TWO_PI )
        {
                while ( fA > TWO_PI )
                {
                        fA -= TWO_PI;
                }
        }

        if ( fA > THREE_HALF_PI )
        {
                fA -= THREE_HALF_PI;
                fA = HALF_PI - fA;
                return fA;
        }

        if ( fA > K_PI )
        {
                fA -= K_PI;
                rbNeg = 1;
                return fA;
        }

        if ( fA > HALF_PI )
        {
                fA -=HALF_PI;
                fA = HALF_PI - fA;
                rbNeg = 1;
                return fA;
        }


        if ( fA < -TWO_PI )
        {
                while ( fA < -TWO_PI )
                {
                        fA += TWO_PI;
                }
        }

        if ( fA < -THREE_HALF_PI )
        {
                fA += THREE_HALF_PI;
                fA = HALF_PI + fA;
                return fA;
        }

        if ( fA < -K_PI )
        {
                fA += K_PI;
                rbNeg = 1;
                return fA;
        }

        if ( fA < -HALF_PI )
        {
                fA +=HALF_PI;
                fA = HALF_PI + fA;
                rbNeg = 1;
                return fA;
        }

        return fA;
}

// Convert to TWO_PI
inline float K3dMath::ConvertTwoPi ( const float fAngle )
{
        float fA;
        fA = fAngle;

        // If angle bigger than zero

        // Convert to max two pi
        if ( fA > TWO_PI )
        {
                while ( fA > TWO_PI )
                {
                        fA -= TWO_PI;
                }
        }

        // If angle less than zero

        // Convert to max two pi
        if ( fA < -TWO_PI )
        {
                while ( fA < -TWO_PI )
                {
                        fA += TWO_PI;
                }
        }

        return fA;
}

inline float K3dMath::FastSin0 ( const float fAngle )
{
        float fA;
        bool bNeg = 0;

        if ( ( fAngle>HALF_PI ) || ( fAngle<0 ) )
        {
                // Convert to K_PI/2 for fast sin functions
                fA = ConvertHalfPiSin ( fAngle, bNeg );
        }
        else
        {
                fA = fAngle;
        }

        float fASqr = fA*fA;
        float fResult = ( float ) 7.61e-03;
        fResult *= fASqr;
        fResult -= ( float ) 1.6605e-01;
        fResult *= fASqr;
        fResult += ( float ) 1.0;
        fResult *= fA;

        // If negative reference from conversion
        if ( bNeg )
        {
                fResult = -fResult;
        }

        return fResult;
}

inline float K3dMath::FastSin1 ( const float fAngle )
{
        float fA;
        bool bNeg = 0;

        if ( ( fAngle>HALF_PI ) || ( fAngle<0 ) )
        {
                // Convert to PI/2 for fast sinfunctions
                fA = ConvertHalfPiSin ( fAngle, bNeg );
        }
        else
        {
                fA = fAngle;
        }

        float fASqr = fA*fA;
        float fResult = - ( float ) 2.39e-08;
        fResult *= fASqr;
        fResult += ( float ) 2.7526e-06;
        fResult *= fASqr;
        fResult -= ( float ) 1.98409e-04;
        fResult *= fASqr;
        fResult += ( float ) 8.3333315e-03;
        fResult *= fASqr;
        fResult -= ( float ) 1.666666664e-01;
        fResult *= fASqr;
        fResult += ( float ) 1.0;
        fResult *= fA;

        // If negative reference from conversion
        if ( bNeg )
        {
                fResult = -fResult;
        }

        return fResult;
}

inline float K3dMath::FastCos0 ( const float fAngle )
{
        float fA;
        bool bNeg = 0;

        if ( ( fAngle>HALF_PI ) || ( fAngle<0 ) )
        {
                // Convert to PI/2 for fast cos function
                fA = ConvertHalfPiCos ( fAngle, bNeg );
        }
        else
        {
                fA = fAngle;
        }


        float fASqr = fA*fA;
        float fResult = ( float ) 3.705e-02;
        fResult *= fASqr;
        fResult -= ( float ) 4.967e-01;
        fResult *= fASqr;
        fResult += ( float ) 1.0;

        // If negative reference from conversion
        if ( bNeg )
        {
                fResult = -fResult;
        }

        return fResult;
}

inline float K3dMath::FastCos1 ( const float fAngle )
{
        float fA;
        bool bNeg = 0;

        if ( ( fAngle>HALF_PI ) || ( fAngle<0 ) )
        {
                // Convert to PI/2 for fast cos function
                fA = ConvertHalfPiCos ( fAngle, bNeg );
        }
        else
        {
                fA = fAngle;
        }

        float fASqr = fA*fA;
        float fResult = - ( float ) 2.605e-07;
        fResult *= fASqr;
        fResult += ( float ) 2.47609e-05;
        fResult *= fASqr;
        fResult -= ( float ) 1.3888397e-03;
        fResult *= fASqr;
        fResult += ( float ) 4.16666418e-02;
        fResult *= fASqr;
        fResult -= ( float ) 4.999999963e-01;
        fResult *= fASqr;
        fResult += ( float ) 1.0;

        // If negative reference from conversion
        if ( bNeg )
        {
                fResult = -fResult;
        }
        return fResult;
}

inline float K3dMath::FastTan0 ( const float fAngle )
{
        float fA;
        float fSinA;
        float fCosA;
        if ( ( fAngle>QUARTER_PI ) || ( fAngle<0 ) )
        {
                if ( ( fAngle>TWO_PI ) || ( fAngle<0 ) )
                {
                        // Convert to TWO_PI
                        fA = K3dMath::ConvertTwoPi ( fAngle );
                        fCosA = K3dMath::FastCos1 ( fA );
                }
                else
                {
                        fA = fAngle;
                        fCosA = K3dMath::FastCos1 ( fA );
                }

                if ( fCosA )
                {
                        fSinA = K3dMath::FastSin1 ( fA );
                        return fSinA/fCosA;
                }
                else
                {
                        return 0.0f;
                }
        }
        else
        {
                fA = fAngle;
        }
        float fASqr = fA*fA;
        float fResult = ( float ) 2.033e-01;
        fResult *= fASqr;
        fResult += ( float ) 3.1755e-01;
        fResult *= fASqr;
        fResult += ( float ) 1.0;
        fResult *= fA;
        return fResult;
}

inline float K3dMath::FastTan1 ( const float fAngle )
{
        float fA;
        float fSinA;
        float fCosA;
        if ( ( fAngle>QUARTER_PI ) || ( fAngle<0 ) )
        {
                if ( ( fAngle>TWO_PI ) || ( fAngle<0 ) )
                {
                        // Convert to TWO_PI
                        fA = K3dMath::ConvertTwoPi ( fAngle );
                        fCosA = K3dMath::FastCos1 ( fA );
                }
                else
                {
                        fA = fAngle;
                        fCosA = K3dMath::FastCos1 ( fA );
                }

                if ( fCosA )
                {
                        fSinA = K3dMath::FastSin1 ( fA );
                        return fSinA/fCosA;
                }
                else
                {
                        return 0.0f;
                }
        }
        else
        {
                fA = fAngle;
        }
        float fASqr = fA*fA;
        float fResult = ( float ) 9.5168091e-03;
        fResult *= fASqr;
        fResult += ( float ) 2.900525e-03;
        fResult *= fASqr;
        fResult += ( float ) 2.45650893e-02;
        fResult *= fASqr;
        fResult += ( float ) 5.33740603e-02;
        fResult *= fASqr;
        fResult += ( float ) 1.333923995e-01;
        fResult *= fASqr;
        fResult += ( float ) 3.333314036e-01;
        fResult *= fASqr;
        fResult += ( float ) 1.0;
        fResult *= fA;
        return fResult;
}

inline float K3dMath::FastASin ( const float fValue )
{
        float fV;
        if ( ( fValue>1.0f ) || ( fValue<-1.0f ) )
        {
                return 0.0f;
        }
        if ( fValue<0 )
        {
                fV = -fValue;
        }
        else
        {
                fV = fValue;
        }
        float fRoot = sqrt ( ( ( float ) 1.0 )-fV );
        float fResult = - ( float ) 0.0187293;
        fResult *= fV;
        fResult += ( float ) 0.0742610;
        fResult *= fV;
        fResult -= ( float ) 0.2121144;
        fResult *= fV;
        fResult += ( float ) 1.5707288;
        fResult = HALF_PI - fRoot*fResult;
        if ( fValue<0 )
        {
                fResult = -fResult;
        }
        return fResult;
}

inline float K3dMath::FastACos ( const float fValue )
{
        float fV;
        if ( ( fValue>1.0f ) || ( fValue<-1.0f ) )
        {
                return 0.0f;
        }
        if ( fValue<0 )
        {
                fV = -fValue;
        }
        else
        {
                fV = fValue;
        }

        float fRoot = sqrt ( ( ( float ) 1.0 )-fV );
        float fResult = - ( float ) 0.0187293;
        fResult *= fV;
        fResult += ( float ) 0.0742610;
        fResult *= fV;
        fResult -= ( float ) 0.2121144;
        fResult *= fV;
        fResult += ( float ) 1.5707288;
        fResult *= fRoot;
        if ( fValue<0 )
        {
                fResult = K_PI-fResult;
        }
        return fResult;

}

inline float K3dMath::FastATan0 ( const float fValue )
{
        float fV;
        if ( ( fValue>1.0f ) || ( fValue<-1.0f ) )
        {
                if ( fValue )
                {
                        fV = 1/fValue;
                }
                else
                {
                        return 0.0f;
                }

        }
        else
        {
                fV = fValue;
        }

        float fVSqr = fV*fV;
        float fResult = ( float ) 0.0208351;
        fResult *= fVSqr;
        fResult -= ( float ) 0.085133;
        fResult *= fVSqr;
        fResult += ( float ) 0.180141;
        fResult *= fVSqr;
        fResult -= ( float ) 0.3302995;
        fResult *= fVSqr;
        fResult += ( float ) 0.999866;
        fResult *= fV;

        if ( fValue>1.0f )
        {
                fResult = HALF_PI - fResult;
        }
        if ( fValue<-1.0f )
        {
                fResult =  - ( fResult + HALF_PI );
        }

        return fResult;
}

inline float K3dMath::FastATan1 ( const float fValue )
{
        float fV;
        if ( ( fValue>1.0f ) || ( fValue<-1.0f ) )
        {
                if ( fValue )
                {
                        fV = 1/fValue;
                }
                else
                {
                        return 0.0f;
                }

        }
        else
        {
                fV = fValue;
        }

        float fVSqr = fV*fV;
        float fResult = ( float ) 0.0028662257;
        fResult *= fVSqr;
        fResult -= ( float ) 0.0161657367;
        fResult *= fVSqr;
        fResult += ( float ) 0.0429096138;
        fResult *= fVSqr;
        fResult -= ( float ) 0.0752896400;
        fResult *= fVSqr;
        fResult += ( float ) 0.1065626393;
        fResult *= fVSqr;
        fResult -= ( float ) 0.1420889944;
        fResult *= fVSqr;
        fResult += ( float ) 0.1999355085;
        fResult *= fVSqr;
        fResult -= ( float ) 0.3333314528;
        fResult *= fVSqr;
        fResult += ( float ) 1.0;
        fResult *= fV;
        if ( fValue>1.0f )
        {
                fResult = HALF_PI - fResult;
        }
        if ( fValue<-1.0f )
        {
                fResult =  - ( fResult + HALF_PI );
        }
        return fResult;
}

inline float K3dMath::UnitRandom ( const float fSeed )
{
        if ( fSeed > ( float ) 0.0 )
                srand ( ( unsigned int ) fSeed );

        double dRatio = ( ( double ) rand() ) / ( ( double ) ( RAND_MAX ) );
        return ( float ) dRatio;
}

inline float K3dMath::SymmetricRandom ( const float fSeed )
{
        if ( fSeed > ( float ) 0.0 )
                srand ( ( unsigned int ) fSeed );

        double dRatio = ( ( double ) rand() ) / ( ( double ) ( RAND_MAX ) );
        return ( float ) ( 2.0*dRatio - 1.0 );
}

inline float K3dMath::IntervalRandom ( const float fMin, const float fMax, const float fSeed )
{
        if ( fSeed > ( float ) 0.0 )
                srand ( ( unsigned int ) fSeed );

        double dRatio = ( ( double ) rand() ) / ( ( double ) ( RAND_MAX ) );
        return fMin+ ( fMax-fMin ) * ( ( float ) dRatio );
}

inline float K3dMath::Positive ( const float fValue )
{
        if ( fValue < 0 )
        {
                return -fValue;
        }

        return fValue;
}

inline int K3dMath::Positive ( const int iValue )
{
        if ( iValue < 0 )
        {
                return -iValue;
        }

        return iValue;
}

// If value positive change to the negative
inline float K3dMath::Negative ( const float fValue )
{
        if ( fValue > 0 )
        {
                return -fValue;
        }

        return fValue;
}

// If value positive change to the negative
inline int K3dMath::Negative ( const int iValue )
{
        if ( iValue > 0 )
        {
                return -iValue;
        }

        return iValue;
}

---