511 lines
29 KiB
TeX
511 lines
29 KiB
TeX
\input{vars}
|
||
\input{config}
|
||
|
||
\begin{document}
|
||
\lstset{language=[11]C++}
|
||
|
||
%title-page
|
||
\include{titlepage}
|
||
\thispagestyle{empty}
|
||
\clearpage
|
||
|
||
\tableofcontents
|
||
\thispagestyle{empty}
|
||
\clearpage
|
||
\input{intro}
|
||
|
||
\chapter{Описание численных методов и возможностей библиотек numpy и scipy}
|
||
В данном разделе будут описаны численные методы и их доступные
|
||
реализации в библиотеках в частях, посвященным классам задач, которые
|
||
они решают.
|
||
|
||
Стоит учитывать, что scipy основан на numpy, поэтому при рассмотрении
|
||
возможностей данных библиотек часто может возникнуть ситуация,
|
||
когда искомый функционал содержится только в scipy, либо в numpy
|
||
или scipy одновременно.
|
||
|
||
\section{Численное решение нелинейных уравнений}
|
||
При решении некоторых практических задач или проведении исследований
|
||
может быть получена математическая модель, которая включает
|
||
непрерывную функцию \(F(x), x \in \textbf{R}\), и необходимо определить корни уравнения
|
||
\(F(x) = 0\). Если данное уравнение не имеет вид \(ax + b = 0\),
|
||
где \(a,b\) -- константы, то оно будет нелинейным.
|
||
|
||
Для решения нелинейных уравнений существует несколько методов, в данной работе будут рассмотрены итерационные.
|
||
|
||
Каждый из итерационных методов, перечисленных ниже, соответствует
|
||
следующему алгоритму из двух этапов \cite[с. 15]{book:nm-examples}.
|
||
\begin{enumerate}
|
||
\item Отыскание приближенного значения корня или содержащего
|
||
его отрезка.
|
||
\item Уточнения значения до некоторой степени точности.
|
||
\end{enumerate}
|
||
Начальное приближение определяется, исходя из физических соображений
|
||
решений похожих задач или графических методов. Если ни один из этих
|
||
способов не доступен или не позволяет получить начальное приближение,
|
||
удовлетворяющее требованиям, то применяют следующий алгоритм
|
||
отыскания начального приближения:
|
||
\begin{enumerate}
|
||
\item Производится поиск двух близкорасположенных значений
|
||
\(a\) и \(b\) таких, что \(F(a) \cdot F(b) < 0\), при этом
|
||
\(F(x)\) должна быть всюду определена на отрезке \([a;b]\).
|
||
\item В качестве начального приближения первой итерации принимается
|
||
значение \(x_0 \in [a;b]\), обычно это середина данного
|
||
отрезка.
|
||
\end{enumerate}
|
||
|
||
Так как выполняется условие \(F(a) \cdot F(b) < 0\) и \(F(x)\)
|
||
непрерывна, то обязательно найдется такое \(x_k \in (a,b)\), что
|
||
\(F(x_k) = 0\) либо \(|F(x_k)| < \varepsilon\), где \(\varepsilon\)
|
||
--- погрешность искомого решения.
|
||
|
||
\subsection{Метод деления отрезка пополам}
|
||
Данный метод использует технику поиска решения, похожую на бинарный
|
||
поиск.
|
||
|
||
\subsubsection{Описание метода}
|
||
Дано начальное приближение \(x_0 = (a+b)/2\) при
|
||
\(F(a) \cdot F(b) < 0\). Для поиска решения уравнения \(x_k\)
|
||
применяем следующий алгоритм:
|
||
\begin{enumerate}
|
||
\item Рассмотрим отрезки \([a;x_i], [x_i;b]\), \(i = 0 \dots k\)
|
||
--- номер итерации. На первой итерации \(i = 0\).
|
||
\label{list:hls_begin}
|
||
\item Из рассмотренных отрезков берем те, что удовлетворяют условию
|
||
\(F(a) \cdot F(b) < 0\), где \(a,b\) --- границы отрезка.
|
||
\label{list:hls_test}
|
||
\item Для каждого из взятых в п.\ref{list:hls_test} отрезков
|
||
вычисляем их длину \(l\). Если \(l < \varepsilon\),
|
||
тогда дальнейшее выполнение данного алгоритма для данного
|
||
отрезка прекращается. За решение уравнения принимается
|
||
число \((a+b)/2\), округленное с учетом заданной погрешности.
|
||
Если для решения задачи достаточно любого одного решения,
|
||
то работа алгоритма прекращается.
|
||
\item Для каждого из взятых в п.\ref{list:hls_test} отрезков
|
||
устанавливаем значения
|
||
\(a,b,x_{i+1}\). Для левого отрезка эти значения будут равны
|
||
\(a = a,b = x_i,x_{i+1} = (a+x_i)/2\), для правого ---
|
||
\(a = x_i,b = b,x_{i+1} = (b+x_i)/2\).
|
||
\label{list:hls_prepare}
|
||
\item Для каждого из взятых отрезков переходим к
|
||
п.\ref{list:hls_begin}, с увеличением номера итерации
|
||
на \(1\) и установленными относительно взятого
|
||
отрезка значениями из п.\ref{list:hls_prepare}.
|
||
\end{enumerate}
|
||
|
||
После применение метода на заданных входных данных получим множество
|
||
решений уравнения \(Ans = \{x, x \in \textbf{R}\}, |Ans| \geq 1\).
|
||
|
||
\subsubsection{Реализации метода в библиотеках numpy, scipy}
|
||
Библиотека scipy содержит функцию \textbf{bisect} из модуля
|
||
\textbf{scipy.optimize} \cite{links:scipy_doc}, которая реализует
|
||
данный метод.
|
||
|
||
Функция имеет следующие параметры (задаются в порядке перечисления):
|
||
\begin{enumerate}
|
||
\item \(f\) --- function
|
||
|
||
Функция Python, возвращающая число.\(f\) должна быть
|
||
непрерывной, а \(f(a)\) и \(f(b)\) должны иметь
|
||
противоположные знаки.
|
||
\item \(a\) --- scalar
|
||
|
||
Первый конец интервала \([a,b]\).
|
||
\item \(b\) --- scalar
|
||
|
||
Второй конец интервала \([a,b]\).
|
||
\item \(xtol\) --- number, необязательный
|
||
|
||
Вычисленный корень \(x0\) будет удовлетворять
|
||
\verb|np.allclose(x, x0,| \verb|atol=xtol,|
|
||
\verb|rtol=rtol)|, где \(x\) --- точный корень.
|
||
Параметр должен быть положительным.
|
||
\item \(rtol\) --- number, необязательный
|
||
|
||
Вычисленный корень \(x0\) будет удовлетворять
|
||
\verb|np.allclose(x, x0,| \verb|atol=xtol, rtol=rtol)|,
|
||
где \(x\) --- точный корень. Параметр не может быть
|
||
меньше значения по умолчанию \verb|4*np.finfo(float).eps|.
|
||
\item \(maxiter\) --- int, необязательный
|
||
|
||
Если сходимость не достигается в итерациях \(maxiter\),
|
||
возникает ошибка. Должен быть \(\geq 0\).
|
||
\item \(args\) --- tuple, необязательный
|
||
|
||
Содержит дополнительные аргументы для функции \(f\).
|
||
\(f\) вызывается с помощью \verb|apply(f, (x)+args)|.
|
||
\item \(full\_output\) --- bool, необязательный
|
||
|
||
Если \(full\_output\) имеет значение \verb|False|,
|
||
возвращается корень. Если \(full\_output\) имеет значение
|
||
\verb|True|, возвращаемое значение равно \verb|(x, r)|, где
|
||
\(x\) --- это корень, а \(r\) --- объект \verb|RootResults|.
|
||
\item \(disp\) --- bool, необязательный
|
||
|
||
Если \verb|True|, будет сгенерировано исключение
|
||
\verb|RuntimeError|, если алгоритм не сошелся. В противном
|
||
случае статус сходимости записывается в возвращаемый объект
|
||
\verb|RootResults|.
|
||
\end{enumerate}
|
||
|
||
\subsection{Метод Ньютона (метод касательных)}
|
||
Данный итерационный метод позволит найти единственное решение
|
||
уравнения (если оно существует) для каждого из выбранных начальных
|
||
приближений.
|
||
\subsubsection{Описание метода}
|
||
На итерации \(i, i = 1\dots k\), строится касательная к кривой
|
||
\(y = F(x)\) в точке \((x_i;F(x_i))\), затем находится \(x_{i+1}\)
|
||
--- пересечение данной касательной с осью \(Ox\). Процесс продолжается
|
||
пока не будет достигнута заданная точность (\(| F ( x_i ) |< \varepsilon\)
|
||
или \(| x_{i+1} - x_i | < \varepsilon\)).
|
||
|
||
\subsubsection{Реализации метода в библиотеках numpy, scipy}
|
||
Библиотека scipy содержит функцию \textbf{newton} из модуля
|
||
\textbf{scipy.optimize} \cite{links:scipy_doc}, которая реализует
|
||
данный метод.
|
||
|
||
Функция имеет следующие параметры (задаются в порядке перечисления):
|
||
\begin{enumerate}
|
||
\item \(f\) --- function
|
||
|
||
Функция, корень которой требуется. Это должна быть функция
|
||
одной переменной вида \(f(x,a,b,c \dots)\), где \(a,b,c \dots\)
|
||
--- дополнительные аргументы, которые можно передать в параметре
|
||
\(args\).
|
||
\item \(x0\) --- float, sequence, или ndarray
|
||
|
||
Начальная оценка корня, которая должна быть где-то рядом с
|
||
фактическим корнем. Если \(f\) не скалярная, то \(f\) должна
|
||
быть векторизована и возвращать последовательность или массив
|
||
той же формы, что и ее первый аргумент.
|
||
\item \(fprime\) --- callable, необязательный
|
||
|
||
Производная функции, когда она доступна и удобна. Если это
|
||
\verb|None| (по умолчанию), то используется метод секущей.
|
||
\item \(args\) --- tuple, необязательный
|
||
|
||
Дополнительные аргументы для использования при вызове функции.
|
||
\item \(tol\) --- float, необязательный
|
||
|
||
Допустимая погрешность значения корня. Если
|
||
\(y=f(x),y \in \textbf{Z}\), рекомендуется большее значение
|
||
\(tol\), так как и действительная, и мнимая части \(x\)
|
||
вносят вклад в \(|x - x0|\).
|
||
\item \(maxiter\) --- int, необязательный
|
||
|
||
Максимальное количество итераций.
|
||
\item \(fprime2\) --- callable, необязательный
|
||
|
||
Производная функции второго порядка, если она доступна и удобна.
|
||
Если это \verb|None| (по умолчанию), то используется обычный
|
||
метод Ньютона или метод секущих. Если не \verb|None|, то
|
||
используется метод Галлея.
|
||
\item \(x1\) float, необязательный
|
||
|
||
Еще одна оценка корня, которая должна быть где-то рядом с фактическим корнем. Используется, если \(fprime\) не указан.
|
||
\item \(rtol\) --- float, необязательный
|
||
|
||
Допустимое отклонение (относительное) для прерывания работы.
|
||
\item \(full\_output\) --- bool, необязательный
|
||
|
||
Если \(full\_output\) имеет значение \verb|False| (по умолчанию),
|
||
возвращается корень. Если \verb|True| и \(x0\) --- скаляр,
|
||
возвращаемое значение равно \verb|(x, r)|, где \(x\) --- это
|
||
корень, а \(r\) --- объект \verb|RootResults|. Если \verb|True|
|
||
и \(x0\) --- не скаляр, возвращаемое значение равно
|
||
\verb|(x, converged, zero_der)|, где:
|
||
\begin{itemize}
|
||
\item converged --- ndarray из значений bool. Указывает, какие элементы сошлись успешно.
|
||
\item zero\_der --- ndarray из значений bool. Указывает, какие элементы имеют нулевую производную.
|
||
\end{itemize}
|
||
\item \(disp\) --- bool, необязательный
|
||
|
||
Если \verb|True| и алгоритм не сошелся, будет сгенерировано
|
||
исключение \verb|RuntimeError|, с сообщением, содержащим
|
||
количество итераций и текущее значение функции. В противном
|
||
случае статус сходимости записывается в возвращаемый объект
|
||
\verb|RootResults|. Игнорируется, если \verb|x0| не является
|
||
скалярным. Примечание: это не имеет ничего общего с
|
||
отображением, однако ключевое слово \verb|disp| нельзя
|
||
переименовать для сохранения обратной совместимости.
|
||
\end{enumerate}
|
||
|
||
\subsection{Метод простой итерации}
|
||
Данный метод, как и предыдущий, не позволяет найти несколько решений
|
||
уравнения за исполнение алгоритма на единственном начальном приближении.
|
||
\subsubsection{Описание метода}
|
||
Уравнение \(F(x)=0\) приводим к виду \(x = \varphi(x)\), например
|
||
\(x-F(x)/M\), где \(M\) --- константа.
|
||
|
||
Условие сходимости алгоритма: \(0<|\varphi'(x)|<1\). Исходя из него,
|
||
\(M\) определяется как \(M=1.01 \cdot F'(x_0)\), где \(x_0\) ---
|
||
начальное приближение.
|
||
|
||
Таким образом, для итерации \(i, i = 1\dots k,\)
|
||
\(x_i = \varphi(x_{i-1})\).
|
||
|
||
Процесс продолжается, пока не будет достигнута заданная точность, в
|
||
данном случае достаточно будет выполнения условия:
|
||
\(|x_{i-1}-x_i|<\varepsilon\).
|
||
\subsubsection{Реализации метода в библиотеках numpy, scipy}
|
||
В библиотеках numpy, scipy не найдено реализаций данного метода.
|
||
|
||
\section{Методы решения систем линейных алгебраических уравнений}
|
||
Система линейных алгебраических (далее, СЛУ) уравнений имеет вид
|
||
\begin{eqnarray}
|
||
\left\{
|
||
\begin{aligned}
|
||
& a_{11}x_1 + a_{12}x_2 + a_{1n}x_n = b_1 \\
|
||
& a_{21}x_1 + a_{22}x_2 + a_{2n}x_n = b_2 \\
|
||
& ........................................ \\
|
||
& a_{n1}x_1 + a_{n2}x_2 + a_{nn}x_n = b_n \\
|
||
\end{aligned}
|
||
\right.
|
||
\label{formula:eqn_system}
|
||
\end{eqnarray}
|
||
|
||
Для решения таких систем существуют прямые и итерационные методы.
|
||
Прямые методы (к ним относятся "метод Гаусса", "метод обратной матрицы"
|
||
и "метод прогонки") позволяют получить решение за конечное количество
|
||
операций, точность которого ограничивается лишь погрешностью округления.
|
||
Итерационные методы (среди которых есть методы, такие как
|
||
"метод простой итерации" и "метод Зейделя") позволяют получить
|
||
приближенное решение с помощью последовательного приближения к точному.
|
||
|
||
\subsection{Метод Гаусса}
|
||
\subsubsection{Описание метода}
|
||
Для решения СЛУ система (\ref{formula:eqn_system}) приводится к
|
||
треугольному виду (\ref{formula:triag_eqn_system}) с помощью цепочки элементарных преобразований.
|
||
\begin{eqnarray}
|
||
\left\{
|
||
\begin{aligned}
|
||
& a'_{11}x_1 + a'_{12}x_2 + a'_{1n}x_n = b'_1 \\
|
||
& 0x_1 + a'_{22}x_2 + a'_{2n}x_n = b'_2 \\
|
||
& ........................................ \\
|
||
& 0x_1 + 0x_2 + a'_{nn}x_n = b'_n \\
|
||
\end{aligned}
|
||
\right.
|
||
\label{formula:triag_eqn_system}
|
||
\end{eqnarray}
|
||
Данный процесс называется прямым ходом, а нахождение неизвестных
|
||
\(x_n, x_{n-1}, \dots,x_1 \) --- обратным.
|
||
\subsubsection{Реализации метода в библиотеках numpy, scipy}
|
||
В библиотеке scipy реализован частный случай метода Гаусса ---
|
||
LU-разложение \cite[с. 259]{book:levitin}. Для получения решения
|
||
СЛУ необходимо задействовать две функции из модуля \textbf{scipy.linalg} \cite{links:scipy_doc}:
|
||
\begin{enumerate}
|
||
\item Для получения разложения используется функция
|
||
\textbf{lu\_factor}.
|
||
\item Для совершения обратного хода алгоритма используется
|
||
\textbf{lu\_solve}, которая принимает на вход разложение с
|
||
предыдущего этапа.
|
||
\end{enumerate}
|
||
|
||
Функция \textbf{lu\_factor} имеет следующие параметры (задаются в порядке перечисления):
|
||
\begin{enumerate}
|
||
\item \(a\) --- (M, N) array\_like
|
||
|
||
Матрица для разложения
|
||
\item \(overwrite\_a\) bool, необязательный
|
||
|
||
Следует ли перезаписывать данные в A (может повысить
|
||
производительность). По умолчанию \verb|False|.
|
||
\item \(check\_finite\) bool, необязательный
|
||
|
||
Проверять, содержит ли входная матрица только конечные числа.
|
||
Отключение может дать прирост производительности, но может
|
||
привести к проблемам (сбоям, незавершению), если входные данные
|
||
содержат бесконечности или NaN. По умолчанию \verb|True|.
|
||
\end{enumerate}
|
||
|
||
Функция \textbf{lu\_solve} имеет следующие параметры (задаются в порядке перечисления):
|
||
\begin{enumerate}
|
||
\item \((lu, piv)\) --- tuple
|
||
|
||
Факторизация матрицы коэффициентов a, полученная из
|
||
\textbf{lu\_factor}.
|
||
\item \(b\) --- array
|
||
|
||
Правая сторона
|
||
\item \(trans\) --- {0, 1, 2}, необязательный
|
||
|
||
Тип системы, которую необходимо решить:
|
||
|
||
\begin{tabularx}{0.8\textwidth}{|X|X|}
|
||
\hline \(trans\) & вид системы \\
|
||
\hline 0 & \(ax = b\) \\
|
||
\hline 1 & \(a^T x = b\) \\
|
||
\hline 2 & \(a^H x = b\) \\
|
||
\hline
|
||
\end{tabularx}\\
|
||
|
||
По умолчанию \verb|0|.
|
||
\item \(overwrite\_b\) --- bool, необязательный
|
||
|
||
Следует ли перезаписывать данные в \(b\) (может повысить производительность). По умолчанию \verb|False|.
|
||
\item \(check\_finite\) --- bool, необязательный
|
||
|
||
Проверять, содержат ли входные матрицы только конечные числа.
|
||
Отключение может дать прирост производительности, но может
|
||
привести к проблемам (сбоям, незавершению), если входные данные
|
||
содержат бесконечности или NaN. По умолчанию \verb|True|.
|
||
\end{enumerate}
|
||
|
||
\subsection{Метод обратной матрицы}
|
||
\subsubsection{Описание метода}
|
||
Исходная система (\ref{formula:eqn_system}) представляется в форме
|
||
\(AX=B\), тогда вектор неизвестных переменных \(X\) определяется по
|
||
формуле (\ref{formula:inv_m_method}).
|
||
\begin{equation}
|
||
X=A^{-1}B
|
||
\label{formula:inv_m_method}
|
||
\end{equation}
|
||
\subsubsection{Реализации метода в библиотеках numpy, scipy}
|
||
Отдельной функции для решения СЛУ не существует, вектор \(X\) можно
|
||
найти по формуле (\ref{formula:inv_m_method}). Для получения \(A^{-1}\)
|
||
существует функция \textbf{inv} в модуле \textbf{scipy.linalg}
|
||
\cite{links:scipy_doc} библиотеки scipy, и функция \textbf{inv} в модуле
|
||
\textbf{numpy.linalg} библиотеки numpy. Для перемножения \(A^{-1}\)
|
||
и \(B\) в языке Python есть оператор \verb|@|, начиная с версии \(3.5\)
|
||
\cite{links:numpy_doc}\cite{links:PEP465}.
|
||
|
||
В результате для получения решения СЛУ необходимо выполнить выражение
|
||
\verb|inv(A) @ B|, используя одну из вышеописанных функций.
|
||
|
||
Функция \textbf{inv} модуля \textbf{scipy.linalg} имеет следующие
|
||
параметры (задаются в порядке перечисления):
|
||
\begin{enumerate}
|
||
\item \(a\) --- array\_like
|
||
|
||
Квадратная матрица, которую необходимо инвертировать.
|
||
\item \(overwrite\_a\) --- bool, необязательный
|
||
|
||
Не запоминать состояние \(a\) (может улучшить
|
||
производительность). По умолчанию \verb|False|.
|
||
\item \(check\_finite\) --- bool, необязательный
|
||
|
||
Проверять, содержат ли входные матрицы только конечные числа.
|
||
Отключение может дать прирост производительности, но может
|
||
привести к проблемам (сбоям, незавершению), если входные данные
|
||
содержат бесконечности или NaN. По умолчанию \verb|True|.
|
||
\end{enumerate}
|
||
|
||
Функция \textbf{inv} модуля \textbf{scipy.linalg} имеет следующие
|
||
параметры (задаются в порядке перечисления):
|
||
\begin{enumerate}
|
||
\item \(a\) --- аналогичен параметру \(a\) функции из модуля \textbf{scipy.linalg}.
|
||
\end{enumerate}
|
||
|
||
\subsection{Метод прогонки}
|
||
TODO
|
||
\subsubsection{Описание метода}
|
||
TODO
|
||
\subsubsection{Реализации метода в библиотеках numpy, scipy}
|
||
|
||
\subsection{Метод простой итерации (метод Якоби)}
|
||
TODO
|
||
\subsubsection{Описание метода}
|
||
TODO
|
||
\subsubsection{Реализации метода в библиотеках numpy, scipy}
|
||
|
||
\subsection{Метод Зейделя}
|
||
TODO
|
||
\subsubsection{Описание метода}
|
||
TODO
|
||
\subsubsection{Реализации метода в библиотеках numpy, scipy}
|
||
|
||
\section{Численные методы решения систем нелинейных уравнений}
|
||
TODO
|
||
\subsection{Метод простой итерации (метод Якоби) для систем
|
||
нелинейных уравнений}
|
||
TODO
|
||
\subsubsection{Описание метода}
|
||
TODO
|
||
\subsubsection{Реализации метода в библиотеках numpy, scipy}
|
||
|
||
\subsection{Метод Зейделя для систем нелинейных уравнений}
|
||
TODO
|
||
\subsubsection{Описание метода}
|
||
TODO
|
||
\subsubsection{Реализации метода в библиотеках numpy, scipy}
|
||
|
||
\subsection{Метод Ньютона решения систем нелинейных уравнений}
|
||
TODO
|
||
\subsubsection{Описание метода}
|
||
TODO
|
||
\subsubsection{Реализации метода в библиотеках numpy, scipy}
|
||
|
||
\section{Аппроксимация функций}
|
||
\subsection{Интерполяционный полином в форме Лагранжа}
|
||
TODO
|
||
\subsubsection{Описание метода}
|
||
TODO
|
||
\subsubsection{Реализации метода в библиотеках numpy, scipy}
|
||
|
||
\subsection{Интерполяционный полином в форме Ньютона}
|
||
TODO
|
||
\subsubsection{Описание метода}
|
||
TODO
|
||
\subsubsection{Реализации метода в библиотеках numpy, scipy}
|
||
|
||
\subsection{Сплайн-интерполяция}
|
||
TODO
|
||
\subsubsection{Описание метода}
|
||
TODO
|
||
\subsubsection{Реализации метода в библиотеках numpy, scipy}
|
||
|
||
\subsection{Сглаживание. Метод наименьших квадратов}
|
||
TODO
|
||
\subsubsection{Описание метода}
|
||
TODO
|
||
\subsubsection{Реализации метода в библиотеках numpy, scipy}
|
||
|
||
\section{Численное интегрирование}
|
||
\subsection{Метод прямоугольников}
|
||
TODO
|
||
\subsubsection{Описание метода}
|
||
TODO
|
||
\subsubsection{Реализации метода в библиотеках numpy, scipy}
|
||
|
||
\subsection{Метод трапеций}
|
||
TODO
|
||
\subsubsection{Описание метода}
|
||
TODO
|
||
\subsubsection{Реализации метода в библиотеках numpy, scipy}
|
||
|
||
\subsection{Метод парабол (Симпсона)}
|
||
TODO
|
||
\subsubsection{Описание метода}
|
||
TODO
|
||
\subsubsection{Реализации метода в библиотеках numpy, scipy}
|
||
|
||
|
||
\section{Численное решение обыкновенных дифференциальных уравнений}
|
||
\subsection{Метод Эйлера}
|
||
TODO
|
||
\subsubsection{Описание метода}
|
||
TODO
|
||
\subsubsection{Реализации метода в библиотеках numpy, scipy}
|
||
|
||
\subsection{Модифицированный метод Эйлера}
|
||
TODO
|
||
\subsubsection{Описание метода}
|
||
TODO
|
||
\subsubsection{Реализации метода в библиотеках numpy, scipy}
|
||
|
||
\subsection{Метод Рунге-Кутта}
|
||
TODO
|
||
\subsubsection{Описание метода}
|
||
TODO
|
||
\subsubsection{Реализации метода в библиотеках numpy, scipy}
|
||
|
||
|
||
\chapter{Экспериментальное исследование возможностей библиотек}
|
||
|
||
\chapter*{Заключение}
|
||
\addcontentsline{toc}{chapter}{Заключение}
|
||
|
||
\input{sources}
|
||
\include{appendix}
|
||
\end{document}
|