plMath.h

/*=============================================================================
 * Product        : OpenPL 
 * File           : plMath.h
 * Author         : Kamel Mekhnacha
 * Creation       : August 07 2001
 *
 *=============================================================================
 *     (c) Copyright 2000, Centre National de la Recherche Scientifique,
 *                              all rights reserved
 *=============================================================================
 *
 *------------------------- Description ---------------------------------------
 *    
 *   
 *-----------------------------------------------------------------------------
 */

#ifndef _plMath_h_
#define _plMath_h_

//=============================================================================
//                 STL INCLUDES
//=============================================================================

#define PL_USE_NAMESPACE


#include <algorithm>
#include <bitset>

#include <list>
#include <map>
#include <set>
#include <string>
#include <vector>
#include <fstream>

#ifdef PL_USE_NAMESPACE
using namespace std;

#else

#define bitset std::bitset
#define list std::list
#define map std::map
#define string std::string
#define vector std::vector
#define pair std::pair

#define ostream std::ostream
#define istream std::istream
#define ofstream std::ofstream
#define ifstream std::ifstream

#define make_pair (std::make_pair)
#define remove_if (std::remove_if)
#define back_inserter (std::back_inserter)
/*  #define find (std::find) */
#define find_if (std::find_if)
#define set_union (std::set_union)
#define set_intersection (std::set_intersection)
#define set_difference (std::set_difference)
#define includes (std::includes)

#define cout (std::cout)
#define cin (std::cin)
#define cerr (std::cerr)
#define endl (std::endl)

#endif


//=============================================================================
//                 STANDARD C INCLUDES
//=============================================================================

#include <math.h>
#include <stdlib.h>
#include <limits.h>
#include <stdio.h>
#include <float.h>

//=============================================================================
//                 COMPILATION VARIABLES
//=============================================================================


// Comment out the following line to use double  or single precision floating numbers.
#define PL_LONG_DOUBLE_PRECISION


// There is no long double floating numbers on macintosh. Long double is just a double!
#ifdef macintosh
#undef PL_LONG_DOUBLE_PRECISION
#endif


// Comment out the following line to use single precision floating numbers 
#define PL_DOUBLE_PRECISION


// Uncomment  the following line to use our own arithmetics on probabilities.
// otherwise, machine floating numbers are used.
//#define PL_USE_PLPROBA

// Uncomment the following line if floating numbers representation is not IEEE754.
// This is only used when PL_USE_PLPROBA is defined (we are using plProbability type).
//#define PL_NOT_IEEE754


// Uncomment this line to use our own tabulated ERF function
//#define PL_USE_TABLE_FOR_ERF

// The ERF function is not defined in Windows machines!!
#if defined(WIN32) || defined(_WIN32)
#define PL_USE_TABLE_FOR_ERF
#endif

//=============================================================================
//                 FLOATING NUMBERS RELATED CONSTANTS
//=============================================================================

#ifdef PL_LONG_DOUBLE_PRECISION
typedef long double plFloat;

#define PL_LOG_OF_2     0.69314718055994530942l
#define PL_PI_2         1.57079632679489661923l
#define PL_PI           3.14159265358979323846l
#define PL_2PI          6.28318530717958647692l
#define PL_INV_SQRT_2PI 0.398942280401433l
#define PL_SQRT_PI      1.77245385090551602729816748334l
#define PL_LOG_ROOT_2_PI  0.9189385332046727418l
#define PL_ZERO         0.0l
#define PL_HALF         0.5l
#define PL_ONE          1.0l
#define PL_TWO          2.0l
#define PL_SQRT_2       1.414213562373095145475l
#define PL_E            2.7182818284590452354l  /* e */
#define PL_EPSILON      LDBL_EPSILON // smallest number such that 1+Eps != 1
#define PL_FLOAT_MAX    LDBL_MAX
#define PL_MIN_EXP      -745.0l
#define PL_LOG_OF_10_BASE2 3.321928094887362660l

#define PL_MINUS_ONE -1.0l
#else

#ifdef PL_DOUBLE_PRECISION
//Use double precision floating numbers
typedef double plFloat;


#define PL_LOG_OF_2     0.69314718055994530942
#define PL_PI_2         1.57079632679489661923
#define PL_PI           3.14159265358979323846
#define PL_2PI          6.28318530717958647692
#define PL_INV_SQRT_2PI 0.398942280401433
#define PL_SQRT_PI      1.77245385090551602729816748334
#define PL_LOG_ROOT_2_PI  0.9189385332046727418
#define PL_ZERO         0.0
#define PL_HALF         0.5
#define PL_ONE          1.0
#define PL_TWO          2.0
#define PL_SQRT_2       1.414213562373095145475
#define PL_E            2.7182818284590452354   /* e */
#define PL_EPSILON      DBL_EPSILON // smallest number such that 1+Eps != 1
#define PL_FLOAT_MAX    DBL_MAX
#define PL_MIN_EXP      -745.0
#define PL_LOG_OF_10_BASE2 3.321928094887362660

