vlMath.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 1992-2010 VT MAK
** All rights reserved.
*********************************************************************/


#ifndef vlMath_H
#define vlMath_H


#if !defined(_WIN32) && !defined(VXWORKS)
#include <sys/param.h>
#endif


#include <vlutil/vlMachineTypes.h>  
#include <math.h>
#include <vlutil/vlExceptions.h>

#ifdef DtUSE_UTILITIES_NAMESPACE
namespace DtUSE_UTILITIES_NAMESPACE
{
#endif

#define DtEPico         1.0E-12
#define DtENano         1.0E-09
#define DtEMicro        1.0E-06
#define DtEMilli        1.0E-03
#define DtECenti        1.0E-02
#define DtEDeci         1.0E-01
#define DtEHalf         5.0E-01
#define DtENineTenths   9.0E-01
#define DtEOne          1.0
#define DtEDeca         1.0E01
#define DtEHecto        1.0E02
#define DtEKilo         1.0E03
#define DtEMega         1.0E06
#define DtEGiga         1.0E09

#define DtEq(x, y, e)        ((DtAbs((x) - (y)) <= (e)) ? true : false)

#define M_2PI       6.28318530717958647693   /* 2Pi                           */

#ifndef __darwin__
#define M_E         2.7182818284590452354    /* Euler constant "e"            */
#define M_1_E       0.36787944117144232160   /* 1/e                           */
#define M_LN2       0.69314718055994530942   /* ln(2)                         */
#define M_LN10      2.30258509299404568402   /* ln(10)                        */
#define M_LOG2E     1.4426950408889634074    /* log2(e)  = 1/ln(2)            */
#define M_LOG10E    0.43429448190325182765   /* log10(e) = 1/ln(10)           */
#define M_PI        3.14159265358979323846   /* Pythagorean constant "Pi"     */
#define M_PI_2      1.57079632679489661923   /* Pi/2                          */
#define M_PI_3      1.04719755119659774615   /* Pi/3                          */
#define M_PI_4      0.78539816339744830962   /* Pi/4                          */
#define M_1_PI      0.31830988618379067154   /* 1/Pi                          */
#define M_2_PI      0.63661977236758134308   /* 2/Pi                          */
#define M_3_PI      0.954929658551372014613  /* 3/Pi                          */
#define M_4_PI      1.27323954473516268615   /* 4/Pi                          */
#define M_SQRTPI    1.77245385090551602730   /* Sqrt(Pi)                      */
#define M_1_SQRTPI  0.564189583547756286948  /* 1/Sqrt(Pi)                    */
#define M_2_SQRTPI  1.12837916709551257390   /* 2/Sqrt(Pi)                    */
#define M_3_SQRTPI  1.69256875064326886084   /* 3/Sqrt(Pi)                    */
#define M_4_SQRTPI  2.25675833419102514779   /* 4/Sqrt(Pi)                    */
#define M_SQRT2PI   2.50662827463100050242   /* Sqrt(2Pi)                     */
#define M_1_SQRT2PI 0.39894228040143267794   /* 1/Sqrt(2Pi)                   */
#define M_RAD2DEG   57.2957795130823208768   /* 180/Pi  radians --> degrees   */
#define M_DEG2RAD   0.0174532925199432957692 /* Pi/180  degrees --> radians   */
#define M_SQRT2     1.41421356237309504880   /* Sqrt(2)                       */
#define M_SQRT_2    0.707106781186547524401  /* 1/Sqrt(2)                     */
#define M_GOLDEN_R  0.6180339887498948482046 /* GoldenRatio: (Sqrt(5) - 1)/2  */
#endif

inline DT_DLL_MATRIX double  DtRad2Deg(double rad)
{
   return ((rad / M_PI) * 180.0);
}

inline  DT_DLL_MATRIX double  DtDeg2Rad(double deg) 
{
   return ((deg * M_PI) / 180.0);
}

template<typename T>
T DtAbs(T x)
{
   return  (((x) >= 0) ? (x) : (-(x)));
}

template<typename T>
int DtSgn(T x)
{
   return (((x) >= 0) ? 1 : -1);
}

template<typename T>
T DtPos(T x)
{
   return (((x) >= 0) ? (x) : 0);
}

template <typename T>
T DtNeg(const T&val)
{
   if (val >= 0) return 0;
   else return val;
}

template <typename T>
T DtSquare(const T& val)
{
   return val * val;
}

template <typename T>
T DtLimit(T x,T lo ,T hi)
{     
   if(lo > hi)
   {     
      return DtLimit(x,hi,lo);
   }     
   if(x > hi)
   {  
      return hi;
   }
   if(x < lo)
   {  
      return lo;
   }     
   return x;
}

template <typename T>
inline T DtMod(T a, T b)
{
   return a % b;
}

template <>
inline float DtMod(float a, float b)
{
   return (float)fmod((float)a,(float)b);
}

template <>
inline double DtMod(double a,double b)
{
   return fmod(a,b);
}

template <typename T>
T DtGCD(T a, T b)
{
   if(a == 0) DtTHROW_NEW(DtInvalidInput,"Can't divide by zero");
   if(b == 0) DtTHROW_NEW(DtInvalidInput,"Can't divide by zero");   
   while( true )
   {
      a = DtMod(a,b);
      if( a == 0 ) return b;
      b = DtMod(b,a);
      if( b == 0 ) return a;
   }
}

template <typename T>
T DtLCM(T a,T b)
{
   if(a == 0) DtTHROW_NEW(DtInvalidInput,"Can't divide by zero");
   if(b == 0) DtTHROW_NEW(DtInvalidInput,"Can't divide by zero");
   return (a * b) / DtGCD(a,b);
}

#ifdef DtUSE_UTILITIES_NAMESPACE
}
#endif
#endif