Алговики - Вклад [ru]

Участник:Борис/Алгоритм Рунге-Кутты

2016-12-19T20:51:01Z

Борис: /* Масштабируемость алгоритма и его реализации */

{{algorithm
| name = Метод Рунге-Кутты 4 порядка
| serial_complexity = <math>4nCm</math>
| pf_height = <math>O(n)</math>
| pf_width = <math>O(m)</math>
| input_data = <math>m + 3</math>
| output_data = <math>m * n</math>
}}

Основные авторы описания: [[Участник:Jest|Е.П.Степанов]](разделы [[#Общее описание алгоритма|1.1]], [[#Математическое описание алгоритма|1.2]], [[#Вычислительное ядро алгоритма|1.3]], [[#Макроструктура алгоритма|1.4]], [[#Входные и выходные данные алгоритма|1.9]]), [[Участник:Борис|Б.Савков]] (разделы [[#Схема реализации последовательного алгоритма|1.5]], [[#Последовательная сложность алгоритма|1.6]], [[#Информационный граф|1.7]], [[#Ресурс параллелизма алгоритма|1.8]], [[#Свойства алгоритма|1.10]], [[#Существующие реализации алгоритма|2.7]])

= Свойства и структура алгоритмов =

== Общее описание алгоритма ==

Ме́тоды Ру́нге — Ку́тты (распространено неправильное название Ме́тоды Ру́нге — Ку́тта или же Ме́тоды Ру́нге — Кутта́) — важное семейство численных алгоритмов решения обыкновенных дифференциальных уравнений и их систем. Данные итеративные методы явного и неявного приближённого вычисления были разработаны около 1900 года немецкими математиками К. Рунге и М. В. Куттой.

Метод Рунге - Кутты применяется при решения задачи Коши для системы обыкновенных дифференциальных уравнений первого порядка:

:<math>
\begin{cases}
\textbf{y}' = \textbf{f}(x, \textbf{y}),\\
\textbf{y}(x_0) = \textbf{y}_0.
\end{cases}
</math>

При этом <math>\textbf{y}, \textbf{f}, x</math> отвечают следующим свойствам: <math> \textbf{y}, \textbf{f} \in \mathbb{R}^m, x \in \mathbb{R}^1 </math>.

Пусть известно значение y(x) и требуется вычислить значение y(x+h). Это можно сделать при помощи формулы:

:<math> y(x + h) = y(x) + \int_0^hy'(x + t)dt</math>

Аппроксимируя интеграл в правой части, можно получить методы Рунге-Кутты разного порядка точности <ref>Бахвалов Н. С., Жидков Н. П., Кобельков. Г. М. — 6-е изд. — М. : БИНОМ. Лаборатория знаний, 2008. — 636 с.</ref>. В общем виде формулы методов Рунге-Кутты можно записать следующим образом:

:<math>\textbf{y}_{n+1} = \textbf{y}_n + h\sum_{i=1}^s b_i \textbf{k}_i</math>

:<math>
\begin{array}{ll}
\textbf{k}_1 =& \textbf{f}(x_n, \textbf{y}_n),\\
\textbf{k}_2 =& \textbf{f}(x_n+c_2h, \textbf{y}_n+a_{21}h\textbf{k}_1),\\
\cdots&\\
\textbf{k}_s =& \textbf{f}(x_n+c_sh, \textbf{y}_n+a_{s1}h\textbf{k}_1+a_{s2}h\textbf{k}_2+\cdots+a_{s,s-1}h\textbf{k}_{s-1})
\end{array}
</math>

Увеличивая число s вспомогательных точек, можно построить методы Рунге-Кутты любого порядка точности p. Однако уже при p > 5 эти методы используются довольно редко. Это объясняется как чрезмерной громоздкостью получающихся вычислительных формул, так и тем, что преимущества методов высокого порядка точности над методами, в которых p = 4 или p = 5, проявляются либо в тех задачах, где нужна очень высокая точность и используются ЭВМ высокой разрядности, либо в тех задачах, где решение очень гладкое. Кроме того, методы Рунге-Кутты высокого порядка точности часто оказываются менее эффективными по сравнению с методами Адамса того же порядка точности <ref>Амосов А.А., Дубинский Ю.А., Копченова Н.В. Вычислительные методы для инженеров: Учеб. пособие. — М.: Высш. шк., 1994. — 544 с. </ref>. На этой странице представлен наиболее распространенный метод Рунге-Кутты 4 порядка с ошибкой на конечном интервале интегрирования <math>O(h^4)</math>.

Существуют как явные, так и неявные методы Рунге-Кутты. Последние имеют ряд преимуществ над явными методами, однако это достигается за счет существенного усложнения вычислительного алгоритма, так как на каждом шаге приходится считать систему нелинейных уравнений. На этой странице представлен явный метод Рунге-Кутты.

Можно отметить, что в современных программах, реализующих метод Рунге-Кутты, обязательно используется некоторый алгоритм автоматического изменения шага интегрирования. Интуитивно ясно, что на участках плавного изменения решения счет можно вести с достаточно крупным шагом. В то же время на тех участках, где происходят резкие изменения поведения решения, необходимо выбирать мелкий шаг интегрирования. Обычно начальное значение шага h1 задает пользователь. Далее шаг интегрирования меняется в соответствии с величиной получаемой в ходе вычислений оценки локальной погрешности. Для упрощения описания на этой странице используется постоянный шаг интегрирования h, зависящий от размера сетки разбиения n.

== Математическое описание алгоритма ==

Далее подразумевается, что <math> \bold y, \bold y_i,\bold f, \bold k_i \in \mathbb{R}^m</math>, а <math>x, h, n, a, b \in \mathbb{R}^1 </math>.

Исходные данные:
:<math> a, b </math> - интервал интегрирования,
:<math> \bold y_0 </math> - вектор значений при <math> x = a </math>,
:n - количество точек в разбиении
:<math>\bold f </math> - функция вычисления производной

Вычисляемые данные:
:<math> \bold y_i </math> - вектора значений в узлах сетки, т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>

Формулы метода:
:Вначале вычисляется шаг сетки:
::<math> h = \frac{b-a}{n}</math>.
:Приближенное значение в следующих точках вычисляется по итерационной формуле:
::<math>\textbf{y}_{n+1} = \textbf{y}_n + {h \over 6}(\textbf{k}_1 + 2\textbf{k}_2 + 2\textbf{k}_3 + \textbf{k}_4)</math>,
::<math>\textbf{k}_1 = \textbf{f} \left( x_n, \textbf{y}_n \right),</math>
::<math>\textbf{k}_2 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_1 \right),</math>
::<math>\textbf{k}_3 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_2 \right),</math>
::<math>\textbf{k}_4 = \textbf{f} \left( x_n + h, \textbf{y}_n + h\ \textbf{k}_3 \right),</math>
::<math>x_{n+1} = x_n + h.</math>

== Вычислительное ядро алгоритма ==

Вычислительным ядром метода Рунге-Кутты можно считать вычисление значений функции производной
:<math>\textbf{f}(x, \textbf{y})</math>,
так как при вычислении каждого нового <math>\textbf{y}_n</math> требуется 4 вычисления значения функции производной. Таким образом, сложность работы алгоритма существенно зависит от сложности вычисления функции <math>\textbf{f}</math>.

== Макроструктура алгоритма ==

Макроструктура алгоритма может быть представлена в следующем виде:

1. Вычисление вспомогательных коэффициентов <math>\textbf{k}_j, j \in [1,4]</math>;

2. Вычисление приближенного значения <math> \bold y_i </math> в следующей точке;

3. Переход на следующую итерацию или остановка.

== Схема реализации последовательного алгоритма ==

Пример реализации последовательного алгоритма на языке C++ (указатель на функцию f передаётся через аргументы представленной ниже функции):
<source lang="c++" line="1">
#include <vector>

// other code ...

std::vector<double> rungekutta4(double a, double b, std::vector<double> y0, int n, std::vector<double (*)(double,double)> f)
{
std::vector<double>::size_type sz = y0.size();
std::vector<double> result;
for (unsigned j=0; j<sz; j++)
{
rezult.push_back(core(a,b,y[j],n,f[j]));
}
return result;
}

double core(double a, double b, double y0, int n, double (*f)(double,double))
{
double h, k1, k2, k3, k4, x, y;
h = (b - a)/n;
y = y0;
x = a;
for (unsigned i = 0; i < n; i++)
{
k1 = f(x, y);
k2 = f(x + h/2, y + h*k1/2);
k3 = f(x + h/2, y + h*k2/2);
k4 = f(x + h/2, y + h*k3);
x += h;
y += h*(k1 + 2*k2 + 2*k3 + k4)/6;
}
return y;
}

// other code ...
</source>

== Последовательная сложность алгоритма ==

Рассмотрим сначала одномерный случай. Наравне с обычными операциями, такими как сложение, умножение и тому подобными, в представленном выше алгоритме присутствует вызов функции <math> f </math>. Так как эта функция может содержать в себе любое количество простых математических операций, будем считать, что её сложность <math> f </math> много больше любой из них, и равна константе <math>C</math>. За весь алгоритм, она вызывается <math>4n</math> раза. Таким образом, сложность последовательного алгоритма для одномерного случая равна <math>4nC</math>.

Для случая решения системы ОДУ, когда <math>f</math> и <math>y</math> являются векторами размерности <math>m</math>, функция core будет вызвана <math>m</math>, и итоговая сложность алгоритма составит <math>4nCm</math>.

== Информационный граф ==

Информационная структура параллельного алгоритма Рунге-Кутты 4-го порядка представляет собой матрицу изображённую на рисунке ниже. Вдоль оси <math>j</math> располагаются <math>j</math>-ые параметры вектора <math>y</math>, соответственно, вдоль <math>i</math> изображены этапы вычисления <math>y_i</math> значения j-параметра вектора <math>y</math>. Таким образом, можно сказать, что вдоль оси <math>j</math>, изображены параллельные процессы. А ось <math>i</math> представляет собой шкалу времени. Чтобы соотнести её с реальным временем, надо просто посчитать сумму <math>\sum_{i=1}^{n} t_i</math>, где <math>t_i</math> - время с момента начала вычисления <math>i</math>-го всеми процессами до момента его завершения всеми процессами.

[[Файл:System_graph.png]]

Можно заметить, что на каждом <math>i</math>-ом шаге происходит обмен информацией между процессами. Это выражено в виде линии пересекающей все <math>j</math>-ые процессы на любом <math>i</math>-ом шаге.

== Ресурс параллелизма алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является итерационным алгоритмом. В нём каждый шаг цикла зависит от предыдущего. В самом шаге, каждая последующая операция также зависит от результата предыдущей. Таким образом, упразднить цикл до независимых и соответственно параллельных операций не является возможным. Однако, так как на результат функции <math> f </math> влияет только <math>i</math>-ый параметр вектора <math> y </math>, то для каждого <math> i </math> можно производить независимое вычисление. В итоге, если вычислять результаты выполнения функции <math> f </math> одновременно для вля всех <math> i</math>-ых параметров вектора <math> y </math>, получим ту же алгоритмическую сложность <math>4nC</math>, что и в [[#Последовательная сложность алгоритма|разделе 1.6]] для одномерного случая.

== Входные и выходные данные алгоритма ==

'''Входные данные''':
:<math> a, b </math> - интервал интегрирования,
:n - количество точек в разбиении,
:<math> \bold y_0 </math> - вектор значений размерности m при <math> x = a </math>,
:функцию вычисления производной <math>\bold f </math> будем считать встроенной в алгоритм.

'''Объём входных данных''':
:m + 3

'''Выходные данные:'''
:<math> \bold y_i </math> - вектора размера m значений в n узлах сетки (т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>).

'''Объем выходных данных'''
:n * m

== Свойства алгоритма ==

Алгоритм обладает следующими свойствами:

* Точность. Как написано в [[#Общее описание алгоритма| разделе 1.1]], алгоритм имеет порядок точности <math>O(h^4)</math>.
* Устойчивость. Алгоритм устойчив на любом конечном отрезке.
* Гибкость. На любом этапе вычисления можно легко изменить шаг интегрирования.
* Вычислительная мощность алгоритма стремится к константе. Сумма входных и выходных данных равна mn+m+3, а общее количество операций - 4nCm. Таким образом, при возрастании значений входных параметров, их отношение стремится к 4C.

= Программная реализация алгоритма =

== [[Особенности реализации последовательного алгоритма]] ==

== [[Локальность данных и вычислений]] ==

== [[Возможные способы и особенности параллельной реализации алгоритма]] ==

== Масштабируемость алгоритма и его реализации ==

Для исследования масштабируемости алгоритма Рунге-Кутты 4-го порядка была написана своя [https://github.com/D86/superpc/blob/master/rk4.c|параллельная реализация]. этого алгоритма на языке C.

Свойства реализации:

* Реализация написана под компилятор mpicxx.
* Тестирование проводилось на [http://hpc.cmc.msu.ru/bgp|IBM Blue Gene/P], расположенном на территории ВМК МГУ.

Исследование проводилось по [https://algowiki-project.org/ru/Scalability_methodology|рекомендованной методологии].

Тестирование

* На вход реализации подавалась система из суперпозиций элементарных функций.
* Начальные значения выбирались случайным образом.

Список изменяющихся параметров:

В качестве изменяемых параметров выбраны количество максимальное количество процессоров, выделяемое при запуске исследуемой реализации, и параметр m, так как из [[#Входные и выходные данные алгоритма| раздела 1.9]] следует, что объём входных данных зависит от него.

Границы изменяющихся параметров:

* Число процессоров выделяется с 256 до 2048 с шагом 128;
* Значение m находится в границах от 1000 до 10000 с шагом 1000.

График производительности:

[[Файл:Perf_b.png]]

График эффективности:

[[Файл:Effic.png]]

Оценки:

На основании полученных результатов были составлены графики [https://algowiki-project.org/ru/Глоссарий#.D0.9F.D1.80.D0.BE.D0.B8.D0.B7.D0.B2.D0.BE.D0.B4.D0.B8.D1.82.D0.B5.D0.BB.D1.8C.D0.BD.D0.BE.D1.81.D1.82.D1.8C| производительности] и [https://algowiki-project.org/ru/Глоссарий#.D0.AD.D1.84.D1.84.D0.B5.D0.BA.D1.82.D0.B8.D0.B2.D0.BD.D0.BE.D1.81.D1.82.D1.8C_.D1.80.D0.B0.D1.81.D0.BF.D0.B0.D1.80.D0.B0.D0.BB.D0.BB.D0.B5.D0.BB.D0.B8.D0.B2.D0.B0.D0.BD.D0.B8.D1.8F| эффективности] параллельной реализации, вычислены максимальная и минимальная [https://algowiki-project.org/ru/Глоссарий#.D0.AD.D1.84.D1.84.D0.B5.D0.BA.D1.82.D0.B8.D0.B2.D0.BD.D0.BE.D1.81.D1.82.D1.8C_.D1.80.D0.B5.D0.B0.D0.BB.D0.B8.D0.B7.D0.B0.D1.86.D0.B8.D0.B8| эффективность реализации], 0.000256661928486 и 1.30949963513e-05 соответственно.

== [[Динамические характеристики и эффективность реализации алгоритма]] ==

== [[Выводы для классов архитектур]] ==

== Существующие реализации алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является одним из наиболее используемых для решения ОДУ и их систем, поэтому существует большое число его реализаций для разных языков программирования. Наиболее популярными являются следующие из них:
* библиотека RK4, которая существует в вариантах для C++, FORTRAN90, FORTRAN77, python и MATLAB;
* библиотека ode45 для MATLAB;
* модуль scipy для PYTHON.

= Литература =

Участник:Борис/Алгоритм Рунге-Кутты

2016-12-19T19:38:57Z

Борис: /* Масштабируемость алгоритма и его реализации */

{{algorithm
| name = Метод Рунге-Кутты 4 порядка
| serial_complexity = <math>4nCm</math>
| pf_height = <math>O(n)</math>
| pf_width = <math>O(m)</math>
| input_data = <math>m + 3</math>
| output_data = <math>m * n</math>
}}

Основные авторы описания: [[Участник:Jest|Е.П.Степанов]](разделы [[#Общее описание алгоритма|1.1]], [[#Математическое описание алгоритма|1.2]], [[#Вычислительное ядро алгоритма|1.3]], [[#Макроструктура алгоритма|1.4]], [[#Входные и выходные данные алгоритма|1.9]]), [[Участник:Борис|Б.Савков]] (разделы [[#Схема реализации последовательного алгоритма|1.5]], [[#Последовательная сложность алгоритма|1.6]], [[#Информационный граф|1.7]], [[#Ресурс параллелизма алгоритма|1.8]], [[#Свойства алгоритма|1.10]], [[#Существующие реализации алгоритма|2.7]])

= Свойства и структура алгоритмов =

== Общее описание алгоритма ==

Ме́тоды Ру́нге — Ку́тты (распространено неправильное название Ме́тоды Ру́нге — Ку́тта или же Ме́тоды Ру́нге — Кутта́) — важное семейство численных алгоритмов решения обыкновенных дифференциальных уравнений и их систем. Данные итеративные методы явного и неявного приближённого вычисления были разработаны около 1900 года немецкими математиками К. Рунге и М. В. Куттой.

Метод Рунге - Кутты применяется при решения задачи Коши для системы обыкновенных дифференциальных уравнений первого порядка:

:<math>
\begin{cases}
\textbf{y}' = \textbf{f}(x, \textbf{y}),\\
\textbf{y}(x_0) = \textbf{y}_0.
\end{cases}
</math>

При этом <math>\textbf{y}, \textbf{f}, x</math> отвечают следующим свойствам: <math> \textbf{y}, \textbf{f} \in \mathbb{R}^m, x \in \mathbb{R}^1 </math>.

Пусть известно значение y(x) и требуется вычислить значение y(x+h). Это можно сделать при помощи формулы:

:<math> y(x + h) = y(x) + \int_0^hy'(x + t)dt</math>

Аппроксимируя интеграл в правой части, можно получить методы Рунге-Кутты разного порядка точности <ref>Бахвалов Н. С., Жидков Н. П., Кобельков. Г. М. — 6-е изд. — М. : БИНОМ. Лаборатория знаний, 2008. — 636 с.</ref>. В общем виде формулы методов Рунге-Кутты можно записать следующим образом:

:<math>\textbf{y}_{n+1} = \textbf{y}_n + h\sum_{i=1}^s b_i \textbf{k}_i</math>

:<math>
\begin{array}{ll}
\textbf{k}_1 =& \textbf{f}(x_n, \textbf{y}_n),\\
\textbf{k}_2 =& \textbf{f}(x_n+c_2h, \textbf{y}_n+a_{21}h\textbf{k}_1),\\
\cdots&\\
\textbf{k}_s =& \textbf{f}(x_n+c_sh, \textbf{y}_n+a_{s1}h\textbf{k}_1+a_{s2}h\textbf{k}_2+\cdots+a_{s,s-1}h\textbf{k}_{s-1})
\end{array}
</math>

Увеличивая число s вспомогательных точек, можно построить методы Рунге-Кутты любого порядка точности p. Однако уже при p > 5 эти методы используются довольно редко. Это объясняется как чрезмерной громоздкостью получающихся вычислительных формул, так и тем, что преимущества методов высокого порядка точности над методами, в которых p = 4 или p = 5, проявляются либо в тех задачах, где нужна очень высокая точность и используются ЭВМ высокой разрядности, либо в тех задачах, где решение очень гладкое. Кроме того, методы Рунге-Кутты высокого порядка точности часто оказываются менее эффективными по сравнению с методами Адамса того же порядка точности <ref>Амосов А.А., Дубинский Ю.А., Копченова Н.В. Вычислительные методы для инженеров: Учеб. пособие. — М.: Высш. шк., 1994. — 544 с. </ref>. На этой странице представлен наиболее распространенный метод Рунге-Кутты 4 порядка с ошибкой на конечном интервале интегрирования <math>O(h^4)</math>.

Существуют как явные, так и неявные методы Рунге-Кутты. Последние имеют ряд преимуществ над явными методами, однако это достигается за счет существенного усложнения вычислительного алгоритма, так как на каждом шаге приходится считать систему нелинейных уравнений. На этой странице представлен явный метод Рунге-Кутты.

Можно отметить, что в современных программах, реализующих метод Рунге-Кутты, обязательно используется некоторый алгоритм автоматического изменения шага интегрирования. Интуитивно ясно, что на участках плавного изменения решения счет можно вести с достаточно крупным шагом. В то же время на тех участках, где происходят резкие изменения поведения решения, необходимо выбирать мелкий шаг интегрирования. Обычно начальное значение шага h1 задает пользователь. Далее шаг интегрирования меняется в соответствии с величиной получаемой в ходе вычислений оценки локальной погрешности. Для упрощения описания на этой странице используется постоянный шаг интегрирования h, зависящий от размера сетки разбиения n.

== Математическое описание алгоритма ==

Далее подразумевается, что <math> \bold y, \bold y_i,\bold f, \bold k_i \in \mathbb{R}^m</math>, а <math>x, h, n, a, b \in \mathbb{R}^1 </math>.

Исходные данные:
:<math> a, b </math> - интервал интегрирования,
:<math> \bold y_0 </math> - вектор значений при <math> x = a </math>,
:n - количество точек в разбиении
:<math>\bold f </math> - функция вычисления производной

Вычисляемые данные:
:<math> \bold y_i </math> - вектора значений в узлах сетки, т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>

Формулы метода:
:Вначале вычисляется шаг сетки:
::<math> h = \frac{b-a}{n}</math>.
:Приближенное значение в следующих точках вычисляется по итерационной формуле:
::<math>\textbf{y}_{n+1} = \textbf{y}_n + {h \over 6}(\textbf{k}_1 + 2\textbf{k}_2 + 2\textbf{k}_3 + \textbf{k}_4)</math>,
::<math>\textbf{k}_1 = \textbf{f} \left( x_n, \textbf{y}_n \right),</math>
::<math>\textbf{k}_2 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_1 \right),</math>
::<math>\textbf{k}_3 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_2 \right),</math>
::<math>\textbf{k}_4 = \textbf{f} \left( x_n + h, \textbf{y}_n + h\ \textbf{k}_3 \right),</math>
::<math>x_{n+1} = x_n + h.</math>

== Вычислительное ядро алгоритма ==

Вычислительным ядром метода Рунге-Кутты можно считать вычисление значений функции производной
:<math>\textbf{f}(x, \textbf{y})</math>,
так как при вычислении каждого нового <math>\textbf{y}_n</math> требуется 4 вычисления значения функции производной. Таким образом, сложность работы алгоритма существенно зависит от сложности вычисления функции <math>\textbf{f}</math>.

== Макроструктура алгоритма ==

Макроструктура алгоритма может быть представлена в следующем виде:

1. Вычисление вспомогательных коэффициентов <math>\textbf{k}_j, j \in [1,4]</math>;

2. Вычисление приближенного значения <math> \bold y_i </math> в следующей точке;

3. Переход на следующую итерацию или остановка.

== Схема реализации последовательного алгоритма ==

Пример реализации последовательного алгоритма на языке C++ (указатель на функцию f передаётся через аргументы представленной ниже функции):
<source lang="c++" line="1">
#include <vector>

// other code ...

std::vector<double> rungekutta4(double a, double b, std::vector<double> y0, int n, std::vector<double (*)(double,double)> f)
{
std::vector<double>::size_type sz = y0.size();
std::vector<double> result;
for (unsigned j=0; j<sz; j++)
{
rezult.push_back(core(a,b,y[j],n,f[j]));
}
return result;
}

double core(double a, double b, double y0, int n, double (*f)(double,double))
{
double h, k1, k2, k3, k4, x, y;
h = (b - a)/n;
y = y0;
x = a;
for (unsigned i = 0; i < n; i++)
{
k1 = f(x, y);
k2 = f(x + h/2, y + h*k1/2);
k3 = f(x + h/2, y + h*k2/2);
k4 = f(x + h/2, y + h*k3);
x += h;
y += h*(k1 + 2*k2 + 2*k3 + k4)/6;
}
return y;
}

// other code ...
</source>

== Последовательная сложность алгоритма ==

Рассмотрим сначала одномерный случай. Наравне с обычными операциями, такими как сложение, умножение и тому подобными, в представленном выше алгоритме присутствует вызов функции <math> f </math>. Так как эта функция может содержать в себе любое количество простых математических операций, будем считать, что её сложность <math> f </math> много больше любой из них, и равна константе <math>C</math>. За весь алгоритм, она вызывается <math>4n</math> раза. Таким образом, сложность последовательного алгоритма для одномерного случая равна <math>4nC</math>.

Для случая решения системы ОДУ, когда <math>f</math> и <math>y</math> являются векторами размерности <math>m</math>, функция core будет вызвана <math>m</math>, и итоговая сложность алгоритма составит <math>4nCm</math>.

== Информационный граф ==

Информационная структура параллельного алгоритма Рунге-Кутты 4-го порядка представляет собой матрицу изображённую на рисунке ниже. Вдоль оси <math>j</math> располагаются <math>j</math>-ые параметры вектора <math>y</math>, соответственно, вдоль <math>i</math> изображены этапы вычисления <math>y_i</math> значения j-параметра вектора <math>y</math>. Таким образом, можно сказать, что вдоль оси <math>j</math>, изображены параллельные процессы. А ось <math>i</math> представляет собой шкалу времени. Чтобы соотнести её с реальным временем, надо просто посчитать сумму <math>\sum_{i=1}^{n} t_i</math>, где <math>t_i</math> - время с момента начала вычисления <math>i</math>-го всеми процессами до момента его завершения всеми процессами.

[[Файл:System_graph.png]]

Можно заметить, что на каждом <math>i</math>-ом шаге происходит обмен информацией между процессами. Это выражено в виде линии пересекающей все <math>j</math>-ые процессы на любом <math>i</math>-ом шаге.

== Ресурс параллелизма алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является итерационным алгоритмом. В нём каждый шаг цикла зависит от предыдущего. В самом шаге, каждая последующая операция также зависит от результата предыдущей. Таким образом, упразднить цикл до независимых и соответственно параллельных операций не является возможным. Однако, так как на результат функции <math> f </math> влияет только <math>i</math>-ый параметр вектора <math> y </math>, то для каждого <math> i </math> можно производить независимое вычисление. В итоге, если вычислять результаты выполнения функции <math> f </math> одновременно для вля всех <math> i</math>-ых параметров вектора <math> y </math>, получим ту же алгоритмическую сложность <math>4nC</math>, что и в [[#Последовательная сложность алгоритма|разделе 1.6]] для одномерного случая.

== Входные и выходные данные алгоритма ==

'''Входные данные''':
:<math> a, b </math> - интервал интегрирования,
:n - количество точек в разбиении,
:<math> \bold y_0 </math> - вектор значений размерности m при <math> x = a </math>,
:функцию вычисления производной <math>\bold f </math> будем считать встроенной в алгоритм.

'''Объём входных данных''':
:m + 3

'''Выходные данные:'''
:<math> \bold y_i </math> - вектора размера m значений в n узлах сетки (т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>).

'''Объем выходных данных'''
:n * m

== Свойства алгоритма ==

Алгоритм обладает следующими свойствами:

* Точность. Как написано в [[#Общее описание алгоритма| разделе 1.1]], алгоритм имеет порядок точности <math>O(h^4)</math>.
* Устойчивость. Алгоритм устойчив на любом конечном отрезке.
* Гибкость. На любом этапе вычисления можно легко изменить шаг интегрирования.
* Вычислительная мощность алгоритма стремится к константе. Сумма входных и выходных данных равна mn+m+3, а общее количество операций - 4nCm. Таким образом, при возрастании значений входных параметров, их отношение стремится к 4C.

= Программная реализация алгоритма =

== [[Особенности реализации последовательного алгоритма]] ==

== [[Локальность данных и вычислений]] ==

== [[Возможные способы и особенности параллельной реализации алгоритма]] ==

== Масштабируемость алгоритма и его реализации ==

Для исследования масштабируемости алгоритма Рунге-Кутты 4-го порядка была написана своя [https://github.com/D86/superpc/blob/master/rk4.c|параллельная реализация]. этого алгоритма на языке C.

Свойства реализации:

* Реализация написана под компилятор mpicxx.
* Тестирование проводилось на [http://hpc.cmc.msu.ru/bgp|IBM Blue Gene/P], расположенном на территории ВМК МГУ.

Исследование проводилось по [https://algowiki-project.org/ru/Scalability_methodology|рекомендованной методологии].

Тестирование

* На вход реализации подавалась система из суперпозиций элементарных функций.
* Начальные значения выбирались случайным образом.

Список изменяющихся параметров:

В качестве изменяемых параметров выбраны количество максимальное количество процессоров, выделяемое при запуске исследуемой реализации, и параметр m, так как из [[#Входные и выходные данные алгоритма| раздела 1.9]] следует, что объём входных данных зависит от него.

Границы изменяющихся параметров:

* Число процессоров выделяется с 256 до 2048 с шагом 128;
* Значение m находится в границах от 1000 до 10000 с шагом 1000.

График производительности:

[[Файл:System_graph.png]]

График эффективности:

[[Файл:System_graph.png]]

Оценки:

На основании полученных результатов были составлены графики [https://algowiki-project.org/ru/Глоссарий#.D0.9F.D1.80.D0.BE.D0.B8.D0.B7.D0.B2.D0.BE.D0.B4.D0.B8.D1.82.D0.B5.D0.BB.D1.8C.D0.BD.D0.BE.D1.81.D1.82.D1.8C| производительности] и [https://algowiki-project.org/ru/Глоссарий#.D0.AD.D1.84.D1.84.D0.B5.D0.BA.D1.82.D0.B8.D0.B2.D0.BD.D0.BE.D1.81.D1.82.D1.8C_.D1.80.D0.B0.D1.81.D0.BF.D0.B0.D1.80.D0.B0.D0.BB.D0.BB.D0.B5.D0.BB.D0.B8.D0.B2.D0.B0.D0.BD.D0.B8.D1.8F| эффективности] параллельной реализации, вычислены максимальная и минимальная [https://algowiki-project.org/ru/Глоссарий#.D0.AD.D1.84.D1.84.D0.B5.D0.BA.D1.82.D0.B8.D0.B2.D0.BD.D0.BE.D1.81.D1.82.D1.8C_.D1.80.D0.B5.D0.B0.D0.BB.D0.B8.D0.B7.D0.B0.D1.86.D0.B8.D0.B8|эффективность реализации], 0.000256661928486 и 1.30949963513e-05 соответственно.

Результаты исследования:

== [[Динамические характеристики и эффективность реализации алгоритма]] ==

== [[Выводы для классов архитектур]] ==

== Существующие реализации алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является одним из наиболее используемых для решения ОДУ и их систем, поэтому существует большое число его реализаций для разных языков программирования. Наиболее популярными являются следующие из них:
* библиотека RK4, которая существует в вариантах для C++, FORTRAN90, FORTRAN77, python и MATLAB;
* библиотека ode45 для MATLAB;
* модуль scipy для PYTHON.

= Литература =

Обсуждение участника:Jest

2016-10-31T17:11:55Z

Борис: /* Статья Нахождение собственных чисел квадратной матрицы методом QR разложения */

== Статья [https://algowiki-project.org/ru/%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA:%D0%91%D0%BE%D1%80%D0%B8%D1%81/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%A0%D1%83%D0%BD%D0%B3%D0%B5-%D0%9A%D1%83%D1%82%D1%82%D1%8B Алгоритм Рунге-Кутты] ==

=== Замечания ===
* нужно убрать слово «Часть» из названий пунктов.
* П. 1.4 - макроструктуру лучше оформить списком.
* П. 1.8 - «туже» заменить на «ту же».
* П. 1.2, 1.9 - формулы не нужно оформлять в отдельных блоках.
* П. 1.10 - не указана вычислительная мощность алгоритма.
* При указании вклада авторов не нужно каждый раз писать слово «раздел», стоит писать «разделы XXX,YYY».

Участник:Борис/Алгоритм Рунге-Кутты

2016-10-31T16:52:12Z

Борис:

{{Assignment}}

{{algorithm
| name = Метод Рунге-Кутты 4 порядка
| serial_complexity = <math>4nCm</math>
| pf_height = <math>O(n)</math>
| pf_width = <math>O(m)</math>
| input_data = <math>m + 3</math>
| output_data = <math>m * n</math>
}}

Основные авторы описания: [[Участник:Jest|Е.П.Степанов]](разделы [[#Общее описание алгоритма|1.1]], [[#Математическое описание алгоритма|1.2]], [[#Вычислительное ядро алгоритма|1.3]], [[#Макроструктура алгоритма|1.4]], [[#Входные и выходные данные алгоритма|1.9]]), [[Участник:Борис|Б.Савков]] (разделы [[#Схема реализации последовательного алгоритма|1.5]], [[#Последовательная сложность алгоритма|1.6]], [[#Информационный граф|1.7]], [[#Ресурс параллелизма алгоритма|1.8]], [[#Свойства алгоритма|1.10]], [[#Существующие реализации алгоритма|2.7]])

= Свойства и структура алгоритмов =

== Общее описание алгоритма ==

Ме́тоды Ру́нге — Ку́тты (распространено неправильное название Ме́тоды Ру́нге — Ку́тта или же Ме́тоды Ру́нге — Кутта́) — важное семейство численных алгоритмов решения обыкновенных дифференциальных уравнений и их систем. Данные итеративные методы явного и неявного приближённого вычисления были разработаны около 1900 года немецкими математиками К. Рунге и М. В. Куттой.

Метод Рунге - Кутты применяется при решения задачи Коши для системы обыкновенных дифференциальных уравнений первого порядка:

:<math>
\begin{cases}
\textbf{y}' = \textbf{f}(x, \textbf{y}),\\
\textbf{y}(x_0) = \textbf{y}_0.
\end{cases}
</math>

При этом <math>\textbf{y}, \textbf{f}, x</math> отвечают следующим свойствам: <math> \textbf{y}, \textbf{f} \in \mathbb{R}^m, x \in \mathbb{R}^1 </math>.

Пусть известно значение y(x) и требуется вычислить значение y(x+h). Это можно сделать при помощи формулы:

:<math> y(x + h) = y(x) + \int_0^hy'(x + t)dt</math>

Аппроксимируя интеграл в правой части, можно получить методы Рунге-Кутты разного порядка точности <ref>Бахвалов Н. С., Жидков Н. П., Кобельков. Г. М. — 6-е изд. — М. : БИНОМ. Лаборатория знаний, 2008. — 636 с.</ref>. В общем виде формулы методов Рунге-Кутты можно записать следующим образом:

:<math>\textbf{y}_{n+1} = \textbf{y}_n + h\sum_{i=1}^s b_i \textbf{k}_i</math>

:<math>
\begin{array}{ll}
\textbf{k}_1 =& \textbf{f}(x_n, \textbf{y}_n),\\
\textbf{k}_2 =& \textbf{f}(x_n+c_2h, \textbf{y}_n+a_{21}h\textbf{k}_1),\\
\cdots&\\
\textbf{k}_s =& \textbf{f}(x_n+c_sh, \textbf{y}_n+a_{s1}h\textbf{k}_1+a_{s2}h\textbf{k}_2+\cdots+a_{s,s-1}h\textbf{k}_{s-1})
\end{array}
</math>

Увеличивая число s вспомогательных точек, можно построить методы Рунге-Кутты любого порядка точности p. Однако уже при p > 5 эти методы используются довольно редко. Это объясняется как чрезмерной громоздкостью получающихся вычислительных формул, так и тем, что преимущества методов высокого порядка точности над методами, в которых p = 4 или p = 5, проявляются либо в тех задачах, где нужна очень высокая точность и используются ЭВМ высокой разрядности, либо в тех задачах, где решение очень гладкое. Кроме того, методы Рунге-Кутты высокого порядка точности часто оказываются менее эффективными по сравнению с методами Адамса того же порядка точности <ref>Амосов А.А., Дубинский Ю.А., Копченова Н.В. Вычислительные методы для инженеров: Учеб. пособие. — М.: Высш. шк., 1994. — 544 с. </ref>. На этой странице представлен наиболее распространенный метод Рунге-Кутты 4 порядка с ошибкой на конечном интервале интегрирования <math>O(h^4)</math>.

Существуют как явные, так и неявные методы Рунге-Кутты. Последние имеют ряд преимуществ над явными методами, однако это достигается за счет существенного усложнения вычислительного алгоритма, так как на каждом шаге приходится считать систему нелинейных уравнений. На этой странице представлен явный метод Рунге-Кутты.

Можно отметить, что в современных программах, реализующих метод Рунге-Кутты, обязательно используется некоторый алгоритм автоматического изменения шага интегрирования. Интуитивно ясно, что на участках плавного изменения решения счет можно вести с достаточно крупным шагом. В то же время на тех участках, где происходят резкие изменения поведения решения, необходимо выбирать мелкий шаг интегрирования. Обычно начальное значение шага h1 задает пользователь. Далее шаг интегрирования меняется в соответствии с величиной получаемой в ходе вычислений оценки локальной погрешности. Для упрощения описания на этой странице используется постоянный шаг интегрирования h, зависящий от размера сетки разбиения n.

== Математическое описание алгоритма ==

Далее подразумевается, что <math> \bold y, \bold y_i,\bold f, \bold k_i \in \mathbb{R}^m</math>, а <math>x, h, n, a, b \in \mathbb{R}^1 </math>.

Исходные данные:
:<math> a, b </math> - интервал интегрирования,
:<math> \bold y_0 </math> - вектор значений при <math> x = a </math>,
:n - количество точек в разбиении
:<math>\bold f </math> - функция вычисления производной

Вычисляемые данные:
:<math> \bold y_i </math> - вектора значений в узлах сетки, т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>

Формулы метода:
:Вначале вычисляется шаг сетки:
::<math> h = \frac{b-a}{n}</math>.
:Приближенное значение в следующих точках вычисляется по итерационной формуле:
::<math>\textbf{y}_{n+1} = \textbf{y}_n + {h \over 6}(\textbf{k}_1 + 2\textbf{k}_2 + 2\textbf{k}_3 + \textbf{k}_4)</math>,
::<math>\textbf{k}_1 = \textbf{f} \left( x_n, \textbf{y}_n \right),</math>
::<math>\textbf{k}_2 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_1 \right),</math>
::<math>\textbf{k}_3 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_2 \right),</math>
::<math>\textbf{k}_4 = \textbf{f} \left( x_n + h, \textbf{y}_n + h\ \textbf{k}_3 \right),</math>
::<math>x_{n+1} = x_n + h.</math>

== Вычислительное ядро алгоритма ==

Вычислительным ядром метода Рунге-Кутты можно считать вычисление значений функции производной
:<math>\textbf{f}(x, \textbf{y})</math>,
так как при вычислении каждого нового <math>\textbf{y}_n</math> требуется 4 вычисления значения функции производной. Таким образом, сложность работы алгоритма существенно зависит от сложности вычисления функции <math>\textbf{f}</math>.

== Макроструктура алгоритма ==

Макроструктура алгоритма может быть представлена в следующем виде:

1. Вычисление вспомогательных коэффициентов <math>\textbf{k}_j, j \in [1,4]</math>;

2. Вычисление приближенного значения <math> \bold y_i </math> в следующей точке;

3. Переход на следующую итерацию или остановка.

== Схема реализации последовательного алгоритма ==

Пример реализации последовательного алгоритма на языке C++ (указатель на функцию f передаётся через аргументы представленной ниже функции):
<source lang="c++" line="1">
#include <vector>

// other code ...

std::vector<double> rungekutta4(double a, double b, std::vector<double> y0, int n, std::vector<double (*)(double,double)> f)
{
std::vector<double>::size_type sz = y0.size();
std::vector<double> result;
for (unsigned j=0; j<sz; j++)
{
rezult.push_back(core(a,b,y[j],n,f[j]));
}
return result;
}

double core(double a, double b, double y0, int n, double (*f)(double,double))
{
double h, k1, k2, k3, k4, x, y;
h = (b - a)/n;
y = y0;
x = a;
for (unsigned i = 0; i < n; i++)
{
k1 = f(x, y);
k2 = f(x + h/2, y + h*k1/2);
k3 = f(x + h/2, y + h*k2/2);
k4 = f(x + h/2, y + h*k3);
x += h;
y += h*(k1 + 2*k2 + 2*k3 + k4)/6;
}
return y;
}

// other code ...
</source>

== Последовательная сложность алгоритма ==

Рассмотрим сначала одномерный случай. Наравне с обычными операциями, такими как сложение, умножение и тому подобными, в представленном выше алгоритме присутствует вызов функции <math> f </math>. Так как эта функция может содержать в себе любое количество простых математических операций, будем считать, что её сложность <math> f </math> много больше любой из них, и равна константе <math>C</math>. За весь алгоритм, она вызывается <math>4n</math> раза. Таким образом, сложность последовательного алгоритма для одномерного случая равна <math>4nC</math>.

Для случая решения системы ОДУ, когда <math>f</math> и <math>y</math> являются векторами размерности <math>m</math>, функция core будет вызвана <math>m</math>, и итоговая сложность алгоритма составит <math>4nCm</math>.

== Информационный граф ==

Информационная структура параллельного алгоритма Рунге-Кутты 4-го порядка представляет собой матрицу изображённую на рисунке ниже. Вдоль оси <math>j</math> располагаются <math>j</math>-ые параметры вектора <math>y</math>, соответственно, вдоль <math>i</math> изображены этапы вычисления <math>y_i</math> значения j-параметра вектора <math>y</math>. Таким образом, можно сказать, что вдоль оси <math>j</math>, изображены параллельные процессы. А ось <math>i</math> представляет собой шкалу времени. Чтобы соотнести её с реальным временем, надо просто посчитать сумму <math>\sum_{i=1}^{n} t_i</math>, где <math>t_i</math> - время с момента начала вычисления <math>i</math>-го всеми процессами до момента его завершения всеми процессами.

[[Файл:System_graph.png]]

Можно заметить, что на каждом <math>i</math>-ом шаге происходит обмен информацией между процессами. Это выражено в виде линии пересекающей все <math>j</math>-ые процессы на любом <math>i</math>-ом шаге.

== Ресурс параллелизма алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является итерационным алгоритмом. В нём каждый шаг цикла зависит от предыдущего. В самом шаге, каждая последующая операция также зависит от результата предыдущей. Таким образом, упразднить цикл до независимых и соответственно параллельных операций не является возможным. Однако, так как на результат функции <math> f </math> влияет только <math>i</math>-ый параметр вектора <math> y </math>, то для каждого <math> i </math> можно производить независимое вычисление. В итоге, если вычислять результаты выполнения функции <math> f </math> одновременно для вля всех <math> i</math>-ых параметров вектора <math> y </math>, получим ту же алгоритмическую сложность <math>4nC</math>, что и в [[#Последовательная сложность алгоритма|разделе 1.6]] для одномерного случая.

== Входные и выходные данные алгоритма ==

'''Входные данные''':
:<math> a, b </math> - интервал интегрирования,
:n - количество точек в разбиении,
:<math> \bold y_0 </math> - вектор значений размерности m при <math> x = a </math>,
:функцию вычисления производной <math>\bold f </math> будем считать встроенной в алгоритм.

'''Объём входных данных''':
:m + 3

'''Выходные данные:'''
:<math> \bold y_i </math> - вектора размера m значений в n узлах сетки (т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>).

'''Объем выходных данных'''
:n * m

== Свойства алгоритма ==

Алгоритм обладает следующими свойствами:

* Точность. Как написано в [[#Общее описание алгоритма| разделе 1.1]], алгоритм имеет порядок точности <math>O(h^4)</math>.
* Устойчивость. Алгоритм устойчив на любом конечном отрезке.
* Гибкость. На любом этапе вычисления можно легко изменить шаг интегрирования.
* Мощность алгоритма стремится к константе. Сумма входных и выходных данных равна mn+m+3, а общее количество операций - 4nCm. Таким образом, при возрастании значений входных параметров, их отношение стремится к 4C.

= Программная реализация алгоритма =

== [[Особенности реализации последовательного алгоритма]] ==

== [[Локальность данных и вычислений]] ==

== [[Возможные способы и особенности параллельной реализации алгоритма]] ==

== Масштабируемость алгоритма и его реализации ==

== [[Динамические характеристики и эффективность реализации алгоритма]] ==

== [[Выводы для классов архитектур]] ==

== Существующие реализации алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является одним из наиболее используемых для решения ОДУ и их систем, поэтому существует большое число его реализаций для разных языков программирования. Наиболее популярными являются следующие из них:
* библиотека RK4, которая существует в вариантах для C++, FORTRAN90, FORTRAN77, python и MATLAB;
* библиотека ode45 для MATLAB;
* модуль scipy для PYTHON.

= Литература =

Участник:Борис/Алгоритм Рунге-Кутты

2016-10-31T16:51:27Z

Борис: /* Свойства алгоритма */

{{algorithm
| name = Метод Рунге-Кутты 4 порядка
| serial_complexity = <math>4nCm</math>
| pf_height = <math>O(n)</math>
| pf_width = <math>O(m)</math>
| input_data = <math>m + 3</math>
| output_data = <math>m * n</math>
}}

Основные авторы описания: [[Участник:Jest|Е.П.Степанов]](разделы [[#Общее описание алгоритма|1.1]], [[#Математическое описание алгоритма|1.2]], [[#Вычислительное ядро алгоритма|1.3]], [[#Макроструктура алгоритма|1.4]], [[#Входные и выходные данные алгоритма|1.9]]), [[Участник:Борис|Б.Савков]] (разделы [[#Схема реализации последовательного алгоритма|1.5]], [[#Последовательная сложность алгоритма|1.6]], [[#Информационный граф|1.7]], [[#Ресурс параллелизма алгоритма|1.8]], [[#Свойства алгоритма|1.10]], [[#Существующие реализации алгоритма|2.7]])

= Свойства и структура алгоритмов =

== Общее описание алгоритма ==

Ме́тоды Ру́нге — Ку́тты (распространено неправильное название Ме́тоды Ру́нге — Ку́тта или же Ме́тоды Ру́нге — Кутта́) — важное семейство численных алгоритмов решения обыкновенных дифференциальных уравнений и их систем. Данные итеративные методы явного и неявного приближённого вычисления были разработаны около 1900 года немецкими математиками К. Рунге и М. В. Куттой.

Метод Рунге - Кутты применяется при решения задачи Коши для системы обыкновенных дифференциальных уравнений первого порядка:

:<math>
\begin{cases}
\textbf{y}' = \textbf{f}(x, \textbf{y}),\\
\textbf{y}(x_0) = \textbf{y}_0.
\end{cases}
</math>

При этом <math>\textbf{y}, \textbf{f}, x</math> отвечают следующим свойствам: <math> \textbf{y}, \textbf{f} \in \mathbb{R}^m, x \in \mathbb{R}^1 </math>.

Пусть известно значение y(x) и требуется вычислить значение y(x+h). Это можно сделать при помощи формулы:

:<math> y(x + h) = y(x) + \int_0^hy'(x + t)dt</math>

Аппроксимируя интеграл в правой части, можно получить методы Рунге-Кутты разного порядка точности <ref>Бахвалов Н. С., Жидков Н. П., Кобельков. Г. М. — 6-е изд. — М. : БИНОМ. Лаборатория знаний, 2008. — 636 с.</ref>. В общем виде формулы методов Рунге-Кутты можно записать следующим образом:

:<math>\textbf{y}_{n+1} = \textbf{y}_n + h\sum_{i=1}^s b_i \textbf{k}_i</math>

:<math>
\begin{array}{ll}
\textbf{k}_1 =& \textbf{f}(x_n, \textbf{y}_n),\\
\textbf{k}_2 =& \textbf{f}(x_n+c_2h, \textbf{y}_n+a_{21}h\textbf{k}_1),\\
\cdots&\\
\textbf{k}_s =& \textbf{f}(x_n+c_sh, \textbf{y}_n+a_{s1}h\textbf{k}_1+a_{s2}h\textbf{k}_2+\cdots+a_{s,s-1}h\textbf{k}_{s-1})
\end{array}
</math>

Увеличивая число s вспомогательных точек, можно построить методы Рунге-Кутты любого порядка точности p. Однако уже при p > 5 эти методы используются довольно редко. Это объясняется как чрезмерной громоздкостью получающихся вычислительных формул, так и тем, что преимущества методов высокого порядка точности над методами, в которых p = 4 или p = 5, проявляются либо в тех задачах, где нужна очень высокая точность и используются ЭВМ высокой разрядности, либо в тех задачах, где решение очень гладкое. Кроме того, методы Рунге-Кутты высокого порядка точности часто оказываются менее эффективными по сравнению с методами Адамса того же порядка точности <ref>Амосов А.А., Дубинский Ю.А., Копченова Н.В. Вычислительные методы для инженеров: Учеб. пособие. — М.: Высш. шк., 1994. — 544 с. </ref>. На этой странице представлен наиболее распространенный метод Рунге-Кутты 4 порядка с ошибкой на конечном интервале интегрирования <math>O(h^4)</math>.

Существуют как явные, так и неявные методы Рунге-Кутты. Последние имеют ряд преимуществ над явными методами, однако это достигается за счет существенного усложнения вычислительного алгоритма, так как на каждом шаге приходится считать систему нелинейных уравнений. На этой странице представлен явный метод Рунге-Кутты.

Можно отметить, что в современных программах, реализующих метод Рунге-Кутты, обязательно используется некоторый алгоритм автоматического изменения шага интегрирования. Интуитивно ясно, что на участках плавного изменения решения счет можно вести с достаточно крупным шагом. В то же время на тех участках, где происходят резкие изменения поведения решения, необходимо выбирать мелкий шаг интегрирования. Обычно начальное значение шага h1 задает пользователь. Далее шаг интегрирования меняется в соответствии с величиной получаемой в ходе вычислений оценки локальной погрешности. Для упрощения описания на этой странице используется постоянный шаг интегрирования h, зависящий от размера сетки разбиения n.

== Математическое описание алгоритма ==

Далее подразумевается, что <math> \bold y, \bold y_i,\bold f, \bold k_i \in \mathbb{R}^m</math>, а <math>x, h, n, a, b \in \mathbb{R}^1 </math>.

Исходные данные:
:<math> a, b </math> - интервал интегрирования,
:<math> \bold y_0 </math> - вектор значений при <math> x = a </math>,
:n - количество точек в разбиении
:<math>\bold f </math> - функция вычисления производной

Вычисляемые данные:
:<math> \bold y_i </math> - вектора значений в узлах сетки, т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>

Формулы метода:
:Вначале вычисляется шаг сетки:
::<math> h = \frac{b-a}{n}</math>.
:Приближенное значение в следующих точках вычисляется по итерационной формуле:
::<math>\textbf{y}_{n+1} = \textbf{y}_n + {h \over 6}(\textbf{k}_1 + 2\textbf{k}_2 + 2\textbf{k}_3 + \textbf{k}_4)</math>,
::<math>\textbf{k}_1 = \textbf{f} \left( x_n, \textbf{y}_n \right),</math>
::<math>\textbf{k}_2 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_1 \right),</math>
::<math>\textbf{k}_3 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_2 \right),</math>
::<math>\textbf{k}_4 = \textbf{f} \left( x_n + h, \textbf{y}_n + h\ \textbf{k}_3 \right),</math>
::<math>x_{n+1} = x_n + h.</math>

== Вычислительное ядро алгоритма ==

Вычислительным ядром метода Рунге-Кутты можно считать вычисление значений функции производной
:<math>\textbf{f}(x, \textbf{y})</math>,
так как при вычислении каждого нового <math>\textbf{y}_n</math> требуется 4 вычисления значения функции производной. Таким образом, сложность работы алгоритма существенно зависит от сложности вычисления функции <math>\textbf{f}</math>.

== Макроструктура алгоритма ==

Макроструктура алгоритма может быть представлена в следующем виде:

1. Вычисление вспомогательных коэффициентов <math>\textbf{k}_j, j \in [1,4]</math>;

2. Вычисление приближенного значения <math> \bold y_i </math> в следующей точке;

3. Переход на следующую итерацию или остановка.

== Схема реализации последовательного алгоритма ==

Пример реализации последовательного алгоритма на языке C++ (указатель на функцию f передаётся через аргументы представленной ниже функции):
<source lang="c++" line="1">
#include <vector>

// other code ...

std::vector<double> rungekutta4(double a, double b, std::vector<double> y0, int n, std::vector<double (*)(double,double)> f)
{
std::vector<double>::size_type sz = y0.size();
std::vector<double> result;
for (unsigned j=0; j<sz; j++)
{
rezult.push_back(core(a,b,y[j],n,f[j]));
}
return result;
}

double core(double a, double b, double y0, int n, double (*f)(double,double))
{
double h, k1, k2, k3, k4, x, y;
h = (b - a)/n;
y = y0;
x = a;
for (unsigned i = 0; i < n; i++)
{
k1 = f(x, y);
k2 = f(x + h/2, y + h*k1/2);
k3 = f(x + h/2, y + h*k2/2);
k4 = f(x + h/2, y + h*k3);
x += h;
y += h*(k1 + 2*k2 + 2*k3 + k4)/6;
}
return y;
}

// other code ...
</source>

== Последовательная сложность алгоритма ==

Рассмотрим сначала одномерный случай. Наравне с обычными операциями, такими как сложение, умножение и тому подобными, в представленном выше алгоритме присутствует вызов функции <math> f </math>. Так как эта функция может содержать в себе любое количество простых математических операций, будем считать, что её сложность <math> f </math> много больше любой из них, и равна константе <math>C</math>. За весь алгоритм, она вызывается <math>4n</math> раза. Таким образом, сложность последовательного алгоритма для одномерного случая равна <math>4nC</math>.

Для случая решения системы ОДУ, когда <math>f</math> и <math>y</math> являются векторами размерности <math>m</math>, функция core будет вызвана <math>m</math>, и итоговая сложность алгоритма составит <math>4nCm</math>.

== Информационный граф ==

Информационная структура параллельного алгоритма Рунге-Кутты 4-го порядка представляет собой матрицу изображённую на рисунке ниже. Вдоль оси <math>j</math> располагаются <math>j</math>-ые параметры вектора <math>y</math>, соответственно, вдоль <math>i</math> изображены этапы вычисления <math>y_i</math> значения j-параметра вектора <math>y</math>. Таким образом, можно сказать, что вдоль оси <math>j</math>, изображены параллельные процессы. А ось <math>i</math> представляет собой шкалу времени. Чтобы соотнести её с реальным временем, надо просто посчитать сумму <math>\sum_{i=1}^{n} t_i</math>, где <math>t_i</math> - время с момента начала вычисления <math>i</math>-го всеми процессами до момента его завершения всеми процессами.

[[Файл:System_graph.png]]

Можно заметить, что на каждом <math>i</math>-ом шаге происходит обмен информацией между процессами. Это выражено в виде линии пересекающей все <math>j</math>-ые процессы на любом <math>i</math>-ом шаге.

== Ресурс параллелизма алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является итерационным алгоритмом. В нём каждый шаг цикла зависит от предыдущего. В самом шаге, каждая последующая операция также зависит от результата предыдущей. Таким образом, упразднить цикл до независимых и соответственно параллельных операций не является возможным. Однако, так как на результат функции <math> f </math> влияет только <math>i</math>-ый параметр вектора <math> y </math>, то для каждого <math> i </math> можно производить независимое вычисление. В итоге, если вычислять результаты выполнения функции <math> f </math> одновременно для вля всех <math> i</math>-ых параметров вектора <math> y </math>, получим ту же алгоритмическую сложность <math>4nC</math>, что и в [[#Последовательная сложность алгоритма|разделе 1.6]] для одномерного случая.

== Входные и выходные данные алгоритма ==

'''Входные данные''':
:<math> a, b </math> - интервал интегрирования,
:n - количество точек в разбиении,
:<math> \bold y_0 </math> - вектор значений размерности m при <math> x = a </math>,
:функцию вычисления производной <math>\bold f </math> будем считать встроенной в алгоритм.

'''Объём входных данных''':
:m + 3

'''Выходные данные:'''
:<math> \bold y_i </math> - вектора размера m значений в n узлах сетки (т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>).

'''Объем выходных данных'''
:n * m

== Свойства алгоритма ==

Алгоритм обладает следующими свойствами:

* Точность. Как написано в [[#Общее описание алгоритма| разделе 1.1]], алгоритм имеет порядок точности <math>O(h^4)</math>.
* Устойчивость. Алгоритм устойчив на любом конечном отрезке.
* Гибкость. На любом этапе вычисления можно легко изменить шаг интегрирования.
* Мощность алгоритма стремится к константе. Сумма входных и выходных данных равна mn+m+3, а общее количество операций - 4nCm. Таким образом, при возрастании значений входных параметров, их отношение стремится к 4C.

= Программная реализация алгоритма =

== [[Особенности реализации последовательного алгоритма]] ==

== [[Локальность данных и вычислений]] ==

== [[Возможные способы и особенности параллельной реализации алгоритма]] ==

== Масштабируемость алгоритма и его реализации ==

== [[Динамические характеристики и эффективность реализации алгоритма]] ==

== [[Выводы для классов архитектур]] ==

== Существующие реализации алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является одним из наиболее используемых для решения ОДУ и их систем, поэтому существует большое число его реализаций для разных языков программирования. Наиболее популярными являются следующие из них:
* библиотека RK4, которая существует в вариантах для C++, FORTRAN90, FORTRAN77, python и MATLAB;
* библиотека ode45 для MATLAB;
* модуль scipy для PYTHON.

= Литература =

Участник:Борис/Алгоритм Рунге-Кутты

2016-10-26T17:19:17Z

Борис: /* Ресурс параллелизма алгоритма */

{{algorithm
| name = Метод Рунге-Кутты 4 порядка
| serial_complexity = <math>4nCm</math>
| pf_height = <math>O(n)</math>
| pf_width = <math>O(m)</math>
| input_data = <math>m + 3</math>
| output_data = <math>m * n</math>
}}

Основные авторы описания: [[Участник:Jest|Е.П.Степанов]]([[#Общее описание алгоритма|раздел 1.1]], [[#Математическое описание алгоритма|раздел 1.2]], [[#Вычислительное ядро алгоритма|раздел 1.3]], [[#Макроструктура алгоритма|раздел 1.4]], [[#Входные и выходные данные алгоритма|раздел 1.9]]), [[Участник:Борис|Б.Савков]] ( [[#Схема реализации последовательного алгоритма|раздел 1.5]], [[#Последовательная сложность алгоритма|раздел 1.6]], [[#Информационный граф|раздел 1.7]], [[#Ресурс параллелизма алгоритма|раздел 1.8]], [[#Свойства алгоритма|раздел 1.10]], [[#Существующие реализации алгоритма|раздел 2.7]])

= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==

Ме́тоды Ру́нге — Ку́тты (распространено неправильное название Ме́тоды Ру́нге — Ку́тта или же Ме́тоды Ру́нге — Кутта́) — важное семейство численных алгоритмов решения обыкновенных дифференциальных уравнений и их систем. Данные итеративные методы явного и неявного приближённого вычисления были разработаны около 1900 года немецкими математиками К. Рунге и М. В. Куттой.

Метод Рунге - Кутты применяется при решения задачи Коши для системы обыкновенных дифференциальных уравнений первого порядка:

:<math>
\begin{cases}
\textbf{y}' = \textbf{f}(x, \textbf{y}),\\
\textbf{y}(x_0) = \textbf{y}_0.
\end{cases}
</math>

При этом <math>\textbf{y}, \textbf{f}, x</math> отвечают следующим свойствам: <math> \textbf{y}, \textbf{f} \in \mathbb{R}^m, x \in \mathbb{R}^1 </math>.

Пусть известно значение y(x) и требуется вычислить значение y(x+h). Это можно сделать при помощи формулы:

:<math> y(x + h) = y(x) + \int_0^hy'(x + t)dt</math>

Аппроксимируя интеграл в правой части, можно получить методы Рунге-Кутты разного порядка точности <ref>Бахвалов Н. С., Жидков Н. П., Кобельков. Г. М. — 6-е изд. — М. : БИНОМ. Лаборатория знаний, 2008. — 636 с.</ref>. В общем виде формулы методов Рунге-Кутты можно записать следующим образом:

:<math>\textbf{y}_{n+1} = \textbf{y}_n + h\sum_{i=1}^s b_i \textbf{k}_i</math>

:<math>
\begin{array}{ll}
\textbf{k}_1 =& \textbf{f}(x_n, \textbf{y}_n),\\
\textbf{k}_2 =& \textbf{f}(x_n+c_2h, \textbf{y}_n+a_{21}h\textbf{k}_1),\\
\cdots&\\
\textbf{k}_s =& \textbf{f}(x_n+c_sh, \textbf{y}_n+a_{s1}h\textbf{k}_1+a_{s2}h\textbf{k}_2+\cdots+a_{s,s-1}h\textbf{k}_{s-1})
\end{array}
</math>

Увеличивая число s вспомогательных точек, можно построить методы Рунге-Кутты любого порядка точности p. Однако уже при p > 5 эти методы используются довольно редко. Это объясняется как чрезмерной громоздкостью получающихся вычислительных формул, так и тем, что преимущества методов высокого порядка точности над методами, в которых p = 4 или p = 5, проявляются либо в тех задачах, где нужна очень высокая точность и используются ЭВМ высокой разрядности, либо в тех задачах, где решение очень гладкое. Кроме того, методы Рунге-Кутты высокого порядка точности часто оказываются менее эффективными по сравнению с методами Адамса того же порядка точности <ref>Амосов А.А., Дубинский Ю.А., Копченова Н.В. Вычислительные методы для инженеров: Учеб. пособие. — М.: Высш. шк., 1994. — 544 с. </ref>. На этой странице представлен наиболее распространенный метод Рунге-Кутты 4 порядка с ошибкой на конечном интервале интегрирования <math>O(h^4)</math>.

Существуют как явные, так и неявные методы Рунге-Кутты. Последние имеют ряд преимуществ над явными методами, однако это достигается за счет существенного усложнения вычислительного алгоритма, так как на каждом шаге приходится считать систему нелинейных уравнений. На этой странице представлен явный метод Рунге-Кутты.

Можно отметить, что в современных программах, реализующих метод Рунге-Кутты, обязательно используется некоторый алгоритм автоматического изменения шага интегрирования. Интуитивно ясно, что на участках плавного изменения решения счет можно вести с достаточно крупным шагом. В то же время на тех участках, где происходят резкие изменения поведения решения, необходимо выбирать мелкий шаг интегрирования. Обычно начальное значение шага h1 задает пользователь. Далее шаг интегрирования меняется в соответствии с величиной получаемой в ходе вычислений оценки локальной погрешности. Для упрощения описания на этой странице используется постоянный шаг интегрирования h, зависящий от размера сетки разбиения n.

== Математическое описание алгоритма ==

Далее подразумевается, что <math> \bold y, \bold y_i,\bold f, \bold k_i \in \mathbb{R}^m</math>, а <math>x, h, n, a, b \in \mathbb{R}^1 </math>.

Исходные данные:
<math> a, b </math> - интервал интегрирования,
<math> \bold y_0 </math> - вектор значений при <math> x = a </math>,
n - количество точек в разбиении
<math>\bold f </math> - функция вычисления производной

Вычисляемые данные:
<math> \bold y_i </math> - вектора значений в узлах сетки, т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>

Формулы метода:
:Вначале вычисляется шаг сетки:
::<math> h = \frac{b-a}{n}</math>.
:Приближенное значение в следующих точках вычисляется по итерационной формуле:
::<math>\textbf{y}_{n+1} = \textbf{y}_n + {h \over 6}(\textbf{k}_1 + 2\textbf{k}_2 + 2\textbf{k}_3 + \textbf{k}_4)</math>,
::<math>\textbf{k}_1 = \textbf{f} \left( x_n, \textbf{y}_n \right),</math>
::<math>\textbf{k}_2 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_1 \right),</math>
::<math>\textbf{k}_3 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_2 \right),</math>
::<math>\textbf{k}_4 = \textbf{f} \left( x_n + h, \textbf{y}_n + h\ \textbf{k}_3 \right),</math>
::<math>x_{n+1} = x_n + h.</math>

== Вычислительное ядро алгоритма ==

Вычислительным ядром метода Рунге-Кутты можно считать вычисление значений функции производной
:<math>\textbf{f}(x, \textbf{y})</math>,
так как при вычислении каждого нового <math>\textbf{y}_n</math> требуется 4 вычисления значения функции производной. Таким образом, сложность работы алгоритма существенно зависит от сложности вычисления функции <math>\textbf{f}</math>.

== Макроструктура алгоритма ==

Макроструктура алгоритма может быть представлена в следующем виде:
:Вычисление вспомогательных коэффициентов <math>\textbf{k}_j, j \in [1,4]</math>;
:Вычисление приближенного значения <math> \bold y_i </math> в следующей точке;
:Переход на следующую итерацию или остановка.

== Схема реализации последовательного алгоритма ==

Пример реализации последовательного алгоритма на языке C++ (указатель на функцию f передаётся через аргументы представленной ниже функции):
<source lang="c++" line="1">
#include <vector>

// other code ...

std::vector<double> rungekutta4(double a, double b, std::vector<double> y0, int n, std::vector<double (*)(double,double)> f)
{
std::vector<double>::size_type sz = y0.size();
std::vector<double> result;
for (unsigned j=0; j<sz; j++)
{
rezult.push_back(core(a,b,y[j],n,f[j]));
}
return result;
}

double core(double a, double b, double y0, int n, double (*f)(double,double))
{
double h, k1, k2, k3, k4, x, y;
h = (b - a)/n;
y = y0;
x = a;
for (unsigned i = 0; i < n; i++)
{
k1 = f(x, y);
k2 = f(x + h/2, y + h*k1/2);
k3 = f(x + h/2, y + h*k2/2);
k4 = f(x + h/2, y + h*k3);
x += h;
y += h*(k1 + 2*k2 + 2*k3 + k4)/6;
}
return y;
}

// other code ...
</source>

== Последовательная сложность алгоритма ==

Рассмотрим сначала одномерный случай. Наравне с обычными операциями, такими как сложение, умножение и тому подобными, в представленном выше алгоритме присутствует вызов функции <math> f </math>. Так как эта функция может содержать в себе любое количество простых математических операций, будем считать, что её сложность <math> f </math> много больше любой из них, и равна константе <math>C</math>. За весь алгоритм, она вызывается <math>4n</math> раза. Таким образом, сложность последовательного алгоритма для одномерного случая равна <math>4nC</math>.

Для случая решения системы ОДУ, когда <math>f</math> и <math>y</math> являются векторами размерности <math>m</math>, функция core будет вызвана <math>m</math>, и итоговая сложность алгоритма составит <math>4nCm</math>.

== Информационный граф ==

Информационная структура параллельного алгоритма Рунге-Кутты 4-го порядка представляет собой матрицу изображённую на рисунке ниже. Вдоль оси <math>j</math> располагаются <math>j</math>-ые параметры вектора <math>y</math>, соответственно, вдоль <math>i</math> изображены этапы вычисления <math>y_i</math> значения j-параметра вектора <math>y</math>. Таким образом, можно сказать, что вдоль оси <math>j</math>, изображены параллельные процессы. А ось <math>i</math> представляет собой шкалу времени. Чтобы соотнести её с реальным временем, надо просто посчитать сумму <math>\sum_{i=1}^{n} t_i</math>, где <math>t_i</math> - время с момента начала вычисления <math>i</math>-го всеми процессами до момента его завершения всеми процессами.

[[Файл:System_graph.png]]

Можно заметить, что на каждом <math>i</math>-ом шаге происходит обмен информацией между процессами. Это выражено в виде линии пересекающей все <math>j</math>-ые процессы на любом <math>i</math>-ом шаге.

== Ресурс параллелизма алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является итерационным алгоритмом. В нём каждый шаг цикла зависит от предыдущего. В самом шаге, каждая последующая операция также зависит от результата предыдущей. Таким образом, упразднить цикл до независимых и соответственно параллельных операций не является возможным. Однако, так как на результат функции <math> f </math> влияет только <math>i</math>-ый параметр вектора <math> y </math>, то для каждого <math> i </math> можно производить независимое вычисление. В итоге, если вычислять результаты выполнения функции <math> f </math> одновременно для вля всех <math> i</math>-ых параметров вектора <math> y </math>, получим ту же алгоритмическую сложность <math>4nC</math>, что и в [[#Последовательная сложность алгоритма|разделе 1.6]] для одномерного случая.

== Входные и выходные данные алгоритма ==

'''Входные данные''':
<math> a, b </math> - интервал интегрирования,
n - количество точек в разбиении,
<math> \bold y_0 </math> - вектор значений размерности m при <math> x = a </math>,
функцию вычисления производной <math>\bold f </math> будем считать встроенной в алгоритм.

'''Объём входных данных''':
m + 3

'''Выходные данные:'''
<math> \bold y_i </math> - вектора размера m значений в n узлах сетки (т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>).

'''Объем выходных данных'''
n * m

== Свойства алгоритма ==

Алгоритм обладает следующими свойствами:

* Точность. Как написано в [[#Общее описание алгоритма| разделе 1.1]], алгоритм имеет порядок точности <math>O(h^4)</math>.
* Устойчивость. Алгоритм устойчив на любом конечном отрезке.
* Гибкость. На любом этапе вычисления можно легко изменить шаг интегрирования.

= ЧАСТЬ. Программная реализация алгоритма =

== [[Особенности реализации последовательного алгоритма]] ==

== [[Локальность данных и вычислений]] ==

== [[Возможные способы и особенности параллельной реализации алгоритма]] ==

== Масштабируемость алгоритма и его реализации ==

== [[Динамические характеристики и эффективность реализации алгоритма]] ==

== [[Выводы для классов архитектур]] ==

== Существующие реализации алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является одним из наиболее используемых для решения ОДУ и их систем, поэтому существует большое число его реализаций для разных языков программирования. Наиболее популярными являются следующие из них:
* библиотека RK4, которая существует в вариантах для C++, FORTRAN90, FORTRAN77, python и MATLAB;
* библиотека ode45 для MATLAB;
* модуль scipy для PYTHON.

= Литература =

Участник:Борис/Алгоритм Рунге-Кутты

2016-10-17T12:13:33Z

Борис:

{{Assignment}}

{{algorithm
| name = Метод Рунге-Кутты 4 порядка
| serial_complexity = <math>4nCm</math>
| pf_height = <math>O(n)</math>
| pf_width = <math>O(m)</math>
| input_data = <math>m + 3</math>
| output_data = <math>m * n</math>
}}

Основные авторы описания: [[Участник:Jest|Е.П.Степанов]]([[#Общее описание алгоритма|раздел 1.1]], [[#Математическое описание алгоритма|раздел 1.2]], [[#Вычислительное ядро алгоритма|раздел 1.3]], [[#Макроструктура алгоритма|раздел 1.4]], [[#Входные и выходные данные алгоритма|раздел 1.9]]), [[Участник:Борис|Б.Савков]] ( [[#Схема реализации последовательного алгоритма|раздел 1.5]], [[#Последовательная сложность алгоритма|раздел 1.6]], [[#Информационный граф|раздел 1.7]], [[#Ресурс параллелизма алгоритма|раздел 1.8]], [[#Свойства алгоритма|раздел 1.10]], [[#Существующие реализации алгоритма|раздел 2.7]])

= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==

Ме́тоды Ру́нге — Ку́тты (распространено неправильное название Ме́тоды Ру́нге — Ку́тта или же Ме́тоды Ру́нге — Кутта́) — важное семейство численных алгоритмов решения обыкновенных дифференциальных уравнений и их систем. Данные итеративные методы явного и неявного приближённого вычисления были разработаны около 1900 года немецкими математиками К. Рунге и М. В. Куттой.

Метод Рунге - Кутты применяется при решения задачи Коши для системы обыкновенных дифференциальных уравнений первого порядка:

:<math>
\begin{cases}
\textbf{y}' = \textbf{f}(x, \textbf{y}),\\
\textbf{y}(x_0) = \textbf{y}_0.
\end{cases}
</math>

При этом <math>\textbf{y}, \textbf{f}, x</math> отвечают следующим свойствам: <math> \textbf{y}, \textbf{f} \in \mathbb{R}^m, x \in \mathbb{R}^1 </math>.

Пусть известно значение y(x) и требуется вычислить значение y(x+h). Это можно сделать при помощи формулы:

:<math> y(x + h) = y(x) + \int_0^hy'(x + t)dt</math>

Аппроксимируя интеграл в правой части, можно получить методы Рунге-Кутты разного порядка точности. В общем виде формулы методов Рунге-Кутты можно записать следующим образом:

:<math>\textbf{y}_{n+1} = \textbf{y}_n + h\sum_{i=1}^s b_i \textbf{k}_i</math>

:<math>
\begin{array}{ll}
\textbf{k}_1 =& \textbf{f}(x_n, \textbf{y}_n),\\
\textbf{k}_2 =& \textbf{f}(x_n+c_2h, \textbf{y}_n+a_{21}h\textbf{k}_1),\\
\cdots&\\
\textbf{k}_s =& \textbf{f}(x_n+c_sh, \textbf{y}_n+a_{s1}h\textbf{k}_1+a_{s2}h\textbf{k}_2+\cdots+a_{s,s-1}h\textbf{k}_{s-1})
\end{array}
</math>

Увеличивая число s вспомогательных точек, можно построить методы Рунге-Кутты любого порядка точности p. Однако уже при p > 5 эти методы используются довольно редко. Это объясняется как чрезмерной громоздкостью получающихся вычислительных формул, так и тем, что преимущества методов высокого порядка точности над методами, в которых p = 4 или p = 5, проявляются либо в тех задачах, где нужна очень высокая точность и используются ЭВМ высокой разрядности, либо в тех задачах, где решение очень гладкое. Кроме того, методы Рунге-Кутты высокого порядка точности часто оказываются менее эффективными по сравнению с методами Адамса того же порядка точности. На этой странице представлен наиболее распространенный метод Рунге-Кутты 4 порядка с ошибкой на конечном интервале интегрирования <math>O(h^4)</math>.

Существуют как явные, так и неявные методы Рунге-Кутты. Последние имеют ряд преимуществ над явными методами, однако это достигается за счет существенного усложнения вычислительного алгоритма, так как на каждом шаге приходится считать систему нелинейных уравнений. На этой странице представлен явный метод Рунге-Кутты.

Можно отметить, что в современных программах, реализующих метод Рунге-Кутты, обязательно используется некоторый алгоритм автоматического изменения шага интегрирования. Интуитивно ясно, что на участках плавного изменения решения счет можно вести с достаточно крупным шагом. В то же время на тех участках, где происходят резкие изменения поведения решения, необходимо выбирать мелкий шаг интегрирования. Обычно начальное значение шага h1 задает пользователь. Далее шаг интегрирования меняется в соответствии с величиной получаемой в ходе вычислений оценки локальной погрешности. Для упрощения описания на этой странице используется постоянный шаг интегрирования h, зависящий от размера сетки разбиения n.

== Математическое описание алгоритма ==

Далее подразумевается, что <math> \bold y, \bold y_i,\bold f, \bold k_i \in \mathbb{R}^m</math>, а <math>x, h, n, a, b \in \mathbb{R}^1 </math>.

Исходные данные:
<math> a, b </math> - интервал интегрирования,
<math> \bold y_0 </math> - вектор значений при <math> x = a </math>,
n - количество точек в разбиении
<math>\bold f </math> - функция вычисления производной

Вычисляемые данные:
<math> \bold y_i </math> - вектора значений в узлах сетки, т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>

Формулы метода:
:Вначале вычисляется шаг сетки:
::<math> h = \frac{b-a}{n}</math>.
:Приближенное значение в следующих точках вычисляется по итерационной формуле:
::<math>\textbf{y}_{n+1} = \textbf{y}_n + {h \over 6}(\textbf{k}_1 + 2\textbf{k}_2 + 2\textbf{k}_3 + \textbf{k}_4)</math>,
::<math>\textbf{k}_1 = \textbf{f} \left( x_n, \textbf{y}_n \right),</math>
::<math>\textbf{k}_2 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_1 \right),</math>
::<math>\textbf{k}_3 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_2 \right),</math>
::<math>\textbf{k}_4 = \textbf{f} \left( x_n + h, \textbf{y}_n + h\ \textbf{k}_3 \right),</math>
::<math>x_{n+1} = x_n + h.</math>

== Вычислительное ядро алгоритма ==

Вычислительным ядром метода Рунге-Кутты можно считать вычисление значений функции производной
:<math>\textbf{f}(x, \textbf{y})</math>,
так как при вычислении каждого нового <math>\textbf{y}_n</math> требуется 4 вычисления значения функции производной. Таким образом, сложность работы алгоритма существенно зависит от сложности вычисления функции <math>\textbf{f}</math>.

== Макроструктура алгоритма ==

Макроструктура алгоритма может быть представлена в следующем виде:
:Вычисление вспомогательных коэффициентов <math>\textbf{k}_j, j \in [1,4]</math>;
:Вычисление приближенного значения <math> \bold y_i </math> в следующей точке;
:Переход на следующую итерацию или остановка.

== Схема реализации последовательного алгоритма ==

Пример реализации последовательного алгоритма на языке C++ (указатель на функцию f передаётся через аргументы представленной ниже функции):
<source lang="c++" line="1">
#include <vector>

// other code ...

std::vector<double> rungekutta4(double a, double b, std::vector<double> y0, int n, std::vector<double (*)(double,double)> f)
{
std::vector<double>::size_type sz = y0.size();
std::vector<double> result;
for (unsigned j=0; j<sz; j++)
{
rezult.push_back(core(a,b,y[j],n,f[j]));
}
return result;
}

double core(double a, double b, double y0, int n, double (*f)(double,double))
{
double h, k1, k2, k3, k4, x, y;
h = (b - a)/n;
y = y0;
x = a;
for (unsigned i = 0; i < n; i++)
{
k1 = f(x, y);
k2 = f(x + h/2, y + h*k1/2);
k3 = f(x + h/2, y + h*k2/2);
k4 = f(x + h/2, y + h*k3);
x += h;
y += h*(k1 + 2*k2 + 2*k3 + k4)/6;
}
return y;
}

// other code ...
</source>

== Последовательная сложность алгоритма ==

Рассмотрим сначала одномерный случай. Наравне с обычными операциями, такими как сложение, умножение и тому подобными, в представленном выше алгоритме присутствует вызов функции <math> f </math>. Так как эта функция может содержать в себе любое количество простых математических операций, будем считать, что её сложность <math> f </math> много больше любой из них, и равна константе <math>C</math>. За весь алгоритм, она вызывается <math>4n</math> раза. Таким образом, сложность последовательного алгоритма для одномерного случая равна <math>4nC</math>.

Для случая решения системы ОДУ, когда <math>f</math> и <math>y</math> являются векторами размерности <math>m</math>, функция core будет вызвана <math>m</math>, и итоговая сложность алгоритма составит <math>4nCm</math>.

== Информационный граф ==

Информационная структура параллельного алгоритма Рунге-Кутты 4-го порядка представляет собой матрицу изображённую на рисунке ниже. Вдоль оси <math>j</math> располагаются <math>j</math>-ые параметры вектора <math>y</math>, соответственно, вдоль <math>i</math> изображены этапы вычисления <math>y_i</math> значения j-параметра вектора <math>y</math>. Таким образом, можно сказать, что вдоль оси <math>j</math>, изображены параллельные процессы. А ось <math>i</math> представляет собой шкалу времени. Чтобы соотнести её с реальным временем, надо просто посчитать сумму <math>\sum_{i=1}^{n} t_i</math>, где <math>t_i</math> - время с момента начала вычисления <math>i</math>-го всеми процессами до момента его завершения всеми процессами.

[[Файл:System_graph.png]]

Можно заметить, что на каждом <math>i</math>-ом шаге происходит обмен информацией между процессами. Это выражено в виде линии пересекающей все <math>j</math>-ые процессы на любом <math>i</math>-ом шаге.

== Ресурс параллелизма алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является итерационным алгоритмом. В нём каждый шаг цикла зависит от предыдущего. В самом шаге, каждая последующая операция также зависит от результата предыдущей. Таким образом, упразднить цикл до независимых и соответственно параллельных операций не является возможным. Однако, так как на результат функции <math> f </math> влияет только <math>i</math>-ый параметр вектора <math> y </math>, то для каждого <math> i </math> можно производить независимое вычисление. В итоге, если вычислять результаты выполнения функции <math> f </math> одновременно для вля всех <math> i</math>-ых параметров вектора <math> y </math>, получим туже алгоритмическую сложность <math>4nC</math>, что и в [[#Последовательная сложность алгоритма|разделе 1.6]] для одномерного случая.

== Входные и выходные данные алгоритма ==

'''Входные данные''':
<math> a, b </math> - интервал интегрирования,
n - количество точек в разбиении,
<math> \bold y_0 </math> - вектор значений размерности m при <math> x = a </math>,
функцию вычисления производной <math>\bold f </math> будем считать встроенной в алгоритм.

'''Объём входных данных''':
m + 3

'''Выходные данные:'''
<math> \bold y_i </math> - вектора размера m значений в n узлах сетки (т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>).

'''Объем выходных данных'''
n * m

== Свойства алгоритма ==

Алгоритм обладает следующими свойствами:

* Точность. Как написано в [[#Общее описание алгоритма| разделе 1.1]], алгоритм имеет порядок точности <math>O(h^4)</math>.
* Устойчивость. Алгоритм устойчив на любом конечном отрезке.
* Гибкость. На любом этапе вычисления можно легко изменить шаг интегрирования.

= ЧАСТЬ. Программная реализация алгоритма =

== [[Особенности реализации последовательного алгоритма]] ==

== [[Локальность данных и вычислений]] ==

== [[Возможные способы и особенности параллельной реализации алгоритма]] ==

== Масштабируемость алгоритма и его реализации ==

== [[Динамические характеристики и эффективность реализации алгоритма]] ==

== [[Выводы для классов архитектур]] ==

== Существующие реализации алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является одним из наиболее используемых для решения ОДУ и их систем, поэтому существует большое число его реализаций для разных языков программирования. Наиболее популярными являются следующие из них:
* библиотека RK4, которая существует в вариантах для C++, FORTRAN90, FORTRAN77, python и MATLAB;
* библиотека ode45 для MATLAB;
* модуль scipy для PYTHON.

= Литература =

Обсуждение участника:Lineprinter

2016-10-17T12:09:33Z

Борис: /* Перенос */

== Перенос ==
Статья: [[Участник:Бобцов Борис/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки]]
Выполняет: [[Участник:Бобцов Борис| Бобцов Борис]]

Статья: [[Кластеризация сетями Кохонена]]
Выполняют: [[Участник:Kravtsovkirill| Кравцов Кирилл]] и [[Участник:Emaksimov| Максимов Егор]]

Статья: [[Нахождение собственных чисел квадратной матрицы методом QR разложения (2)]]
Выполняют: Баев Олег и Шевелев Александр

Статья: [[Стабилизированный метод биспоряженных градиентов (BiCGSTAB)]]
Выполняют: Гаврилов Алексей и Новиков Александр

Статья: [[Участники: Бобошко А., Юмакаева А./Решение начальной задачи Коши для системы ОДУ методом Рунге-Кутта 4-го порядка]];
Выполняют: Бобошко Алексей и Юмакаева Алина

Статья: [[Алгоритм кластеризации, основанный на сетях Кохоннена]];
Выполняют: Логвиненко Александра и Адиев Тохтар

Статья: [[Ортогонализация Грама-Шмидта]];
Выполняют: [[Участник:KibAndrey| Кибанов Андрей]] и Аджиева Татьяна

Статья: [[Самоорганизующиеся карты Кохонена]];
Выполняет: [[Участник:Anton goy| Гой Антон]]

Статья:[[ЕМ-алгоритм_(Тематическое_моделирование)]];
Выполняют: Мурат Апишев и Андрей Заночкин

Статья:[[Алгоритм_Ланцоша_с_полной_переортогонализацией]];
Выполняет:[[Участник:Sfedotov| Федотов С.А.]]

Статья: [[Алгоритм_k-средних]]
Выполняют: [[Участник:Error2407|Богомазов Евгений]], [[Участник:Илья_Егоров|Егоров Илья]]

Статья: [[Алгоритм k-means]]
Выполняют: [[Участник:Бротиковская Данута|Данута Бротиковская]] и [[Участник:DennZo1993|Денис Зобнин]]

Статья: [[Partitioning Around Medoids (Алгоритм)]]
Выполняют: [[Участник:Denemmy| Галеев Данил]] и [[Участник:Ivan.Z| Запутляев Иван]]

Статья: [[Нечеткий_алгоритм_С_средних]]
Выполняют: [[Участник:Demon smd|Д.А.Гуськов]], [[Участник:marina abramenkova|М.А.Абраменкова]]

Статья: [[Решение_задачи_Коши_для_системы_ОДУ_методом_Рунге-Кутты_4_порядка]];
Выполняют: [[Участник:Алимов_Дамир_Алиевич|Алимов Дамир]] и [[Участник:Anlesnichiy|Антон Лесничий]]

Статья: [[Строгий_алгоритм_С_средних_(Hard_C-Means,_HCM)]];
Выполняют: [[Участник:Светлана_Лукьяненко|Лукьяненко Светлана]] и [[Участник:Юрий_Комаров|Комаров Юрий]]

Статья: [[Алгоритм кластеризации, основанный на минимальном остовном дереве]];
Выполняет: [[Участник:Astandrik | Стандрик Антон Сергеевич]]

Статья: [[Умножение разреженной матрицы на вектор]];
Выполняет: [[Участник:Lexaloris | Новоселов Алексей]], Выполняет: [[Участник:kochet|П.А. Кочетков]]

Статья: [[Нахождение_собственных_чисел_квадратной_матрицы_методом_QR_разложения_(3)|Нахождение собственных чисел квадратной матрицы методом QR разложения (3)]];
Выполняют: [[Участник:Смирнова_Александра|Смирнова А.С.]], [[Участник:Александра_Киямова|Киямова А.]]

Статья: [[Метод_Якоби_вычисления_сингулярных_чисел_и_векторов]];
Выполняют: [[Участница:Почернина_Елена| Почернина Елена]] и [[Участница:Светлана|Костюкова Светлана]]

Статья: [[Метод_Ньютона_для_решения_систем_нелинейных_уравнений(2)]];
Выполняют: [[Участник:Oleggium|Гирняк О.Р.]], [[Участник:Dimx19|Васильков Д.А.]]

Статья: [[Алгоритм_кластеризации_с_использованием_представлений]];
Выполняют: [[Участник:Cookie|Шатков С.А.]], [[Участница:JuliaA|Антохина Ю.А.]]

Статья: [[Быстрое_преобразование_Фурье_(FFT)|Быстрое преобразование Фурье (FFT)]];
Выполняют: [[Участник:Victoria_Stepanischeva|Степанищева Виктория]] и [[Участник:Igor_Munkin|Мунькин Игорь]]

Статья: [[Быстрое_дискретное_преобразование_Фурье|Быстрое_дискретное_преобразование_Фурье]];
Выполняют: [[Участник:ivanov.kir.m | К.М.Иванов]], [[Участник:Pumpkin | А.C.Сапин]]

Статья:[[Алгоритм_k_средних]]
Выполняют: [[Участник:Parkhomenko|Пархоменко Павел]], [[Участник:ivan.mashonskiy|Машонский Иван]]

Статья:[[EM-алгоритм_кластеризации]]
Выполняет: [[Участник:Noite|Зинченко Дмитрий]]

Статья:[[Алгоритм_k_means]]
Выполняют: [[Участник:IanaV| Валуйская Яна]], [[Участник:GlotovES| Глотов Евгений]]

Статья: [[Метод Якоби вычисления собственных значений симметричной матрицы ЗП |Метод Якоби вычисления собственных значений симметричной матрицы ЗП]];
Выполняют: [[Участник:Зиновьев Владимир|Зиновьев В.С.]], [[Участник:Пронин Андрей|Пронин А.М.]]

Статья:[[Алгоритм_кластеризации,_основанный_на_минимальном_покрывающем_дереве]]
Выполняет: [[Участник:Kanast74|Дмитриева Анастасия]]

Статья:[[Нахождение_собственных_чисел_квадратной_матрицы_методом_QR_разложения_(4)]]
Выполняют: [[Участник:F-morozov|Морозов Ф. В.]], [[Участник:Nataliya|Пащенко Н. Ф.]]

Статья:[[Хранение_ненулевых_элементов_разреженных_матриц._Умножение_разреженной_матрицы_на_вектор]];
Выполняют: [[Участник:Trrufina|Третьякова Р.М.]] и [[Участник:Екатерина_Буторина|Буторина Е.В.]]

Статья: [[Алгоритм_кластеризации_с_использованием_представлений2]];
Выполняет: [[Участник:Лукьянова Анна|Лукьянова А.Я.]]

Статья: [[Метод Якоби вычисления собственных значений симметричной матрицы]];
Выполняют: [[Участник: Galkina|Галкина А.С.]], [[Участник: Игорь|Плахов И.А.]]

Статья: [[Метод рекурсивной координатной бисекции]];
Выполняют: [[Участник: Obirvalger|Гордеев Михаил]], [[Участник: KolmakovEA|Колмаков Евгений]]

Статья: [[Итерационный метод решения системы линейных алгебраических уравнений GMRES (обобщенный метод минимальных невязок)]];
Выполняют: [[Участник: Эльвира Ахиярова|Ахиярова Эльвира]]

Статья: [[Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор]];
Выполняют: [[Участник: Janyell|Сычева Евгения]], [[Участник: Ahahalin|Хахалин Анатолий]]

Статья: [[Построение матрицы Адамара произвольного размера]];
Выполняют: [[Участник: Бугаков Юрий|Бугаков Юрий]], Кужамалиев Ернур

Статья: [[Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки (1)]]
Выполняют: [[Участница:Sannikovats| Санникова Татьяна Сергеевна]], [[Участник:Plukshin| Лукшин Петр Андреевич]]

Статья: [[Алгоритм кластеризации, основанный на построении каркаса]];
Выполняют: [[Участник:SenderovichNikita| Сендерович Никита]]

Статья: [[Алгоритм кластеризации, основанный на максимизации ожидания]];
Выполняют: Готман Мария, Лукашкина Юлия

Статья: [[Partitioning_Around_Medoids_(PAM)]]
Выполняют: [[Участник:Avasilenko|А.Э.Василенко]], [[Участник:Anastasia|А.В.Тузикова]]

Статья: [[Нечеткий алгоритм С-средних (Fuzzy C-means)]]
Выполняют: [[Участник:Nikmedoed|Н.А. Муромцев]], [[Участник:illusive_mike|М.С. Дворецкий]]

Статья: [[Нечеткий алгоритм C средних]]
Выполняют: [[Участник:Gkhazeeva|Гелана Хазеева]], [[Участник:Yushin|Павел Юшин]]

Статья: [[Плотностный алгоритм кластеризации DBSCAN]]
Выполняют: [[Участник:Elena777mc|Малахова Е.С.]], [[Участник:Жаннат_Сагиолданова|Сагиолданова Ж.]]

Статья: [[Кластеризация Partitioning Around Medoids (PAM)]]
Выполняют:[[ Участник:Тодуа Антон| Тодуа Антон]], [[Участник:Гусева Юлия| Гусева Юлия]]

Статья: [[Участник:Бугаков Юрий (613 группа), Кужамалиев Ернур (601 группа)/Построение матрицы Адамара произвольной размерности]]
Выполняют:[[ Участник:Бугаков Юрий| Бугаков Юрий]], [[Участник:Кужамалиев Ернур| Кужамалиев Ернур]]

Статья: [[Участник:Nikita/Построение_матрицы_Адамара|Построение матрицы Адамара]]
Выполняют: [[Участник:Nikita|Иванов Никита]], [[Участник:Tsyganov Nikita|Цыганов Никита]]

Статья: [[Метод Ньютона для решения систем нелинейных уравнений]]
Выполняют: [[Участник:Александр Чернышев|Александр Чернышев]], [[Участник:Захаров Никита|Захаров Никита]]

Статья: [[BIRCH|Сбалансированный итеративный алгоритм редукции и кластеризации с использованием иерархий
(BIRCH)]]
Выполняют: [[Участник:Светлана Морозова|Морозова Светлана]], [[Участник:Smirnov.maxim|Смирнов Максим]]

Статья: [[Плотностный_алгоритм_кластеризации|Плотностный_алгоритм_кластеризации]], Выполняют: [[Участник:Ramon93i7|Шемякин Роман]], [[Участник:Dadrik|Вашуров Илья]]

Статья: [[Алгоритм CLOPE кластеризации категориальных данных]].
Выполняют: [[Участник:Артем_Карпухин|Карпухин Артем]], [[Участник:Артем_Желтков|Желтков Артем]].

Статья: [[Участник:Борис/Алгоритм_Рунге-Кутты]]
Выполняет: [[Участник:Борис| Савков Борис]] и Степанов Евгений.

Участник:Борис/Алгоритм Рунге-Кутты

2016-10-15T21:43:15Z

Борис: /* Ресурс параллелизма алгоритма */

{{algorithm
| name = Метод Рунге-Кутты 4 порядка
| serial_complexity = <math>4nCm</math>
| pf_height = <math>O(n)</math>
| pf_width = <math>O(m)</math>
| input_data = <math>m + 3</math>
| output_data = <math>m * n</math>
}}

Основные авторы описания: [[Участник:Jest|Е.П.Степанов]]([[#Общее описание алгоритма|раздел 1.1]], [[#Математическое описание алгоритма|раздел 1.2]], [[#Вычислительное ядро алгоритма|раздел 1.3]], [[#Макроструктура алгоритма|раздел 1.4]], [[#Входные и выходные данные алгоритма|раздел 1.9]]), [[Участник:Борис|Б.Савков]] ( [[#Схема реализации последовательного алгоритма|раздел 1.5]], [[#Последовательная сложность алгоритма|раздел 1.6]], [[#Информационный граф|раздел 1.7]], [[#Ресурс параллелизма алгоритма|раздел 1.8]], [[#Свойства алгоритма|раздел 1.10]], [[#Существующие реализации алгоритма|раздел 2.7]])

= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==

Ме́тоды Ру́нге — Ку́тты (распространено неправильное название Ме́тоды Ру́нге — Ку́тта или же Ме́тоды Ру́нге — Кутта́) — важное семейство численных алгоритмов решения обыкновенных дифференциальных уравнений и их систем. Данные итеративные методы явного и неявного приближённого вычисления были разработаны около 1900 года немецкими математиками К. Рунге и М. В. Куттой.

Метод Рунге - Кутты применяется при решения задачи Коши для системы обыкновенных дифференциальных уравнений первого порядка:

:<math>
\begin{cases}
\textbf{y}' = \textbf{f}(x, \textbf{y}),\\
\textbf{y}(x_0) = \textbf{y}_0.
\end{cases}
</math>

При этом <math>\textbf{y}, \textbf{f}, x</math> отвечают следующим свойствам: <math> \textbf{y}, \textbf{f} \in \mathbb{R}^m, x \in \mathbb{R}^1 </math>.

Пусть известно значение y(x) и требуется вычислить значение y(x+h). Это можно сделать при помощи формулы:

:<math> y(x + h) = y(x) + \int_0^hy'(x + t)dt</math>

Аппроксимируя интеграл в правой части, можно получить методы Рунге-Кутты разного порядка точности. В общем виде формулы методов Рунге-Кутты можно записать следующим образом:

:<math>\textbf{y}_{n+1} = \textbf{y}_n + h\sum_{i=1}^s b_i \textbf{k}_i</math>

:<math>
\begin{array}{ll}
\textbf{k}_1 =& \textbf{f}(x_n, \textbf{y}_n),\\
\textbf{k}_2 =& \textbf{f}(x_n+c_2h, \textbf{y}_n+a_{21}h\textbf{k}_1),\\
\cdots&\\
\textbf{k}_s =& \textbf{f}(x_n+c_sh, \textbf{y}_n+a_{s1}h\textbf{k}_1+a_{s2}h\textbf{k}_2+\cdots+a_{s,s-1}h\textbf{k}_{s-1})
\end{array}
</math>

Увеличивая число s вспомогательных точек, можно построить методы Рунге-Кутты любого порядка точности p. Однако уже при p > 5 эти методы используются довольно редко. Это объясняется как чрезмерной громоздкостью получающихся вычислительных формул, так и тем, что преимущества методов высокого порядка точности над методами, в которых p = 4 или p = 5, проявляются либо в тех задачах, где нужна очень высокая точность и используются ЭВМ высокой разрядности, либо в тех задачах, где решение очень гладкое. Кроме того, методы Рунге-Кутты высокого порядка точности часто оказываются менее эффективными по сравнению с методами Адамса того же порядка точности. На этой странице представлен наиболее распространенный метод Рунге-Кутты 4 порядка с ошибкой на конечном интервале интегрирования <math>O(h^4)</math>.

Существуют как явные, так и неявные методы Рунге-Кутты. Последние имеют ряд преимуществ над явными методами, однако это достигается за счет существенного усложнения вычислительного алгоритма, так как на каждом шаге приходится считать систему нелинейных уравнений. На этой странице представлен явный метод Рунге-Кутты.

Можно отметить, что в современных программах, реализующих метод Рунге-Кутты, обязательно используется некоторый алгоритм автоматического изменения шага интегрирования. Интуитивно ясно, что на участках плавного изменения решения счет можно вести с достаточно крупным шагом. В то же время на тех участках, где происходят резкие изменения поведения решения, необходимо выбирать мелкий шаг интегрирования. Обычно начальное значение шага h1 задает пользователь. Далее шаг интегрирования меняется в соответствии с величиной получаемой в ходе вычислений оценки локальной погрешности. Для упрощения описания на этой странице используется постоянный шаг интегрирования h, зависящий от размера сетки разбиения n.

== Математическое описание алгоритма ==

Далее подразумевается, что <math> \bold y, \bold y_i,\bold f, \bold k_i \in \mathbb{R}^m</math>, а <math>x, h, n, a, b \in \mathbb{R}^1 </math>.

Исходные данные:
<math> a, b </math> - интервал интегрирования,
<math> \bold y_0 </math> - вектор значений при <math> x = a </math>,
n - количество точек в разбиении
<math>\bold f </math> - функция вычисления производной

Вычисляемые данные:
<math> \bold y_i </math> - вектора значений в узлах сетки, т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>

Формулы метода:
:Вначале вычисляется шаг сетки:
::<math> h = \frac{b-a}{n}</math>.
:Приближенное значение в следующих точках вычисляется по итерационной формуле:
::<math>\textbf{y}_{n+1} = \textbf{y}_n + {h \over 6}(\textbf{k}_1 + 2\textbf{k}_2 + 2\textbf{k}_3 + \textbf{k}_4)</math>,
::<math>\textbf{k}_1 = \textbf{f} \left( x_n, \textbf{y}_n \right),</math>
::<math>\textbf{k}_2 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_1 \right),</math>
::<math>\textbf{k}_3 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_2 \right),</math>
::<math>\textbf{k}_4 = \textbf{f} \left( x_n + h, \textbf{y}_n + h\ \textbf{k}_3 \right),</math>
::<math>x_{n+1} = x_n + h.</math>

== Вычислительное ядро алгоритма ==

Вычислительным ядром метода Рунге-Кутты можно считать вычисление значений функции производной
:<math>\textbf{f}(x, \textbf{y})</math>,
так как при вычислении каждого нового <math>\textbf{y}_n</math> требуется 4 вычисления значения функции производной. Таким образом, сложность работы алгоритма существенно зависит от сложности вычисления функции <math>\textbf{f}</math>.

== Макроструктура алгоритма ==

Макроструктура алгоритма может быть представлена в следующем виде:
:Вычисление вспомогательных коэффициентов <math>\textbf{k}_j, j \in [1,4]</math>;
:Вычисление приближенного значения <math> \bold y_i </math> в следующей точке;
:Переход на следующую итерацию или остановка.

== Схема реализации последовательного алгоритма ==

Пример реализации последовательного алгоритма на языке C++ (указатель на функцию f передаётся через аргументы представленной ниже функции):
<source lang="c++" line="1">
#include <vector>

// other code ...

std::vector<double> rungekutta4(double a, double b, std::vector<double> y0, int n, std::vector<double (*)(double,double)> f)
{
std::vector<double>::size_type sz = y0.size();
std::vector<double> result;
for (unsigned j=0; j<sz; j++)
{
rezult.push_back(core(a,b,y[j],n,f[j]));
}
return result;
}

double core(double a, double b, double y0, int n, double (*f)(double,double))
{
double h, k1, k2, k3, k4, x, y;
h = (b - a)/n;
y = y0;
x = a;
for (unsigned i = 0; i < n; i++)
{
k1 = f(x, y);
k2 = f(x + h/2, y + h*k1/2);
k3 = f(x + h/2, y + h*k2/2);
k4 = f(x + h/2, y + h*k3);
x += h;
y += h*(k1 + 2*k2 + 2*k3 + k4)/6;
}
return y;
}

// other code ...
</source>

== Последовательная сложность алгоритма ==

Рассмотрим сначала одномерный случай. Наравне с обычными операциями, такими как сложение, умножение и тому подобными, в представленном выше алгоритме присутствует вызов функции <math> f </math>. Так как эта функция может содержать в себе любое количество простых математических операций, будем считать, что её сложность <math> f </math> много больше любой из них, и равна константе <math>C</math>. За весь алгоритм, она вызывается <math>4n</math> раза. Таким образом, сложность последовательного алгоритма для одномерного случая равна <math>4nC</math>.

Для случая решения системы ОДУ, когда <math>f</math> и <math>y</math> являются векторами размерности <math>m</math>, функция core будет вызвана <math>m</math>, и итоговая сложность алгоритма составит <math>4nCm</math>.

== Информационный граф ==

Информационная структура параллельного алгоритма Рунге-Кутты 4-го порядка представляет собой матрицу изображённую на рисунке ниже. Вдоль оси <math>j</math> располагаются <math>j</math>-ые параметры вектора <math>y</math>, соответственно, вдоль <math>i</math> изображены этапы вычисления <math>y_i</math> значения j-параметра вектора <math>y</math>. Таким образом, можно сказать, что вдоль оси <math>j</math>, изображены параллельные процессы. А ось <math>i</math> представляет собой шкалу времени. Чтобы соотнести её с реальным временем, надо просто посчитать сумму <math>\sum_{i=1}^{n} t_i</math>, где <math>t_i</math> - время с момента начала вычисления <math>i</math>-го всеми процессами до момента его завершения всеми процессами.

[[Файл:System_graph.png]]

Можно заметить, что на каждом <math>i</math>-ом шаге происходит обмен информацией между процессами. Это выражено в виде линии пересекающей все <math>j</math>-ые процессы на любом <math>i</math>-ом шаге.

== Ресурс параллелизма алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является итерационным алгоритмом. В нём каждый шаг цикла зависит от предыдущего. В самом шаге, каждая последующая операция также зависит от результата предыдущей. Таким образом, упразднить цикл до независимых и соответственно параллельных операций не является возможным. Однако, так как на результат функции <math> f </math> влияет только <math>i</math>-ый параметр вектора <math> y </math>, то для каждого <math> i </math> можно производить независимое вычисление. В итоге, если вычислять результаты выполнения функции <math> f </math> одновременно для вля всех <math> i</math>-ых параметров вектора <math> y </math>, получим туже алгоритмическую сложность <math>4nC</math>, что и в [[#Последовательная сложность алгоритма|разделе 1.6]] для одномерного случая.

== Входные и выходные данные алгоритма ==

'''Входные данные''':
<math> a, b </math> - интервал интегрирования,
n - количество точек в разбиении,
<math> \bold y_0 </math> - вектор значений размерности m при <math> x = a </math>,
функцию вычисления производной <math>\bold f </math> будем считать встроенной в алгоритм.

'''Объём входных данных''':
m + 3

'''Выходные данные:'''
<math> \bold y_i </math> - вектора размера m значений в n узлах сетки (т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>).

'''Объем выходных данных'''
n * m

== Свойства алгоритма ==

Алгоритм обладает следующими свойствами:

* Точность. Как написано в [[#Общее описание алгоритма| разделе 1.1]], алгоритм имеет порядок точности <math>O(h^4)</math>.
* Устойчивость. Алгоритм устойчив на любом конечном отрезке.
* Гибкость. На любом этапе вычисления можно легко изменить шаг интегрирования.

= ЧАСТЬ. Программная реализация алгоритма =

== [[Особенности реализации последовательного алгоритма]] ==

== [[Локальность данных и вычислений]] ==

== [[Возможные способы и особенности параллельной реализации алгоритма]] ==

== Масштабируемость алгоритма и его реализации ==

== [[Динамические характеристики и эффективность реализации алгоритма]] ==

== [[Выводы для классов архитектур]] ==

== Существующие реализации алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является одним из наиболее используемых для решения ОДУ и их систем, поэтому существует большое число его реализаций для разных языков программирования. Наиболее популярными являются следующие из них:
* библиотека RK4, которая существует в вариантах для C++, FORTRAN90, FORTRAN77, python и MATLAB;
* библиотека ode45 для MATLAB;
* модуль scipy для PYTHON.

= Литература =

Участник:Борис/Алгоритм Рунге-Кутты

2016-10-15T21:42:44Z

Борис: /* Последовательная сложность алгоритма */

{{algorithm
| name = Метод Рунге-Кутты 4 порядка
| serial_complexity = <math>4nCm</math>
| pf_height = <math>O(n)</math>
| pf_width = <math>O(m)</math>
| input_data = <math>m + 3</math>
| output_data = <math>m * n</math>
}}

Основные авторы описания: [[Участник:Jest|Е.П.Степанов]]([[#Общее описание алгоритма|раздел 1.1]], [[#Математическое описание алгоритма|раздел 1.2]], [[#Вычислительное ядро алгоритма|раздел 1.3]], [[#Макроструктура алгоритма|раздел 1.4]], [[#Входные и выходные данные алгоритма|раздел 1.9]]), [[Участник:Борис|Б.Савков]] ( [[#Схема реализации последовательного алгоритма|раздел 1.5]], [[#Последовательная сложность алгоритма|раздел 1.6]], [[#Информационный граф|раздел 1.7]], [[#Ресурс параллелизма алгоритма|раздел 1.8]], [[#Свойства алгоритма|раздел 1.10]], [[#Существующие реализации алгоритма|раздел 2.7]])

= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==

Ме́тоды Ру́нге — Ку́тты (распространено неправильное название Ме́тоды Ру́нге — Ку́тта или же Ме́тоды Ру́нге — Кутта́) — важное семейство численных алгоритмов решения обыкновенных дифференциальных уравнений и их систем. Данные итеративные методы явного и неявного приближённого вычисления были разработаны около 1900 года немецкими математиками К. Рунге и М. В. Куттой.

Метод Рунге - Кутты применяется при решения задачи Коши для системы обыкновенных дифференциальных уравнений первого порядка:

:<math>
\begin{cases}
\textbf{y}' = \textbf{f}(x, \textbf{y}),\\
\textbf{y}(x_0) = \textbf{y}_0.
\end{cases}
</math>

При этом <math>\textbf{y}, \textbf{f}, x</math> отвечают следующим свойствам: <math> \textbf{y}, \textbf{f} \in \mathbb{R}^m, x \in \mathbb{R}^1 </math>.

Пусть известно значение y(x) и требуется вычислить значение y(x+h). Это можно сделать при помощи формулы:

:<math> y(x + h) = y(x) + \int_0^hy'(x + t)dt</math>

Аппроксимируя интеграл в правой части, можно получить методы Рунге-Кутты разного порядка точности. В общем виде формулы методов Рунге-Кутты можно записать следующим образом:

:<math>\textbf{y}_{n+1} = \textbf{y}_n + h\sum_{i=1}^s b_i \textbf{k}_i</math>

:<math>
\begin{array}{ll}
\textbf{k}_1 =& \textbf{f}(x_n, \textbf{y}_n),\\
\textbf{k}_2 =& \textbf{f}(x_n+c_2h, \textbf{y}_n+a_{21}h\textbf{k}_1),\\
\cdots&\\
\textbf{k}_s =& \textbf{f}(x_n+c_sh, \textbf{y}_n+a_{s1}h\textbf{k}_1+a_{s2}h\textbf{k}_2+\cdots+a_{s,s-1}h\textbf{k}_{s-1})
\end{array}
</math>

Увеличивая число s вспомогательных точек, можно построить методы Рунге-Кутты любого порядка точности p. Однако уже при p > 5 эти методы используются довольно редко. Это объясняется как чрезмерной громоздкостью получающихся вычислительных формул, так и тем, что преимущества методов высокого порядка точности над методами, в которых p = 4 или p = 5, проявляются либо в тех задачах, где нужна очень высокая точность и используются ЭВМ высокой разрядности, либо в тех задачах, где решение очень гладкое. Кроме того, методы Рунге-Кутты высокого порядка точности часто оказываются менее эффективными по сравнению с методами Адамса того же порядка точности. На этой странице представлен наиболее распространенный метод Рунге-Кутты 4 порядка с ошибкой на конечном интервале интегрирования <math>O(h^4)</math>.

Существуют как явные, так и неявные методы Рунге-Кутты. Последние имеют ряд преимуществ над явными методами, однако это достигается за счет существенного усложнения вычислительного алгоритма, так как на каждом шаге приходится считать систему нелинейных уравнений. На этой странице представлен явный метод Рунге-Кутты.

Можно отметить, что в современных программах, реализующих метод Рунге-Кутты, обязательно используется некоторый алгоритм автоматического изменения шага интегрирования. Интуитивно ясно, что на участках плавного изменения решения счет можно вести с достаточно крупным шагом. В то же время на тех участках, где происходят резкие изменения поведения решения, необходимо выбирать мелкий шаг интегрирования. Обычно начальное значение шага h1 задает пользователь. Далее шаг интегрирования меняется в соответствии с величиной получаемой в ходе вычислений оценки локальной погрешности. Для упрощения описания на этой странице используется постоянный шаг интегрирования h, зависящий от размера сетки разбиения n.

== Математическое описание алгоритма ==

Далее подразумевается, что <math> \bold y, \bold y_i,\bold f, \bold k_i \in \mathbb{R}^m</math>, а <math>x, h, n, a, b \in \mathbb{R}^1 </math>.

Исходные данные:
<math> a, b </math> - интервал интегрирования,
<math> \bold y_0 </math> - вектор значений при <math> x = a </math>,
n - количество точек в разбиении
<math>\bold f </math> - функция вычисления производной

Вычисляемые данные:
<math> \bold y_i </math> - вектора значений в узлах сетки, т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>

Формулы метода:
:Вначале вычисляется шаг сетки:
::<math> h = \frac{b-a}{n}</math>.
:Приближенное значение в следующих точках вычисляется по итерационной формуле:
::<math>\textbf{y}_{n+1} = \textbf{y}_n + {h \over 6}(\textbf{k}_1 + 2\textbf{k}_2 + 2\textbf{k}_3 + \textbf{k}_4)</math>,
::<math>\textbf{k}_1 = \textbf{f} \left( x_n, \textbf{y}_n \right),</math>
::<math>\textbf{k}_2 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_1 \right),</math>
::<math>\textbf{k}_3 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_2 \right),</math>
::<math>\textbf{k}_4 = \textbf{f} \left( x_n + h, \textbf{y}_n + h\ \textbf{k}_3 \right),</math>
::<math>x_{n+1} = x_n + h.</math>

== Вычислительное ядро алгоритма ==

Вычислительным ядром метода Рунге-Кутты можно считать вычисление значений функции производной
:<math>\textbf{f}(x, \textbf{y})</math>,
так как при вычислении каждого нового <math>\textbf{y}_n</math> требуется 4 вычисления значения функции производной. Таким образом, сложность работы алгоритма существенно зависит от сложности вычисления функции <math>\textbf{f}</math>.

== Макроструктура алгоритма ==

Макроструктура алгоритма может быть представлена в следующем виде:
:Вычисление вспомогательных коэффициентов <math>\textbf{k}_j, j \in [1,4]</math>;
:Вычисление приближенного значения <math> \bold y_i </math> в следующей точке;
:Переход на следующую итерацию или остановка.

== Схема реализации последовательного алгоритма ==

Пример реализации последовательного алгоритма на языке C++ (указатель на функцию f передаётся через аргументы представленной ниже функции):
<source lang="c++" line="1">
#include <vector>

// other code ...

std::vector<double> rungekutta4(double a, double b, std::vector<double> y0, int n, std::vector<double (*)(double,double)> f)
{
std::vector<double>::size_type sz = y0.size();
std::vector<double> result;
for (unsigned j=0; j<sz; j++)
{
rezult.push_back(core(a,b,y[j],n,f[j]));
}
return result;
}

double core(double a, double b, double y0, int n, double (*f)(double,double))
{
double h, k1, k2, k3, k4, x, y;
h = (b - a)/n;
y = y0;
x = a;
for (unsigned i = 0; i < n; i++)
{
k1 = f(x, y);
k2 = f(x + h/2, y + h*k1/2);
k3 = f(x + h/2, y + h*k2/2);
k4 = f(x + h/2, y + h*k3);
x += h;
y += h*(k1 + 2*k2 + 2*k3 + k4)/6;
}
return y;
}

// other code ...
</source>

== Последовательная сложность алгоритма ==

Рассмотрим сначала одномерный случай. Наравне с обычными операциями, такими как сложение, умножение и тому подобными, в представленном выше алгоритме присутствует вызов функции <math> f </math>. Так как эта функция может содержать в себе любое количество простых математических операций, будем считать, что её сложность <math> f </math> много больше любой из них, и равна константе <math>C</math>. За весь алгоритм, она вызывается <math>4n</math> раза. Таким образом, сложность последовательного алгоритма для одномерного случая равна <math>4nC</math>.

Для случая решения системы ОДУ, когда <math>f</math> и <math>y</math> являются векторами размерности <math>m</math>, функция core будет вызвана <math>m</math>, и итоговая сложность алгоритма составит <math>4nCm</math>.

== Информационный граф ==

Информационная структура параллельного алгоритма Рунге-Кутты 4-го порядка представляет собой матрицу изображённую на рисунке ниже. Вдоль оси <math>j</math> располагаются <math>j</math>-ые параметры вектора <math>y</math>, соответственно, вдоль <math>i</math> изображены этапы вычисления <math>y_i</math> значения j-параметра вектора <math>y</math>. Таким образом, можно сказать, что вдоль оси <math>j</math>, изображены параллельные процессы. А ось <math>i</math> представляет собой шкалу времени. Чтобы соотнести её с реальным временем, надо просто посчитать сумму <math>\sum_{i=1}^{n} t_i</math>, где <math>t_i</math> - время с момента начала вычисления <math>i</math>-го всеми процессами до момента его завершения всеми процессами.

[[Файл:System_graph.png]]

Можно заметить, что на каждом <math>i</math>-ом шаге происходит обмен информацией между процессами. Это выражено в виде линии пересекающей все <math>j</math>-ые процессы на любом <math>i</math>-ом шаге.

== Ресурс параллелизма алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является итерационным алгоритмом. В нём каждый шаг цикла зависит от предыдущего. В самом шаге, каждая последующая операция также зависит от результата предыдущей. Таким образом, упразднить цикл до независимых и соответственно параллельных операций не является возможным. Однако, так как на результат функции <math> \bold f </math> влияет только <math>i</math>-ый параметр вектора <math> y </math>, то для каждого <math> i </math> можно производить независимое вычисление. В итоге, если вычислять результаты выполнения функции <math> \bold f </math> одновременно для вля всех <math> i</math>-ых параметров вектора <math> y </math>, получим туже алгоритмическую сложность <math>4nC</math>, что и в [[#Последовательная сложность алгоритма|разделе 1.6]] для одномерного случая.

== Входные и выходные данные алгоритма ==

'''Входные данные''':
<math> a, b </math> - интервал интегрирования,
n - количество точек в разбиении,
<math> \bold y_0 </math> - вектор значений размерности m при <math> x = a </math>,
функцию вычисления производной <math>\bold f </math> будем считать встроенной в алгоритм.

'''Объём входных данных''':
m + 3

'''Выходные данные:'''
<math> \bold y_i </math> - вектора размера m значений в n узлах сетки (т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>).

'''Объем выходных данных'''
n * m

== Свойства алгоритма ==

Алгоритм обладает следующими свойствами:

* Точность. Как написано в [[#Общее описание алгоритма| разделе 1.1]], алгоритм имеет порядок точности <math>O(h^4)</math>.
* Устойчивость. Алгоритм устойчив на любом конечном отрезке.
* Гибкость. На любом этапе вычисления можно легко изменить шаг интегрирования.

= ЧАСТЬ. Программная реализация алгоритма =

== [[Особенности реализации последовательного алгоритма]] ==

== [[Локальность данных и вычислений]] ==

== [[Возможные способы и особенности параллельной реализации алгоритма]] ==

== Масштабируемость алгоритма и его реализации ==

== [[Динамические характеристики и эффективность реализации алгоритма]] ==

== [[Выводы для классов архитектур]] ==

== Существующие реализации алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является одним из наиболее используемых для решения ОДУ и их систем, поэтому существует большое число его реализаций для разных языков программирования. Наиболее популярными являются следующие из них:
* библиотека RK4, которая существует в вариантах для C++, FORTRAN90, FORTRAN77, python и MATLAB;
* библиотека ode45 для MATLAB;
* модуль scipy для PYTHON.

= Литература =

Участник:Борис/Алгоритм Рунге-Кутты

2016-10-15T21:41:57Z

Борис: /* Ресурс параллелизма алгоритма */

{{algorithm
| name = Метод Рунге-Кутты 4 порядка
| serial_complexity = <math>4nCm</math>
| pf_height = <math>O(n)</math>
| pf_width = <math>O(m)</math>
| input_data = <math>m + 3</math>
| output_data = <math>m * n</math>
}}

Основные авторы описания: [[Участник:Jest|Е.П.Степанов]]([[#Общее описание алгоритма|раздел 1.1]], [[#Математическое описание алгоритма|раздел 1.2]], [[#Вычислительное ядро алгоритма|раздел 1.3]], [[#Макроструктура алгоритма|раздел 1.4]], [[#Входные и выходные данные алгоритма|раздел 1.9]]), [[Участник:Борис|Б.Савков]] ( [[#Схема реализации последовательного алгоритма|раздел 1.5]], [[#Последовательная сложность алгоритма|раздел 1.6]], [[#Информационный граф|раздел 1.7]], [[#Ресурс параллелизма алгоритма|раздел 1.8]], [[#Свойства алгоритма|раздел 1.10]], [[#Существующие реализации алгоритма|раздел 2.7]])

= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==

Ме́тоды Ру́нге — Ку́тты (распространено неправильное название Ме́тоды Ру́нге — Ку́тта или же Ме́тоды Ру́нге — Кутта́) — важное семейство численных алгоритмов решения обыкновенных дифференциальных уравнений и их систем. Данные итеративные методы явного и неявного приближённого вычисления были разработаны около 1900 года немецкими математиками К. Рунге и М. В. Куттой.

Метод Рунге - Кутты применяется при решения задачи Коши для системы обыкновенных дифференциальных уравнений первого порядка:

:<math>
\begin{cases}
\textbf{y}' = \textbf{f}(x, \textbf{y}),\\
\textbf{y}(x_0) = \textbf{y}_0.
\end{cases}
</math>

При этом <math>\textbf{y}, \textbf{f}, x</math> отвечают следующим свойствам: <math> \textbf{y}, \textbf{f} \in \mathbb{R}^m, x \in \mathbb{R}^1 </math>.

Пусть известно значение y(x) и требуется вычислить значение y(x+h). Это можно сделать при помощи формулы:

:<math> y(x + h) = y(x) + \int_0^hy'(x + t)dt</math>

Аппроксимируя интеграл в правой части, можно получить методы Рунге-Кутты разного порядка точности. В общем виде формулы методов Рунге-Кутты можно записать следующим образом:

:<math>\textbf{y}_{n+1} = \textbf{y}_n + h\sum_{i=1}^s b_i \textbf{k}_i</math>

:<math>
\begin{array}{ll}
\textbf{k}_1 =& \textbf{f}(x_n, \textbf{y}_n),\\
\textbf{k}_2 =& \textbf{f}(x_n+c_2h, \textbf{y}_n+a_{21}h\textbf{k}_1),\\
\cdots&\\
\textbf{k}_s =& \textbf{f}(x_n+c_sh, \textbf{y}_n+a_{s1}h\textbf{k}_1+a_{s2}h\textbf{k}_2+\cdots+a_{s,s-1}h\textbf{k}_{s-1})
\end{array}
</math>

Увеличивая число s вспомогательных точек, можно построить методы Рунге-Кутты любого порядка точности p. Однако уже при p > 5 эти методы используются довольно редко. Это объясняется как чрезмерной громоздкостью получающихся вычислительных формул, так и тем, что преимущества методов высокого порядка точности над методами, в которых p = 4 или p = 5, проявляются либо в тех задачах, где нужна очень высокая точность и используются ЭВМ высокой разрядности, либо в тех задачах, где решение очень гладкое. Кроме того, методы Рунге-Кутты высокого порядка точности часто оказываются менее эффективными по сравнению с методами Адамса того же порядка точности. На этой странице представлен наиболее распространенный метод Рунге-Кутты 4 порядка с ошибкой на конечном интервале интегрирования <math>O(h^4)</math>.

Существуют как явные, так и неявные методы Рунге-Кутты. Последние имеют ряд преимуществ над явными методами, однако это достигается за счет существенного усложнения вычислительного алгоритма, так как на каждом шаге приходится считать систему нелинейных уравнений. На этой странице представлен явный метод Рунге-Кутты.

Можно отметить, что в современных программах, реализующих метод Рунге-Кутты, обязательно используется некоторый алгоритм автоматического изменения шага интегрирования. Интуитивно ясно, что на участках плавного изменения решения счет можно вести с достаточно крупным шагом. В то же время на тех участках, где происходят резкие изменения поведения решения, необходимо выбирать мелкий шаг интегрирования. Обычно начальное значение шага h1 задает пользователь. Далее шаг интегрирования меняется в соответствии с величиной получаемой в ходе вычислений оценки локальной погрешности. Для упрощения описания на этой странице используется постоянный шаг интегрирования h, зависящий от размера сетки разбиения n.

== Математическое описание алгоритма ==

Далее подразумевается, что <math> \bold y, \bold y_i,\bold f, \bold k_i \in \mathbb{R}^m</math>, а <math>x, h, n, a, b \in \mathbb{R}^1 </math>.

Исходные данные:
<math> a, b </math> - интервал интегрирования,
<math> \bold y_0 </math> - вектор значений при <math> x = a </math>,
n - количество точек в разбиении
<math>\bold f </math> - функция вычисления производной

Вычисляемые данные:
<math> \bold y_i </math> - вектора значений в узлах сетки, т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>

Формулы метода:
:Вначале вычисляется шаг сетки:
::<math> h = \frac{b-a}{n}</math>.
:Приближенное значение в следующих точках вычисляется по итерационной формуле:
::<math>\textbf{y}_{n+1} = \textbf{y}_n + {h \over 6}(\textbf{k}_1 + 2\textbf{k}_2 + 2\textbf{k}_3 + \textbf{k}_4)</math>,
::<math>\textbf{k}_1 = \textbf{f} \left( x_n, \textbf{y}_n \right),</math>
::<math>\textbf{k}_2 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_1 \right),</math>
::<math>\textbf{k}_3 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_2 \right),</math>
::<math>\textbf{k}_4 = \textbf{f} \left( x_n + h, \textbf{y}_n + h\ \textbf{k}_3 \right),</math>
::<math>x_{n+1} = x_n + h.</math>

== Вычислительное ядро алгоритма ==

Вычислительным ядром метода Рунге-Кутты можно считать вычисление значений функции производной
:<math>\textbf{f}(x, \textbf{y})</math>,
так как при вычислении каждого нового <math>\textbf{y}_n</math> требуется 4 вычисления значения функции производной. Таким образом, сложность работы алгоритма существенно зависит от сложности вычисления функции <math>\textbf{f}</math>.

== Макроструктура алгоритма ==

Макроструктура алгоритма может быть представлена в следующем виде:
:Вычисление вспомогательных коэффициентов <math>\textbf{k}_j, j \in [1,4]</math>;
:Вычисление приближенного значения <math> \bold y_i </math> в следующей точке;
:Переход на следующую итерацию или остановка.

== Схема реализации последовательного алгоритма ==

Пример реализации последовательного алгоритма на языке C++ (указатель на функцию f передаётся через аргументы представленной ниже функции):
<source lang="c++" line="1">
#include <vector>

// other code ...

std::vector<double> rungekutta4(double a, double b, std::vector<double> y0, int n, std::vector<double (*)(double,double)> f)
{
std::vector<double>::size_type sz = y0.size();
std::vector<double> result;
for (unsigned j=0; j<sz; j++)
{
rezult.push_back(core(a,b,y[j],n,f[j]));
}
return result;
}

double core(double a, double b, double y0, int n, double (*f)(double,double))
{
double h, k1, k2, k3, k4, x, y;
h = (b - a)/n;
y = y0;
x = a;
for (unsigned i = 0; i < n; i++)
{
k1 = f(x, y);
k2 = f(x + h/2, y + h*k1/2);
k3 = f(x + h/2, y + h*k2/2);
k4 = f(x + h/2, y + h*k3);
x += h;
y += h*(k1 + 2*k2 + 2*k3 + k4)/6;
}
return y;
}

// other code ...
</source>

== Последовательная сложность алгоритма ==

Рассмотрим сначала одномерный случай. Наравне с обычными операциями, такими как сложение, умножение и тому подобными, в представленном выше алгоритме присутствует вызов функции <math>\bold f </math>. Так как эта функция может содержать в себе любое количество простых математических операций, будем считать, что её сложность <math>\bold f </math> много больше любой из них, и равна константе <math>C</math>. За весь алгоритм, она вызывается <math>4n</math> раза. Таким образом, сложность последовательного алгоритма для одномерного случая равна <math>4nC</math>.

Для случая решения системы ОДУ, когда <math>f</math> и <math>y</math> являются векторами размерности <math>m</math>, функция core будет вызвана <math>m</math>, и итоговая сложность алгоритма составит <math>4nCm</math>.

== Информационный граф ==

Информационная структура параллельного алгоритма Рунге-Кутты 4-го порядка представляет собой матрицу изображённую на рисунке ниже. Вдоль оси <math>j</math> располагаются <math>j</math>-ые параметры вектора <math>y</math>, соответственно, вдоль <math>i</math> изображены этапы вычисления <math>y_i</math> значения j-параметра вектора <math>y</math>. Таким образом, можно сказать, что вдоль оси <math>j</math>, изображены параллельные процессы. А ось <math>i</math> представляет собой шкалу времени. Чтобы соотнести её с реальным временем, надо просто посчитать сумму <math>\sum_{i=1}^{n} t_i</math>, где <math>t_i</math> - время с момента начала вычисления <math>i</math>-го всеми процессами до момента его завершения всеми процессами.

[[Файл:System_graph.png]]

Можно заметить, что на каждом <math>i</math>-ом шаге происходит обмен информацией между процессами. Это выражено в виде линии пересекающей все <math>j</math>-ые процессы на любом <math>i</math>-ом шаге.

== Ресурс параллелизма алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является итерационным алгоритмом. В нём каждый шаг цикла зависит от предыдущего. В самом шаге, каждая последующая операция также зависит от результата предыдущей. Таким образом, упразднить цикл до независимых и соответственно параллельных операций не является возможным. Однако, так как на результат функции <math> \bold f </math> влияет только <math>i</math>-ый параметр вектора <math> y </math>, то для каждого <math> i </math> можно производить независимое вычисление. В итоге, если вычислять результаты выполнения функции <math> \bold f </math> одновременно для вля всех <math> i</math>-ых параметров вектора <math> y </math>, получим туже алгоритмическую сложность <math>4nC</math>, что и в [[#Последовательная сложность алгоритма|разделе 1.6]] для одномерного случая.

== Входные и выходные данные алгоритма ==

'''Входные данные''':
<math> a, b </math> - интервал интегрирования,
n - количество точек в разбиении,
<math> \bold y_0 </math> - вектор значений размерности m при <math> x = a </math>,
функцию вычисления производной <math>\bold f </math> будем считать встроенной в алгоритм.

'''Объём входных данных''':
m + 3

'''Выходные данные:'''
<math> \bold y_i </math> - вектора размера m значений в n узлах сетки (т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>).

'''Объем выходных данных'''
n * m

== Свойства алгоритма ==

Алгоритм обладает следующими свойствами:

* Точность. Как написано в [[#Общее описание алгоритма| разделе 1.1]], алгоритм имеет порядок точности <math>O(h^4)</math>.
* Устойчивость. Алгоритм устойчив на любом конечном отрезке.
* Гибкость. На любом этапе вычисления можно легко изменить шаг интегрирования.

= ЧАСТЬ. Программная реализация алгоритма =

== [[Особенности реализации последовательного алгоритма]] ==

== [[Локальность данных и вычислений]] ==

== [[Возможные способы и особенности параллельной реализации алгоритма]] ==

== Масштабируемость алгоритма и его реализации ==

== [[Динамические характеристики и эффективность реализации алгоритма]] ==

== [[Выводы для классов архитектур]] ==

== Существующие реализации алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является одним из наиболее используемых для решения ОДУ и их систем, поэтому существует большое число его реализаций для разных языков программирования. Наиболее популярными являются следующие из них:
* библиотека RK4, которая существует в вариантах для C++, FORTRAN90, FORTRAN77, python и MATLAB;
* библиотека ode45 для MATLAB;
* модуль scipy для PYTHON.

= Литература =

Участник:Борис/Алгоритм Рунге-Кутты

2016-10-15T21:40:40Z

Борис: /* Информационный граф */

{{algorithm
| name = Метод Рунге-Кутты 4 порядка
| serial_complexity = <math>4nCm</math>
| pf_height = <math>O(n)</math>
| pf_width = <math>O(m)</math>
| input_data = <math>m + 3</math>
| output_data = <math>m * n</math>
}}

Основные авторы описания: [[Участник:Jest|Е.П.Степанов]]([[#Общее описание алгоритма|раздел 1.1]], [[#Математическое описание алгоритма|раздел 1.2]], [[#Вычислительное ядро алгоритма|раздел 1.3]], [[#Макроструктура алгоритма|раздел 1.4]], [[#Входные и выходные данные алгоритма|раздел 1.9]]), [[Участник:Борис|Б.Савков]] ( [[#Схема реализации последовательного алгоритма|раздел 1.5]], [[#Последовательная сложность алгоритма|раздел 1.6]], [[#Информационный граф|раздел 1.7]], [[#Ресурс параллелизма алгоритма|раздел 1.8]], [[#Свойства алгоритма|раздел 1.10]], [[#Существующие реализации алгоритма|раздел 2.7]])

= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==

Ме́тоды Ру́нге — Ку́тты (распространено неправильное название Ме́тоды Ру́нге — Ку́тта или же Ме́тоды Ру́нге — Кутта́) — важное семейство численных алгоритмов решения обыкновенных дифференциальных уравнений и их систем. Данные итеративные методы явного и неявного приближённого вычисления были разработаны около 1900 года немецкими математиками К. Рунге и М. В. Куттой.

Метод Рунге - Кутты применяется при решения задачи Коши для системы обыкновенных дифференциальных уравнений первого порядка:

:<math>
\begin{cases}
\textbf{y}' = \textbf{f}(x, \textbf{y}),\\
\textbf{y}(x_0) = \textbf{y}_0.
\end{cases}
</math>

При этом <math>\textbf{y}, \textbf{f}, x</math> отвечают следующим свойствам: <math> \textbf{y}, \textbf{f} \in \mathbb{R}^m, x \in \mathbb{R}^1 </math>.

Пусть известно значение y(x) и требуется вычислить значение y(x+h). Это можно сделать при помощи формулы:

:<math> y(x + h) = y(x) + \int_0^hy'(x + t)dt</math>

Аппроксимируя интеграл в правой части, можно получить методы Рунге-Кутты разного порядка точности. В общем виде формулы методов Рунге-Кутты можно записать следующим образом:

:<math>\textbf{y}_{n+1} = \textbf{y}_n + h\sum_{i=1}^s b_i \textbf{k}_i</math>

:<math>
\begin{array}{ll}
\textbf{k}_1 =& \textbf{f}(x_n, \textbf{y}_n),\\
\textbf{k}_2 =& \textbf{f}(x_n+c_2h, \textbf{y}_n+a_{21}h\textbf{k}_1),\\
\cdots&\\
\textbf{k}_s =& \textbf{f}(x_n+c_sh, \textbf{y}_n+a_{s1}h\textbf{k}_1+a_{s2}h\textbf{k}_2+\cdots+a_{s,s-1}h\textbf{k}_{s-1})
\end{array}
</math>

Увеличивая число s вспомогательных точек, можно построить методы Рунге-Кутты любого порядка точности p. Однако уже при p > 5 эти методы используются довольно редко. Это объясняется как чрезмерной громоздкостью получающихся вычислительных формул, так и тем, что преимущества методов высокого порядка точности над методами, в которых p = 4 или p = 5, проявляются либо в тех задачах, где нужна очень высокая точность и используются ЭВМ высокой разрядности, либо в тех задачах, где решение очень гладкое. Кроме того, методы Рунге-Кутты высокого порядка точности часто оказываются менее эффективными по сравнению с методами Адамса того же порядка точности. На этой странице представлен наиболее распространенный метод Рунге-Кутты 4 порядка с ошибкой на конечном интервале интегрирования <math>O(h^4)</math>.

Существуют как явные, так и неявные методы Рунге-Кутты. Последние имеют ряд преимуществ над явными методами, однако это достигается за счет существенного усложнения вычислительного алгоритма, так как на каждом шаге приходится считать систему нелинейных уравнений. На этой странице представлен явный метод Рунге-Кутты.

Можно отметить, что в современных программах, реализующих метод Рунге-Кутты, обязательно используется некоторый алгоритм автоматического изменения шага интегрирования. Интуитивно ясно, что на участках плавного изменения решения счет можно вести с достаточно крупным шагом. В то же время на тех участках, где происходят резкие изменения поведения решения, необходимо выбирать мелкий шаг интегрирования. Обычно начальное значение шага h1 задает пользователь. Далее шаг интегрирования меняется в соответствии с величиной получаемой в ходе вычислений оценки локальной погрешности. Для упрощения описания на этой странице используется постоянный шаг интегрирования h, зависящий от размера сетки разбиения n.

== Математическое описание алгоритма ==

Далее подразумевается, что <math> \bold y, \bold y_i,\bold f, \bold k_i \in \mathbb{R}^m</math>, а <math>x, h, n, a, b \in \mathbb{R}^1 </math>.

Исходные данные:
<math> a, b </math> - интервал интегрирования,
<math> \bold y_0 </math> - вектор значений при <math> x = a </math>,
n - количество точек в разбиении
<math>\bold f </math> - функция вычисления производной

Вычисляемые данные:
<math> \bold y_i </math> - вектора значений в узлах сетки, т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>

Формулы метода:
:Вначале вычисляется шаг сетки:
::<math> h = \frac{b-a}{n}</math>.
:Приближенное значение в следующих точках вычисляется по итерационной формуле:
::<math>\textbf{y}_{n+1} = \textbf{y}_n + {h \over 6}(\textbf{k}_1 + 2\textbf{k}_2 + 2\textbf{k}_3 + \textbf{k}_4)</math>,
::<math>\textbf{k}_1 = \textbf{f} \left( x_n, \textbf{y}_n \right),</math>
::<math>\textbf{k}_2 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_1 \right),</math>
::<math>\textbf{k}_3 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_2 \right),</math>
::<math>\textbf{k}_4 = \textbf{f} \left( x_n + h, \textbf{y}_n + h\ \textbf{k}_3 \right),</math>
::<math>x_{n+1} = x_n + h.</math>

== Вычислительное ядро алгоритма ==

Вычислительным ядром метода Рунге-Кутты можно считать вычисление значений функции производной
:<math>\textbf{f}(x, \textbf{y})</math>,
так как при вычислении каждого нового <math>\textbf{y}_n</math> требуется 4 вычисления значения функции производной. Таким образом, сложность работы алгоритма существенно зависит от сложности вычисления функции <math>\textbf{f}</math>.

== Макроструктура алгоритма ==

Макроструктура алгоритма может быть представлена в следующем виде:
:Вычисление вспомогательных коэффициентов <math>\textbf{k}_j, j \in [1,4]</math>;
:Вычисление приближенного значения <math> \bold y_i </math> в следующей точке;
:Переход на следующую итерацию или остановка.

== Схема реализации последовательного алгоритма ==

Пример реализации последовательного алгоритма на языке C++ (указатель на функцию f передаётся через аргументы представленной ниже функции):
<source lang="c++" line="1">
#include <vector>

// other code ...

std::vector<double> rungekutta4(double a, double b, std::vector<double> y0, int n, std::vector<double (*)(double,double)> f)
{
std::vector<double>::size_type sz = y0.size();
std::vector<double> result;
for (unsigned j=0; j<sz; j++)
{
rezult.push_back(core(a,b,y[j],n,f[j]));
}
return result;
}

double core(double a, double b, double y0, int n, double (*f)(double,double))
{
double h, k1, k2, k3, k4, x, y;
h = (b - a)/n;
y = y0;
x = a;
for (unsigned i = 0; i < n; i++)
{
k1 = f(x, y);
k2 = f(x + h/2, y + h*k1/2);
k3 = f(x + h/2, y + h*k2/2);
k4 = f(x + h/2, y + h*k3);
x += h;
y += h*(k1 + 2*k2 + 2*k3 + k4)/6;
}
return y;
}

// other code ...
</source>

== Последовательная сложность алгоритма ==

Рассмотрим сначала одномерный случай. Наравне с обычными операциями, такими как сложение, умножение и тому подобными, в представленном выше алгоритме присутствует вызов функции <math>\bold f </math>. Так как эта функция может содержать в себе любое количество простых математических операций, будем считать, что её сложность <math>\bold f </math> много больше любой из них, и равна константе <math>C</math>. За весь алгоритм, она вызывается <math>4n</math> раза. Таким образом, сложность последовательного алгоритма для одномерного случая равна <math>4nC</math>.

Для случая решения системы ОДУ, когда <math>f</math> и <math>y</math> являются векторами размерности <math>m</math>, функция core будет вызвана <math>m</math>, и итоговая сложность алгоритма составит <math>4nCm</math>.

== Информационный граф ==

Информационная структура параллельного алгоритма Рунге-Кутты 4-го порядка представляет собой матрицу изображённую на рисунке ниже. Вдоль оси <math>j</math> располагаются <math>j</math>-ые параметры вектора <math>y</math>, соответственно, вдоль <math>i</math> изображены этапы вычисления <math>y_i</math> значения j-параметра вектора <math>y</math>. Таким образом, можно сказать, что вдоль оси <math>j</math>, изображены параллельные процессы. А ось <math>i</math> представляет собой шкалу времени. Чтобы соотнести её с реальным временем, надо просто посчитать сумму <math>\sum_{i=1}^{n} t_i</math>, где <math>t_i</math> - время с момента начала вычисления <math>i</math>-го всеми процессами до момента его завершения всеми процессами.

[[Файл:System_graph.png]]

Можно заметить, что на каждом <math>i</math>-ом шаге происходит обмен информацией между процессами. Это выражено в виде линии пересекающей все <math>j</math>-ые процессы на любом <math>i</math>-ом шаге.

== Ресурс параллелизма алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является итерационным алгоритмом. В нём каждый шаг цикла зависит от предыдущего. В самом шаге, каждая последующая операция также зависит от результата предыдущей. Таким образом, упразднить цикл до независимых и соответственно параллельных операций не является возможным. Однако, так как на результат функции <math> \bold f </math> влияет только <math>i</math>-ый параметр векторов <math> f </math> и <math> y </math>, то для каждого <math> i </math> можно производить независимое вычисление. В итоге, если вычислять результаты выполнения функции <math> \bold f </math> одновременно для вля всех <math> i</math>-ых параметров векторов <math> f </math> и <math> y </math>, получим туже алгоритмическую сложность <math>4nC</math>, что и в [[#Последовательная сложность алгоритма|разделе 1.6]] для одномерного случая.

== Входные и выходные данные алгоритма ==

'''Входные данные''':
<math> a, b </math> - интервал интегрирования,
n - количество точек в разбиении,
<math> \bold y_0 </math> - вектор значений размерности m при <math> x = a </math>,
функцию вычисления производной <math>\bold f </math> будем считать встроенной в алгоритм.

'''Объём входных данных''':
m + 3

'''Выходные данные:'''
<math> \bold y_i </math> - вектора размера m значений в n узлах сетки (т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>).

'''Объем выходных данных'''
n * m

== Свойства алгоритма ==

Алгоритм обладает следующими свойствами:

* Точность. Как написано в [[#Общее описание алгоритма| разделе 1.1]], алгоритм имеет порядок точности <math>O(h^4)</math>.
* Устойчивость. Алгоритм устойчив на любом конечном отрезке.
* Гибкость. На любом этапе вычисления можно легко изменить шаг интегрирования.

= ЧАСТЬ. Программная реализация алгоритма =

== [[Особенности реализации последовательного алгоритма]] ==

== [[Локальность данных и вычислений]] ==

== [[Возможные способы и особенности параллельной реализации алгоритма]] ==

== Масштабируемость алгоритма и его реализации ==

== [[Динамические характеристики и эффективность реализации алгоритма]] ==

== [[Выводы для классов архитектур]] ==

== Существующие реализации алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является одним из наиболее используемых для решения ОДУ и их систем, поэтому существует большое число его реализаций для разных языков программирования. Наиболее популярными являются следующие из них:
* библиотека RK4, которая существует в вариантах для C++, FORTRAN90, FORTRAN77, python и MATLAB;
* библиотека ode45 для MATLAB;
* модуль scipy для PYTHON.

= Литература =

Участник:Борис/Алгоритм Рунге-Кутты

2016-10-15T21:09:04Z

Борис:

{{algorithm
| name = Метод Рунге-Кутты 4 порядка
| serial_complexity = <math>4nCm</math>
| pf_height = <math>O(n)</math>
| pf_width = <math>O(m)</math>
| input_data = <math>m + 3</math>
| output_data = <math>m * n</math>
}}

Основные авторы описания: [[Участник:Jest|Е.П.Степанов]]([[#Общее описание алгоритма|раздел 1.1]], [[#Математическое описание алгоритма|раздел 1.2]], [[#Вычислительное ядро алгоритма|раздел 1.3]], [[#Макроструктура алгоритма|раздел 1.4]], [[#Входные и выходные данные алгоритма|раздел 1.9]]), [[Участник:Борис|Б.Савков]] ( [[#Схема реализации последовательного алгоритма|раздел 1.5]], [[#Последовательная сложность алгоритма|раздел 1.6]], [[#Информационный граф|раздел 1.7]], [[#Ресурс параллелизма алгоритма|раздел 1.8]], [[#Свойства алгоритма|раздел 1.10]], [[#Существующие реализации алгоритма|раздел 2.7]])

= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==

Ме́тоды Ру́нге — Ку́тты (распространено неправильное название Ме́тоды Ру́нге — Ку́тта или же Ме́тоды Ру́нге — Кутта́) — важное семейство численных алгоритмов решения обыкновенных дифференциальных уравнений и их систем. Данные итеративные методы явного и неявного приближённого вычисления были разработаны около 1900 года немецкими математиками К. Рунге и М. В. Куттой.

Метод Рунге - Кутты применяется при решения задачи Коши для системы обыкновенных дифференциальных уравнений первого порядка:

:<math>
\begin{cases}
\textbf{y}' = \textbf{f}(x, \textbf{y}),\\
\textbf{y}(x_0) = \textbf{y}_0.
\end{cases}
</math>

При этом <math>\textbf{y}, \textbf{f}, x</math> отвечают следующим свойствам: <math> \textbf{y}, \textbf{f} \in \mathbb{R}^m, x \in \mathbb{R}^1 </math>.

Пусть известно значение y(x) и требуется вычислить значение y(x+h). Это можно сделать при помощи формулы:

:<math> y(x + h) = y(x) + \int_0^hy'(x + t)dt</math>

Аппроксимируя интеграл в правой части, можно получить методы Рунге-Кутты разного порядка точности. В общем виде формулы методов Рунге-Кутты можно записать следующим образом:

:<math>\textbf{y}_{n+1} = \textbf{y}_n + h\sum_{i=1}^s b_i \textbf{k}_i</math>

:<math>
\begin{array}{ll}
\textbf{k}_1 =& \textbf{f}(x_n, \textbf{y}_n),\\
\textbf{k}_2 =& \textbf{f}(x_n+c_2h, \textbf{y}_n+a_{21}h\textbf{k}_1),\\
\cdots&\\
\textbf{k}_s =& \textbf{f}(x_n+c_sh, \textbf{y}_n+a_{s1}h\textbf{k}_1+a_{s2}h\textbf{k}_2+\cdots+a_{s,s-1}h\textbf{k}_{s-1})
\end{array}
</math>

Увеличивая число s вспомогательных точек, можно построить методы Рунге-Кутты любого порядка точности p. Однако уже при p > 5 эти методы используются довольно редко. Это объясняется как чрезмерной громоздкостью получающихся вычислительных формул, так и тем, что преимущества методов высокого порядка точности над методами, в которых p = 4 или p = 5, проявляются либо в тех задачах, где нужна очень высокая точность и используются ЭВМ высокой разрядности, либо в тех задачах, где решение очень гладкое. Кроме того, методы Рунге-Кутты высокого порядка точности часто оказываются менее эффективными по сравнению с методами Адамса того же порядка точности. На этой странице представлен наиболее распространенный метод Рунге-Кутты 4 порядка с ошибкой на конечном интервале интегрирования <math>O(h^4)</math>.

Существуют как явные, так и неявные методы Рунге-Кутты. Последние имеют ряд преимуществ над явными методами, однако это достигается за счет существенного усложнения вычислительного алгоритма, так как на каждом шаге приходится считать систему нелинейных уравнений. На этой странице представлен явный метод Рунге-Кутты.

Можно отметить, что в современных программах, реализующих метод Рунге-Кутты, обязательно используется некоторый алгоритм автоматического изменения шага интегрирования. Интуитивно ясно, что на участках плавного изменения решения счет можно вести с достаточно крупным шагом. В то же время на тех участках, где происходят резкие изменения поведения решения, необходимо выбирать мелкий шаг интегрирования. Обычно начальное значение шага h1 задает пользователь. Далее шаг интегрирования меняется в соответствии с величиной получаемой в ходе вычислений оценки локальной погрешности. Для упрощения описания на этой странице используется постоянный шаг интегрирования h, зависящий от размера сетки разбиения n.

== Математическое описание алгоритма ==

Далее подразумевается, что <math> \bold y, \bold y_i,\bold f, \bold k_i \in \mathbb{R}^m</math>, а <math>x, h, n, a, b \in \mathbb{R}^1 </math>.

Исходные данные:
<math> a, b </math> - интервал интегрирования,
<math> \bold y_0 </math> - вектор значений при <math> x = a </math>,
n - количество точек в разбиении
<math>\bold f </math> - функция вычисления производной

Вычисляемые данные:
<math> \bold y_i </math> - вектора значений в узлах сетки, т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>

Формулы метода:
:Вначале вычисляется шаг сетки:
::<math> h = \frac{b-a}{n}</math>.
:Приближенное значение в следующих точках вычисляется по итерационной формуле:
::<math>\textbf{y}_{n+1} = \textbf{y}_n + {h \over 6}(\textbf{k}_1 + 2\textbf{k}_2 + 2\textbf{k}_3 + \textbf{k}_4)</math>,
::<math>\textbf{k}_1 = \textbf{f} \left( x_n, \textbf{y}_n \right),</math>
::<math>\textbf{k}_2 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_1 \right),</math>
::<math>\textbf{k}_3 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_2 \right),</math>
::<math>\textbf{k}_4 = \textbf{f} \left( x_n + h, \textbf{y}_n + h\ \textbf{k}_3 \right),</math>
::<math>x_{n+1} = x_n + h.</math>

== Вычислительное ядро алгоритма ==

Вычислительным ядром метода Рунге-Кутты можно считать вычисление значений функции производной
:<math>\textbf{f}(x, \textbf{y})</math>,
так как при вычислении каждого нового <math>\textbf{y}_n</math> требуется 4 вычисления значения функции производной. Таким образом, сложность работы алгоритма существенно зависит от сложности вычисления функции <math>\textbf{f}</math>.

== Макроструктура алгоритма ==

Макроструктура алгоритма может быть представлена в следующем виде:
:Вычисление вспомогательных коэффициентов <math>\textbf{k}_j, j \in [1,4]</math>;
:Вычисление приближенного значения <math> \bold y_i </math> в следующей точке;
:Переход на следующую итерацию или остановка.

== Схема реализации последовательного алгоритма ==

Пример реализации последовательного алгоритма на языке C++ (указатель на функцию f передаётся через аргументы представленной ниже функции):
<source lang="c++" line="1">
#include <vector>

// other code ...

std::vector<double> rungekutta4(double a, double b, std::vector<double> y0, int n, std::vector<double (*)(double,double)> f)
{
std::vector<double>::size_type sz = y0.size();
std::vector<double> result;
for (unsigned j=0; j<sz; j++)
{
rezult.push_back(core(a,b,y[j],n,f[j]));
}
return result;
}

double core(double a, double b, double y0, int n, double (*f)(double,double))
{
double h, k1, k2, k3, k4, x, y;
h = (b - a)/n;
y = y0;
x = a;
for (unsigned i = 0; i < n; i++)
{
k1 = f(x, y);
k2 = f(x + h/2, y + h*k1/2);
k3 = f(x + h/2, y + h*k2/2);
k4 = f(x + h/2, y + h*k3);
x += h;
y += h*(k1 + 2*k2 + 2*k3 + k4)/6;
}
return y;
}

// other code ...
</source>

== Последовательная сложность алгоритма ==

Рассмотрим сначала одномерный случай. Наравне с обычными операциями, такими как сложение, умножение и тому подобными, в представленном выше алгоритме присутствует вызов функции <math>\bold f </math>. Так как эта функция может содержать в себе любое количество простых математических операций, будем считать, что её сложность <math>\bold f </math> много больше любой из них, и равна константе <math>C</math>. За весь алгоритм, она вызывается <math>4n</math> раза. Таким образом, сложность последовательного алгоритма для одномерного случая равна <math>4nC</math>.

Для случая решения системы ОДУ, когда <math>f</math> и <math>y</math> являются векторами размерности <math>m</math>, функция core будет вызвана <math>m</math>, и итоговая сложность алгоритма составит <math>4nCm</math>.

== Информационный граф ==

Информационная структура параллельного алгоритма Рунге-Кутты 4-го порядка представляет собой матрицу изображённую на рисунке ниже. Вдоль оси <math>j</math> располагаются <math>j</math>-ые параметры вектора <math>y</math>, соответственно, вдоль <math>i</math> изображены этапы вычисления <math>y_i</math> значения j-параметра вектора <math>y</math>. Таким образом, можно сказать, что вдоль оси <math>j</math>, изображены параллельные процессы. А ось <math>i</math> представляет собой шкалу времени. Чтобы соотнести её с реальным временем, надо просто посчитать сумму <math>\sum_{i=1}^{n} t_i</math>, где <math>t_i</math> - время с момента начала вычисления <math>i</math>-го всеми процессами до момента его завершения всеми процессами.

[[Файл:system_graph.jpg]]

Можно заметить, что на каждом <math>i</math>-ом шаге происходит обмен информацией между процессами. Это выражено в виде линии пересекающей все <math>j</math>-ые процессы на любом <math>i</math>-ом шаге.

== Ресурс параллелизма алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является итерационным алгоритмом. В нём каждый шаг цикла зависит от предыдущего. В самом шаге, каждая последующая операция также зависит от результата предыдущей. Таким образом, упразднить цикл до независимых и соответственно параллельных операций не является возможным. Однако, так как на результат функции <math> \bold f </math> влияет только <math>i</math>-ый параметр векторов <math> f </math> и <math> y </math>, то для каждого <math> i </math> можно производить независимое вычисление. В итоге, если вычислять результаты выполнения функции <math> \bold f </math> одновременно для вля всех <math> i</math>-ых параметров векторов <math> f </math> и <math> y </math>, получим туже алгоритмическую сложность <math>4nC</math>, что и в [[#Последовательная сложность алгоритма|разделе 1.6]] для одномерного случая.

== Входные и выходные данные алгоритма ==

'''Входные данные''':
<math> a, b </math> - интервал интегрирования,
n - количество точек в разбиении,
<math> \bold y_0 </math> - вектор значений размерности m при <math> x = a </math>,
функцию вычисления производной <math>\bold f </math> будем считать встроенной в алгоритм.

'''Объём входных данных''':
m + 3

'''Выходные данные:'''
<math> \bold y_i </math> - вектора размера m значений в n узлах сетки (т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>).

'''Объем выходных данных'''
n * m

== Свойства алгоритма ==

Алгоритм обладает следующими свойствами:

* Точность. Как написано в [[#Общее описание алгоритма| разделе 1.1]], алгоритм имеет порядок точности <math>O(h^4)</math>.
* Устойчивость. Алгоритм устойчив на любом конечном отрезке.
* Гибкость. На любом этапе вычисления можно легко изменить шаг интегрирования.

= ЧАСТЬ. Программная реализация алгоритма =

== [[Особенности реализации последовательного алгоритма]] ==

== [[Локальность данных и вычислений]] ==

== [[Возможные способы и особенности параллельной реализации алгоритма]] ==

== Масштабируемость алгоритма и его реализации ==

== [[Динамические характеристики и эффективность реализации алгоритма]] ==

== [[Выводы для классов архитектур]] ==

== Существующие реализации алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является одним из наиболее используемых для решения ОДУ и их систем, поэтому существует большое число его реализаций для разных языков программирования. Наиболее популярными являются следующие из них:
* библиотека RK4, которая существует в вариантах для C++, FORTRAN90, FORTRAN77, python и MATLAB;
* библиотека ode45 для MATLAB;
* модуль scipy для PYTHON.

= Литература =

Участник:Борис/Алгоритм Рунге-Кутты

2016-10-15T20:59:40Z

Борис: /* Информационный граф */

{{algorithm
| name = Метод Рунге-Кутты 4 порядка
| serial_complexity = <math>O()</math>
| pf_height = <math>O()</math>
| pf_width = <math>O()</math>
| input_data = <math>m + 3</math>
| output_data = <math>m * n</math>
}}

Основные авторы описания: [[Участник:Jest|Е.П.Степанов]]([[#Общее описание алгоритма|раздел 1.1]], [[#Математическое описание алгоритма|раздел 1.2]], [[#Вычислительное ядро алгоритма|раздел 1.3]], [[#Макроструктура алгоритма|раздел 1.4]], [[#Входные и выходные данные алгоритма|раздел 1.9]]), [[Участник:Борис|Б.Савков]] ( [[#Схема реализации последовательного алгоритма|раздел 1.5]], [[#Последовательная сложность алгоритма|раздел 1.6]], [[#Информационный граф|раздел 1.7]], [[#Ресурс параллелизма алгоритма|раздел 1.8]], [[#Свойства алгоритма|раздел 1.10]], [[#Существующие реализации алгоритма|раздел 2.7]])

= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==

Ме́тоды Ру́нге — Ку́тты (распространено неправильное название Ме́тоды Ру́нге — Ку́тта или же Ме́тоды Ру́нге — Кутта́) — важное семейство численных алгоритмов решения обыкновенных дифференциальных уравнений и их систем. Данные итеративные методы явного и неявного приближённого вычисления были разработаны около 1900 года немецкими математиками К. Рунге и М. В. Куттой.

Метод Рунге - Кутты применяется при решения задачи Коши для системы обыкновенных дифференциальных уравнений первого порядка:

:<math>
\begin{cases}
\textbf{y}' = \textbf{f}(x, \textbf{y}),\\
\textbf{y}(x_0) = \textbf{y}_0.
\end{cases}
</math>

При этом <math>\textbf{y}, \textbf{f}, x</math> отвечают следующим свойствам: <math> \textbf{y}, \textbf{f} \in \mathbb{R}^m, x \in \mathbb{R}^1 </math>.

Пусть известно значение y(x) и требуется вычислить значение y(x+h). Это можно сделать при помощи формулы:

:<math> y(x + h) = y(x) + \int_0^hy'(x + t)dt</math>

Аппроксимируя интеграл в правой части, можно получить методы Рунге-Кутты разного порядка точности. В общем виде формулы методов Рунге-Кутты можно записать следующим образом:

:<math>\textbf{y}_{n+1} = \textbf{y}_n + h\sum_{i=1}^s b_i \textbf{k}_i</math>

:<math>
\begin{array}{ll}
\textbf{k}_1 =& \textbf{f}(x_n, \textbf{y}_n),\\
\textbf{k}_2 =& \textbf{f}(x_n+c_2h, \textbf{y}_n+a_{21}h\textbf{k}_1),\\
\cdots&\\
\textbf{k}_s =& \textbf{f}(x_n+c_sh, \textbf{y}_n+a_{s1}h\textbf{k}_1+a_{s2}h\textbf{k}_2+\cdots+a_{s,s-1}h\textbf{k}_{s-1})
\end{array}
</math>

Увеличивая число s вспомогательных точек, можно построить методы Рунге-Кутты любого порядка точности p. Однако уже при p > 5 эти методы используются довольно редко. Это объясняется как чрезмерной громоздкостью получающихся вычислительных формул, так и тем, что преимущества методов высокого порядка точности над методами, в которых p = 4 или p = 5, проявляются либо в тех задачах, где нужна очень высокая точность и используются ЭВМ высокой разрядности, либо в тех задачах, где решение очень гладкое. Кроме того, методы Рунге-Кутты высокого порядка точности часто оказываются менее эффективными по сравнению с методами Адамса того же порядка точности. На этой странице представлен наиболее распространенный метод Рунге-Кутты 4 порядка с ошибкой на конечном интервале интегрирования <math>O(h^4)</math>.

Существуют как явные, так и неявные методы Рунге-Кутты. Последние имеют ряд преимуществ над явными методами, однако это достигается за счет существенного усложнения вычислительного алгоритма, так как на каждом шаге приходится считать систему нелинейных уравнений. На этой странице представлен явный метод Рунге-Кутты.

Можно отметить, что в современных программах, реализующих метод Рунге-Кутты, обязательно используется некоторый алгоритм автоматического изменения шага интегрирования. Интуитивно ясно, что на участках плавного изменения решения счет можно вести с достаточно крупным шагом. В то же время на тех участках, где происходят резкие изменения поведения решения, необходимо выбирать мелкий шаг интегрирования. Обычно начальное значение шага h1 задает пользователь. Далее шаг интегрирования меняется в соответствии с величиной получаемой в ходе вычислений оценки локальной погрешности. Для упрощения описания на этой странице используется постоянный шаг интегрирования h, зависящий от размера сетки разбиения n.

== Математическое описание алгоритма ==

Далее подразумевается, что <math> \bold y, \bold y_i,\bold f, \bold k_i \in \mathbb{R}^m</math>, а <math>x, h, n, a, b \in \mathbb{R}^1 </math>.

Исходные данные:
<math> a, b </math> - интервал интегрирования,
<math> \bold y_0 </math> - вектор значений при <math> x = a </math>,
n - количество точек в разбиении
<math>\bold f </math> - функция вычисления производной

Вычисляемые данные:
<math> \bold y_i </math> - вектора значений в узлах сетки, т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>

Формулы метода:
:Вначале вычисляется шаг сетки:
::<math> h = \frac{b-a}{n}</math>.
:Приближенное значение в следующих точках вычисляется по итерационной формуле:
::<math>\textbf{y}_{n+1} = \textbf{y}_n + {h \over 6}(\textbf{k}_1 + 2\textbf{k}_2 + 2\textbf{k}_3 + \textbf{k}_4)</math>,
::<math>\textbf{k}_1 = \textbf{f} \left( x_n, \textbf{y}_n \right),</math>
::<math>\textbf{k}_2 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_1 \right),</math>
::<math>\textbf{k}_3 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_2 \right),</math>
::<math>\textbf{k}_4 = \textbf{f} \left( x_n + h, \textbf{y}_n + h\ \textbf{k}_3 \right),</math>
::<math>x_{n+1} = x_n + h.</math>

== Вычислительное ядро алгоритма ==

Вычислительным ядром метода Рунге-Кутты можно считать вычисление значений функции производной
:<math>\textbf{f}(x, \textbf{y})</math>,
так как при вычислении каждого нового <math>\textbf{y}_n</math> требуется 4 вычисления значения функции производной. Таким образом, сложность работы алгоритма существенно зависит от сложности вычисления функции <math>\textbf{f}</math>.

== Макроструктура алгоритма ==

Макроструктура алгоритма может быть представлена в следующем виде:
:Вычисление вспомогательных коэффициентов <math>\textbf{k}_j, j \in [1,4]</math>;
:Вычисление приближенного значения <math> \bold y_i </math> в следующей точке;
:Переход на следующую итерацию или остановка.

== Схема реализации последовательного алгоритма ==

Пример реализации последовательного алгоритма на языке C++ (указатель на функцию f передаётся через аргументы представленной ниже функции):
<source lang="c++" line="1">
#include <vector>

// other code ...

std::vector<double> rungekutta4(double a, double b, std::vector<double> y0, int n, std::vector<double (*)(double,double)> f)
{
std::vector<double>::size_type sz = y0.size();
std::vector<double> result;
for (unsigned j=0; j<sz; j++)
{
rezult.push_back(core(a,b,y[j],n,f[j]));
}
return result;
}

double core(double a, double b, double y0, int n, double (*f)(double,double))
{
double h, k1, k2, k3, k4, x, y;
h = (b - a)/n;
y = y0;
x = a;
for (unsigned i = 0; i < n; i++)
{
k1 = f(x, y);
k2 = f(x + h/2, y + h*k1/2);
k3 = f(x + h/2, y + h*k2/2);
k4 = f(x + h/2, y + h*k3);
x += h;
y += h*(k1 + 2*k2 + 2*k3 + k4)/6;
}
return y;
}

// other code ...
</source>

== Последовательная сложность алгоритма ==

Рассмотрим сначала одномерный случай. Наравне с обычными операциями, такими как сложение, умножение и тому подобными, в представленном выше алгоритме присутствует вызов функции <math>\bold f </math>. Так как эта функция может содержать в себе любое количество простых математических операций, будем считать, что её сложность <math>\bold f </math> много больше любой из них, и равна константе <math>C</math>. За весь алгоритм, она вызывается <math>4n</math> раза. Таким образом, сложность последовательного алгоритма для одномерного случая равна <math>4nC</math>.

Для случая решения системы ОДУ, когда <math>f</math> и <math>y</math> являются векторами размерности <math>m</math>, функция core будет вызвана <math>m</math>, и итоговая сложность алгоритма составит <math>4nCm</math>.

== Информационный граф ==

Информационная структура параллельного алгоритма Рунге-Кутты 4-го порядка представляет собой матрицу изображённую на рисунке ниже. Вдоль оси <math>j</math> располагаются <math>j</math>-ые параметры вектора <math>y</math>, соответственно, вдоль <math>i</math> изображены этапы вычисления <math>y_i</math> значения j-параметра вектора <math>y</math>. Таким образом, можно сказать, что вдоль оси <math>j</math>, изображены параллельные процессы. А ось <math>i</math> представляет собой шкалу времени. Чтобы соотнести её с реальным временем, надо просто посчитать сумму <math>\sum_{i=1}^{n} t_i</math>, где <math>t_i</math> - время с момента начала вычисления <math>i</math>-го всеми процессами до момента его завершения всеми процессами.

[[Файл:system_graph.jpg]]

Можно заметить, что на каждом <math>i</math>-ом шаге происходит обмен информацией между процессами. Это выражено в виде линии пересекающей все <math>j</math>-ые процессы на любом <math>i</math>-ом шаге.

== Ресурс параллелизма алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является итерационным алгоритмом. В нём каждый шаг цикла зависит от предыдущего. В самом шаге, каждая последующая операция также зависит от результата предыдущей. Таким образом, упразднить цикл до независимых и соответственно параллельных операций не является возможным. Однако, так как на результат функции <math> \bold f </math> влияет только <math>i</math>-ый параметр векторов <math> f </math> и <math> y </math>, то для каждого <math> i </math> можно производить независимое вычисление. В итоге, если вычислять результаты выполнения функции <math> \bold f </math> одновременно для вля всех <math> i</math>-ых параметров векторов <math> f </math> и <math> y </math>, получим туже алгоритмическую сложность <math>4nC</math>, что и в [[#Последовательная сложность алгоритма|разделе 1.6]] для одномерного случая.

== Входные и выходные данные алгоритма ==

'''Входные данные''':
<math> a, b </math> - интервал интегрирования,
n - количество точек в разбиении,
<math> \bold y_0 </math> - вектор значений размерности m при <math> x = a </math>,
функцию вычисления производной <math>\bold f </math> будем считать встроенной в алгоритм.

'''Объём входных данных''':
m + 3

'''Выходные данные:'''
<math> \bold y_i </math> - вектора размера m значений в n узлах сетки (т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>).

'''Объем выходных данных'''
n * m

== Свойства алгоритма ==

Алгоритм обладает следующими свойствами:

* Точность. Как написано в [[#Общее описание алгоритма| разделе 1.1]], алгоритм имеет порядок точности <math>O(h^4)</math>.
* Устойчивость. Алгоритм устойчив на любом конечном отрезке.
* Гибкость. На любом этапе вычисления можно легко изменить шаг интегрирования.

= ЧАСТЬ. Программная реализация алгоритма =

== [[Особенности реализации последовательного алгоритма]] ==

== [[Локальность данных и вычислений]] ==

== [[Возможные способы и особенности параллельной реализации алгоритма]] ==

== Масштабируемость алгоритма и его реализации ==

== [[Динамические характеристики и эффективность реализации алгоритма]] ==

== [[Выводы для классов архитектур]] ==

== Существующие реализации алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является одним из наиболее используемых для решения ОДУ и их систем, поэтому существует большое число его реализаций для разных языков программирования. Наиболее популярными являются следующие из них:
* библиотека RK4, которая существует в вариантах для C++, FORTRAN90, FORTRAN77, python и MATLAB;
* библиотека ode45 для MATLAB;
* модуль scipy для PYTHON.

= Литература =

Участник:Борис/Алгоритм Рунге-Кутты

2016-10-15T20:55:45Z

Борис: /* Информационный граф */

{{algorithm
| name = Метод Рунге-Кутты 4 порядка
| serial_complexity = <math>O()</math>
| pf_height = <math>O()</math>
| pf_width = <math>O()</math>
| input_data = <math>m + 3</math>
| output_data = <math>m * n</math>
}}

Основные авторы описания: [[Участник:Jest|Е.П.Степанов]]([[#Общее описание алгоритма|раздел 1.1]], [[#Математическое описание алгоритма|раздел 1.2]], [[#Вычислительное ядро алгоритма|раздел 1.3]], [[#Макроструктура алгоритма|раздел 1.4]], [[#Входные и выходные данные алгоритма|раздел 1.9]]), [[Участник:Борис|Б.Савков]] ( [[#Схема реализации последовательного алгоритма|раздел 1.5]], [[#Последовательная сложность алгоритма|раздел 1.6]], [[#Информационный граф|раздел 1.7]], [[#Ресурс параллелизма алгоритма|раздел 1.8]], [[#Свойства алгоритма|раздел 1.10]], [[#Существующие реализации алгоритма|раздел 2.7]])

= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==

Ме́тоды Ру́нге — Ку́тты (распространено неправильное название Ме́тоды Ру́нге — Ку́тта или же Ме́тоды Ру́нге — Кутта́) — важное семейство численных алгоритмов решения обыкновенных дифференциальных уравнений и их систем. Данные итеративные методы явного и неявного приближённого вычисления были разработаны около 1900 года немецкими математиками К. Рунге и М. В. Куттой.

Метод Рунге - Кутты применяется при решения задачи Коши для системы обыкновенных дифференциальных уравнений первого порядка:

:<math>
\begin{cases}
\textbf{y}' = \textbf{f}(x, \textbf{y}),\\
\textbf{y}(x_0) = \textbf{y}_0.
\end{cases}
</math>

При этом <math>\textbf{y}, \textbf{f}, x</math> отвечают следующим свойствам: <math> \textbf{y}, \textbf{f} \in \mathbb{R}^m, x \in \mathbb{R}^1 </math>.

Пусть известно значение y(x) и требуется вычислить значение y(x+h). Это можно сделать при помощи формулы:

:<math> y(x + h) = y(x) + \int_0^hy'(x + t)dt</math>

Аппроксимируя интеграл в правой части, можно получить методы Рунге-Кутты разного порядка точности. В общем виде формулы методов Рунге-Кутты можно записать следующим образом:

:<math>\textbf{y}_{n+1} = \textbf{y}_n + h\sum_{i=1}^s b_i \textbf{k}_i</math>

:<math>
\begin{array}{ll}
\textbf{k}_1 =& \textbf{f}(x_n, \textbf{y}_n),\\
\textbf{k}_2 =& \textbf{f}(x_n+c_2h, \textbf{y}_n+a_{21}h\textbf{k}_1),\\
\cdots&\\
\textbf{k}_s =& \textbf{f}(x_n+c_sh, \textbf{y}_n+a_{s1}h\textbf{k}_1+a_{s2}h\textbf{k}_2+\cdots+a_{s,s-1}h\textbf{k}_{s-1})
\end{array}
</math>

Увеличивая число s вспомогательных точек, можно построить методы Рунге-Кутты любого порядка точности p. Однако уже при p > 5 эти методы используются довольно редко. Это объясняется как чрезмерной громоздкостью получающихся вычислительных формул, так и тем, что преимущества методов высокого порядка точности над методами, в которых p = 4 или p = 5, проявляются либо в тех задачах, где нужна очень высокая точность и используются ЭВМ высокой разрядности, либо в тех задачах, где решение очень гладкое. Кроме того, методы Рунге-Кутты высокого порядка точности часто оказываются менее эффективными по сравнению с методами Адамса того же порядка точности. На этой странице представлен наиболее распространенный метод Рунге-Кутты 4 порядка с ошибкой на конечном интервале интегрирования <math>O(h^4)</math>.

Существуют как явные, так и неявные методы Рунге-Кутты. Последние имеют ряд преимуществ над явными методами, однако это достигается за счет существенного усложнения вычислительного алгоритма, так как на каждом шаге приходится считать систему нелинейных уравнений. На этой странице представлен явный метод Рунге-Кутты.

Можно отметить, что в современных программах, реализующих метод Рунге-Кутты, обязательно используется некоторый алгоритм автоматического изменения шага интегрирования. Интуитивно ясно, что на участках плавного изменения решения счет можно вести с достаточно крупным шагом. В то же время на тех участках, где происходят резкие изменения поведения решения, необходимо выбирать мелкий шаг интегрирования. Обычно начальное значение шага h1 задает пользователь. Далее шаг интегрирования меняется в соответствии с величиной получаемой в ходе вычислений оценки локальной погрешности. Для упрощения описания на этой странице используется постоянный шаг интегрирования h, зависящий от размера сетки разбиения n.

== Математическое описание алгоритма ==

Далее подразумевается, что <math> \bold y, \bold y_i,\bold f, \bold k_i \in \mathbb{R}^m</math>, а <math>x, h, n, a, b \in \mathbb{R}^1 </math>.

Исходные данные:
<math> a, b </math> - интервал интегрирования,
<math> \bold y_0 </math> - вектор значений при <math> x = a </math>,
n - количество точек в разбиении
<math>\bold f </math> - функция вычисления производной

Вычисляемые данные:
<math> \bold y_i </math> - вектора значений в узлах сетки, т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>

Формулы метода:
:Вначале вычисляется шаг сетки:
::<math> h = \frac{b-a}{n}</math>.
:Приближенное значение в следующих точках вычисляется по итерационной формуле:
::<math>\textbf{y}_{n+1} = \textbf{y}_n + {h \over 6}(\textbf{k}_1 + 2\textbf{k}_2 + 2\textbf{k}_3 + \textbf{k}_4)</math>,
::<math>\textbf{k}_1 = \textbf{f} \left( x_n, \textbf{y}_n \right),</math>
::<math>\textbf{k}_2 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_1 \right),</math>
::<math>\textbf{k}_3 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_2 \right),</math>
::<math>\textbf{k}_4 = \textbf{f} \left( x_n + h, \textbf{y}_n + h\ \textbf{k}_3 \right),</math>
::<math>x_{n+1} = x_n + h.</math>

== Вычислительное ядро алгоритма ==

Вычислительным ядром метода Рунге-Кутты можно считать вычисление значений функции производной
:<math>\textbf{f}(x, \textbf{y})</math>,
так как при вычислении каждого нового <math>\textbf{y}_n</math> требуется 4 вычисления значения функции производной. Таким образом, сложность работы алгоритма существенно зависит от сложности вычисления функции <math>\textbf{f}</math>.

== Макроструктура алгоритма ==

Макроструктура алгоритма может быть представлена в следующем виде:
:Вычисление вспомогательных коэффициентов <math>\textbf{k}_j, j \in [1,4]</math>;
:Вычисление приближенного значения <math> \bold y_i </math> в следующей точке;
:Переход на следующую итерацию или остановка.

== Схема реализации последовательного алгоритма ==

Пример реализации последовательного алгоритма на языке C++ (указатель на функцию f передаётся через аргументы представленной ниже функции):
<source lang="c++" line="1">
#include <vector>

// other code ...

std::vector<double> rungekutta4(double a, double b, std::vector<double> y0, int n, std::vector<double (*)(double,double)> f)
{
std::vector<double>::size_type sz = y0.size();
std::vector<double> result;
for (unsigned j=0; j<sz; j++)
{
rezult.push_back(core(a,b,y[j],n,f[j]));
}
return result;
}

double core(double a, double b, double y0, int n, double (*f)(double,double))
{
double h, k1, k2, k3, k4, x, y;
h = (b - a)/n;
y = y0;
x = a;
for (unsigned i = 0; i < n; i++)
{
k1 = f(x, y);
k2 = f(x + h/2, y + h*k1/2);
k3 = f(x + h/2, y + h*k2/2);
k4 = f(x + h/2, y + h*k3);
x += h;
y += h*(k1 + 2*k2 + 2*k3 + k4)/6;
}
return y;
}

// other code ...
</source>

== Последовательная сложность алгоритма ==

Рассмотрим сначала одномерный случай. Наравне с обычными операциями, такими как сложение, умножение и тому подобными, в представленном выше алгоритме присутствует вызов функции <math>\bold f </math>. Так как эта функция может содержать в себе любое количество простых математических операций, будем считать, что её сложность <math>\bold f </math> много больше любой из них, и равна константе <math>C</math>. За весь алгоритм, она вызывается <math>4n</math> раза. Таким образом, сложность последовательного алгоритма для одномерного случая равна <math>4nC</math>.

Для случая решения системы ОДУ, когда <math>f</math> и <math>y</math> являются векторами размерности <math>m</math>, функция core будет вызвана <math>m</math>, и итоговая сложность алгоритма составит <math>4nCm</math>.

== Информационный граф ==

Информационная структура параллельного алгоритма Рунге-Кутты 4-го порядка представляет собой матрицу изображённую на рисунке ниже. Вдоль оси <math>j</math> располагаются <math>j</math>-ые параметры вектора <math>y</math>, соответственно, вдоль <math>i</math> изображены этапы вычисления <math>y_i</math> значения j-параметра вектора <math>y</math>. Таким образом, можно сказать, что вдоль оси <math>j</math>, изображены параллельные процессы. А ось <math>i</math> представляет собой шкалу времени. Чтобы соотнести её с реальным временем, надо просто посчитать сумму, где <math>t_i</math> - время с момента начала вычисления <math>i</math>-го всеми процессами до момента его завершения всеми процессами.

[[Файл:system_graph.jpg]]

Можно заметить, что на каждом <math>i</math>-ом шаге происходит обмен информацией между процессами. Это выражено в виде линии пересекающей все <math>j</math>-ые процессы на любом <math>i</math>-ом шаге.

== Ресурс параллелизма алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является итерационным алгоритмом. В нём каждый шаг цикла зависит от предыдущего. В самом шаге, каждая последующая операция также зависит от результата предыдущей. Таким образом, упразднить цикл до независимых и соответственно параллельных операций не является возможным. Однако, так как на результат функции <math> \bold f </math> влияет только <math>i</math>-ый параметр векторов <math> f </math> и <math> y </math>, то для каждого <math> i </math> можно производить независимое вычисление. В итоге, если вычислять результаты выполнения функции <math> \bold f </math> одновременно для вля всех <math> i</math>-ых параметров векторов <math> f </math> и <math> y </math>, получим туже алгоритмическую сложность <math>4nC</math>, что и в [[#Последовательная сложность алгоритма|разделе 1.6]] для одномерного случая.

== Входные и выходные данные алгоритма ==

'''Входные данные''':
<math> a, b </math> - интервал интегрирования,
n - количество точек в разбиении,
<math> \bold y_0 </math> - вектор значений размерности m при <math> x = a </math>,
функцию вычисления производной <math>\bold f </math> будем считать встроенной в алгоритм.

'''Объём входных данных''':
m + 3

'''Выходные данные:'''
<math> \bold y_i </math> - вектора размера m значений в n узлах сетки (т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>).

'''Объем выходных данных'''
n * m

== Свойства алгоритма ==

Алгоритм обладает следующими свойствами:

* Точность. Как написано в [[#Общее описание алгоритма| разделе 1.1]], алгоритм имеет порядок точности <math>O(h^4)</math>.
* Устойчивость. Алгоритм устойчив на любом конечном отрезке.
* Гибкость. На любом этапе вычисления можно легко изменить шаг интегрирования.

= ЧАСТЬ. Программная реализация алгоритма =

== [[Особенности реализации последовательного алгоритма]] ==

== [[Локальность данных и вычислений]] ==

== [[Возможные способы и особенности параллельной реализации алгоритма]] ==

== Масштабируемость алгоритма и его реализации ==

== [[Динамические характеристики и эффективность реализации алгоритма]] ==

== [[Выводы для классов архитектур]] ==

== Существующие реализации алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является одним из наиболее используемых для решения ОДУ и их систем, поэтому существует большое число его реализаций для разных языков программирования. Наиболее популярными являются следующие из них:
* библиотека RK4, которая существует в вариантах для C++, FORTRAN90, FORTRAN77, python и MATLAB;
* библиотека ode45 для MATLAB;
* модуль scipy для PYTHON.

= Литература =

Участник:Борис/Алгоритм Рунге-Кутты

2016-10-15T20:54:45Z

Борис: /* Информационный граф */

{{algorithm
| name = Метод Рунге-Кутты 4 порядка
| serial_complexity = <math>O()</math>
| pf_height = <math>O()</math>
| pf_width = <math>O()</math>
| input_data = <math>m + 3</math>
| output_data = <math>m * n</math>
}}

Основные авторы описания: [[Участник:Jest|Е.П.Степанов]]([[#Общее описание алгоритма|раздел 1.1]], [[#Математическое описание алгоритма|раздел 1.2]], [[#Вычислительное ядро алгоритма|раздел 1.3]], [[#Макроструктура алгоритма|раздел 1.4]], [[#Входные и выходные данные алгоритма|раздел 1.9]]), [[Участник:Борис|Б.Савков]] ( [[#Схема реализации последовательного алгоритма|раздел 1.5]], [[#Последовательная сложность алгоритма|раздел 1.6]], [[#Информационный граф|раздел 1.7]], [[#Ресурс параллелизма алгоритма|раздел 1.8]], [[#Свойства алгоритма|раздел 1.10]], [[#Существующие реализации алгоритма|раздел 2.7]])

= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==

Ме́тоды Ру́нге — Ку́тты (распространено неправильное название Ме́тоды Ру́нге — Ку́тта или же Ме́тоды Ру́нге — Кутта́) — важное семейство численных алгоритмов решения обыкновенных дифференциальных уравнений и их систем. Данные итеративные методы явного и неявного приближённого вычисления были разработаны около 1900 года немецкими математиками К. Рунге и М. В. Куттой.

Метод Рунге - Кутты применяется при решения задачи Коши для системы обыкновенных дифференциальных уравнений первого порядка:

:<math>
\begin{cases}
\textbf{y}' = \textbf{f}(x, \textbf{y}),\\
\textbf{y}(x_0) = \textbf{y}_0.
\end{cases}
</math>

При этом <math>\textbf{y}, \textbf{f}, x</math> отвечают следующим свойствам: <math> \textbf{y}, \textbf{f} \in \mathbb{R}^m, x \in \mathbb{R}^1 </math>.

Пусть известно значение y(x) и требуется вычислить значение y(x+h). Это можно сделать при помощи формулы:

:<math> y(x + h) = y(x) + \int_0^hy'(x + t)dt</math>

Аппроксимируя интеграл в правой части, можно получить методы Рунге-Кутты разного порядка точности. В общем виде формулы методов Рунге-Кутты можно записать следующим образом:

:<math>\textbf{y}_{n+1} = \textbf{y}_n + h\sum_{i=1}^s b_i \textbf{k}_i</math>

:<math>
\begin{array}{ll}
\textbf{k}_1 =& \textbf{f}(x_n, \textbf{y}_n),\\
\textbf{k}_2 =& \textbf{f}(x_n+c_2h, \textbf{y}_n+a_{21}h\textbf{k}_1),\\
\cdots&\\
\textbf{k}_s =& \textbf{f}(x_n+c_sh, \textbf{y}_n+a_{s1}h\textbf{k}_1+a_{s2}h\textbf{k}_2+\cdots+a_{s,s-1}h\textbf{k}_{s-1})
\end{array}
</math>

Увеличивая число s вспомогательных точек, можно построить методы Рунге-Кутты любого порядка точности p. Однако уже при p > 5 эти методы используются довольно редко. Это объясняется как чрезмерной громоздкостью получающихся вычислительных формул, так и тем, что преимущества методов высокого порядка точности над методами, в которых p = 4 или p = 5, проявляются либо в тех задачах, где нужна очень высокая точность и используются ЭВМ высокой разрядности, либо в тех задачах, где решение очень гладкое. Кроме того, методы Рунге-Кутты высокого порядка точности часто оказываются менее эффективными по сравнению с методами Адамса того же порядка точности. На этой странице представлен наиболее распространенный метод Рунге-Кутты 4 порядка с ошибкой на конечном интервале интегрирования <math>O(h^4)</math>.

Существуют как явные, так и неявные методы Рунге-Кутты. Последние имеют ряд преимуществ над явными методами, однако это достигается за счет существенного усложнения вычислительного алгоритма, так как на каждом шаге приходится считать систему нелинейных уравнений. На этой странице представлен явный метод Рунге-Кутты.

Можно отметить, что в современных программах, реализующих метод Рунге-Кутты, обязательно используется некоторый алгоритм автоматического изменения шага интегрирования. Интуитивно ясно, что на участках плавного изменения решения счет можно вести с достаточно крупным шагом. В то же время на тех участках, где происходят резкие изменения поведения решения, необходимо выбирать мелкий шаг интегрирования. Обычно начальное значение шага h1 задает пользователь. Далее шаг интегрирования меняется в соответствии с величиной получаемой в ходе вычислений оценки локальной погрешности. Для упрощения описания на этой странице используется постоянный шаг интегрирования h, зависящий от размера сетки разбиения n.

== Математическое описание алгоритма ==

Далее подразумевается, что <math> \bold y, \bold y_i,\bold f, \bold k_i \in \mathbb{R}^m</math>, а <math>x, h, n, a, b \in \mathbb{R}^1 </math>.

Исходные данные:
<math> a, b </math> - интервал интегрирования,
<math> \bold y_0 </math> - вектор значений при <math> x = a </math>,
n - количество точек в разбиении
<math>\bold f </math> - функция вычисления производной

Вычисляемые данные:
<math> \bold y_i </math> - вектора значений в узлах сетки, т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>

Формулы метода:
:Вначале вычисляется шаг сетки:
::<math> h = \frac{b-a}{n}</math>.
:Приближенное значение в следующих точках вычисляется по итерационной формуле:
::<math>\textbf{y}_{n+1} = \textbf{y}_n + {h \over 6}(\textbf{k}_1 + 2\textbf{k}_2 + 2\textbf{k}_3 + \textbf{k}_4)</math>,
::<math>\textbf{k}_1 = \textbf{f} \left( x_n, \textbf{y}_n \right),</math>
::<math>\textbf{k}_2 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_1 \right),</math>
::<math>\textbf{k}_3 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_2 \right),</math>
::<math>\textbf{k}_4 = \textbf{f} \left( x_n + h, \textbf{y}_n + h\ \textbf{k}_3 \right),</math>
::<math>x_{n+1} = x_n + h.</math>

== Вычислительное ядро алгоритма ==

Вычислительным ядром метода Рунге-Кутты можно считать вычисление значений функции производной
:<math>\textbf{f}(x, \textbf{y})</math>,
так как при вычислении каждого нового <math>\textbf{y}_n</math> требуется 4 вычисления значения функции производной. Таким образом, сложность работы алгоритма существенно зависит от сложности вычисления функции <math>\textbf{f}</math>.

== Макроструктура алгоритма ==

Макроструктура алгоритма может быть представлена в следующем виде:
:Вычисление вспомогательных коэффициентов <math>\textbf{k}_j, j \in [1,4]</math>;
:Вычисление приближенного значения <math> \bold y_i </math> в следующей точке;
:Переход на следующую итерацию или остановка.

== Схема реализации последовательного алгоритма ==

Пример реализации последовательного алгоритма на языке C++ (указатель на функцию f передаётся через аргументы представленной ниже функции):
<source lang="c++" line="1">
#include <vector>

// other code ...

std::vector<double> rungekutta4(double a, double b, std::vector<double> y0, int n, std::vector<double (*)(double,double)> f)
{
std::vector<double>::size_type sz = y0.size();
std::vector<double> result;
for (unsigned j=0; j<sz; j++)
{
rezult.push_back(core(a,b,y[j],n,f[j]));
}
return result;
}

double core(double a, double b, double y0, int n, double (*f)(double,double))
{
double h, k1, k2, k3, k4, x, y;
h = (b - a)/n;
y = y0;
x = a;
for (unsigned i = 0; i < n; i++)
{
k1 = f(x, y);
k2 = f(x + h/2, y + h*k1/2);
k3 = f(x + h/2, y + h*k2/2);
k4 = f(x + h/2, y + h*k3);
x += h;
y += h*(k1 + 2*k2 + 2*k3 + k4)/6;
}
return y;
}

// other code ...
</source>

== Последовательная сложность алгоритма ==

Рассмотрим сначала одномерный случай. Наравне с обычными операциями, такими как сложение, умножение и тому подобными, в представленном выше алгоритме присутствует вызов функции <math>\bold f </math>. Так как эта функция может содержать в себе любое количество простых математических операций, будем считать, что её сложность <math>\bold f </math> много больше любой из них, и равна константе <math>C</math>. За весь алгоритм, она вызывается <math>4n</math> раза. Таким образом, сложность последовательного алгоритма для одномерного случая равна <math>4nC</math>.

Для случая решения системы ОДУ, когда <math>f</math> и <math>y</math> являются векторами размерности <math>m</math>, функция core будет вызвана <math>m</math>, и итоговая сложность алгоритма составит <math>4nCm</math>.

== Информационный граф ==

Информационная структура параллельного алгоритма Рунге-Кутты 4-го порядка представляет собой матрицу изображённую на рисунке ниже. Вдоль оси <math>j</math> располагаются <math>j</math>-ые параметры вектора <math>y</math>, соответственно, вдоль <math>i</math> изображены этапы вычисления <math>y_i</math> значения j-параметра вектора <math>y</math>. Таким образом, можно сказать, что вдоль оси <math>j</math>, изображены параллельные процессы. А ось <math>i</math> представляет собой шкалу времени. Чтобы соотнести её с реальным временем, надо просто посчитать сумму, где <math>t_i</math> - время с момента начала вычисления <math>i</math>-го всеми процессами до момента его завершения всеми процессами.

[[Файл:Example.jpg]]

Можно заметить, что на каждом <math>i</math>-ом шаге происходит обмен информацией между процессами. Это выражено в виде линии пересекающей все <math>j</math>-ые процессы на любом <math>i</math>-ом шаге.

== Ресурс параллелизма алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является итерационным алгоритмом. В нём каждый шаг цикла зависит от предыдущего. В самом шаге, каждая последующая операция также зависит от результата предыдущей. Таким образом, упразднить цикл до независимых и соответственно параллельных операций не является возможным. Однако, так как на результат функции <math> \bold f </math> влияет только <math>i</math>-ый параметр векторов <math> f </math> и <math> y </math>, то для каждого <math> i </math> можно производить независимое вычисление. В итоге, если вычислять результаты выполнения функции <math> \bold f </math> одновременно для вля всех <math> i</math>-ых параметров векторов <math> f </math> и <math> y </math>, получим туже алгоритмическую сложность <math>4nC</math>, что и в [[#Последовательная сложность алгоритма|разделе 1.6]] для одномерного случая.

== Входные и выходные данные алгоритма ==

'''Входные данные''':
<math> a, b </math> - интервал интегрирования,
n - количество точек в разбиении,
<math> \bold y_0 </math> - вектор значений размерности m при <math> x = a </math>,
функцию вычисления производной <math>\bold f </math> будем считать встроенной в алгоритм.

'''Объём входных данных''':
m + 3

'''Выходные данные:'''
<math> \bold y_i </math> - вектора размера m значений в n узлах сетки (т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>).

'''Объем выходных данных'''
n * m

== Свойства алгоритма ==

Алгоритм обладает следующими свойствами:

* Точность. Как написано в [[#Общее описание алгоритма| разделе 1.1]], алгоритм имеет порядок точности <math>O(h^4)</math>.
* Устойчивость. Алгоритм устойчив на любом конечном отрезке.
* Гибкость. На любом этапе вычисления можно легко изменить шаг интегрирования.

= ЧАСТЬ. Программная реализация алгоритма =

== [[Особенности реализации последовательного алгоритма]] ==

== [[Локальность данных и вычислений]] ==

== [[Возможные способы и особенности параллельной реализации алгоритма]] ==

== Масштабируемость алгоритма и его реализации ==

== [[Динамические характеристики и эффективность реализации алгоритма]] ==

== [[Выводы для классов архитектур]] ==

== Существующие реализации алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является одним из наиболее используемых для решения ОДУ и их систем, поэтому существует большое число его реализаций для разных языков программирования. Наиболее популярными являются следующие из них:
* библиотека RK4, которая существует в вариантах для C++, FORTRAN90, FORTRAN77, python и MATLAB;
* библиотека ode45 для MATLAB;
* модуль scipy для PYTHON.

= Литература =

Участник:Борис/Алгоритм Рунге-Кутты

2016-10-15T20:32:23Z

Борис:

{{algorithm
| name = Метод Рунге-Кутты 4 порядка
| serial_complexity = <math>O()</math>
| pf_height = <math>O()</math>
| pf_width = <math>O()</math>
| input_data = <math>m + 3</math>
| output_data = <math>m * n</math>
}}

Основные авторы описания: [[Участник:Jest|Е.П.Степанов]]([[#Общее описание алгоритма|раздел 1.1]], [[#Математическое описание алгоритма|раздел 1.2]], [[#Вычислительное ядро алгоритма|раздел 1.3]], [[#Макроструктура алгоритма|раздел 1.4]], [[#Входные и выходные данные алгоритма|раздел 1.9]]), [[Участник:Борис|Б.Савков]] ( [[#Схема реализации последовательного алгоритма|раздел 1.5]], [[#Последовательная сложность алгоритма|раздел 1.6]], [[#Информационный граф|раздел 1.7]], [[#Ресурс параллелизма алгоритма|раздел 1.8]], [[#Свойства алгоритма|раздел 1.10]], [[#Существующие реализации алгоритма|раздел 2.7]])

= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==

Ме́тоды Ру́нге — Ку́тты (распространено неправильное название Ме́тоды Ру́нге — Ку́тта или же Ме́тоды Ру́нге — Кутта́) — важное семейство численных алгоритмов решения обыкновенных дифференциальных уравнений и их систем. Данные итеративные методы явного и неявного приближённого вычисления были разработаны около 1900 года немецкими математиками К. Рунге и М. В. Куттой.

Метод Рунге - Кутты применяется при решения задачи Коши для системы обыкновенных дифференциальных уравнений первого порядка:

:<math>
\begin{cases}
\textbf{y}' = \textbf{f}(x, \textbf{y}),\\
\textbf{y}(x_0) = \textbf{y}_0.
\end{cases}
</math>

При этом <math>\textbf{y}, \textbf{f}, x</math> отвечают следующим свойствам: <math> \textbf{y}, \textbf{f} \in \mathbb{R}^m, x \in \mathbb{R}^1 </math>.

Пусть известно значение y(x) и требуется вычислить значение y(x+h). Это можно сделать при помощи формулы:

:<math> y(x + h) = y(x) + \int_0^hy'(x + t)dt</math>

Аппроксимируя интеграл в правой части, можно получить методы Рунге-Кутты разного порядка точности. В общем виде формулы методов Рунге-Кутты можно записать следующим образом:

:<math>\textbf{y}_{n+1} = \textbf{y}_n + h\sum_{i=1}^s b_i \textbf{k}_i</math>

:<math>
\begin{array}{ll}
\textbf{k}_1 =& \textbf{f}(x_n, \textbf{y}_n),\\
\textbf{k}_2 =& \textbf{f}(x_n+c_2h, \textbf{y}_n+a_{21}h\textbf{k}_1),\\
\cdots&\\
\textbf{k}_s =& \textbf{f}(x_n+c_sh, \textbf{y}_n+a_{s1}h\textbf{k}_1+a_{s2}h\textbf{k}_2+\cdots+a_{s,s-1}h\textbf{k}_{s-1})
\end{array}
</math>

Увеличивая число s вспомогательных точек, можно построить методы Рунге-Кутты любого порядка точности p. Однако уже при p > 5 эти методы используются довольно редко. Это объясняется как чрезмерной громоздкостью получающихся вычислительных формул, так и тем, что преимущества методов высокого порядка точности над методами, в которых p = 4 или p = 5, проявляются либо в тех задачах, где нужна очень высокая точность и используются ЭВМ высокой разрядности, либо в тех задачах, где решение очень гладкое. Кроме того, методы Рунге-Кутты высокого порядка точности часто оказываются менее эффективными по сравнению с методами Адамса того же порядка точности. На этой странице представлен наиболее распространенный метод Рунге-Кутты 4 порядка с ошибкой на конечном интервале интегрирования <math>O(h^4)</math>.

Существуют как явные, так и неявные методы Рунге-Кутты. Последние имеют ряд преимуществ над явными методами, однако это достигается за счет существенного усложнения вычислительного алгоритма, так как на каждом шаге приходится считать систему нелинейных уравнений. На этой странице представлен явный метод Рунге-Кутты.

Можно отметить, что в современных программах, реализующих метод Рунге-Кутты, обязательно используется некоторый алгоритм автоматического изменения шага интегрирования. Интуитивно ясно, что на участках плавного изменения решения счет можно вести с достаточно крупным шагом. В то же время на тех участках, где происходят резкие изменения поведения решения, необходимо выбирать мелкий шаг интегрирования. Обычно начальное значение шага h1 задает пользователь. Далее шаг интегрирования меняется в соответствии с величиной получаемой в ходе вычислений оценки локальной погрешности. Для упрощения описания на этой странице используется постоянный шаг интегрирования h, зависящий от размера сетки разбиения n.

== Математическое описание алгоритма ==

Далее подразумевается, что <math> \bold y, \bold y_i,\bold f, \bold k_i \in \mathbb{R}^m</math>, а <math>x, h, n, a, b \in \mathbb{R}^1 </math>.

Исходные данные:
<math> a, b </math> - интервал интегрирования,
<math> \bold y_0 </math> - вектор значений при <math> x = a </math>,
n - количество точек в разбиении
<math>\bold f </math> - функция вычисления производной

Вычисляемые данные:
<math> \bold y_i </math> - вектора значений в узлах сетки, т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>

Формулы метода:
:Вначале вычисляется шаг сетки:
::<math> h = \frac{b-a}{n}</math>.
:Приближенное значение в следующих точках вычисляется по итерационной формуле:
::<math>\textbf{y}_{n+1} = \textbf{y}_n + {h \over 6}(\textbf{k}_1 + 2\textbf{k}_2 + 2\textbf{k}_3 + \textbf{k}_4)</math>,
::<math>\textbf{k}_1 = \textbf{f} \left( x_n, \textbf{y}_n \right),</math>
::<math>\textbf{k}_2 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_1 \right),</math>
::<math>\textbf{k}_3 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_2 \right),</math>
::<math>\textbf{k}_4 = \textbf{f} \left( x_n + h, \textbf{y}_n + h\ \textbf{k}_3 \right),</math>
::<math>x_{n+1} = x_n + h.</math>

== Вычислительное ядро алгоритма ==

Вычислительным ядром метода Рунге-Кутты можно считать вычисление значений функции производной
:<math>\textbf{f}(x, \textbf{y})</math>,
так как при вычислении каждого нового <math>\textbf{y}_n</math> требуется 4 вычисления значения функции производной. Таким образом, сложность работы алгоритма существенно зависит от сложности вычисления функции <math>\textbf{f}</math>.

== Макроструктура алгоритма ==

Макроструктура алгоритма может быть представлена в следующем виде:
:Вычисление вспомогательных коэффициентов <math>\textbf{k}_j, j \in [1,4]</math>;
:Вычисление приближенного значения <math> \bold y_i </math> в следующей точке;
:Переход на следующую итерацию или остановка.

== Схема реализации последовательного алгоритма ==

Пример реализации последовательного алгоритма на языке C++ (указатель на функцию f передаётся через аргументы представленной ниже функции):
<source lang="c++" line="1">
#include <vector>

// other code ...

std::vector<double> rungekutta4(double a, double b, std::vector<double> y0, int n, std::vector<double (*)(double,double)> f)
{
std::vector<double>::size_type sz = y0.size();
std::vector<double> result;
for (unsigned j=0; j<sz; j++)
{
rezult.push_back(core(a,b,y[j],n,f[j]));
}
return result;
}

double core(double a, double b, double y0, int n, double (*f)(double,double))
{
double h, k1, k2, k3, k4, x, y;
h = (b - a)/n;
y = y0;
x = a;
for (unsigned i = 0; i < n; i++)
{
k1 = f(x, y);
k2 = f(x + h/2, y + h*k1/2);
k3 = f(x + h/2, y + h*k2/2);
k4 = f(x + h/2, y + h*k3);
x += h;
y += h*(k1 + 2*k2 + 2*k3 + k4)/6;
}
return y;
}

// other code ...
</source>

== Последовательная сложность алгоритма ==

Рассмотрим сначала одномерный случай. Наравне с обычными операциями, такими как сложение, умножение и тому подобными, в представленном выше алгоритме присутствует вызов функции <math>\bold f </math>. Так как эта функция может содержать в себе любое количество простых математических операций, будем считать, что её сложность <math>\bold f </math> много больше любой из них, и равна константе <math>C</math>. За весь алгоритм, она вызывается <math>4n</math> раза. Таким образом, сложность последовательного алгоритма для одномерного случая равна <math>4nC</math>.

Для случая решения системы ОДУ, когда <math>f</math> и <math>y</math> являются векторами размерности <math>m</math>, функция core будет вызвана <math>m</math>, и итоговая сложность алгоритма составит <math>4nCm</math>.

== Информационный граф ==

== Ресурс параллелизма алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является итерационным алгоритмом. В нём каждый шаг цикла зависит от предыдущего. В самом шаге, каждая последующая операция также зависит от результата предыдущей. Таким образом, упразднить цикл до независимых и соответственно параллельных операций не является возможным. Однако, так как на результат функции <math> \bold f </math> влияет только <math>i</math>-ый параметр векторов <math> f </math> и <math> y </math>, то для каждого <math> i </math> можно производить независимое вычисление. В итоге, если вычислять результаты выполнения функции <math> \bold f </math> одновременно для вля всех <math> i</math>-ых параметров векторов <math> f </math> и <math> y </math>, получим туже алгоритмическую сложность <math>4nC</math>, что и в [[#Последовательная сложность алгоритма|разделе 1.6]] для одномерного случая.

== Входные и выходные данные алгоритма ==

'''Входные данные''':
<math> a, b </math> - интервал интегрирования,
n - количество точек в разбиении,
<math> \bold y_0 </math> - вектор значений размерности m при <math> x = a </math>,
функцию вычисления производной <math>\bold f </math> будем считать встроенной в алгоритм.

'''Объём входных данных''':
m + 3

'''Выходные данные:'''
<math> \bold y_i </math> - вектора размера m значений в n узлах сетки (т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>).

'''Объем выходных данных'''
n * m

== Свойства алгоритма ==

Алгоритм обладает следующими свойствами:

* Точность. Как написано в [[#Общее описание алгоритма| разделе 1.1]], алгоритм имеет порядок точности <math>O(h^4)</math>.
* Устойчивость. Алгоритм устойчив на любом конечном отрезке.
* Гибкость. На любом этапе вычисления можно легко изменить шаг интегрирования.

= ЧАСТЬ. Программная реализация алгоритма =

== [[Особенности реализации последовательного алгоритма]] ==

== [[Локальность данных и вычислений]] ==

== [[Возможные способы и особенности параллельной реализации алгоритма]] ==

== Масштабируемость алгоритма и его реализации ==

== [[Динамические характеристики и эффективность реализации алгоритма]] ==

== [[Выводы для классов архитектур]] ==

== Существующие реализации алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является одним из наиболее используемых для решения ОДУ и их систем, поэтому существует большое число его реализаций для разных языков программирования. Наиболее популярными являются следующие из них:
* библиотека RK4, которая существует в вариантах для C++, FORTRAN90, FORTRAN77, python и MATLAB;
* библиотека ode45 для MATLAB;
* модуль scipy для PYTHON.

= Литература =

Участник:Борис/Алгоритм Рунге-Кутты

2016-10-15T20:29:38Z

Борис: /* Свойства алгоритма */

{{algorithm
| name = Метод Рунге-Кутты 4 порядка
| serial_complexity = <math>O()</math>
| pf_height = <math>O()</math>
| pf_width = <math>O()</math>
| input_data = <math>m + 3</math>
| output_data = <math>m * n</math>
}}

Основные авторы описания: [[Участник:Jest|Е.П.Степанов]]([[#Общее описание алгоритма|раздел 1.1]], [[#Математическое описание алгоритма|раздел 1.2]], [[#Вычислительное ядро алгоритма|раздел 1.3]], [[#Макроструктура алгоритма|раздел 1.4]], [[#Входные и выходные данные алгоритма|раздел 1.9]]), [[Участник:Борис|Б.Савков]] ( [[#Схема реализации последовательного алгоритма|раздел 1.5]], [[#Последовательная сложность алгоритма|раздел 1.6]], [[#Информационный граф|раздел 1.7]], [[#Ресурс параллелизма алгоритма|раздел 1.8]], [[#Существующие реализации алгоритма|раздел 2.7]])

= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==

Ме́тоды Ру́нге — Ку́тты (распространено неправильное название Ме́тоды Ру́нге — Ку́тта или же Ме́тоды Ру́нге — Кутта́) — важное семейство численных алгоритмов решения обыкновенных дифференциальных уравнений и их систем. Данные итеративные методы явного и неявного приближённого вычисления были разработаны около 1900 года немецкими математиками К. Рунге и М. В. Куттой.

Метод Рунге - Кутты применяется при решения задачи Коши для системы обыкновенных дифференциальных уравнений первого порядка:

:<math>
\begin{cases}
\textbf{y}' = \textbf{f}(x, \textbf{y}),\\
\textbf{y}(x_0) = \textbf{y}_0.
\end{cases}
</math>

При этом <math>\textbf{y}, \textbf{f}, x</math> отвечают следующим свойствам: <math> \textbf{y}, \textbf{f} \in \mathbb{R}^m, x \in \mathbb{R}^1 </math>.

Пусть известно значение y(x) и требуется вычислить значение y(x+h). Это можно сделать при помощи формулы:

:<math> y(x + h) = y(x) + \int_0^hy'(x + t)dt</math>

Аппроксимируя интеграл в правой части, можно получить методы Рунге-Кутты разного порядка точности. В общем виде формулы методов Рунге-Кутты можно записать следующим образом:

:<math>\textbf{y}_{n+1} = \textbf{y}_n + h\sum_{i=1}^s b_i \textbf{k}_i</math>

:<math>
\begin{array}{ll}
\textbf{k}_1 =& \textbf{f}(x_n, \textbf{y}_n),\\
\textbf{k}_2 =& \textbf{f}(x_n+c_2h, \textbf{y}_n+a_{21}h\textbf{k}_1),\\
\cdots&\\
\textbf{k}_s =& \textbf{f}(x_n+c_sh, \textbf{y}_n+a_{s1}h\textbf{k}_1+a_{s2}h\textbf{k}_2+\cdots+a_{s,s-1}h\textbf{k}_{s-1})
\end{array}
</math>

Увеличивая число s вспомогательных точек, можно построить методы Рунге-Кутты любого порядка точности p. Однако уже при p > 5 эти методы используются довольно редко. Это объясняется как чрезмерной громоздкостью получающихся вычислительных формул, так и тем, что преимущества методов высокого порядка точности над методами, в которых p = 4 или p = 5, проявляются либо в тех задачах, где нужна очень высокая точность и используются ЭВМ высокой разрядности, либо в тех задачах, где решение очень гладкое. Кроме того, методы Рунге-Кутты высокого порядка точности часто оказываются менее эффективными по сравнению с методами Адамса того же порядка точности. На этой странице представлен наиболее распространенный метод Рунге-Кутты 4 порядка с ошибкой на конечном интервале интегрирования <math>O(h^4)</math>.

Существуют как явные, так и неявные методы Рунге-Кутты. Последние имеют ряд преимуществ над явными методами, однако это достигается за счет существенного усложнения вычислительного алгоритма, так как на каждом шаге приходится считать систему нелинейных уравнений. На этой странице представлен явный метод Рунге-Кутты.

Можно отметить, что в современных программах, реализующих метод Рунге-Кутты, обязательно используется некоторый алгоритм автоматического изменения шага интегрирования. Интуитивно ясно, что на участках плавного изменения решения счет можно вести с достаточно крупным шагом. В то же время на тех участках, где происходят резкие изменения поведения решения, необходимо выбирать мелкий шаг интегрирования. Обычно начальное значение шага h1 задает пользователь. Далее шаг интегрирования меняется в соответствии с величиной получаемой в ходе вычислений оценки локальной погрешности. Для упрощения описания на этой странице используется постоянный шаг интегрирования h, зависящий от размера сетки разбиения n.

== Математическое описание алгоритма ==

Далее подразумевается, что <math> \bold y, \bold y_i,\bold f, \bold k_i \in \mathbb{R}^m</math>, а <math>x, h, n, a, b \in \mathbb{R}^1 </math>.

Исходные данные:
<math> a, b </math> - интервал интегрирования,
<math> \bold y_0 </math> - вектор значений при <math> x = a </math>,
n - количество точек в разбиении
<math>\bold f </math> - функция вычисления производной

Вычисляемые данные:
<math> \bold y_i </math> - вектора значений в узлах сетки, т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>

Формулы метода:
:Вначале вычисляется шаг сетки:
::<math> h = \frac{b-a}{n}</math>.
:Приближенное значение в следующих точках вычисляется по итерационной формуле:
::<math>\textbf{y}_{n+1} = \textbf{y}_n + {h \over 6}(\textbf{k}_1 + 2\textbf{k}_2 + 2\textbf{k}_3 + \textbf{k}_4)</math>,
::<math>\textbf{k}_1 = \textbf{f} \left( x_n, \textbf{y}_n \right),</math>
::<math>\textbf{k}_2 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_1 \right),</math>
::<math>\textbf{k}_3 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_2 \right),</math>
::<math>\textbf{k}_4 = \textbf{f} \left( x_n + h, \textbf{y}_n + h\ \textbf{k}_3 \right),</math>
::<math>x_{n+1} = x_n + h.</math>

== Вычислительное ядро алгоритма ==

Вычислительным ядром метода Рунге-Кутты можно считать вычисление значений функции производной
:<math>\textbf{f}(x, \textbf{y})</math>,
так как при вычислении каждого нового <math>\textbf{y}_n</math> требуется 4 вычисления значения функции производной. Таким образом, сложность работы алгоритма существенно зависит от сложности вычисления функции <math>\textbf{f}</math>.

== Макроструктура алгоритма ==

Макроструктура алгоритма может быть представлена в следующем виде:
:Вычисление вспомогательных коэффициентов <math>\textbf{k}_j, j \in [1,4]</math>;
:Вычисление приближенного значения <math> \bold y_i </math> в следующей точке;
:Переход на следующую итерацию или остановка.

== Схема реализации последовательного алгоритма ==

Пример реализации последовательного алгоритма на языке C++ (указатель на функцию f передаётся через аргументы представленной ниже функции):
<source lang="c++" line="1">
#include <vector>

// other code ...

std::vector<double> rungekutta4(double a, double b, std::vector<double> y0, int n, std::vector<double (*)(double,double)> f)
{
std::vector<double>::size_type sz = y0.size();
std::vector<double> result;
for (unsigned j=0; j<sz; j++)
{
rezult.push_back(core(a,b,y[j],n,f[j]));
}
return result;
}

double core(double a, double b, double y0, int n, double (*f)(double,double))
{
double h, k1, k2, k3, k4, x, y;
h = (b - a)/n;
y = y0;
x = a;
for (unsigned i = 0; i < n; i++)
{
k1 = f(x, y);
k2 = f(x + h/2, y + h*k1/2);
k3 = f(x + h/2, y + h*k2/2);
k4 = f(x + h/2, y + h*k3);
x += h;
y += h*(k1 + 2*k2 + 2*k3 + k4)/6;
}
return y;
}

// other code ...
</source>

== Последовательная сложность алгоритма ==

Рассмотрим сначала одномерный случай. Наравне с обычными операциями, такими как сложение, умножение и тому подобными, в представленном выше алгоритме присутствует вызов функции <math>\bold f </math>. Так как эта функция может содержать в себе любое количество простых математических операций, будем считать, что её сложность <math>\bold f </math> много больше любой из них, и равна константе <math>C</math>. За весь алгоритм, она вызывается <math>4n</math> раза. Таким образом, сложность последовательного алгоритма для одномерного случая равна <math>4nC</math>.

Для случая решения системы ОДУ, когда <math>f</math> и <math>y</math> являются векторами размерности <math>m</math>, функция core будет вызвана <math>m</math>, и итоговая сложность алгоритма составит <math>4nCm</math>.

== Информационный граф ==

== Ресурс параллелизма алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является итерационным алгоритмом. В нём каждый шаг цикла зависит от предыдущего. В самом шаге, каждая последующая операция также зависит от результата предыдущей. Таким образом, упразднить цикл до независимых и соответственно параллельных операций не является возможным. Однако, так как на результат функции <math> \bold f </math> влияет только <math>i</math>-ый параметр векторов <math> f </math> и <math> y </math>, то для каждого <math> i </math> можно производить независимое вычисление. В итоге, если вычислять результаты выполнения функции <math> \bold f </math> одновременно для вля всех <math> i</math>-ых параметров векторов <math> f </math> и <math> y </math>, получим туже алгоритмическую сложность <math>4nC</math>, что и в [[#Последовательная сложность алгоритма|разделе 1.6]] для одномерного случая.

== Входные и выходные данные алгоритма ==

'''Входные данные''':
<math> a, b </math> - интервал интегрирования,
n - количество точек в разбиении,
<math> \bold y_0 </math> - вектор значений размерности m при <math> x = a </math>,
функцию вычисления производной <math>\bold f </math> будем считать встроенной в алгоритм.

'''Объём входных данных''':
m + 3

'''Выходные данные:'''
<math> \bold y_i </math> - вектора размера m значений в n узлах сетки (т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>).

'''Объем выходных данных'''
n * m

== Свойства алгоритма ==

Алгоритм обладает следующими свойствами:

* Точность. Как написано в [[#Общее описание алгоритма| разделе 1.1]], алгоритм имеет порядок точности <math>O(h^4)</math>.
* Устойчивость. Алгоритм устойчив на любом конечном отрезке.
* Гибкость. На любом этапе вычисления можно легко изменить шаг интегрирования.

= ЧАСТЬ. Программная реализация алгоритма =

== [[Особенности реализации последовательного алгоритма]] ==

== [[Локальность данных и вычислений]] ==

== [[Возможные способы и особенности параллельной реализации алгоритма]] ==

== Масштабируемость алгоритма и его реализации ==

== [[Динамические характеристики и эффективность реализации алгоритма]] ==

== [[Выводы для классов архитектур]] ==

== Существующие реализации алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является одним из наиболее используемых для решения ОДУ и их систем, поэтому существует большое число его реализаций для разных языков программирования. Наиболее популярными являются следующие из них:
* библиотека RK4, которая существует в вариантах для C++, FORTRAN90, FORTRAN77, python и MATLAB;
* библиотека ode45 для MATLAB;
* модуль scipy для PYTHON.

= Литература =

Участник:Борис/Алгоритм Рунге-Кутты

2016-10-15T20:29:18Z

Борис: /* Свойства алгоритма */

{{algorithm
| name = Метод Рунге-Кутты 4 порядка
| serial_complexity = <math>O()</math>
| pf_height = <math>O()</math>
| pf_width = <math>O()</math>
| input_data = <math>m + 3</math>
| output_data = <math>m * n</math>
}}

Основные авторы описания: [[Участник:Jest|Е.П.Степанов]]([[#Общее описание алгоритма|раздел 1.1]], [[#Математическое описание алгоритма|раздел 1.2]], [[#Вычислительное ядро алгоритма|раздел 1.3]], [[#Макроструктура алгоритма|раздел 1.4]], [[#Входные и выходные данные алгоритма|раздел 1.9]]), [[Участник:Борис|Б.Савков]] ( [[#Схема реализации последовательного алгоритма|раздел 1.5]], [[#Последовательная сложность алгоритма|раздел 1.6]], [[#Информационный граф|раздел 1.7]], [[#Ресурс параллелизма алгоритма|раздел 1.8]], [[#Существующие реализации алгоритма|раздел 2.7]])

= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==

Ме́тоды Ру́нге — Ку́тты (распространено неправильное название Ме́тоды Ру́нге — Ку́тта или же Ме́тоды Ру́нге — Кутта́) — важное семейство численных алгоритмов решения обыкновенных дифференциальных уравнений и их систем. Данные итеративные методы явного и неявного приближённого вычисления были разработаны около 1900 года немецкими математиками К. Рунге и М. В. Куттой.

Метод Рунге - Кутты применяется при решения задачи Коши для системы обыкновенных дифференциальных уравнений первого порядка:

:<math>
\begin{cases}
\textbf{y}' = \textbf{f}(x, \textbf{y}),\\
\textbf{y}(x_0) = \textbf{y}_0.
\end{cases}
</math>

При этом <math>\textbf{y}, \textbf{f}, x</math> отвечают следующим свойствам: <math> \textbf{y}, \textbf{f} \in \mathbb{R}^m, x \in \mathbb{R}^1 </math>.

Пусть известно значение y(x) и требуется вычислить значение y(x+h). Это можно сделать при помощи формулы:

:<math> y(x + h) = y(x) + \int_0^hy'(x + t)dt</math>

Аппроксимируя интеграл в правой части, можно получить методы Рунге-Кутты разного порядка точности. В общем виде формулы методов Рунге-Кутты можно записать следующим образом:

:<math>\textbf{y}_{n+1} = \textbf{y}_n + h\sum_{i=1}^s b_i \textbf{k}_i</math>

:<math>
\begin{array}{ll}
\textbf{k}_1 =& \textbf{f}(x_n, \textbf{y}_n),\\
\textbf{k}_2 =& \textbf{f}(x_n+c_2h, \textbf{y}_n+a_{21}h\textbf{k}_1),\\
\cdots&\\
\textbf{k}_s =& \textbf{f}(x_n+c_sh, \textbf{y}_n+a_{s1}h\textbf{k}_1+a_{s2}h\textbf{k}_2+\cdots+a_{s,s-1}h\textbf{k}_{s-1})
\end{array}
</math>

Увеличивая число s вспомогательных точек, можно построить методы Рунге-Кутты любого порядка точности p. Однако уже при p > 5 эти методы используются довольно редко. Это объясняется как чрезмерной громоздкостью получающихся вычислительных формул, так и тем, что преимущества методов высокого порядка точности над методами, в которых p = 4 или p = 5, проявляются либо в тех задачах, где нужна очень высокая точность и используются ЭВМ высокой разрядности, либо в тех задачах, где решение очень гладкое. Кроме того, методы Рунге-Кутты высокого порядка точности часто оказываются менее эффективными по сравнению с методами Адамса того же порядка точности. На этой странице представлен наиболее распространенный метод Рунге-Кутты 4 порядка с ошибкой на конечном интервале интегрирования <math>O(h^4)</math>.

Существуют как явные, так и неявные методы Рунге-Кутты. Последние имеют ряд преимуществ над явными методами, однако это достигается за счет существенного усложнения вычислительного алгоритма, так как на каждом шаге приходится считать систему нелинейных уравнений. На этой странице представлен явный метод Рунге-Кутты.

Можно отметить, что в современных программах, реализующих метод Рунге-Кутты, обязательно используется некоторый алгоритм автоматического изменения шага интегрирования. Интуитивно ясно, что на участках плавного изменения решения счет можно вести с достаточно крупным шагом. В то же время на тех участках, где происходят резкие изменения поведения решения, необходимо выбирать мелкий шаг интегрирования. Обычно начальное значение шага h1 задает пользователь. Далее шаг интегрирования меняется в соответствии с величиной получаемой в ходе вычислений оценки локальной погрешности. Для упрощения описания на этой странице используется постоянный шаг интегрирования h, зависящий от размера сетки разбиения n.

== Математическое описание алгоритма ==

Далее подразумевается, что <math> \bold y, \bold y_i,\bold f, \bold k_i \in \mathbb{R}^m</math>, а <math>x, h, n, a, b \in \mathbb{R}^1 </math>.

Исходные данные:
<math> a, b </math> - интервал интегрирования,
<math> \bold y_0 </math> - вектор значений при <math> x = a </math>,
n - количество точек в разбиении
<math>\bold f </math> - функция вычисления производной

Вычисляемые данные:
<math> \bold y_i </math> - вектора значений в узлах сетки, т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>

Формулы метода:
:Вначале вычисляется шаг сетки:
::<math> h = \frac{b-a}{n}</math>.
:Приближенное значение в следующих точках вычисляется по итерационной формуле:
::<math>\textbf{y}_{n+1} = \textbf{y}_n + {h \over 6}(\textbf{k}_1 + 2\textbf{k}_2 + 2\textbf{k}_3 + \textbf{k}_4)</math>,
::<math>\textbf{k}_1 = \textbf{f} \left( x_n, \textbf{y}_n \right),</math>
::<math>\textbf{k}_2 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_1 \right),</math>
::<math>\textbf{k}_3 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_2 \right),</math>
::<math>\textbf{k}_4 = \textbf{f} \left( x_n + h, \textbf{y}_n + h\ \textbf{k}_3 \right),</math>
::<math>x_{n+1} = x_n + h.</math>

== Вычислительное ядро алгоритма ==

Вычислительным ядром метода Рунге-Кутты можно считать вычисление значений функции производной
:<math>\textbf{f}(x, \textbf{y})</math>,
так как при вычислении каждого нового <math>\textbf{y}_n</math> требуется 4 вычисления значения функции производной. Таким образом, сложность работы алгоритма существенно зависит от сложности вычисления функции <math>\textbf{f}</math>.

== Макроструктура алгоритма ==

Макроструктура алгоритма может быть представлена в следующем виде:
:Вычисление вспомогательных коэффициентов <math>\textbf{k}_j, j \in [1,4]</math>;
:Вычисление приближенного значения <math> \bold y_i </math> в следующей точке;
:Переход на следующую итерацию или остановка.

== Схема реализации последовательного алгоритма ==

Пример реализации последовательного алгоритма на языке C++ (указатель на функцию f передаётся через аргументы представленной ниже функции):
<source lang="c++" line="1">
#include <vector>

// other code ...

std::vector<double> rungekutta4(double a, double b, std::vector<double> y0, int n, std::vector<double (*)(double,double)> f)
{
std::vector<double>::size_type sz = y0.size();
std::vector<double> result;
for (unsigned j=0; j<sz; j++)
{
rezult.push_back(core(a,b,y[j],n,f[j]));
}
return result;
}

double core(double a, double b, double y0, int n, double (*f)(double,double))
{
double h, k1, k2, k3, k4, x, y;
h = (b - a)/n;
y = y0;
x = a;
for (unsigned i = 0; i < n; i++)
{
k1 = f(x, y);
k2 = f(x + h/2, y + h*k1/2);
k3 = f(x + h/2, y + h*k2/2);
k4 = f(x + h/2, y + h*k3);
x += h;
y += h*(k1 + 2*k2 + 2*k3 + k4)/6;
}
return y;
}

// other code ...
</source>

== Последовательная сложность алгоритма ==

Рассмотрим сначала одномерный случай. Наравне с обычными операциями, такими как сложение, умножение и тому подобными, в представленном выше алгоритме присутствует вызов функции <math>\bold f </math>. Так как эта функция может содержать в себе любое количество простых математических операций, будем считать, что её сложность <math>\bold f </math> много больше любой из них, и равна константе <math>C</math>. За весь алгоритм, она вызывается <math>4n</math> раза. Таким образом, сложность последовательного алгоритма для одномерного случая равна <math>4nC</math>.

Для случая решения системы ОДУ, когда <math>f</math> и <math>y</math> являются векторами размерности <math>m</math>, функция core будет вызвана <math>m</math>, и итоговая сложность алгоритма составит <math>4nCm</math>.

== Информационный граф ==

== Ресурс параллелизма алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является итерационным алгоритмом. В нём каждый шаг цикла зависит от предыдущего. В самом шаге, каждая последующая операция также зависит от результата предыдущей. Таким образом, упразднить цикл до независимых и соответственно параллельных операций не является возможным. Однако, так как на результат функции <math> \bold f </math> влияет только <math>i</math>-ый параметр векторов <math> f </math> и <math> y </math>, то для каждого <math> i </math> можно производить независимое вычисление. В итоге, если вычислять результаты выполнения функции <math> \bold f </math> одновременно для вля всех <math> i</math>-ых параметров векторов <math> f </math> и <math> y </math>, получим туже алгоритмическую сложность <math>4nC</math>, что и в [[#Последовательная сложность алгоритма|разделе 1.6]] для одномерного случая.

== Входные и выходные данные алгоритма ==

'''Входные данные''':
<math> a, b </math> - интервал интегрирования,
n - количество точек в разбиении,
<math> \bold y_0 </math> - вектор значений размерности m при <math> x = a </math>,
функцию вычисления производной <math>\bold f </math> будем считать встроенной в алгоритм.

'''Объём входных данных''':
m + 3

'''Выходные данные:'''
<math> \bold y_i </math> - вектора размера m значений в n узлах сетки (т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>).

'''Объем выходных данных'''
n * m

== Свойства алгоритма ==

Алгоритм обладает следующими свойствами:

* Точность. Как написано в [[#Общее описание алгоритма| разделе 1.1]], алгоритм имеет порядок точности <math>O(h^4)</math>.
* Устойчивость. Алгоритм устойчив на всяком конечном отрезке.
* Гибкость. На любом этапе вычисления можно легко изменить шаг интегрирования.

= ЧАСТЬ. Программная реализация алгоритма =

== [[Особенности реализации последовательного алгоритма]] ==

== [[Локальность данных и вычислений]] ==

== [[Возможные способы и особенности параллельной реализации алгоритма]] ==

== Масштабируемость алгоритма и его реализации ==

== [[Динамические характеристики и эффективность реализации алгоритма]] ==

== [[Выводы для классов архитектур]] ==

== Существующие реализации алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является одним из наиболее используемых для решения ОДУ и их систем, поэтому существует большое число его реализаций для разных языков программирования. Наиболее популярными являются следующие из них:
* библиотека RK4, которая существует в вариантах для C++, FORTRAN90, FORTRAN77, python и MATLAB;
* библиотека ode45 для MATLAB;
* модуль scipy для PYTHON.

= Литература =

Участник:Борис/Алгоритм Рунге-Кутты

2016-10-15T20:12:53Z

Борис: /* Схема реализации последовательного алгоритма */

{{algorithm
| name = Метод Рунге-Кутты 4 порядка
| serial_complexity = <math>O()</math>
| pf_height = <math>O()</math>
| pf_width = <math>O()</math>
| input_data = <math>m + 3</math>
| output_data = <math>m * n</math>
}}

Основные авторы описания: [[Участник:Jest|Е.П.Степанов]]([[#Общее описание алгоритма|раздел 1.1]], [[#Математическое описание алгоритма|раздел 1.2]], [[#Вычислительное ядро алгоритма|раздел 1.3]], [[#Макроструктура алгоритма|раздел 1.4]], [[#Входные и выходные данные алгоритма|раздел 1.9]]), [[Участник:Борис|Б.Савков]] ( [[#Схема реализации последовательного алгоритма|раздел 1.5]], [[#Последовательная сложность алгоритма|раздел 1.6]], [[#Информационный граф|раздел 1.7]], [[#Ресурс параллелизма алгоритма|раздел 1.8]], [[#Существующие реализации алгоритма|раздел 2.7]])

= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==

Ме́тоды Ру́нге — Ку́тты (распространено неправильное название Ме́тоды Ру́нге — Ку́тта или же Ме́тоды Ру́нге — Кутта́) — важное семейство численных алгоритмов решения обыкновенных дифференциальных уравнений и их систем. Данные итеративные методы явного и неявного приближённого вычисления были разработаны около 1900 года немецкими математиками К. Рунге и М. В. Куттой.

Метод Рунге - Кутты применяется при решения задачи Коши для системы обыкновенных дифференциальных уравнений первого порядка:

:<math>
\begin{cases}
\textbf{y}' = \textbf{f}(x, \textbf{y}),\\
\textbf{y}(x_0) = \textbf{y}_0.
\end{cases}
</math>

При этом <math>\textbf{y}, \textbf{f}, x</math> отвечают следующим свойствам: <math> \textbf{y}, \textbf{f} \in \mathbb{R}^m, x \in \mathbb{R}^1 </math>.

Пусть известно значение y(x) и требуется вычислить значение y(x+h). Это можно сделать при помощи формулы:

:<math> y(x + h) = y(x) + \int_0^hy'(x + t)dt</math>

Аппроксимируя интеграл в правой части, можно получить методы Рунге-Кутты разного порядка точности. В общем виде формулы методов Рунге-Кутты можно записать следующим образом:

:<math>\textbf{y}_{n+1} = \textbf{y}_n + h\sum_{i=1}^s b_i \textbf{k}_i</math>

:<math>
\begin{array}{ll}
\textbf{k}_1 =& \textbf{f}(x_n, \textbf{y}_n),\\
\textbf{k}_2 =& \textbf{f}(x_n+c_2h, \textbf{y}_n+a_{21}h\textbf{k}_1),\\
\cdots&\\
\textbf{k}_s =& \textbf{f}(x_n+c_sh, \textbf{y}_n+a_{s1}h\textbf{k}_1+a_{s2}h\textbf{k}_2+\cdots+a_{s,s-1}h\textbf{k}_{s-1})
\end{array}
</math>

Увеличивая число s вспомогательных точек, можно построить методы Рунге-Кутты любого порядка точности p. Однако уже при p > 5 эти методы используются довольно редко. Это объясняется как чрезмерной громоздкостью получающихся вычислительных формул, так и тем, что преимущества методов высокого порядка точности над методами, в которых p = 4 или p = 5, проявляются либо в тех задачах, где нужна очень высокая точность и используются ЭВМ высокой разрядности, либо в тех задачах, где решение очень гладкое. Кроме того, методы Рунге-Кутты высокого порядка точности часто оказываются менее эффективными по сравнению с методами Адамса того же порядка точности. На этой странице представлен наиболее распространенный метод Рунге-Кутты 4 порядка с ошибкой на конечном интервале интегрирования <math>O(h^4)</math>.

Существуют как явные, так и неявные методы Рунге-Кутты. Последние имеют ряд преимуществ над явными методами, однако это достигается за счет существенного усложнения вычислительного алгоритма, так как на каждом шаге приходится считать систему нелинейных уравнений. На этой странице представлен явный метод Рунге-Кутты.

Можно отметить, что в современных программах, реализующих метод Рунге-Кутты, обязательно используется некоторый алгоритм автоматического изменения шага интегрирования. Интуитивно ясно, что на участках плавного изменения решения счет можно вести с достаточно крупным шагом. В то же время на тех участках, где происходят резкие изменения поведения решения, необходимо выбирать мелкий шаг интегрирования. Обычно начальное значение шага h1 задает пользователь. Далее шаг интегрирования меняется в соответствии с величиной получаемой в ходе вычислений оценки локальной погрешности. Для упрощения описания на этой странице используется постоянный шаг интегрирования h, зависящий от размера сетки разбиения n.

== Математическое описание алгоритма ==

Далее подразумевается, что <math> \bold y, \bold y_i,\bold f, \bold k_i \in \mathbb{R}^m</math>, а <math>x, h, n, a, b \in \mathbb{R}^1 </math>.

Исходные данные:
<math> a, b </math> - интервал интегрирования,
<math> \bold y_0 </math> - вектор значений при <math> x = a </math>,
n - количество точек в разбиении
<math>\bold f </math> - функция вычисления производной

Вычисляемые данные:
<math> \bold y_i </math> - вектора значений в узлах сетки, т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>

Формулы метода:
:Вначале вычисляется шаг сетки:
::<math> h = \frac{b-a}{n}</math>.
:Приближенное значение в следующих точках вычисляется по итерационной формуле:
::<math>\textbf{y}_{n+1} = \textbf{y}_n + {h \over 6}(\textbf{k}_1 + 2\textbf{k}_2 + 2\textbf{k}_3 + \textbf{k}_4)</math>,
::<math>\textbf{k}_1 = \textbf{f} \left( x_n, \textbf{y}_n \right),</math>
::<math>\textbf{k}_2 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_1 \right),</math>
::<math>\textbf{k}_3 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_2 \right),</math>
::<math>\textbf{k}_4 = \textbf{f} \left( x_n + h, \textbf{y}_n + h\ \textbf{k}_3 \right),</math>
::<math>x_{n+1} = x_n + h.</math>

== Вычислительное ядро алгоритма ==

Вычислительным ядром метода Рунге-Кутты можно считать вычисление значений функции производной
:<math>\textbf{f}(x, \textbf{y})</math>,
так как при вычислении каждого нового <math>\textbf{y}_n</math> требуется 4 вычисления значения функции производной. Таким образом, сложность работы алгоритма существенно зависит от сложности вычисления функции <math>\textbf{f}</math>.

== Макроструктура алгоритма ==

Макроструктура алгоритма может быть представлена в следующем виде:
:Вычисление вспомогательных коэффициентов <math>\textbf{k}_j, j \in [1,4]</math>;
:Вычисление приближенного значения <math> \bold y_i </math> в следующей точке;
:Переход на следующую итерацию или остановка.

== Схема реализации последовательного алгоритма ==

Пример реализации последовательного алгоритма на языке C++ (указатель на функцию f передаётся через аргументы представленной ниже функции):
<source lang="c++" line="1">
#include <vector>

// other code ...

std::vector<double> rungekutta4(double a, double b, std::vector<double> y0, int n, std::vector<double (*)(double,double)> f)
{
std::vector<double>::size_type sz = y0.size();
std::vector<double> result;
for (unsigned j=0; j<sz; j++)
{
rezult.push_back(core(a,b,y[j],n,f[j]));
}
return result;
}

double core(double a, double b, double y0, int n, double (*f)(double,double))
{
double h, k1, k2, k3, k4, x, y;
h = (b - a)/n;
y = y0;
x = a;
for (unsigned i = 0; i < n; i++)
{
k1 = f(x, y);
k2 = f(x + h/2, y + h*k1/2);
k3 = f(x + h/2, y + h*k2/2);
k4 = f(x + h/2, y + h*k3);
x += h;
y += h*(k1 + 2*k2 + 2*k3 + k4)/6;
}
return y;
}

// other code ...
</source>

== Последовательная сложность алгоритма ==

Рассмотрим сначала одномерный случай. Наравне с обычными операциями, такими как сложение, умножение и тому подобными, в представленном выше алгоритме присутствует вызов функции <math>\bold f </math>. Так как эта функция может содержать в себе любое количество простых математических операций, будем считать, что её сложность <math>\bold f </math> много больше любой из них, и равна константе <math>C</math>. За весь алгоритм, она вызывается <math>4n</math> раза. Таким образом, сложность последовательного алгоритма для одномерного случая равна <math>4nC</math>.

Для случая решения системы ОДУ, когда <math>f</math> и <math>y</math> являются векторами размерности <math>m</math>, функция core будет вызвана <math>m</math>, и итоговая сложность алгоритма составит <math>4nCm</math>.

== Информационный граф ==

== Ресурс параллелизма алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является итерационным алгоритмом. В нём каждый шаг цикла зависит от предыдущего. В самом шаге, каждая последующая операция также зависит от результата предыдущей. Таким образом, упразднить цикл до независимых и соответственно параллельных операций не является возможным. Однако, так как на результат функции <math> \bold f </math> влияет только <math>i</math>-ый параметр векторов <math> f </math> и <math> y </math>, то для каждого <math> i </math> можно производить независимое вычисление. В итоге, если вычислять результаты выполнения функции <math> \bold f </math> одновременно для вля всех <math> i</math>-ых параметров векторов <math> f </math> и <math> y </math>, получим туже алгоритмическую сложность <math>4nC</math>, что и в [[#Последовательная сложность алгоритма|разделе 1.6]] для одномерного случая.

== Входные и выходные данные алгоритма ==

'''Входные данные''':
<math> a, b </math> - интервал интегрирования,
n - количество точек в разбиении,
<math> \bold y_0 </math> - вектор значений размерности m при <math> x = a </math>,
функцию вычисления производной <math>\bold f </math> будем считать встроенной в алгоритм.

'''Объём входных данных''':
m + 3

'''Выходные данные:'''
<math> \bold y_i </math> - вектора размера m значений в n узлах сетки (т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>).

'''Объем выходных данных'''
n * m

== Свойства алгоритма ==

= ЧАСТЬ. Программная реализация алгоритма =

== [[Особенности реализации последовательного алгоритма]] ==

== [[Локальность данных и вычислений]] ==

== [[Возможные способы и особенности параллельной реализации алгоритма]] ==

== Масштабируемость алгоритма и его реализации ==

== [[Динамические характеристики и эффективность реализации алгоритма]] ==

== [[Выводы для классов архитектур]] ==

== Существующие реализации алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является одним из наиболее используемых для решения ОДУ и их систем, поэтому существует большое число его реализаций для разных языков программирования. Наиболее популярными являются следующие из них:
* библиотека RK4, которая существует в вариантах для C++, FORTRAN90, FORTRAN77, python и MATLAB;
* библиотека ode45 для MATLAB;
* модуль scipy для PYTHON.

= Литература =

Участник:Борис/Алгоритм Рунге-Кутты

2016-10-15T20:04:06Z

Борис: /* Последовательная сложность алгоритма */

{{algorithm
| name = Метод Рунге-Кутты 4 порядка
| serial_complexity = <math>O()</math>
| pf_height = <math>O()</math>
| pf_width = <math>O()</math>
| input_data = <math>m + 3</math>
| output_data = <math>m * n</math>
}}

Основные авторы описания: [[Участник:Jest|Е.П.Степанов]]([[#Общее описание алгоритма|раздел 1.1]], [[#Математическое описание алгоритма|раздел 1.2]], [[#Вычислительное ядро алгоритма|раздел 1.3]], [[#Макроструктура алгоритма|раздел 1.4]], [[#Входные и выходные данные алгоритма|раздел 1.9]]), [[Участник:Борис|Б.Савков]] ( [[#Схема реализации последовательного алгоритма|раздел 1.5]], [[#Последовательная сложность алгоритма|раздел 1.6]], [[#Информационный граф|раздел 1.7]], [[#Ресурс параллелизма алгоритма|раздел 1.8]], [[#Существующие реализации алгоритма|раздел 2.7]])

= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==

Ме́тоды Ру́нге — Ку́тты (распространено неправильное название Ме́тоды Ру́нге — Ку́тта или же Ме́тоды Ру́нге — Кутта́) — важное семейство численных алгоритмов решения обыкновенных дифференциальных уравнений и их систем. Данные итеративные методы явного и неявного приближённого вычисления были разработаны около 1900 года немецкими математиками К. Рунге и М. В. Куттой.

Метод Рунге - Кутты применяется при решения задачи Коши для системы обыкновенных дифференциальных уравнений первого порядка:

:<math>
\begin{cases}
\textbf{y}' = \textbf{f}(x, \textbf{y}),\\
\textbf{y}(x_0) = \textbf{y}_0.
\end{cases}
</math>

При этом <math>\textbf{y}, \textbf{f}, x</math> отвечают следующим свойствам: <math> \textbf{y}, \textbf{f} \in \mathbb{R}^m, x \in \mathbb{R}^1 </math>.

Пусть известно значение y(x) и требуется вычислить значение y(x+h). Это можно сделать при помощи формулы:

:<math> y(x + h) = y(x) + \int_0^hy'(x + t)dt</math>

Аппроксимируя интеграл в правой части, можно получить методы Рунге-Кутты разного порядка точности. В общем виде формулы методов Рунге-Кутты можно записать следующим образом:

:<math>\textbf{y}_{n+1} = \textbf{y}_n + h\sum_{i=1}^s b_i \textbf{k}_i</math>

:<math>
\begin{array}{ll}
\textbf{k}_1 =& \textbf{f}(x_n, \textbf{y}_n),\\
\textbf{k}_2 =& \textbf{f}(x_n+c_2h, \textbf{y}_n+a_{21}h\textbf{k}_1),\\
\cdots&\\
\textbf{k}_s =& \textbf{f}(x_n+c_sh, \textbf{y}_n+a_{s1}h\textbf{k}_1+a_{s2}h\textbf{k}_2+\cdots+a_{s,s-1}h\textbf{k}_{s-1})
\end{array}
</math>

Увеличивая число s вспомогательных точек, можно построить методы Рунге-Кутты любого порядка точности p. Однако уже при p > 5 эти методы используются довольно редко. Это объясняется как чрезмерной громоздкостью получающихся вычислительных формул, так и тем, что преимущества методов высокого порядка точности над методами, в которых p = 4 или p = 5, проявляются либо в тех задачах, где нужна очень высокая точность и используются ЭВМ высокой разрядности, либо в тех задачах, где решение очень гладкое. Кроме того, методы Рунге-Кутты высокого порядка точности часто оказываются менее эффективными по сравнению с методами Адамса того же порядка точности. На этой странице представлен наиболее распространенный метод Рунге-Кутты 4 порядка с ошибкой на конечном интервале интегрирования <math>O(h^4)</math>.

Существуют как явные, так и неявные методы Рунге-Кутты. Последние имеют ряд преимуществ над явными методами, однако это достигается за счет существенного усложнения вычислительного алгоритма, так как на каждом шаге приходится считать систему нелинейных уравнений. На этой странице представлен явный метод Рунге-Кутты.

Можно отметить, что в современных программах, реализующих метод Рунге-Кутты, обязательно используется некоторый алгоритм автоматического изменения шага интегрирования. Интуитивно ясно, что на участках плавного изменения решения счет можно вести с достаточно крупным шагом. В то же время на тех участках, где происходят резкие изменения поведения решения, необходимо выбирать мелкий шаг интегрирования. Обычно начальное значение шага h1 задает пользователь. Далее шаг интегрирования меняется в соответствии с величиной получаемой в ходе вычислений оценки локальной погрешности. Для упрощения описания на этой странице используется постоянный шаг интегрирования h, зависящий от размера сетки разбиения n.

== Математическое описание алгоритма ==

Далее подразумевается, что <math> \bold y, \bold y_i,\bold f, \bold k_i \in \mathbb{R}^m</math>, а <math>x, h, n, a, b \in \mathbb{R}^1 </math>.

Исходные данные:
<math> a, b </math> - интервал интегрирования,
<math> \bold y_0 </math> - вектор значений при <math> x = a </math>,
n - количество точек в разбиении
<math>\bold f </math> - функция вычисления производной

Вычисляемые данные:
<math> \bold y_i </math> - вектора значений в узлах сетки, т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>

Формулы метода:
:Вначале вычисляется шаг сетки:
::<math> h = \frac{b-a}{n}</math>.
:Приближенное значение в следующих точках вычисляется по итерационной формуле:
::<math>\textbf{y}_{n+1} = \textbf{y}_n + {h \over 6}(\textbf{k}_1 + 2\textbf{k}_2 + 2\textbf{k}_3 + \textbf{k}_4)</math>,
::<math>\textbf{k}_1 = \textbf{f} \left( x_n, \textbf{y}_n \right),</math>
::<math>\textbf{k}_2 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_1 \right),</math>
::<math>\textbf{k}_3 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_2 \right),</math>
::<math>\textbf{k}_4 = \textbf{f} \left( x_n + h, \textbf{y}_n + h\ \textbf{k}_3 \right),</math>
::<math>x_{n+1} = x_n + h.</math>

== Вычислительное ядро алгоритма ==

Вычислительным ядром метода Рунге-Кутты можно считать вычисление значений функции производной
:<math>\textbf{f}(x, \textbf{y})</math>,
так как при вычислении каждого нового <math>\textbf{y}_n</math> требуется 4 вычисления значения функции производной. Таким образом, сложность работы алгоритма существенно зависит от сложности вычисления функции <math>\textbf{f}</math>.

== Макроструктура алгоритма ==

Макроструктура алгоритма может быть представлена в следующем виде:
:Вычисление вспомогательных коэффициентов <math>\textbf{k}_j, j \in [1,4]</math>;
:Вычисление приближенного значения <math> \bold y_i </math> в следующей точке;
:Переход на следующую итерацию или остановка.

== Схема реализации последовательного алгоритма ==

Пример реализации последовательного алгоритма на языке C++ (указатель на функцию f передаётся через аргументы представленной ниже функции):
<source lang="c++" line="1">
#include <vector>

// other code ...

std::vector<double> rungekutta4(double a, double b, std::vector<double> y0, int n, std::vector<double (*)(double,double)> f)
{
std::vector<double>::size_type sz = y0.size();
std::vector<double> result;
for (unsigned i=0; i<sz; i++)
{
rezult.push_back(core(a,b,y[i],n,f[i]));
}
return result;
}

double core(double a, double b, double y0, int n, double (*f)(double,double))
{
double h, k1, k2, k3, k4, x, y;
h = (b - a)/n;
y = y0;
x = a;
for (unsigned i = 0; i < n; i++)
{
k1 = f(x, y);
k2 = f(x + h/2, y + h*k1/2);
k3 = f(x + h/2, y + h*k2/2);
k4 = f(x + h/2, y + h*k3);
x += h;
y += h*(k1 + 2*k2 + 2*k3 + k4)/6;
}
return y;
}

// other code ...
</source>

== Последовательная сложность алгоритма ==

Рассмотрим сначала одномерный случай. Наравне с обычными операциями, такими как сложение, умножение и тому подобными, в представленном выше алгоритме присутствует вызов функции <math>\bold f </math>. Так как эта функция может содержать в себе любое количество простых математических операций, будем считать, что её сложность <math>\bold f </math> много больше любой из них, и равна константе <math>C</math>. За весь алгоритм, она вызывается <math>4n</math> раза. Таким образом, сложность последовательного алгоритма для одномерного случая равна <math>4nC</math>.

Для случая решения системы ОДУ, когда <math>f</math> и <math>y</math> являются векторами размерности <math>m</math>, функция core будет вызвана <math>m</math>, и итоговая сложность алгоритма составит <math>4nCm</math>.

== Информационный граф ==

== Ресурс параллелизма алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является итерационным алгоритмом. В нём каждый шаг цикла зависит от предыдущего. В самом шаге, каждая последующая операция также зависит от результата предыдущей. Таким образом, упразднить цикл до независимых и соответственно параллельных операций не является возможным. Однако, так как на результат функции <math> \bold f </math> влияет только <math>i</math>-ый параметр векторов <math> f </math> и <math> y </math>, то для каждого <math> i </math> можно производить независимое вычисление. В итоге, если вычислять результаты выполнения функции <math> \bold f </math> одновременно для вля всех <math> i</math>-ых параметров векторов <math> f </math> и <math> y </math>, получим туже алгоритмическую сложность <math>4nC</math>, что и в [[#Последовательная сложность алгоритма|разделе 1.6]] для одномерного случая.

== Входные и выходные данные алгоритма ==

'''Входные данные''':
<math> a, b </math> - интервал интегрирования,
n - количество точек в разбиении,
<math> \bold y_0 </math> - вектор значений размерности m при <math> x = a </math>,
функцию вычисления производной <math>\bold f </math> будем считать встроенной в алгоритм.

'''Объём входных данных''':
m + 3

'''Выходные данные:'''
<math> \bold y_i </math> - вектора размера m значений в n узлах сетки (т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>).

'''Объем выходных данных'''
n * m

== Свойства алгоритма ==

= ЧАСТЬ. Программная реализация алгоритма =

== [[Особенности реализации последовательного алгоритма]] ==

== [[Локальность данных и вычислений]] ==

== [[Возможные способы и особенности параллельной реализации алгоритма]] ==

== Масштабируемость алгоритма и его реализации ==

== [[Динамические характеристики и эффективность реализации алгоритма]] ==

== [[Выводы для классов архитектур]] ==

== Существующие реализации алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является одним из наиболее используемых для решения ОДУ и их систем, поэтому существует большое число его реализаций для разных языков программирования. Наиболее популярными являются следующие из них:
* библиотека RK4, которая существует в вариантах для C++, FORTRAN90, FORTRAN77, python и MATLAB;
* библиотека ode45 для MATLAB;
* модуль scipy для PYTHON.

= Литература =

Участник:Борис/Алгоритм Рунге-Кутты

2016-10-15T20:03:14Z

Борис: /* Ресурс параллелизма алгоритма */

{{algorithm
| name = Метод Рунге-Кутты 4 порядка
| serial_complexity = <math>O()</math>
| pf_height = <math>O()</math>
| pf_width = <math>O()</math>
| input_data = <math>m + 3</math>
| output_data = <math>m * n</math>
}}

Основные авторы описания: [[Участник:Jest|Е.П.Степанов]]([[#Общее описание алгоритма|раздел 1.1]], [[#Математическое описание алгоритма|раздел 1.2]], [[#Вычислительное ядро алгоритма|раздел 1.3]], [[#Макроструктура алгоритма|раздел 1.4]], [[#Входные и выходные данные алгоритма|раздел 1.9]]), [[Участник:Борис|Б.Савков]] ( [[#Схема реализации последовательного алгоритма|раздел 1.5]], [[#Последовательная сложность алгоритма|раздел 1.6]], [[#Информационный граф|раздел 1.7]], [[#Ресурс параллелизма алгоритма|раздел 1.8]], [[#Существующие реализации алгоритма|раздел 2.7]])

= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==

Ме́тоды Ру́нге — Ку́тты (распространено неправильное название Ме́тоды Ру́нге — Ку́тта или же Ме́тоды Ру́нге — Кутта́) — важное семейство численных алгоритмов решения обыкновенных дифференциальных уравнений и их систем. Данные итеративные методы явного и неявного приближённого вычисления были разработаны около 1900 года немецкими математиками К. Рунге и М. В. Куттой.

Метод Рунге - Кутты применяется при решения задачи Коши для системы обыкновенных дифференциальных уравнений первого порядка:

:<math>
\begin{cases}
\textbf{y}' = \textbf{f}(x, \textbf{y}),\\
\textbf{y}(x_0) = \textbf{y}_0.
\end{cases}
</math>

При этом <math>\textbf{y}, \textbf{f}, x</math> отвечают следующим свойствам: <math> \textbf{y}, \textbf{f} \in \mathbb{R}^m, x \in \mathbb{R}^1 </math>.

Пусть известно значение y(x) и требуется вычислить значение y(x+h). Это можно сделать при помощи формулы:

:<math> y(x + h) = y(x) + \int_0^hy'(x + t)dt</math>

Аппроксимируя интеграл в правой части, можно получить методы Рунге-Кутты разного порядка точности. В общем виде формулы методов Рунге-Кутты можно записать следующим образом:

:<math>\textbf{y}_{n+1} = \textbf{y}_n + h\sum_{i=1}^s b_i \textbf{k}_i</math>

:<math>
\begin{array}{ll}
\textbf{k}_1 =& \textbf{f}(x_n, \textbf{y}_n),\\
\textbf{k}_2 =& \textbf{f}(x_n+c_2h, \textbf{y}_n+a_{21}h\textbf{k}_1),\\
\cdots&\\
\textbf{k}_s =& \textbf{f}(x_n+c_sh, \textbf{y}_n+a_{s1}h\textbf{k}_1+a_{s2}h\textbf{k}_2+\cdots+a_{s,s-1}h\textbf{k}_{s-1})
\end{array}
</math>

Увеличивая число s вспомогательных точек, можно построить методы Рунге-Кутты любого порядка точности p. Однако уже при p > 5 эти методы используются довольно редко. Это объясняется как чрезмерной громоздкостью получающихся вычислительных формул, так и тем, что преимущества методов высокого порядка точности над методами, в которых p = 4 или p = 5, проявляются либо в тех задачах, где нужна очень высокая точность и используются ЭВМ высокой разрядности, либо в тех задачах, где решение очень гладкое. Кроме того, методы Рунге-Кутты высокого порядка точности часто оказываются менее эффективными по сравнению с методами Адамса того же порядка точности. На этой странице представлен наиболее распространенный метод Рунге-Кутты 4 порядка с ошибкой на конечном интервале интегрирования <math>O(h^4)</math>.

Существуют как явные, так и неявные методы Рунге-Кутты. Последние имеют ряд преимуществ над явными методами, однако это достигается за счет существенного усложнения вычислительного алгоритма, так как на каждом шаге приходится считать систему нелинейных уравнений. На этой странице представлен явный метод Рунге-Кутты.

Можно отметить, что в современных программах, реализующих метод Рунге-Кутты, обязательно используется некоторый алгоритм автоматического изменения шага интегрирования. Интуитивно ясно, что на участках плавного изменения решения счет можно вести с достаточно крупным шагом. В то же время на тех участках, где происходят резкие изменения поведения решения, необходимо выбирать мелкий шаг интегрирования. Обычно начальное значение шага h1 задает пользователь. Далее шаг интегрирования меняется в соответствии с величиной получаемой в ходе вычислений оценки локальной погрешности. Для упрощения описания на этой странице используется постоянный шаг интегрирования h, зависящий от размера сетки разбиения n.

== Математическое описание алгоритма ==

Далее подразумевается, что <math> \bold y, \bold y_i,\bold f, \bold k_i \in \mathbb{R}^m</math>, а <math>x, h, n, a, b \in \mathbb{R}^1 </math>.

Исходные данные:
<math> a, b </math> - интервал интегрирования,
<math> \bold y_0 </math> - вектор значений при <math> x = a </math>,
n - количество точек в разбиении
<math>\bold f </math> - функция вычисления производной

Вычисляемые данные:
<math> \bold y_i </math> - вектора значений в узлах сетки, т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>

Формулы метода:
:Вначале вычисляется шаг сетки:
::<math> h = \frac{b-a}{n}</math>.
:Приближенное значение в следующих точках вычисляется по итерационной формуле:
::<math>\textbf{y}_{n+1} = \textbf{y}_n + {h \over 6}(\textbf{k}_1 + 2\textbf{k}_2 + 2\textbf{k}_3 + \textbf{k}_4)</math>,
::<math>\textbf{k}_1 = \textbf{f} \left( x_n, \textbf{y}_n \right),</math>
::<math>\textbf{k}_2 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_1 \right),</math>
::<math>\textbf{k}_3 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_2 \right),</math>
::<math>\textbf{k}_4 = \textbf{f} \left( x_n + h, \textbf{y}_n + h\ \textbf{k}_3 \right),</math>
::<math>x_{n+1} = x_n + h.</math>

== Вычислительное ядро алгоритма ==

Вычислительным ядром метода Рунге-Кутты можно считать вычисление значений функции производной
:<math>\textbf{f}(x, \textbf{y})</math>,
так как при вычислении каждого нового <math>\textbf{y}_n</math> требуется 4 вычисления значения функции производной. Таким образом, сложность работы алгоритма существенно зависит от сложности вычисления функции <math>\textbf{f}</math>.

== Макроструктура алгоритма ==

Макроструктура алгоритма может быть представлена в следующем виде:
:Вычисление вспомогательных коэффициентов <math>\textbf{k}_j, j \in [1,4]</math>;
:Вычисление приближенного значения <math> \bold y_i </math> в следующей точке;
:Переход на следующую итерацию или остановка.

== Схема реализации последовательного алгоритма ==

Пример реализации последовательного алгоритма на языке C++ (указатель на функцию f передаётся через аргументы представленной ниже функции):
<source lang="c++" line="1">
#include <vector>

// other code ...

std::vector<double> rungekutta4(double a, double b, std::vector<double> y0, int n, std::vector<double (*)(double,double)> f)
{
std::vector<double>::size_type sz = y0.size();
std::vector<double> result;
for (unsigned i=0; i<sz; i++)
{
rezult.push_back(core(a,b,y[i],n,f[i]));
}
return result;
}

double core(double a, double b, double y0, int n, double (*f)(double,double))
{
double h, k1, k2, k3, k4, x, y;
h = (b - a)/n;
y = y0;
x = a;
for (unsigned i = 0; i < n; i++)
{
k1 = f(x, y);
k2 = f(x + h/2, y + h*k1/2);
k3 = f(x + h/2, y + h*k2/2);
k4 = f(x + h/2, y + h*k3);
x += h;
y += h*(k1 + 2*k2 + 2*k3 + k4)/6;
}
return y;
}

// other code ...
</source>

== Последовательная сложность алгоритма ==

Рассмотрим сначала одномерный случай. Наравне с обычными операциями, такими как сложение, умножение и тому подобными, в представленном выше алгоритме присутствует вызов функции <math>\bold f </math>. Так как эта функция может содержать в себе любое количество простых математических операций, будем считать, что её сложность <math>\bold f </math> много больше любой из них, и равна константе <math>C</math>. За весь алгоритм, она вызывается <math>4n</math> раза. Таким образом, сложность последовательного алгоритма для одномерного случая равна <math>4nC</math>.

Для многомерного случая, когда <math>f</math> и <math>y</math> являются векторами размерности <math>m</math>, функция core будет вызвана <math>m</math>, и итоговая сложность алгоритма составит <math>4nCm</math>.

== Информационный граф ==

== Ресурс параллелизма алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является итерационным алгоритмом. В нём каждый шаг цикла зависит от предыдущего. В самом шаге, каждая последующая операция также зависит от результата предыдущей. Таким образом, упразднить цикл до независимых и соответственно параллельных операций не является возможным. Однако, так как на результат функции <math> \bold f </math> влияет только <math>i</math>-ый параметр векторов <math> f </math> и <math> y </math>, то для каждого <math> i </math> можно производить независимое вычисление. В итоге, если вычислять результаты выполнения функции <math> \bold f </math> одновременно для вля всех <math> i</math>-ых параметров векторов <math> f </math> и <math> y </math>, получим туже алгоритмическую сложность <math>4nC</math>, что и в [[#Последовательная сложность алгоритма|разделе 1.6]] для одномерного случая.

== Входные и выходные данные алгоритма ==

'''Входные данные''':
<math> a, b </math> - интервал интегрирования,
n - количество точек в разбиении,
<math> \bold y_0 </math> - вектор значений размерности m при <math> x = a </math>,
функцию вычисления производной <math>\bold f </math> будем считать встроенной в алгоритм.

'''Объём входных данных''':
m + 3

'''Выходные данные:'''
<math> \bold y_i </math> - вектора размера m значений в n узлах сетки (т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>).

'''Объем выходных данных'''
n * m

== Свойства алгоритма ==

= ЧАСТЬ. Программная реализация алгоритма =

== [[Особенности реализации последовательного алгоритма]] ==

== [[Локальность данных и вычислений]] ==

== [[Возможные способы и особенности параллельной реализации алгоритма]] ==

== Масштабируемость алгоритма и его реализации ==

== [[Динамические характеристики и эффективность реализации алгоритма]] ==

== [[Выводы для классов архитектур]] ==

== Существующие реализации алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является одним из наиболее используемых для решения ОДУ и их систем, поэтому существует большое число его реализаций для разных языков программирования. Наиболее популярными являются следующие из них:
* библиотека RK4, которая существует в вариантах для C++, FORTRAN90, FORTRAN77, python и MATLAB;
* библиотека ode45 для MATLAB;
* модуль scipy для PYTHON.

= Литература =

Участник:Борис/Алгоритм Рунге-Кутты

2016-10-15T20:02:13Z

Борис: /* Ресурс параллелизма алгоритма */

{{algorithm
| name = Метод Рунге-Кутты 4 порядка
| serial_complexity = <math>O()</math>
| pf_height = <math>O()</math>
| pf_width = <math>O()</math>
| input_data = <math>m + 3</math>
| output_data = <math>m * n</math>
}}

Основные авторы описания: [[Участник:Jest|Е.П.Степанов]]([[#Общее описание алгоритма|раздел 1.1]], [[#Математическое описание алгоритма|раздел 1.2]], [[#Вычислительное ядро алгоритма|раздел 1.3]], [[#Макроструктура алгоритма|раздел 1.4]], [[#Входные и выходные данные алгоритма|раздел 1.9]]), [[Участник:Борис|Б.Савков]] ( [[#Схема реализации последовательного алгоритма|раздел 1.5]], [[#Последовательная сложность алгоритма|раздел 1.6]], [[#Информационный граф|раздел 1.7]], [[#Ресурс параллелизма алгоритма|раздел 1.8]], [[#Существующие реализации алгоритма|раздел 2.7]])

= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==

Ме́тоды Ру́нге — Ку́тты (распространено неправильное название Ме́тоды Ру́нге — Ку́тта или же Ме́тоды Ру́нге — Кутта́) — важное семейство численных алгоритмов решения обыкновенных дифференциальных уравнений и их систем. Данные итеративные методы явного и неявного приближённого вычисления были разработаны около 1900 года немецкими математиками К. Рунге и М. В. Куттой.

Метод Рунге - Кутты применяется при решения задачи Коши для системы обыкновенных дифференциальных уравнений первого порядка:

:<math>
\begin{cases}
\textbf{y}' = \textbf{f}(x, \textbf{y}),\\
\textbf{y}(x_0) = \textbf{y}_0.
\end{cases}
</math>

При этом <math>\textbf{y}, \textbf{f}, x</math> отвечают следующим свойствам: <math> \textbf{y}, \textbf{f} \in \mathbb{R}^m, x \in \mathbb{R}^1 </math>.

Пусть известно значение y(x) и требуется вычислить значение y(x+h). Это можно сделать при помощи формулы:

:<math> y(x + h) = y(x) + \int_0^hy'(x + t)dt</math>

Аппроксимируя интеграл в правой части, можно получить методы Рунге-Кутты разного порядка точности. В общем виде формулы методов Рунге-Кутты можно записать следующим образом:

:<math>\textbf{y}_{n+1} = \textbf{y}_n + h\sum_{i=1}^s b_i \textbf{k}_i</math>

:<math>
\begin{array}{ll}
\textbf{k}_1 =& \textbf{f}(x_n, \textbf{y}_n),\\
\textbf{k}_2 =& \textbf{f}(x_n+c_2h, \textbf{y}_n+a_{21}h\textbf{k}_1),\\
\cdots&\\
\textbf{k}_s =& \textbf{f}(x_n+c_sh, \textbf{y}_n+a_{s1}h\textbf{k}_1+a_{s2}h\textbf{k}_2+\cdots+a_{s,s-1}h\textbf{k}_{s-1})
\end{array}
</math>

Увеличивая число s вспомогательных точек, можно построить методы Рунге-Кутты любого порядка точности p. Однако уже при p > 5 эти методы используются довольно редко. Это объясняется как чрезмерной громоздкостью получающихся вычислительных формул, так и тем, что преимущества методов высокого порядка точности над методами, в которых p = 4 или p = 5, проявляются либо в тех задачах, где нужна очень высокая точность и используются ЭВМ высокой разрядности, либо в тех задачах, где решение очень гладкое. Кроме того, методы Рунге-Кутты высокого порядка точности часто оказываются менее эффективными по сравнению с методами Адамса того же порядка точности. На этой странице представлен наиболее распространенный метод Рунге-Кутты 4 порядка с ошибкой на конечном интервале интегрирования <math>O(h^4)</math>.

Существуют как явные, так и неявные методы Рунге-Кутты. Последние имеют ряд преимуществ над явными методами, однако это достигается за счет существенного усложнения вычислительного алгоритма, так как на каждом шаге приходится считать систему нелинейных уравнений. На этой странице представлен явный метод Рунге-Кутты.

Можно отметить, что в современных программах, реализующих метод Рунге-Кутты, обязательно используется некоторый алгоритм автоматического изменения шага интегрирования. Интуитивно ясно, что на участках плавного изменения решения счет можно вести с достаточно крупным шагом. В то же время на тех участках, где происходят резкие изменения поведения решения, необходимо выбирать мелкий шаг интегрирования. Обычно начальное значение шага h1 задает пользователь. Далее шаг интегрирования меняется в соответствии с величиной получаемой в ходе вычислений оценки локальной погрешности. Для упрощения описания на этой странице используется постоянный шаг интегрирования h, зависящий от размера сетки разбиения n.

== Математическое описание алгоритма ==

Далее подразумевается, что <math> \bold y, \bold y_i,\bold f, \bold k_i \in \mathbb{R}^m</math>, а <math>x, h, n, a, b \in \mathbb{R}^1 </math>.

Исходные данные:
<math> a, b </math> - интервал интегрирования,
<math> \bold y_0 </math> - вектор значений при <math> x = a </math>,
n - количество точек в разбиении
<math>\bold f </math> - функция вычисления производной

Вычисляемые данные:
<math> \bold y_i </math> - вектора значений в узлах сетки, т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>

Формулы метода:
:Вначале вычисляется шаг сетки:
::<math> h = \frac{b-a}{n}</math>.
:Приближенное значение в следующих точках вычисляется по итерационной формуле:
::<math>\textbf{y}_{n+1} = \textbf{y}_n + {h \over 6}(\textbf{k}_1 + 2\textbf{k}_2 + 2\textbf{k}_3 + \textbf{k}_4)</math>,
::<math>\textbf{k}_1 = \textbf{f} \left( x_n, \textbf{y}_n \right),</math>
::<math>\textbf{k}_2 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_1 \right),</math>
::<math>\textbf{k}_3 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_2 \right),</math>
::<math>\textbf{k}_4 = \textbf{f} \left( x_n + h, \textbf{y}_n + h\ \textbf{k}_3 \right),</math>
::<math>x_{n+1} = x_n + h.</math>

== Вычислительное ядро алгоритма ==

Вычислительным ядром метода Рунге-Кутты можно считать вычисление значений функции производной
:<math>\textbf{f}(x, \textbf{y})</math>,
так как при вычислении каждого нового <math>\textbf{y}_n</math> требуется 4 вычисления значения функции производной. Таким образом, сложность работы алгоритма существенно зависит от сложности вычисления функции <math>\textbf{f}</math>.

== Макроструктура алгоритма ==

Макроструктура алгоритма может быть представлена в следующем виде:
:Вычисление вспомогательных коэффициентов <math>\textbf{k}_j, j \in [1,4]</math>;
:Вычисление приближенного значения <math> \bold y_i </math> в следующей точке;
:Переход на следующую итерацию или остановка.

== Схема реализации последовательного алгоритма ==

Пример реализации последовательного алгоритма на языке C++ (указатель на функцию f передаётся через аргументы представленной ниже функции):
<source lang="c++" line="1">
#include <vector>

// other code ...

std::vector<double> rungekutta4(double a, double b, std::vector<double> y0, int n, std::vector<double (*)(double,double)> f)
{
std::vector<double>::size_type sz = y0.size();
std::vector<double> result;
for (unsigned i=0; i<sz; i++)
{
rezult.push_back(core(a,b,y[i],n,f[i]));
}
return result;
}

double core(double a, double b, double y0, int n, double (*f)(double,double))
{
double h, k1, k2, k3, k4, x, y;
h = (b - a)/n;
y = y0;
x = a;
for (unsigned i = 0; i < n; i++)
{
k1 = f(x, y);
k2 = f(x + h/2, y + h*k1/2);
k3 = f(x + h/2, y + h*k2/2);
k4 = f(x + h/2, y + h*k3);
x += h;
y += h*(k1 + 2*k2 + 2*k3 + k4)/6;
}
return y;
}

// other code ...
</source>

== Последовательная сложность алгоритма ==

Рассмотрим сначала одномерный случай. Наравне с обычными операциями, такими как сложение, умножение и тому подобными, в представленном выше алгоритме присутствует вызов функции <math>\bold f </math>. Так как эта функция может содержать в себе любое количество простых математических операций, будем считать, что её сложность <math>\bold f </math> много больше любой из них, и равна константе <math>C</math>. За весь алгоритм, она вызывается <math>4n</math> раза. Таким образом, сложность последовательного алгоритма для одномерного случая равна <math>4nC</math>.

Для многомерного случая, когда <math>f</math> и <math>y</math> являются векторами размерности <math>m</math>, функция core будет вызвана <math>m</math>, и итоговая сложность алгоритма составит <math>4nCm</math>.

== Информационный граф ==

== Ресурс параллелизма алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является итерационным алгоритмом. В нём каждый шаг цикла зависит от предыдущего. В самом шаге, каждая последующая операция также зависит от результата предыдущей. Таким образом, упразднить цикл до независимых и соответственно параллельных операций не является возможным. Однако, так как на результат функции <math> \bold f </math> влияет только <math>i</math>-ый параметр векторов <math> f </math> и <math> \bold y </math>, то для каждого <math> i </math> можно производить независимое вычисление. В итоге, если вычислять результаты выполнения функции <math> \bold f </math> одновременно для вля всех <math>\bold i</math>-ых параметров векторов <math> f </math> и <math> \bold y </math>, получим туже алгоритмическую сложность <math>4nC</math>, что и в [[#Последовательная сложность алгоритма|разделе 1.6]] для одномерного случая.

== Входные и выходные данные алгоритма ==

'''Входные данные''':
<math> a, b </math> - интервал интегрирования,
n - количество точек в разбиении,
<math> \bold y_0 </math> - вектор значений размерности m при <math> x = a </math>,
функцию вычисления производной <math>\bold f </math> будем считать встроенной в алгоритм.

'''Объём входных данных''':
m + 3

'''Выходные данные:'''
<math> \bold y_i </math> - вектора размера m значений в n узлах сетки (т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>).

'''Объем выходных данных'''
n * m

== Свойства алгоритма ==

= ЧАСТЬ. Программная реализация алгоритма =

== [[Особенности реализации последовательного алгоритма]] ==

== [[Локальность данных и вычислений]] ==

== [[Возможные способы и особенности параллельной реализации алгоритма]] ==

== Масштабируемость алгоритма и его реализации ==

== [[Динамические характеристики и эффективность реализации алгоритма]] ==

== [[Выводы для классов архитектур]] ==

== Существующие реализации алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является одним из наиболее используемых для решения ОДУ и их систем, поэтому существует большое число его реализаций для разных языков программирования. Наиболее популярными являются следующие из них:
* библиотека RK4, которая существует в вариантах для C++, FORTRAN90, FORTRAN77, python и MATLAB;
* библиотека ode45 для MATLAB;
* модуль scipy для PYTHON.

= Литература =

Участник:Борис/Алгоритм Рунге-Кутты

2016-10-15T20:01:34Z

Борис: /* Последовательная сложность алгоритма */

{{algorithm
| name = Метод Рунге-Кутты 4 порядка
| serial_complexity = <math>O()</math>
| pf_height = <math>O()</math>
| pf_width = <math>O()</math>
| input_data = <math>m + 3</math>
| output_data = <math>m * n</math>
}}

Основные авторы описания: [[Участник:Jest|Е.П.Степанов]]([[#Общее описание алгоритма|раздел 1.1]], [[#Математическое описание алгоритма|раздел 1.2]], [[#Вычислительное ядро алгоритма|раздел 1.3]], [[#Макроструктура алгоритма|раздел 1.4]], [[#Входные и выходные данные алгоритма|раздел 1.9]]), [[Участник:Борис|Б.Савков]] ( [[#Схема реализации последовательного алгоритма|раздел 1.5]], [[#Последовательная сложность алгоритма|раздел 1.6]], [[#Информационный граф|раздел 1.7]], [[#Ресурс параллелизма алгоритма|раздел 1.8]], [[#Существующие реализации алгоритма|раздел 2.7]])

= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==

Ме́тоды Ру́нге — Ку́тты (распространено неправильное название Ме́тоды Ру́нге — Ку́тта или же Ме́тоды Ру́нге — Кутта́) — важное семейство численных алгоритмов решения обыкновенных дифференциальных уравнений и их систем. Данные итеративные методы явного и неявного приближённого вычисления были разработаны около 1900 года немецкими математиками К. Рунге и М. В. Куттой.

Метод Рунге - Кутты применяется при решения задачи Коши для системы обыкновенных дифференциальных уравнений первого порядка:

:<math>
\begin{cases}
\textbf{y}' = \textbf{f}(x, \textbf{y}),\\
\textbf{y}(x_0) = \textbf{y}_0.
\end{cases}
</math>

При этом <math>\textbf{y}, \textbf{f}, x</math> отвечают следующим свойствам: <math> \textbf{y}, \textbf{f} \in \mathbb{R}^m, x \in \mathbb{R}^1 </math>.

Пусть известно значение y(x) и требуется вычислить значение y(x+h). Это можно сделать при помощи формулы:

:<math> y(x + h) = y(x) + \int_0^hy'(x + t)dt</math>

Аппроксимируя интеграл в правой части, можно получить методы Рунге-Кутты разного порядка точности. В общем виде формулы методов Рунге-Кутты можно записать следующим образом:

:<math>\textbf{y}_{n+1} = \textbf{y}_n + h\sum_{i=1}^s b_i \textbf{k}_i</math>

:<math>
\begin{array}{ll}
\textbf{k}_1 =& \textbf{f}(x_n, \textbf{y}_n),\\
\textbf{k}_2 =& \textbf{f}(x_n+c_2h, \textbf{y}_n+a_{21}h\textbf{k}_1),\\
\cdots&\\
\textbf{k}_s =& \textbf{f}(x_n+c_sh, \textbf{y}_n+a_{s1}h\textbf{k}_1+a_{s2}h\textbf{k}_2+\cdots+a_{s,s-1}h\textbf{k}_{s-1})
\end{array}
</math>

Увеличивая число s вспомогательных точек, можно построить методы Рунге-Кутты любого порядка точности p. Однако уже при p > 5 эти методы используются довольно редко. Это объясняется как чрезмерной громоздкостью получающихся вычислительных формул, так и тем, что преимущества методов высокого порядка точности над методами, в которых p = 4 или p = 5, проявляются либо в тех задачах, где нужна очень высокая точность и используются ЭВМ высокой разрядности, либо в тех задачах, где решение очень гладкое. Кроме того, методы Рунге-Кутты высокого порядка точности часто оказываются менее эффективными по сравнению с методами Адамса того же порядка точности. На этой странице представлен наиболее распространенный метод Рунге-Кутты 4 порядка с ошибкой на конечном интервале интегрирования <math>O(h^4)</math>.

Существуют как явные, так и неявные методы Рунге-Кутты. Последние имеют ряд преимуществ над явными методами, однако это достигается за счет существенного усложнения вычислительного алгоритма, так как на каждом шаге приходится считать систему нелинейных уравнений. На этой странице представлен явный метод Рунге-Кутты.

Можно отметить, что в современных программах, реализующих метод Рунге-Кутты, обязательно используется некоторый алгоритм автоматического изменения шага интегрирования. Интуитивно ясно, что на участках плавного изменения решения счет можно вести с достаточно крупным шагом. В то же время на тех участках, где происходят резкие изменения поведения решения, необходимо выбирать мелкий шаг интегрирования. Обычно начальное значение шага h1 задает пользователь. Далее шаг интегрирования меняется в соответствии с величиной получаемой в ходе вычислений оценки локальной погрешности. Для упрощения описания на этой странице используется постоянный шаг интегрирования h, зависящий от размера сетки разбиения n.

== Математическое описание алгоритма ==

Далее подразумевается, что <math> \bold y, \bold y_i,\bold f, \bold k_i \in \mathbb{R}^m</math>, а <math>x, h, n, a, b \in \mathbb{R}^1 </math>.

Исходные данные:
<math> a, b </math> - интервал интегрирования,
<math> \bold y_0 </math> - вектор значений при <math> x = a </math>,
n - количество точек в разбиении
<math>\bold f </math> - функция вычисления производной

Вычисляемые данные:
<math> \bold y_i </math> - вектора значений в узлах сетки, т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>

Формулы метода:
:Вначале вычисляется шаг сетки:
::<math> h = \frac{b-a}{n}</math>.
:Приближенное значение в следующих точках вычисляется по итерационной формуле:
::<math>\textbf{y}_{n+1} = \textbf{y}_n + {h \over 6}(\textbf{k}_1 + 2\textbf{k}_2 + 2\textbf{k}_3 + \textbf{k}_4)</math>,
::<math>\textbf{k}_1 = \textbf{f} \left( x_n, \textbf{y}_n \right),</math>
::<math>\textbf{k}_2 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_1 \right),</math>
::<math>\textbf{k}_3 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_2 \right),</math>
::<math>\textbf{k}_4 = \textbf{f} \left( x_n + h, \textbf{y}_n + h\ \textbf{k}_3 \right),</math>
::<math>x_{n+1} = x_n + h.</math>

== Вычислительное ядро алгоритма ==

Вычислительным ядром метода Рунге-Кутты можно считать вычисление значений функции производной
:<math>\textbf{f}(x, \textbf{y})</math>,
так как при вычислении каждого нового <math>\textbf{y}_n</math> требуется 4 вычисления значения функции производной. Таким образом, сложность работы алгоритма существенно зависит от сложности вычисления функции <math>\textbf{f}</math>.

== Макроструктура алгоритма ==

Макроструктура алгоритма может быть представлена в следующем виде:
:Вычисление вспомогательных коэффициентов <math>\textbf{k}_j, j \in [1,4]</math>;
:Вычисление приближенного значения <math> \bold y_i </math> в следующей точке;
:Переход на следующую итерацию или остановка.

== Схема реализации последовательного алгоритма ==

Пример реализации последовательного алгоритма на языке C++ (указатель на функцию f передаётся через аргументы представленной ниже функции):
<source lang="c++" line="1">
#include <vector>

// other code ...

std::vector<double> rungekutta4(double a, double b, std::vector<double> y0, int n, std::vector<double (*)(double,double)> f)
{
std::vector<double>::size_type sz = y0.size();
std::vector<double> result;
for (unsigned i=0; i<sz; i++)
{
rezult.push_back(core(a,b,y[i],n,f[i]));
}
return result;
}

double core(double a, double b, double y0, int n, double (*f)(double,double))
{
double h, k1, k2, k3, k4, x, y;
h = (b - a)/n;
y = y0;
x = a;
for (unsigned i = 0; i < n; i++)
{
k1 = f(x, y);
k2 = f(x + h/2, y + h*k1/2);
k3 = f(x + h/2, y + h*k2/2);
k4 = f(x + h/2, y + h*k3);
x += h;
y += h*(k1 + 2*k2 + 2*k3 + k4)/6;
}
return y;
}

// other code ...
</source>

== Последовательная сложность алгоритма ==

Рассмотрим сначала одномерный случай. Наравне с обычными операциями, такими как сложение, умножение и тому подобными, в представленном выше алгоритме присутствует вызов функции <math>\bold f </math>. Так как эта функция может содержать в себе любое количество простых математических операций, будем считать, что её сложность <math>\bold f </math> много больше любой из них, и равна константе <math>C</math>. За весь алгоритм, она вызывается <math>4n</math> раза. Таким образом, сложность последовательного алгоритма для одномерного случая равна <math>4nC</math>.

Для многомерного случая, когда <math>f</math> и <math>y</math> являются векторами размерности <math>m</math>, функция core будет вызвана <math>m</math>, и итоговая сложность алгоритма составит <math>4nCm</math>.

== Информационный граф ==

== Ресурс параллелизма алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является итерационным алгоритмом. В нём каждый шаг цикла зависит от предыдущего. В самом шаге, каждая последующая операция также зависит от результата предыдущей. Таким образом, упразднить цикл до независимых и соответственно параллельных операций не является возможным. Однако, так как на результат функции <math> \bold f </math> влияет только <math>i</math>-ый параметр векторов <math> \bold x </math> и <math> \bold y </math>, то для каждого <math> i </math> можно производить независимое вычисление. В итоге, если вычислять результаты выполнения функции <math> \bold f </math> одновременно для вля всех <math>\bold i</math>-ых параметров векторов <math> \bold x </math> и <math> \bold y </math>, получим туже алгоритмическую сложность <math>4nC</math>, что и в [[#Последовательная сложность алгоритма|разделе 1.6]] для одномерного случая.

== Входные и выходные данные алгоритма ==

'''Входные данные''':
<math> a, b </math> - интервал интегрирования,
n - количество точек в разбиении,
<math> \bold y_0 </math> - вектор значений размерности m при <math> x = a </math>,
функцию вычисления производной <math>\bold f </math> будем считать встроенной в алгоритм.

'''Объём входных данных''':
m + 3

'''Выходные данные:'''
<math> \bold y_i </math> - вектора размера m значений в n узлах сетки (т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>).

'''Объем выходных данных'''
n * m

== Свойства алгоритма ==

= ЧАСТЬ. Программная реализация алгоритма =

== [[Особенности реализации последовательного алгоритма]] ==

== [[Локальность данных и вычислений]] ==

== [[Возможные способы и особенности параллельной реализации алгоритма]] ==

== Масштабируемость алгоритма и его реализации ==

== [[Динамические характеристики и эффективность реализации алгоритма]] ==

== [[Выводы для классов архитектур]] ==

== Существующие реализации алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является одним из наиболее используемых для решения ОДУ и их систем, поэтому существует большое число его реализаций для разных языков программирования. Наиболее популярными являются следующие из них:
* библиотека RK4, которая существует в вариантах для C++, FORTRAN90, FORTRAN77, python и MATLAB;
* библиотека ode45 для MATLAB;
* модуль scipy для PYTHON.

= Литература =

Участник:Борис/Алгоритм Рунге-Кутты

2016-10-15T20:01:00Z

Борис: /* Схема реализации последовательного алгоритма */

{{algorithm
| name = Метод Рунге-Кутты 4 порядка
| serial_complexity = <math>O()</math>
| pf_height = <math>O()</math>
| pf_width = <math>O()</math>
| input_data = <math>m + 3</math>
| output_data = <math>m * n</math>
}}

Основные авторы описания: [[Участник:Jest|Е.П.Степанов]]([[#Общее описание алгоритма|раздел 1.1]], [[#Математическое описание алгоритма|раздел 1.2]], [[#Вычислительное ядро алгоритма|раздел 1.3]], [[#Макроструктура алгоритма|раздел 1.4]], [[#Входные и выходные данные алгоритма|раздел 1.9]]), [[Участник:Борис|Б.Савков]] ( [[#Схема реализации последовательного алгоритма|раздел 1.5]], [[#Последовательная сложность алгоритма|раздел 1.6]], [[#Информационный граф|раздел 1.7]], [[#Ресурс параллелизма алгоритма|раздел 1.8]], [[#Существующие реализации алгоритма|раздел 2.7]])

= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==

Ме́тоды Ру́нге — Ку́тты (распространено неправильное название Ме́тоды Ру́нге — Ку́тта или же Ме́тоды Ру́нге — Кутта́) — важное семейство численных алгоритмов решения обыкновенных дифференциальных уравнений и их систем. Данные итеративные методы явного и неявного приближённого вычисления были разработаны около 1900 года немецкими математиками К. Рунге и М. В. Куттой.

Метод Рунге - Кутты применяется при решения задачи Коши для системы обыкновенных дифференциальных уравнений первого порядка:

:<math>
\begin{cases}
\textbf{y}' = \textbf{f}(x, \textbf{y}),\\
\textbf{y}(x_0) = \textbf{y}_0.
\end{cases}
</math>

При этом <math>\textbf{y}, \textbf{f}, x</math> отвечают следующим свойствам: <math> \textbf{y}, \textbf{f} \in \mathbb{R}^m, x \in \mathbb{R}^1 </math>.

Пусть известно значение y(x) и требуется вычислить значение y(x+h). Это можно сделать при помощи формулы:

:<math> y(x + h) = y(x) + \int_0^hy'(x + t)dt</math>

Аппроксимируя интеграл в правой части, можно получить методы Рунге-Кутты разного порядка точности. В общем виде формулы методов Рунге-Кутты можно записать следующим образом:

:<math>\textbf{y}_{n+1} = \textbf{y}_n + h\sum_{i=1}^s b_i \textbf{k}_i</math>

:<math>
\begin{array}{ll}
\textbf{k}_1 =& \textbf{f}(x_n, \textbf{y}_n),\\
\textbf{k}_2 =& \textbf{f}(x_n+c_2h, \textbf{y}_n+a_{21}h\textbf{k}_1),\\
\cdots&\\
\textbf{k}_s =& \textbf{f}(x_n+c_sh, \textbf{y}_n+a_{s1}h\textbf{k}_1+a_{s2}h\textbf{k}_2+\cdots+a_{s,s-1}h\textbf{k}_{s-1})
\end{array}
</math>

Увеличивая число s вспомогательных точек, можно построить методы Рунге-Кутты любого порядка точности p. Однако уже при p > 5 эти методы используются довольно редко. Это объясняется как чрезмерной громоздкостью получающихся вычислительных формул, так и тем, что преимущества методов высокого порядка точности над методами, в которых p = 4 или p = 5, проявляются либо в тех задачах, где нужна очень высокая точность и используются ЭВМ высокой разрядности, либо в тех задачах, где решение очень гладкое. Кроме того, методы Рунге-Кутты высокого порядка точности часто оказываются менее эффективными по сравнению с методами Адамса того же порядка точности. На этой странице представлен наиболее распространенный метод Рунге-Кутты 4 порядка с ошибкой на конечном интервале интегрирования <math>O(h^4)</math>.

Существуют как явные, так и неявные методы Рунге-Кутты. Последние имеют ряд преимуществ над явными методами, однако это достигается за счет существенного усложнения вычислительного алгоритма, так как на каждом шаге приходится считать систему нелинейных уравнений. На этой странице представлен явный метод Рунге-Кутты.

Можно отметить, что в современных программах, реализующих метод Рунге-Кутты, обязательно используется некоторый алгоритм автоматического изменения шага интегрирования. Интуитивно ясно, что на участках плавного изменения решения счет можно вести с достаточно крупным шагом. В то же время на тех участках, где происходят резкие изменения поведения решения, необходимо выбирать мелкий шаг интегрирования. Обычно начальное значение шага h1 задает пользователь. Далее шаг интегрирования меняется в соответствии с величиной получаемой в ходе вычислений оценки локальной погрешности. Для упрощения описания на этой странице используется постоянный шаг интегрирования h, зависящий от размера сетки разбиения n.

== Математическое описание алгоритма ==

Далее подразумевается, что <math> \bold y, \bold y_i,\bold f, \bold k_i \in \mathbb{R}^m</math>, а <math>x, h, n, a, b \in \mathbb{R}^1 </math>.

Исходные данные:
<math> a, b </math> - интервал интегрирования,
<math> \bold y_0 </math> - вектор значений при <math> x = a </math>,
n - количество точек в разбиении
<math>\bold f </math> - функция вычисления производной

Вычисляемые данные:
<math> \bold y_i </math> - вектора значений в узлах сетки, т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>

Формулы метода:
:Вначале вычисляется шаг сетки:
::<math> h = \frac{b-a}{n}</math>.
:Приближенное значение в следующих точках вычисляется по итерационной формуле:
::<math>\textbf{y}_{n+1} = \textbf{y}_n + {h \over 6}(\textbf{k}_1 + 2\textbf{k}_2 + 2\textbf{k}_3 + \textbf{k}_4)</math>,
::<math>\textbf{k}_1 = \textbf{f} \left( x_n, \textbf{y}_n \right),</math>
::<math>\textbf{k}_2 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_1 \right),</math>
::<math>\textbf{k}_3 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_2 \right),</math>
::<math>\textbf{k}_4 = \textbf{f} \left( x_n + h, \textbf{y}_n + h\ \textbf{k}_3 \right),</math>
::<math>x_{n+1} = x_n + h.</math>

== Вычислительное ядро алгоритма ==

Вычислительным ядром метода Рунге-Кутты можно считать вычисление значений функции производной
:<math>\textbf{f}(x, \textbf{y})</math>,
так как при вычислении каждого нового <math>\textbf{y}_n</math> требуется 4 вычисления значения функции производной. Таким образом, сложность работы алгоритма существенно зависит от сложности вычисления функции <math>\textbf{f}</math>.

== Макроструктура алгоритма ==

Макроструктура алгоритма может быть представлена в следующем виде:
:Вычисление вспомогательных коэффициентов <math>\textbf{k}_j, j \in [1,4]</math>;
:Вычисление приближенного значения <math> \bold y_i </math> в следующей точке;
:Переход на следующую итерацию или остановка.

== Схема реализации последовательного алгоритма ==

Пример реализации последовательного алгоритма на языке C++ (указатель на функцию f передаётся через аргументы представленной ниже функции):
<source lang="c++" line="1">
#include <vector>

// other code ...

std::vector<double> rungekutta4(double a, double b, std::vector<double> y0, int n, std::vector<double (*)(double,double)> f)
{
std::vector<double>::size_type sz = y0.size();
std::vector<double> result;
for (unsigned i=0; i<sz; i++)
{
rezult.push_back(core(a,b,y[i],n,f[i]));
}
return result;
}

double core(double a, double b, double y0, int n, double (*f)(double,double))
{
double h, k1, k2, k3, k4, x, y;
h = (b - a)/n;
y = y0;
x = a;
for (unsigned i = 0; i < n; i++)
{
k1 = f(x, y);
k2 = f(x + h/2, y + h*k1/2);
k3 = f(x + h/2, y + h*k2/2);
k4 = f(x + h/2, y + h*k3);
x += h;
y += h*(k1 + 2*k2 + 2*k3 + k4)/6;
}
return y;
}

// other code ...
</source>

== Последовательная сложность алгоритма ==

Рассмотрим сначала одномерный случай. Наравне с обычными операциями, такими как сложение, умножение и тому подобными, в представленном выше алгоритме присутствует вызов функции <math>\bold f </math>. Так как эта функция может содержать в себе любое количество простых математических операций, будем считать, что её сложность <math>\bold f </math> много больше любой из них, и равна константе <math>C</math>. За весь алгоритм, она вызывается <math>4n</math> раза. Таким образом, сложность последовательного алгоритма для одномерного случая равна <math>4nC</math>.

Для многомерного случая, когда <math>x</math> и <math>y</math> являются векторами размерности <math>m</math>, функция core будет вызвана <math>m</math>, и итоговая сложность алгоритма составит <math>4nCm</math>.

== Информационный граф ==

== Ресурс параллелизма алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является итерационным алгоритмом. В нём каждый шаг цикла зависит от предыдущего. В самом шаге, каждая последующая операция также зависит от результата предыдущей. Таким образом, упразднить цикл до независимых и соответственно параллельных операций не является возможным. Однако, так как на результат функции <math> \bold f </math> влияет только <math>i</math>-ый параметр векторов <math> \bold x </math> и <math> \bold y </math>, то для каждого <math> i </math> можно производить независимое вычисление. В итоге, если вычислять результаты выполнения функции <math> \bold f </math> одновременно для вля всех <math>\bold i</math>-ых параметров векторов <math> \bold x </math> и <math> \bold y </math>, получим туже алгоритмическую сложность <math>4nC</math>, что и в [[#Последовательная сложность алгоритма|разделе 1.6]] для одномерного случая.

== Входные и выходные данные алгоритма ==

'''Входные данные''':
<math> a, b </math> - интервал интегрирования,
n - количество точек в разбиении,
<math> \bold y_0 </math> - вектор значений размерности m при <math> x = a </math>,
функцию вычисления производной <math>\bold f </math> будем считать встроенной в алгоритм.

'''Объём входных данных''':
m + 3

'''Выходные данные:'''
<math> \bold y_i </math> - вектора размера m значений в n узлах сетки (т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>).

'''Объем выходных данных'''
n * m

== Свойства алгоритма ==

= ЧАСТЬ. Программная реализация алгоритма =

== [[Особенности реализации последовательного алгоритма]] ==

== [[Локальность данных и вычислений]] ==

== [[Возможные способы и особенности параллельной реализации алгоритма]] ==

== Масштабируемость алгоритма и его реализации ==

== [[Динамические характеристики и эффективность реализации алгоритма]] ==

== [[Выводы для классов архитектур]] ==

== Существующие реализации алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является одним из наиболее используемых для решения ОДУ и их систем, поэтому существует большое число его реализаций для разных языков программирования. Наиболее популярными являются следующие из них:
* библиотека RK4, которая существует в вариантах для C++, FORTRAN90, FORTRAN77, python и MATLAB;
* библиотека ode45 для MATLAB;
* модуль scipy для PYTHON.

= Литература =

Участник:Борис/Алгоритм Рунге-Кутты

2016-10-15T19:41:26Z

Борис:

{{algorithm
| name = Метод Рунге-Кутты 4 порядка
| serial_complexity = <math>O()</math>
| pf_height = <math>O()</math>
| pf_width = <math>O()</math>
| input_data = <math>m + 3</math>
| output_data = <math>m * n</math>
}}

Основные авторы описания: [[Участник:Jest|Е.П.Степанов]]([[#Общее описание алгоритма|раздел 1.1]], [[#Математическое описание алгоритма|раздел 1.2]], [[#Вычислительное ядро алгоритма|раздел 1.3]], [[#Макроструктура алгоритма|раздел 1.4]], [[#Входные и выходные данные алгоритма|раздел 1.9]]), [[Участник:Борис|Б.Савков]] ( [[#Схема реализации последовательного алгоритма|раздел 1.5]], [[#Последовательная сложность алгоритма|раздел 1.6]], [[#Информационный граф|раздел 1.7]], [[#Ресурс параллелизма алгоритма|раздел 1.8]], [[#Существующие реализации алгоритма|раздел 2.7]])

= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==

Ме́тоды Ру́нге — Ку́тты (распространено неправильное название Ме́тоды Ру́нге — Ку́тта или же Ме́тоды Ру́нге — Кутта́) — важное семейство численных алгоритмов решения обыкновенных дифференциальных уравнений и их систем. Данные итеративные методы явного и неявного приближённого вычисления были разработаны около 1900 года немецкими математиками К. Рунге и М. В. Куттой.

Метод Рунге - Кутты применяется при решения задачи Коши для системы обыкновенных дифференциальных уравнений первого порядка:

:<math>
\begin{cases}
\textbf{y}' = \textbf{f}(x, \textbf{y}),\\
\textbf{y}(x_0) = \textbf{y}_0.
\end{cases}
</math>

При этом <math>\textbf{y}, \textbf{f}, x</math> отвечают следующим свойствам: <math> \textbf{y}, \textbf{f} \in \mathbb{R}^m, x \in \mathbb{R}^1 </math>.

Пусть известно значение y(x) и требуется вычислить значение y(x+h). Это можно сделать при помощи формулы:

:<math> y(x + h) = y(x) + \int_0^hy'(x + t)dt</math>

Аппроксимируя интеграл в правой части, можно получить методы Рунге-Кутты разного порядка точности. В общем виде формулы методов Рунге-Кутты можно записать следующим образом:

:<math>\textbf{y}_{n+1} = \textbf{y}_n + h\sum_{i=1}^s b_i \textbf{k}_i</math>

:<math>
\begin{array}{ll}
\textbf{k}_1 =& \textbf{f}(x_n, \textbf{y}_n),\\
\textbf{k}_2 =& \textbf{f}(x_n+c_2h, \textbf{y}_n+a_{21}h\textbf{k}_1),\\
\cdots&\\
\textbf{k}_s =& \textbf{f}(x_n+c_sh, \textbf{y}_n+a_{s1}h\textbf{k}_1+a_{s2}h\textbf{k}_2+\cdots+a_{s,s-1}h\textbf{k}_{s-1})
\end{array}
</math>

Увеличивая число s вспомогательных точек, можно построить методы Рунге-Кутты любого порядка точности p. Однако уже при p > 5 эти методы используются довольно редко. Это объясняется как чрезмерной громоздкостью получающихся вычислительных формул, так и тем, что преимущества методов высокого порядка точности над методами, в которых p = 4 или p = 5, проявляются либо в тех задачах, где нужна очень высокая точность и используются ЭВМ высокой разрядности, либо в тех задачах, где решение очень гладкое. Кроме того, методы Рунге-Кутты высокого порядка точности часто оказываются менее эффективными по сравнению с методами Адамса того же порядка точности. На этой странице представлен наиболее распространенный метод Рунге-Кутты 4 порядка с ошибкой на конечном интервале интегрирования <math>O(h^4)</math>.

Существуют как явные, так и неявные методы Рунге-Кутты. Последние имеют ряд преимуществ над явными методами, однако это достигается за счет существенного усложнения вычислительного алгоритма, так как на каждом шаге приходится считать систему нелинейных уравнений. На этой странице представлен явный метод Рунге-Кутты.

Можно отметить, что в современных программах, реализующих метод Рунге-Кутты, обязательно используется некоторый алгоритм автоматического изменения шага интегрирования. Интуитивно ясно, что на участках плавного изменения решения счет можно вести с достаточно крупным шагом. В то же время на тех участках, где происходят резкие изменения поведения решения, необходимо выбирать мелкий шаг интегрирования. Обычно начальное значение шага h1 задает пользователь. Далее шаг интегрирования меняется в соответствии с величиной получаемой в ходе вычислений оценки локальной погрешности. Для упрощения описания на этой странице используется постоянный шаг интегрирования h, зависящий от размера сетки разбиения n.

== Математическое описание алгоритма ==

Далее подразумевается, что <math> \bold y, \bold y_i,\bold f, \bold k_i \in \mathbb{R}^m</math>, а <math>x, h, n, a, b \in \mathbb{R}^1 </math>.

Исходные данные:
<math> a, b </math> - интервал интегрирования,
<math> \bold y_0 </math> - вектор значений при <math> x = a </math>,
n - количество точек в разбиении
<math>\bold f </math> - функция вычисления производной

Вычисляемые данные:
<math> \bold y_i </math> - вектора значений в узлах сетки, т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>

Формулы метода:
:Вначале вычисляется шаг сетки:
::<math> h = \frac{b-a}{n}</math>.
:Приближенное значение в следующих точках вычисляется по итерационной формуле:
::<math>\textbf{y}_{n+1} = \textbf{y}_n + {h \over 6}(\textbf{k}_1 + 2\textbf{k}_2 + 2\textbf{k}_3 + \textbf{k}_4)</math>,
::<math>\textbf{k}_1 = \textbf{f} \left( x_n, \textbf{y}_n \right),</math>
::<math>\textbf{k}_2 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_1 \right),</math>
::<math>\textbf{k}_3 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_2 \right),</math>
::<math>\textbf{k}_4 = \textbf{f} \left( x_n + h, \textbf{y}_n + h\ \textbf{k}_3 \right),</math>
::<math>x_{n+1} = x_n + h.</math>

== Вычислительное ядро алгоритма ==

Вычислительным ядром метода Рунге-Кутты можно считать вычисление значений функции производной
:<math>\textbf{f}(x, \textbf{y})</math>,
так как при вычислении каждого нового <math>\textbf{y}_n</math> требуется 4 вычисления значения функции производной. Таким образом, сложность работы алгоритма существенно зависит от сложности вычисления функции <math>\textbf{f}</math>.

== Макроструктура алгоритма ==

Макроструктура алгоритма может быть представлена в следующем виде:
:Вычисление вспомогательных коэффициентов <math>\textbf{k}_j, j \in [1,4]</math>;
:Вычисление приближенного значения <math> \bold y_i </math> в следующей точке;
:Переход на следующую итерацию или остановка.

== Схема реализации последовательного алгоритма ==

Пример реализации последовательного алгоритма на языке C++ (указатель на функцию f передаётся через аргументы представленной ниже функции):
<source lang="c++" line="1">
#include <vector>

// other code ...

std::vector<double> rungekutta4(std::vector<double> a, std::vector<double> b, std::vector<double> y0, int n, double (*f)(double,double))
{
std::vector<double>::size_type sz = myvector.size();
std::vector<double> result;
for (unsigned i=0; i<sz; i++)
{
rezult.push_back(core(a[i],b[i],y0,n,f));
}
return result;
}

double core(double a, double b, double y0, int n, double (*f)(double,double))
{
double h, k1, k2, k3, k4, x, y;
h = (b - a)/n;
y = y0;
x = a;
for (unsigned i = 0; i < n; i++)
{
k1 = f(x, y);
k2 = f(x + h/2, y + h*k1/2);
k3 = f(x + h/2, y + h*k2/2);
k4 = f(x + h/2, y + h*k3);
x += h;
y += h*(k1 + 2*k2 + 2*k3 + k4)/6;
}
return y;
}

// other code ...
</source>

== Последовательная сложность алгоритма ==

Рассмотрим сначала одномерный случай. Наравне с обычными операциями, такими как сложение, умножение и тому подобными, в представленном выше алгоритме присутствует вызов функции <math>\bold f </math>. Так как эта функция может содержать в себе любое количество простых математических операций, будем считать, что её сложность <math>\bold f </math> много больше любой из них, и равна константе <math>C</math>. За весь алгоритм, она вызывается <math>4n</math> раза. Таким образом, сложность последовательного алгоритма для одномерного случая равна <math>4nC</math>.

Для многомерного случая, когда <math>x</math> и <math>y</math> являются векторами размерности <math>m</math>, функция core будет вызвана <math>m</math>, и итоговая сложность алгоритма составит <math>4nCm</math>.

== Информационный граф ==

== Ресурс параллелизма алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является итерационным алгоритмом. В нём каждый шаг цикла зависит от предыдущего. В самом шаге, каждая последующая операция также зависит от результата предыдущей. Таким образом, упразднить цикл до независимых и соответственно параллельных операций не является возможным. Однако, так как на результат функции <math> \bold f </math> влияет только <math>i</math>-ый параметр векторов <math> \bold x </math> и <math> \bold y </math>, то для каждого <math> i </math> можно производить независимое вычисление. В итоге, если вычислять результаты выполнения функции <math> \bold f </math> одновременно для вля всех <math>\bold i</math>-ых параметров векторов <math> \bold x </math> и <math> \bold y </math>, получим туже алгоритмическую сложность <math>4nC</math>, что и в [[#Последовательная сложность алгоритма|разделе 1.6]] для одномерного случая.

== Входные и выходные данные алгоритма ==

'''Входные данные''':
<math> a, b </math> - интервал интегрирования,
n - количество точек в разбиении,
<math> \bold y_0 </math> - вектор значений размерности m при <math> x = a </math>,
функцию вычисления производной <math>\bold f </math> будем считать встроенной в алгоритм.

'''Объём входных данных''':
m + 3

'''Выходные данные:'''
<math> \bold y_i </math> - вектора размера m значений в n узлах сетки (т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>).

'''Объем выходных данных'''
n * m

== Свойства алгоритма ==

= ЧАСТЬ. Программная реализация алгоритма =

== [[Особенности реализации последовательного алгоритма]] ==

== [[Локальность данных и вычислений]] ==

== [[Возможные способы и особенности параллельной реализации алгоритма]] ==

== Масштабируемость алгоритма и его реализации ==

== [[Динамические характеристики и эффективность реализации алгоритма]] ==

== [[Выводы для классов архитектур]] ==

== Существующие реализации алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является одним из наиболее используемых для решения ОДУ и их систем, поэтому существует большое число его реализаций для разных языков программирования. Наиболее популярными являются следующие из них:
* библиотека RK4, которая существует в вариантах для C++, FORTRAN90, FORTRAN77, python и MATLAB;
* библиотека ode45 для MATLAB;
* модуль scipy для PYTHON.

= Литература =

Участник:Борис/Алгоритм Рунге-Кутты

2016-10-15T19:40:53Z

Борис:

{{algorithm
| name = Метод Рунге-Кутты 4 порядка
| serial_complexity = <math>O()</math>
| pf_height = <math>O()</math>
| pf_width = <math>O()</math>
| input_data = <math>m + 3</math>
| output_data = <math>m * n</math>
}}

Основные авторы описания: [[Участник:Jest|Е.П.Степанов]]([[#Общее описание алгоритма|раздел 1.1]], [[#Математическое описание алгоритма|раздел 1.2]], [[#Вычислительное ядро алгоритма|раздел 1.3]], [[#Макроструктура алгоритма|раздел 1.4]], [[#Входные и выходные данные алгоритма|раздел 1.9]]), [[Участник:Борис|Б.Савков]] ( [[#Схема реализации последовательного алгоритма|раздел 1.5]], [[#Последовательная сложность алгоритма|раздел 1.6]], [[#Информационный граф|раздел 1.7]], [[#Ресурс параллелизма алгоритма|раздел 1.8]], [[Существующие реализации алгоритма|раздел 2.7]])

= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==

Ме́тоды Ру́нге — Ку́тты (распространено неправильное название Ме́тоды Ру́нге — Ку́тта или же Ме́тоды Ру́нге — Кутта́) — важное семейство численных алгоритмов решения обыкновенных дифференциальных уравнений и их систем. Данные итеративные методы явного и неявного приближённого вычисления были разработаны около 1900 года немецкими математиками К. Рунге и М. В. Куттой.

Метод Рунге - Кутты применяется при решения задачи Коши для системы обыкновенных дифференциальных уравнений первого порядка:

:<math>
\begin{cases}
\textbf{y}' = \textbf{f}(x, \textbf{y}),\\
\textbf{y}(x_0) = \textbf{y}_0.
\end{cases}
</math>

При этом <math>\textbf{y}, \textbf{f}, x</math> отвечают следующим свойствам: <math> \textbf{y}, \textbf{f} \in \mathbb{R}^m, x \in \mathbb{R}^1 </math>.

Пусть известно значение y(x) и требуется вычислить значение y(x+h). Это можно сделать при помощи формулы:

:<math> y(x + h) = y(x) + \int_0^hy'(x + t)dt</math>

Аппроксимируя интеграл в правой части, можно получить методы Рунге-Кутты разного порядка точности. В общем виде формулы методов Рунге-Кутты можно записать следующим образом:

:<math>\textbf{y}_{n+1} = \textbf{y}_n + h\sum_{i=1}^s b_i \textbf{k}_i</math>

:<math>
\begin{array}{ll}
\textbf{k}_1 =& \textbf{f}(x_n, \textbf{y}_n),\\
\textbf{k}_2 =& \textbf{f}(x_n+c_2h, \textbf{y}_n+a_{21}h\textbf{k}_1),\\
\cdots&\\
\textbf{k}_s =& \textbf{f}(x_n+c_sh, \textbf{y}_n+a_{s1}h\textbf{k}_1+a_{s2}h\textbf{k}_2+\cdots+a_{s,s-1}h\textbf{k}_{s-1})
\end{array}
</math>

Увеличивая число s вспомогательных точек, можно построить методы Рунге-Кутты любого порядка точности p. Однако уже при p > 5 эти методы используются довольно редко. Это объясняется как чрезмерной громоздкостью получающихся вычислительных формул, так и тем, что преимущества методов высокого порядка точности над методами, в которых p = 4 или p = 5, проявляются либо в тех задачах, где нужна очень высокая точность и используются ЭВМ высокой разрядности, либо в тех задачах, где решение очень гладкое. Кроме того, методы Рунге-Кутты высокого порядка точности часто оказываются менее эффективными по сравнению с методами Адамса того же порядка точности. На этой странице представлен наиболее распространенный метод Рунге-Кутты 4 порядка с ошибкой на конечном интервале интегрирования <math>O(h^4)</math>.

Существуют как явные, так и неявные методы Рунге-Кутты. Последние имеют ряд преимуществ над явными методами, однако это достигается за счет существенного усложнения вычислительного алгоритма, так как на каждом шаге приходится считать систему нелинейных уравнений. На этой странице представлен явный метод Рунге-Кутты.

Можно отметить, что в современных программах, реализующих метод Рунге-Кутты, обязательно используется некоторый алгоритм автоматического изменения шага интегрирования. Интуитивно ясно, что на участках плавного изменения решения счет можно вести с достаточно крупным шагом. В то же время на тех участках, где происходят резкие изменения поведения решения, необходимо выбирать мелкий шаг интегрирования. Обычно начальное значение шага h1 задает пользователь. Далее шаг интегрирования меняется в соответствии с величиной получаемой в ходе вычислений оценки локальной погрешности. Для упрощения описания на этой странице используется постоянный шаг интегрирования h, зависящий от размера сетки разбиения n.

== Математическое описание алгоритма ==

Далее подразумевается, что <math> \bold y, \bold y_i,\bold f, \bold k_i \in \mathbb{R}^m</math>, а <math>x, h, n, a, b \in \mathbb{R}^1 </math>.

Исходные данные:
<math> a, b </math> - интервал интегрирования,
<math> \bold y_0 </math> - вектор значений при <math> x = a </math>,
n - количество точек в разбиении
<math>\bold f </math> - функция вычисления производной

Вычисляемые данные:
<math> \bold y_i </math> - вектора значений в узлах сетки, т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>

Формулы метода:
:Вначале вычисляется шаг сетки:
::<math> h = \frac{b-a}{n}</math>.
:Приближенное значение в следующих точках вычисляется по итерационной формуле:
::<math>\textbf{y}_{n+1} = \textbf{y}_n + {h \over 6}(\textbf{k}_1 + 2\textbf{k}_2 + 2\textbf{k}_3 + \textbf{k}_4)</math>,
::<math>\textbf{k}_1 = \textbf{f} \left( x_n, \textbf{y}_n \right),</math>
::<math>\textbf{k}_2 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_1 \right),</math>
::<math>\textbf{k}_3 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_2 \right),</math>
::<math>\textbf{k}_4 = \textbf{f} \left( x_n + h, \textbf{y}_n + h\ \textbf{k}_3 \right),</math>
::<math>x_{n+1} = x_n + h.</math>

== Вычислительное ядро алгоритма ==

Вычислительным ядром метода Рунге-Кутты можно считать вычисление значений функции производной
:<math>\textbf{f}(x, \textbf{y})</math>,
так как при вычислении каждого нового <math>\textbf{y}_n</math> требуется 4 вычисления значения функции производной. Таким образом, сложность работы алгоритма существенно зависит от сложности вычисления функции <math>\textbf{f}</math>.

== Макроструктура алгоритма ==

Макроструктура алгоритма может быть представлена в следующем виде:
:Вычисление вспомогательных коэффициентов <math>\textbf{k}_j, j \in [1,4]</math>;
:Вычисление приближенного значения <math> \bold y_i </math> в следующей точке;
:Переход на следующую итерацию или остановка.

== Схема реализации последовательного алгоритма ==

Пример реализации последовательного алгоритма на языке C++ (указатель на функцию f передаётся через аргументы представленной ниже функции):
<source lang="c++" line="1">
#include <vector>

// other code ...

std::vector<double> rungekutta4(std::vector<double> a, std::vector<double> b, std::vector<double> y0, int n, double (*f)(double,double))
{
std::vector<double>::size_type sz = myvector.size();
std::vector<double> result;
for (unsigned i=0; i<sz; i++)
{
rezult.push_back(core(a[i],b[i],y0,n,f));
}
return result;
}

double core(double a, double b, double y0, int n, double (*f)(double,double))
{
double h, k1, k2, k3, k4, x, y;
h = (b - a)/n;
y = y0;
x = a;
for (unsigned i = 0; i < n; i++)
{
k1 = f(x, y);
k2 = f(x + h/2, y + h*k1/2);
k3 = f(x + h/2, y + h*k2/2);
k4 = f(x + h/2, y + h*k3);
x += h;
y += h*(k1 + 2*k2 + 2*k3 + k4)/6;
}
return y;
}

// other code ...
</source>

== Последовательная сложность алгоритма ==

Рассмотрим сначала одномерный случай. Наравне с обычными операциями, такими как сложение, умножение и тому подобными, в представленном выше алгоритме присутствует вызов функции <math>\bold f </math>. Так как эта функция может содержать в себе любое количество простых математических операций, будем считать, что её сложность <math>\bold f </math> много больше любой из них, и равна константе <math>C</math>. За весь алгоритм, она вызывается <math>4n</math> раза. Таким образом, сложность последовательного алгоритма для одномерного случая равна <math>4nC</math>.

Для многомерного случая, когда <math>x</math> и <math>y</math> являются векторами размерности <math>m</math>, функция core будет вызвана <math>m</math>, и итоговая сложность алгоритма составит <math>4nCm</math>.

== Информационный граф ==

== Ресурс параллелизма алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является итерационным алгоритмом. В нём каждый шаг цикла зависит от предыдущего. В самом шаге, каждая последующая операция также зависит от результата предыдущей. Таким образом, упразднить цикл до независимых и соответственно параллельных операций не является возможным. Однако, так как на результат функции <math> \bold f </math> влияет только <math>i</math>-ый параметр векторов <math> \bold x </math> и <math> \bold y </math>, то для каждого <math> i </math> можно производить независимое вычисление. В итоге, если вычислять результаты выполнения функции <math> \bold f </math> одновременно для вля всех <math>\bold i</math>-ых параметров векторов <math> \bold x </math> и <math> \bold y </math>, получим туже алгоритмическую сложность <math>4nC</math>, что и в [[#Последовательная сложность алгоритма|разделе 1.6]] для одномерного случая.

== Входные и выходные данные алгоритма ==

'''Входные данные''':
<math> a, b </math> - интервал интегрирования,
n - количество точек в разбиении,
<math> \bold y_0 </math> - вектор значений размерности m при <math> x = a </math>,
функцию вычисления производной <math>\bold f </math> будем считать встроенной в алгоритм.

'''Объём входных данных''':
m + 3

'''Выходные данные:'''
<math> \bold y_i </math> - вектора размера m значений в n узлах сетки (т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>).

'''Объем выходных данных'''
n * m

== Свойства алгоритма ==

= ЧАСТЬ. Программная реализация алгоритма =

== [[Особенности реализации последовательного алгоритма]] ==

== [[Локальность данных и вычислений]] ==

== [[Возможные способы и особенности параллельной реализации алгоритма]] ==

== Масштабируемость алгоритма и его реализации ==

== [[Динамические характеристики и эффективность реализации алгоритма]] ==

== [[Выводы для классов архитектур]] ==

== Существующие реализации алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является одним из наиболее используемых для решения ОДУ и их систем, поэтому существует большое число его реализаций для разных языков программирования. Наиболее популярными являются следующие из них:
* библиотека RK4, которая существует в вариантах для C++, FORTRAN90, FORTRAN77, python и MATLAB;
* библиотека ode45 для MATLAB;
* модуль scipy для PYTHON.

= Литература =

Участник:Борис/Алгоритм Рунге-Кутты

2016-10-15T19:38:57Z

Борис: /* Существующие реализации алгоритма */

{{algorithm
| name = Метод Рунге-Кутты 4 порядка
| serial_complexity = <math>O()</math>
| pf_height = <math>O()</math>
| pf_width = <math>O()</math>
| input_data = <math>m + 3</math>
| output_data = <math>m * n</math>
}}

Основные авторы описания: [[Участник:Jest|Е.П.Степанов]]([[#Общее описание алгоритма|раздел 1.1]], [[#Математическое описание алгоритма|раздел 1.2]], [[#Вычислительное ядро алгоритма|раздел 1.3]], [[#Макроструктура алгоритма|раздел 1.4]], [[#Входные и выходные данные алгоритма|раздел 1.9]]), [[Участник:Борис|Б.Савков]] ( [[#Схема реализации последовательного алгоритма|раздел 1.5]], [[#Последовательная сложность алгоритма|раздел 1.6]], [[#Ресурс параллелизма алгоритма|раздел 1.8]])

= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==

Ме́тоды Ру́нге — Ку́тты (распространено неправильное название Ме́тоды Ру́нге — Ку́тта или же Ме́тоды Ру́нге — Кутта́) — важное семейство численных алгоритмов решения обыкновенных дифференциальных уравнений и их систем. Данные итеративные методы явного и неявного приближённого вычисления были разработаны около 1900 года немецкими математиками К. Рунге и М. В. Куттой.

Метод Рунге - Кутты применяется при решения задачи Коши для системы обыкновенных дифференциальных уравнений первого порядка:

:<math>
\begin{cases}
\textbf{y}' = \textbf{f}(x, \textbf{y}),\\
\textbf{y}(x_0) = \textbf{y}_0.
\end{cases}
</math>

При этом <math>\textbf{y}, \textbf{f}, x</math> отвечают следующим свойствам: <math> \textbf{y}, \textbf{f} \in \mathbb{R}^m, x \in \mathbb{R}^1 </math>.

Пусть известно значение y(x) и требуется вычислить значение y(x+h). Это можно сделать при помощи формулы:

:<math> y(x + h) = y(x) + \int_0^hy'(x + t)dt</math>

Аппроксимируя интеграл в правой части, можно получить методы Рунге-Кутты разного порядка точности. В общем виде формулы методов Рунге-Кутты можно записать следующим образом:

:<math>\textbf{y}_{n+1} = \textbf{y}_n + h\sum_{i=1}^s b_i \textbf{k}_i</math>

:<math>
\begin{array}{ll}
\textbf{k}_1 =& \textbf{f}(x_n, \textbf{y}_n),\\
\textbf{k}_2 =& \textbf{f}(x_n+c_2h, \textbf{y}_n+a_{21}h\textbf{k}_1),\\
\cdots&\\
\textbf{k}_s =& \textbf{f}(x_n+c_sh, \textbf{y}_n+a_{s1}h\textbf{k}_1+a_{s2}h\textbf{k}_2+\cdots+a_{s,s-1}h\textbf{k}_{s-1})
\end{array}
</math>

Увеличивая число s вспомогательных точек, можно построить методы Рунге-Кутты любого порядка точности p. Однако уже при p > 5 эти методы используются довольно редко. Это объясняется как чрезмерной громоздкостью получающихся вычислительных формул, так и тем, что преимущества методов высокого порядка точности над методами, в которых p = 4 или p = 5, проявляются либо в тех задачах, где нужна очень высокая точность и используются ЭВМ высокой разрядности, либо в тех задачах, где решение очень гладкое. Кроме того, методы Рунге-Кутты высокого порядка точности часто оказываются менее эффективными по сравнению с методами Адамса того же порядка точности. На этой странице представлен наиболее распространенный метод Рунге-Кутты 4 порядка с ошибкой на конечном интервале интегрирования <math>O(h^4)</math>.

Существуют как явные, так и неявные методы Рунге-Кутты. Последние имеют ряд преимуществ над явными методами, однако это достигается за счет существенного усложнения вычислительного алгоритма, так как на каждом шаге приходится считать систему нелинейных уравнений. На этой странице представлен явный метод Рунге-Кутты.

Можно отметить, что в современных программах, реализующих метод Рунге-Кутты, обязательно используется некоторый алгоритм автоматического изменения шага интегрирования. Интуитивно ясно, что на участках плавного изменения решения счет можно вести с достаточно крупным шагом. В то же время на тех участках, где происходят резкие изменения поведения решения, необходимо выбирать мелкий шаг интегрирования. Обычно начальное значение шага h1 задает пользователь. Далее шаг интегрирования меняется в соответствии с величиной получаемой в ходе вычислений оценки локальной погрешности. Для упрощения описания на этой странице используется постоянный шаг интегрирования h, зависящий от размера сетки разбиения n.

== Математическое описание алгоритма ==

Далее подразумевается, что <math> \bold y, \bold y_i,\bold f, \bold k_i \in \mathbb{R}^m</math>, а <math>x, h, n, a, b \in \mathbb{R}^1 </math>.

Исходные данные:
<math> a, b </math> - интервал интегрирования,
<math> \bold y_0 </math> - вектор значений при <math> x = a </math>,
n - количество точек в разбиении
<math>\bold f </math> - функция вычисления производной

Вычисляемые данные:
<math> \bold y_i </math> - вектора значений в узлах сетки, т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>

Формулы метода:
:Вначале вычисляется шаг сетки:
::<math> h = \frac{b-a}{n}</math>.
:Приближенное значение в следующих точках вычисляется по итерационной формуле:
::<math>\textbf{y}_{n+1} = \textbf{y}_n + {h \over 6}(\textbf{k}_1 + 2\textbf{k}_2 + 2\textbf{k}_3 + \textbf{k}_4)</math>,
::<math>\textbf{k}_1 = \textbf{f} \left( x_n, \textbf{y}_n \right),</math>
::<math>\textbf{k}_2 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_1 \right),</math>
::<math>\textbf{k}_3 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_2 \right),</math>
::<math>\textbf{k}_4 = \textbf{f} \left( x_n + h, \textbf{y}_n + h\ \textbf{k}_3 \right),</math>
::<math>x_{n+1} = x_n + h.</math>

== Вычислительное ядро алгоритма ==

Вычислительным ядром метода Рунге-Кутты можно считать вычисление значений функции производной
:<math>\textbf{f}(x, \textbf{y})</math>,
так как при вычислении каждого нового <math>\textbf{y}_n</math> требуется 4 вычисления значения функции производной. Таким образом, сложность работы алгоритма существенно зависит от сложности вычисления функции <math>\textbf{f}</math>.

== Макроструктура алгоритма ==

Макроструктура алгоритма может быть представлена в следующем виде:
:Вычисление вспомогательных коэффициентов <math>\textbf{k}_j, j \in [1,4]</math>;
:Вычисление приближенного значения <math> \bold y_i </math> в следующей точке;
:Переход на следующую итерацию или остановка.

== Схема реализации последовательного алгоритма ==

Пример реализации последовательного алгоритма на языке C++ (указатель на функцию f передаётся через аргументы представленной ниже функции):
<source lang="c++" line="1">
#include <vector>

// other code ...

std::vector<double> rungekutta4(std::vector<double> a, std::vector<double> b, std::vector<double> y0, int n, double (*f)(double,double))
{
std::vector<double>::size_type sz = myvector.size();
std::vector<double> result;
for (unsigned i=0; i<sz; i++)
{
rezult.push_back(core(a[i],b[i],y0,n,f));
}
return result;
}

double core(double a, double b, double y0, int n, double (*f)(double,double))
{
double h, k1, k2, k3, k4, x, y;
h = (b - a)/n;
y = y0;
x = a;
for (unsigned i = 0; i < n; i++)
{
k1 = f(x, y);
k2 = f(x + h/2, y + h*k1/2);
k3 = f(x + h/2, y + h*k2/2);
k4 = f(x + h/2, y + h*k3);
x += h;
y += h*(k1 + 2*k2 + 2*k3 + k4)/6;
}
return y;
}

// other code ...
</source>

== Последовательная сложность алгоритма ==

Рассмотрим сначала одномерный случай. Наравне с обычными операциями, такими как сложение, умножение и тому подобными, в представленном выше алгоритме присутствует вызов функции <math>\bold f </math>. Так как эта функция может содержать в себе любое количество простых математических операций, будем считать, что её сложность <math>\bold f </math> много больше любой из них, и равна константе <math>C</math>. За весь алгоритм, она вызывается <math>4n</math> раза. Таким образом, сложность последовательного алгоритма для одномерного случая равна <math>4nC</math>.

Для многомерного случая, когда <math>x</math> и <math>y</math> являются векторами размерности <math>m</math>, функция core будет вызвана <math>m</math>, и итоговая сложность алгоритма составит <math>4nCm</math>.

== Информационный граф ==

== Ресурс параллелизма алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является итерационным алгоритмом. В нём каждый шаг цикла зависит от предыдущего. В самом шаге, каждая последующая операция также зависит от результата предыдущей. Таким образом, упразднить цикл до независимых и соответственно параллельных операций не является возможным. Однако, так как на результат функции <math> \bold f </math> влияет только <math>i</math>-ый параметр векторов <math> \bold x </math> и <math> \bold y </math>, то для каждого <math> i </math> можно производить независимое вычисление. В итоге, если вычислять результаты выполнения функции <math> \bold f </math> одновременно для вля всех <math>\bold i</math>-ых параметров векторов <math> \bold x </math> и <math> \bold y </math>, получим туже алгоритмическую сложность <math>4nC</math>, что и в [[#Последовательная сложность алгоритма|разделе 1.6]] для одномерного случая.

== Входные и выходные данные алгоритма ==

'''Входные данные''':
<math> a, b </math> - интервал интегрирования,
n - количество точек в разбиении,
<math> \bold y_0 </math> - вектор значений размерности m при <math> x = a </math>,
функцию вычисления производной <math>\bold f </math> будем считать встроенной в алгоритм.

'''Объём входных данных''':
m + 3

'''Выходные данные:'''
<math> \bold y_i </math> - вектора размера m значений в n узлах сетки (т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>).

'''Объем выходных данных'''
n * m

== Свойства алгоритма ==

= ЧАСТЬ. Программная реализация алгоритма =

== [[Особенности реализации последовательного алгоритма]] ==

== [[Локальность данных и вычислений]] ==

== [[Возможные способы и особенности параллельной реализации алгоритма]] ==

== Масштабируемость алгоритма и его реализации ==

== [[Динамические характеристики и эффективность реализации алгоритма]] ==

== [[Выводы для классов архитектур]] ==

== Существующие реализации алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является одним из наиболее используемых для решения ОДУ и их систем, поэтому существует большое число его реализаций для разных языков программирования. Наиболее популярными являются следующие из них:
* библиотека RK4, которая существует в вариантах для C++, FORTRAN90, FORTRAN77, python и MATLAB;
* библиотека ode45 для MATLAB;
* модуль scipy для PYTHON.

= Литература =

Участник:Борис/Алгоритм Рунге-Кутты

2016-10-15T19:07:08Z

Борис: /* Существующие реализации алгоритма */

{{algorithm
| name = Метод Рунге-Кутты 4 порядка
| serial_complexity = <math>O()</math>
| pf_height = <math>O()</math>
| pf_width = <math>O()</math>
| input_data = <math>m + 3</math>
| output_data = <math>m * n</math>
}}

Основные авторы описания: [[Участник:Jest|Е.П.Степанов]]([[#Общее описание алгоритма|раздел 1.1]], [[#Математическое описание алгоритма|раздел 1.2]], [[#Вычислительное ядро алгоритма|раздел 1.3]], [[#Макроструктура алгоритма|раздел 1.4]], [[#Входные и выходные данные алгоритма|раздел 1.9]]), [[Участник:Борис|Б.Савков]] ( [[#Схема реализации последовательного алгоритма|раздел 1.5]], [[#Последовательная сложность алгоритма|раздел 1.6]], [[#Ресурс параллелизма алгоритма|раздел 1.8]])

= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==

Ме́тоды Ру́нге — Ку́тты (распространено неправильное название Ме́тоды Ру́нге — Ку́тта или же Ме́тоды Ру́нге — Кутта́) — важное семейство численных алгоритмов решения обыкновенных дифференциальных уравнений и их систем. Данные итеративные методы явного и неявного приближённого вычисления были разработаны около 1900 года немецкими математиками К. Рунге и М. В. Куттой.

Метод Рунге - Кутты применяется при решения задачи Коши для системы обыкновенных дифференциальных уравнений первого порядка:

:<math>
\begin{cases}
\textbf{y}' = \textbf{f}(x, \textbf{y}),\\
\textbf{y}(x_0) = \textbf{y}_0.
\end{cases}
</math>

При этом <math>\textbf{y}, \textbf{f}, x</math> отвечают следующим свойствам: <math> \textbf{y}, \textbf{f} \in \mathbb{R}^m, x \in \mathbb{R}^1 </math>.

Пусть известно значение y(x) и требуется вычислить значение y(x+h). Это можно сделать при помощи формулы:

:<math> y(x + h) = y(x) + \int_0^hy'(x + t)dt</math>

Аппроксимируя интеграл в правой части, можно получить методы Рунге-Кутты разного порядка точности. В общем виде формулы методов Рунге-Кутты можно записать следующим образом:

:<math>\textbf{y}_{n+1} = \textbf{y}_n + h\sum_{i=1}^s b_i \textbf{k}_i</math>

:<math>
\begin{array}{ll}
\textbf{k}_1 =& \textbf{f}(x_n, \textbf{y}_n),\\
\textbf{k}_2 =& \textbf{f}(x_n+c_2h, \textbf{y}_n+a_{21}h\textbf{k}_1),\\
\cdots&\\
\textbf{k}_s =& \textbf{f}(x_n+c_sh, \textbf{y}_n+a_{s1}h\textbf{k}_1+a_{s2}h\textbf{k}_2+\cdots+a_{s,s-1}h\textbf{k}_{s-1})
\end{array}
</math>

Увеличивая число s вспомогательных точек, можно построить методы Рунге-Кутты любого порядка точности p. Однако уже при p > 5 эти методы используются довольно редко. Это объясняется как чрезмерной громоздкостью получающихся вычислительных формул, так и тем, что преимущества методов высокого порядка точности над методами, в которых p = 4 или p = 5, проявляются либо в тех задачах, где нужна очень высокая точность и используются ЭВМ высокой разрядности, либо в тех задачах, где решение очень гладкое. Кроме того, методы Рунге-Кутты высокого порядка точности часто оказываются менее эффективными по сравнению с методами Адамса того же порядка точности. На этой странице представлен наиболее распространенный метод Рунге-Кутты 4 порядка с ошибкой на конечном интервале интегрирования <math>O(h^4)</math>.

Существуют как явные, так и неявные методы Рунге-Кутты. Последние имеют ряд преимуществ над явными методами, однако это достигается за счет существенного усложнения вычислительного алгоритма, так как на каждом шаге приходится считать систему нелинейных уравнений. На этой странице представлен явный метод Рунге-Кутты.

Можно отметить, что в современных программах, реализующих метод Рунге-Кутты, обязательно используется некоторый алгоритм автоматического изменения шага интегрирования. Интуитивно ясно, что на участках плавного изменения решения счет можно вести с достаточно крупным шагом. В то же время на тех участках, где происходят резкие изменения поведения решения, необходимо выбирать мелкий шаг интегрирования. Обычно начальное значение шага h1 задает пользователь. Далее шаг интегрирования меняется в соответствии с величиной получаемой в ходе вычислений оценки локальной погрешности. Для упрощения описания на этой странице используется постоянный шаг интегрирования h, зависящий от размера сетки разбиения n.

== Математическое описание алгоритма ==

Далее подразумевается, что <math> \bold y, \bold y_i,\bold f, \bold k_i \in \mathbb{R}^m</math>, а <math>x, h, n, a, b \in \mathbb{R}^1 </math>.

Исходные данные:
<math> a, b </math> - интервал интегрирования,
<math> \bold y_0 </math> - вектор значений при <math> x = a </math>,
n - количество точек в разбиении
<math>\bold f </math> - функция вычисления производной

Вычисляемые данные:
<math> \bold y_i </math> - вектора значений в узлах сетки, т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>

Формулы метода:
:Вначале вычисляется шаг сетки:
::<math> h = \frac{b-a}{n}</math>.
:Приближенное значение в следующих точках вычисляется по итерационной формуле:
::<math>\textbf{y}_{n+1} = \textbf{y}_n + {h \over 6}(\textbf{k}_1 + 2\textbf{k}_2 + 2\textbf{k}_3 + \textbf{k}_4)</math>,
::<math>\textbf{k}_1 = \textbf{f} \left( x_n, \textbf{y}_n \right),</math>
::<math>\textbf{k}_2 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_1 \right),</math>
::<math>\textbf{k}_3 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_2 \right),</math>
::<math>\textbf{k}_4 = \textbf{f} \left( x_n + h, \textbf{y}_n + h\ \textbf{k}_3 \right),</math>
::<math>x_{n+1} = x_n + h.</math>

== Вычислительное ядро алгоритма ==

Вычислительным ядром метода Рунге-Кутты можно считать вычисление значений функции производной
:<math>\textbf{f}(x, \textbf{y})</math>,
так как при вычислении каждого нового <math>\textbf{y}_n</math> требуется 4 вычисления значения функции производной. Таким образом, сложность работы алгоритма существенно зависит от сложности вычисления функции <math>\textbf{f}</math>.

== Макроструктура алгоритма ==

Макроструктура алгоритма может быть представлена в следующем виде:
:Вычисление вспомогательных коэффициентов <math>\textbf{k}_j, j \in [1,4]</math>;
:Вычисление приближенного значения <math> \bold y_i </math> в следующей точке;
:Переход на следующую итерацию или остановка.

== Схема реализации последовательного алгоритма ==

Пример реализации последовательного алгоритма на языке C++ (указатель на функцию f передаётся через аргументы представленной ниже функции):
<source lang="c++" line="1">
#include <vector>

// other code ...

std::vector<double> rungekutta4(std::vector<double> a, std::vector<double> b, std::vector<double> y0, int n, double (*f)(double,double))
{
std::vector<double>::size_type sz = myvector.size();
std::vector<double> result;
for (unsigned i=0; i<sz; i++)
{
rezult.push_back(core(a[i],b[i],y0,n,f));
}
return result;
}

double core(double a, double b, double y0, int n, double (*f)(double,double))
{
double h, k1, k2, k3, k4, x, y;
h = (b - a)/n;
y = y0;
x = a;
for (unsigned i = 0; i < n; i++)
{
k1 = f(x, y);
k2 = f(x + h/2, y + h*k1/2);
k3 = f(x + h/2, y + h*k2/2);
k4 = f(x + h/2, y + h*k3);
x += h;
y += h*(k1 + 2*k2 + 2*k3 + k4)/6;
}
return y;
}

// other code ...
</source>

== Последовательная сложность алгоритма ==

Рассмотрим сначала одномерный случай. Наравне с обычными операциями, такими как сложение, умножение и тому подобными, в представленном выше алгоритме присутствует вызов функции <math>\bold f </math>. Так как эта функция может содержать в себе любое количество простых математических операций, будем считать, что её сложность <math>\bold f </math> много больше любой из них, и равна константе <math>C</math>. За весь алгоритм, она вызывается <math>4n</math> раза. Таким образом, сложность последовательного алгоритма для одномерного случая равна <math>4nC</math>.

Для многомерного случая, когда <math>x</math> и <math>y</math> являются векторами размерности <math>m</math>, функция core будет вызвана <math>m</math>, и итоговая сложность алгоритма составит <math>4nCm</math>.

== Информационный граф ==

== Ресурс параллелизма алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является итерационным алгоритмом. В нём каждый шаг цикла зависит от предыдущего. В самом шаге, каждая последующая операция также зависит от результата предыдущей. Таким образом, упразднить цикл до независимых и соответственно параллельных операций не является возможным. Однако, так как на результат функции <math> \bold f </math> влияет только <math>i</math>-ый параметр векторов <math> \bold x </math> и <math> \bold y </math>, то для каждого <math> i </math> можно производить независимое вычисление. В итоге, если вычислять результаты выполнения функции <math> \bold f </math> одновременно для вля всех <math>\bold i</math>-ых параметров векторов <math> \bold x </math> и <math> \bold y </math>, получим туже алгоритмическую сложность <math>4nC</math>, что и в [[#Последовательная сложность алгоритма|разделе 1.6]] для одномерного случая.

== Входные и выходные данные алгоритма ==

'''Входные данные''':
<math> a, b </math> - интервал интегрирования,
n - количество точек в разбиении,
<math> \bold y_0 </math> - вектор значений размерности m при <math> x = a </math>,
функцию вычисления производной <math>\bold f </math> будем считать встроенной в алгоритм.

'''Объём входных данных''':
m + 3

'''Выходные данные:'''
<math> \bold y_i </math> - вектора размера m значений в n узлах сетки (т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>).

'''Объем выходных данных'''
n * m

== Свойства алгоритма ==

= ЧАСТЬ. Программная реализация алгоритма =

== [[Особенности реализации последовательного алгоритма]] ==

== [[Локальность данных и вычислений]] ==

== [[Возможные способы и особенности параллельной реализации алгоритма]] ==

== Масштабируемость алгоритма и его реализации ==

== [[Динамические характеристики и эффективность реализации алгоритма]] ==

== [[Выводы для классов архитектур]] ==

== Существующие реализации алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является одним из наиболее используемых для решения ОДУ и их систем, поэтому существует большое число его реализаций. Наиболее популярными являются следующие из них:

= Литература =

Участник:Борис/Алгоритм Рунге-Кутты

2016-10-15T18:12:46Z

Борис: /* Последовательная сложность алгоритма */

{{algorithm
| name = Метод Рунге-Кутты 4 порядка
| serial_complexity = <math>O()</math>
| pf_height = <math>O()</math>
| pf_width = <math>O()</math>
| input_data = <math>m + 3</math>
| output_data = <math>m * n</math>
}}

Основные авторы описания: [[Участник:Jest|Е.П.Степанов]]([[#Общее описание алгоритма|раздел 1.1]], [[#Математическое описание алгоритма|раздел 1.2]], [[#Вычислительное ядро алгоритма|раздел 1.3]], [[#Макроструктура алгоритма|раздел 1.4]], [[#Входные и выходные данные алгоритма|раздел 1.9]]), [[Участник:Борис|Б.Савков]] ( [[#Схема реализации последовательного алгоритма|раздел 1.5]], [[#Последовательная сложность алгоритма|раздел 1.6]], [[#Ресурс параллелизма алгоритма|раздел 1.8]])

= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==

Ме́тоды Ру́нге — Ку́тты (распространено неправильное название Ме́тоды Ру́нге — Ку́тта или же Ме́тоды Ру́нге — Кутта́) — важное семейство численных алгоритмов решения обыкновенных дифференциальных уравнений и их систем. Данные итеративные методы явного и неявного приближённого вычисления были разработаны около 1900 года немецкими математиками К. Рунге и М. В. Куттой.

Метод Рунге - Кутты применяется при решения задачи Коши для системы обыкновенных дифференциальных уравнений первого порядка:

:<math>
\begin{cases}
\textbf{y}' = \textbf{f}(x, \textbf{y}),\\
\textbf{y}(x_0) = \textbf{y}_0.
\end{cases}
</math>

При этом <math>\textbf{y}, \textbf{f}, x</math> отвечают следующим свойствам: <math> \textbf{y}, \textbf{f} \in \mathbb{R}^m, x \in \mathbb{R}^1 </math>.

Пусть известно значение y(x) и требуется вычислить значение y(x+h). Это можно сделать при помощи формулы:

:<math> y(x + h) = y(x) + \int_0^hy'(x + t)dt</math>

Аппроксимируя интеграл в правой части, можно получить методы Рунге-Кутты разного порядка точности. В общем виде формулы методов Рунге-Кутты можно записать следующим образом:

:<math>\textbf{y}_{n+1} = \textbf{y}_n + h\sum_{i=1}^s b_i \textbf{k}_i</math>

:<math>
\begin{array}{ll}
\textbf{k}_1 =& \textbf{f}(x_n, \textbf{y}_n),\\
\textbf{k}_2 =& \textbf{f}(x_n+c_2h, \textbf{y}_n+a_{21}h\textbf{k}_1),\\
\cdots&\\
\textbf{k}_s =& \textbf{f}(x_n+c_sh, \textbf{y}_n+a_{s1}h\textbf{k}_1+a_{s2}h\textbf{k}_2+\cdots+a_{s,s-1}h\textbf{k}_{s-1})
\end{array}
</math>

Увеличивая число s вспомогательных точек, можно построить методы Рунге-Кутты любого порядка точности p. Однако уже при p > 5 эти методы используются довольно редко. Это объясняется как чрезмерной громоздкостью получающихся вычислительных формул, так и тем, что преимущества методов высокого порядка точности над методами, в которых p = 4 или p = 5, проявляются либо в тех задачах, где нужна очень высокая точность и используются ЭВМ высокой разрядности, либо в тех задачах, где решение очень гладкое. Кроме того, методы Рунге-Кутты высокого порядка точности часто оказываются менее эффективными по сравнению с методами Адамса того же порядка точности. На этой странице представлен наиболее распространенный метод Рунге-Кутты 4 порядка с ошибкой на конечном интервале интегрирования <math>O(h^4)</math>.

Существуют как явные, так и неявные методы Рунге-Кутты. Последние имеют ряд преимуществ над явными методами, однако это достигается за счет существенного усложнения вычислительного алгоритма, так как на каждом шаге приходится считать систему нелинейных уравнений. На этой странице представлен явный метод Рунге-Кутты.

Можно отметить, что в современных программах, реализующих метод Рунге-Кутты, обязательно используется некоторый алгоритм автоматического изменения шага интегрирования. Интуитивно ясно, что на участках плавного изменения решения счет можно вести с достаточно крупным шагом. В то же время на тех участках, где происходят резкие изменения поведения решения, необходимо выбирать мелкий шаг интегрирования. Обычно начальное значение шага h1 задает пользователь. Далее шаг интегрирования меняется в соответствии с величиной получаемой в ходе вычислений оценки локальной погрешности. Для упрощения описания на этой странице используется постоянный шаг интегрирования h, зависящий от размера сетки разбиения n.

== Математическое описание алгоритма ==

Далее подразумевается, что <math> \bold y, \bold y_i,\bold f, \bold k_i \in \mathbb{R}^m</math>, а <math>x, h, n, a, b \in \mathbb{R}^1 </math>.

Исходные данные:
<math> a, b </math> - интервал интегрирования,
<math> \bold y_0 </math> - вектор значений при <math> x = a </math>,
n - количество точек в разбиении
<math>\bold f </math> - функция вычисления производной

Вычисляемые данные:
<math> \bold y_i </math> - вектора значений в узлах сетки, т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>

Формулы метода:
:Вначале вычисляется шаг сетки:
::<math> h = \frac{b-a}{n}</math>.
:Приближенное значение в следующих точках вычисляется по итерационной формуле:
::<math>\textbf{y}_{n+1} = \textbf{y}_n + {h \over 6}(\textbf{k}_1 + 2\textbf{k}_2 + 2\textbf{k}_3 + \textbf{k}_4)</math>,
::<math>\textbf{k}_1 = \textbf{f} \left( x_n, \textbf{y}_n \right),</math>
::<math>\textbf{k}_2 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_1 \right),</math>
::<math>\textbf{k}_3 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_2 \right),</math>
::<math>\textbf{k}_4 = \textbf{f} \left( x_n + h, \textbf{y}_n + h\ \textbf{k}_3 \right),</math>
::<math>x_{n+1} = x_n + h.</math>

== Вычислительное ядро алгоритма ==

Вычислительным ядром метода Рунге-Кутты можно считать вычисление значений функции производной
:<math>\textbf{f}(x, \textbf{y})</math>,
так как при вычислении каждого нового <math>\textbf{y}_n</math> требуется 4 вычисления значения функции производной. Таким образом, сложность работы алгоритма существенно зависит от сложности вычисления функции <math>\textbf{f}</math>.

== Макроструктура алгоритма ==

Макроструктура алгоритма может быть представлена в следующем виде:
:Вычисление вспомогательных коэффициентов <math>\textbf{k}_j, j \in [1,4]</math>;
:Вычисление приближенного значения <math> \bold y_i </math> в следующей точке;
:Переход на следующую итерацию или остановка.

== Схема реализации последовательного алгоритма ==

Пример реализации последовательного алгоритма на языке C++ (указатель на функцию f передаётся через аргументы представленной ниже функции):
<source lang="c++" line="1">
#include <vector>

// other code ...

std::vector<double> rungekutta4(std::vector<double> a, std::vector<double> b, std::vector<double> y0, int n, double (*f)(double,double))
{
std::vector<double>::size_type sz = myvector.size();
std::vector<double> result;
for (unsigned i=0; i<sz; i++)
{
rezult.push_back(core(a[i],b[i],y0,n,f));
}
return result;
}

double core(double a, double b, double y0, int n, double (*f)(double,double))
{
double h, k1, k2, k3, k4, x, y;
h = (b - a)/n;
y = y0;
x = a;
for (unsigned i = 0; i < n; i++)
{
k1 = f(x, y);
k2 = f(x + h/2, y + h*k1/2);
k3 = f(x + h/2, y + h*k2/2);
k4 = f(x + h/2, y + h*k3);
x += h;
y += h*(k1 + 2*k2 + 2*k3 + k4)/6;
}
return y;
}

// other code ...
</source>

== Последовательная сложность алгоритма ==

Рассмотрим сначала одномерный случай. Наравне с обычными операциями, такими как сложение, умножение и тому подобными, в представленном выше алгоритме присутствует вызов функции <math>\bold f </math>. Так как эта функция может содержать в себе любое количество простых математических операций, будем считать, что её сложность <math>\bold f </math> много больше любой из них, и равна константе <math>C</math>. За весь алгоритм, она вызывается <math>4n</math> раза. Таким образом, сложность последовательного алгоритма для одномерного случая равна <math>4nC</math>.

Для многомерного случая, когда <math>x</math> и <math>y</math> являются векторами размерности <math>m</math>, функция core будет вызвана <math>m</math>, и итоговая сложность алгоритма составит <math>4nCm</math>.

== Информационный граф ==

== Ресурс параллелизма алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является итерационным алгоритмом. В нём каждый шаг цикла зависит от предыдущего. В самом шаге, каждая последующая операция также зависит от результата предыдущей. Таким образом, упразднить цикл до независимых и соответственно параллельных операций не является возможным. Однако, так как на результат функции <math> \bold f </math> влияет только <math>i</math>-ый параметр векторов <math> \bold x </math> и <math> \bold y </math>, то для каждого <math> i </math> можно производить независимое вычисление. В итоге, если вычислять результаты выполнения функции <math> \bold f </math> одновременно для вля всех <math>\bold i</math>-ых параметров векторов <math> \bold x </math> и <math> \bold y </math>, получим туже алгоритмическую сложность <math>4nC</math>, что и в [[#Последовательная сложность алгоритма|разделе 1.6]] для одномерного случая.

== Входные и выходные данные алгоритма ==

'''Входные данные''':
<math> a, b </math> - интервал интегрирования,
n - количество точек в разбиении,
<math> \bold y_0 </math> - вектор значений размерности m при <math> x = a </math>,
функцию вычисления производной <math>\bold f </math> будем считать встроенной в алгоритм.

'''Объём входных данных''':
m + 3

'''Выходные данные:'''
<math> \bold y_i </math> - вектора размера m значений в n узлах сетки (т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>).

'''Объем выходных данных'''
n * m

== Свойства алгоритма ==

= ЧАСТЬ. Программная реализация алгоритма =

== [[Особенности реализации последовательного алгоритма]] ==

== [[Локальность данных и вычислений]] ==

== [[Возможные способы и особенности параллельной реализации алгоритма]] ==

== Масштабируемость алгоритма и его реализации ==

== [[Динамические характеристики и эффективность реализации алгоритма]] ==

== [[Выводы для классов архитектур]] ==

== Существующие реализации алгоритма ==

= Литература =

Участник:Борис/Алгоритм Рунге-Кутты

2016-10-15T18:09:16Z

Борис: /* Последовательная сложность алгоритма */

{{algorithm
| name = Метод Рунге-Кутты 4 порядка
| serial_complexity = <math>O()</math>
| pf_height = <math>O()</math>
| pf_width = <math>O()</math>
| input_data = <math>m + 3</math>
| output_data = <math>m * n</math>
}}

Основные авторы описания: [[Участник:Jest|Е.П.Степанов]]([[#Общее описание алгоритма|раздел 1.1]], [[#Математическое описание алгоритма|раздел 1.2]], [[#Вычислительное ядро алгоритма|раздел 1.3]], [[#Макроструктура алгоритма|раздел 1.4]], [[#Входные и выходные данные алгоритма|раздел 1.9]]), [[Участник:Борис|Б.Савков]] ( [[#Схема реализации последовательного алгоритма|раздел 1.5]], [[#Последовательная сложность алгоритма|раздел 1.6]], [[#Ресурс параллелизма алгоритма|раздел 1.8]])

= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==

Ме́тоды Ру́нге — Ку́тты (распространено неправильное название Ме́тоды Ру́нге — Ку́тта или же Ме́тоды Ру́нге — Кутта́) — важное семейство численных алгоритмов решения обыкновенных дифференциальных уравнений и их систем. Данные итеративные методы явного и неявного приближённого вычисления были разработаны около 1900 года немецкими математиками К. Рунге и М. В. Куттой.

Метод Рунге - Кутты применяется при решения задачи Коши для системы обыкновенных дифференциальных уравнений первого порядка:

:<math>
\begin{cases}
\textbf{y}' = \textbf{f}(x, \textbf{y}),\\
\textbf{y}(x_0) = \textbf{y}_0.
\end{cases}
</math>

При этом <math>\textbf{y}, \textbf{f}, x</math> отвечают следующим свойствам: <math> \textbf{y}, \textbf{f} \in \mathbb{R}^m, x \in \mathbb{R}^1 </math>.

Пусть известно значение y(x) и требуется вычислить значение y(x+h). Это можно сделать при помощи формулы:

:<math> y(x + h) = y(x) + \int_0^hy'(x + t)dt</math>

Аппроксимируя интеграл в правой части, можно получить методы Рунге-Кутты разного порядка точности. В общем виде формулы методов Рунге-Кутты можно записать следующим образом:

:<math>\textbf{y}_{n+1} = \textbf{y}_n + h\sum_{i=1}^s b_i \textbf{k}_i</math>

:<math>
\begin{array}{ll}
\textbf{k}_1 =& \textbf{f}(x_n, \textbf{y}_n),\\
\textbf{k}_2 =& \textbf{f}(x_n+c_2h, \textbf{y}_n+a_{21}h\textbf{k}_1),\\
\cdots&\\
\textbf{k}_s =& \textbf{f}(x_n+c_sh, \textbf{y}_n+a_{s1}h\textbf{k}_1+a_{s2}h\textbf{k}_2+\cdots+a_{s,s-1}h\textbf{k}_{s-1})
\end{array}
</math>

Увеличивая число s вспомогательных точек, можно построить методы Рунге-Кутты любого порядка точности p. Однако уже при p > 5 эти методы используются довольно редко. Это объясняется как чрезмерной громоздкостью получающихся вычислительных формул, так и тем, что преимущества методов высокого порядка точности над методами, в которых p = 4 или p = 5, проявляются либо в тех задачах, где нужна очень высокая точность и используются ЭВМ высокой разрядности, либо в тех задачах, где решение очень гладкое. Кроме того, методы Рунге-Кутты высокого порядка точности часто оказываются менее эффективными по сравнению с методами Адамса того же порядка точности. На этой странице представлен наиболее распространенный метод Рунге-Кутты 4 порядка с ошибкой на конечном интервале интегрирования <math>O(h^4)</math>.

Существуют как явные, так и неявные методы Рунге-Кутты. Последние имеют ряд преимуществ над явными методами, однако это достигается за счет существенного усложнения вычислительного алгоритма, так как на каждом шаге приходится считать систему нелинейных уравнений. На этой странице представлен явный метод Рунге-Кутты.

Можно отметить, что в современных программах, реализующих метод Рунге-Кутты, обязательно используется некоторый алгоритм автоматического изменения шага интегрирования. Интуитивно ясно, что на участках плавного изменения решения счет можно вести с достаточно крупным шагом. В то же время на тех участках, где происходят резкие изменения поведения решения, необходимо выбирать мелкий шаг интегрирования. Обычно начальное значение шага h1 задает пользователь. Далее шаг интегрирования меняется в соответствии с величиной получаемой в ходе вычислений оценки локальной погрешности. Для упрощения описания на этой странице используется постоянный шаг интегрирования h, зависящий от размера сетки разбиения n.

== Математическое описание алгоритма ==

Далее подразумевается, что <math> \bold y, \bold y_i,\bold f, \bold k_i \in \mathbb{R}^m</math>, а <math>x, h, n, a, b \in \mathbb{R}^1 </math>.

Исходные данные:
<math> a, b </math> - интервал интегрирования,
<math> \bold y_0 </math> - вектор значений при <math> x = a </math>,
n - количество точек в разбиении
<math>\bold f </math> - функция вычисления производной

Вычисляемые данные:
<math> \bold y_i </math> - вектора значений в узлах сетки, т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>

Формулы метода:
:Вначале вычисляется шаг сетки:
::<math> h = \frac{b-a}{n}</math>.
:Приближенное значение в следующих точках вычисляется по итерационной формуле:
::<math>\textbf{y}_{n+1} = \textbf{y}_n + {h \over 6}(\textbf{k}_1 + 2\textbf{k}_2 + 2\textbf{k}_3 + \textbf{k}_4)</math>,
::<math>\textbf{k}_1 = \textbf{f} \left( x_n, \textbf{y}_n \right),</math>
::<math>\textbf{k}_2 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_1 \right),</math>
::<math>\textbf{k}_3 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_2 \right),</math>
::<math>\textbf{k}_4 = \textbf{f} \left( x_n + h, \textbf{y}_n + h\ \textbf{k}_3 \right),</math>
::<math>x_{n+1} = x_n + h.</math>

== Вычислительное ядро алгоритма ==

Вычислительным ядром метода Рунге-Кутты можно считать вычисление значений функции производной
:<math>\textbf{f}(x, \textbf{y})</math>,
так как при вычислении каждого нового <math>\textbf{y}_n</math> требуется 4 вычисления значения функции производной. Таким образом, сложность работы алгоритма существенно зависит от сложности вычисления функции <math>\textbf{f}</math>.

== Макроструктура алгоритма ==

Макроструктура алгоритма может быть представлена в следующем виде:
:Вычисление вспомогательных коэффициентов <math>\textbf{k}_j, j \in [1,4]</math>;
:Вычисление приближенного значения <math> \bold y_i </math> в следующей точке;
:Переход на следующую итерацию или остановка.

== Схема реализации последовательного алгоритма ==

Пример реализации последовательного алгоритма на языке C++ (указатель на функцию f передаётся через аргументы представленной ниже функции):
<source lang="c++" line="1">
#include <vector>

// other code ...

std::vector<double> rungekutta4(std::vector<double> a, std::vector<double> b, std::vector<double> y0, int n, double (*f)(double,double))
{
std::vector<double>::size_type sz = myvector.size();
std::vector<double> result;
for (unsigned i=0; i<sz; i++)
{
rezult.push_back(core(a[i],b[i],y0,n,f));
}
return result;
}

double core(double a, double b, double y0, int n, double (*f)(double,double))
{
double h, k1, k2, k3, k4, x, y;
h = (b - a)/n;
y = y0;
x = a;
for (unsigned i = 0; i < n; i++)
{
k1 = f(x, y);
k2 = f(x + h/2, y + h*k1/2);
k3 = f(x + h/2, y + h*k2/2);
k4 = f(x + h/2, y + h*k3);
x += h;
y += h*(k1 + 2*k2 + 2*k3 + k4)/6;
}
return y;
}

// other code ...
</source>

== Последовательная сложность алгоритма ==

Рассмотрим сначала одномерный случай. Наравне с обычными операциями, такими как сложение, умножение и тому подобными, в представленном выше алгоритме присутствует вызов функции <math>\bold f </math>. Так как эта функция может содержать в себе любое количество простых математических операций, будем считать, что её сложность <math>\bold f </math> много больше любой из них, и равна константе <math>C</math>. За весь алгоритм, она вызывается <math>4n</math> раза. Таким образом, сложность последовательного алгоритма для одномерного случая равна <math>4nC</math>. Для многомерного случая, когда <math>x</math> и <math>y</math> являются векторами размерности <math>m</math>, функция core будет вызвана <math>m</math>, и итоговая сложность алгоритма составит <math>4nCm</math>.

== Информационный граф ==

== Ресурс параллелизма алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является итерационным алгоритмом. В нём каждый шаг цикла зависит от предыдущего. В самом шаге, каждая последующая операция также зависит от результата предыдущей. Таким образом, упразднить цикл до независимых и соответственно параллельных операций не является возможным. Однако, так как на результат функции <math> \bold f </math> влияет только <math>i</math>-ый параметр векторов <math> \bold x </math> и <math> \bold y </math>, то для каждого <math> i </math> можно производить независимое вычисление. В итоге, если вычислять результаты выполнения функции <math> \bold f </math> одновременно для вля всех <math>\bold i</math>-ых параметров векторов <math> \bold x </math> и <math> \bold y </math>, получим туже алгоритмическую сложность <math>4nC</math>, что и в [[#Последовательная сложность алгоритма|разделе 1.6]] для одномерного случая.

== Входные и выходные данные алгоритма ==

'''Входные данные''':
<math> a, b </math> - интервал интегрирования,
n - количество точек в разбиении,
<math> \bold y_0 </math> - вектор значений размерности m при <math> x = a </math>,
функцию вычисления производной <math>\bold f </math> будем считать встроенной в алгоритм.

'''Объём входных данных''':
m + 3

'''Выходные данные:'''
<math> \bold y_i </math> - вектора размера m значений в n узлах сетки (т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>).

'''Объем выходных данных'''
n * m

== Свойства алгоритма ==

= ЧАСТЬ. Программная реализация алгоритма =

== [[Особенности реализации последовательного алгоритма]] ==

== [[Локальность данных и вычислений]] ==

== [[Возможные способы и особенности параллельной реализации алгоритма]] ==

== Масштабируемость алгоритма и его реализации ==

== [[Динамические характеристики и эффективность реализации алгоритма]] ==

== [[Выводы для классов архитектур]] ==

== Существующие реализации алгоритма ==

= Литература =

Участник:Борис/Алгоритм Рунге-Кутты

2016-10-15T18:08:56Z

Борис:

{{algorithm
| name = Метод Рунге-Кутты 4 порядка
| serial_complexity = <math>O()</math>
| pf_height = <math>O()</math>
| pf_width = <math>O()</math>
| input_data = <math>m + 3</math>
| output_data = <math>m * n</math>
}}

Основные авторы описания: [[Участник:Jest|Е.П.Степанов]]([[#Общее описание алгоритма|раздел 1.1]], [[#Математическое описание алгоритма|раздел 1.2]], [[#Вычислительное ядро алгоритма|раздел 1.3]], [[#Макроструктура алгоритма|раздел 1.4]], [[#Входные и выходные данные алгоритма|раздел 1.9]]), [[Участник:Борис|Б.Савков]] ( [[#Схема реализации последовательного алгоритма|раздел 1.5]], [[#Последовательная сложность алгоритма|раздел 1.6]], [[#Ресурс параллелизма алгоритма|раздел 1.8]])

= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==

Ме́тоды Ру́нге — Ку́тты (распространено неправильное название Ме́тоды Ру́нге — Ку́тта или же Ме́тоды Ру́нге — Кутта́) — важное семейство численных алгоритмов решения обыкновенных дифференциальных уравнений и их систем. Данные итеративные методы явного и неявного приближённого вычисления были разработаны около 1900 года немецкими математиками К. Рунге и М. В. Куттой.

Метод Рунге - Кутты применяется при решения задачи Коши для системы обыкновенных дифференциальных уравнений первого порядка:

:<math>
\begin{cases}
\textbf{y}' = \textbf{f}(x, \textbf{y}),\\
\textbf{y}(x_0) = \textbf{y}_0.
\end{cases}
</math>

При этом <math>\textbf{y}, \textbf{f}, x</math> отвечают следующим свойствам: <math> \textbf{y}, \textbf{f} \in \mathbb{R}^m, x \in \mathbb{R}^1 </math>.

Пусть известно значение y(x) и требуется вычислить значение y(x+h). Это можно сделать при помощи формулы:

:<math> y(x + h) = y(x) + \int_0^hy'(x + t)dt</math>

Аппроксимируя интеграл в правой части, можно получить методы Рунге-Кутты разного порядка точности. В общем виде формулы методов Рунге-Кутты можно записать следующим образом:

:<math>\textbf{y}_{n+1} = \textbf{y}_n + h\sum_{i=1}^s b_i \textbf{k}_i</math>

:<math>
\begin{array}{ll}
\textbf{k}_1 =& \textbf{f}(x_n, \textbf{y}_n),\\
\textbf{k}_2 =& \textbf{f}(x_n+c_2h, \textbf{y}_n+a_{21}h\textbf{k}_1),\\
\cdots&\\
\textbf{k}_s =& \textbf{f}(x_n+c_sh, \textbf{y}_n+a_{s1}h\textbf{k}_1+a_{s2}h\textbf{k}_2+\cdots+a_{s,s-1}h\textbf{k}_{s-1})
\end{array}
</math>

Увеличивая число s вспомогательных точек, можно построить методы Рунге-Кутты любого порядка точности p. Однако уже при p > 5 эти методы используются довольно редко. Это объясняется как чрезмерной громоздкостью получающихся вычислительных формул, так и тем, что преимущества методов высокого порядка точности над методами, в которых p = 4 или p = 5, проявляются либо в тех задачах, где нужна очень высокая точность и используются ЭВМ высокой разрядности, либо в тех задачах, где решение очень гладкое. Кроме того, методы Рунге-Кутты высокого порядка точности часто оказываются менее эффективными по сравнению с методами Адамса того же порядка точности. На этой странице представлен наиболее распространенный метод Рунге-Кутты 4 порядка с ошибкой на конечном интервале интегрирования <math>O(h^4)</math>.

Существуют как явные, так и неявные методы Рунге-Кутты. Последние имеют ряд преимуществ над явными методами, однако это достигается за счет существенного усложнения вычислительного алгоритма, так как на каждом шаге приходится считать систему нелинейных уравнений. На этой странице представлен явный метод Рунге-Кутты.

Можно отметить, что в современных программах, реализующих метод Рунге-Кутты, обязательно используется некоторый алгоритм автоматического изменения шага интегрирования. Интуитивно ясно, что на участках плавного изменения решения счет можно вести с достаточно крупным шагом. В то же время на тех участках, где происходят резкие изменения поведения решения, необходимо выбирать мелкий шаг интегрирования. Обычно начальное значение шага h1 задает пользователь. Далее шаг интегрирования меняется в соответствии с величиной получаемой в ходе вычислений оценки локальной погрешности. Для упрощения описания на этой странице используется постоянный шаг интегрирования h, зависящий от размера сетки разбиения n.

== Математическое описание алгоритма ==

Далее подразумевается, что <math> \bold y, \bold y_i,\bold f, \bold k_i \in \mathbb{R}^m</math>, а <math>x, h, n, a, b \in \mathbb{R}^1 </math>.

Исходные данные:
<math> a, b </math> - интервал интегрирования,
<math> \bold y_0 </math> - вектор значений при <math> x = a </math>,
n - количество точек в разбиении
<math>\bold f </math> - функция вычисления производной

Вычисляемые данные:
<math> \bold y_i </math> - вектора значений в узлах сетки, т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>

Формулы метода:
:Вначале вычисляется шаг сетки:
::<math> h = \frac{b-a}{n}</math>.
:Приближенное значение в следующих точках вычисляется по итерационной формуле:
::<math>\textbf{y}_{n+1} = \textbf{y}_n + {h \over 6}(\textbf{k}_1 + 2\textbf{k}_2 + 2\textbf{k}_3 + \textbf{k}_4)</math>,
::<math>\textbf{k}_1 = \textbf{f} \left( x_n, \textbf{y}_n \right),</math>
::<math>\textbf{k}_2 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_1 \right),</math>
::<math>\textbf{k}_3 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_2 \right),</math>
::<math>\textbf{k}_4 = \textbf{f} \left( x_n + h, \textbf{y}_n + h\ \textbf{k}_3 \right),</math>
::<math>x_{n+1} = x_n + h.</math>

== Вычислительное ядро алгоритма ==

Вычислительным ядром метода Рунге-Кутты можно считать вычисление значений функции производной
:<math>\textbf{f}(x, \textbf{y})</math>,
так как при вычислении каждого нового <math>\textbf{y}_n</math> требуется 4 вычисления значения функции производной. Таким образом, сложность работы алгоритма существенно зависит от сложности вычисления функции <math>\textbf{f}</math>.

== Макроструктура алгоритма ==

Макроструктура алгоритма может быть представлена в следующем виде:
:Вычисление вспомогательных коэффициентов <math>\textbf{k}_j, j \in [1,4]</math>;
:Вычисление приближенного значения <math> \bold y_i </math> в следующей точке;
:Переход на следующую итерацию или остановка.

== Схема реализации последовательного алгоритма ==

Пример реализации последовательного алгоритма на языке C++ (указатель на функцию f передаётся через аргументы представленной ниже функции):
<source lang="c++" line="1">
#include <vector>

// other code ...

std::vector<double> rungekutta4(std::vector<double> a, std::vector<double> b, std::vector<double> y0, int n, double (*f)(double,double))
{
std::vector<double>::size_type sz = myvector.size();
std::vector<double> result;
for (unsigned i=0; i<sz; i++)
{
rezult.push_back(core(a[i],b[i],y0,n,f));
}
return result;
}

double core(double a, double b, double y0, int n, double (*f)(double,double))
{
double h, k1, k2, k3, k4, x, y;
h = (b - a)/n;
y = y0;
x = a;
for (unsigned i = 0; i < n; i++)
{
k1 = f(x, y);
k2 = f(x + h/2, y + h*k1/2);
k3 = f(x + h/2, y + h*k2/2);
k4 = f(x + h/2, y + h*k3);
x += h;
y += h*(k1 + 2*k2 + 2*k3 + k4)/6;
}
return y;
}

// other code ...
</source>

== Последовательная сложность алгоритма ==

Рассмотрим сначала одномерный случай. Наравне с обычными операциями, такими как сложение, умножение и тому подобными, в представленном выше алгоритме присутствует вызов функции <math>\bold f </math>. Так как эта функция может содержать в себе любое количество простых математических операций, будем считать, что её сложность <math>\bold f </math> много больше любой из них, и равна константе <math>C</math>. За весь алгоритм, она вызывается <math>4n</math> раза. Таким образом, сложность последовательного алгоритма для одномерного случая равна <math>4nC</math>. Для многомерного случая, когда <math>x</math> и <math>y</math> являются векторами размерности <math>m</math>, функция core будет вызвана <math>m</math>, и итоговая сложность алгоритма составит <math>4nCm</math>

== Информационный граф ==

== Ресурс параллелизма алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является итерационным алгоритмом. В нём каждый шаг цикла зависит от предыдущего. В самом шаге, каждая последующая операция также зависит от результата предыдущей. Таким образом, упразднить цикл до независимых и соответственно параллельных операций не является возможным. Однако, так как на результат функции <math> \bold f </math> влияет только <math>i</math>-ый параметр векторов <math> \bold x </math> и <math> \bold y </math>, то для каждого <math> i </math> можно производить независимое вычисление. В итоге, если вычислять результаты выполнения функции <math> \bold f </math> одновременно для вля всех <math>\bold i</math>-ых параметров векторов <math> \bold x </math> и <math> \bold y </math>, получим туже алгоритмическую сложность <math>4nC</math>, что и в [[#Последовательная сложность алгоритма|разделе 1.6]] для одномерного случая.

== Входные и выходные данные алгоритма ==

'''Входные данные''':
<math> a, b </math> - интервал интегрирования,
n - количество точек в разбиении,
<math> \bold y_0 </math> - вектор значений размерности m при <math> x = a </math>,
функцию вычисления производной <math>\bold f </math> будем считать встроенной в алгоритм.

'''Объём входных данных''':
m + 3

'''Выходные данные:'''
<math> \bold y_i </math> - вектора размера m значений в n узлах сетки (т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>).

'''Объем выходных данных'''
n * m

== Свойства алгоритма ==

= ЧАСТЬ. Программная реализация алгоритма =

== [[Особенности реализации последовательного алгоритма]] ==

== [[Локальность данных и вычислений]] ==

== [[Возможные способы и особенности параллельной реализации алгоритма]] ==

== Масштабируемость алгоритма и его реализации ==

== [[Динамические характеристики и эффективность реализации алгоритма]] ==

== [[Выводы для классов архитектур]] ==

== Существующие реализации алгоритма ==

= Литература =

Участник:Борис/Алгоритм Рунге-Кутты

2016-10-15T18:04:42Z

Борис: /* Последовательная сложность алгоритма */

{{algorithm
| name = Метод Рунге-Кутты 4 порядка
| serial_complexity = <math>O()</math>
| pf_height = <math>O()</math>
| pf_width = <math>O()</math>
| input_data = <math>m + 3</math>
| output_data = <math>m * n</math>
}}

Основные авторы описания: [[Участник:Jest|Е.П.Степанов]]([[#Общее описание алгоритма|раздел 1.1]], [[#Математическое описание алгоритма|раздел 1.2]], [[#Вычислительное ядро алгоритма|раздел 1.3]], [[#Макроструктура алгоритма|раздел 1.4]], [[#Входные и выходные данные алгоритма|раздел 1.9]]), [[Участник:Борис|Б.Савков]] ()

= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==

Ме́тоды Ру́нге — Ку́тты (распространено неправильное название Ме́тоды Ру́нге — Ку́тта или же Ме́тоды Ру́нге — Кутта́) — важное семейство численных алгоритмов решения обыкновенных дифференциальных уравнений и их систем. Данные итеративные методы явного и неявного приближённого вычисления были разработаны около 1900 года немецкими математиками К. Рунге и М. В. Куттой.

Метод Рунге - Кутты применяется при решения задачи Коши для системы обыкновенных дифференциальных уравнений первого порядка:

:<math>
\begin{cases}
\textbf{y}' = \textbf{f}(x, \textbf{y}),\\
\textbf{y}(x_0) = \textbf{y}_0.
\end{cases}
</math>

При этом <math>\textbf{y}, \textbf{f}, x</math> отвечают следующим свойствам: <math> \textbf{y}, \textbf{f} \in \mathbb{R}^m, x \in \mathbb{R}^1 </math>.

Пусть известно значение y(x) и требуется вычислить значение y(x+h). Это можно сделать при помощи формулы:

:<math> y(x + h) = y(x) + \int_0^hy'(x + t)dt</math>

Аппроксимируя интеграл в правой части, можно получить методы Рунге-Кутты разного порядка точности. В общем виде формулы методов Рунге-Кутты можно записать следующим образом:

:<math>\textbf{y}_{n+1} = \textbf{y}_n + h\sum_{i=1}^s b_i \textbf{k}_i</math>

:<math>
\begin{array}{ll}
\textbf{k}_1 =& \textbf{f}(x_n, \textbf{y}_n),\\
\textbf{k}_2 =& \textbf{f}(x_n+c_2h, \textbf{y}_n+a_{21}h\textbf{k}_1),\\
\cdots&\\
\textbf{k}_s =& \textbf{f}(x_n+c_sh, \textbf{y}_n+a_{s1}h\textbf{k}_1+a_{s2}h\textbf{k}_2+\cdots+a_{s,s-1}h\textbf{k}_{s-1})
\end{array}
</math>

Увеличивая число s вспомогательных точек, можно построить методы Рунге-Кутты любого порядка точности p. Однако уже при p > 5 эти методы используются довольно редко. Это объясняется как чрезмерной громоздкостью получающихся вычислительных формул, так и тем, что преимущества методов высокого порядка точности над методами, в которых p = 4 или p = 5, проявляются либо в тех задачах, где нужна очень высокая точность и используются ЭВМ высокой разрядности, либо в тех задачах, где решение очень гладкое. Кроме того, методы Рунге-Кутты высокого порядка точности часто оказываются менее эффективными по сравнению с методами Адамса того же порядка точности. На этой странице представлен наиболее распространенный метод Рунге-Кутты 4 порядка с ошибкой на конечном интервале интегрирования <math>O(h^4)</math>.

Существуют как явные, так и неявные методы Рунге-Кутты. Последние имеют ряд преимуществ над явными методами, однако это достигается за счет существенного усложнения вычислительного алгоритма, так как на каждом шаге приходится считать систему нелинейных уравнений. На этой странице представлен явный метод Рунге-Кутты.

Можно отметить, что в современных программах, реализующих метод Рунге-Кутты, обязательно используется некоторый алгоритм автоматического изменения шага интегрирования. Интуитивно ясно, что на участках плавного изменения решения счет можно вести с достаточно крупным шагом. В то же время на тех участках, где происходят резкие изменения поведения решения, необходимо выбирать мелкий шаг интегрирования. Обычно начальное значение шага h1 задает пользователь. Далее шаг интегрирования меняется в соответствии с величиной получаемой в ходе вычислений оценки локальной погрешности. Для упрощения описания на этой странице используется постоянный шаг интегрирования h, зависящий от размера сетки разбиения n.

== Математическое описание алгоритма ==

Далее подразумевается, что <math> \bold y, \bold y_i,\bold f, \bold k_i \in \mathbb{R}^m</math>, а <math>x, h, n, a, b \in \mathbb{R}^1 </math>.

Исходные данные:
<math> a, b </math> - интервал интегрирования,
<math> \bold y_0 </math> - вектор значений при <math> x = a </math>,
n - количество точек в разбиении
<math>\bold f </math> - функция вычисления производной

Вычисляемые данные:
<math> \bold y_i </math> - вектора значений в узлах сетки, т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>

Формулы метода:
:Вначале вычисляется шаг сетки:
::<math> h = \frac{b-a}{n}</math>.
:Приближенное значение в следующих точках вычисляется по итерационной формуле:
::<math>\textbf{y}_{n+1} = \textbf{y}_n + {h \over 6}(\textbf{k}_1 + 2\textbf{k}_2 + 2\textbf{k}_3 + \textbf{k}_4)</math>,
::<math>\textbf{k}_1 = \textbf{f} \left( x_n, \textbf{y}_n \right),</math>
::<math>\textbf{k}_2 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_1 \right),</math>
::<math>\textbf{k}_3 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_2 \right),</math>
::<math>\textbf{k}_4 = \textbf{f} \left( x_n + h, \textbf{y}_n + h\ \textbf{k}_3 \right),</math>
::<math>x_{n+1} = x_n + h.</math>

== Вычислительное ядро алгоритма ==

Вычислительным ядром метода Рунге-Кутты можно считать вычисление значений функции производной
:<math>\textbf{f}(x, \textbf{y})</math>,
так как при вычислении каждого нового <math>\textbf{y}_n</math> требуется 4 вычисления значения функции производной. Таким образом, сложность работы алгоритма существенно зависит от сложности вычисления функции <math>\textbf{f}</math>.

== Макроструктура алгоритма ==

Макроструктура алгоритма может быть представлена в следующем виде:
:Вычисление вспомогательных коэффициентов <math>\textbf{k}_j, j \in [1,4]</math>;
:Вычисление приближенного значения <math> \bold y_i </math> в следующей точке;
:Переход на следующую итерацию или остановка.

== Схема реализации последовательного алгоритма ==

Пример реализации последовательного алгоритма на языке C++ (указатель на функцию f передаётся через аргументы представленной ниже функции):
<source lang="c++" line="1">
#include <vector>

// other code ...

std::vector<double> rungekutta4(std::vector<double> a, std::vector<double> b, std::vector<double> y0, int n, double (*f)(double,double))
{
std::vector<double>::size_type sz = myvector.size();
std::vector<double> result;
for (unsigned i=0; i<sz; i++)
{
rezult.push_back(core(a[i],b[i],y0,n,f));
}
return result;
}

double core(double a, double b, double y0, int n, double (*f)(double,double))
{
double h, k1, k2, k3, k4, x, y;
h = (b - a)/n;
y = y0;
x = a;
for (unsigned i = 0; i < n; i++)
{
k1 = f(x, y);
k2 = f(x + h/2, y + h*k1/2);
k3 = f(x + h/2, y + h*k2/2);
k4 = f(x + h/2, y + h*k3);
x += h;
y += h*(k1 + 2*k2 + 2*k3 + k4)/6;
}
return y;
}

// other code ...
</source>

== Последовательная сложность алгоритма ==

Рассмотрим сначала одномерный случай. Наравне с обычными операциями, такими как сложение, умножение и тому подобными, в представленном выше алгоритме присутствует вызов функции <math>\bold f </math>. Так как эта функция может содержать в себе любое количество простых математических операций, будем считать, что её сложность <math>\bold f </math> много больше любой из них, и равна константе <math>C</math>. За весь алгоритм, она вызывается <math>4n</math> раза. Таким образом, сложность последовательного алгоритма для одномерного случая равна <math>4nC</math>. Для многомерного случая, когда <math>x</math> и <math>y</math> являются векторами размерности <math>m</math>, функция core будет вызвана <math>m</math>, и итоговая сложность алгоритма составит <math>4nCm</math>

== Информационный граф ==

== Ресурс параллелизма алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является итерационным алгоритмом. В нём каждый шаг цикла зависит от предыдущего. В самом шаге, каждая последующая операция также зависит от результата предыдущей. Таким образом, упразднить цикл до независимых и соответственно параллельных операций не является возможным. Однако, так как на результат функции <math> \bold f </math> влияет только <math>i</math>-ый параметр векторов <math> \bold x </math> и <math> \bold y </math>, то для каждого <math> i </math> можно производить независимое вычисление. В итоге, если вычислять результаты выполнения функции <math> \bold f </math> одновременно для вля всех <math>\bold i</math>-ых параметров векторов <math> \bold x </math> и <math> \bold y </math>, получим туже алгоритмическую сложность <math>4nC</math>, что и в пункте 1.6 для одномерного случая.

== Входные и выходные данные алгоритма ==

'''Входные данные''':
<math> a, b </math> - интервал интегрирования,
n - количество точек в разбиении,
<math> \bold y_0 </math> - вектор значений размерности m при <math> x = a </math>,
функцию вычисления производной <math>\bold f </math> будем считать встроенной в алгоритм.

'''Объём входных данных''':
m + 3

'''Выходные данные:'''
<math> \bold y_i </math> - вектора размера m значений в n узлах сетки (т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>).

'''Объем выходных данных'''
n * m

== Свойства алгоритма ==

= ЧАСТЬ. Программная реализация алгоритма =

== [[Особенности реализации последовательного алгоритма]] ==

== [[Локальность данных и вычислений]] ==

== [[Возможные способы и особенности параллельной реализации алгоритма]] ==

== Масштабируемость алгоритма и его реализации ==

== [[Динамические характеристики и эффективность реализации алгоритма]] ==

== [[Выводы для классов архитектур]] ==

== Существующие реализации алгоритма ==

= Литература =

Участник:Борис/Алгоритм Рунге-Кутты

2016-10-15T18:04:04Z

Борис: /* Схема реализации последовательного алгоритма */

{{algorithm
| name = Метод Рунге-Кутты 4 порядка
| serial_complexity = <math>O()</math>
| pf_height = <math>O()</math>
| pf_width = <math>O()</math>
| input_data = <math>m + 3</math>
| output_data = <math>m * n</math>
}}

Основные авторы описания: [[Участник:Jest|Е.П.Степанов]]([[#Общее описание алгоритма|раздел 1.1]], [[#Математическое описание алгоритма|раздел 1.2]], [[#Вычислительное ядро алгоритма|раздел 1.3]], [[#Макроструктура алгоритма|раздел 1.4]], [[#Входные и выходные данные алгоритма|раздел 1.9]]), [[Участник:Борис|Б.Савков]] ()

= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==

Ме́тоды Ру́нге — Ку́тты (распространено неправильное название Ме́тоды Ру́нге — Ку́тта или же Ме́тоды Ру́нге — Кутта́) — важное семейство численных алгоритмов решения обыкновенных дифференциальных уравнений и их систем. Данные итеративные методы явного и неявного приближённого вычисления были разработаны около 1900 года немецкими математиками К. Рунге и М. В. Куттой.

Метод Рунге - Кутты применяется при решения задачи Коши для системы обыкновенных дифференциальных уравнений первого порядка:

:<math>
\begin{cases}
\textbf{y}' = \textbf{f}(x, \textbf{y}),\\
\textbf{y}(x_0) = \textbf{y}_0.
\end{cases}
</math>

При этом <math>\textbf{y}, \textbf{f}, x</math> отвечают следующим свойствам: <math> \textbf{y}, \textbf{f} \in \mathbb{R}^m, x \in \mathbb{R}^1 </math>.

Пусть известно значение y(x) и требуется вычислить значение y(x+h). Это можно сделать при помощи формулы:

:<math> y(x + h) = y(x) + \int_0^hy'(x + t)dt</math>

Аппроксимируя интеграл в правой части, можно получить методы Рунге-Кутты разного порядка точности. В общем виде формулы методов Рунге-Кутты можно записать следующим образом:

:<math>\textbf{y}_{n+1} = \textbf{y}_n + h\sum_{i=1}^s b_i \textbf{k}_i</math>

:<math>
\begin{array}{ll}
\textbf{k}_1 =& \textbf{f}(x_n, \textbf{y}_n),\\
\textbf{k}_2 =& \textbf{f}(x_n+c_2h, \textbf{y}_n+a_{21}h\textbf{k}_1),\\
\cdots&\\
\textbf{k}_s =& \textbf{f}(x_n+c_sh, \textbf{y}_n+a_{s1}h\textbf{k}_1+a_{s2}h\textbf{k}_2+\cdots+a_{s,s-1}h\textbf{k}_{s-1})
\end{array}
</math>

Увеличивая число s вспомогательных точек, можно построить методы Рунге-Кутты любого порядка точности p. Однако уже при p > 5 эти методы используются довольно редко. Это объясняется как чрезмерной громоздкостью получающихся вычислительных формул, так и тем, что преимущества методов высокого порядка точности над методами, в которых p = 4 или p = 5, проявляются либо в тех задачах, где нужна очень высокая точность и используются ЭВМ высокой разрядности, либо в тех задачах, где решение очень гладкое. Кроме того, методы Рунге-Кутты высокого порядка точности часто оказываются менее эффективными по сравнению с методами Адамса того же порядка точности. На этой странице представлен наиболее распространенный метод Рунге-Кутты 4 порядка с ошибкой на конечном интервале интегрирования <math>O(h^4)</math>.

Существуют как явные, так и неявные методы Рунге-Кутты. Последние имеют ряд преимуществ над явными методами, однако это достигается за счет существенного усложнения вычислительного алгоритма, так как на каждом шаге приходится считать систему нелинейных уравнений. На этой странице представлен явный метод Рунге-Кутты.

Можно отметить, что в современных программах, реализующих метод Рунге-Кутты, обязательно используется некоторый алгоритм автоматического изменения шага интегрирования. Интуитивно ясно, что на участках плавного изменения решения счет можно вести с достаточно крупным шагом. В то же время на тех участках, где происходят резкие изменения поведения решения, необходимо выбирать мелкий шаг интегрирования. Обычно начальное значение шага h1 задает пользователь. Далее шаг интегрирования меняется в соответствии с величиной получаемой в ходе вычислений оценки локальной погрешности. Для упрощения описания на этой странице используется постоянный шаг интегрирования h, зависящий от размера сетки разбиения n.

== Математическое описание алгоритма ==

Далее подразумевается, что <math> \bold y, \bold y_i,\bold f, \bold k_i \in \mathbb{R}^m</math>, а <math>x, h, n, a, b \in \mathbb{R}^1 </math>.

Исходные данные:
<math> a, b </math> - интервал интегрирования,
<math> \bold y_0 </math> - вектор значений при <math> x = a </math>,
n - количество точек в разбиении
<math>\bold f </math> - функция вычисления производной

Вычисляемые данные:
<math> \bold y_i </math> - вектора значений в узлах сетки, т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>

Формулы метода:
:Вначале вычисляется шаг сетки:
::<math> h = \frac{b-a}{n}</math>.
:Приближенное значение в следующих точках вычисляется по итерационной формуле:
::<math>\textbf{y}_{n+1} = \textbf{y}_n + {h \over 6}(\textbf{k}_1 + 2\textbf{k}_2 + 2\textbf{k}_3 + \textbf{k}_4)</math>,
::<math>\textbf{k}_1 = \textbf{f} \left( x_n, \textbf{y}_n \right),</math>
::<math>\textbf{k}_2 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_1 \right),</math>
::<math>\textbf{k}_3 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_2 \right),</math>
::<math>\textbf{k}_4 = \textbf{f} \left( x_n + h, \textbf{y}_n + h\ \textbf{k}_3 \right),</math>
::<math>x_{n+1} = x_n + h.</math>

== Вычислительное ядро алгоритма ==

Вычислительным ядром метода Рунге-Кутты можно считать вычисление значений функции производной
:<math>\textbf{f}(x, \textbf{y})</math>,
так как при вычислении каждого нового <math>\textbf{y}_n</math> требуется 4 вычисления значения функции производной. Таким образом, сложность работы алгоритма существенно зависит от сложности вычисления функции <math>\textbf{f}</math>.

== Макроструктура алгоритма ==

Макроструктура алгоритма может быть представлена в следующем виде:
:Вычисление вспомогательных коэффициентов <math>\textbf{k}_j, j \in [1,4]</math>;
:Вычисление приближенного значения <math> \bold y_i </math> в следующей точке;
:Переход на следующую итерацию или остановка.

== Схема реализации последовательного алгоритма ==

Пример реализации последовательного алгоритма на языке C++ (указатель на функцию f передаётся через аргументы представленной ниже функции):
<source lang="c++" line="1">
#include <vector>

// other code ...

std::vector<double> rungekutta4(std::vector<double> a, std::vector<double> b, std::vector<double> y0, int n, double (*f)(double,double))
{
std::vector<double>::size_type sz = myvector.size();
std::vector<double> result;
for (unsigned i=0; i<sz; i++)
{
rezult.push_back(core(a[i],b[i],y0,n,f));
}
return result;
}

double core(double a, double b, double y0, int n, double (*f)(double,double))
{
double h, k1, k2, k3, k4, x, y;
h = (b - a)/n;
y = y0;
x = a;
for (unsigned i = 0; i < n; i++)
{
k1 = f(x, y);
k2 = f(x + h/2, y + h*k1/2);
k3 = f(x + h/2, y + h*k2/2);
k4 = f(x + h/2, y + h*k3);
x += h;
y += h*(k1 + 2*k2 + 2*k3 + k4)/6;
}
return y;
}

// other code ...
</source>

== Последовательная сложность алгоритма ==

Рассмотрим сначала одномерный случай. Наравне с обычными операциями, такими как сложение, умножение и тому подобными, в представленном выше алгоритме присутствует вызов функции <math>\bold f </math>. Так как эта функция может содержать в себе любое количество простых математических операций, будем считать, что её сложность <math>\bold f </math> много больше любой из них, и равна константе <math>C</math>. За весь алгоритм, она вызывается <math>4n</math> раза. Таким образом, сложность последовательного алгоритма для одномерного случая равна <math>4nC</math>. Для многомерного случая, когда <math>x</math> и <math>y</math> являются векторами размерности <math>m</math>, функция rungekutta4 будет вызвана <math>m</math>, и итоговая сложность алгоритма составит <math>4nCm</math>

== Информационный граф ==

== Ресурс параллелизма алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является итерационным алгоритмом. В нём каждый шаг цикла зависит от предыдущего. В самом шаге, каждая последующая операция также зависит от результата предыдущей. Таким образом, упразднить цикл до независимых и соответственно параллельных операций не является возможным. Однако, так как на результат функции <math> \bold f </math> влияет только <math>i</math>-ый параметр векторов <math> \bold x </math> и <math> \bold y </math>, то для каждого <math> i </math> можно производить независимое вычисление. В итоге, если вычислять результаты выполнения функции <math> \bold f </math> одновременно для вля всех <math>\bold i</math>-ых параметров векторов <math> \bold x </math> и <math> \bold y </math>, получим туже алгоритмическую сложность <math>4nC</math>, что и в пункте 1.6 для одномерного случая.

== Входные и выходные данные алгоритма ==

'''Входные данные''':
<math> a, b </math> - интервал интегрирования,
n - количество точек в разбиении,
<math> \bold y_0 </math> - вектор значений размерности m при <math> x = a </math>,
функцию вычисления производной <math>\bold f </math> будем считать встроенной в алгоритм.

'''Объём входных данных''':
m + 3

'''Выходные данные:'''
<math> \bold y_i </math> - вектора размера m значений в n узлах сетки (т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>).

'''Объем выходных данных'''
n * m

== Свойства алгоритма ==

= ЧАСТЬ. Программная реализация алгоритма =

== [[Особенности реализации последовательного алгоритма]] ==

== [[Локальность данных и вычислений]] ==

== [[Возможные способы и особенности параллельной реализации алгоритма]] ==

== Масштабируемость алгоритма и его реализации ==

== [[Динамические характеристики и эффективность реализации алгоритма]] ==

== [[Выводы для классов архитектур]] ==

== Существующие реализации алгоритма ==

= Литература =

Участник:Борис/Алгоритм Рунге-Кутты

2016-10-15T18:02:45Z

Борис: /* Схема реализации последовательного алгоритма */

{{algorithm
| name = Метод Рунге-Кутты 4 порядка
| serial_complexity = <math>O()</math>
| pf_height = <math>O()</math>
| pf_width = <math>O()</math>
| input_data = <math>m + 3</math>
| output_data = <math>m * n</math>
}}

Основные авторы описания: [[Участник:Jest|Е.П.Степанов]]([[#Общее описание алгоритма|раздел 1.1]], [[#Математическое описание алгоритма|раздел 1.2]], [[#Вычислительное ядро алгоритма|раздел 1.3]], [[#Макроструктура алгоритма|раздел 1.4]], [[#Входные и выходные данные алгоритма|раздел 1.9]]), [[Участник:Борис|Б.Савков]] ()

= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==

Ме́тоды Ру́нге — Ку́тты (распространено неправильное название Ме́тоды Ру́нге — Ку́тта или же Ме́тоды Ру́нге — Кутта́) — важное семейство численных алгоритмов решения обыкновенных дифференциальных уравнений и их систем. Данные итеративные методы явного и неявного приближённого вычисления были разработаны около 1900 года немецкими математиками К. Рунге и М. В. Куттой.

Метод Рунге - Кутты применяется при решения задачи Коши для системы обыкновенных дифференциальных уравнений первого порядка:

:<math>
\begin{cases}
\textbf{y}' = \textbf{f}(x, \textbf{y}),\\
\textbf{y}(x_0) = \textbf{y}_0.
\end{cases}
</math>

При этом <math>\textbf{y}, \textbf{f}, x</math> отвечают следующим свойствам: <math> \textbf{y}, \textbf{f} \in \mathbb{R}^m, x \in \mathbb{R}^1 </math>.

Пусть известно значение y(x) и требуется вычислить значение y(x+h). Это можно сделать при помощи формулы:

:<math> y(x + h) = y(x) + \int_0^hy'(x + t)dt</math>

Аппроксимируя интеграл в правой части, можно получить методы Рунге-Кутты разного порядка точности. В общем виде формулы методов Рунге-Кутты можно записать следующим образом:

:<math>\textbf{y}_{n+1} = \textbf{y}_n + h\sum_{i=1}^s b_i \textbf{k}_i</math>

:<math>
\begin{array}{ll}
\textbf{k}_1 =& \textbf{f}(x_n, \textbf{y}_n),\\
\textbf{k}_2 =& \textbf{f}(x_n+c_2h, \textbf{y}_n+a_{21}h\textbf{k}_1),\\
\cdots&\\
\textbf{k}_s =& \textbf{f}(x_n+c_sh, \textbf{y}_n+a_{s1}h\textbf{k}_1+a_{s2}h\textbf{k}_2+\cdots+a_{s,s-1}h\textbf{k}_{s-1})
\end{array}
</math>

Увеличивая число s вспомогательных точек, можно построить методы Рунге-Кутты любого порядка точности p. Однако уже при p > 5 эти методы используются довольно редко. Это объясняется как чрезмерной громоздкостью получающихся вычислительных формул, так и тем, что преимущества методов высокого порядка точности над методами, в которых p = 4 или p = 5, проявляются либо в тех задачах, где нужна очень высокая точность и используются ЭВМ высокой разрядности, либо в тех задачах, где решение очень гладкое. Кроме того, методы Рунге-Кутты высокого порядка точности часто оказываются менее эффективными по сравнению с методами Адамса того же порядка точности. На этой странице представлен наиболее распространенный метод Рунге-Кутты 4 порядка с ошибкой на конечном интервале интегрирования <math>O(h^4)</math>.

Существуют как явные, так и неявные методы Рунге-Кутты. Последние имеют ряд преимуществ над явными методами, однако это достигается за счет существенного усложнения вычислительного алгоритма, так как на каждом шаге приходится считать систему нелинейных уравнений. На этой странице представлен явный метод Рунге-Кутты.

Можно отметить, что в современных программах, реализующих метод Рунге-Кутты, обязательно используется некоторый алгоритм автоматического изменения шага интегрирования. Интуитивно ясно, что на участках плавного изменения решения счет можно вести с достаточно крупным шагом. В то же время на тех участках, где происходят резкие изменения поведения решения, необходимо выбирать мелкий шаг интегрирования. Обычно начальное значение шага h1 задает пользователь. Далее шаг интегрирования меняется в соответствии с величиной получаемой в ходе вычислений оценки локальной погрешности. Для упрощения описания на этой странице используется постоянный шаг интегрирования h, зависящий от размера сетки разбиения n.

== Математическое описание алгоритма ==

Далее подразумевается, что <math> \bold y, \bold y_i,\bold f, \bold k_i \in \mathbb{R}^m</math>, а <math>x, h, n, a, b \in \mathbb{R}^1 </math>.

Исходные данные:
<math> a, b </math> - интервал интегрирования,
<math> \bold y_0 </math> - вектор значений при <math> x = a </math>,
n - количество точек в разбиении
<math>\bold f </math> - функция вычисления производной

Вычисляемые данные:
<math> \bold y_i </math> - вектора значений в узлах сетки, т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>

Формулы метода:
:Вначале вычисляется шаг сетки:
::<math> h = \frac{b-a}{n}</math>.
:Приближенное значение в следующих точках вычисляется по итерационной формуле:
::<math>\textbf{y}_{n+1} = \textbf{y}_n + {h \over 6}(\textbf{k}_1 + 2\textbf{k}_2 + 2\textbf{k}_3 + \textbf{k}_4)</math>,
::<math>\textbf{k}_1 = \textbf{f} \left( x_n, \textbf{y}_n \right),</math>
::<math>\textbf{k}_2 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_1 \right),</math>
::<math>\textbf{k}_3 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_2 \right),</math>
::<math>\textbf{k}_4 = \textbf{f} \left( x_n + h, \textbf{y}_n + h\ \textbf{k}_3 \right),</math>
::<math>x_{n+1} = x_n + h.</math>

== Вычислительное ядро алгоритма ==

Вычислительным ядром метода Рунге-Кутты можно считать вычисление значений функции производной
:<math>\textbf{f}(x, \textbf{y})</math>,
так как при вычислении каждого нового <math>\textbf{y}_n</math> требуется 4 вычисления значения функции производной. Таким образом, сложность работы алгоритма существенно зависит от сложности вычисления функции <math>\textbf{f}</math>.

== Макроструктура алгоритма ==

Макроструктура алгоритма может быть представлена в следующем виде:
:Вычисление вспомогательных коэффициентов <math>\textbf{k}_j, j \in [1,4]</math>;
:Вычисление приближенного значения <math> \bold y_i </math> в следующей точке;
:Переход на следующую итерацию или остановка.

== Схема реализации последовательного алгоритма ==

Пример реализации последовательного алгоритма на языке C++ (указатель на функцию f передаётся через аргументы представленной ниже функции):
<source lang="c++" line="1">
std::vector<double> rungekutta4(std::vector<double> a, std::vector<double> b, std::vector<double> y0, int n, double (*f)(double,double))
{
std::vector<double>::size_type sz = myvector.size();
std::vector<double> result;
for (unsigned i=0; i<sz; i++)
{
rezult.push_back(core(a[i],b[i],y0,n,f));
}
return result;
}

double core(double a, double b, double y0, int n, double (*f)(double,double))
{
double h, k1, k2, k3, k4, x, y;
h = (b - a)/n;
y = y0;
x = a;
for (unsigned i = 0; i < n; i++)
{
k1 = f(x, y);
k2 = f(x + h/2, y + h*k1/2);
k3 = f(x + h/2, y + h*k2/2);
k4 = f(x + h/2, y + h*k3);
x += h;
y += h*(k1 + 2*k2 + 2*k3 + k4)/6;
}
return y;
}
</source>

== Последовательная сложность алгоритма ==

Рассмотрим сначала одномерный случай. Наравне с обычными операциями, такими как сложение, умножение и тому подобными, в представленном выше алгоритме присутствует вызов функции <math>\bold f </math>. Так как эта функция может содержать в себе любое количество простых математических операций, будем считать, что её сложность <math>\bold f </math> много больше любой из них, и равна константе <math>C</math>. За весь алгоритм, она вызывается <math>4n</math> раза. Таким образом, сложность последовательного алгоритма для одномерного случая равна <math>4nC</math>. Для многомерного случая, когда <math>x</math> и <math>y</math> являются векторами размерности <math>m</math>, функция rungekutta4 будет вызвана <math>m</math>, и итоговая сложность алгоритма составит <math>4nCm</math>

== Информационный граф ==

== Ресурс параллелизма алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является итерационным алгоритмом. В нём каждый шаг цикла зависит от предыдущего. В самом шаге, каждая последующая операция также зависит от результата предыдущей. Таким образом, упразднить цикл до независимых и соответственно параллельных операций не является возможным. Однако, так как на результат функции <math> \bold f </math> влияет только <math>i</math>-ый параметр векторов <math> \bold x </math> и <math> \bold y </math>, то для каждого <math> i </math> можно производить независимое вычисление. В итоге, если вычислять результаты выполнения функции <math> \bold f </math> одновременно для вля всех <math>\bold i</math>-ых параметров векторов <math> \bold x </math> и <math> \bold y </math>, получим туже алгоритмическую сложность <math>4nC</math>, что и в пункте 1.6 для одномерного случая.

== Входные и выходные данные алгоритма ==

'''Входные данные''':
<math> a, b </math> - интервал интегрирования,
n - количество точек в разбиении,
<math> \bold y_0 </math> - вектор значений размерности m при <math> x = a </math>,
функцию вычисления производной <math>\bold f </math> будем считать встроенной в алгоритм.

'''Объём входных данных''':
m + 3

'''Выходные данные:'''
<math> \bold y_i </math> - вектора размера m значений в n узлах сетки (т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>).

'''Объем выходных данных'''
n * m

== Свойства алгоритма ==

= ЧАСТЬ. Программная реализация алгоритма =

== [[Особенности реализации последовательного алгоритма]] ==

== [[Локальность данных и вычислений]] ==

== [[Возможные способы и особенности параллельной реализации алгоритма]] ==

== Масштабируемость алгоритма и его реализации ==

== [[Динамические характеристики и эффективность реализации алгоритма]] ==

== [[Выводы для классов архитектур]] ==

== Существующие реализации алгоритма ==

= Литература =

Участник:Борис/Алгоритм Рунге-Кутты

2016-10-15T17:49:49Z

Борис: /* Последовательная сложность алгоритма */

{{algorithm
| name = Метод Рунге-Кутты 4 порядка
| serial_complexity = <math>O()</math>
| pf_height = <math>O()</math>
| pf_width = <math>O()</math>
| input_data = <math>m + 3</math>
| output_data = <math>m * n</math>
}}

Основные авторы описания: [[Участник:Jest|Е.П.Степанов]]([[#Общее описание алгоритма|раздел 1.1]], [[#Математическое описание алгоритма|раздел 1.2]], [[#Вычислительное ядро алгоритма|раздел 1.3]], [[#Макроструктура алгоритма|раздел 1.4]], [[#Входные и выходные данные алгоритма|раздел 1.9]]), [[Участник:Борис|Б.Савков]] ()

= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==

Ме́тоды Ру́нге — Ку́тты (распространено неправильное название Ме́тоды Ру́нге — Ку́тта или же Ме́тоды Ру́нге — Кутта́) — важное семейство численных алгоритмов решения обыкновенных дифференциальных уравнений и их систем. Данные итеративные методы явного и неявного приближённого вычисления были разработаны около 1900 года немецкими математиками К. Рунге и М. В. Куттой.

Метод Рунге - Кутты применяется при решения задачи Коши для системы обыкновенных дифференциальных уравнений первого порядка:

:<math>
\begin{cases}
\textbf{y}' = \textbf{f}(x, \textbf{y}),\\
\textbf{y}(x_0) = \textbf{y}_0.
\end{cases}
</math>

При этом <math>\textbf{y}, \textbf{f}, x</math> отвечают следующим свойствам: <math> \textbf{y}, \textbf{f} \in \mathbb{R}^m, x \in \mathbb{R}^1 </math>.

Пусть известно значение y(x) и требуется вычислить значение y(x+h). Это можно сделать при помощи формулы:

:<math> y(x + h) = y(x) + \int_0^hy'(x + t)dt</math>

Аппроксимируя интеграл в правой части, можно получить методы Рунге-Кутты разного порядка точности. В общем виде формулы методов Рунге-Кутты можно записать следующим образом:

:<math>\textbf{y}_{n+1} = \textbf{y}_n + h\sum_{i=1}^s b_i \textbf{k}_i</math>

:<math>
\begin{array}{ll}
\textbf{k}_1 =& \textbf{f}(x_n, \textbf{y}_n),\\
\textbf{k}_2 =& \textbf{f}(x_n+c_2h, \textbf{y}_n+a_{21}h\textbf{k}_1),\\
\cdots&\\
\textbf{k}_s =& \textbf{f}(x_n+c_sh, \textbf{y}_n+a_{s1}h\textbf{k}_1+a_{s2}h\textbf{k}_2+\cdots+a_{s,s-1}h\textbf{k}_{s-1})
\end{array}
</math>

Увеличивая число s вспомогательных точек, можно построить методы Рунге-Кутты любого порядка точности p. Однако уже при p > 5 эти методы используются довольно редко. Это объясняется как чрезмерной громоздкостью получающихся вычислительных формул, так и тем, что преимущества методов высокого порядка точности над методами, в которых p = 4 или p = 5, проявляются либо в тех задачах, где нужна очень высокая точность и используются ЭВМ высокой разрядности, либо в тех задачах, где решение очень гладкое. Кроме того, методы Рунге-Кутты высокого порядка точности часто оказываются менее эффективными по сравнению с методами Адамса того же порядка точности. На этой странице представлен наиболее распространенный метод Рунге-Кутты 4 порядка с ошибкой на конечном интервале интегрирования <math>O(h^4)</math>.

Существуют как явные, так и неявные методы Рунге-Кутты. Последние имеют ряд преимуществ над явными методами, однако это достигается за счет существенного усложнения вычислительного алгоритма, так как на каждом шаге приходится считать систему нелинейных уравнений. На этой странице представлен явный метод Рунге-Кутты.

Можно отметить, что в современных программах, реализующих метод Рунге-Кутты, обязательно используется некоторый алгоритм автоматического изменения шага интегрирования. Интуитивно ясно, что на участках плавного изменения решения счет можно вести с достаточно крупным шагом. В то же время на тех участках, где происходят резкие изменения поведения решения, необходимо выбирать мелкий шаг интегрирования. Обычно начальное значение шага h1 задает пользователь. Далее шаг интегрирования меняется в соответствии с величиной получаемой в ходе вычислений оценки локальной погрешности. Для упрощения описания на этой странице используется постоянный шаг интегрирования h, зависящий от размера сетки разбиения n.

== Математическое описание алгоритма ==

Далее подразумевается, что <math> \bold y, \bold y_i,\bold f, \bold k_i \in \mathbb{R}^m</math>, а <math>x, h, n, a, b \in \mathbb{R}^1 </math>.

Исходные данные:
<math> a, b </math> - интервал интегрирования,
<math> \bold y_0 </math> - вектор значений при <math> x = a </math>,
n - количество точек в разбиении
<math>\bold f </math> - функция вычисления производной

Вычисляемые данные:
<math> \bold y_i </math> - вектора значений в узлах сетки, т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>

Формулы метода:
:Вначале вычисляется шаг сетки:
::<math> h = \frac{b-a}{n}</math>.
:Приближенное значение в следующих точках вычисляется по итерационной формуле:
::<math>\textbf{y}_{n+1} = \textbf{y}_n + {h \over 6}(\textbf{k}_1 + 2\textbf{k}_2 + 2\textbf{k}_3 + \textbf{k}_4)</math>,
::<math>\textbf{k}_1 = \textbf{f} \left( x_n, \textbf{y}_n \right),</math>
::<math>\textbf{k}_2 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_1 \right),</math>
::<math>\textbf{k}_3 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_2 \right),</math>
::<math>\textbf{k}_4 = \textbf{f} \left( x_n + h, \textbf{y}_n + h\ \textbf{k}_3 \right),</math>
::<math>x_{n+1} = x_n + h.</math>

== Вычислительное ядро алгоритма ==

Вычислительным ядром метода Рунге-Кутты можно считать вычисление значений функции производной
:<math>\textbf{f}(x, \textbf{y})</math>,
так как при вычислении каждого нового <math>\textbf{y}_n</math> требуется 4 вычисления значения функции производной. Таким образом, сложность работы алгоритма существенно зависит от сложности вычисления функции <math>\textbf{f}</math>.

== Макроструктура алгоритма ==

Макроструктура алгоритма может быть представлена в следующем виде:
:Вычисление вспомогательных коэффициентов <math>\textbf{k}_j, j \in [1,4]</math>;
:Вычисление приближенного значения <math> \bold y_i </math> в следующей точке;
:Переход на следующую итерацию или остановка.

== Схема реализации последовательного алгоритма ==

Пример реализации последовательного алгоритма на языке C++ (указатель на функцию f передаётся через аргументы представленной ниже функции):
<source lang="c++" line="1">
double rungekutta4(double a, double b, double y0, int n, double (*f)(double,double))
{
double h, k1, k2, k3, k4, x, y;
h = (b - a)/n;
y = y0;
x = a;
for (int i = 0; i < n; i++)
{
k1 = f(x, y);
k2 = f(x + h/2, y + h*k1/2);
k3 = f(x + h/2, y + h*k2/2);
k4 = f(x + h/2, y + h*k3);
x += h;
y += h*(k1 + 2*k2 + 2*k3 + k4)/6;
}
return y;
}
</source>

== Последовательная сложность алгоритма ==

Рассмотрим сначала одномерный случай. Наравне с обычными операциями, такими как сложение, умножение и тому подобными, в представленном выше алгоритме присутствует вызов функции <math>\bold f </math>. Так как эта функция может содержать в себе любое количество простых математических операций, будем считать, что её сложность <math>\bold f </math> много больше любой из них, и равна константе <math>C</math>. За весь алгоритм, она вызывается <math>4n</math> раза. Таким образом, сложность последовательного алгоритма для одномерного случая равна <math>4nC</math>. Для многомерного случая, когда <math>x</math> и <math>y</math> являются векторами размерности <math>m</math>, функция rungekutta4 будет вызвана <math>m</math>, и итоговая сложность алгоритма составит <math>4nCm</math>

== Информационный граф ==

== Ресурс параллелизма алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является итерационным алгоритмом. В нём каждый шаг цикла зависит от предыдущего. В самом шаге, каждая последующая операция также зависит от результата предыдущей. Таким образом, упразднить цикл до независимых и соответственно параллельных операций не является возможным. Однако, так как на результат функции <math> \bold f </math> влияет только <math>i</math>-ый параметр векторов <math> \bold x </math> и <math> \bold y </math>, то для каждого <math> i </math> можно производить независимое вычисление. В итоге, если вычислять результаты выполнения функции <math> \bold f </math> одновременно для вля всех <math>\bold i</math>-ых параметров векторов <math> \bold x </math> и <math> \bold y </math>, получим туже алгоритмическую сложность <math>4nC</math>, что и в пункте 1.6 для одномерного случая.

== Входные и выходные данные алгоритма ==

'''Входные данные''':
<math> a, b </math> - интервал интегрирования,
n - количество точек в разбиении,
<math> \bold y_0 </math> - вектор значений размерности m при <math> x = a </math>,
функцию вычисления производной <math>\bold f </math> будем считать встроенной в алгоритм.

'''Объём входных данных''':
m + 3

'''Выходные данные:'''
<math> \bold y_i </math> - вектора размера m значений в n узлах сетки (т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>).

'''Объем выходных данных'''
n * m

== Свойства алгоритма ==

= ЧАСТЬ. Программная реализация алгоритма =

== [[Особенности реализации последовательного алгоритма]] ==

== [[Локальность данных и вычислений]] ==

== [[Возможные способы и особенности параллельной реализации алгоритма]] ==

== Масштабируемость алгоритма и его реализации ==

== [[Динамические характеристики и эффективность реализации алгоритма]] ==

== [[Выводы для классов архитектур]] ==

== Существующие реализации алгоритма ==

= Литература =

Участник:Борис/Алгоритм Рунге-Кутты

2016-10-15T17:43:57Z

Борис: /* Ресурс параллелизма алгоритма */

{{algorithm
| name = Метод Рунге-Кутты 4 порядка
| serial_complexity = <math>O()</math>
| pf_height = <math>O()</math>
| pf_width = <math>O()</math>
| input_data = <math>m + 3</math>
| output_data = <math>m * n</math>
}}

Основные авторы описания: [[Участник:Jest|Е.П.Степанов]]([[#Общее описание алгоритма|раздел 1.1]], [[#Математическое описание алгоритма|раздел 1.2]], [[#Вычислительное ядро алгоритма|раздел 1.3]], [[#Макроструктура алгоритма|раздел 1.4]], [[#Входные и выходные данные алгоритма|раздел 1.9]]), [[Участник:Борис|Б.Савков]] ()

= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==

Ме́тоды Ру́нге — Ку́тты (распространено неправильное название Ме́тоды Ру́нге — Ку́тта или же Ме́тоды Ру́нге — Кутта́) — важное семейство численных алгоритмов решения обыкновенных дифференциальных уравнений и их систем. Данные итеративные методы явного и неявного приближённого вычисления были разработаны около 1900 года немецкими математиками К. Рунге и М. В. Куттой.

Метод Рунге - Кутты применяется при решения задачи Коши для системы обыкновенных дифференциальных уравнений первого порядка:

:<math>
\begin{cases}
\textbf{y}' = \textbf{f}(x, \textbf{y}),\\
\textbf{y}(x_0) = \textbf{y}_0.
\end{cases}
</math>

При этом <math>\textbf{y}, \textbf{f}, x</math> отвечают следующим свойствам: <math> \textbf{y}, \textbf{f} \in \mathbb{R}^m, x \in \mathbb{R}^1 </math>.

Пусть известно значение y(x) и требуется вычислить значение y(x+h). Это можно сделать при помощи формулы:

:<math> y(x + h) = y(x) + \int_0^hy'(x + t)dt</math>

Аппроксимируя интеграл в правой части, можно получить методы Рунге-Кутты разного порядка точности. В общем виде формулы методов Рунге-Кутты можно записать следующим образом:

:<math>\textbf{y}_{n+1} = \textbf{y}_n + h\sum_{i=1}^s b_i \textbf{k}_i</math>

:<math>
\begin{array}{ll}
\textbf{k}_1 =& \textbf{f}(x_n, \textbf{y}_n),\\
\textbf{k}_2 =& \textbf{f}(x_n+c_2h, \textbf{y}_n+a_{21}h\textbf{k}_1),\\
\cdots&\\
\textbf{k}_s =& \textbf{f}(x_n+c_sh, \textbf{y}_n+a_{s1}h\textbf{k}_1+a_{s2}h\textbf{k}_2+\cdots+a_{s,s-1}h\textbf{k}_{s-1})
\end{array}
</math>

Увеличивая число s вспомогательных точек, можно построить методы Рунге-Кутты любого порядка точности p. Однако уже при p > 5 эти методы используются довольно редко. Это объясняется как чрезмерной громоздкостью получающихся вычислительных формул, так и тем, что преимущества методов высокого порядка точности над методами, в которых p = 4 или p = 5, проявляются либо в тех задачах, где нужна очень высокая точность и используются ЭВМ высокой разрядности, либо в тех задачах, где решение очень гладкое. Кроме того, методы Рунге-Кутты высокого порядка точности часто оказываются менее эффективными по сравнению с методами Адамса того же порядка точности. На этой странице представлен наиболее распространенный метод Рунге-Кутты 4 порядка с ошибкой на конечном интервале интегрирования <math>O(h^4)</math>.

Существуют как явные, так и неявные методы Рунге-Кутты. Последние имеют ряд преимуществ над явными методами, однако это достигается за счет существенного усложнения вычислительного алгоритма, так как на каждом шаге приходится считать систему нелинейных уравнений. На этой странице представлен явный метод Рунге-Кутты.

Можно отметить, что в современных программах, реализующих метод Рунге-Кутты, обязательно используется некоторый алгоритм автоматического изменения шага интегрирования. Интуитивно ясно, что на участках плавного изменения решения счет можно вести с достаточно крупным шагом. В то же время на тех участках, где происходят резкие изменения поведения решения, необходимо выбирать мелкий шаг интегрирования. Обычно начальное значение шага h1 задает пользователь. Далее шаг интегрирования меняется в соответствии с величиной получаемой в ходе вычислений оценки локальной погрешности. Для упрощения описания на этой странице используется постоянный шаг интегрирования h, зависящий от размера сетки разбиения n.

== Математическое описание алгоритма ==

Далее подразумевается, что <math> \bold y, \bold y_i,\bold f, \bold k_i \in \mathbb{R}^m</math>, а <math>x, h, n, a, b \in \mathbb{R}^1 </math>.

Исходные данные:
<math> a, b </math> - интервал интегрирования,
<math> \bold y_0 </math> - вектор значений при <math> x = a </math>,
n - количество точек в разбиении
<math>\bold f </math> - функция вычисления производной

Вычисляемые данные:
<math> \bold y_i </math> - вектора значений в узлах сетки, т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>

Формулы метода:
:Вначале вычисляется шаг сетки:
::<math> h = \frac{b-a}{n}</math>.
:Приближенное значение в следующих точках вычисляется по итерационной формуле:
::<math>\textbf{y}_{n+1} = \textbf{y}_n + {h \over 6}(\textbf{k}_1 + 2\textbf{k}_2 + 2\textbf{k}_3 + \textbf{k}_4)</math>,
::<math>\textbf{k}_1 = \textbf{f} \left( x_n, \textbf{y}_n \right),</math>
::<math>\textbf{k}_2 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_1 \right),</math>
::<math>\textbf{k}_3 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_2 \right),</math>
::<math>\textbf{k}_4 = \textbf{f} \left( x_n + h, \textbf{y}_n + h\ \textbf{k}_3 \right),</math>
::<math>x_{n+1} = x_n + h.</math>

== Вычислительное ядро алгоритма ==

Вычислительным ядром метода Рунге-Кутты можно считать вычисление значений функции производной
:<math>\textbf{f}(x, \textbf{y})</math>,
так как при вычислении каждого нового <math>\textbf{y}_n</math> требуется 4 вычисления значения функции производной. Таким образом, сложность работы алгоритма существенно зависит от сложности вычисления функции <math>\textbf{f}</math>.

== Макроструктура алгоритма ==

Макроструктура алгоритма может быть представлена в следующем виде:
:Вычисление вспомогательных коэффициентов <math>\textbf{k}_j, j \in [1,4]</math>;
:Вычисление приближенного значения <math> \bold y_i </math> в следующей точке;
:Переход на следующую итерацию или остановка.

== Схема реализации последовательного алгоритма ==

Пример реализации последовательного алгоритма на языке C++ (указатель на функцию f передаётся через аргументы представленной ниже функции):
<source lang="c++" line="1">
double rungekutta4(double a, double b, double y0, int n, double (*f)(double,double))
{
double h, k1, k2, k3, k4, x, y;
h = (b - a)/n;
y = y0;
x = a;
for (int i = 0; i < n; i++)
{
k1 = f(x, y);
k2 = f(x + h/2, y + h*k1/2);
k3 = f(x + h/2, y + h*k2/2);
k4 = f(x + h/2, y + h*k3);
x += h;
y += h*(k1 + 2*k2 + 2*k3 + k4)/6;
}
return y;
}
</source>

== Последовательная сложность алгоритма ==

Наравне с обычными операциями, такими как сложение, умножение и тому подобными, в представленном выше алгоритме присутствует вызов функции <math>\bold f </math>. Так как эта функция может содержать в себе любое количество простых математических операций, будем считать, что её сложность <math>\bold f </math> много больше любой из них, и равна константе <math>C</math>. За весь алгоритм, она вызывается <math>4n</math> раза. Таким образом, сложность последовательного алгоритма равна <math>4nC</math>.

== Информационный граф ==

== Ресурс параллелизма алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является итерационным алгоритмом. В нём каждый шаг цикла зависит от предыдущего. В самом шаге, каждая последующая операция также зависит от результата предыдущей. Таким образом, упразднить цикл до независимых и соответственно параллельных операций не является возможным. Однако, так как на результат функции <math> \bold f </math> влияет только <math>i</math>-ый параметр векторов <math> \bold x </math> и <math> \bold y </math>, то для каждого <math> i </math> можно производить независимое вычисление. В итоге, если вычислять результаты выполнения функции <math> \bold f </math> одновременно для вля всех <math>\bold i</math>-ых параметров векторов <math> \bold x </math> и <math> \bold y </math>, получим туже алгоритмическую сложность <math>4nC</math>, что и в пункте 1.6 для одномерного случая.

== Входные и выходные данные алгоритма ==

'''Входные данные''':
<math> a, b </math> - интервал интегрирования,
n - количество точек в разбиении,
<math> \bold y_0 </math> - вектор значений размерности m при <math> x = a </math>,
функцию вычисления производной <math>\bold f </math> будем считать встроенной в алгоритм.

'''Объём входных данных''':
m + 3

'''Выходные данные:'''
<math> \bold y_i </math> - вектора размера m значений в n узлах сетки (т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>).

'''Объем выходных данных'''
n * m

== Свойства алгоритма ==

= ЧАСТЬ. Программная реализация алгоритма =

== [[Особенности реализации последовательного алгоритма]] ==

== [[Локальность данных и вычислений]] ==

== [[Возможные способы и особенности параллельной реализации алгоритма]] ==

== Масштабируемость алгоритма и его реализации ==

== [[Динамические характеристики и эффективность реализации алгоритма]] ==

== [[Выводы для классов архитектур]] ==

== Существующие реализации алгоритма ==

= Литература =

Участник:Борис/Алгоритм Рунге-Кутты

2016-10-15T17:43:27Z

Борис: /* Ресурс параллелизма алгоритма */

{{algorithm
| name = Метод Рунге-Кутты 4 порядка
| serial_complexity = <math>O()</math>
| pf_height = <math>O()</math>
| pf_width = <math>O()</math>
| input_data = <math>m + 3</math>
| output_data = <math>m * n</math>
}}

Основные авторы описания: [[Участник:Jest|Е.П.Степанов]]([[#Общее описание алгоритма|раздел 1.1]], [[#Математическое описание алгоритма|раздел 1.2]], [[#Вычислительное ядро алгоритма|раздел 1.3]], [[#Макроструктура алгоритма|раздел 1.4]], [[#Входные и выходные данные алгоритма|раздел 1.9]]), [[Участник:Борис|Б.Савков]] ()

= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==

Ме́тоды Ру́нге — Ку́тты (распространено неправильное название Ме́тоды Ру́нге — Ку́тта или же Ме́тоды Ру́нге — Кутта́) — важное семейство численных алгоритмов решения обыкновенных дифференциальных уравнений и их систем. Данные итеративные методы явного и неявного приближённого вычисления были разработаны около 1900 года немецкими математиками К. Рунге и М. В. Куттой.

Метод Рунге - Кутты применяется при решения задачи Коши для системы обыкновенных дифференциальных уравнений первого порядка:

:<math>
\begin{cases}
\textbf{y}' = \textbf{f}(x, \textbf{y}),\\
\textbf{y}(x_0) = \textbf{y}_0.
\end{cases}
</math>

При этом <math>\textbf{y}, \textbf{f}, x</math> отвечают следующим свойствам: <math> \textbf{y}, \textbf{f} \in \mathbb{R}^m, x \in \mathbb{R}^1 </math>.

Пусть известно значение y(x) и требуется вычислить значение y(x+h). Это можно сделать при помощи формулы:

:<math> y(x + h) = y(x) + \int_0^hy'(x + t)dt</math>

Аппроксимируя интеграл в правой части, можно получить методы Рунге-Кутты разного порядка точности. В общем виде формулы методов Рунге-Кутты можно записать следующим образом:

:<math>\textbf{y}_{n+1} = \textbf{y}_n + h\sum_{i=1}^s b_i \textbf{k}_i</math>

:<math>
\begin{array}{ll}
\textbf{k}_1 =& \textbf{f}(x_n, \textbf{y}_n),\\
\textbf{k}_2 =& \textbf{f}(x_n+c_2h, \textbf{y}_n+a_{21}h\textbf{k}_1),\\
\cdots&\\
\textbf{k}_s =& \textbf{f}(x_n+c_sh, \textbf{y}_n+a_{s1}h\textbf{k}_1+a_{s2}h\textbf{k}_2+\cdots+a_{s,s-1}h\textbf{k}_{s-1})
\end{array}
</math>

Увеличивая число s вспомогательных точек, можно построить методы Рунге-Кутты любого порядка точности p. Однако уже при p > 5 эти методы используются довольно редко. Это объясняется как чрезмерной громоздкостью получающихся вычислительных формул, так и тем, что преимущества методов высокого порядка точности над методами, в которых p = 4 или p = 5, проявляются либо в тех задачах, где нужна очень высокая точность и используются ЭВМ высокой разрядности, либо в тех задачах, где решение очень гладкое. Кроме того, методы Рунге-Кутты высокого порядка точности часто оказываются менее эффективными по сравнению с методами Адамса того же порядка точности. На этой странице представлен наиболее распространенный метод Рунге-Кутты 4 порядка с ошибкой на конечном интервале интегрирования <math>O(h^4)</math>.

Существуют как явные, так и неявные методы Рунге-Кутты. Последние имеют ряд преимуществ над явными методами, однако это достигается за счет существенного усложнения вычислительного алгоритма, так как на каждом шаге приходится считать систему нелинейных уравнений. На этой странице представлен явный метод Рунге-Кутты.

Можно отметить, что в современных программах, реализующих метод Рунге-Кутты, обязательно используется некоторый алгоритм автоматического изменения шага интегрирования. Интуитивно ясно, что на участках плавного изменения решения счет можно вести с достаточно крупным шагом. В то же время на тех участках, где происходят резкие изменения поведения решения, необходимо выбирать мелкий шаг интегрирования. Обычно начальное значение шага h1 задает пользователь. Далее шаг интегрирования меняется в соответствии с величиной получаемой в ходе вычислений оценки локальной погрешности. Для упрощения описания на этой странице используется постоянный шаг интегрирования h, зависящий от размера сетки разбиения n.

== Математическое описание алгоритма ==

Далее подразумевается, что <math> \bold y, \bold y_i,\bold f, \bold k_i \in \mathbb{R}^m</math>, а <math>x, h, n, a, b \in \mathbb{R}^1 </math>.

Исходные данные:
<math> a, b </math> - интервал интегрирования,
<math> \bold y_0 </math> - вектор значений при <math> x = a </math>,
n - количество точек в разбиении
<math>\bold f </math> - функция вычисления производной

Вычисляемые данные:
<math> \bold y_i </math> - вектора значений в узлах сетки, т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>

Формулы метода:
:Вначале вычисляется шаг сетки:
::<math> h = \frac{b-a}{n}</math>.
:Приближенное значение в следующих точках вычисляется по итерационной формуле:
::<math>\textbf{y}_{n+1} = \textbf{y}_n + {h \over 6}(\textbf{k}_1 + 2\textbf{k}_2 + 2\textbf{k}_3 + \textbf{k}_4)</math>,
::<math>\textbf{k}_1 = \textbf{f} \left( x_n, \textbf{y}_n \right),</math>
::<math>\textbf{k}_2 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_1 \right),</math>
::<math>\textbf{k}_3 = \textbf{f} \left( x_n + {h \over 2}, \textbf{y}_n + {h \over 2} \textbf{k}_2 \right),</math>
::<math>\textbf{k}_4 = \textbf{f} \left( x_n + h, \textbf{y}_n + h\ \textbf{k}_3 \right),</math>
::<math>x_{n+1} = x_n + h.</math>

== Вычислительное ядро алгоритма ==

Вычислительным ядром метода Рунге-Кутты можно считать вычисление значений функции производной
:<math>\textbf{f}(x, \textbf{y})</math>,
так как при вычислении каждого нового <math>\textbf{y}_n</math> требуется 4 вычисления значения функции производной. Таким образом, сложность работы алгоритма существенно зависит от сложности вычисления функции <math>\textbf{f}</math>.

== Макроструктура алгоритма ==

Макроструктура алгоритма может быть представлена в следующем виде:
:Вычисление вспомогательных коэффициентов <math>\textbf{k}_j, j \in [1,4]</math>;
:Вычисление приближенного значения <math> \bold y_i </math> в следующей точке;
:Переход на следующую итерацию или остановка.

== Схема реализации последовательного алгоритма ==

Пример реализации последовательного алгоритма на языке C++ (указатель на функцию f передаётся через аргументы представленной ниже функции):
<source lang="c++" line="1">
double rungekutta4(double a, double b, double y0, int n, double (*f)(double,double))
{
double h, k1, k2, k3, k4, x, y;
h = (b - a)/n;
y = y0;
x = a;
for (int i = 0; i < n; i++)
{
k1 = f(x, y);
k2 = f(x + h/2, y + h*k1/2);
k3 = f(x + h/2, y + h*k2/2);
k4 = f(x + h/2, y + h*k3);
x += h;
y += h*(k1 + 2*k2 + 2*k3 + k4)/6;
}
return y;
}
</source>

== Последовательная сложность алгоритма ==

Наравне с обычными операциями, такими как сложение, умножение и тому подобными, в представленном выше алгоритме присутствует вызов функции <math>\bold f </math>. Так как эта функция может содержать в себе любое количество простых математических операций, будем считать, что её сложность <math>\bold f </math> много больше любой из них, и равна константе <math>C</math>. За весь алгоритм, она вызывается <math>4n</math> раза. Таким образом, сложность последовательного алгоритма равна <math>4nC</math>.

== Информационный граф ==

== Ресурс параллелизма алгоритма ==

Алгоритм Рунге-Кутты 4-го порядка является итерационным алгоритмом. В нём каждый шаг цикла зависит от предыдущего. В самом шаге, каждая последующая операция также зависит от результата предыдущей. Таким образом, упразднить цикл до независимых и соответственно параллельных операций не является возможным. Однако, так как на результат функции <math> \bold f </math> влияет только <math>i</math>-ый параметр векторов <math> \bold x </math> и <math> \bold y </math>, то для каждого <math> i </math> можно производить независимое вычисление. В итоге, если вычислять результаты выполнения функции <math> \bold f </math> одновременно для вля всех <math>\bold i</math>-ых параметров векторов <math> \bold x </math> и <math> \bold y </math>, получим туже алгоритмическую сложность <math> 4nС </math>, что и в пункте 1.6 для одномерного случая.

== Входные и выходные данные алгоритма ==

'''Входные данные''':
<math> a, b </math> - интервал интегрирования,
n - количество точек в разбиении,
<math> \bold y_0 </math> - вектор значений размерности m при <math> x = a </math>,
функцию вычисления производной <math>\bold f </math> будем считать встроенной в алгоритм.

'''Объём входных данных''':
m + 3

'''Выходные данные:'''
<math> \bold y_i </math> - вектора размера m значений в n узлах сетки (т.е. при <math> x = a + i * \frac{b-a}{n}, i \in [1, n] </math>).

'''Объем выходных данных'''
n * m

== Свойства алгоритма ==

= ЧАСТЬ. Программная реализация алгоритма =

== [[Особенности реализации последовательного алгоритма]] ==

== [[Локальность данных и вычислений]] ==

== [[Возможные способы и особенности параллельной реализации алгоритма]] ==

== Масштабируемость алгоритма и его реализации ==

== [[Динамические характеристики и эффективность реализации алгоритма]] ==

== [[Выводы для классов архитектур]] ==

== Существующие реализации алгоритма ==

= Литература =

Участник:Борис/Алгоритм Рунге-Кутты

2016-10-15T15:47:01Z

Борис:

Участник:Борис/Алгоритм Рунге-Кутты

2016-10-13T14:37:56Z

Борис: Добавлены разделы

= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==

Ме́тоды Ру́нге — Ку́тты (распространено неправильное название Ме́тоды Ру́нге — Ку́тта или же Ме́тоды Ру́нге — Кутта́) — важное семейство численных алгоритмов решения обыкновенных дифференциальных уравнений и их систем. Данные итеративные методы явного и неявного приближённого вычисления были разработаны около 1900 года немецкими математиками К. Рунге и М. В. Куттой.

Метод Рунге - Кутты применяется при решения задачи Коши для системы обыкновенных дифференциальных уравнений первого порядка:

<math>
\begin{cases}
\textbf{y}' = \textbf{f}(x, \textbf{y}),\\
\textbf{y}(x_0) = \textbf{y}_0.
\end{cases}
</math>

При этом <math>\textbf{y}, \textbf{f}, x</math> отвечают следующим свойствам: <math> \textbf{y}, \textbf{f} \in \mathbb{R}^n, x \in \mathbb{R} </math>.

<math>\textbf{y}_{n+1} = \textbf{y}_n + h\sum_{i=1}^s b_i \textbf{k}_i</math>

<math>
\begin{array}{ll}
\textbf{k}_1 =& \textbf{f}(x_n, \textbf{y}_n),\\
\textbf{k}_2 =& \textbf{f}(x_n+c_2h, \textbf{y}_n+a_{21}h\textbf{k}_1),\\
\cdots&\\
\textbf{k}_s =& \textbf{f}(x_n+c_sh, \textbf{y}_n+a_{s1}h\textbf{k}_1+a_{s2}h\textbf{k}_2+\cdots+a_{s,s-1}h\textbf{k}_{s-1})
\end{array}
</math>

== Математическое описание алгоритма ==

== Вычислительное ядро алгоритма ==

== Макроструктура алгоритма ==

== Схема реализации последовательного алгоритма ==

== Последовательная сложность алгоритма ==

== Информационный граф ==

== Ресурс параллелизма алгоритма ==

== Входные и выходные данные алгоритма ==

== Свойства алгоритма ==

= ЧАСТЬ. Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==

== [[Локальность данных и вычислений]] ==

== Возможные способы и особенности параллельной реализации алгоритма ==

== Масштабируемость алгоритма и его реализации ==

== Динамические характеристики и эффективность реализации алгоритма ==

== Выводы для классов архитектур ==

== Существующие реализации алгоритма ==

= Литература =

Участник:Борис/Алгоритм Рунге-Кутты

2016-10-13T14:20:52Z

Борис: Начало первого раздела

Ме́тоды Ру́нге — Ку́тты (распространено неправильное название Ме́тоды Ру́нге — Ку́тта или же Ме́тоды Ру́нге — Кутта́) — важное семейство численных алгоритмов решения обыкновенных дифференциальных уравнений и их систем. Данные итеративные методы явного и неявного приближённого вычисления были разработаны около 1900 года немецкими математиками К. Рунге и М. В. Куттой.

Метод Рунге - Кутты применяется при решения задачи Коши для системы обыкновенных дифференциальных уравнений первого порядка:

<math>
\begin{cases}
\textbf{y}' = \textbf{f}(x, \textbf{y}),\\
\textbf{y}(x_0) = \textbf{y}_0.
\end{cases}
</math>

При этом <math>\textbf{y}, \textbf{f}, x</math> отвечают следующим свойствам: <math> \textbf{y}, \textbf{f} \in \mathbb{R}^n, x \in \mathbb{R} </math>.

<math>\textbf{y}_{n+1} = \textbf{y}_n + h\sum_{i=1}^s b_i \textbf{k}_i</math>

<math>
\begin{array}{ll}
\textbf{k}_1 =& \textbf{f}(x_n, \textbf{y}_n),\\
\textbf{k}_2 =& \textbf{f}(x_n+c_2h, \textbf{y}_n+a_{21}h\textbf{k}_1),\\
\cdots&\\
\textbf{k}_s =& \textbf{f}(x_n+c_sh, \textbf{y}_n+a_{s1}h\textbf{k}_1+a_{s2}h\textbf{k}_2+\cdots+a_{s,s-1}h\textbf{k}_{s-1})
\end{array}
</math>