C:/Work/specialnumbers_svn/NumberLib/NumbersLib/utils.h

Go to the documentation of this file.

#ifndef _UTILS_H_
#define _UTILS_H_

#include "math.h"

namespace luma
{
namespace numbers
{

template <class T>
inline T min(const T& v1, const T& v2);

template <class T>
inline T max(const T& v1, const T& v2);

template <class T>
inline T clamp(const T& value, const T& minValue, const T& maxValue);

template <class T>
inline T mod(const T& value, const T& minValue, const T& maxValue);

template <class T>
inline T reflect(const T& value, const T& minValue, const T& maxValue);


template <class T>
inline T lerp(const T& value, const T& inputMin, const T& inputMax, const T& outputMin, const T& outputMax);

template <class T>
inline T sigmoid(const T& value, const T& inputMin, const T& inputMax, const T& outputMin, const T& outputMax);

template <class T>
inline T ramp(const T& value, const T& inputMin, const T& inputMax, const T& outputMin, const T& outputMax);

template <class T>
inline T line(const T& value, const T& inputMin, const T& inputMax, const T& outputMin, const T& outputMax);

template <class T>
inline T step(const T& input, const T& inputThreshold, const T& outputMin, const T& outputMax);

template <class T>
inline T frac(T x);

template <class T>
inline T floor(T x);

template <class T>
inline T extreme(T v1, T v2, T center);

template <unsigned int n, class T>
void integrate(T samples[]);


//---------------------------------------------------------------------------------------
// Function definitions
//

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

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


template <class T>
inline T clamp(const T& value, const T& minValue, const T& maxValue)
{
   return min(maxValue, max(minValue, value));
}

template <class T>
inline T mod(const T& value, const T& minValue, const T& maxValue)
{
   T tmpValue = value - minValue;
   T range = maxValue - minValue;

   int quotient = (int)(tmpValue / range);
   T remainder = tmpValue - quotient * range;

   if (remainder < 0)
   {
      remainder += range;
   }

   return minValue + remainder;
}

template <class T>
inline T reflect(const T& value, const T& minValue, const T& maxValue)
{
   T cycleMax = 2 * maxValue - minValue;
   T c = mod(value, minValue, cycleMax);

   return c <= maxValue ? c: 2 * maxValue - c;
}


template <class T>
inline T lerp(const T& value, const T& inputMin, const T& inputMax, const T& outputMin, const T& outputMax)
{
   if(value >= inputMax)
   {
      return outputMax;
   }

   return ramp(value, inputMin, inputMax, outputMin, outputMax);
}

template <class T>
inline T sigmoid(const T& value, const T& inputMin, const T& inputMax, const T& outputMin, const T& outputMax)
{
   T w = exp((-2 * value + (inputMax + inputMin))/ (inputMax - inputMin));

   return (outputMax - outputMin) / (1 + w) + outputMin;
}

template <class T>
inline T ramp(const T& value, const T& inputMin, const T& inputMax, const T& outputMin, const T& outputMax)
{
   if(value <= inputMin)
   {
      return outputMin;
   }

   return line(value, inputMin, inputMax, outputMin, outputMax);
}

template <class T>
inline T line(const T& value, const T& inputMin, const T& inputMax, const T& outputMin, const T& outputMax)
{
   return outputMin + ((value - inputMin) * (outputMax - outputMin) / (inputMax - inputMin));
}

template <class T>
inline T frac(T x)
{
   return x >= (T) 0 ? x - (int) x : x + 1 - (int) x;
}

template <class T>
inline T floor(T x)
{
   return x >= (T) 0 ? (int) x : (int) x - 1;
}

template <class T>
inline T extreme(T v1, T v2, T center = 0)
{
   return abs(v1 - center) > abs(v2 - center) ? v1 : v2;
}

template <class T>
inline T step(const T& input, const T& inputThreshold, const T& outputMin, const T& outputMax)
{
   return input < inputThreshold ? outputMin : outputMax;
}

template <unsigned int n, class T>
void integrate(T samples[])
{
   for(int i = 1; i < n; i++)
   {
      samples[i] += samples[i - 1];
   }
}

}} //namespace
#endif //_UTILS_H_

---