TAPsMath.cpp

Go to the documentation of this file.

/******************************************************************************
TAPsMath.cpp

Under TAPs namespace
Defines a Math class for basic math.
All member functions and data members are static.

SUKITTI PUNAK   (09/05/2004)
UPDATE          (09/07/2004)
******************************************************************************/
#include "TAPsMath.hpp"
// Using Inclusion Model (i.e. definitions are included in declarations)
//                       (this name.cpp is included in name.hpp)
// Each friend is defined directly inside its declaration.

BEGIN_NAMESPACE_TAPs
//=============================================================================
// Constant Values
//=============================================================================
template <typename T> const T TAPs::Math<T>::ZERO = 0;
template <typename T> const T TAPs::Math<T>::ONE  = 1;
template <typename T> const T TAPs::Math<T>::EPSILON  = std::numeric_limits<T>::epsilon();
template <typename T> const T TAPs::Math<T>::INFINITY = std::numeric_limits<T>::infinity();
template <typename T> T TAPs::Math<T>::ThresholdZero = std::numeric_limits<T>::epsilon()*10;
//-----------------------------------------------------------------------------
// max() and min() are defined as macros in numeric_limits from <limits>.
// However, windows.h also has max(a,b) and min(a,b) as macro.
// Therefore, if windows.h is included, then these two fns will not work properly.
#ifndef _WINDOWS_
template <typename T> const T TAPs::Math<T>::MAX = std::numeric_limits<T>::max();
template <typename T> const T TAPs::Math<T>::MIN = std::numeric_limits<T>::min();
#endif
//-----------------------------------------------------------------------------
template <typename T> const T TAPs::Math<T>::ROUND_ERROR = std::numeric_limits<T>::round_error();
//PI = 3.1415926535897932384626433832795
template <typename T> const T TAPs::Math<T>::PI = static_cast<T>(4.0*atan(ONE));    // atan(1.0) gives radians of 45 degs
template <typename T> const T TAPs::Math<T>::TWO_PI     = static_cast<T>(2.0*PI);   // radians of 360 degrees
template <typename T> const T TAPs::Math<T>::HALF_PI    = static_cast<T>(0.5*PI);   // radians of  90 degrees
template <typename T> const T TAPs::Math<T>::QUARTER_PI = static_cast<T>(0.25*PI);  // radians of  45 degrees
template <typename T> const T TAPs::Math<T>::DEG_TO_RAD = static_cast<T>(TAPs::Math<T>::PI/180.0);  // degrees to radians
template <typename T> const T TAPs::Math<T>::RAD_TO_DEG = static_cast<T>(180.0/TAPs::Math<T>::PI);  // radians to degrees

//=============================================================================
// Absolute, Ceil, Floor, and Sign
//=============================================================================
//-----------------------------------------------------------------------------
template <typename T> inline T TAPs::Math<T>::Abs  ( T tValue )
{   return tValue >= ZERO ? tValue : -tValue;   }
//-----------------------------------------------------------------------------
template <typename T> inline T TAPs::Math<T>::Ceil ( T tValue )
{   return ceil( tValue );  }
//-----------------------------------------------------------------------------
template <typename T> inline T TAPs::Math<T>::Floor ( T tValue )
{   return floor( tValue ); }
//-----------------------------------------------------------------------------
template <typename T> inline T TAPs::Math<T>::Sign ( T tValue )
{   return tValue > ZERO ? ONE : ( tValue < ZERO ? -ONE : ZERO );   }
//-----------------------------------------------------------------------------

//=============================================================================
// Trigonometric Functions
//=============================================================================
//-----------------------------------------------------------------------------
template <typename T> inline T TAPs::Math<T>::Sin ( T tValue )  // sine
{   return sin( tValue );   }
//-----------------------------------------------------------------------------
template <typename T> inline T TAPs::Math<T>::Cos ( T tValue )  // cosine
{   return cos( tValue );   }
//-----------------------------------------------------------------------------
template <typename T> inline T TAPs::Math<T>::Tan ( T tValue )  // tangent
{   return tan( tValue );   }
//-----------------------------------------------------------------------------
template <typename T> inline T TAPs::Math<T>::Csc ( T tValue )  // cosecant
{   return static_cast<T>(ONE) / sin( tValue ); }
//-----------------------------------------------------------------------------
template <typename T> inline T TAPs::Math<T>::Sec ( T tValue )  // secant
{   return static_cast<T>(ONE) / cos( tValue ); }
//-----------------------------------------------------------------------------
template <typename T> inline T TAPs::Math<T>::Cot ( T tValue )  // cotangent
{   return static_cast<T>(ONE) / tan( tValue ); }
//-----------------------------------------------------------------------------

