summaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
authorTavian Barnes <tavianator@gmail.com>2010-10-06 09:53:00 -0400
committerTavian Barnes <tavianator@gmail.com>2010-10-06 09:53:00 -0400
commitb9afb13de34b495956d5b0cee712e949052bfba8 (patch)
tree7f931e9bedf938bf3373139da2f4cfc47a58072f /src
parent53b7d03b39ae30bcca53dc294f213e6d455943f7 (diff)
downloadvz-b9afb13de34b495956d5b0cee712e949052bfba8.tar.xz
Don't use 'Real' for the template parameter.
We could be dealing with vectors, etc.
Diffstat (limited to 'src')
-rw-r--r--src/vZ/integrator.hpp30
-rw-r--r--src/vZ/simple.hpp16
2 files changed, 23 insertions, 23 deletions
diff --git a/src/vZ/integrator.hpp b/src/vZ/integrator.hpp
index 394f40f..a652bf6 100644
--- a/src/vZ/integrator.hpp
+++ b/src/vZ/integrator.hpp
@@ -32,35 +32,35 @@ namespace vZ
// If the initial value problem is specified as
// y' = f(t, y); y(t0) = y0
// then an Integrator could be constructed as Integrator(f, dt).y(y0).t(t0)
- template <typename Real>
+ template <typename T>
class GenericIntegrator
{
public:
- typedef std::tr1::function<Real (Real, Real)> Function;
+ typedef std::tr1::function<T (T, T)> Function;
// By default, y and t start at zero
- GenericIntegrator(Function f, Real dt)
+ GenericIntegrator(Function f, T dt)
: m_f(f), m_y(0), m_t(0), m_dt(dt) { }
virtual ~GenericIntegrator() { }
- GenericIntegrator& y(Real y) { m_y = y; return *this; }
- GenericIntegrator& t(Real t) { m_t = t; return *this; }
- GenericIntegrator& dt(Real dt) { m_dt = dt; return *this; }
+ GenericIntegrator& y(T y) { m_y = y; return *this; }
+ GenericIntegrator& t(T t) { m_t = t; return *this; }
+ GenericIntegrator& dt(T dt) { m_dt = dt; return *this; }
- Real y() const { return m_y; }
- Real t() const { return m_t; }
- Real dt() const { return m_dt; }
+ T y() const { return m_y; }
+ T t() const { return m_t; }
+ T dt() const { return m_dt; }
// Integrate until time t
- void integrate(Real t_final);
+ void integrate(T t_final);
protected:
- virtual void step(Real& t, Real& dt) = 0;
+ virtual void step(T& t, T& dt) = 0;
Function m_f;
private:
- Real m_y;
- Real m_t, m_dt;
+ T m_y;
+ T m_t, m_dt;
};
// Type alias
@@ -68,9 +68,9 @@ namespace vZ
// Definitions
- template <typename Real>
+ template <typename T>
void
- GenericIntegrator<Real>::integrate(Real t_final)
+ GenericIntegrator<T>::integrate(T t_final)
{
while (m_t < t_final) {
m_dt = std::min(m_dt, t_final - m_t);
diff --git a/src/vZ/simple.hpp b/src/vZ/simple.hpp
index 65b7560..3b02472 100644
--- a/src/vZ/simple.hpp
+++ b/src/vZ/simple.hpp
@@ -26,23 +26,23 @@
namespace vZ
{
// Base class for non-adaptive RK-style algorithms
- template <typename Real>
- class GenericSimpleIntegrator : public GenericIntegrator<Real>
+ template <typename T>
+ class GenericSimpleIntegrator : public GenericIntegrator<T>
{
public:
- typedef typename GenericIntegrator<Real>::Function Function;
+ typedef typename GenericIntegrator<T>::Function Function;
// Coefficients in the tableau representation of the RK algorithm
- typedef std::vector<std::vector<Real> > ACoefficients;
- typedef std::vector<Real> BCoefficients;
+ typedef std::vector<std::vector<T> > ACoefficients;
+ typedef std::vector<T> BCoefficients;
- GenericSimpleIntegrator(Function f, Real dt,
+ GenericSimpleIntegrator(Function f, T dt,
ACoefficients a, BCoefficients b)
- : GenericIntegrator<Real>(f, dt), m_a(a), m_b(b) { }
+ : GenericIntegrator<T>(f, dt), m_a(a), m_b(b) { }
virtual ~GenericSimpleIntegrator() { }
protected:
- virtual void step(Real& t, Real& dt);
+ virtual void step(T& t, T& dt);
private:
ACoefficients m_a;