#define PL_MINUS_ONE -1.0
#else
//Use single precision floating numbers
typedef float plFloat;


#define PL_LOG_OF_2     0.69314718055994530942f
#define PL_PI_2         1.57079632679489661923f
#define PL_PI           3.14159265358979323846f
#define PL_2PI          6.28318530717958647692f
#define PL_INV_SQRT_2PI 0.398942280401433f
#define PL_SQRT_PI      1.77245385090551602729816748334f
#define PL_LOG_ROOT_2_PI  0.9189385332046727418f
#define PL_ZERO         0.0f
#define PL_HALF         0.5f
#define PL_ONE          1.0f
#define PL_TWO          2.0f
#define PL_SQRT_2       1.414213562373095145475f
#define PL_E            2.7182818284590452354f  /* e */
#define PL_EPSILON      FLT_EPSILON // smallest number such that 1+Eps != 1
#define PL_FLOAT_MAX    FLT_MAX
#define PL_MIN_EXP      -745.0f
#define PL_LOG_OF_10_BASE2 3.321928094887362660f

#define PL_MINUS_ONE -1.0f
#endif

#endif


//=============================================================================
//                 OTHER CONSTANTS AND TOOLS
//=============================================================================

//=============================================================================
inline plFloat plLogBase2(plFloat v) 
{ 
  return log(v)/PL_LOG_OF_2; 
}

static const unsigned int PL_NUMBER_OF_BITS_BY_CHAR = sizeof(unsigned char)*8;

//=============================================================================
inline int plNbBits(int _int) 
{ 
  int i=0;
  _int = _int -1;
  while( _int != 0){
    _int = _int >> 1;
    i++;
  }
  return i;
}

#define PL_MAX_ULONG ULONG_MAX

//=============================================================================
inline int plRound( plFloat x )
{
  plFloat tmp1 = floor( x );
  plFloat tmp2 = ceil( x );
  return (int) ( ( x - tmp1 < tmp2 - x ) ? tmp1 : tmp2);
}


//=============================================================================
inline plFloat plFabs( plFloat x )
{
  return (x < PL_ZERO) ? -x : x;
}


//=============================================================================
//                 TIMING TOOLS
//=============================================================================

#include <plTimer.h>

// Returns execution time in seconds of the program "prg" in the double floating 
// number "time_in_seconds".
#define PL_TIME_SEC(prg, time_in_seconds)\
plTimer::timer.start();\
prg;\
plTimer::timer.stop();\
time_in_seconds = plTimer::timer.get_time_sec();

// Returns execution time in milliseconds of the program "prg" in the double floating 
// number "time_in_milliseconds".
#define PL_TIME_MSEC(prg, time_in_milliseconds)\
plTimer::timer.start();\
prg;\
plTimer::timer.stop();\
time_in_milliseconds = plTimer::timer.get_time_msec();

#define PL_TIME PL_TIME_SEC

//=============================================================================
//                 DEFINE A TYPE TO BE USED FOR PROBABILITIES
//=============================================================================

#ifndef PL_USE_PLPROBA
//We are using standard arithmetics using machine's floating numbers.

typedef plFloat plProbValue;
#define PL_ZERO_PROB PL_ZERO
#define PL_HALF_PROB PL_HALF
#define PL_ONE_PROB PL_ONE
#define PL_TWO_PROB PL_TWO

#define PL_INFINITY_PROB HUGE_VAL
#define PL_INVALID_PROB -1.0
#else

//  We are using our own arithmetics.
#include <plProbability32.h>

typedef plProbability plProbValue;
#define PL_ZERO_PROB plProbability::plZeroProbaConstant
#define PL_HALF_PROB plProbability::plHalfProbaConstant
#define PL_ONE_PROB plProbability::plOneProbaConstant
#define PL_TWO_PROB plProbability::plTwoProbaConstant

#define PL_INFINITY_PROB plProbability::plInfinityProbaConstant
#define PL_INVALID_PROB plProbability::plNaNProbaConstant
#endif

//=============================================================================
//                 RANDOM SAMPLING TOOLS
//=============================================================================
#include <plRandom.h>



//==============================================================================
#endif 

---