//=============================================================================
// Inverse Trigonometric Functions
//=============================================================================
//-----------------------------------------------------------------------------
template <typename T> inline T TAPs::Math<T>::ASin ( T tValue ) // arc sine
{
    // asin function
    // I/P: tValue must be in the range [-1,1]
    // O/P: return value is in the range [-PI/2,PI/2];
#ifndef _WINDOWS_
    if ( tValue < -ONE )
    {
        //return TAPs::Math<T>::MIN;
        return std::numeric_limits<T>::min();
    }
    else if ( tValue > ONE )
    {
        //return TAPs::Math<T>::MAX;
        return std::numeric_limits<T>::max();
    }
    else
    {
        return asin( tValue );
    }
#else
    return asin( tValue );
#endif
}
//-----------------------------------------------------------------------------
template <typename T> inline T TAPs::Math<T>::ACos ( T tValue ) // arc cosine
{
    // acos function
    // I/P: tValue must be in the range [-1,1]
    // O/P: return value is in the range [0,PI];
#ifndef _WINDOWS_
    if ( tValue < -ONE )
    {
        //return TAPs::Math<T>::MIN;
        return std::numeric_limits<T>::min();
    }
    else if ( tValue > ONE )
    {
        //return TAPs::Math<T>::MAX;
        return std::numeric_limits<T>::max();
    }
    else
    {
        return acos( tValue );
    }
#else
    return acos( tValue );
#endif
}
//-----------------------------------------------------------------------------
template <typename T> inline T TAPs::Math<T>::ATan ( T tValue ) // arc tangent
{
    // atan function
    // O/P: return value is in the range [-PI/2,PI/2];
    return atan( tValue );
}
//-----------------------------------------------------------------------------
template <typename T> inline T TAPs::Math<T>::ATan2 ( T fY, T fX )
{
    // atan2 function
    // returns the inverse tangent of fY/fX using the sign of both numbers to 
    // determine the quadrant for the return value.  It correctly handles the 
    // case in which fX is 0.  (That is, it returns PI/2 times the sign of fY 
    // for nonzero fY; if fY is 0, the result is implementation-defined and 
    // might be a range error).
    // O/P: return value is in the range [-PI/2,PI/2];
    return atan2( fY, fX );
}
//-----------------------------------------------------------------------------
//template <typename T> inline static T TAPs::Math<T>::ACsc ( T tValue )    // arc cosecant
//-----------------------------------------------------------------------------
//template <typename T> inline static T TAPs::Math<T>::ASec ( T tValue )    // arc secant
//-----------------------------------------------------------------------------
//template <typename T> inline static T TAPs::Math<T>::ACot ( T tValue )    // arc cotangent
//-----------------------------------------------------------------------------

//=============================================================================
// Exponential and Logarithmic Functions
//=============================================================================
//-----------------------------------------------------------------------------
template <typename T> inline T TAPs::Math<T>::Exp  ( T tValue )
{   return exp( tValue );   }
//-----------------------------------------------------------------------------
template <typename T> inline T TAPs::Math<T>::Log  ( T tValue )
{   return log( tValue );   }
//-----------------------------------------------------------------------------
template <typename T> inline T TAPs::Math<T>::Log10  ( T tValue )
{   return log10( tValue ); }
//-----------------------------------------------------------------------------
template <typename T> inline T TAPs::Math<T>::Pow  ( T tBase, T tExponent )
{   
    // pow function
    // raises fBase to the fExponent power.  If fBase is negative and fExponent 
    // is not an integer, then a domain error occurs.  If fBase is 0 and 
    // fExponent is less than or equal to 0, then the result cannot be 
    // represented as a real number, a domain error occurs.
    return pow( tBase, tExponent );
}
//-----------------------------------------------------------------------------
template <typename T> inline T TAPs::Math<T>::Square ( T tValue )
{   return tValue * tValue; }
//-----------------------------------------------------------------------------
template <typename T> inline T TAPs::Math<T>::Sqrt ( T tValue )
{
    // sqrt function
    // returns the square root or its argument.  If tValue is negative, a 
    // domain error occurs.  The return value is always positive or zero.
    return sqrt( tValue );
}
//-----------------------------------------------------------------------------

//=============================================================================
// Random Numbers
//=============================================================================
//-----------------------------------------------------------------------------
template <typename T> inline T TAPs::Math<T>::UnitRandom ()     // between [0,1]
{
    // void srand ( unsigned int seed )     (defined in <cstdlib>)
    // saves seed as the seed for a new sequence of pseudo-random numbers to be 
    // returned by successive calls to rand.  The default seed is 1.

    // int rand ()      (defined in <cstdlib>)
    // returns a pseudo-random integer in the range of 0 to RAND_MAX inclusively
    return static_cast<T>( rand() ) / static_cast<T>( RAND_MAX );
}
//-----------------------------------------------------------------------------
template <typename T> inline T TAPs::Math<T>::SymmetricRandom ()    // between [-1,1]
{   return  static_cast<T>(2.0)*UnitRandom() - static_cast<T>(ONE); }
//-----------------------------------------------------------------------------
//=============================================================================
// Explicit Instantiation
//template class TAPs::Math<int>;   // can't create <int> template, ambiguous 
                                    // call with double or long double
template class TAPs::Math<float>;
template class TAPs::Math<double>;
template class TAPs::Math<long double>;
//*/
//=============================================================================
END_NAMESPACE_TAPs
//345678901234567890123456789012345678901234567890123456789012345678901234567890
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8