Utilities.hpp

#ifndef UTILITIES_HPP
#define UTILITIES_HPP

#include <math.h>
#include <sstream>
#include <string>
#include <vector>
#include <limits>
#include <cassert>
#include <iomanip>

namespace steer //namespace steeriously
{

typedef signed   char Int8;
typedef unsigned char Uint8;
typedef signed   short Int16;
typedef unsigned short Uint16;
typedef signed   int Int32;
typedef unsigned int Uint32;
typedef signed   long long Int64;
typedef unsigned long long Uint64;

const int     MaxInt    = (std::numeric_limits<int>::max)();
const double  MaxDouble = (std::numeric_limits<double>::max)();
const double  MinDouble = (std::numeric_limits<double>::min)();
const float   MaxFloat  = (std::numeric_limits<float>::max)();
const float   MinFloat  = (std::numeric_limits<float>::min)();

const float   Pi        = 3.14159f;
const float   TwoPi     = Pi * 2;
const float   HalfPi    = Pi / 2;
const float   QuarterPi = Pi / 4;

template <typename T>
inline bool isNaN(T val)
{
  return val != val;
}

inline float DegreesToRadians(float degrees)
{
  return TwoPi * (degrees/360.f);
}

inline bool IsZero(float val)
{
  return ( (-MinFloat < val) && (val < MinFloat) );
}

inline bool InRange(float start, float end, float val)
{
  if (start < end)
  {
    if ( (val > start) && (val < end) ) return true;
    else return false;
  }

  else
  {
    if ( (val < start) && (val > end) ) return true;
    else return false;
  }
}

template <class T>
T Maximum(const T& v1, const T& v2)
{
  return v1 > v2 ? v1 : v2;
}

//----------------------------------------------------------------------------
//  some random number functions.
//----------------------------------------------------------------------------

inline int RandInt(int x,int y) {return rand()%(y-x+1)+x;}

inline float RandFloat(){return ((rand())/(RAND_MAX+1.0));}

inline float RandInRange(float x, float y)
{
  return x + RandFloat()*(y-x);
}

inline bool   RandBool()
{
  if (RandInt(0,1)) return true;

  else return false;
}

inline float RandomClamped(){return RandFloat() - RandFloat();}

inline float RandGaussian(float mean = 0.0, float standard_deviation = 1.0)
{
    float x1, x2, w, y1;
    static float y2;
    static int use_last = 0;

    if (use_last)               /* use value from previous call */
    {
        y1 = y2;
        use_last = 0;
    }
    else
    {
        do
        {
            x1 = 2.0 * RandFloat() - 1.0;
            x2 = 2.0 * RandFloat() - 1.0;
            w = x1 * x1 + x2 * x2;
        }
        while ( w >= 1.0 );

            w = sqrt( (-2.0 * log( w ) ) / w );
            y1 = x1 * w;
            y2 = x2 * w;
            use_last = 1;
    }

    return( mean + y1 * standard_deviation );
}

//-----------------------------------------------------------------------
//
//  some handy little functions
//-----------------------------------------------------------------------

inline float Sigmoid(float input, float response = 1.0)
{
    return ( 1.0 / ( 1.0 + exp(-input / response)));
}

template <class T>
inline T MaxOf(const T& a, const T& b)
{
  if (a>b) return a; return b;
}

template <class T>
inline T MinOf(const T& a, const T& b)
{
  if (a<b) return a; return b;
}

template <class T, class U, class V>
inline void Clamp(T& arg, const U& minVal, const V& maxVal)
{
  assert ( (minVal < maxVal) && "<Clamp>MaxVal < MinVal!");

  if (arg < (T)minVal)
  {
    arg = (T)minVal;
  }

  if (arg > (T)maxVal)
  {
    arg = (T)maxVal;
  }
}

inline int Rounded(float val)
{
  int    integral = (int)val;
  float mantissa = val - integral;

  if (mantissa < 0.5)
  {
    return integral;
  }

  else
  {
    return integral + 1;
  }
}

inline int RoundUnderOffset(float val, float offset)
{
  int    integral = (int)val;
  float mantissa = val - integral;

  if (mantissa < offset)
  {
    return integral;
  }

  else
  {
    return integral + 1;
  }
}

inline bool isEqual(float a, float b)
{
  if (fabs(a-b) < 1E-12)
  {
    return true;
  }

  return false;
}

inline bool isEqual(double a, double b)
{
  if (fabs(a-b) < 1E-12)
  {
    return true;
  }

  return false;
}

template <class T>
inline float Average(const std::vector<T>& v)
{
  float average = 0.0;

  for (unsigned int i=0; i < v.size(); ++i)
  {
    average += (float)v[i];
  }

  return average / (float)v.size();
}

inline float StandardDeviation(const std::vector<float>& v)
{
  float sd      = 0.0;
  float average = Average(v);

  for (unsigned int i=0; i<v.size(); ++i)
  {
    sd += (v[i] - average) * (v[i] - average);
  }

  sd = sd / v.size();

  return sqrt(sd);
}

template <class container>
inline void DeleteSTLContainer(container& c)
{
  for (typename container::iterator it = c.begin(); it!=c.end(); ++it)
  {
    delete *it;
    *it = NULL;
  }
}

template <class map>
inline void DeleteSTLMap(map& m)
{
  for (typename map::iterator it = m.begin(); it!=m.end(); ++it)
  {
    delete it->second;
    it->second = NULL;
  }
}

} //namespace steeriously

#endif //UTILITIES_HPP