odeint поддерживает итераторы, которые итерируют вдоль приблизительного решения обычного дифференциального уравнения. Итераторы предлагают альтернативу интегрированным функциям. Кроме того, многие стандартные алгоритмы в стандартной библиотеке C++ и Boost. Диапазон можно использовать с итераторами odeint.

Предусмотрено несколько типов итераторов, в соответствии синтегрированными функциями.. Следовательно, есть<const_step_iterator>,<adaptive_step_iterator>,<n_step_iterator>и<times_iterator>— каждая из них в двух вариантах: либо только с<state>, либо с<std::pair<state,time>>в качестве типа значения. Все они являются единичными итераторами. Ниже мы покажем несколько примеров того, как использовать эти итераторы вместе с алгоритмами std.

runge_kutta4< state_type > stepper;
state_type x = {{ 10.0 , 10.0 , 10.0 }};
double res = std::accumulate( make_const_step_iterator_begin( stepper , lorenz() , x , 0.0 , 1.0 , 0.01 ) ,
                              make_const_step_iterator_end( stepper , lorenz() , x ) ,
                              0.0 ,
                              []( double sum , const state_type &x ) {
                                  return sum + x[0]; } );
cout << res << endl;

В этом примере аккумулируются все x-значения решения. Обратите внимание, как отступление от итератора дает текущее состояние<x>ОДЭ (второй аргумент аккумулируемой лямбды). Сам итератор не встречается непосредственно в этом примере, но он генерируется заводскими функциями<make_const_step_iterator_begin>и<make_const_step_iterator_end>. Диапазон, позволяющий записать вышеприведенный пример в более компактном виде с заводской функцией<make_const_step_range>, но теперь использующий<boost::accumulate>из __bost_range:

runge_kutta4< state_type > stepper;
state_type x = {{ 10.0 , 10.0 , 10.0 }};
double res = boost::accumulate( make_const_step_range( stepper , lorenz() , x , 0.0 , 1.0 , 0.01 ) , 0.0 ,
                                []( double sum , const state_type &x ) {
                                    return sum + x[0]; } );
cout << res << endl;

Второй тип итератора также является итератором с размером шага const. Но ценностный тип этого итератора состоит здесь из пары времени и состояния решения ОДЭ. Примером является

runge_kutta4< state_type > stepper;
state_type x = {{ 10.0 , 10.0 , 10.0 }};
double res = boost::accumulate( make_const_step_time_range( stepper , lorenz() , x , 0.0 , 1.0 , 0.01 ) , 0.0 ,
                                []( double sum , const std::pair< const state_type &, double > &x ) {
                                    return sum + x.first[0]; } );
cout << res << endl;

В настоящее время заводские функции<make_const_step_time_iterator_begin>,<make_const_step_time_iterator_end>и<make_const_step_time_range>. Обратите внимание, что лямбда теперь ожидает<std::pair>, поскольку это тип стоимости<const_step_time_iterator>.

Далее мы обсудим адаптивные итераторы, которые полностью аналогичны конст-ступенчатым итераторам, но основаны на адаптивных степперных процедурах и, таким образом, корректируют размер шага во время итерации. Примерами являются

auto stepper = make_controlled( 1.0e-6 , 1.0e-6 , runge_kutta_cash_karp54< state_type >() );
state_type x = {{ 10.0 , 10.0 , 10.0 }};
double res = boost::accumulate( make_adaptive_range( stepper , lorenz() , x , 0.0 , 1.0 , 0.01 ) , 0.0 ,
                                []( double sum , const state_type& x ) {
                                    return sum + x[0]; } );
cout << res << endl;

auto stepper = make_controlled( 1.0e-6 , 1.0e-6 , runge_kutta_cash_karp54< state_type >() );
state_type x = {{ 10.0 , 10.0 , 10.0 }};
double res = boost::accumulate( make_adaptive_time_range( stepper , lorenz() , x , 0.0 , 1.0 , 0.01 ) , 0.0 ,
                                []( double sum , const pair< const state_type& , double > &x ) {
                                    return sum + x.first[0]; } );
cout << res << endl;

	Note
	Adaptive_iterator<and>Adaptive_time_iterator можно использовать только сКонтролируемый степперилиПлотный выходной степпер.

В общем, можно сказать, что повторение в диапазоне<const_step_iterator>ведет себя как<integrate_const>вызов функции, и аналогично для<adaptive_iterator>и<integrate_adaptive>,<n_step_iterator>и<integrate_n_steps>, и, наконец,<times_iterator>и<integrate_times>.

Ниже мы перечислим наиболее важные свойства итераторов: