00001 #ifndef _DIFFERENTIABLE_NUMBER_H_
00002 #define _DIFFERENTIABLE_NUMBER_H_
00003
00004 namespace luma
00005 {
00006 namespace numbers
00007 {
00008
00056 template <class T, unsigned int maxOrder>
00057 class DifferentiableNumber : public AbstractFilteredNumber<T, 2, maxOrder>
00058 {
00059 private:
00060 T mValue;
00061 T mPreviousValue;
00062 T mInitialValue;
00063
00069 DifferentiableNumber<T, maxOrder - 1> mDifference;
00070
00071 public:
00078 DifferentiableNumber(T initialValue);
00079
00086 void setValue(T value, float elapsedTime = 1.0f);
00087
00097 T getValue(unsigned int order = 1) const;
00098
00104 void forceValue(T value);
00105 };
00106
00107 template <class T, unsigned int maxOrder>
00108 void DifferentiableNumber<T, maxOrder>::setValue(T value, float elapsedTime)
00109 {
00110 mPreviousValue = mValue;
00111 mValue = value;
00112
00113 mDifference.setValue((mValue - mPreviousValue) / (elapsedTime * frameRate));
00114 }
00115
00116 template <class T, unsigned int maxOrder>
00117 void DifferentiableNumber<T, maxOrder>::forceValue(T value)
00118 {
00119 mPreviousValue = value;
00120 mValue = value;
00121
00122 mDifference.forceValue(mInitialValue);
00123 }
00124
00125 template <class T, unsigned int maxOrder>
00126 DifferentiableNumber<T, maxOrder>::DifferentiableNumber(T initialValue):
00127 mInitialValue(initialValue),
00128 mValue(initialValue),
00129 mPreviousValue(initialValue),
00130 mDifference(initialValue)
00131 {
00132 }
00133
00134 template <class T, unsigned int maxOrder>
00135 T DifferentiableNumber<T, maxOrder>::getValue(unsigned int order) const
00136 {
00137 if(order == 0)
00138 {
00139 return mValue;
00140 }
00141 else if(order > 0)
00142 {
00143 if(order <= maxOrder)
00144 {
00145 return mDifference.getValue(order - 1);
00146 }
00147 }
00148
00149 return mInitialValue;
00150 }
00151
00157 template <class T>
00158 class DifferentiableNumber<T, 1> : public AbstractFilteredNumber<T, 2, 1>
00159 {
00160 private:
00161 T mValue;
00162 T mPreviousValue;
00163 T mDifference;
00164 T mInitialValue;
00165
00166 public:
00167
00171 DifferentiableNumber(T initialValue);
00172
00176 void setValue(T value, float elapsedTime = 1.0f);
00177
00178 void forceValue(T value);
00179
00183 T getValue(unsigned int order = 1) const;
00184 };
00185
00186 template <class T>
00187 void DifferentiableNumber<T, 1>::setValue(T value, float elapsedTime)
00188 {
00189 mPreviousValue = mValue;
00190 mValue = value;
00191 mDifference = (mValue - mPreviousValue) / (elapsedTime * frameRate);
00192 }
00193
00194 template <class T>
00195 void DifferentiableNumber<T, 1>::forceValue(T value)
00196 {
00197 mPreviousValue = value;
00198 mValue = value;
00199 mDifference = mInitialValue;
00200 }
00201
00202
00203 template <class T>
00204 DifferentiableNumber<T, 1>::DifferentiableNumber(T initialValue):
00205 mInitialValue(initialValue),
00206 mValue(initialValue),
00207 mPreviousValue(initialValue),
00208 mDifference(initialValue)
00209 {
00210 }
00211
00212 template <class T>
00213 T DifferentiableNumber<T, 1>::getValue(unsigned int order) const
00214 {
00215 if(order == 0)
00216 {
00217 return mValue;
00218 }
00219 else if(order == 1)
00220 {
00221 return mDifference;
00222 }
00223
00224 return mInitialValue;
00225 }
00226
00232 template <class T>
00233 class DifferentiableNumber<T, 0> : public AbstractFilteredNumber<T, 2, 0>
00234 {
00235 private:
00236 T mValue;
00237 T mInitialValue;
00238 public:
00239 DifferentiableNumber(T initialValue);
00240 };
00241
00242
00243 template <class T>
00244 DifferentiableNumber<T, 0>::DifferentiableNumber(T initialValue):
00245 AbstractFilteredNumber(initialValue)
00246 {
00247 }
00248
00249 };};
00250
00251 #endif //_DIFFERENTIABLE_NUMBER_H_
