ODE

Header-only ordinary differential equation solvers in C++20.

Example: Lorenz system

#include <ode/ode.hpp>

using method_type  = ode::explicit_method<ode::runge_kutta_4_tableau<float>>;
using problem_type = ode::initial_value_problem<float, vector3f>;

std::int32_t main(std::int32_t argc, char** argv)
{
  const auto sigma   = 10.0f;
  const auto rho     = 28.0f;
  const auto beta    = 8.0f / 3.0f;

  const auto problem = problem_type
  {
    0.0f,                                  /* t0 */
    vector3f(16.0f, 16.0f, 16.0f),         /* y0 */         
    [&] (const float t, const vector3f& y) /* dy/dt = f(t, y) */
    {
      return vector3f(sigma * (y[1] - y[0]), y[0] * (rho - y[2]) - y[1], y[0] * y[1] - beta * y[2]);
    }
  };
  
  auto iterator = ode::fixed_step_iterator<method_type, problem_type>(problem, 1.0f /* h */);
  while (true)
    ++iterator;
}

Design Notes

Butcher Tableau

  • The [ |extended_]butcher_tableau encapsulate the coefficients of a Butcher tableau.
  • The type of a tableau must satisfy std::is_arithmetic<type>.
  • The following tableau are currently provided:
    • Explicit:
      • Forward Euler
      • Runge Kutta 4
      • Dormand Prince 5

Problems

  • The initial_value_problem encapsulate the (initial) state of an ordinary differential equation problem.
  • The higher_order_initial_value_problems may be decomposed into order many coupled initial_value_problems.
  • The time_type of a problem must satisfy std::is_arithmetic<time_type>.
  • The value_type of a problem must satisfy std::is_default_constructible<value_type>, std::is_assignable<value_type>, and additionally provide the following operators.
    • Add assign: value += value.
    • Add : value + value -> value.
    • Subtract : value - value -> value.
    • Scale : value * time -> value.

Methods

  • The explicit_methods encapsulate the operations to perform a single iteration of the solution to a initial_value_problem.
  • The methods are constructed from [ |extended_]butcher_tableau.

Iterators

  • The [fixed_size|adaptive_size]_iterators iterate a explicit_method over a initial_value_problem.
  • The coupled_fixed_size_iterators iterate a explicit_method over coupled initial_value_problems.

Acknowledgements

GitHub

View Github