numeric

Giriş
ODE kelimesi ordinary differential equations anlamına gelir.  boost/odeint dışında gnuscientific kullanılabilir.

interval Sınıfı
interval Sınıfı yazısına taşıdım.

runge_kutta4 Sınıfı
Giriş
Şu satırı dahil ederiz.

#include<boost/numeric/odeint.hpp>

Constructor
Şöyle yaparız.

odeint::runge_kutta4< double > rk4;

do_step metodu
Şöyle yaparız.

raman_signal_system sys;

double P_s = ...

double z = ...

const double dz = ...

rk4.do_step( sys, P_s, z, dz );

odeint::integrate metodu
Şu satırı dahil ederiz.

#include <boost/numeric/odeint.hpp>

Örnek
Sinüs dalgası üretmek için kullanılır. Elimizde bir dizi ve bu dizi ile işlem yapan bir sınıf olsun

// define structure
struct T
{
  std::array<double, 6> IC;
  double                S;
};

// force model
class harm_osc
{
  struct T T1;

public:
  harm_osc(struct T G) : T1(G) {}

  void operator() ( const std::vector< double > &x ,
                    std::vector< double > &dxdt , const double /* t */ )
  {
    dxdt[0] = x[1];
    dxdt[1] = -x[0] - T1.IC[0]*x[1] + T1.S;
  }
};

Şöyle bir metodumuz olsun

// print integrated state solution
void write_solution( const std::vector< double > &x , const double t )
{
  printf("%-6.2f %-6.2f %-6.2f\n", t, x[0], x[1]);
}

Şöyle yaparız. Dalganın başlangıç noktasını x = 1.0 ve p = 0.0 yapar.

std::vector< double > x(2);
x[0] = 1.0;
x[1] = 0.0;

struct T T2;

T2.IC = {0.15, 0.15, 0.15, 0.15, 0.15, 0.15};
T2.S  = 0.0;

harm_osc ho(T2);
boost::numeric::odeint::integrate(ho, x, 0.0, 10.0, 0.1, write_solution);

odeint::integrate_adaptive metodu
Sanırım integral alıyor. 6 veya 7 parametre alıyor. Çıktı 3. parametre.
İlk parametre stepper. Default stepper için şöyle yaparız.

using Stepper = boost::numeric::odeint::runge_kutta_dopri5<State, Value, Derivative,
  Time, boost::numeric::odeint::vector_space_algebra>;

Diğer parametreler system, start_state, min, max, dt, observer
Örnek
Şöyle yaparız.

 DeterministicStateType x0 { { {"A", 1.0}, {"B", 1.0} } };
typedef runge_kutta_dopri5<DeterministicStateType, double, DeterministicStateType, double,
  vector_space_algebra> stepper_type;
integrate_adaptive(make_dense_output(1e-6, 1e-6, stepper_type()), derivative, x0, 0.0,
  300.0, 0.00001);

Örnek

Elimizde şöyle bir kod olsun.

double err_abs = 1.0e-10;
double err_rel = 1.0e-6;

Şöyle yaparız.

state_type x = std::complex<double>(0.0, 0.0);
odeint::integrate_adaptive(
           odeint::make_controlled<error_stepper_type>(err_abs, err_rel),
           Integrand(pt), x, 0.0, 1.0, 0.001);
return x;

odeint::integrate_const metodu
Örnek
Elimizde şöyle bir kod olsun.

typedef boost::units::quantity<boost::units::si::length, double> length_type;
typedef boost::units::quantity<boost::units::si::velocity, double> velocity_type;
typedef boost::units::quantity<boost::units::si::time, double> time_type;

namespace si = boost::units::si;

Şöyle yaparız.

void exponential_decay(const length_type &x, velocity_type &dxdt, time_type /*t*/) {
  dxdt = -0.0001 * x / si::second;
}


using stepper_type = boost::numeric::odeint::runge_kutta4<
  length_type, double, velocity_type, time_type,
  boost::numeric::odeint::vector_space_algebra>;

length_type startValue = 10 * si::meter;
auto steps = integrate_const(
  stepper_type{}, exponential_decay,
  startValue, 0.0 * si::second, 10.0 * si::second,
  0.1 * si::second);

Çıktı olarak şunu alırız.

Steps: 100

odedint::integrate_times metodu
Şöyle yaparız.

auto stepper = make_controlled<error_stepper_type>( 1.0e-10 , 1.0e-16 );
// std::vector<time> times;
// std::vector<state> x_vec;
auto tbegin = times.begin();
auto tend = times.end();
integrate_times(stepper, dynamics, x, tbegin, tend, push_back_state(x_vec));