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

Go to the documentation of this file.

#ifndef _INTEGRABLE_NUMBER_H_
#define _INTEGRABLE_NUMBER_H_

#include "CyclicNumber.h"
#include "AbstractFilteredNumber.h"

namespace luma
{
namespace numbers
{
template <class T, unsigned int sampleCount, unsigned int maxOrder>
class IntegrableNumber: public AbstractFilteredNumber<T, sampleCount, maxOrder>
{
private:
   T mSamples[sampleCount];   
   float mTimeSamples[sampleCount];

   CyclicNumber<int> mCurrentIndex; 
   T mCurrentValue;
   T mInitialValue;

   IntegrableNumber<T, sampleCount, maxOrder - 1> mSum;
   float mTotalTime;

public:
   IntegrableNumber(T initialValue);

   void setValue(T x, float elapsedTime = 1.0f);

   void forceValue(T x, float elapsedTime = 1.0f);

   T getValue(unsigned int order) const;

   T getSample(int i) const;
};

template <class T, unsigned int sampleCount, unsigned int maxOrder>
IntegrableNumber<T, sampleCount, maxOrder>::IntegrableNumber(T initialValue):
   mInitialValue(initialValue),
   mCurrentValue(initialValue),
   mCurrentIndex(0, 0, sampleCount, 1),
   mSum(initialValue),
   mTotalTime(sampleCount * TIME_UNIT)
{
   for(int i = 0; i < sampleCount; i++)
   {
      mSamples[i] = initialValue;
      mTimeSamples[i] = TIME_UNIT;
   }
}

template <class T, unsigned int sampleCount, unsigned int maxOrder>
void IntegrableNumber<T, sampleCount, maxOrder>::setValue(T x, float elapsedTime)
{
   T sum = mSum.getValue(0);

   mCurrentIndex++;

   int index = mCurrentIndex;
   T newValue = x * elapsedTime;

   mTotalTime += elapsedTime - mTimeSamples[index];
   sum += (newValue - mSamples[index]) / mTotalTime;  

   mSum.setValue(sum);  

   mSamples[index] = newValue;
   mCurrentValue = x;

}

template <class T, unsigned int sampleCount, unsigned int maxOrder>
void IntegrableNumber<T, sampleCount, maxOrder>::forceValue(T x, float elapsedTime)
{
   
   T newValue = x * elapsedTime; // we do not have to multiply by the framerate
                           // because we divide by the total time later

   T sum = mInitialValue;

   for(int i = 0; i < sampleCount; i++)
   {
      mSamples[i] = newValue;
      sum += newValue;
   }

   mTotalTime = sampleCount * elapsedTime;
   
   mSum.forceValue(sum / mTotalTime, elapsedTime);
   
   mCurrentValue = x;
}

template <class T, unsigned int sampleCount, unsigned int maxOrder>
T IntegrableNumber<T, sampleCount, maxOrder>::getValue(unsigned int order) const
{
   if(order == 0)
   {
      return mCurrentValue;
   }
   else if(order > 0)
   {
      if(order <= maxOrder)
      {
         return mSum.getValue(order - 1);
      }
   }

   return mInitialValue;

}

template <class T, unsigned int sampleCount, unsigned int maxOrder>
T IntegrableNumber<T, sampleCount, maxOrder>::getSample(int i) const
{
   return mSamples[i % sampleCount];
}

template <class T, unsigned int sampleCount>
class IntegrableNumber<T, sampleCount, 1>: public AbstractFilteredNumber<T, sampleCount, 1>
{
private:
   T mSamples[sampleCount];   
   T mTimeSamples[sampleCount];  
   CyclicNumber<int> mCurrentIndex; 
   T mCurrentValue;
   T mInitialValue;
   T mSum;
   float mTotalTime;

public:
   IntegrableNumber(T initialValue);

   void setValue(T x, float elapsedTime = 1.0f);

   T getValue(unsigned int order) const;

   T getSample(int i) const;

   void forceValue(T x, float elapsedTime = 1.0f);
};

template <class T, unsigned int sampleCount>
IntegrableNumber<T, sampleCount, 1>::IntegrableNumber(T initialValue):
   mInitialValue(initialValue),
   mCurrentValue(initialValue),
   mCurrentIndex(0, 0, sampleCount, 1),
   mSum(initialValue),
   mTotalTime(sampleCount * TIME_UNIT)
{
   for(int i = 0; i < sampleCount; i++)
   {
      mSamples[i] = initialValue;
      mTimeSamples[i] = TIME_UNIT;
   }
}

template <class T, unsigned int sampleCount>
void IntegrableNumber<T, sampleCount, 1>::setValue(T x, float elapsedTime)
{
   mCurrentIndex++;

   int index = mCurrentIndex;

   T newValue = x * elapsedTime;

   mTotalTime += elapsedTime - mTimeSamples[index];
   mSum += (newValue - mSamples[index]) / mTotalTime;
   

   mSamples[index] = newValue;
   mTimeSamples[index] = elapsedTime;

   mCurrentValue = x;
}

template <class T, unsigned int sampleCount>
void IntegrableNumber<T, sampleCount, 1>::forceValue(T x, float elapsedTime)
{
   T newValue = x * elapsedTime;

   mSum = mInitialValue; //zero

   for(int i = 0; i < sampleCount; i++)
   {
      mSamples[i] = newValue;
      mTimeSamples[i] = elapsedTime;

      mSum += newValue;    
   }  

   mTotalTime = sampleCount * elapsedTime;
   mSum /= mTotalTime;


   mCurrentValue = x;
}

template <class T, unsigned int sampleCount>
T IntegrableNumber<T, sampleCount, 1>::getValue(unsigned int order) const
{
   if(order == 0)
   {
      return mCurrentValue;
   }
   else if(order == 1)
   {
      return mSum;
   }

   return mInitialValue;
}

template <class T, unsigned int sampleCount>
T IntegrableNumber<T, sampleCount, 1>::getSample(int i) const
{
   return mSamples[i % sampleCount];
}

template <class T, unsigned int sampleCount>
class IntegrableNumber<T, sampleCount, 0>: public AbstractFilteredNumber<T, sampleCount, 0>
{
public:
   IntegrableNumber(T initialValue);
};

template <class T, unsigned int sampleCount>
IntegrableNumber<T, sampleCount, 0>::IntegrableNumber(T initialValue):
   AbstractFilteredNumber(initialValue)
{
}

}} //namespace

#endif //_INTEGRABLE_NUMBER_H_

---