Интегрированные функции выполняют временную эволюцию данного ОДЭ от некоторого начального времениt₀до заданного конечного времениt₁и начиная с состоянияx₀последующими вызовами функции<do_step>данного степпера. Кроме того, пользователь может предоставить __observer для анализа состояния во время эволюции и<max_step_checker>для исключения, если между вызовами наблюдателя делается слишком много шагов (т.е. слишком маленький размер шага). Существует пять различных интегрирующих функций, которые имеют разные стратегии вызова функции наблюдателя во время интеграции. Все функции интеграции, за исключением<integrate_n_steps>, могут быть вызваны любым степпером, следующим за одним из степперных понятий:Stepper,Error Stepper,Controlled Stepper,Dense Output Stepper. В зависимости от способностей степпера интегрируемые функции используют пошаговый контроль или плотный выход.

Equidistant observer calls

Если требуется вызов наблюдателя с равноудаленными интервалами времениdt, следует использовать функцию<integrate_const>или<integrate_n_steps>. Начнем с объяснения<integrate_const>:

<integrate_const( stepper, system, x0, t0, t1, dt)>

<integrate_const( stepper, system, x0, t0, t1, dt, observer)>

<integrate_const( stepper, system, x0, t0, t1, dt, observer, max_step_checker)>

Они объединяют ODE, данное<system>, с последующими шагами<stepper>. Интеграция начинается с<t0>и<x0>и заканчивается примерноt' = t₀+ n dtсnтаким образом, чтоt₁- dt< t'<= t₁.<x0>изменяется на приблизительное решениеx(t')в конце интеграции. Если дано,<observer>вызывается время от времениt₀,t₀+ dt,t₀+ 2dt, ...,t'. При условии, что<max_step_checker>подсчитывает количество шагов между вызовами наблюдателя и бросает<no_progress_error>, это превышает некоторый предел (по умолчанию: 500).<integrate_const>возвращает количество шагов, выполненных во время интеграции. Обратите внимание, что если вы используете простыеStepperилиError Stepperи хотите сделать ровно<n>шагов, вы должны предпочесть функцию<integrate_n_steps>ниже.

Integrate a given number of steps

Эта функция очень похожа на<integrate_const>выше. Разница лишь в том, что оно принимает в качестве параметра не конечное время, а количество шагов. Интеграция выполняется до времени<t0+n*dt>.

<integrate_n_steps( stepper, system, x0, t0, dt, n)>

<integrate_n_steps( stepper, system, x0, t0, dt, n,observer)>

<integrate_n_steps( stepper, system, x0, t0, dt, n,observer,max_step_checker)>

Интегрирует ODE, данный<system>, с последующими шагами от<stepper>, начиная сx₀иt₀. Если дано, то<observer>вызывается после каждого шага и в начале<t0>, как и выше. И снова, если между вызовами наблюдателя выполняется слишком много шагов<max_step_checker>, то он бросает<no_progress_error>. Примерный результат дляx(t₀+ n dt )хранится в<x0>. Эта функция возвращает время окончания<t0 +n*dt>.

Observer calls at each step

Если наблюдатель должен вызываться на каждом этапе, то следует использовать функцию<integrate_adaptive>. Обратите внимание, что в случаеКонтролируемый степперилиDense Output Stepperприводит к неэквидистантным вызовам наблюдателя при изменении размера шага.

<integrate_adaptive( stepper, system, x0, t0, t1, dt)>

<integrate_adaptive( stepper, system, x0, t0, t1, dt, observer)>

Для этого необходимо, чтобы<system><stepper>было принято решение. Интеграция начинается на<t0>и<x0>и заканчивается наt₁.<x0>изменяется на приблизительное решениеx(t₁]в конце интеграции. Если это так, то<observer>называется после каждого шага (и перед первым шагом<t0>).<integrate_adaptive>возвращает количество шагов, выполненных во время интеграции.

	Note
	<integrate_adaptive>по замыслу выполняет вызов наблюдателя после каждого шага времени. Следовательно, нет необходимости в<max_step_checker>, поскольку между вызовами наблюдателя выполняется только один шаг.

Observer calls at given time points

Если наблюдатель должен быть вызван в определенный момент времени пользователем, следует использовать функцию<integrate_times>. Время вызова наблюдателя предоставляется как последовательность значений времени. Последовательность определяется либо с помощью двух итераторов, указывающих начало и конец последовательности, либо с точки зрения объектаBoost.Range.

<integrate_times( stepper, system, x0, times_start, times_end, dt, observer)>

<integrate_times( stepper, system, x0, time_range, dt, observer)>

Устанавливается<system>с последующими шагами<stepper>. Интеграция начинается в<*times_start>и заканчивается точно в<*(times_end-1)>.<x0>содержит приблизительное решение в конечной точке интеграции. Эта функция требует наблюдателя, который вызывается в последующие времена<*times_start++>до<times_start== times_end>. При вызове сBoost.Range<time_range>функция ведет себя так же с<times_start=boost::begin(time_range )>и<times_end =boost::end( time_range)>. Кроме того, может быть предусмотрена<max_step_checker>, например:

<integrate_times( stepper, system, x0, times_start, times_end, dt, observer, max_step_checker)>

Как указано выше, это приведет к тому, что<no_progress_error>будет выполнено слишком много шагов между вызовами наблюдателя.

<integrate_times>возвращает количество шагов, выполненных во время интеграции.

Convenience integrate function

Дополнительно к сложной функции интеграции выше odeint также обеспечивается простая<integrate>процедура, которая использует плотный выходной степпер на основе<runge_kutta_dopri5>со стандартными границами ошибок10^-6для этапов.

<integrate( system, x0, t0, t1, dt)>

<integrate( system, x0, t0, t1, dt, observer)>

Эта функция ведет себя точно так же, как<integrate_adaptive>выше, но не должна быть предусмотрена степпер. Он также возвращает количество шагов, выполненных во время интеграции.