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

Участник:Анюшева Ирина/Итерационный метод решения системы линейных алгебраических уравнений GMRES (обобщенный метод минимальных невязок)

2016-12-03T14:04:03Z

Dan:

{{algorithm
| name = GMRES (обобщенный метод минимальных невязок)
| serial_complexity = <math>O(m^2n^2)</math>
| pf_height = <math>O(mn)</math>
| pf_width = <math>O(mn)</math>
| input_data = <math>n^2+2n</math>
| output_data = <math>n</math>
}}

Основные авторы описания: [[U:Анюшева Ирина|Анюшева Ирина]] (614 группа, разделы: 1.1-1.2, 1.7-1.8, 2.7, 3), Исхаков Эльдар (614 группа, разделы 1.3-1.6, 1.9-1.10)

= Свойства и структура алгоритма =
== Общее описание алгоритма ==
Обобщенный метод минимальных невязок (GMRES) для решения системы линейных алгебраических уравнений аппроксимирует решение с помощью вектора в подпространстве Крылова с минимальным остатком. Метод GMRES разработан Ю.Саадом и Мартин Х. Шульцом в 1986 году. Метод по праву считается одним из самых эффективных численных методов решения несимметричных систем. Он гарантирует неувеличение нормы невязки в ходе итерационного процесса, который основан на построении базиса в соответствующей системе подпространстве Крылова <math>K_j(A, r_0)</math>.
Затем решение уточняется некоторой добавкой, представленной в виде разложения по этому базису.

Метод обобщенных минимальных невязок популярен из-за наличия ряда преимуществ: он ошибкоустойчив, допускает эффективное распараллеливание, не требует нахождения параметра релаксации, обладает суперлинейной скоростью сходимости. Однако в чистом виде для больших систем метод не используется из-за чрезвычайно больших затрат памяти. Зато широкое распространение получила перезапускаемая версия метода, подоразумевающая перезапуск метода каждые m итераций. Уменьшение размерности пространства может привести к стагнации метода – процессу, при котором с каждой следующей итерацией норма невязки уменьшается незначительно, либо не уменьшается вовсе.

== Математическое описание алгоритма ==
Исходные данные: система линейных алгебраических уравнений <math>Ax=b</math>, где:

<math>A=(a_{ij})</math> <math>-</math> вещественная матрица размера <math>n \times n</math>;

<math>b</math> и <math>x</math> вектора из <math>n</math> элементов;

<math>x^*</math> <math>-</math> точное решение системы.

Вычисляемые данные: <math>x^{(s)} - </math>приближенное решение системы.

===Ортогонализация Арнольди===
Для построения базиса <math>V</math> в подпространстве Крылова в методе GMRES применяется ортогонализация Арнольди.

Формулы метода:
:<math>
\begin{align}
(h_{i+1,i}v_{i+1}) & = Av_i - \sum_{j = 1}^{i} h_{j,i}v_j, \\
v_1 &= \frac{r_0}{\parallel r_0 \parallel},
\end{align}
</math>
В матрично-векторных обозначениях соотношение может быть записано как
:<math>
\begin{align}
AV_i &= V_i H_i + h_{i+1,i}v_{i+1} e_i^T &=V_{i+1}\overline{H}_i,
\end{align}
</math>
:<math>
\begin{align}
V_i &= [v_1|v_2|...|v_i], \overline{H}_i - \end{align}
</math> верхняя матрица Хессенберга размерности <math>(i+1)\times i</math>

===Минимизация невязки===

Невязку уравнения можно определить как
<math> J(y) = \parallel b- A x\parallel = \parallel b- (Ax_0+V_m y)\parallel =\parallel \beta e_1 - \overline{H}_m y \parallel</math>,
где <math>y -</math> вектор размерности <math>m</math>.

Вектор <math>x_m</math> может быть получен как
<math>x_m = x_0 + V_m y_m</math>, вектор <math>y_m</math> может найден как решение линейной задачи наименьших квадратов размера <math>(m+1)\times m</math>, где <math>m<<n</math>.

Для решения задачи минимизации приведем матрицу <math>\overline{H}_m</math> к верхнему треугольному виду с помощью вращений Гивенса. На шаге
<math>i</math> матрица вращения <math>\Omega_i</math> имеет размеры <math>(m+1)\times (m+1)</math> и имеет следующий вид:

<math>
\Omega_i= \begin{pmatrix}
1 & &&&&&& \\
&\ddots &&&&&&\\
&&1&&&&& \\
&&&c_i&s_i &&& \\
&&&-s_i& c_i &&&\\
&&&&&1&&& \\
&&&&&&\ddots&\\
&&&&&&&1 \\
\end{pmatrix}</math>

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

В алгоритме GMRES присутствуют два ресурсоемких с точки зрения вычислительных мощностей этапа:

* умножение исходной матрицы на вектор при вычислении невязок;

* вычисление скалярных произведений векторов при построении ортонормированного базиса подпространства Крылова.

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

Нижеперечисленные шаги алгоритма и входящие в них операции являются наиболее ресурсоемкими. Они выполняются в приведенном порядке. Каждый из них допускает распараллеливание:

* Вычисление нормы невязки для задачи "начальных" условий;

* Вычисление элементов Хессенберговой матрицы - матрично-векторные умножения и скалярные произведения векторов;

* Вычисление произведений разреженных матриц при минимизации невязки.

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

===Шаги алгоритма===

1. Выбрать произвольное <math>x_0</math>; вычислить <math>r_0=b-Ax_0</math> и <math>v_1=\frac{r_0}{\parallel r_0 \parallel}</math>

2. Задать матрицу <math>\overline{H}_m</math> размерности <math>(m+1)\times m</math> и всем ее элементам присвоить нулевые значения

3. Для <math>j=1,\dots,m</math> выполнять:

* для <math>i=1,\dots,j</math> выполнять: <math>h_{i,j}=(Av_j,v_i)</math>
* <math>\omega_j=Av_j-\sum_{i=1}^j h_{i,j}v_i</math>
* <math>h_{j+1,j}={\parallel \omega_j \parallel}</math>
* <math>v_{j+1}=\frac{\omega_j}{h_{j+1,j}}</math>

4. Вычислить <math>y_m=\arg\min_{y} \parallel \beta e_1 - \overline{H}_my \parallel,\ y \in \mathbb{R}^m</math> и <math>x_m=x_0+V_my_m</math>

5. Вычислить <math>r_m=b-Ax_m</math>. Если достигнутая точность удовлетворительна, остановиться.

Иначе принять <math>x_0=x_m</math> и <math>v_1=\frac{r_m}{\parallel r_m \parallel}</math> и вернуться к пункту 2.

===Решение задачи минимизации невязки===

Для нахождения <math>y_m=\arg\min_{y} \parallel \beta e_1 - \overline{H}_my \parallel</math> необходимо выполнить следующие шаги:

1. Найти <math>m</math> матриц вращений Гивенса <math>\Omega_i(c_i,s_i),\ i=1,\dots,m</math> размера <math>(m+1)\times(m+1)</math>, где <math>s_i=\frac{h_{i+1,i}}{\sqrt{h_{i,i}^2+h_{i+1,i}^2}}</math>, <math>c_i=\frac{h_{i,i}}{\sqrt{h_{i,i}^2+h_{i+1,i}^2}}</math>

2. Вычислить <math>\overline{H}_m^{(m)}=\Omega_1\dots\Omega_m\overline{H}_m</math> и <math>\overline{g}_m=\Omega_1\dots\Omega_m\beta e_1</math>, удалить последнюю строку и последний элемент соответственно и решить СЛАУ с полученной верхнетреугольной матрицей и правой частью. Полученное решение <math>y_m</math> минимизирует исходный функционал.

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

Для выполнения одной итерации алгоритма необходимо произвести:

* <math>3m+1</math> делений;

* <math>2m+1</math> вычислений квадратного корня;

* <math>n^2+\frac{3m+5}{2}n</math> умножений;

* <math>O(\frac{m^2n^2}{2})</math> сложений (вычитаний).

==Информационный граф==
Метод состоит из двух блоков: ортогонализация и минимизация невязки. При ортогонализации основными операциями являются умножение матрицы на вектор и скалярное умножение векторов, для которых возможен параллелизм, что показано в блоке на темно-синем фоне. В блоке <math>min</math> решается задача минимизации невязки, которая, строго говоря, является отдельной самостоятельной задачей.
[[file:gmres.jpg|thumb|center|700px|Рис.1. Информационная структура алгоритма GMRES]]

==Ресурс параллелизма алгоритма==
Для нахождения матрично-векторных произведений при вычислении невязок матрица СЛАУ должна быть подвергнута декомпозиции на строчные блоки, размеры которых определяются требованиями равномерности загрузки. Соответствующим образом подвергается декомпозиции и вектор правой части. Для наиболее эффективного вычисления скалярных произведений и линейных комбинаций векторов базиса каждый из векторов <math>v_j</math> должен быть разбит на блоки равного размера по числу процессов; каждый из процессов при этом хранит соответствующие блоки всех векторов. Обработка вектора решения дублируется на всех процессах.

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

'''Входные данные:'''
* матрица <math>A</math> размера <math>n\times n</math>;
* вектор-столбец <math>b</math> размера <math>n</math>;
* вектор-столбец <math>x_0</math> размера <math>n</math> - начальное приближение;
* натуральное число <math>m<<n</math>, определяющее размерность подпространства Крылова.

'''Выходные данные:'''
* вектор-столбец <math>x</math> размера <math>n</math> - решение системы.

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

* Вычислительная мощность: весьма маленькая и равна <math>m^2</math>, так как <math>m<<n</math>.

* Устойчивость: GMRES в этом плане является очень хорошим методом. Теоретически можно получить точное решение не более чем за <math>n</math> итераций. Однако, очень приемлемые результаты получаются и за <math>m<<n</math> итераций. Однако, есть примеры, в которых видно, что первые <math>m-1</math> итераций дают невязку, равную некой константе, а на итерации под номером <math>m</math> получаем точное решение.

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

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

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

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

==Масштабируемость алгоритма и его реализации==
Исследование масштабируемости параллельной реализации итерационного метода решения системы линейных алгебраических уравнений GMRES проводилось в тестовой среде суперкомпьютера "Ломоносов". Алгоритм реализован на языке С с использованием библиотеки IntelMPI версии 4.1.0. Сборка производилась при помощи компилятора, разработанным компанией Intel версии 13.1.0.
Набор и границы значений изменяемых параметров запуска:
*число процессов [1 : 128] со значениями, равными степеням двойки;
*размер матрицы [128 : 2048] с шагом 128.
В результате проведенных экспериментов был получен следующий диапазон эффективности реализации алгоритма:
*минимальная эффективность реализации 0.002%;
*максимальная эффективность реализации 4.92%.
На следующих рисунках приведены графики производительности и эффективности выбранной реализации в зависимости от изменяемых параметров запуска. Размерность подпространства Крылова во всех случаях равна 10.
[[File:Anyusheva iskhakovPerformance.jpg|thumb|center|1500px|Рис.2 Изменение производительности выполнения в зависимости от числа процессов и размера входной матрицы]]
[[File:Anyusheva iskhakovEfficiency.jpg|thumb|center|1500px|Рис.3 Изменение эффективности выполнения в зависимости от числа процессов и размера входной матрицы]]
Из рисунков видно, что при увеличении количества процессов, а также при увеличении размерности задачи, производительность параллельной реализации алгоритма уменьшается, что говорит о плохой масштабируемости.
Исследуемая реализация алгоритма доступна по [http://pastebin.com/vEyb3kuS ссылке].

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

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

==Существующие реализации алгоритма==
* Реализация алгоритма в библиотеке SciPy [https://docs.scipy.org/doc/scipy-0.17.0/reference/generated/scipy.sparse.linalg.gmres.html]
* Реализация алгоритма в библиотеке IML++ [http://math.nist.gov/iml++/gmres.h.txt]
* Библиотека для MATLAB [http://www.mathworks.com/help/matlab/ref/gmres.html]

= Литература=
1. Y. Saad, M.H. Schultz. GMRES: A generalized minimal residual algorithm for solving nonsymmetric linear systems. SIAM J. Sci. Statist. Comput., 7 (1986), pp. 856–869

2. Е.Е. Тыртышников. Методы численного анализа. – Москва: Академия, 2007

3. М.Ю. Баландин, Э.П. Шурина. Некоторые оценки эффективности параллельных алгоритмов решения СЛАУ на подпространствах Крылова. - Вычислительные технологии, том 3, №1, 1998

Обсуждение участника:Анюшева Ирина

2016-12-03T14:03:51Z

Dan:

--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:05, 3 декабря 2016 (MSK) К работе есть несколько замечаний по содержанию (отмечены моей подписью), помимо выполнения требований к работе

= Пункт 2.4 =
[[Участник:Dan|Dan]] ([[Обсуждение участника:Dan|обсуждение]]) 17:03, 3 декабря 2016 (MSK) Добавьте строки запуска и компиляции со всеми ключами

= Пункт 1.1 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:05, 3 декабря 2016 (MSK)

'''Обобщенный метод минимальных невязок (GMRES) для решения системы линейных алгебраических уравнений аппроксимирует решение с помощью вектора в подпространстве Крылова с минимальным остатком.'''

Что здесь подразумевается по «минимальным остатком»?

'''Метод по праву считается одним из самых эффективных численных методов решения несимметричных систем.'''

Чем GMRES эффективнее с вычислительной точки зрения, например, других итерационных Крыловских методов для несимметричных матриц?

'''Метод обобщенных минимальных невязок популярен из-за наличия ряда преимуществ: он ошибкоустойчив, допускает эффективное распараллеливание, не требует нахождения параметра релаксации, обладает суперлинейной скоростью сходимости.'''

Нужно пояснить, что подразумевается под ошибкоустойчивостью метода? Причем здесь параметр релаксации? Обычно вместо «суперлинейной сходимости», пишут сверхлинейная сходимость. Хорошо бы выделить класс методов, с которыми сравнивается GMRES в плане эффективности и преимуществ. Так, например, стабилизированный метод бисопряженных градиентов также «допускает эффективное распараллеливание и не требует нахождения параметра релаксации».

'''Зато широкое распространение получила перезапускаемая версия метода, подоразумевающая перезапуск метода каждые m итераций.'''

Сохраняются ли преимущества метода для версии метода GMRES с рестартами? Например, сверхлинейная сходимость и ошибкоустойчивость? Свойства (достоинства и недостатки) GMRES(m) лучше описать подробнее.

Опечатка - '''подоразумевающая перезапуск метода каждые m итераций'''

= Пункт 1.2.1 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:05, 3 декабря 2016 (MSK)

Нужно уточнить какая норма здесь рассматривается. Также в нескольких местах (в этом и следующих разделах) при записи нормы пропущена одна правая вертикальная скобка.

= Пункт 1.5.1 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:05, 3 декабря 2016 (MSK)

'''Выбрать произвольное <math>x_0</math>;'''

Для любого <math>x_0</math> достигается сходимость?

= Пункт 1.6 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:05, 3 декабря 2016 (MSK)

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

= Пункт 1.7 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:05, 3 декабря 2016 (MSK)

Хорошо бы подробнее описать структуру алгоритма в блоках ортогонализации и минимизации невязки.

= Пункт 1.8 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:05, 3 декабря 2016 (MSK)

'''Для нахождения матрично-векторных произведений при вычислении невязок матрица СЛАУ должна быть подвергнута декомпозиции на строчные блоки, размеры которых определяются требованиями равномерности загрузки.'''

Можно ли рассматривать декомпозицию матрицы по «двумерным» блокам, а не только по строкам?

'''Обработка вектора решения дублируется на всех процессах.'''

В практических задачах размерность вектора решения может быть очень большой и не помещаться в память процессора. Как предлагается решать такие задачи? Если такие задачи не рассматриваются, то это нужно явно прописать.

= Пункт 1.10 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:05, 3 декабря 2016 (MSK)

'''Однако, есть примеры, в которых видно, что первые <math>m-1</math> итераций дают невязку, равную некой константе, а на итерации под номером <math>m</math> получаем точное решение'''

Нужно привести такие примеры и описать подробнее данные случаи или указать ссылку на работу, где такие примеры построены.

= Пункт 2.4 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:05, 3 декабря 2016 (MSK)

Нужно описать структуру матрицы, которая рассматривалась в экспериментах. Какое условие на выход из итерационного процесса использовалось в расчетах?

С чем связана такая низкая эффективность реализации?

'''Из рисунков видно, что при увеличении количества процессов, а также при увеличении размерности задачи, производительность параллельной реализации алгоритма уменьшается, что говорит о плохой масштабируемости.'''

Нужно объяснить в чем причина плохой масштабируемости алгоритма. Особенно с учетом того, что в разделе 1.1 Вы пишите о том, что метод GMRES «допускает эффективное распараллеливание».

----

Обсуждение участника:Анюшева Ирина

2016-12-03T14:03:27Z

Dan:

--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:05, 3 декабря 2016 (MSK) К работе есть несколько замечаний по содержанию (отмечены моей подписью), помимо выполнения требований к работе

= Пункт 2.4 =
[[Участник:Dan|Dan]] ([[Обсуждение участника:Dan|обсуждение]]) 17:03, 3 декабря 2016 (MSK) Добавьте строки запуска и компиляции со всему ключами

= Пункт 1.1 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:05, 3 декабря 2016 (MSK)

'''Обобщенный метод минимальных невязок (GMRES) для решения системы линейных алгебраических уравнений аппроксимирует решение с помощью вектора в подпространстве Крылова с минимальным остатком.'''

Что здесь подразумевается по «минимальным остатком»?

'''Метод по праву считается одним из самых эффективных численных методов решения несимметричных систем.'''

Чем GMRES эффективнее с вычислительной точки зрения, например, других итерационных Крыловских методов для несимметричных матриц?

'''Метод обобщенных минимальных невязок популярен из-за наличия ряда преимуществ: он ошибкоустойчив, допускает эффективное распараллеливание, не требует нахождения параметра релаксации, обладает суперлинейной скоростью сходимости.'''

Нужно пояснить, что подразумевается под ошибкоустойчивостью метода? Причем здесь параметр релаксации? Обычно вместо «суперлинейной сходимости», пишут сверхлинейная сходимость. Хорошо бы выделить класс методов, с которыми сравнивается GMRES в плане эффективности и преимуществ. Так, например, стабилизированный метод бисопряженных градиентов также «допускает эффективное распараллеливание и не требует нахождения параметра релаксации».

'''Зато широкое распространение получила перезапускаемая версия метода, подоразумевающая перезапуск метода каждые m итераций.'''

Сохраняются ли преимущества метода для версии метода GMRES с рестартами? Например, сверхлинейная сходимость и ошибкоустойчивость? Свойства (достоинства и недостатки) GMRES(m) лучше описать подробнее.

Опечатка - '''подоразумевающая перезапуск метода каждые m итераций'''

= Пункт 1.2.1 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:05, 3 декабря 2016 (MSK)

Нужно уточнить какая норма здесь рассматривается. Также в нескольких местах (в этом и следующих разделах) при записи нормы пропущена одна правая вертикальная скобка.

= Пункт 1.5.1 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:05, 3 декабря 2016 (MSK)

'''Выбрать произвольное <math>x_0</math>;'''

Для любого <math>x_0</math> достигается сходимость?

= Пункт 1.6 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:05, 3 декабря 2016 (MSK)

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

= Пункт 1.7 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:05, 3 декабря 2016 (MSK)

Хорошо бы подробнее описать структуру алгоритма в блоках ортогонализации и минимизации невязки.

= Пункт 1.8 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:05, 3 декабря 2016 (MSK)

'''Для нахождения матрично-векторных произведений при вычислении невязок матрица СЛАУ должна быть подвергнута декомпозиции на строчные блоки, размеры которых определяются требованиями равномерности загрузки.'''

Можно ли рассматривать декомпозицию матрицы по «двумерным» блокам, а не только по строкам?

'''Обработка вектора решения дублируется на всех процессах.'''

В практических задачах размерность вектора решения может быть очень большой и не помещаться в память процессора. Как предлагается решать такие задачи? Если такие задачи не рассматриваются, то это нужно явно прописать.

= Пункт 1.10 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:05, 3 декабря 2016 (MSK)

'''Однако, есть примеры, в которых видно, что первые <math>m-1</math> итераций дают невязку, равную некой константе, а на итерации под номером <math>m</math> получаем точное решение'''

Нужно привести такие примеры и описать подробнее данные случаи или указать ссылку на работу, где такие примеры построены.

= Пункт 2.4 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:05, 3 декабря 2016 (MSK)

Нужно описать структуру матрицы, которая рассматривалась в экспериментах. Какое условие на выход из итерационного процесса использовалось в расчетах?

С чем связана такая низкая эффективность реализации?

'''Из рисунков видно, что при увеличении количества процессов, а также при увеличении размерности задачи, производительность параллельной реализации алгоритма уменьшается, что говорит о плохой масштабируемости.'''

Нужно объяснить в чем причина плохой масштабируемости алгоритма. Особенно с учетом того, что в разделе 1.1 Вы пишите о том, что метод GMRES «допускает эффективное распараллеливание».

----

Участник:Alexander34396/Обобщенный метод минимальных невязок

2016-11-30T16:10:08Z

Dan:

{{Assignment|Dan}}

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

{{algorithm
| name = Обобщенный метод минимальных невязок
| serial_complexity = <math> O(nm^2) </math>
| input_data = <math> (n + 1)^2 </math>
| output_data = <math> n </math>
}}

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

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

'''Обобщённый метод минимальных невязок''' ({{lang-en|Generalized minimal residual method, GMRES}}) - итерационный метод численного решения системы линейных алгебраических уравнений с невырожденной матрицей. Метод основан на минимизации квадратичного функционала невязки на подпространствах Крылова. Разработан Юсефом Саадом и Мартином Шульцем<ref> Y.Saad, M.H. Schultz, GMRES: A generalized minimal residual algorithm for solving nonsymmetric linear systems, SIAM J. Scientific and Stat. Comp. 7: 856-869 (1986) </ref> в 1986 году как обобщение метода MINRES<ref>C. C. Paige and M. A. Saunders. Solution of sparse indefinite systems of linear equations, SIAM J. Numerical Analysis 12, 617-629 (1975)</ref> на случай систем с несимметричными матрицами.

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

'''Исходные данные:'''
* система линейных алгебраических уравнений вида <math> Ax = b </math>, где <math> A </math> — невырожденная матрица размера <math>n</math>-на-<math> n </math>;
* <math> x_0 </math> - начальное приближение.
'''Вычисляемые данные:'''
* <math> x_m </math> - приближённое решение исходной системы.

Метод GMRES приближает точное решение исходной системы <math> Ax = b </math> вектором <math> x_m </math>, который минимизирует Евклидову норму невязки <math> r_m = Ax_m - b</math> на подпространстве Крылова:
: <math> K_m = K_m(A,b) = \operatorname{span} \, \{ b, Ab, A^2b, \ldots, A^{m-1}b \} </math>, где <math> \operatorname{span} \, \{ a_1, a_2, \ldots, a_m \} </math> - линейная оболочка системы векторов <math> \{ a_1, a_2, \ldots, a_m \} </math>.

На каждой итерации метода решение уточняется поправкой, представленной в виде разложения по ортонормированному базису пространства <math> K_m </math>:
: <math> x_m = x_0 + z_m </math>, где <math> x_0 </math> - некоторое начальное приближение, <math> z_m \in K_m </math> - поправка решения.

=== Ортогонализация Арнольди ===

Для построения ортонормированного базиса <math> v_1, v_2, \ldots, v_m </math> пространства Крылова <math> K_m </math> метод использует процесс Арнольди.

Идея процесса Арнольди состоит в том, что для нахождения вектора <math> v_{j+1} </math> при известных векторах <math> v_1, v_2, \ldots, v_j </math> необходимо вычислить вектор <math> Av_j </math> и ортонормировать этот вектор относительно <math> v_1, v_2, \ldots, v_j </math>:
: <math> v_{j+1} = \frac{\hat{v}_{j+1}}{\|\hat{v}_{j+1}\|_2} </math>, где <math> \hat{v}_{j+1} = Av_j - \sum_{i=1}^j h_{ij}v_{i} </math>.

Коэффициенты <math> h_{ij} = (Av_j, v_i) </math> определяются из условия ортогональности:
: <math> A(v_j, v_k) - \sum_{i=1}^j h_{ij}(v_{i}, v_k) = 0 </math>, где <math> \quad k=1,\ldots,j </math>.

Результат процедуры Арнольди совпадает с результатом процесса Грамма-Шмидта, применённого к векторам <math> \{b, Ab, A^2b, \ldots, A^{m-1}b\} </math>.

'''Исходные данные:'''
* <math> v_1 </math>, такой что <math> \|v_1\|_2 = 1 </math>;
* матрица <math> A </math> размером <math> n </math>-на-<math> n </math>.

'''Вычисляемые данные:'''
* <math> v_1, v_2, \ldots, v_m </math> - ортонормированный базис пространства Крылова <math> K_m </math>.

'''Алгоритм процесса:'''

Выполнять для <math> \quad j=1,\ldots,m </math>:
# <math> h_{ij} = (Av_j, v_i), \quad i=1,\ldots,j </math>;
# <math> \hat{v}_{j+1} = Av_j - \sum_{i=1}^j h_{ij}v_{i} </math>;
# <math> h_{j+1j} = \|\hat{v}_{j+1}\|_2 </math>;
# <math> v_{j+1} = \frac{\hat{v}_{j+1}}{h_{j+1j}} </math>.

'''При введении матричных обозначений можно записать:'''

Поправка решения:
: <math> z_m = V_my_m </math>, где <math> y_m \in \mathbb{R}^m </math> - вектор коэффициентов, <math> V_m = [v_1|v_2|...|v_m] </math>.

Матричное представление процесса Арнольди:
: <math> AV_m = V_{m+1}H_{m+1m} = V_mH_m + h_{m+1m}v_{m+1} e_m^T </math>,
где
: <math>H_{m+1m} = \begin{bmatrix}h_{11} & h_{12} & h_{13} &... & h_{1m-1} & h_{1m} \\ h_{21} & h_{22} & h_{23} & ... & h_{2m-1} & h_{2m} \\ 0 & h_{32} & h_{33} &...& h_{3m-1} & h_{3m} \\ ... & ... & ... & ... & ... & ... \\ 0 & 0 & 0 & ... & h_{m m-1} & h_{mm} \\0 & 0 & 0 & ... & 0 & h_{m+1 m}\end{bmatrix}</math>
- верхняя матрица Хессенберга размерности <math> m+1 </math> на <math> m </math>.

=== Минимизация функционала невязки ===

Невязка исходной системы имеет вид:
: <math> r_m = b - A(x_0 + z_m) = r_0 - AV_my_m = \beta v_1 - V_{m+1}H_{m+1m}y_m</math>, где <math> \beta = \|r_0\|_2</math>.

C учетом того, что матрица <math> V_{k+1} </math> составлена из ортонормированных векторов:
: <math> r_m = \beta V_{m+1}e_1 - H_{m+1m}y_m</math>, где <math> e_1 = (1,0,0,\ldots,0)^T </math>.

Норма невязки <math> r_m </math>:
: <math> \|r_m\|_2 = \|\beta e_1 - H_{m+1m}y_m\|_2 </math>.

Норма <math> \|r_m\|_2 </math> достигает минимума при <math> \beta e_1 = H_{m+1m}y_m </math>.

Для нахождения решения такой системы, матрица <math> H_{m+1m} </math> приводится к верхнему треугольному виду с помощью <math> m </math> последовательных [[Метод_Гивенса_(вращений)_QR-разложения_квадратной_матрицы_(вещественный_вариант)|вращений Гивенса]].

=== Общая схема метода ===

В общем виде m-aя итерация алгоритма GMRES может быть записан следующим образом:

# найти ортонормированный базис <math> V_m </math> подпространства <math> K_m </math> с помощью ортогонализации Арнольди;
# найти <math> y_m </math>, минимизирующий <math> \|r_m\|_2 </math>;
# вычислить <math> x_m = x_0 + V_my_m </math>, где <math> x_0 </math> - начальное приближение;
# вычислить <math> r_m </math> и остановиться,если требуемая точность была достигнута, иначе повторить.

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

Вычислительное ядро последовательной версии метода GMRES состоит из двух частей:
* Вычисление ортонормированного базиса <math> K_m </math>;
* Формирование приближенного решения <math> x_m </math>.

Для вычисления ортонормированного базиса <math> K_m </math> метод использует процесс Арнольди:
: <math> h_{j+1j}v_{j+1} = Av_j - \sum_{i=1}^j h_{ij}v_{j} </math>, где <math> h_{ij} = (Av_j, v_i)</math>, <math> \quad j=1,\ldots,m </math>.

Для нахождения приближённого решения <math> x_m </math> метод использует формулу:
: <math> x_m = x_0 + V_my_m </math>.

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

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

* Умножение матрицы на вектор;
* Вычисление скалярного произведения векторов;
* Вычисление Евклидовой нормы вектора;
* Умножение вектора на скаляр;
* Деление вектора на скаляр.

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

На практике используется перезапускаемая версия метода - GMRES(m):

'''1 Подготовка перед итерационным процессом:'''
:1.1 Выбрать начальное приближение <math> x_0 </math>;
:1.2 Посчитать невязку <math> r_0 = b - Ax_0 </math>;
:1.3 Вычислить <math> v_1 = \frac{r_0}{\|r_0\|_2} </math>.

'''2 Построение ортонормированного базиса <math> K_m </math>:'''

: Для всех <math> j </math> от 1 до m по нарастанию выполнять:
:2.1 <math> h_{ij} := (Av_j, v_i), \quad i=1,\ldots,j </math>;
:2.2 <math> \hat{v}_{j+1} := Av_j - \sum_{i=1}^j h_{ij}v_{i} </math>;
:2.3 <math> h_{j+1j} = \|\hat{v}_{j+1}\|_2 </math>;
:2.4 <math> v_{j+1} = \frac{\hat{v}_{j+1}}{h_{j+1j}} </math>.

'''3 Вычисление <math> x_m </math>:'''
:3.1 <math> x_m = x_0 + V_my_m </math>, где <math>y_m</math> минимизирует <math>\|r_0 - AV_my_m\|_2</math>;
:3.2 Вычислить <math> r_m </math>;
:3.3 Если требуемая точность достигнута, остановиться.

'''4 Перезапуск:'''
:4.1 <math>x_0 = x_m</math>;
:4.2 <math>v_1 = \frac{r_m}{\|r_m\|_2}</math>;
:4.3 Перейти к шагу 2.

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

Если пренебречь сложностью вычисления <math> y_m </math>, то общую сложность алгоритма GMRES можно разделить на две части:

'''1. Сложность вычисления ортонормированного базиса пространства <math> K_m </math>:'''
:a) Для вычисления <math> j </math>-го вектора базиса <math> K_m, j < m </math> требуется:
:: <math> NZ + (2j + 1)n </math> мультипликативных операций, где <math> NZ </math> - количество ненулевых элементов матрицы <math> A </math>.
:b) Вычисление последнего вектора базиса требует:
:: <math> n(m + 1) </math> мультипликативных операций.
:c) Общая мультипликативная сложность вычисления ортонормированного базиса <math> K_m </math>:
:: <math> O(nm^2) </math>.

'''2. Сложность вычисления приближённого решения <math> x_m </math>:'''
:a) Вычисление этой формулы требует <math> nm </math> мультипликативных операций.

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

[[File: Drawing.png|thumb|center|350px|'''Рис. 1'''
'''input''' - входные данные алгоритма (квадратная матрица, вектор правой части, начальное приближение, точность решения);
'''<math> A_i </math>''' - шаги алгоритма Арнольди, <math> x_i </math> - нахождение невязки на <math> i </math>-ой итерации;
'''if''' - вычисление <math> r_m </math> и в случае достижения нужной точности - остановка.]]
Шаги алгоритма Арнольди выполняются строго последовательно, но вычисление <math> i </math>-ой невязки может происходить параллельно
с <math> (i + 1) </math>-ым шагом алгоритма Арнольди.

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

В ходе анализа перезапускаемого метода обобщенных минимальных невязок был выявлен ряд подзадач, выполняющихся неоднократно: умножение матрицы на вектор, вычисление скалярного произведения векторов, нахождение нормы вектора, нормирование вектора, нахождение взвешенной суммы векторов. Наиболее трудоемкой среди перечисленных операций является умножение матрицы на вектор.

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

При выполнении параллельного алгоритма решения систем линейных алгебраических уравнений необходимо распределить входные данные наиболее рациональным способом. Матрица коэффициентов разбивается на непрерывные горизонтальные полосы. Распределение вектора правой части и начального приближения выполнено по принципу дублирования, т.е. все элементы векторов скопированы на все процессоры. Для рассматриваемой задачи решения СЛАУ такой подход распределения допустим, т.к. векторы содержат столько же элементов, сколько и одна строка или один столбец матрицы коэффициентов.

Подзадачи можно разделить на 2 группы: операции между матрицей и вектором (например, умножение матрицы на вектор) и операции между двумя векторами (например, скалярное умножение). Подзадачи умножения константы на вектор и определение нормы вектора можно относить ко второй группе, так как их трудоемкость одного порядка.

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

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

'''Входные данные:'''
* <math> A </math> – квадратная матрица размера <math> n </math>-на-<math> n </math>;
* <math> b </math> – вектор правой части размера <math> n </math>;
* <math> x_0 </math> – начальное приближение размера <math> n </math>;
* <math> \epsilon </math> – погрешность решения.

'''Для перезапускаемой версии алгоритма дополнительно:'''
* <math> m </math> – число итераций.

'''Объём входных данных''': <math> n^2 + 2n + 1 </math>.

'''Выходные данные''':
* <math> x_m </math> - вектор приближённого решения размера <math> n </math>.

'''Объём выходных данных''': <math> n </math>.

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

Обобщенный метод минимальных невязок предназначен для решения несимметричных систем линейных уравнений. GMRES использует перезазапуски для контроля требований к хранению данных.

Если используется неперезапускаемый метод, GMRES будет сходиться за не более <math> n </math> шагов. Но это не имеет практического применения, когда <math> n </math> велико. Кроме того, требования к памяти и вычислениям при отсутствии перезапусков являются очень высокими. Важнейшим элементом для успешного применения <math> GMRES(m)</math> являются перезапуски; то есть выбор <math> m </math>. Существуют примеры, для которых метод застаивается и сходимость есть только на <math>m</math>-м шаге. Для таких систем, любой выбор <math> m </math> меньше, чем <math> n </math> - не сходится.

Основным недостатком GMRES является то, что объемы работ и ресурсы памяти, требуемые для итерации, линейно возрастают с увеличением числа итераций. Если не удалось получить чрезвычайно быструю сходимость - затраты будут очень высокими. Основной способ преодолеть это ограничение - это перезапуск итерации. После выбранного числа итераций <math> m </math> накопленные данные будут очищены и промежуточные результаты используются в качестве входных данных для последующих итераций. Эта процедура повторяется до тех пор, пока сходимость не будет достигнута. Трудность заключается в выборе подходящего значения <math> m </math>. Если <math> m </math> слишком мало, <math>GMRES(m)</math> может быть медленно сходиться, или не сойтись совсем. Значение <math> m </math>, большее, чем это необходимо, включает в себя чрезмерную работы и использует больше памяти. К сожалению, нет определенных правил, регулирующих выбор <math> m </math>; выбирая , когда делать перезапуск - это вопрос опыта.

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

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

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

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

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

Масштабируемость рассматривалась в работах <ref>https://arxiv.org/pdf/1606.08740.pdf</ref> и <ref>https://smartech.gatech.edu/bitstream/handle/1853/55635/PRATAPA-DISSERTATION-2016.pdf</ref>.
Для исследования масштабируемости была использована параллельная реализация с использованием объекта KSP(решатель СЛАУ) бибилиотеки PETSc(содержащей структуры, типы данных и подпрограммы для параллельной реализации методов на подпространствах Крылова), найденная на GitHub <ref>https://github.com/erdc-cm/petsc-dev/tree/master/src/ksp/ksp/impls/gmres</ref>.

Вычисления проводились на вычислительном кластере, состоящем из 16 узлов, со следующей конфигурацией:
Altus 1804i Server - 4P Interlagos Node, Quad AMD Opteron 6276, 16C,
2.3 GHz, 128GB, DDR3-1333 ECC, 80GB SSD, MLC, 2.5" HCA, Mellanox ConnectX 2, 1-port QSFP, QDR, memfree, CentOS, Version 5.

На рис. 2 представлен график сильной масштабируемости.

[[File:scaling.JPG|thumb|center|500px|'''Рис. 2''' Зависимость производительности от числа процессоров (запуск производился на 1, 8, 27, 64, 216, 512, 1000 процессорах)]]

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

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

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

Реализации алгоритма GMRES присутствуют во многих программных пакетах:
* [http://www.netlib.org/linpack/ LINPACK]
* [http://math.nist.gov/tnt/download.html/ JAMA/C++]
* [http://math-atlas.sourceforge.net/ ATLAS]
* [http://software.intel.com/mkl‎/ Intel MLK]
* [http://math.nist.gov/iml++/ IML++]
* [http://netlib.org/lapack/ LAPACK]
* [http://osl.iu.edu/research/mtl/ MTL]
* [http://www-users.cs.umn.edu/~saad/software/SPARSKIT/ SPARSKIT]
* [http://researcher.watson.ibm.com/researcher/view_group.php?id=1426 WSMP]

= Литература =
<references \>

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

2016-11-30T16:09:49Z

Dan:

Участник:Obirvalger/Метод рекурсивной координатной бисекции

2016-11-29T08:39:29Z

Dan:

{{Assignment|Dan}}
{{algorithm
| name = Рекурсивная координатная бисекция
| serial_complexity = <math>O(n \log_2{n} \log_2{k})</math>
| pf_height = <math>\log_2{k}</math>
| pf_width = <math>k</math>
| input_data = <math>N|V| + |G|</math>
| output_data = <math>|V|</math>
}}

Авторы: [[Участник:Obirvalger|Гордеев Михаил]] (разделы 1.4, 1.6, 1.8, 1.10, 2.1, 2.4), [[Участник:KolmakovEA|Колмаков Евгений]] (разделы 1.1, 1.2, 1.3, 1.5, 1.7, 1.9, 2.1, 2.4, 2.7).

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

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

=== Задача декомпозиции графа ===
'''Метод рекурсивной координатной бисекции''' является одним из методов, применяемых для декомпозиции графов <ref>Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2012. – 328 с., илл. – (Серия «Суперкомпьютерное образование»), ISBN 978-5-211-06382-2 URL: http://lira.imamod.ru/ITTPMOPS/</ref>. В прикладных задачах, как правило, граф
представляет собой сетку в пространстве некоторой размерности. При численном решении задач механики сплошной среды с помощью методов конечных разностей или конечных элементов широко используется геометрический параллелизм, при котором сетка, покрывающая расчётную область, разбивается на множество доменов, каждый из которых обрабатывается отдельным процессором. Основная проблема связана с необходимостью решения задачи статистической балансировки загрузки, то есть равномерного распределения вычислительной нагрузки между процессорами за счёт выбора оптимальной декомпозиции сетки.

=== Критерии декомпозиции ===
В зависимости от специфики решаемой задачи, к виду декомпозиции графов могут быть предъявлены разные требования. Существует много критериев декомпозиции, однако наиболее классическим из них считается минимизация максимального веса исходящих из домена ребёр (в простейшем случае - минимизация числа разрезанных ребер). Среди других критериев можно выделить следующие:
* выделение обособленных доменов;
* минимизация максимальной степени доменов;
* обеспечение связности доменов;
* обеспечение связности множества внутренних узлов доменов.

=== Метод рекурсивной бисекции ===
Метод рекурсивной координатной бисекции является частным случаем более общего '''метода рекурсивной бисекции'''. В этом методе сетка последовательно за <math>k-1</math> шаг делится на <math>k</math> частей. На первом шаге сетка делится на две части, далее каждая из полученных ранее частей также делится на две части и т.п. Конкретные алгоритмы деления сетки на две части (бисекции) и определяют метод рекурсивной бисекции. Соотношение размеров частей зависит количества доменов и процедуры вычисления желаемого числа вершин в каждой из формируемых частей графа.

=== Метод рекурсивной координатной бисекции ===
Для декомпозиции больших сеток применяют параллельные алгоритмы, предполагающие, что сетка уже распределена по процессорным узлам. Они эффективны, только если вершины распределены по процессорам компактными группами, а не произвольно. Однако к моменту начала работы алгоритмов декомпозиции, никакая декомпозиция сетки еще не найдена, поэтому требуется некоторый простой способ предварительного распределения графа по выполняющим декомпозицию процессорам. Для решения этой задачи и используется метод рекурсивной покоординатной бисекции. Несмотря на то, что он уступает по качеству формируемой декомпозиции некоторым другим методам, его целесообразно использовать на предварительном этапе, благодаря скорости работы, ориентированности на распределенную обработку и простоте.

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

=== Выбор координатной оси ===
В зависимости от [[#Критерии декомпозиции|критериев декомпозиции]] и других особенностей задачи могут быть использованы различные критерии выбора координатной оси вдоль, которой будет производится разбиение сетки на две части. Наиболее используемыми являются следующие:
* Протяжённость области вдоль данной оси: для каждой оси вычисляется разность между максимумом и минимумом координат вершин сетки по данной оси, и выбирается ось с наибольшим значением этой величины;
* Число разрезанных ребер при разбиении сетки вдоль данной оси: вершины упорядочиваются вдоль каждой из осей, и выбирается тот вариант, который приводит к наименьшему числу разрезанных ребер;

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

Исходные данные: граф <math>G = (V, E) </math>, вложенный в <math>\mathbb{R}^N</math> (то есть каждая вершина этого графа - это точка в <math>N</math> мерном пространстве), и число <math>k</math> доменов, на которое нужно разбить граф.
Под ''декомпозицией'' графа на <math>k</math> доменов понимается разбиение множества вершин <math>V</math> на <math>k</math> подмножеств <math>V_1, \dots, V_k</math> таких, что

<center><math>V = \bigcup_{i = 1}^k V_i</math> и <math>V_i \cap V_j = \varnothing</math> при <math>i \neq j</math>.</center>

С каждым доменом можно связать порождённый им подграф <math>G(V_i) = (V_i, E_i)</math>, где <math>E_i \subseteq E</math> - множество рёбер, оба конца которых принадлежат домену.

Задача заключается в нахождении декомпозиции <math>V_1, \dots, V_k</math>, доставляющей минимум некоторого функционала (см. [[#Критерии декомпозиции| соответствующий пункт]]), например, числа разрезанных рёбер <math>E_{\mbox{cut}} = |\{(u, v) \in E \mid u \in V_i, v \in V_j, i \neq j\}| = |E| - \sum_{i = 1}^k |E_i|</math>.

Дадим формальное описание алгоритма. Как уже упоминалось, метод основан на алгоритме рекурсивной бисекции, поэтому представляет собой рекурсивную процедуру, на вход которой поступает граф <math>G = (V, E) </math> и число доменов <math>k</math>, на которое нужно разбить множество вершин данного графа. Внутри этой процедуры выполняется следующая последовательность действий:
* в зависимости от числа доменов вычисляется "желаемое" число доменов и вершин в каждой из частей разбиения;
* вызывается процедура координатной бисекции для получения разбиения графа на две части;
* для каждой из двух полученных частей рекурсивно вызывается описываемая процедура (если число доменов для этой части больше единицы).

Процедура координатной бисекции устроена следующим образом:
* [[#Выбор координатной оси| выбирается]] координатная ось <math>m^* \in \{1, \dots, N\}</math>;
** в случае максимизации протяженности: для каждой оси <math>m</math> вычисляется величина <math>l_m = \max_{v \in V} v_m - \min_{v \in V} v_m</math>, и выбирается ось <math>m^* = \arg\max_{m \in \{1, \dots, N\}} l_m</math>;
** в случае минимизации числа разрезанных ребер: вершины упорядочиваются вдоль каждой из осей, для каждой оси вычисляется величина <math>E^m_{\mbox{cut}}</math>, равная числу разрезанных ребер при разбиении вдоль данной оси, и выбирается ось <math>m^* = \arg\max_{m \in \{1, \dots, N\}} E^m_{\mbox{cut}}</math>;
* множество вершин сортируется по возрастанию координаты с номером <math>m^*</math>;
* отсортированный массив вершин делится на две (непрерывные) части в соответствии с желаемым числом вершин в каждой из частей;
**как правило, выбирается индекс <math>i = \lfloor\frac{k+1}{2k}\rfloor \cdot |V|</math>, соответствующий примерно равному разделению текущего графа на части;
* первая часть состоит из вершин <math>v \in V</math> с индексами <math>j \leqslant i</math>, вторая - с индексами <math>j > i</math>.

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма составляют сортировки массива вершин сетки по выбранной координате при каждом из <math>k - 1</math> вызовов процедуры бисекции.

Также, в зависимости от критерия выбора координатной оси, требуются дополнительные вычисления:
*В случае максимизации протяженности при каждом вызове требуется вычисление величины <math>l_m</math>.
*В случае минимизации числа разрезанных ребер при каждом вызове требуется сортировка по каждой из координат (таким образом, при каждом разбиении осуществляется <math>N</math> сортировок).

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют множественные (всего <math>k-1</math>) сортировки (функция argsort в коде в [[#Схема реализации последовательного алгоритма |следующем разделе]]).

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

Опишем последовательную реализацию метода рекурсивной координатной бисекции, где выбор оси производится исходя из условия максимизации протяженности вдоль этой оси. Ниже представлен код данного алгоритма на языке Python 3.

<source lang="python">
# Переменная для хранения результата работы алгоритма
partition = []

# V - numpy.ndarray размера |V| x N, k - число доменов
def recursive_bisection(V, k):

global partition

# Если текущая часть графа есть домен, добавляем ее к результату разбиения
if (k <= 1):
partition.append(V)
return

# Вычисляем количество доменов в каждой из частей
k1 = (k + 1) / 2
k2 = k - k1

# Производим разбиение
V1, V2 = bisect(V, k)

# Рекурсивно разбиваем каждую из частей
recursive_bisect(V1, k1)
recursive_bisect(V2, k2)

def bisect(V, k):
# Вычисляем координату с наибольшей протяженностью
t = V.max(axis=0) - V.min(axis=0)
m = t.argmax()

# Сортируем вершины по координате с номером m
V_sorted = V[V[:, m].argsort()]

# Вычисляем индекс для разбиения в соответствии с числом доменов
ind = (k + 1) * V.shape[0] // (2 * k)

return V_sorted[:ind, :], V_sorted[ind:, :]
</source>

Приведённый код предназначен для более подробного описания основных шагов в алгоритме, представляет собой лишь схему и не является максимально эффективным. Это сделано для того, чтобы код был более наглядным. В более эффективной реализации, например, вместо создания массивов в процедуре bisect можно везде оперировать только индексами.

== Последовательная сложность алгоритма ==
Обозначим через <math>D_k(n)</math> сложность алгоритма рекурсивной координатной бисекции для декомпозиции графа с <math>n</math> вершинами на <math>k</math> доменов.

Определим величину <math>D(n) = D_n(n)</math>. Для <math>D(n)</math> имеет место следующее рекуррентное равенство:

<center>
<math>
\begin{array}{l}
D(n) = S(n) + 2D(\frac{n}{2}) \\
D(1) = S(1) = 0. \\
\end{array}
</math>, где <math>S(n)</math> - это сложность алгоритма сортировки массива из <math>n</math> элементов.
</center>

Пусть <math>S(n) = O(n\log_2{n})</math> (например, для сортировки слиянием), тогда по теореме о рекуррентных соотношениях <ref>https://ru.wikipedia.org/wiki/Основная_теорема_о_рекуррентных_соотношениях</ref> для произвольного положительного <math>\varepsilon</math> имеет место оценка <math>D(n) \lesssim n^{1+\varepsilon}</math>.

Величину <math>D_k(n)</math> можно явно посчитать по формуле <math>\sum\limits_{i=0}^{\lceil\log_2{k}\rceil}2^i S(\frac{n}{2^i})</math>. Если использовать сортировку со сложностью <math>S(n) = O(n\log_2{n})</math>, то
<center>
<math>D_k(n) = </math> <math>O(\sum\limits_{i=0}^{\lceil\log_2{k}\rceil}2^i \frac{n}{2^i} \log_2{\frac{n}{2^i}}) = </math> <math>O(n\log_2(\prod\limits_{i=0}^{\lceil\log_2{k}\rceil}\frac{n}{2^i})) = </math> <math>O(n\log_2{\frac{n^{\log_2{k}}}{2^\frac{\log_2{k}(\log_2{k}+1))}{2}}}) =</math> <math> O(n(\log_2{n}\log_2{k} - \frac{\log^2_2{k}}{2})) = </math> <math>O(n\log_2{n}\log_2{k})</math>.
</center>

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

Под операцией в данном пункте будем понимать макрооперацию сортировки. Передача данных происходит после разбиения множества вершин на две части.
Таким образом, информационный граф представляет из себя бинарное дерево с <math>k</math> листьями. На рисунке ниже приведена часть информационного графа для <math>k = 16</math>. Зависимость от числа вершин <math>n</math> учитывается в самих узлах дерева.

<center>
[[Файл:Tree_sort.svg|thumb|center|800px|Рисунок 1. Граф алгоритма.]]
</center>

Высота ярусно-параллельной формы - <math>\log_2{k}</math>.

Ширина ярусно-параллельной формы - <math>k</math>.

Если рассматривать более мелкие операции, используемые в процессе сортировки, то глобально информационный граф будет выглядеть также, однако каждый
узел будет заменён на информационный граф используемого алгоритма сортировки (или <math>N</math> таких графов, если используется критерий минимизации числа разрезов).

== Ресурс параллелизма алгоритма ==
Данный алгоритм обладает координатным параллелизмом.
Для декомпозиции графа с <math>n</math> вершинами на <math>k</math> доменов методом рекурсивной координатной бисекции в параллельном варианте требуется последовательно выполнить <math>\lceil\log_2{k}\rceil</math> ярусов. На <math>i</math>-ом ярусе будет выполнятся <math>2^i</math> операций сортировки.
Рассмотрим два случая распараллеливания нашего алгоритма:
* Параллельное выполнение операций на каждом ярусе с использованием последовательного алгоритма сортировки со сложностью <math>O(n\log_2{n})</math>.
# На первом шаге один процессор производит сортировку всех вершин, разделяет граф на два подграфа и передает однин из подрафов новому процессору.
# На <math>i</math>-ом шаге каждый из уже получивший свой граф процессор производит сортировку всех вершин, разделяет граф на два подграфа и передает однин из подрафов новому процессору.

Тогда сложность нашего алгоритма равна:
<center>
<math>D_k(n) = O(\sum\limits_{i=0}^{\lceil\log_2{k}\rceil}\frac{n}{2^i} \log_2{\frac{n}{2^i}}) = </math> <math>n\sum\limits_{i=0}^{\lceil\log_2{k}\rceil}(\frac{\log_2{n}}{2^i} - \frac{i}{2^i}) = </math> <math>O(n\log_2{n}) - O(n) = O(n\log_2{n})</math>.
</center>

*Параллельное выполнение операций на каждом ярусе с использованием параллельного алгоритма сортировки со сложностью <math>O(\log_2^2{n})</math><ref>https://en.wikipedia.org/wiki/Batcher_odd–even_mergesort</ref>.
На каждом шаге производится параллельная сортировка вершин и разбиение графа на два подграфа.
В этом случае

<center>
<math>D_k(n) = \sum\limits_{i=0}^{\lceil\log_2{k}\rceil}\log^2_2\frac{n}{2^i} = O(\log^2_2{n}\log_2{k}) = O(\log^3_2{n})</math>.
</center>
Известно <ref>https://en.wikipedia.org/wiki/Sorting_algorithm</ref>, что оптимальная параллельная сортировка имеет сложность <math>O(\log_2{n})</math>. В этом случае
<center>
<math>D_k(n) = \sum\limits_{i=0}^{\lceil\log_2{k}\rceil}\log_2\frac{n}{2^i} = O(\log_2{n}\log_2{k})</math>.
</center>

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

'''Входные данные:''' граф <math>G = (V, E) </math>, вложенный в <math>\mathbb{R}^N</math>, и число <math>k</math> частей (доменов), на которое нужно разбить граф. Таким образом, помимо матрицы смежности (или любого другого представления графа) для каждой вершины <math>v \in V</math> задан набор её координат <math>v = (v_1, \dots, v_N) \in \mathbb{R}^N</math>, поэтому <math>V</math> задаётся массивом <math>N</math>-мерных векторов или матрицей размера <math>|V| \times N</math>.

'''Объём входных данных:''' <math>N|V| + |G|</math>, где <math>|G|</math> - объём данных, представляющих граф <math>G</math>, который в общем случае зависит от выбранного представления.

'''Выходные данные:''' <math>k</math> доменов графа <math>G</math>, задающих его декомпозицию.

'''Объём выходных данных:''' <math>|V|</math> - для каждого домена достаточно хранить соответствующие вершинам из этого домена индексы строк в матрице, представляющей множество вершин.

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности в случае неограниченных ресурсов является ''линейным'' (отношение <math>O(n\log{n})</math> к <math>O(\log{n}))</math>.

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

Так как количество вершин на разных процессорах примерно одинаковое алгоритм является сбалансированным по числу операций на каждом процессоре.

Алгоритм достаточно прост и легко модифицируется в зависимости от критерия декомпозиции.

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

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

Ниже приведен пример реализации последовательного алгоритма на языке C++. Следует отметить, что исходный массив вершин не изменяется, вся работа осуществляется с индексами.
<source lang = "c++">
#include <algorithm>
#include <iostream>
#include <vector>

using namespace std;

#define N 5
#define M 5
#define STEP 0.01

#define N_DIMS 2
#define N_DOMAINS 6

vector<vector<double> > points_matrix(N_DIMS, vector<double>(N * M));
vector<vector<int> > graph_partition;

double span(vector<double> x, vector<int> idx)
{
double max_value = x[idx[0]];
double min_value = x[idx[0]];

for (size_t i = 1; i < idx.size(); i++) {
max_value = (x[idx[i]] > max_value) ? x[idx[i]] : max_value;
min_value = (x[idx[i]] < min_value) ? x[idx[i]] : min_value;
}

return max_value;
}

vector<int> bisect(vector<int> idx)
{
double max_span = 0;
double max_ind = 0;

// finding coordinate with maximal span
for (size_t i = 0; i < points_matrix.size(); i++) {
double cur_span = span(points_matrix[i], idx);
if (cur_span > max_span) {
max_span = cur_span;
max_ind = i;
}
}

// sorting vertices along this coordinate
sort(idx.begin(), idx.end(), [&](const int& a, const int& b) {
return points_matrix[max_ind][a] < points_matrix[max_ind][b];
});

return idx;
}

void recursive_bisection(vector<int> idx, int k)
{
// adding current domain to partition
if (k < 2) {
graph_partition.push_back(idx);
return;
}

int k1 = (k + 1) / 2;
int k2 = k - k1;

// bisecting current graph
vector<int> sorted_idx1 = bisect(idx);
vector<int> sorted_idx2(make_move_iterator(sorted_idx1.begin() + k1 * sorted_idx1.size() / k),
make_move_iterator(sorted_idx1.end()));
sorted_idx1.erase(sorted_idx1.begin() + k1 * sorted_idx1.size() / k, sorted_idx1.end());

recursive_bisection(sorted_idx1, k1);
recursive_bisection(sorted_idx2, k2);
}

int main()
{
// example: uniform MxN-mesh
for(size_t i = 0; i < N; ++i)
for(size_t j = 0; j < M; ++j) {
points_matrix[0][M * i + j] = i * STEP;
points_matrix[1][M * i + j] = j * STEP;
}

vector<int> idx(M * N);
iota(idx.begin(), idx.end(), 0);

recursive_bisection(idx, K);

// partitioning results
for(size_t i = 0; i < graph_partition.size(); ++i) {
for(size_t j = 0; j < graph_partition[i].size(); ++j)
cout << graph_partition[i][j] << " ";
cout << endl;
}
}
</source>

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

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

== Масштабируемость алгоритма и его реализации ==
Эксперименты проводились на компьютере с четырехъядерным процессором Intel Core i7 3610QM 2300 Mhz, который поддерживает до 8 потоков и оперативной памятью типа DDR3 1600 МГц размером 8 Gb.

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число потоков от 1 до 8 с шагом 1;
* размер сетки N x N, n от 500 до 2000 с шагом 500;
* число доменов k 100 и от 2000 до 10000 с шагом 1000;

<center>
[[Файл:Perf_500.svg|thumb|center|800px|Рисунок 2. График производительности на сетке 500 x 500.]]
</center>

<center>
[[Файл:Perf_1000.svg|thumb|center|800px|Рисунок 3. График производительности на сетке 1000 x 1000.]]
</center>

<center>
[[Файл:Perf_1500.svg|thumb|center|800px|Рисунок 4. График производительности на сетке 1500 x 1500.]]
</center>

<center>
[[Файл:Perf_2000.svg|thumb|center|800px|Рисунок 5. График производительности на сетке 2000 x 2000.]]
</center>

<center>
[[Файл:Eff_500.svg|thumb|center|800px|Рисунок 6. График эффективности на сетке 500 x 500.]]
</center>

<center>
[[Файл:Eff_1000.svg|thumb|center|800px|Рисунок 7. График эффективности на сетке 1000 x 1000.]]
</center>

<center>
[[Файл:Eff_1500.svg|thumb|center|800px|Рисунок 8. График эффективности на сетке 1500 x 1500.]]
</center>

<center>
[[Файл:Eff_2000.svg|thumb|center|800px|Рисунок 9. График эффективности на сетке 2000 x 2000.]]
</center>

[http://pastebin.com/hCqz7vBU Параллельная реализация алгоритма на языке C++]

В статье <ref>http://glaros.dtc.umn.edu/gkhome/node/112</ref> приводятся результаты работы алгоритма декомпозиции графов из пакета ParMETIS. В таблице ниже приведено время работы алгоритма в зависимости от числа вершин в графе и используемого числа процессоров. Рассмотравились следующие графы:
граф mrng2 с 1 миллионом вершин, mrng3 с 4 миллионами и граф mrgn4 с 7.5 миллионами вершин.

{| class="wikitable"
|+ Время выполнения разбиения графа с использованием Parmetis
|-
! Graph
! 8 processors
! 16 processors
! 32 processors
! 64 processors
! 128 processors
|-
| mrng2
| 5.4
| 3.1
| 2.1
| 1.5
| 1.7
|-
| mrng3
| 15.8
| 8.8
| 4.8
| 3.0
| 2.7
|-
| mrng4
| 38.6
| 16.2
| 8.8
| 5.0
| 3.6
|}

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

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

== Существующие реализации алгоритма ==
Описанный алгоритм реализован во многих пакетах декомпозиции графов, включающих в себя и другие версии алгоритма бисекции.

Последовательная версия алгоритма реализована в пакетах Chaco, JOSTLE, [http://glaros.dtc.umn.edu/gkhome/metis/metis/overview METIS], [https://www.labri.fr/perso/pelegrin/scotch/ SCOTCH].

Параллельная версия реализована в пакетах JOSTLE, [http://glaros.dtc.umn.edu/gkhome/metis/parmetis/overview ParMETIS], [https://www.labri.fr/perso/pelegrin/scotch/ PT-SCOTCH].

Стоит отметить, что пакеты METIS и ParMETIS распространяются свободно.

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

[[en:Recursive coordinate bisection method]]

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

2016-11-29T08:39:19Z

Dan: /* Пункт 2.4 */

= Пункт 2.4 =
'''принято'''

Участник:Lvs/Итерационный метод решения системы линейных алгебраических уравнений GMRES

2016-11-23T11:03:44Z

Dan:

{{Assignment|Dan}}
= Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Итерационный метод решения системы линейных алгебраических уравнений GMRES (или обобщенный метод минимальных невязок) используется для решения систем линейных алгебраических уравнений с заданной точностью приближения. Метод основан на процессе Арнольди, посредством которого матрица СЛАУ приводится к (верхней) хессенберговой форме.

== Математическое описание алгоритма ==
Дана система линейных алгебраических уравнений <math>Ax = b</math>, где <math>A</math> - квадратная матрица размера <math>n \times n</math>.

Вычисляется последовательность приближённых решений уравнения <math> x_m </math>, которая сходится к точному решению уравнения <math>x^*</math>.

Подпространство Крылова размерности <math>m</math>, порожденное вектором <math>b</math> и матрицей <math>A</math> – линейное пространство
<math>K_m(A, v)</math>, являющееся линейной оболочкой векторов <math>b, Ab, A^2b, ..., A^{m-1}b</math>.

Приближённое решение считается по формуле <math> x_m = Q_my_m</math>, где <math>Q_m</math> - матрица размера <math>n \times m</math>, составленная из векторов ортонормированного базиса пространства <math>K_m(A, v)</math>, <math>y_m \in \mathbb{R}^m</math>.

Итоговым считается решение, минимизирующее норму невязки (<math>||r||_2 = ||b - Ax_m||_2</math>) с заданной точностью.

Для вычисления векторов ортонормированного базиса используется алгоритм Арнольди:
<source>
q[1] = b/||b||
for j = 1, ..., n-1 do
z = Aq[j]; //очередной вектор
for i = 1,..., j do
h[i][j] = (z, q[i]);
z = z − h[i][j]q[i];
end i
h[j+1][j] = ||z||;
if (h[j+1][j] == 0) break;
q[j+1] = z/h[j+1][j];
end j
</source>
Сложность алгоритма <math>O(n^2)</math>.

На каждом шаге алгоритма получаются векторы <math>q_1, q_2, ..., q_m</math>, являющиеся ортонормированным базисом Крыловского пространства <math>K_m(A, b)</math>.

Значения <math>h_{i,j}</math> образуют верхнюю матрицу Хессенберга (обозначим как <math>H_m</math>, размерность <math>m+1 \times m</math>).

<math>H_k = \begin{bmatrix}h_{11} & h_{12} & h_{13} &... & h_{1m-1} & h_{1m} \\ h_{21} & h_{22} & h_{23} & ... & h_{2m-1} & h_{2m} \\ 0 & h_{32} & h_{33} &...& h_{3m-1} & h_{3m} \\ ... & ... & ... & ... & ... & ... \\ 0 & 0 & 0 & ... & h_{m m-1} & h_{mm} \\0 & 0 & 0 & ... & 0 & h_{m+1 m}\end{bmatrix}</math>.

Вектор невязки задан уравнением <math>r_m = H_my_m - ||b - Ax_0||e_1</math>, где <math>x_0</math> - вектор начального приближения. Минимизация второй нормы вектора невязки представляет из себя решение линейной задачи минимальных квадратов размера <math>n</math>.

Приближённое решение вычисляется по формуле <math> x_m = Q_my_m</math> после нахождения соответствующего значения минимизирующего вторую невязку вектора. Сложность вычислений <math>O(nm)</math>
== Вычислительное ядро алгоритма ==
Самая трудоёмкая и самая часто вызываемая операция в алгоритме - умножение матрицы на вектор. В первую очередь это связано с вычислением матрицы Хессенберга.
== Макроструктура алгоритма ==
# Алгоритм Арнольди
# Решение линейной задачи минимальных квадратов
# Вычисление решения
== Схема реализации последовательного алгоритма ==
<source>
Вычислить ортонормированный базис размера m
Вычислить минимальное приближение
if (приближение < заданная точность)
Вычислить результат
return;
else
Повторить для m = m+1
</source>
== Последовательная сложность алгоритма ==
Сложность вычислений собственных векторов на каждом шаге - <math>O(n^2)</math>, но может уменьшиться до <math>O(n)</math> при более разреженной матрице.

Сложность решения задачи минимальных квадратов <math>O(m^2)</math>, но при последовательном выполнении алгоритма можно понизить сложность до <math>O(m)</math> путём использования подсчитанных на прошлых итерациях значений.

Сложность вычисления решения <math>O(nm)</math>, поэтому его целесообразно вычислять только в конце.
== Информационный граф ==
Основной ресурс параллелизма - умножение матрицы на вектор. Для этой операции информационный граф представлен на рисунке.

[[file:GraphLvs2FM.jpg|thumb|center|700px|Рис.1. Информационный граф умножения матрицы на вектор]]

== Ресурс параллелизма алгоритма ==
# Параллельное умножение матрицы на вектор выполняется в <math> n </math> ярусов умножений и сложений.
# Шаги алгоритма Арнольди выполняются строго последовательно, однако последующее нахождение невязки можно выполнять параллельно с запуском следующего шага алгоритма.
# Сложность решения задачи минимальных квадратов зависит от используемого алгоритма. В отличие от последовательного метода данные, полученные на прошлых шагах здесь использовать нельзя.
# Вычисление результата выполняется один раз, его можно выполнить параллельно в <math> n </math> ярусов умножений и сложений.

== Входные и выходные данные алгоритма ==
'''Входные данные:''' Матрица <math>A</math>, вектор <math>b</math>, точность <math>t</math>. Объём: <math>n^2 + n + 1</math>

'''Выходные данные:''' Вектор <math>x_m</math>. Объём: <math>n</math>

== Свойства алгоритма ==
Теоретически на каждой итерации алгоритма сложность вычислений составляет <math>n + X</math> операций умножения, где <math>X</math> - сложность алгоритма для решения задачи минимальных квадратов. Таким образом в худшем случае сложность будет примерно равна <math>n^2 + X*n + n</math> операций умножения.

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

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

== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
Для исследования масштабируемости алгоритма была использована параллельная реализация, найденная на просторах GitHub<ref>Parallel GMRES Algorithm for Solving Giant Sparse System of Linear Equations https://github.com/arrgasm/paraGMRES/</ref>. Программа была запущена на суперкомпьютере BlueGene на разреженной матрице размера 90448х90448. Параметрами запуска являются 100 итераций алгоритма и 10 перезапусков алгоритм (повторный запуск алгоритма с использованием решения, полученного на предыдущем запуске, в качестве начального приближения). График зависимости времени выполнения от числа процессоров представлен на рисунке 2.
[[file:PlotLvs1.png|thumb|center|400px|Рис 2. График зависимости времени выполнения от числа процессоров]]
График эффективности для полученного времени выполнения указан на рисунке 3.
[[file:PlotLvs2.png|thumb|center|400px|Рис 3. График зависимости эффективности реализации от числа процессоров]]
Параметры компиляции:
<code>mpixlc_r -qsmp=omp -O3</code>

Параметры запуска:
<code>gmres mat.mtx void 100 0 10</code>

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Реализации алгоритма GMRES присутствуют во многих программных продуктах как части стандартных библиотек, например Matlab или DEFORM3D. Также существую отдельные библиотеки, например MGMRES для языка С++.

= Литература =
[1] Тыртышников Е. Е. Методы численного анализа — М., Академия, 2007.

[2] М. Дана, А. Г. Зыков, Х. Д. Икрамов Метод минимальных невязок для специального класса линейных систем с нормальными матрицами коэффициентов - Ж. вычисл. матем. и матем. физ., 2005, том 45, номер 11

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

2016-11-23T11:03:32Z

Dan:

Участник:Lvs/Итерационный метод решения системы линейных алгебраических уравнений GMRES

2016-11-22T13:42:00Z

Dan:

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Итерационный метод решения системы линейных алгебраических уравнений GMRES (или обобщенный метод минимальных невязок) используется для решения систем линейных алгебраических уравнений с заданной точностью приближения. Метод основан на процессе Арнольди, посредством которого матрица СЛАУ приводится к (верхней) хессенберговой форме.

== Математическое описание алгоритма ==
Дана система линейных алгебраических уравнений <math>Ax = b</math>, где <math>A</math> - квадратная матрица размера <math>n \times n</math>.

Вычисляется последовательность приближённых решений уравнения <math> x_m </math>, которая сходится к точному решению уравнения <math>x^*</math>.

Подпространство Крылова размерности <math>m</math>, порожденное вектором <math>b</math> и матрицей <math>A</math> – линейное пространство
<math>K_m(A, v)</math>, являющееся линейной оболочкой векторов <math>b, Ab, A^2b, ..., A^{m-1}b</math>.

Приближённое решение считается по формуле <math> x_m = Q_my_m</math>, где <math>Q_m</math> - матрица размера <math>n \times m</math>, составленная из векторов ортонормированного базиса пространства <math>K_m(A, v)</math>, <math>y_m \in \mathbb{R}^m</math>.

Итоговым считается решение, минимизирующее норму невязки (<math>||r||_2 = ||b - Ax_m||_2</math>) с заданной точностью.

Для вычисления векторов ортонормированного базиса используется алгоритм Арнольди:
<source>
q[1] = b/||b||
for j = 1, ..., n-1 do
z = Aq[j]; //очередной вектор
for i = 1,..., j do
h[i][j] = (z, q[i]);
z = z − h[i][j]q[i];
end i
h[j+1][j] = ||z||;
if (h[j+1][j] == 0) break;
q[j+1] = z/h[j+1][j];
end j
</source>
Сложность алгоритма <math>O(n^2)</math>.

На каждом шаге алгоритма получаются векторы <math>q_1, q_2, ..., q_m</math>, являющиеся ортонормированным базисом Крыловского пространства <math>K_m(A, b)</math>.

Значения <math>h_{i,j}</math> образуют верхнюю матрицу Хессенберга (обозначим как <math>H_m</math>, размерность <math>m+1 \times m</math>).

<math>H_k = \begin{bmatrix}h_{11} & h_{12} & h_{13} &... & h_{1m-1} & h_{1m} \\ h_{21} & h_{22} & h_{23} & ... & h_{2m-1} & h_{2m} \\ 0 & h_{32} & h_{33} &...& h_{3m-1} & h_{3m} \\ ... & ... & ... & ... & ... & ... \\ 0 & 0 & 0 & ... & h_{m m-1} & h_{mm} \\0 & 0 & 0 & ... & 0 & h_{m+1 m}\end{bmatrix}</math>.

Вектор невязки задан уравнением <math>r_m = H_my_m - ||b - Ax_0||e_1</math>, где <math>x_0</math> - вектор начального приближения. Минимизация второй нормы вектора невязки представляет из себя решение линейной задачи минимальных квадратов размера <math>n</math>.

Приближённое решение вычисляется по формуле <math> x_m = Q_my_m</math> после нахождения соответствующего значения минимизирующего вторую невязку вектора. Сложность вычислений <math>O(nm)</math>
== Вычислительное ядро алгоритма ==
Самая трудоёмкая и самая часто вызываемая операция в алгоритме - умножение матрицы на вектор. В первую очередь это связано с вычислением матрицы Хессенберга.
== Макроструктура алгоритма ==
# Алгоритм Арнольди
# Решение линейной задачи минимальных квадратов
# Вычисление решения
== Схема реализации последовательного алгоритма ==
<source>
Вычислить ортонормированный базис размера m
Вычислить минимальное приближение
if (приближение < заданная точность)
Вычислить результат
return;
else
Повторить для m = m+1
</source>
== Последовательная сложность алгоритма ==
Сложность вычислений собственных векторов на каждом шаге - <math>O(n^2)</math>, но может уменьшиться до <math>O(n)</math> при более разреженной матрице.

Сложность решения задачи минимальных квадратов <math>O(m^2)</math>, но при последовательном выполнении алгоритма можно понизить сложность до <math>O(m)</math> путём использования подсчитанных на прошлых итерациях значений.

Сложность вычисления решения <math>O(nm)</math>, поэтому его целесообразно вычислять только в конце.
== Информационный граф ==
Основной ресурс параллелизма - умножение матрицы на вектор. Для этой операции информационный граф представлен на рисунке.

[[file:GraphLvs2FM.jpg|thumb|center|700px|Рис.1. Информационный граф умножения матрицы на вектор]]

== Ресурс параллелизма алгоритма ==
# Параллельное умножение матрицы на вектор выполняется в <math> n </math> ярусов умножений и сложений.
# Шаги алгоритма Арнольди выполняются строго последовательно, однако последующее нахождение невязки можно выполнять параллельно с запуском следующего шага алгоритма.
# Сложность решения задачи минимальных квадратов зависит от используемого алгоритма. В отличие от последовательного метода данные, полученные на прошлых шагах здесь использовать нельзя.
# Вычисление результата выполняется один раз, его можно выполнить параллельно в <math> n </math> ярусов умножений и сложений.

== Входные и выходные данные алгоритма ==
'''Входные данные:''' Матрица <math>A</math>, вектор <math>b</math>, точность <math>t</math>. Объём: <math>n^2 + n + 1</math>

'''Выходные данные:''' Вектор <math>x_m</math>. Объём: <math>n</math>

== Свойства алгоритма ==
Теоретически на каждой итерации алгоритма сложность вычислений составляет <math>n + X</math> операций умножения, где <math>X</math> - сложность алгоритма для решения задачи минимальных квадратов. Таким образом в худшем случае сложность будет примерно равна <math>n^2 + X*n + n</math> операций умножения.

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

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

== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
Для исследования масштабируемости алгоритма была использована параллельная реализация, найденная на просторах GitHub<ref>Parallel GMRES Algorithm for Solving Giant Sparse System of Linear Equations https://github.com/arrgasm/paraGMRES/</ref>. Программа была запущена на суперкомпьютере BlueGene на разреженной матрице размера 90448х90448. Параметрами запуска являются 100 итераций алгоритма и 10 перезапусков алгоритм (повторный запуск алгоритма с использованием решения, полученного на предыдущем запуске, в качестве начального приближения). График зависимости времени выполнения от числа процессоров представлен на рисунке 2.
[[file:PlotLvs1.png|thumb|center|400px|Рис 2. График зависимости времени выполнения от числа процессоров]]
График эффективности для полученного времени выполнения указан на рисунке 3.
[[file:PlotLvs2.png|thumb|center|400px|Рис 3. График зависимости эффективности реализации от числа процессоров]]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Реализации алгоритма GMRES присутствуют во многих программных продуктах как части стандартных библиотек, например Matlab или DEFORM3D. Также существую отдельные библиотеки, например MGMRES для языка С++.

= Литература =
[1] Тыртышников Е. Е. Методы численного анализа — М., Академия, 2007.

[2] М. Дана, А. Г. Зыков, Х. Д. Икрамов Метод минимальных невязок для специального класса линейных систем с нормальными матрицами коэффициентов - Ж. вычисл. матем. и матем. физ., 2005, том 45, номер 11

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

2016-11-22T13:41:47Z

Dan:

= Пункт 1.2 =
Это определение пространства Крылова?
Не совсем понятно описание алгоритма, если не знаешь, о чем речь

= Пункт 1.3 =
Он достаточно длинный. Посмотрите описания готовых алгоритмов на алговики. Псевдокод здесь не читается, ядро должно лучше восприниматься

= Пункт 1.4 =
Если макроструктура это указанные 3 пункта, то нужно пояснить, почему именно пункт 1 является ядром. Он самый ресурсоемкий?

= Пункт 1.7 =
Почему это основной ресурс. Это основная операция в алгоритме? Требуются пояснения

= Пункт 2.4 =
[[Участник:Dan|Dan]] ([[Обсуждение участника:Dan|обсуждение]]) 14:16, 17 ноября 2016 (MSK) необходимо доработать:
Требования были такие:
- Реализация: полностью собственная или обращение к библиотечной функции (Intel MKL, PETSc, FFTW, ScaLAPACK). В любом случае, текст исследуемой программы должен быть представлен в отчете.
- Компьютерная платформа может быть любой (Ломоносов, BlueGene или что-то иное). Описание компьютерной платформы должно быть в отчете.
- Должен быть представлен график сильной масштабируемости (зависимости производительности от числа процессов; если при этом
ещё и зависимость от размера задачи - это только в плюс). График должен выглядеть пристойно и понятно, оси и единицы измерения должны быть подписаны. К графику обязательно должны быть словесные пояснения! Требовалось подобрать такие размеры задачи и числа процессоров, чтобы отразить на графике характерные точки, описывающие свойства алгоритма и программы.

'''В ПРОЦЕССЕ!'''

[[Участник:Dan|Dan]] ([[Обсуждение участника:Dan|обсуждение]]) 10:56, 21 ноября 2016 (MSK) приведите код, параметры компиляции

Реализация не моя, ссылку на GitHub с кодом я указал, что ещё надо?

[[Участник:Dan|Dan]] ([[Обсуждение участника:Dan|обсуждение]]) 16:41, 22 ноября 2016 (MSK) Укажите явно: 1) параметры компиляции и 2) строку запуска (комментарии в тексте оставьте)

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

2016-11-21T08:00:07Z

Dan:

Основной вопрос. Ядро это все-таки умножение матрицы или строки матрицы? Соответственно под это нужно подстраивать и остальной текст, потому что можно понять и так, и так.

= Пункт 2.4 =
[[Участник:Dan|Dan]] ([[Обсуждение участника:Dan|обсуждение]]) 14:17, 17 ноября 2016 (MSK) необходимо доработать:

Требования были такие:
- Реализация: полностью собственная или обращение к библиотечной функции (Intel MKL, PETSc, FFTW, ScaLAPACK). В любом случае, текст исследуемой программы должен быть представлен в отчете.
- Компьютерная платформа может быть любой (Ломоносов, BlueGene или что-то иное). Описание компьютерной платформы должно быть в отчете.
- Должен быть представлен график сильной масштабируемости (зависимости производительности от числа процессов; если при этом
ещё и зависимость от размера задачи - это только в плюс). График должен выглядеть пристойно и понятно, оси и единицы измерения должны быть подписаны. К графику обязательно должны быть словесные пояснения! Требовалось подобрать такие размеры задачи и числа процессоров, чтобы отразить на графике характерные точки, описывающие свойства алгоритма и программы.

[[Участник:Dan|Dan]] ([[Обсуждение участника:Dan|обсуждение]]) 11:00, 21 ноября 2016 (MSK)
- Приведите код, параметры компиляции.

- График построен по каким значениям?

- Укажите все параметры, при которой исследовалась задача: размер матрицы и т.д.

Участник:Lexaloris/Умножение разреженной матрицы на вектор

2016-11-21T07:56:59Z

Dan:

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>O(k)</math>
| pf_height = <math>O(m)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>k + m</math>
| output_data = <math>n</math>
}}

'''Авторы страницы:''' [[Участник:Lexaloris|A.Д. Новоселов]] и [[Участник:kochet|П.А. Кочетков]]

Кочетков Павел ответственен за программную реализацию алгоритма, Новоселов Алексей ответственен за оформление статьи.

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

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

=== Хранение ненулевых элементов разреженной матрицы ===

==== Разреженный строчной формат ====

Одной из наиболее широко используемых схем хранения разреженных матриц является ''разреженный строчный формат''. Эта
схема предъявляет минимальные требования к памяти и в то же время оказывается очень удобной для умножения разреженной матрицы на вектор.
Например, рассмотрим формат хранения разряженной матрицы <math>A</math>:

[[File:RRCOMatrix.png]]

Значения ненулевых элементов матрицы и соответствующие столбцовые индексы хранятся в этой схеме по строкам в двух массивах <math>AN</math> и <math>JA</math> соответственно. Используется также массив указателей <math>IA</math>, отмечающих позиции массивов <math>AN</math> и <math>JA</math>, с которых начинается описание очередной строки. Дополнительная компонента в <math>IA</math> содержит указатель первой свободной позиции в <math>JA</math> и <math>AN</math>.

Таким образом <math>A</math> представляется в виде:

IA = [ 1 4 4 6 ]
JA = [ 3 4 8 6 8 ]
AN = [ 1 3 5 7 1 ]

Данный способ представления называют ''полным'', поскольку представлена вся матрица <math>A</math>, и ''упорядоченным'', поскольку элементы каждой строки хранятся в соответствии с возрастанием столбцовых индексов. Таким образом, это строчное представление, полное и упорядоченное, или сокращенно '''(RR (С) О)'''.

==== Неупорядоченное представление ====

Представления разреженных матриц необязательно должны быть упорядочены в том смысле, что, хотя упорядоченность строк поддерживается, внутри каждой строки элементы могут храниться в произвольном порядке. Для матрицы А нашего примера вполне можно было бы использовать и строчное представление, полное, но ''неупорядоченное'' '''(RR (С) U )'''.

Неупорядоченное представление <math>A</math>:

IA = [ 1 4 4 6 ]
JA = [ 8 3 4 8 6 ]
AN = [ 5 1 3 1 7 ]

Неупорядоченные представления могут быть очень удобны. Результаты большинства матричных операций получаются не упорядоченными, и упорядочение их стоило бы больших затрат машинного времени. В то же время, за немногими исключениями, алгоритмы для разреженных матриц не требуют, чтобы представления были упорядоченными.

=== Умножение разреженной матрицы на вектор ===

Пусть <math>N</math> — число строк матрицы.
Для каждой ее строки <math>I</math> матрицы мы находим с помощью <math>IA</math> значения первой <math>IAA</math> и последней <math>IAB</math> позиций, занимаемых элементами строки <math>I</math> в массивах <math>JA</math> и <math>AN</math>. Затем, чтобы вычислить скалярное произведение строки <math>I</math> и вектора <math>B</math>, мы просто просматриваем <math>JA</math> и <math>AN</math> на отрезке от <math>IAA</math> до <math>IAB</math>:
каждое значение, хранимое в <math>JA</math>, есть столбцовый индекс и используется для извлечения из массива <math>B</math> элемента, который должен быть умножен на соответствующее число из <math>AN</math>. Результат каждого умножения прибавляется к <math>C(I)</math>.

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

'''Исходные данные:'''

<math>IA, JA, AN</math> - заданная матрица в форме '''(RR (С) U)''';

<math>B</math> - заданный заполненный вектор;

<math>N</math> - число строк матрицы.

'''Выход:''' <math>C</math> вектор-произведение размерности <math>N</math>.

'''Формулы метода:'''

:<math>
\begin{align}
& IAA_{i} = IA(i), \quad i \in [1, N], \\
& IAB_{i} = IA(i + 1) - 1, \quad i \in [1, N], \\
& c_{i} = \sum\limits_{j = IAA_{i}}^{IAB_{i}} AN(j)B(JA(j)), \quad i \in [1, N] \\
\end{align}
</math>

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

Вычислительным ядром, т.е. той частью алгоритма, на которую приходится основное время его работы, является вычисление значения <math>i</math>-го элемента <math>c_{i}</math> вектора-произведения, т.е произведения строки <math>I</math> матрицы <math>A</math> и вектора <math>B</math> по формуле:

:<math>
\begin{align}
& c_{i} = \sum\limits_{j = IAA_{i}}^{IAB_{i}} AN(j)B(JA(j)), \quad i \in [1, N] \\
\end{align}
</math>

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

Основу алгоритма составляет вычисление значения <math>i</math>-го элемента <math>c_{i}</math> вектора-произведения:

:<math>
\begin{align}
& c_{i} = \sum\limits_{j = IAA_{i}}^{IAB_{i}} AN(j)B(JA(j)), \quad i \in [1, N] \\
\end{align}
</math>

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

Последовательность исполнения метода следующая:

Далее для всех <math>i</math> от <math>1</math> до <math>N</math> по нарастанию выполняются:

1. <math> c_{i} = 0; IAA = IA(i); IAB = IA(i + 1 ) - 1 </math>

После этого, если <math>(IAB \le IAA)</math>:

2. Для всех <math>j</math> от <math>IAA</math> до <math>IAB</math> выполняется:

<math>c_{i} = \sum\limits_{j = IAA_{i}}^{IAB_{i}} AN(j)B(JA(j))</math>

Псевдокод алгоритма:

FOR I = 1, N (1)
U = 0. (2)
IAA = IA(I) (3)
IAB = IA(I + 1 ) - 1 (4)
IF NOT(IAB.LT.IAA) (5)
FOR J = IAA, IAB (6)
C(I) = U + AN(J)*B(JA(J)) (7)

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

Для всего алгоритма потребуется выполнить <math>O(k)</math> операций, как в строке стр.7 псевдокода алгоритма ([[#Схема реализации последовательного алгоритма|п.1.5]]), где <math>k</math> - число ненулевых элементов матрицы.

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

На рисунке 1 изображен информационный граф алгоритма.

[[file:InfoGrafMatrixRRCUandVextor.jpg|thumb|center|1200px|Рисунок 1. Информационный граф алгоритма.]]

По оси <math>X</math> для отдельной строки <math>I</math> матрицы отложены в пределах первой <math>IAA</math> и последней <math>IAB</math> позиций ненулевых элементов значения <math>AN</math> и соответствуюие им по столбцовомым индексам, хранимимым в <math>JA</math>, значения <math>B</math> элементов.
Пары этих значений обозначены желтыми квадратиками <math>(in)</math>. Значения in попарно скалярно перемножаются (зеленый кружочек) и суммируются (синий кружочек) в результат значения элемента вектора-произведения <math>c_{i}</math>, т.е <math>out</math>(красный квадратик) с строковым индексом, соответствующем номеру строки матрицы.

По оси <math>Y</math> отложена схема вычисление значения каждого элемента вектора-произведения для каждой строки матрицы.

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

Алгоритм обладает возможностью выполняться параллельно, что позволяет значительно ускорить вычисления.
Вычисление значения каждого элемента вектора-произведения для каждой строки матрицы и элемента вектора <math>B</math> можно проводить на отдельных процессорах.
Максимальная эффективность вычислений достигается при наличии не менее, чем <math>N</math> процессоров, т.е отдельный процессор на вычисление значения каждого элемента вектора-произведения. На процессоре выполняется <math>k(i)</math> последовательных операций умножения и сложения. Поэтому число ярусов для <math>i</math>-ого процессора равно <math>k(i)</math>.

Для параллельного выполнения алгоритма требуется:

* <math>N</math> ярусов умножений и сложений,
* в каждом из ярусов <math>k << m</math> операций.

При классификации по высоте ЯПФ, алгоритм имеет линейную сложность. При классификации по высоте ЯПФ также линейную.

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

* <math>IA, JA, AN</math> - заданная матрица в форме '''(RR (С) U)''' c <math>k</math> ненулевыми элементами и <math>N</math> строками, <math>m</math> столбцами;

* <math>B</math> - заданный заполненный вектор c <math>m</math> элементами;
'''
'''Объем входных данных''': <math>k + m</math>

'''Выходные данные:''' <math>C</math> вектор-произведение размерности <math>N</math>.

'''Объем выходных данных''': <math>N</math>

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

Алгоритм в рамках выбранной версии полностью детерминирован.

Вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных – константа.

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

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

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

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

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

Параллельная реализация алгоритма позволяет до некоторой степени сократить время вычислений в несколько раз.
На вычислительном комплексе ''IBM Blue Gene/P'' было проведено экспериментальное исследование масштабируемости программной реализации умножения разряженной матрицы на вектор. Результаты исследования представлены на рис.2:

[[Файл:DependeceOfTheExecutionTime.jpg |thumb|center|900px|Рисунок 2. График зависимости времени выполнения программы умножения разряженной матрицы на вектор от количества ненулевых элементов матрицы для данного числа процессоров.]]

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

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

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

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

Алгоритм релизован в составе библиотек:
* SparseLib++[http://math.nist.gov/sparselib++/]
* cuSPARSE [http://docs.nvidia.com/cuda/cusparse/]
* uBLAS [http://www.boost.org/doc/libs/1_62_0/libs/numeric/ublas/doc/]
* Intel MKL [https://software.intel.com/en-us/intel-mkl]

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

* [1] С. Писсанецки. Технология разреженных матриц. Изд. Мир, 1988.
* [2] В. В. Воеводин, Вл.В. Воеводин. Параллельные вычисления. – СПб.: БХВ - Петербург, 2002.

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

2016-11-21T07:56:36Z

Dan:

Участник:Lvs/Итерационный метод решения системы линейных алгебраических уравнений GMRES

2016-11-21T07:54:55Z

Dan:

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Итерационный метод решения системы линейных алгебраических уравнений GMRES (или обобщенный метод минимальных невязок) используется для решения систем линейных алгебраических уравнений с заданной точностью приближения. Метод основан на процессе Арнольди, посредством которого матрица СЛАУ приводится к (верхней) хессенберговой форме.

== Математическое описание алгоритма ==
Дана система линейных алгебраических уравнений <math>Ax = b</math>, где <math>A</math> - квадратная матрица размера <math>n \times n</math>.

Вычисляется последовательность приближённых решений уравнения <math> x_m </math>, которая сходится к точному решению уравнения <math>x^*</math>.

Подпространство Крылова размерности <math>m</math>, порожденное вектором <math>b</math> и матрицей <math>A</math> – линейное пространство
<math>K_m(A, v)</math>, являющееся линейной оболочкой векторов <math>b, Ab, A^2b, ..., A^{m-1}b</math>.

Приближённое решение считается по формуле <math> x_m = Q_my_m</math>, где <math>Q_m</math> - матрица размера <math>n \times m</math>, составленная из векторов ортонормированного базиса пространства <math>K_m(A, v)</math>, <math>y_m \in \mathbb{R}^m</math>.

Итоговым считается решение, минимизирующее норму невязки (<math>||r||_2 = ||b - Ax_m||_2</math>) с заданной точностью.

Для вычисления векторов ортонормированного базиса используется алгоритм Арнольди:
<source>
q[1] = b/||b||
for j = 1, ..., n-1 do
z = Aq[j]; //очередной вектор
for i = 1,..., j do
h[i][j] = (z, q[i]);
z = z − h[i][j]q[i];
end i
h[j+1][j] = ||z||;
if (h[j+1][j] == 0) break;
q[j+1] = z/h[j+1][j];
end j
</source>
Сложность алгоритма <math>O(n^2)</math>.

На каждом шаге алгоритма получаются векторы <math>q_1, q_2, ..., q_m</math>, являющиеся ортонормированным базисом Крыловского пространства <math>K_m(A, b)</math>.

Значения <math>h_{i,j}</math> образуют верхнюю матрицу Хессенберга (обозначим как <math>H_m</math>, размерность <math>m+1 \times m</math>).

<math>H_k = \begin{bmatrix}h_{11} & h_{12} & h_{13} &... & h_{1m-1} & h_{1m} \\ h_{21} & h_{22} & h_{23} & ... & h_{2m-1} & h_{2m} \\ 0 & h_{32} & h_{33} &...& h_{3m-1} & h_{3m} \\ ... & ... & ... & ... & ... & ... \\ 0 & 0 & 0 & ... & h_{m m-1} & h_{mm} \\0 & 0 & 0 & ... & 0 & h_{m+1 m}\end{bmatrix}</math>.

Вектор невязки задан уравнением <math>r_m = H_my_m - ||b - Ax_0||e_1</math>, где <math>x_0</math> - вектор начального приближения. Минимизация второй нормы вектора невязки представляет из себя решение линейной задачи минимальных квадратов размера <math>n</math>.

Приближённое решение вычисляется по формуле <math> x_m = Q_my_m</math> после нахождения соответствующего значения минимизирующего вторую невязку вектора. Сложность вычислений <math>O(nm)</math>
== Вычислительное ядро алгоритма ==
Самая трудоёмкая и самая часто вызываемая операция в алгоритме - умножение матрицы на вектор. В первую очередь это связано с вычислением матрицы Хессенберга.
== Макроструктура алгоритма ==
# Алгоритм Арнольди
# Решение линейной задачи минимальных квадратов
# Вычисление решения
== Схема реализации последовательного алгоритма ==
<source>
Вычислить ортонормированный базис размера m
Вычислить минимальное приближение
if (приближение < заданная точность)
Вычислить результат
return;
else
Повторить для m = m+1
</source>
== Последовательная сложность алгоритма ==
Сложность вычислений собственных векторов на каждом шаге - <math>O(n^2)</math>, но может уменьшиться до <math>O(n)</math> при более разреженной матрице.

Сложность решения задачи минимальных квадратов <math>O(m^2)</math>, но при последовательном выполнении алгоритма можно понизить сложность до <math>O(m)</math> путём использования подсчитанных на прошлых итерациях значений.

Сложность вычисления решения <math>O(nm)</math>, поэтому его целесообразно вычислять только в конце.
== Информационный граф ==
Основной ресурс параллелизма - умножение матрицы на вектор. Для этой операции информационный граф представлен на рисунке.

[[file:GraphLvs2FM.jpg|thumb|center|700px|Рис.1. Информационный граф умножения матрицы на вектор]]

== Ресурс параллелизма алгоритма ==
# Параллельное умножение матрицы на вектор выполняется в <math> n </math> ярусов умножений и сложений.
# Шаги алгоритма Арнольди выполняются строго последовательно, однако последующее нахождение невязки можно выполнять параллельно с запуском следующего шага алгоритма.
# Сложность решения задачи минимальных квадратов зависит от используемого алгоритма. В отличие от последовательного метода данные, полученные на прошлых шагах здесь использовать нельзя.
# Вычисление результата выполняется один раз, его можно выполнить параллельно в <math> n </math> ярусов умножений и сложений.

== Входные и выходные данные алгоритма ==
'''Входные данные:''' Матрица <math>A</math>, вектор <math>b</math>, точность <math>t</math>. Объём: <math>n^2 + n + 1</math>

'''Выходные данные:''' Вектор <math>x_m</math>. Объём: <math>n</math>

== Свойства алгоритма ==
Теоретически на каждой итерации алгоритма сложность вычислений составляет <math>n + X</math> операций умножения, где <math>X</math> - сложность алгоритма для решения задачи минимальных квадратов. Таким образом в худшем случае сложность будет примерно равна <math>n^2 + X*n + n</math> операций умножения.

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

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

== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
Для исследования масштабируемости алгоритма была использована параллельная реализация <ref>Parallel GMRES Algorithm for Solving Giant Sparse System of Linear Equations https://github.com/arrgasm/paraGMRES/</ref>. Программа была запущена на суперкомпьютере BlueGene на разреженной матрице размера 90448х90448. Параметрами запуска являются 100 итераций алгоритма и 10 перезапусков алгоритм (повторный запуск алгоритма с использованием решения, полученного на предыдущем запуске, в качестве начального приближения). График зависимости времени выполнения от числа процессоров представлен на рисунке 2.
[[file:PlotLvs1.png|thumb|center|400px|Рис 2. График зависимости времени выполнения от числа процессоров]]
График эффективности для полученного времени выполнения указан на рисунке 3.
[[file:PlotLvs2.png|thumb|center|400px|Рис 3. График зависимости эффективности реализации от числа процессоров]]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Реализации алгоритма GMRES присутствуют во многих программных продуктах как части стандартных библиотек, например Matlab или DEFORM3D. Также существую отдельные библиотеки, например MGMRES для языка С++.

= Литература =
[1] Тыртышников Е. Е. Методы численного анализа — М., Академия, 2007.

[2] М. Дана, А. Г. Зыков, Х. Д. Икрамов Метод минимальных невязок для специального класса линейных систем с нормальными матрицами коэффициентов - Ж. вычисл. матем. и матем. физ., 2005, том 45, номер 11

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-11-21T07:54:16Z

Dan:

{{Assignment|Dan}}

Автор: [[U:Сергей|Герасимов Сергей]] (619)

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

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

'''Разреженная матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается плотной.

Нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:

~ есть O(n). Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;

~ в каждой строке не превышает 10 в типичном случае;

~ ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.

Огромные разрежённые матрицы часто возникают при решении таких задач, как дифференциальное уравнение в частных производных.

При хранении и преобразовании разрежённых матриц в компьютере бывает полезно, а часто и необходимо, использовать специальные алгоритмы и структуры данных, которые учитывают разрежённую структуру матрицы. Операции и алгоритмы, применяемые для работы с обычными, плотными матрицами, применительно к большим разрежённым матрицам работают относительно медленно и требуют значительных объёмов памяти. Однако разрежённые матрицы могут быть легко сжаты путём записи только своих ненулевых элементов, что снижает требования к компьютерной памяти.

'''Существуют различные форматы хранения разреженных матриц.''' Одни предназначены для хранения матриц специального вида (например, ленточных), другие обеспечивают работу с матрицами общего вида. Ниже рассмотрим некоторые весьма распространенные способы представления разреженных матриц.

По-видимому, наиболее очевидным способом хранения произвольной разреженной матрицы является '''координатный формат''': хранятся только ненулевые элементы матрицы, и их координаты (номера строк и столбцов). При данном подходе хранение матрицы A можно обеспечить в трех одномерных массивах:

~ массив ненулевых элементов матрицы A (обозначим его как values);

~ массив номеров строк матрицы A, соответствующих элементам массива values (обозначим его как rows);

~ массив номеров столбцов матрицы A, соответствующих элементам массива values (обозначим его как cols);

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

Хотя многие математические библиотеки поддерживают матрично-векторные операции в координатном формате, данный формат обеспечивает медленный доступ к элементам матрицы, и является затратным по используемой памяти. В рассмотренном выше примере избыточность по памяти образом проявляется в массиве rows, в котором строчные координаты хранятся неоптимальным образом.

Перейдем далее к рассмотрению более экономных форматов хранения. '''Разреженный строчный формат''' - это одна из наиболее широко используемых схем хранения разреженных матриц. Эта схема предъявляет минимальные требования к памяти и в то же время оказывается очень удобной для нескольких важных операций над разреженными матрицами: сложения, умножения, перестановок строк и столбцов, транспонирования, решения линейных систем с разреженными матрицами коэффициентов как прямыми, так и итерационными методами и т. д.

В соответствии с рассматриваемой схемой для хранения матрицы A требуется три одномерных массива:

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его опять как values);

~ массив номеров столбцов для соответствующих элементов массива values (обозначим его как cols);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его pointer). Описание k-й строки хранится в позициях с pointer[k]-й по (pointer[k+1]–1)-ю массивов values и cols. Если pointer[k]=pointer[k+1], то k-я строка пустая. Если матрица A состоит из n строк, то длина массива pointer будет n+1.

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

Очевидно, что объем памяти, требуемый для хранения вектора pointer, значительно меньше, чем для хранения вектора rows. Более того, разреженный строчный формат обеспечивает эффективный доступ к строчкам матрицы; доступ к столбцам по прежнему затруднен. Поэтому предпочтительно использовать этот способ хранения в тех алгоритмах, в которых преобладают строчные операции.

Существует также '''разреженный столбцовый формат''', который строится аналогичным способом.

Теперь, разобравшись со способами хранения разреженных матриц, можно перейти к ''алгоритму умножения разреженной матрицы на вектор''. Умножение матрицы на вектор является подзадачей для нахождения решений СЛАУ итерационными методами.

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

Пусть матрица размером <math>N\times M</math> содержит в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>

Условимся использовать строчный формат хранения матрицы, который описан выше.

На входе у нас 4 массива: val(ненулевые элементы матрицы), col(номера столбцов), row(массив указателей) и vec(вектор, на который мы умножаем матрицу).

На выходе получим вектор out.

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}, \ i=\overline{0,N-1}</math>, где <math>N</math> - число строк матрицы.

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

Ядром алгоритма является вычисление сумм произведений:

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}</math>

Итого: <math>NZ</math> умножений + <math>x</math> сложений(<math>NZ-N<x<NZ-1</math>).

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

Метод состоит из вычисления неполных скалярных произведений.

[[Файл:sparse.jpg|thumb|center|500px|Рис.1 Умножение разреженной матрицы на вектор]]

Элементы из массива val умножаются на элементы из массива vec с соответствующим индексом. Черным отмечены ненулевые элементы.

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

Предполагается, что матрица представлена в разреженном строчном формате.

for(i=0; i<N; i++)
{
out[i]=0;
for(j=row[i]; j<row[i+1]; j++)
{
out[i] += val[j]*vec[col[j]];
}
}

Внешний цикл - цикл по элементам выходного вектора. Внутренний - цикл по строкам разреженной матрицы.
Во внутреннем цикле реализовано накопление сумм произведений в выходной элемент.
Индекс ''j'' показывает с какого по какой элемент нужно считать из ''val'' (вектор с ненулевыми значениями матрицы), а также позволяет определить в каких столбцах расположены эти значения в матрице (с помощью вектора ''col'').
Минимальное и максимальное значение ''j'' узнается из вектора ''row''.

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

<math>\bullet \ NZ</math> умножений

<math>\bullet \ x</math> сложений(<math>NZ-N<x<NZ-1</math>).

Всего <math>2NZ</math> операций, где <math>NZ</math> - количество ненулевых элементов.

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

Опишем граф алгоритма.

Граф алгоритма состоит из двух групп вершин, расположенных в целочисленных узлах двух областей одной размерности.

'''Первая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a \cdot b</math>. Координаты области следующие:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math> k </math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>. (На рисунке вместо обозначения ''row'' использовано обозначение ''r'').

Результаты операции - '''промежуточные''' данные алгоритма.

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a + b</math>.
Координаты области таковы:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>.

Результат операции:

<math>\cdot</math> при <math>j < k - 1</math> является '''промежуточным''' данным алгоритма;

<math>\cdot</math> при <math>j = k - 1</math> является '''выходным''' данным <math>out[i]</math>.

Описанный граф изображен на Рис.2. Здесь вершины первой группы обозначены красным цветом и отмечены знаком умножения, вершины второй - зелёным цветом и знаком сложения. Вершины, соответствующие входным данным обозначены белым цветом и выходным - синим.

[[Файл:new_sparse.png|thumb|center|1000px|Рис.2 Умножение разреженной матрицы на вектор. Информационный граф]]

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

При наличии бесконечного числа процессоров для умножения разреженной матрицы на вектор потребуется:

~ 1 ярус умножений

~ <math>Z-1</math> операция сложения, где Z - максимальное число ненулевых элементов в строке.

Максимальное число требуемых процессоров - NZ.

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

'''Входные данные:'''

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его как val);

~ массив номеров столбцов для соответствующих элементов массива val (обозначим его как col);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его row);

~ вектор, на который будет умножаться матрица (обозначим его vec).

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

Для матрицы размером <math>N\times M</math>, содержащей в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>,

~ вектор val - NZ элементов;

~ вектор col - NZ элементов;

~ вектор row - N+1 элемент;

~ вектор vec - M элементов.

'''Выходные данные:'''

Вектор out размером N.

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

Соотношение последовательной и параллельной сложности в случае неограниченных ресурсов, как хорошо видно, является ''линейным''.

Вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных – чуть меньше ''единицы''.

Данный алгоритм обладает свойством детерминированности.

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Проведём исследование масштабируемости параллельной реализации умножения разреженной матрицы на вектор. Исследование проводилось на вычислительном комплексе [http://hpc.cmc.msu.ru/bgp Blue Gene/P]<ref> Blue Gene/P http://hpc.cmc.msu.ru/bgp</ref>. Вычисления проводились с помощью следующего программного [https://www.dropbox.com/s/gx0s5r0jg58y8wa/main.c кода]<ref>Sparse matrix-vector MPI multiplication </ref>.
Матрицы генерировались случайным образом.

На следующем рисунке показана зависимость времени выполнения алгоритма от числа используемых процессоров и количества ненулевых элементов матрицы. Можно заметить, что скорость вычисления при переходе с последовательной на параллельную версию возросла значительно. Однако, дальнейшее увеличение числа вычислительных устройств не дает сильного прироста производительности. Это объясняется быстрым ростом накладных расходов на организацию параллельного выполнения.

[[Файл:plot_more_points.png|thumb|center|1000px|Рис.3 Умножение разреженной матрицы на вектор. Масштабируемость]]

На рисунке ниже изображен график эффективности в зависимости от числа процессоров и размера задачи. Можно заметить небольшой всплеск эффективности при использовании 64 процессоров.

[[Файл:plot_eff_new.png|thumb|center|1000px|Рис.4 Умножение разреженной матрицы на вектор. Эффективность]]

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

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

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

Эффективная работа с разреженными матрицами реализована во многих библиотеках, например, [https://software.intel.com/en-us/intel-mkl Intel Math Kernel Library], базирующуюся на библиотеках BLAS и LAPACK, также математических пакет [http://matlab.ru/products/matlab Matlab] имеет собственную реализацию.

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

[1] Писсанецки С. Технология разреженных матриц. - М.: Мир, 1988. — 410 с.

[2] https://software.intel.com/sites/default/files/m/d/4/1/d/8/LW_SparseMM_ppt.pdf

Обсуждение участника:Сергей

2016-11-21T07:54:08Z

Dan: Содержимое страницы заменено на «= Правки = Не удаляйте замечания»

= Правки =
Не удаляйте замечания

Участник:Alexander34396/Обобщенный метод минимальных невязок

2016-11-17T11:25:26Z

Dan:

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

{{algorithm
| name = Обобщенный метод минимальных невязок
| serial_complexity = <math> O(nm^2) </math>
| input_data = <math> (n + 1)^2 </math>
| output_data = <math> n </math>
}}

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

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

'''Обобщённый метод минимальных невязок''' ({{lang-en|Generalized minimal residual method, GMRES}}) - итерационный метод численного решения системы линейных алгебраических уравнений с невырожденной матрицей. Метод основан на минимизации квадратичного функционала невязки на подпространствах Крылова. Разработан Юсефом Саадом и Мартином Шульцем<ref> Y.Saad, M.H. Schultz, GMRES: A generalized minimal residual algorithm for solving nonsymmetric linear systems, SIAM J. Scientific and Stat. Comp. 7: 856-869 (1986) </ref> в 1986 году как обобщение метода MINRES<ref>C. C. Paige and M. A. Saunders. Solution of sparse indefinite systems of linear equations, SIAM J. Numerical Analysis 12, 617-629 (1975)</ref> на случай систем с несимметричными матрицами.

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

'''Исходные данные:'''
* система линейных алгебраических уравнений вида <math> Ax = b </math>, где <math> A </math> — невырожденная матрица размера <math>n</math>-на-<math> n </math>;
* <math> x_0 </math> - начальное приближение.
'''Вычисляемые данные:'''
* <math> x_m </math> - приближённое решение исходной системы.

Метод GMRES приближает точное решение исходной системы <math> Ax = b </math> вектором <math> x_m </math>, который минимизирует Евклидову норму невязки <math> r_m = Ax_m - b</math> на подпространстве Крылова:
: <math> K_m = K_m(A,b) = \operatorname{span} \, \{ b, Ab, A^2b, \ldots, A^{m-1}b \} </math>, где <math> \operatorname{span} \, \{ a_1, a_2, \ldots, a_m \} </math> - линейная оболочка системы векторов <math> \{ a_1, a_2, \ldots, a_m \} </math>.

На каждой итерации метода решение уточняется поправкой, представленной в виде разложения по ортонормированному базису пространства <math> K_m </math>:
: <math> x_m = x_0 + z_m </math>, где <math> x_0 </math> - некоторое начальное приближение, <math> z_m \in K_m </math> - поправка решения.

=== Ортогонализация Арнольди ===

Для построения ортонормированного базиса <math> v_1, v_2, \ldots, v_m </math> пространства Крылова <math> K_m </math> метод использует процесс Арнольди.

Идея процесса Арнольди состоит в том, что для нахождения вектора <math> v_{j+1} </math> при известных векторах <math> v_1, v_2, \ldots, v_j </math> необходимо вычислить вектор <math> Av_j </math> и ортонормировать этот вектор относительно <math> v_1, v_2, \ldots, v_j </math>:
: <math> v_{j+1} = \frac{\hat{v}_{j+1}}{\|\hat{v}_{j+1}\|_2} </math>, где <math> \hat{v}_{j+1} = Av_j - \sum_{i=1}^j h_{ij}v_{i} </math>.

Коэффициенты <math> h_{ij} = (Av_j, v_i) </math> определяются из условия ортогональности:
: <math> A(v_j, v_k) - \sum_{i=1}^j h_{ij}(v_{i}, v_k) = 0 </math>, где <math> \quad k=1,\ldots,j </math>.

Результат процедуры Арнольди совпадает с результатом процесса Грамма-Шмидта, применённого к векторам <math> \{b, Ab, A^2b, \ldots, A^{m-1}b\} </math>.

'''Исходные данные:'''
* <math> v_1 </math>, такой что <math> \|v_1\|_2 = 1 </math>;
* матрица <math> A </math> размером <math> n </math>-на-<math> n </math>.

'''Вычисляемые данные:'''
* <math> v_1, v_2, \ldots, v_m </math> - ортонормированный базис пространства Крылова <math> K_m </math>.

'''Алгоритм процесса:'''

Выполнять для <math> \quad j=1,\ldots,m </math>:
# <math> h_{ij} = (Av_j, v_i), \quad i=1,\ldots,j </math>;
# <math> \hat{v}_{j+1} = Av_j - \sum_{i=1}^j h_{ij}v_{i} </math>;
# <math> h_{j+1j} = \|\hat{v}_{j+1}\|_2 </math>;
# <math> v_{j+1} = \frac{\hat{v}_{j+1}}{h_{j+1j}} </math>.

'''При введении матричных обозначений можно записать:'''

Поправка решения:
: <math> z_m = V_my_m </math>, где <math> y_m \in \mathbb{R}^m </math> - вектор коэффициентов, <math> V_m = [v_1|v_2|...|v_m] </math>.

Матричное представление процесса Арнольди:
: <math> AV_m = V_{m+1}H_{m+1m} = V_mH_m + h_{m+1m}v_{m+1} e_m^T </math>,
где
: <math>H_{m+1m} = \begin{bmatrix}h_{11} & h_{12} & h_{13} &... & h_{1m-1} & h_{1m} \\ h_{21} & h_{22} & h_{23} & ... & h_{2m-1} & h_{2m} \\ 0 & h_{32} & h_{33} &...& h_{3m-1} & h_{3m} \\ ... & ... & ... & ... & ... & ... \\ 0 & 0 & 0 & ... & h_{m m-1} & h_{mm} \\0 & 0 & 0 & ... & 0 & h_{m+1 m}\end{bmatrix}</math>
- верхняя матрица Хессенберга размерности <math> m+1 </math> на <math> m </math>.

=== Минимизация функционала невязки ===

Невязка исходной системы имеет вид:
: <math> r_m = b - A(x_0 + z_m) = r_0 - AV_my_m = \beta v_1 - V_{m+1}H_{m+1k}y_m</math>, где <math> \beta = \|r_0\|_2</math>.

C учетом того, что матрица <math> V_{k+1} </math> составлена из ортонормированных векторов:
: <math> r_m = \beta V_{m+1}e_1 - H_{m+1m}y_m</math>, где <math> e_1 = (1,0,0,\ldots,0)^T </math>.

Норма невязки <math> r_m </math>:
: <math> \|r_m\|_2 = \|\beta e_1 - H_{m+1m}y_m\|_2 </math>.

Норма <math> \|r_m\|_2 </math> достигает минимума при <math> \beta e_1 = H_{m+1m}y_m </math>.

Для нахождения решения такой системы, матрица <math> H_{m+1m} </math> приводится к верхнему треугольному виду с помощью <math> m </math> последовательных [[Метод_Гивенса_(вращений)_QR-разложения_квадратной_матрицы_(вещественный_вариант)|вращений Гивенса]].

=== Общая схема метода ===

В общем виде m-aя итерация алгоритма GMRES может быть записан следующим образом:

# найти ортонормированный базис <math> V_m </math> подпространства <math> K_m </math> с помощью ортогонализации Арнольди;
# найти <math> y_m </math>, минимизирующий <math> \|r_m\|_2 </math>;
# вычислить <math> x_m = x_0 + V_my_m </math>, где <math> x_0 </math> - начальное приближение;
# вычислить <math> r_m </math> и остановиться,если требуемая точность была достигнута, иначе повторить.

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

Вычислительное ядро последовательной версии метода GMRES состоит из двух частей:
* Вычисление ортонормированного базиса <math> K_m </math>;
* Формирование приближенного решения <math> x_m </math>.

Для вычисления ортонормированного базиса <math> K_m </math> метод использует процесс Арнольди:
: <math> h_{j+1j}v_{j+1} = Av_j - \sum_{i=1}^j h_{ij}v_{j} </math>, где <math> h_{ij} = (Av_j, v_i)</math>, <math> \quad j=1,\ldots,m </math>.

Для нахождения приближённого решения <math> x_m </math> метод использует формулу:
: <math> x_m = x_0 + V_my_m </math>.

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

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

* Умножение матрицы на вектор;
* Вычисление скалярного произведения векторов;
* Вычисление Евклидовой нормы вектора;
* Умножение вектора на скаляр;
* Деление вектора на скаляр.

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

На практике используется перезапускаемая версия метода - GMRES(m):

'''1 Подготовка перед итерационным процессом:'''
:1.1 Выбрать начальное приближение <math> x_0 </math>;
:1.2 Посчитать невязку <math> r_0 = b - Ax_0 </math>;
:1.3 Вычислить <math> v_1 = \frac{r_0}{\|r_0\|_2} </math>.

'''2 Построение ортонормированного базиса <math> K_m </math>:'''

: Для всех <math> j </math> от 1 до m по нарастанию выполнять:
:2.1 <math> h_{ij} := (Av_j, v_i), \quad i=1,\ldots,j </math>;
:2.2 <math> \hat{v}_{j+1} := Av_j - \sum_{i=1}^j h_{ij}v_{i} </math>;
:2.3 <math> h_{j+1j} = \|\hat{v}_{j+1}\|_2 </math>;
:2.4 <math> v_{j+1} = \frac{\hat{v}_{j+1}}{h_{j+1j}} </math>.

'''3 Вычисление <math> x_m </math>:'''
:3.1 <math> x_m = x_0 + V_my_m </math>, где <math>y_m</math> минимизирует <math>\|r_0 - AV_my_m\|_2</math>;
:3.2 Вычислить <math> r_m </math>;
:3.3 Если требуемая точность достигнута, остановиться.

'''4 Перезапуск:'''
:4.1 <math>x_0 = x_m</math>;
:4.2 <math>v_1 = \frac{r_m}{\|r_m\|_2}</math>;
:4.3 Перейти к шагу 2.

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

Если пренебречь сложностью вычисления <math> y_m </math>, то общую сложность алгоритма GMRES можно разделить на две части:

'''1. Сложность вычисления ортонормированного базиса пространства <math> K_m </math>:'''
:a) Для вычисления <math> j </math>-го вектора базиса <math> K_m, j < m </math> требуется:
:: <math> NZ + (2j + 1)n </math> мультипликативных операций, где <math> NZ </math> - количество ненулевых элементов матрицы <math> A </math>.
:b) Вычисление последнего вектора базиса требует:
:: <math> n(m + 1) </math> мультипликативных операций.
:c) Общая мультипликативная сложность вычисления ортонормированного базиса <math> K_m </math>:
:: <math> O(nm^2) </math>.

'''2. Сложность вычисления приближённого решения <math> x_m </math>:'''
:a) Вычисление этой формулы требует <math> nm </math> мультипликативных операций.

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

[[File: Drawing.png|thumb|center|350px|'''Рис. 1'''
'''input''' - входные данные алгоритма (квадратная матрица, вектор правой части, начальное приближение, точность решения);
'''<math> A_i </math>''' - шаги алгоритма Арнольди, <math> x_i </math> - нахождение невязки на <math> i </math>-ой итерации;
'''if''' - вычисление <math> r_m </math> и в случае достижения нужной точности - остановка.]]
Шаги алгоритма Арнольди выполняются строго последовательно, но вычисление <math> i </math>-ой невязки может происходить параллельно
с <math> (i + 1) </math>-ым шагом алгоритма Арнольди.

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

В ходе анализа перезапускаемого метода обобщенных минимальных невязок был выявлен ряд подзадач, выполняющихся неоднократно: умножение матрицы на вектор, вычисление скалярного произведения векторов, нахождение нормы вектора, нормирование вектора, нахождение взвешенной суммы векторов. Наиболее трудоемкой среди перечисленных операций является умножение матрицы на вектор.

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

При выполнении параллельного алгоритма решения систем линейных алгебраических уравнений необходимо распределить входные данные наиболее рациональным способом. Матрица коэффициентов разбивается на непрерывные горизонтальные полосы. Распределение вектора правой части и начального приближения выполнено по принципу дублирования, т.е. все элементы векторов скопированы на все процессоры. Для рассматриваемой задачи решения СЛАУ такой подход распределения допустим, т.к. векторы содержат столько же элементов, сколько и одна строка или один столбец матрицы коэффициентов.

Подзадачи можно разделить на 2 группы: операции между матрицей и вектором (например, умножение матрицы на вектор) и операции между двумя векторами (например, скалярное умножение). Подзадачи умножения константы на вектор и определение нормы вектора можно относить ко второй группе, так как их трудоемкость одного порядка.

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

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

'''Входные данные:'''
* <math> A </math> – квадратная матрица размера <math> n </math>-на-<math> n </math>;
* <math> b </math> – вектор правой части размера <math> n </math>;
* <math> x_0 </math> – начальное приближение размера <math> n </math>;
* <math> \epsilon </math> – погрешность решения.

'''Для перезапускаемой версии алгоритма дополнительно:'''
* <math> m </math> – число итераций.

'''Объём входных данных''': <math> n^2 + 2n + 1 </math>.

'''Выходные данные''':
* <math> x_m </math> - вектор приближённого решения размера <math> n </math>.

'''Объём выходных данных''': <math> n </math>.

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

Обобщенный метод минимальных невязок предназначен для решения несимметричных систем линейных уравнений. GMRES использует перезазапуски для контроля требований к хранению данных.

Если используется неперезапускаемый метод, GMRES будет сходиться за не более <math> n </math> шагов. Но это не имеет практического применения, когда <math> n </math> велико. Кроме того, требования к памяти и вычислениям при отсутствии перезапусков являются очень высокими. Важнейшим элементом для успешного применения <math> GMRES(m)</math> являются перезапуски; то есть выбор <math> m </math>. Существуют примеры, для которых метод застаивается и сходимость есть только на <math>m</math>-м шаге. Для таких систем, любой выбор <math> m </math> меньше, чем <math> n </math> - не сходится.

Основным недостатком GMRES является то, что объемы работ и ресурсы памяти, требуемые для итерации, линейно возрастают с увеличением числа итераций. Если не удалось получить чрезвычайно быструю сходимость - затраты будут очень высокими. Основной способ преодолеть это ограничение - это перезапуск итерации. После выбранного числа итераций <math> m </math> накопленные данные будут очищены и промежуточные результаты используются в качестве входных данных для последующих итераций. Эта процедура повторяется до тех пор, пока сходимость не будет достигнута. Трудность заключается в выборе подходящего значения <math> m </math>. Если <math> m </math> слишком мало, <math>GMRES(m)</math> может быть медленно сходиться, или не сойтись совсем. Значение <math> m </math>, большее, чем это необходимо, включает в себя чрезмерную работы и использует больше памяти. К сожалению, нет определенных правил, регулирующих выбор <math> m </math>; выбирая , когда делать перезапуск - это вопрос опыта.

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

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

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

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

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

В статье <ref> M. Sosonkina, Donald C. S. Allison, Layne T. Watson: Scalability analysis of parallel GMRES implementations </ref> анализируется параллельная реализация <math>GMRES(k)</math> на Intel Paragon, IBM SP2 и Cray T3E.
Системы Intel Paragon и IBM SP2 не имеют двухуровневого кэша, что значительно сказывается на времени работы из-за больших потерь скорости и частых обращений к памяти.
В Cray T3E каждый процессор соединен с 8-килобайтовым кэшем данных и 96-килобайтовым двухуровневым кэшем данных. Также имеется дополнительный кэш объемом 4 мегабайта. Это достаточная емкость кэш-памяти для хранения всех данных с плавающей точкой с высоким коэффициентом попаданий кэша.

Ниже представлены графики экспериментальных результатов, где штриховыми линиями указывается теоретическая связь между коэффициентом масштабируемости <math>K</math> и числом процессоров <math>p</math> для фиксированного значения эффективности. Сплошная линия является аппроксимацией экспериментальных данных методом наименьших квадратов. На всех графиках вертикальная ось представляет <math>K</math>, а горизонтальная ось - <math>p</math>.

[[File:Intel paragon.JPG|thumb|center|800px|'''Рис. 2''' Intel Paragon]]
[[File:Ibm sp2.JPG|thumb|center|800px|'''Рис. 3''' IBM SP2]]
[[File:Cray t3e.JPG|thumb|center|800px|'''Рис. 4''' Cray T3E]]

Теоретические и экспериментальные результаты показывают, что параллельные реализации <math>GMRES(k)</math> являются достаточно масштабируемыми.

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

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

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

Реализации алгоритма GMRES присутствуют во многих программных пакетах:
* [http://www.netlib.org/linpack/ LINPACK]
* [http://math.nist.gov/tnt/download.html/ JAMA/C++]
* [http://math-atlas.sourceforge.net/ ATLAS]
* [http://software.intel.com/mkl‎/ Intel MLK]
* [http://math.nist.gov/iml++/ IML++]
* [http://netlib.org/lapack/ LAPACK]
* [http://osl.iu.edu/research/mtl/ MTL]
* [http://www-users.cs.umn.edu/~saad/software/SPARSKIT/ SPARSKIT]
* [http://researcher.watson.ibm.com/researcher/view_group.php?id=1426 WSMP]

= Литература =
<references \>

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

2016-11-17T11:24:48Z

Dan:

Добрый день. Начал проверять статью и оставил следующие заметки

Здравствуйте. Немного исправил статью, исходя из ваших замечаний.

= 1.2 =
На мой взгляд, нужны определения
span?
l2-норма?

: [[Участник:Alexander34396|Alexander34396]] Дано пояснение обозначения span.Вместо l2-норма теперь используется Евклидова норма.

= 1.2.1 =
Вот я читаю этот раздел как человек со стороны и вижу много формул. Почему они именно такие? В чем суть этого алгоритма?

: [[Участник:Alexander34396|Alexander34396]] Перед алгоритмом добавлено описание идеи алгоритма и пояснения к формулам.

= 1.2.2 =
Новые определения

: [[Участник:Alexander34396|Alexander34396]] Добавлены некоторые пояснения.Добавлена ссылка на статью - вращения Гивенса.

Затем я остановился, и у меня главные вопрос. Возможно ли сделать статью такой, чтобы для ее прочтения не требовалось обращаться к куче дополнительных источников? Вот я человек со стороны, хотя и заканчивал мехмат. Я могу разобраться со всем написанным здесь, но для этого мне придется гуглить кучу материалов. Но, насколько я понимаю, цель таких статей - быть более полными.

: [[Участник:Alexander34396|Alexander34396]] На мой взгляд, формат статей algo-wiki не подразумевает подробных объяснений и выводов формул, поэтому я добавил только некоторые пояснения, которые делают повествование более последовательным и несколько более понятным. При этом для полного понимания описанного метода для человека со стороны всё равно придётся обращаться к сторонним источникам.

Можете или добавить объяснений или возразить мне. В любом случае, пока с прочтением остановился, жду ответа или исправление (а лучше и того, и другого)

= 2.4 =
[[Участник:Dan|Dan]] ([[Обсуждение участника:Dan|обсуждение]]) 14:24, 17 ноября 2016 (MSK) Необходимо переработать
Требования были такие:
- Реализация: полностью собственная или обращение к библиотечной функции (Intel MKL, PETSc, FFTW, ScaLAPACK). В любом случае, текст исследуемой программы должен быть представлен в отчете.

- Компьютерная платформа может быть любой (Ломоносов, BlueGene или что-то иное). Описание компьютерной платформы должно быть в отчете.

- Должен быть представлен график сильной масштабируемости (зависимости производительности от числа процессов; если при этом
ещё и зависимость от размера задачи - это только в плюс). График должен выглядеть пристойно и понятно, оси и единицы измерения должны быть подписаны. К графику обязательно должны быть словесные пояснения! Требовалось подобрать такие размеры задачи и числа процессоров, чтобы отразить на графике характерные точки, описывающие свойства алгоритма и программы.

Обсуждение участника:Юлия Жосан

2016-11-17T11:23:33Z

Dan:

= Пункт 1.10 =
[[Участник:Dan|Dan]] ([[Обсуждение участника:Dan|обсуждение]]) 14:03, 17 ноября 2016 (MSK) Отсутствует оценка вычислительной мощности

= Пункт 2.4 =
[[Участник:Dan|Dan]] ([[Обсуждение участника:Dan|обсуждение]]) 14:03, 17 ноября 2016 (MSK) отсутствует исследование масштабируемости

Требования были такие:
- Реализация: полностью собственная или обращение к библиотечной функции (Intel MKL, PETSc, FFTW, ScaLAPACK). В любом случае, текст исследуемой программы должен быть представлен в отчете.
- Компьютерная платформа может быть любой (Ломоносов, BlueGene или что-то иное). Описание компьютерной платформы должно быть в отчете.
- Должен быть представлен график сильной масштабируемости (зависимости производительности от числа процессов; если при этом
ещё и зависимость от размера задачи - это только в плюс). График должен выглядеть пристойно и понятно, оси и единицы измерения должны быть подписаны. К графику обязательно должны быть словесные пояснения! Требовалось подобрать такие размеры задачи и числа процессоров, чтобы отразить на графике характерные точки, описывающие свойства алгоритма и программы.

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

2016-11-17T11:19:40Z

Dan:

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

= Пункт 1.1 =
Разреженная матрица, будучи множеством чисел, не имеющим регулярности, '''не может быть представлена в памяти машины тем же простым способом, что и полная матрица'''. Поэтому возникает необходимость дополнительно хранить индексную информацию, указывающую расположение каждого элемента в регулярном массиве.

Что означает фраза, выделенная жирным? Или как-то переформулируйте утверждение, оно не понятно

'''Однако многие схемы хранения допускают определенную долю нулей, и алгоритм обрабатывает их, как если бы они не были нулями.'''
Тоже непонятно

= Пункт 1.1.1.1 =
Поставьте определение ленточной матрицы в начало. Потому что, начиная читать первую фразу, сначала задаешься вопросом, что это такое

= Пункт 1.1.1.2 =
'''Кроме того, схема является статической, потому что включение нового элемента, лежащего вне оболочки, требует изменения всей структуры (если только не используются записи переменной длины).'''
Также нужны пояснения

= Пункт 1.1.2 =
'''Достоинство этих процедур, с вычислительной точки зрения, состоит в том, что единственная требуемая матричная операция — это повторное умножение матрицы на последовательность заполненных векторов; сама матрица не меняется.'''
Опять непонятно

= Пункт 1.3 =
Почему вычислительное ядро только последовательной версии?
Вычислительное ядро (computational kernel) алгоритма - это часть алгоритма, на которую приходится основное время его работы.

= Пункт 1.4 =
Наверное, вопрос в том, что алгоритм делает помимо запуска вычислительных ядер?

= Пункт 1.5 =
Как была выбрана форма хранения матрицы? Это нужно прокомментировать

= Пункт 1.7 =
Правильно я понимаю, что на рисунке изображено вычисление всего произведения матрицы на вектор? Аналогичные блоки для разных строк. А разве не должен быть рисунок, изображающий ядро (то есть произведение одной строки на вектор)?
(я не уверен, поэтому спрашиваю. Возможно, это как-то надо лучше подписать)

__

Нам показалось верным отобразить на рисунке именно параллельную версию, на которой будет видно как и произведение одной строки на вектор, так и вычисление всех элементов. Как следует из определения [[глоссарий#Граф алгоритма|графа алгоритма]], он должен давать удобное представление не только ядра, но и позволять рассмотреть алгоритм с параллельной точки зрения. Внесли небольшое пояснение для рисунка.

= Пункт 2.4 =
Пока пустой?

__

Поправили

Обсуждение участницы:Trrufina

2016-11-17T11:18:35Z

Dan:

Хорошая работа. Один маленький вопрос

= Пункт 1.2 =
Наиболее удобный CSR. Почему?

И, конечно, хорошо бы действительно пересчитать на однородном кластере, сделать соответствующие диаграммы, приложить код (на algowiki есть git-репозиторий).
Обратитесь к организаторам, может быть, все это возможно устроить?

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

2016-11-17T11:17:13Z

Dan:

Участник:Lexaloris/Умножение разреженной матрицы на вектор

2016-11-17T11:16:34Z

Dan:

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>O(k)</math>
| pf_height = <math>O(m)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>k + m</math>
| output_data = <math>n</math>
}}

'''Авторы страницы:''' [[Участник:Lexaloris|A.Д. Новоселов]] и [[Участник:kochet|П.А. Кочетков]]

Кочетков Павел ответственен за программную реализацию алгоритма, Новоселов Алексей ответственен за оформление статьи.

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

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

=== Хранение ненулевых элементов разреженной матрицы ===

==== Разреженный строчной формат ====

Одной из наиболее широко используемых схем хранения разреженных матриц является ''разреженный строчный формат''. Эта
схема предъявляет минимальные требования к памяти и в то же время оказывается очень удобной для умножения разреженной матрицы на вектор.
Например, рассмотрим формат хранения разряженной матрицы <math>A</math>:

[[File:RRCOMatrix.png]]

Значения ненулевых элементов матрицы и соответствующие столбцовые индексы хранятся в этой схеме по строкам в двух массивах <math>AN</math> и <math>JA</math> соответственно. Используется также массив указателей <math>IA</math>, отмечающих позиции массивов <math>AN</math> и <math>JA</math>, с которых начинается описание очередной строки. Дополнительная компонента в <math>IA</math> содержит указатель первой свободной позиции в <math>JA</math> и <math>AN</math>.

Таким образом <math>A</math> представляется в виде:

IA = [ 1 4 4 6 ]
JA = [ 3 4 8 6 8 ]
AN = [ 1 3 5 7 1 ]

Данный способ представления называют ''полным'', поскольку представлена вся матрица <math>A</math>, и ''упорядоченным'', поскольку элементы каждой строки хранятся в соответствии с возрастанием столбцовых индексов. Таким образом, это строчное представление, полное и упорядоченное, или сокращенно '''(RR (С) О)'''.

==== Неупорядоченное представление ====

Представления разреженных матриц необязательно должны быть упорядочены в том смысле, что, хотя упорядоченность строк поддерживается, внутри каждой строки элементы могут храниться в произвольном порядке. Для матрицы А нашего примера вполне можно было бы использовать и строчное представление, полное, но ''неупорядоченное'' '''(RR (С) U )'''.

Неупорядоченное представление <math>A</math>:

IA = [ 1 4 4 6 ]
JA = [ 8 3 4 8 6 ]
AN = [ 5 1 3 1 7 ]

Неупорядоченные представления могут быть очень удобны. Результаты большинства матричных операций получаются не упорядоченными, и упорядочение их стоило бы больших затрат машинного времени. В то же время, за немногими исключениями, алгоритмы для разреженных матриц не требуют, чтобы представления были упорядоченными.

=== Умножение разреженной матрицы на вектор ===

Пусть <math>N</math> — число строк матрицы.
Для каждой ее строки <math>I</math> матрицы мы находим с помощью <math>IA</math> значения первой <math>IAA</math> и последней <math>IAB</math> позиций, занимаемых элементами строки <math>I</math> в массивах <math>JA</math> и <math>AN</math>. Затем, чтобы вычислить скалярное произведение строки <math>I</math> и вектора <math>B</math>, мы просто просматриваем <math>JA</math> и <math>AN</math> на отрезке от <math>IAA</math> до <math>IAB</math>:
каждое значение, хранимое в <math>JA</math>, есть столбцовый индекс и используется для извлечения из массива <math>B</math> элемента, который должен быть умножен на соответствующее число из <math>AN</math>. Результат каждого умножения прибавляется к <math>C(I)</math>.

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

'''Исходные данные:'''

<math>IA, JA, AN</math> - заданная матрица в форме '''(RR (С) U)''';

<math>B</math> - заданный заполненный вектор;

<math>N</math> - число строк матрицы.

'''Выход:''' <math>C</math> вектор-произведение размерности <math>N</math>.

'''Формулы метода:'''

:<math>
\begin{align}
& IAA_{i} = IA(i), \quad i \in [1, N], \\
& IAB_{i} = IA(i + 1) - 1, \quad i \in [1, N], \\
& c_{i} = \sum\limits_{j = IAA_{i}}^{IAB_{i}} AN(j)B(JA(j)), \quad i \in [1, N] \\
\end{align}
</math>

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

Вычислительным ядром, т.е. той частью алгоритма, на которую приходится основное время его работы, является вычисление значения <math>i</math>-го элемента <math>c_{i}</math> вектора-произведения, т.е произведения строки <math>I</math> матрицы <math>A</math> и вектора <math>B</math> по формуле:

:<math>
\begin{align}
& c_{i} = \sum\limits_{j = IAA_{i}}^{IAB_{i}} AN(j)B(JA(j)), \quad i \in [1, N] \\
\end{align}
</math>

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

Основу алгоритма составляет вычисление значения <math>i</math>-го элемента <math>c_{i}</math> вектора-произведения:

:<math>
\begin{align}
& c_{i} = \sum\limits_{j = IAA_{i}}^{IAB_{i}} AN(j)B(JA(j)), \quad i \in [1, N] \\
\end{align}
</math>

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

Последовательность исполнения метода следующая:

Далее для всех <math>i</math> от <math>1</math> до <math>N</math> по нарастанию выполняются:

1. <math> c_{i} = 0; IAA = IA(i); IAB = IA(i + 1 ) - 1 </math>

После этого, если <math>(IAB \le IAA)</math>:

2. Для всех <math>j</math> от <math>IAA</math> до <math>IAB</math> выполняется:

<math>c_{i} = \sum\limits_{j = IAA_{i}}^{IAB_{i}} AN(j)B(JA(j))</math>

Псевдокод алгоритма:

FOR I = 1, N (1)
U = 0. (2)
IAA = IA(I) (3)
IAB = IA(I + 1 ) - 1 (4)
IF NOT(IAB.LT.IAA) (5)
FOR J = IAA, IAB (6)
C(I) = U + AN(J)*B(JA(J)) (7)

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

Для всего алгоритма потребуется выполнить <math>O(k)</math> операций, как в строке стр.7 псевдокода алгоритма ([[#Схема реализации последовательного алгоритма|п.1.5]]), где <math>k</math> - число ненулевых элементов матрицы.

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

На рисунке 1 изображен информационный граф алгоритма.

[[file:InfoGrafMatrixRRCUandVextor.jpg|thumb|center|1200px|Рисунок 1. Информационный граф алгоритма.]]

По оси <math>X</math> для отдельной строки <math>I</math> матрицы отложены в пределах первой <math>IAA</math> и последней <math>IAB</math> позиций ненулевых элементов значения <math>AN</math> и соответствуюие им по столбцовомым индексам, хранимимым в <math>JA</math>, значения <math>B</math> элементов.
Пары этих значений обозначены желтыми квадратиками <math>(in)</math>. Значения in попарно скалярно перемножаются (зеленый кружочек) и суммируются (синий кружочек) в результат значения элемента вектора-произведения <math>c_{i}</math>, т.е <math>out</math>(красный квадратик) с строковым индексом, соответствующем номеру строки матрицы.

По оси <math>Y</math> отложена схема вычисление значения каждого элемента вектора-произведения для каждой строки матрицы.

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

Алгоритм обладает возможностью выполняться параллельно, что позволяет значительно ускорить вычисления.
Вычисление значения каждого элемента вектора-произведения для каждой строки матрицы и элемента вектора <math>B</math> можно проводить на отдельных процессорах.
Максимальная эффективность вычислений достигается при наличии не менее, чем <math>N</math> процессоров, т.е отдельный процессор на вычисление значения каждого элемента вектора-произведения. На процессоре выполняется <math>k(i)</math> последовательных операций умножения и сложения. Поэтому число ярусов для <math>i</math>-ого процессора равно <math>k(i)</math>.

Для параллельного выполнения алгоритма требуется:

* <math>N</math> ярусов умножений и сложений,
* в каждом из ярусов <math>k << m</math> операций.

При классификации по высоте ЯПФ, алгоритм имеет линейную сложность. При классификации по высоте ЯПФ также линейную.

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

* <math>IA, JA, AN</math> - заданная матрица в форме '''(RR (С) U)''' c <math>k</math> ненулевыми элементами и <math>N</math> строками, <math>m</math> столбцами;

* <math>B</math> - заданный заполненный вектор c <math>m</math> элементами;
'''
'''Объем входных данных''': <math>k + m</math>

'''Выходные данные:''' <math>C</math> вектор-произведение размерности <math>N</math>.

'''Объем выходных данных''': <math>N</math>

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

Алгоритм в рамках выбранной версии полностью детерминирован.

Вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных – константа.

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

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

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

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

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

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

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

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

Алгоритм релизован в составе библиотек:
* SparseLib++[http://math.nist.gov/sparselib++/]
* cuSPARSE [http://docs.nvidia.com/cuda/cusparse/]
* uBLAS [http://www.boost.org/doc/libs/1_62_0/libs/numeric/ublas/doc/]
* Intel MKL [https://software.intel.com/en-us/intel-mkl]

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

* [1] С. Писсанецки. Технология разреженных матриц. Изд. Мир, 1988.
* [2] В. В. Воеводин, Вл.В. Воеводин. Параллельные вычисления. – СПб.: БХВ - Петербург, 2002.

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

2016-11-17T11:16:17Z

Dan:

= Пункт 1.2 =
Это определение пространства Крылова?
Не совсем понятно описание алгоритма, если не знаешь, о чем речь

= Пункт 1.3 =
Он достаточно длинный. Посмотрите описания готовых алгоритмов на алговики. Псевдокод здесь не читается, ядро должно лучше восприниматься

= Пункт 1.4 =
Если макроструктура это указанные 3 пункта, то нужно пояснить, почему именно пункт 1 является ядром. Он самый ресурсоемкий?

= Пункт 1.7 =
Почему это основной ресурс. Это основная операция в алгоритме? Требуются пояснения

= Пункт 2.4 =
[[Участник:Dan|Dan]] ([[Обсуждение участника:Dan|обсуждение]]) 14:16, 17 ноября 2016 (MSK) необходимо доработать:

Требования были такие:
- Реализация: полностью собственная или обращение к библиотечной функции (Intel MKL, PETSc, FFTW, ScaLAPACK). В любом случае, текст исследуемой программы должен быть представлен в отчете.
- Компьютерная платформа может быть любой (Ломоносов, BlueGene или что-то иное). Описание компьютерной платформы должно быть в отчете.
- Должен быть представлен график сильной масштабируемости (зависимости производительности от числа процессов; если при этом
ещё и зависимость от размера задачи - это только в плюс). График должен выглядеть пристойно и понятно, оси и единицы измерения должны быть подписаны. К графику обязательно должны быть словесные пояснения! Требовалось подобрать такие размеры задачи и числа процессоров, чтобы отразить на графике характерные точки, описывающие свойства алгоритма и программы.

Участник:Lvs/Итерационный метод решения системы линейных алгебраических уравнений GMRES

2016-11-17T11:15:14Z

Dan:

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Итерационный метод решения системы линейных алгебраических уравнений GMRES (или обобщенный метод минимальных невязок) используется для решения систем линейных алгебраических уравнений с заданной точностью приближения. Метод основан на процессе Арнольди, посредством которого матрица СЛАУ приводится к (верхней) хессенберговой форме.

== Математическое описание алгоритма ==
Дана система линейных алгебраических уравнений <math>Ax = b</math>, где <math>A</math> - квадратная матрица размера <math>n \times n</math>.

Вычисляется последовательность приближённых решений уравнения <math> x_m </math>, которая сходится к точному решению уравнения <math>x^*</math>.

Подпространство Крылова размерности <math>m</math>, порожденное вектором <math>b</math> и матрицей <math>A</math> – линейное пространство
<math>K_m(A, v)</math>, являющееся линейной оболочкой векторов <math>b, Ab, A^2b, ..., A^{m-1}b</math>.

Приближённое решение считается по формуле <math> x_m = Q_my_m</math>, где <math>Q_m</math> - матрица размера <math>n \times m</math>, составленная из векторов ортонормированного базиса пространства <math>K_m(A, v)</math>, <math>y_m \in \mathbb{R}^m</math>.

Итоговым считается решение, минимизирующее норму невязки (<math>||r||_2 = ||b - Ax_m||_2</math>) с заданной точностью.

Для вычисления векторов ортонормированного базиса используется алгоритм Арнольди:
<source>
q[1] = b/||b||
for j = 1, ..., n-1 do
z = Aq[j]; //очередной вектор
for i = 1,..., j do
h[i][j] = (z, q[i]);
z = z − h[i][j]q[i];
end i
h[j+1][j] = ||z||;
if (h[j+1][j] == 0) break;
q[j+1] = z/h[j+1][j];
end j
</source>
Сложность алгоритма <math>O(n^2)</math>.

На каждом шаге алгоритма получаются векторы <math>q_1, q_2, ..., q_m</math>, являющиеся ортонормированным базисом Крыловского пространства <math>K_m(A, b)</math>.

Значения <math>h_{i,j}</math> образуют верхнюю матрицу Хессенберга (обозначим как <math>H_m</math>, размерность <math>m+1 \times m</math>).

<math>H_k = \begin{bmatrix}h_{11} & h_{12} & h_{13} &... & h_{1m-1} & h_{1m} \\ h_{21} & h_{22} & h_{23} & ... & h_{2m-1} & h_{2m} \\ 0 & h_{32} & h_{33} &...& h_{3m-1} & h_{3m} \\ ... & ... & ... & ... & ... & ... \\ 0 & 0 & 0 & ... & h_{m m-1} & h_{mm} \\0 & 0 & 0 & ... & 0 & h_{m+1 m}\end{bmatrix}</math>.

Вектор невязки задан уравнением <math>r_m = H_my_m - ||b - Ax_0||e_1</math>, где <math>x_0</math> - вектор начального приближения. Минимизация второй нормы вектора невязки представляет из себя решение линейной задачи минимальных квадратов размера <math>n</math>.

Приближённое решение вычисляется по формуле <math> x_m = Q_my_m</math> после нахождения соответствующего значения минимизирующего вторую невязку вектора. Сложность вычислений <math>O(nm)</math>
== Вычислительное ядро алгоритма ==
Самая трудоёмкая и самая часто вызываемая операция в алгоритме - умножение матрицы на вектор. В первую очередь это связано с вычислением матрицы Хессенберга.
== Макроструктура алгоритма ==
# Алгоритм Арнольди
# Решение линейной задачи минимальных квадратов
# Вычисление решения
== Схема реализации последовательного алгоритма ==
<source>
Вычислить ортонормированный базис размера m
Вычислить минимальное приближение
if (приближение < заданная точность)
Вычислить результат
return;
else
Повторить для m = m+1
</source>
== Последовательная сложность алгоритма ==
Сложность вычислений собственных векторов на каждом шаге - <math>O(n^2)</math>, но может уменьшиться до <math>O(n)</math> при более разреженной матрице.

Сложность решения задачи минимальных квадратов <math>O(m^2)</math>, но при последовательном выполнении алгоритма можно понизить сложность до <math>O(m)</math> путём использования подсчитанных на прошлых итерациях значений.

Сложность вычисления решения <math>O(nm)</math>, поэтому его целесообразно вычислять только в конце.
== Информационный граф ==
Основной ресурс параллелизма - умножение матрицы на вектор. Для этой операции информационный граф представлен на рисунке.

[[file:GraphLvs2FM.jpg|thumb|center|700px|Рис.1. Информационный граф умножения матрицы на вектор]]

== Ресурс параллелизма алгоритма ==
# Параллельное умножение матрицы на вектор выполняется в <math> n </math> ярусов умножений и сложений.
# Шаги алгоритма Арнольди выполняются строго последовательно, однако последующее нахождение невязки можно выполнять параллельно с запуском следующего шага алгоритма.
# Сложность решения задачи минимальных квадратов зависит от используемого алгоритма. В отличие от последовательного метода данные, полученные на прошлых шагах здесь использовать нельзя.
# Вычисление результата выполняется один раз, его можно выполнить параллельно в <math> n </math> ярусов умножений и сложений.

== Входные и выходные данные алгоритма ==
'''Входные данные:''' Матрица <math>A</math>, вектор <math>b</math>, точность <math>t</math>. Объём: <math>n^2 + n + 1</math>

'''Выходные данные:''' Вектор <math>x_m</math>. Объём: <math>n</math>

== Свойства алгоритма ==
Теоретически на каждой итерации алгоритма сложность вычислений составляет <math>n + X</math> операций умножения, где <math>X</math> - сложность алгоритма для решения задачи минимальных квадратов. Таким образом в худшем случае сложность будет примерно равна <math>n^2 + X*n + n</math> операций умножения.

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

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

== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Реализации алгоритма GMRES присутствуют во многих программных продуктах как части стандартных библиотек, например Matlab или DEFORM3D. Также существую отдельные библиотеки, например MGMRES для языка С++.

= Литература =
[1] Тыртышников Е. Е. Методы численного анализа — М., Академия, 2007.

[2] М. Дана, А. Г. Зыков, Х. Д. Икрамов Метод минимальных невязок для специального класса линейных систем с нормальными матрицами коэффициентов - Ж. вычисл. матем. и матем. физ., 2005, том 45, номер 11

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

2016-11-17T11:14:56Z

Dan:

= Пункт 2.4 =
[[Участник:Dan|Dan]] ([[Обсуждение участника:Dan|обсуждение]]) 14:14, 17 ноября 2016 (MSK) необходимо переработать:

Требования были такие:
- Реализация: полностью собственная или обращение к библиотечной функции (Intel MKL, PETSc, FFTW, ScaLAPACK). В любом случае, текст исследуемой программы должен быть представлен в отчете.
- Компьютерная платформа может быть любой (Ломоносов, BlueGene или что-то иное). Описание компьютерной платформы должно быть в отчете.
- Должен быть представлен график сильной масштабируемости (зависимости производительности от числа процессов; если при этом
ещё и зависимость от размера задачи - это только в плюс). График должен выглядеть пристойно и понятно, оси и единицы измерения должны быть подписаны. К графику обязательно должны быть словесные пояснения! Требовалось подобрать такие размеры задачи и числа процессоров, чтобы отразить на графике характерные точки, описывающие свойства алгоритма и программы.

Участник:Obirvalger/Метод рекурсивной координатной бисекции

2016-11-17T11:14:31Z

Dan:

{{algorithm
| name = Рекурсивная координатная бисекция
| serial_complexity = <math>O(n \log_2{n} \log_2{k})</math>
| pf_height = <math>\log_2{k}</math>
| pf_width = <math>k</math>
| input_data = <math>N|V| + |G|</math>
| output_data = <math>|V|</math>
}}

Авторы: [[Участник:Obirvalger|Гордеев Михаил]] (разделы 1.4, 1.6, 1.8, 1.10), [[Участник:KolmakovEA|Колмаков Евгений]] (разделы 1.1, 1.2, 1.3, 1.5, 1.7, 1.9, 2.7).

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

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

=== Задача декомпозиции графа ===
'''Метод рекурсивной координатной бисекции''' является одним из методов, применяемых для декомпозиции графов <ref>Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2012. – 328 с., илл. – (Серия «Суперкомпьютерное образование»), ISBN 978-5-211-06382-2 URL: http://lira.imamod.ru/ITTPMOPS/</ref>. В прикладных задачах, как правило, граф
представляет собой сетку в пространстве некоторой размерности. При численном решении задач механики сплошной среды с помощью методов конечных разностей или конечных элементов широко используется геометрический параллелизм, при котором сетка, покрывающая расчётную область, разбивается на множество доменов, каждый из которых обрабатывается отдельным процессором. Основная проблема связана с необходимостью решения задачи статистической балансировки загрузки, то есть равномерного распределения вычислительной нагрузки между процессорами за счёт выбора оптимальной декомпозиции сетки.

=== Критерии декомпозиции ===
В зависимости от специфики решаемой задачи, к виду декомпозиции графов могут быть предъявлены разные требования. Существует много критериев декомпозиции, однако наиболее классическим из них считается минимизация максимального веса исходящих из домена ребёр (в простейшем случае - минимизация числа разрезанных ребер). Среди других критериев можно выделить следующие:
* выделение обособленных доменов;
* минимизация максимальной степени доменов;
* обеспечение связности доменов;
* обеспечение связности множества внутренних узлов доменов.

=== Метод рекурсивной бисекции ===
Метод рекурсивной координатной бисекции является частным случаем более общего '''метода рекурсивной бисекции'''. В этом методе сетка последовательно за <math>k-1</math> шаг делится на <math>k</math> частей. На первом шаге сетка делится на две части, далее каждая из полученных ранее частей также делится на две части и т.п. Конкретные алгоритмы деления сетки на две части (бисекции) и определяют метод рекурсивной бисекции. Соотношение размеров частей зависит количества доменов и процедуры вычисления желаемого числа вершин в каждой из формируемых частей графа.

=== Метод рекурсивной координатной бисекции ===
Для декомпозиции больших сеток применяют параллельные алгоритмы, предполагающие, что сетка уже распределена по процессорным узлам. Они эффективны, только если вершины распределены по процессорам компактными группами, а не произвольно. Однако к моменту начала работы алгоритмов декомпозиции, никакая декомпозиция сетки еще не найдена, поэтому требуется некоторый простой способ предварительного распределения графа по выполняющим декомпозицию процессорам. Для решения этой задачи и используется метод рекурсивной покоординатной бисекции. Несмотря на то, что он уступает по качеству формируемой декомпозиции некоторым другим методам, его целесообразно использовать на предварительном этапе, благодаря скорости работы, ориентированности на распределенную обработку и простоте.

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

=== Выбор координатной оси ===
В зависимости от [[#Критерии декомпозиции|критериев декомпозиции]] и других особенностей задачи могут быть использованы различные критерии выбора координатной оси вдоль, которой будет производится разбиение сетки на две части. Наиболее используемыми являются следующие:
* Протяжённость области вдоль данной оси: для каждой оси вычисляется разность между максимумом и минимумом координат вершин сетки по данной оси, и выбирается ось с наибольшим значением этой величины;
* Число разрезанных ребер при разбиении сетки вдоль данной оси: вершины упорядочиваются вдоль каждой из осей, и выбирается тот вариант, который приводит к наименьшему числу разрезанных ребер;

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

Исходные данные: граф <math>G = (V, E) </math>, вложенный в <math>\mathbb{R}^N</math> (то есть каждая вершина этого графа - это точка в <math>N</math> мерном пространстве), и число <math>k</math> доменов, на которое нужно разбить граф.
Под ''декомпозицией'' графа на <math>k</math> доменов понимается разбиение множества вершин <math>V</math> на <math>k</math> подмножеств <math>V_1, \dots, V_k</math> таких, что

<center><math>V = \bigcup_{i = 1}^k V_i</math> и <math>V_i \cap V_j = \varnothing</math> при <math>i \neq j</math>.</center>

С каждым доменом можно связать порождённый им подграф <math>G(V_i) = (V_i, E_i)</math>, где <math>E_i \subseteq E</math> - множество рёбер, оба конца которых принадлежат домену.

Задача заключается в нахождении декомпозиции <math>V_1, \dots, V_k</math>, доставляющей минимум некоторого функционала (см. [[#Критерии декомпозиции| соответствующий пункт]]), например, числа разрезанных рёбер <math>E_{\mbox{cut}} = |\{(u, v) \in E \mid u \in V_i, v \in V_j, i \neq j\}| = |E| - \sum_{i = 1}^k |E_i|</math>.

Дадим формальное описание алгоритма. Как уже упоминалось, метод основан на алгоритме рекурсивной бисекции, поэтому представляет собой рекурсивную процедуру, на вход которой поступает граф <math>G = (V, E) </math> и число доменов <math>k</math>, на которое нужно разбить множество вершин данного графа. Внутри этой процедуры выполняется следующая последовательность действий:
* в зависимости от числа доменов вычисляется "желаемое" число доменов и вершин в каждой из частей разбиения;
* вызывается процедура координатной бисекции для получения разбиения графа на две части;
* для каждой из двух полученных частей рекурсивно вызывается описываемая процедура (если число доменов для этой части больше единицы).

Процедура координатной бисекции устроена следующим образом:
* [[#Выбор координатной оси| выбирается]] координатная ось <math>m^* \in \{1, \dots, N\}</math>;
** в случае максимизации протяженности: для каждой оси <math>m</math> вычисляется величина <math>l_m = \max_{v \in V} v_m - \min_{v \in V} v_m</math>, и выбирается ось <math>m^* = \arg\max_{m \in \{1, \dots, N\}} l_m</math>;
** в случае минимизации числа разрезанных ребер: вершины упорядочиваются вдоль каждой из осей, для каждой оси вычисляется величина <math>E^m_{\mbox{cut}}</math>, равная числу разрезанных ребер при разбиении вдоль данной оси, и выбирается ось <math>m^* = \arg\max_{m \in \{1, \dots, N\}} E^m_{\mbox{cut}}</math>;
* множество вершин сортируется по возрастанию координаты с номером <math>m^*</math>;
* отсортированный массив вершин делится на две (непрерывные) части в соответствии с желаемым числом вершин в каждой из частей;
**как правило, выбирается индекс <math>i = \lfloor\frac{k+1}{2k}\rfloor \cdot |V|</math>, соответствующий примерно равному разделению текущего графа на части;
* первая часть состоит из вершин <math>v \in V</math> с индексами <math>j \leqslant i</math>, вторая - с индексами <math>j > i</math>.

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма составляют сортировки массива вершин сетки по выбранной координате при каждом из <math>k - 1</math> вызовов процедуры бисекции.

Также, в зависимости от критерия выбора координатной оси, требуются дополнительные вычисления:
*В случае максимизации протяженности при каждом вызове требуется вычисление величины <math>l_m</math>.
*В случае минимизации числа разрезанных ребер при каждом вызове требуется сортировка по каждой из координат (таким образом, при каждом разбиении осуществляется <math>N</math> сортировок).

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют множественные (всего <math>k-1</math>) сортировки (функция argsort в коде в [[#Схема реализации последовательного алгоритма |следующем разделе]]).

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

Опишем последовательную реализацию метода рекурсивной координатной бисекции, где выбор оси производится исходя из условия максимизации протяженности вдоль этой оси. Ниже представлен код данного алгоритма на языке Python 3.

<source lang="python">
# Переменная для хранения результата работы алгоритма
partition = []

# V - numpy.ndarray размера |V| x N, k - число доменов
def recursive_bisection(V, k):

global partition

# Если текущая часть графа есть домен, добавляем ее к результату разбиения
if (k <= 1):
partition.append(V)
return

# Вычисляем количество доменов в каждой из частей
k1 = (k + 1) / 2
k2 = k - k1

# Производим разбиение
V1, V2 = bisect(V, k)

# Рекурсивно разбиваем каждую из частей
recursive_bisect(V1, k1)
recursive_bisect(V2, k2)

def bisect(V, k):
# Вычисляем координату с наибольшей протяженностью
t = V.max(axis=0) - V.min(axis=0)
m = t.argmax()

# Сортируем вершины по координате с номером m
V_sorted = V[V[:, m].argsort()]

# Вычисляем индекс для разбиения в соответствии с числом доменов
ind = (k + 1) * V.shape[0] // (2 * k)

return V_sorted[:ind, :], V_sorted[ind:, :]
</source>

Приведённый код предназначен для более подробного описания основных шагов в алгоритме, представляет собой лишь схему и не является максимально эффективным. Это сделано для того, чтобы код был более наглядным. В более эффективной реализации, например, вместо создания массивов в процедуре bisect можно везде оперировать только индексами.

== Последовательная сложность алгоритма ==
Обозначим через <math>D_k(n)</math> сложность алгоритма рекурсивной координатной бисекции для декомпозиции графа с <math>n</math> вершинами на <math>k</math> доменов.

Определим величину <math>D(n) = D_n(n)</math>. Для <math>D(n)</math> имеет место следующее рекуррентное равенство:

<center>
<math>
\begin{array}{l}
D(n) = S(n) + 2D(\frac{n}{2}) \\
D(1) = S(1) = 0. \\
\end{array}
</math>, где <math>S(n)</math> - это сложность алгоритма сортировки массива из <math>n</math> элементов.
</center>

Пусть <math>S(n) = O(n\log_2{n})</math> (например, для сортировки слиянием), тогда по теореме о рекуррентных соотношениях <ref>https://ru.wikipedia.org/wiki/Основная_теорема_о_рекуррентных_соотношениях</ref> для произвольного положительного <math>\varepsilon</math> имеет место оценка <math>D(n) \lesssim n^{1+\varepsilon}</math>.

Величину <math>D_k(n)</math> можно явно посчитать по формуле <math>\sum\limits_{i=0}^{\lceil\log_2{k}\rceil}2^i S(\frac{n}{2^i})</math>. Если использовать сортировку со сложностью <math>S(n) = O(n\log_2{n})</math>, то
<center>
<math>D_k(n) = </math> <math>O(\sum\limits_{i=0}^{\lceil\log_2{k}\rceil}2^i \frac{n}{2^i} \log_2{\frac{n}{2^i}}) = </math> <math>O(n\log_2(\prod\limits_{i=0}^{\lceil\log_2{k}\rceil}\frac{n}{2^i})) = </math> <math>O(n\log_2{\frac{n^{\log_2{k}}}{2^\frac{\log_2{k}(\log_2{k}+1))}{2}}}) =</math> <math> O(n(\log_2{n}\log_2{k} - \frac{\log^2_2{k}}{2})) = </math> <math>O(n\log_2{n}\log_2{k})</math>.
</center>

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

Под операцией в данном пункте будем понимать макрооперацию сортировки. Передача данных происходит после разбиения множества вершин на две части.
Таким образом, информационный граф представляет из себя бинарное дерево с <math>k</math> листьями. На рисунке ниже приведена часть информационного графа для <math>k = 16</math>. Зависимость от числа вершин <math>n</math> учитывается в самих узлах дерева.

<center>
[[Файл:Tree_sort.svg|thumb|center|800px|Рисунок 1. Граф алгоритма.]]
</center>

Высота ярусно-параллельной формы - <math>\log_2{k}</math>.

Ширина ярусно-параллельной формы - <math>k</math>.

Если рассматривать более мелкие операции, используемые в процессе сортировки, то глобально информационный граф будет выглядеть также, однако каждый
узел будет заменён на информационный граф используемого алгоритма сортировки (или <math>N</math> таких графов, если используется критерий минимизации числа разрезов).

== Ресурс параллелизма алгоритма ==
Данный алгоритм обладает координатным параллелизмом.
Для декомпозиции графа с <math>n</math> вершинами на <math>k</math> доменов методом рекурсивной координатной бисекции в параллельном варианте требуется последовательно выполнить <math>\lceil\log_2{k}\rceil</math> ярусов. На <math>i</math>-ом ярусе будет выполнятся <math>2^i</math> операций сортировки.
Рассмотрим два случая распараллеливания нашего алгоритма:
* Параллельное выполнение операций на каждом ярусе с использованием последовательного алгоритма сортировки со сложностью <math>O(n\log_2{n})</math>.
# На первом шаге один процессор производит сортировку всех вершин, разделяет граф на два подграфа и передает однин из подрафов новому процессору.
# На <math>i</math>-ом шаге каждый из уже получивший свой граф процессор производит сортировку всех вершин, разделяет граф на два подграфа и передает однин из подрафов новому процессору.

Тогда сложность нашего алгоритма равна:
<center>
<math>D_k(n) = O(\sum\limits_{i=0}^{\lceil\log_2{k}\rceil}\frac{n}{2^i} \log_2{\frac{n}{2^i}}) = </math> <math>n\sum\limits_{i=0}^{\lceil\log_2{k}\rceil}(\frac{\log_2{n}}{2^i} - \frac{i}{2^i}) = </math> <math>O(n\log_2{n}) - O(n) = O(n\log_2{n})</math>.
</center>

*Параллельное выполнение операций на каждом ярусе с использованием параллельного алгоритма сортировки со сложностью <math>O(\log_2^2{n})</math><ref>https://en.wikipedia.org/wiki/Batcher_odd–even_mergesort</ref>.
На каждом шаге производится параллельная сортировка вершин и разбиение графа на два подграфа.
В этом случае

<center>
<math>D_k(n) = \sum\limits_{i=0}^{\lceil\log_2{k}\rceil}\log^2_2\frac{n}{2^i} = O(\log^2_2{n}\log_2{k}) = O(\log^3_2{n})</math>.
</center>
Известно <ref>https://en.wikipedia.org/wiki/Sorting_algorithm</ref>, что оптимальная параллельная сортировка имеет сложность <math>O(\log_2{n})</math>. В этом случае
<center>
<math>D_k(n) = \sum\limits_{i=0}^{\lceil\log_2{k}\rceil}\log_2\frac{n}{2^i} = O(\log_2{n}\log_2{k})</math>.
</center>

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

'''Входные данные:''' граф <math>G = (V, E) </math>, вложенный в <math>\mathbb{R}^N</math>, и число <math>k</math> частей (доменов), на которое нужно разбить граф. Таким образом, помимо матрицы смежности (или любого другого представления графа) для каждой вершины <math>v \in V</math> задан набор её координат <math>v = (v_1, \dots, v_N) \in \mathbb{R}^N</math>, поэтому <math>V</math> задаётся массивом <math>N</math>-мерных векторов или матрицей размера <math>|V| \times N</math>.

'''Объём входных данных:''' <math>N|V| + |G|</math>, где <math>|G|</math> - объём данных, представляющих граф <math>G</math>, который в общем случае зависит от выбранного представления.

'''Выходные данные:''' <math>k</math> доменов графа <math>G</math>, задающих его декомпозицию.

'''Объём выходных данных:''' <math>|V|</math> - для каждого домена достаточно хранить соответствующие вершинам из этого домена индексы строк в матрице, представляющей множество вершин.

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности в случае неограниченных ресурсов является ''линейным'' (отношение <math>O(n\log{n})</math> к <math>O(\log{n}))</math>.

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

Так как количество вершин на разных процессорах примерно одинаковое алгоритм является сбалансированным по числу операций на каждом процессоре.

Алгоритм достаточно прост и легко модифицируется в зависимости от критерия декомпозиции.

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

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

Ниже приведен пример реализации последовательного алгоритма на языке C++. Следует отметить, что исходный массив вершин не изменяется, вся работа осуществляется с индексами.
<source lang = "c++">
#include <algorithm>
#include <iostream>
#include <vector>

using namespace std;

vector<vector<double> > points_matrix;
vector<vector<int> > graph_partition;

double span(vector<double> &x, vector<int> &idx)
{
double max_value = x[idx[0]];
double min_value = x[idx[0]];

for (size_t i = 1; i < idx.size(); i++) {
max_value = (x[idx[i]] > max_value) ? x[idx[i]] : max_value;
min_value = (x[idx[i]] < min_value) ? x[idx[i]] : min_value;
}

return max_value;
}

vector<int> bisect(vector<int> &idx)
{
double max_span = 0;
double max_ind = 0;

// finding coordinate with maximal span
for (size_t i = 0; i < points_matrix.size(); i++) {
double cur_span = span(points_matrix[i], idx);
if (cur_span > max_span) {
max_span = cur_span;
max_ind = i;
}
}

// sorting vertices along this coordinate
vector<int> sorted_idx = idx;

sort(sorted_idx.begin(), sorted_idx.end(),
[&](const int& a, const int& b) {
return points_matrix[max_ind][idx[a]] < points_matrix[max_ind][idx[b]];
});

return sorted_idx;
}

void recursive_bisection(vector<int> &idx, int k)
{
// adding current domain to partition
if (k < 2) {
graph_partition.push_back(idx);
return;
}

int k1 = (k + 1) / 2;
int k2 = k - k1;

// bisecting current graph
vector<int> sorted_idx1 = bisect(idx);
vector<int> sorted_idx2(make_move_iterator(sorted_idx1.begin() + k1 * sorted_idx1.size() / k),
make_move_iterator(sorted_idx1.end()));
sorted_idx1.erase(sorted_idx1.begin() + k1 * sorted_idx1.size() / k, sorted_idx1.end());

recursive_bisection(sorted_idx1, k1);
recursive_bisection(sorted_idx2, k2);
}

int main()
{
// example: 2x4-mesh
points_matrix = {{0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0}, {0.0, 1.0, 2.0, 3.0, 0.0, 1.0, 2.0, 3.0}};
vector<int> idx = {0, 1, 2, 3, 4, 5, 6, 7};
int k = 4;

recursive_bisection(idx, k);

for(size_t i = 0; i < graph_partition.size(); ++i) {
for(size_t j = 0; j < graph_partition[i].size(); ++j)
cout << graph_partition[i][j] << " ";
cout << endl;
}
}
</source>

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

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

== Масштабируемость алгоритма и его реализации ==
В статье <ref>http://glaros.dtc.umn.edu/gkhome/node/112</ref> приводятся результаты работы алгоритма декомпозиции графов из пакета ParMETIS. В таблице ниже приведено время работы алгоритма в зависимости от числа вершин в графе и используемого числа процессоров. Рассмотравились следующие графы:
граф mrng2 с 1 миллионом вершин, mrng3 с 4 миллионами и граф mrgn4 с 7.5 миллионами вершин.

{| class="wikitable"
|+ Время выполнения разбиения графа с использованием Parmetis
|-
! Graph
! 8 processors
! 16 processors
! 32 processors
! 64 processors
! 128 processors
|-
| mrng2
| 5.4
| 3.1
| 2.1
| 1.5
| 1.7
|-
| mrng3
| 15.8
| 8.8
| 4.8
| 3.0
| 2.7
|-
| mrng4
| 38.6
| 16.2
| 8.8
| 5.0
| 3.6
|}

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

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

== Существующие реализации алгоритма ==
Описанный алгоритм реализован во многих пакетах декомпозиции графов, включающих в себя и другие версии алгоритма бисекции.

Последовательная версия алгоритма реализована в пакетах Chaco, JOSTLE, [http://glaros.dtc.umn.edu/gkhome/metis/metis/overview METIS], [https://www.labri.fr/perso/pelegrin/scotch/ SCOTCH].

Параллельная версия реализована в пакетах JOSTLE, [http://glaros.dtc.umn.edu/gkhome/metis/parmetis/overview ParMETIS], [https://www.labri.fr/perso/pelegrin/scotch/ PT-SCOTCH].

Стоит отметить, что пакеты METIS и ParMETIS распространяются свободно.

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

[[en:Recursive coordinate bisection method]]

Обсуждение участника:Макарова Алёна

2016-11-17T11:13:56Z

Dan: /* Пункт 1.7 */

= Пункт 2.4 =
[[Участник:Dan|Dan]] ([[Обсуждение участника:Dan|обсуждение]]) 14:13, 17 ноября 2016 (MSK) необходимо доработать:

Требования были такие:
- Реализация: полностью собственная или обращение к библиотечной функции (Intel MKL, PETSc, FFTW, ScaLAPACK). В любом случае, текст исследуемой программы должен быть представлен в отчете.
- Компьютерная платформа может быть любой (Ломоносов, BlueGene или что-то иное). Описание компьютерной платформы должно быть в отчете.
- Должен быть представлен график сильной масштабируемости (зависимости производительности от числа процессов; если при этом
ещё и зависимость от размера задачи - это только в плюс). График должен выглядеть пристойно и понятно, оси и единицы измерения должны быть подписаны. К графику обязательно должны быть словесные пояснения! Требовалось подобрать такие размеры задачи и числа процессоров, чтобы отразить на графике характерные точки, описывающие свойства алгоритма и программы.

Участник:Макарова Алёна/Итерационный метод решения системы линейных алгебраических уравнений GMRES (обобщенный метод минимальных невязок)

2016-11-17T11:13:41Z

Dan:

{{algorithm
| name = Обобщенный метод минимальных невязок
| serial_complexity = <math>O(nm^2)</math>
| input_data = <math>n(n + 1)</math>
| output_data = <math>n</math>
}}

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

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

Метод минимальных невязок представляет собой итерационный метод для численного решения несимметричной системы линейных уравнений. Метод приближает решение вектором в подпространстве Крылова с минимальной невязкой. Чтобы найти этот вектор используется итерация Арнольди.

Впервые метод минимальных невязок был описан в книге Марчука и Кузнецова "Итерационные методы и квадратичные функционалы" <ref> Г.И. Марчук, Ю.А. Кузнецов, Итерационные методы и квадратичные функционалы, Методы вычислительной математики, Новосибирск, 1975, с. 4-143.</ref> и представлял собой геометрическую реализацию метода минимальных невязок.

Алгебраическая реализация метода минимальных невязок была предложена Саадом и Шульцем в 1986 году <ref>Y.Saad, M.H. Schultz, GMRES: A generalized minimal residual algorithm for solving nonsymmetric linear systems, SIAM J. Scientific and Stat. Comp. 7: 856-869 (1986). </ref>. С их подачи за методом закрепилась аббревиатура GMRES (обобщенный метод минимальных невязок).

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

Для решения системы <math>Ax = b</math> с невырожденной матрицей <math>A</math>, выбирается начальное приближение <math>x_0</math>, затем решается редуцированная система <math>Au = r_0</math>, где <math>r_0 = b - Ax_0, x = x_0 + u</math>. Подпространства Крылова строятся для редуцированной системы (в предположении, что <math>r_0 \neq 0</math>).

Пусть <math>x_i = x_0 + y</math>, где <math> y \in \mathcal{K}_i </math>. Невязка имеет вид <math>r_i = r_0 - Ay</math>, а её длина минимальна, в силу теоремы Пифагора, в том и только том случае, когда

:<math>

r_i \perp A\mathcal{K}_i

</math>.

Таким образом, для реализации <math>i</math>-го шага требуется опустить перпендикуляр из вектора <math>r_0</math> на подпространство <math>A\mathcal{K}_i</math>. Проще всего это сделать, если в данном подпространстве уже найден ортогональный базис. <ref> Тыртышников Е. Е. Методы численного анализа — М., Академия, 2007.</ref>.

==== Геометрическая реализация ====

''Геометрическая реализация'' метода минимальных невязок заключается в построении последовательности векторов <math>q_1, q_2,...</math> таким образом, что <math>q_1, q_2,.., q_i</math> дают базис в подпространстве Крылова <math>\mathcal{K}_i</math> и при этом вектора <math>p_1 = Aq_1, ..., p_i = Aq_i</math> образуют ортогональный базис в подпространстве <math>A\mathcal{K}_i</math>. Вектор <math>q_{i+1} \notin \mathcal{K}_i</math> должен обладать следующими свойствами:
:<math>

q_{i+1} \in \mathcal{K}_{i+1}, p_{i+1} = Aq_{i+1} \perp A\mathcal{K}_i

</math>.

Его можно получить с помощью процесса ортогонализации, применённого к вектору <math>p = Aq</math>, где <math>q = Aq_i</math>. В геометрической реализации необходимо хранить две системы векторов: <math>q_1, ..., q_i</math> и <math>p_1, ..., p_i</math>.

==== Алгебраическая реализация ====

''Алгебраическая реализация'' метода минимальных невязок использует лишь одну систему векторов, образующих ортогональные базисы в подпространствах <math>\mathcal{K}_i</math>.

<math>q_1 = r_0/||r_0||_2</math>. Чтобы получить ортонормированный базис <math>q_1, ..., q_{i+1}</math> в <math>\mathcal{K}_{i+1} = \mathcal{K}_{i+1}(r_0, A)</math>, проводим ортогонализацию вектора <math>Aq_i</math> к векторам <math>q_1, ..., q_i</math>. Если <math>Q_i \equiv [q_1, ..., q_i] \in \mathbb{C}^{n*i}</math>, то получим

:<math>

AQ_i = Q_{i+1}\hat{H_i}, \hat{H_i}= \begin{bmatrix} H_i \\ 0 ... 0 & h_{i+1 i} \end{bmatrix},

</math>

где <math>H_i</math> - верхняя хессенбергова матрица порядка <math>i</math>.

Далее рассмотрим <math>QR</math>-разложение прямоугольной матрицы <math>\hat{H_i}</math>:

:<math>

\hat{H_i} = U_iR_i, R_i \in \mathbb{C}^{i*i}

</math>.

Тогда минимум невязки <math>||r_0 - AQ_iy||_2</math> по всем <math>y</math> будет достигаться в том случае, если <math>y = y_i</math> удовлетворяет уравнению

:<math>

R_iy_i = z_i \equiv ||r_0||_2U^T_ie_1, e_1 = \begin{bmatrix} 1 0 ... 0 \end{bmatrix}^T,

</math>.

Матрица <math>R_i</math> невырожденная, следовательно,

:<math>

x_i = x_0 + Q_iy_i = x_0 + Q_iR_i^{-1}z_i

</math>.

==== Сходимость метода ====

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

Но об этом не верно говорить в общем. Согласно теореме (Greenbaum, Pták and Strakoš), для каждой монотонной последовательности <math> a_1,..., a_{m-1}, a_m = 0 </math>, найдётся матрица <math>A</math> такая что <math>||r_n|| = a_n</math> для всех <math>n</math>, где <math>r_n</math> невязка, определенная ранее.

На практике для матрицы порядка <math>n</math> число шагов может оказаться равным <math>n</math>, а норма невязки может оставаться равной норме начальной невязки на всех шагах, кроме последнего.

'''Пример'''

:<math>

\begin{bmatrix} 0 1 & ... \\ 0 0 1 & ... \\...\\... & 01 \\1 & ... \end{bmatrix} \begin{bmatrix} 1 \\ 0 \\...\\ 0 \\ 0 \end{bmatrix} = \begin{bmatrix} 0 \\ 0 \\...\\ 0 \\ 1 \end{bmatrix}

</math>

Если <math> x_0 = 0 </math>, то <math> r_0 = b</math>. Подпространства Крылова получаются такие:

:<math>

\mathcal{K}_i = span \{ e_n, e_{n-1}, ..., e_{n-i+1}\}, i \le i \le n

</math>

Точное решение системы имеет вид <math>x = e_1</math>, а на итерациях получаются следующие векторы:

:<math>

x_0 = x_1 = ... = x_{n-1} = 0, x_n = e_1

</math>.

Для получения оценок требуются дополнительные предположения относительно матрицы коэффициентов.

===== Сходимость для положительно определенной матрицы =====

Если матрица <math>A</math> положительно определена, то
:<math>
\|r_n\| \leq \left( 1-\frac{\lambda_{\mathrm{min}}^2(1/2(A^T + A))}{ \lambda_{\mathrm{max}}(A^T A)} \right)^{n/2} \|r_0\|,
</math>,
где <math>\lambda_{\mathrm{min}}(M)</math> и <math>\lambda_{\mathrm{max}}(M)</math> обозначают наибольшее и наименьшее собственное значение матрицы <math>M</math>, соответственно. <ref>Eisenstat, Elman & Schultz, Thm 3.3. NB all results for GCR also hold for GMRES, cf. Saad & Schultz</ref>

===== Сходимость для симметричной матрицы =====
Если матрица <math>A</math> является симметрично и положительно определена, тогда

:<math>

\|r_n\| \leq \left( \frac{\kappa_2(A)^2-1}{\kappa_2(A)^2} \right)^{n/2} \|r_0\|

</math>,
где <math>\kappa_2(A)</math> число обусловленности матрицы <math>A</math> в Евклидовой норме.

Если не требовать положительной определённости
:<math>
\|r_n\| \le \inf_{p \in P_n} \|p(A)\| \le \kappa_2(V) \inf_{p \in P_n} \max_{\lambda \in \sigma(A)} |p(\lambda)| \|r_0\|, \,
</math>
где <math>P_n</math> обозначает множество полиномов степени не выше <math>n</math> и <math>p(0) = 1</math>, матрица <math>V</math> появляется из спектрального разложения матрицы <math>A</math> и <math>\sigma(A)</math> - спектр матрицы <math>A</math>. Грубо говоря, это означает, что быстрая сходимость имеет место, когда собственные значения матрицы <math>A</math> невелики и <math>A</math> не сильно отклоняется от нормальной матрицы.<ref>Trefethen & Bau, Thm 35.2</ref>

Все эти неравенства связаны с невязкой вместо фактической ошибки, т.е. расстоянием между текущей итерацией и точным решением.

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

Самой трудоёмкой процедурой в методе является <math>QR</math>-разложение <math>\hat{H_i}</math>. В общем случае требуется <math>\mathcal{O}(i^3)</math> арифметических операций, однако то, что <math>\hat{H_i}</math> является хессенберговой матрицей, позволяет сократить требуемый объём до <math>\mathcal{O}(i^2)</math> действий.

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

Алгоритм начинается с выбора начального приближения <math>x_0</math>.
Далее для <math>i = 1,2 ..</math>
: 1. Вычисляем матрицу <math>\hat{H_i}</math>.
: 2. Находим её <math>QR</math>-разложение: <math>\hat{H_i} = U_iR_i</math>.
: 3. Решаем систему <math>R_iy_i = U^T_ie_1</math>.
: 4. Находим приближение <math>x_i = x_0 + Q_iy_i</math>.

Алгоритм завершается, когда норма вектора невязки становится достаточно малой. При большом числе итераций вычислительные затраты и требуемая для хранения векторов <math>p_i</math> память могу оказаться чрезмерно большими. В таких случаях применяют алгоритм с перезапусками (restart): задают максимальную допустимую размерность <math>K</math> пространств Крылова <math>\mathcal{K}_i</math>, и если точность не достигнута, берут полученное приближение в качестве нового начального приближения <math>x^0_{new} = x_K</math>.

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

* Инициализация начальных значений

1. Выбрать начальное приближение <math>x_0</math> и точность решения <math>\epsilon</math>.

2. Для <math> k = 1, 2, .. </math>

* Вычисление невязки

3. <math>r_0 = b - Ax_0</math>, <math>\beta = ||r_0||</math>, <math>q_1 = r_0/\beta</math>.

4. Цикл по <math> j = 1, 2, .. k </math>.

* Ортогонализация Арнольди

5. Для каждого <math> i = 1, 2, .. j </math> вычислим:

:<math>h_{ij} = (Aq_j, q_i)</math>.

6. Построим вектор: <math>z_{j+1} = Aq_j - \sum_{i = 1}^j h_{ij}q_i</math>.

7. Вычислим его норму <math>h_{j+1,j} = ||z_{j+1}||_2</math>.

8. Если <math>h_{j+1,j}</math> = 0, то останавливаемся.

9. Построим очередной вектор базиса <math>q_{j+1} = z_{j+1}/h_{j+1,j}</math>.

10. Конец цикла по <math>j</math>.

11. Процесс требует хранения всех предыдущих элементов базиса:<math>q_1, .. q_k</math>. Будем хранить их в виде матриц <math>Q_k</math>.

* Задача наименьших квадратов

12. Чтобы вычислить <math>x_k = x_0 + Q_ky_k</math>, решаем задачу: <math> y_k = argmin ||r_0 - AP_ky_k||_2</math>.

* Проверка достижения требуемой точности приближения

13. Если <math>||b - Ax_k|| < \epsilon</math>, где <math>x_k = x_0 + Q_ky_k</math> перейти к п.15

14. <math>x_0 = x_k</math>, перейти к п.2

*Конец

15. <math>x^* = x_k</math>

=== Последовательная сложность алгоритма ===
Будем предполагать, что матрица решаемой СЛАУ является разреженной.
Пусть несимметричная матрица <math>A</math> имеет симметричный портрет и число ненулевых элементов в нижнем(верхнем) треугольнике равно <math>k</math>.

При <math> m << n </math> можно говорить, что один GMRES-цикл имеет сложность <math>\mathcal{O}(nm^2)</math>.

Требования по памяти с учетом <math>1 < m << n</math> и <math>k << n</math> составляют <math>\mathcal{O}(mn)</math>.<ref> М.Ю. Баландин, Э.П.Шурина, Некоторые оценки эффективности параллельных алгоритмов решения СЛАУ на подпространствах Крылова, Вычислительные технологии, 1998, Т.3</ref>.

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

Основная и самая трудоёмкая операция в алгоритме - умножение матрицы на вектор. Для этой операции приводится граф вычисления операции.

[[Файл:graf.png|thumb|center|1400px|Рисунок 2. Граф вычислений подзадачи умножения матрицы на вектор<ref> http://ssd.sscc.ru/sites/default/files/content/attach/449/shkorin_-_gmres.pdf</ref>]]

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

В вычислительной схеме присутствуют два интенсивных в вычислительном плане этапа:
:1. Умножение матрицы СЛАУ на вектор (для нахождения невязок).
Для нахождения матрично-векторных произведений при вычислении невязок матрича должна быть подвергнута декомпозиции на строчные блоки.
:2. Нахождение скалярных произведений векторов (при построении ортонормального базиса подпространства Крылова).
Для наиболее эффективного вычисления скалярных проихведений и линейных комбинаций векоров базиса каждый из векторов <math>p_i</math> должен быть разбит на блоки равного размера по числу процессоров.

Кроме того, на хранение векторов базиса приходится бОльшая часть затрат памяти.

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

'''Входные данные: '''
Обязательные параметры:
:<math>A</math> - квадратная матрица ''(n x n)''.
:<math>b</math> - вектор правой части ''(n x 1)''.
Вариативно:
:<math>x_0</math> - начальное приближение (может не передаваться и быть всегда нулевым).
:<math>\epsilon</math> - погрешность (может не передаваться и быть заданным по умолчанию, обычно равна 1e-6).
:Максимальное число итераций.

'''Выходные данные:'''
<math>x^*</math> - решение системы <math>Ax = b</math>

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

:1. Рассматриваемый алгоритм предназначен для решения невырожденных линейных систем большой размерности. При этом симметрия и положительная определенность матрицы не предполагается.

:2. Для систем с разряженной матрицей алгоритм требует гораздо меньшей вычислительной мощности.

:3. Особенностью метода является то, что с целью экономии памяти выбирается некоторая размерность Крылова <math>m</math>, и после того как <math>m</math> базисных векторов построены, решение уточняется.

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

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

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

Реализация GMRES с преобуславливанием на python, доступная в пакете scipy (scipy.sparse.linal)<ref> https://github.com/scipy/scipy/blob/v0.14.0/scipy/sparse/linalg/isolve/iterative.py.</ref>.

<source lang="python">
def gmres(A, b, x0=None, tol=1e-5, restart=None, maxiter=None, xtype=None, M=None, callback=None, restrt=None):
"""
Use Generalized Minimal RESidual iteration to solve A x = b.
Parameters
----------
A : {sparse matrix, dense matrix, LinearOperator}
The real or complex N-by-N matrix of the linear system.
b : {array, matrix}
Right hand side of the linear system. Has shape (N,) or (N,1).
Returns
-------
x : {array, matrix}
The converged solution.
info : int
Provides convergence information:
* 0 : successful exit
* >0 : convergence to tolerance not achieved, number of iterations
* <0 : illegal input or breakdown
Other parameters
----------------
x0 : {array, matrix}
Starting guess for the solution (a vector of zeros by default).
tol : float
Tolerance to achieve. The algorithm terminates when either the relative
or the absolute residual is below `tol`.
restart : int, optional
Number of iterations between restarts. Larger values increase
iteration cost, but may be necessary for convergence.
Default is 20.
maxiter : int, optional
Maximum number of iterations (restart cycles). Iteration will stop
after maxiter steps even if the specified tolerance has not been
achieved.
xtype : {'f','d','F','D'}
This parameter is DEPRECATED --- avoid using it.
The type of the result. If None, then it will be determined from
A.dtype.char and b. If A does not have a typecode method then it
will compute A.matvec(x0) to get a typecode. To save the extra
computation when A does not have a typecode attribute use xtype=0
for the same type as b or use xtype='f','d','F',or 'D'.
This parameter has been superseded by LinearOperator.
M : {sparse matrix, dense matrix, LinearOperator}
Inverse of the preconditioner of A. M should approximate the
inverse of A and be easy to solve for (see Notes). Effective
preconditioning dramatically improves the rate of convergence,
which implies that fewer iterations are needed to reach a given
error tolerance. By default, no preconditioner is used.
callback : function
User-supplied function to call after each iteration. It is called
as callback(rk), where rk is the current residual vector.
restrt : int, optional
DEPRECATED - use `restart` instead.
See Also
--------
LinearOperator
Notes
-----
A preconditioner, P, is chosen such that P is close to A but easy to solve
for. The preconditioner parameter required by this routine is
``M = P^-1``. The inverse should preferably not be calculated
explicitly. Rather, use the following template to produce M::
# Construct a linear operator that computes P^-1 * x.
import scipy.sparse.linalg as spla
M_x = lambda x: spla.spsolve(P, x)
M = spla.LinearOperator((n, n), M_x)
"""

# Change 'restrt' keyword to 'restart'
if restrt is None:
restrt = restart
elif restart is not None:
raise ValueError("Cannot specify both restart and restrt keywords. "
"Preferably use 'restart' only.")

A,M,x,b,postprocess = make_system(A,M,x0,b,xtype)

n = len(b)
if maxiter is None:
maxiter = n*10

if restrt is None:
restrt = 20
restrt = min(restrt, n)

matvec = A.matvec
psolve = M.matvec
ltr = _type_conv[x.dtype.char]
revcom = getattr(_iterative, ltr + 'gmresrevcom')
stoptest = getattr(_iterative, ltr + 'stoptest2')

resid = tol
ndx1 = 1
ndx2 = -1
work = np.zeros((6+restrt)*n,dtype=x.dtype)
work2 = np.zeros((restrt+1)*(2*restrt+2),dtype=x.dtype)
ijob = 1
info = 0
ftflag = True
bnrm2 = -1.0
iter_ = maxiter
old_ijob = ijob
first_pass = True
resid_ready = False
iter_num = 1
while True:
olditer = iter_
x, iter_, resid, info, ndx1, ndx2, sclr1, sclr2, ijob = \
revcom(b, x, restrt, work, work2, iter_, resid, info, ndx1, ndx2, ijob)
# if callback is not None and iter_ > olditer:
# callback(x)
slice1 = slice(ndx1-1, ndx1-1+n)
slice2 = slice(ndx2-1, ndx2-1+n)
if (ijob == -1): # gmres success, update last residual
if resid_ready and callback is not None:
callback(resid)
resid_ready = False

break
elif (ijob == 1):
work[slice2] *= sclr2
work[slice2] += sclr1*matvec(x)
elif (ijob == 2):
work[slice1] = psolve(work[slice2])
if not first_pass and old_ijob == 3:
resid_ready = True

first_pass = False
elif (ijob == 3):
work[slice2] *= sclr2
work[slice2] += sclr1*matvec(work[slice1])
if resid_ready and callback is not None:
callback(resid)
resid_ready = False
iter_num = iter_num+1

elif (ijob == 4):
if ftflag:
info = -1
ftflag = False
bnrm2, resid, info = stoptest(work[slice1], b, bnrm2, tol, info)

old_ijob = ijob
ijob = 2

if iter_num > maxiter:
break

if info >= 0 and resid > tol:
# info isn't set appropriately otherwise
info = maxiter

return postprocess(x), info
</source>

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

==== Локальность реализации алгоритма ====

==== Структура обращений в память и качественная оценка локальности ====
==== Количественная оценка локальности ====
=== Возможные способы и особенности параллельной реализации алгоритма ===

Возможный способ реализации приведен в работе Буренкова С.А.<ref> С.А. Буренков, Организация и исследование эффективных вычислений для решения задач аэроакустики на кластерных архитектурах, Москва, 2014.</ref>. А также рассмотрены особенности параллельной реализации алгоритма.

==== Распределение данных ====

При выполнении параллельного алгоритма решения систем линейных алгебраических уравнений необходимо распределить входные данные наиболее рациональным способом. Матрица коэффициентов разбивается на непрерывные горизонтальные полосы. Распределение вектора правой части и начального приближения выполнено по принципу дублирования, т.е. все элементы векторов скопированы на все процессоры. Для рассматриваемой задачи решения СЛАУ такой подход распределения допустим, т.к. векторы содержат столько же элементов, сколько и одна строка или один столбец матрицы коэффициентов. Если процессор хранит строку матрицы и одиночные элементы векторов правой части и начального приближения, то общее число сохраняемых элементов имеет порядок . Если же процессор хранит строку матрицы и все элементы векторов, то общее число сохраняемых элементов также порядка . Таким образом, при дублировании и при разделении векторов требования к объему памяти из одного класса сложности.

==== Выполнение параллельных операций ====

Рассмотрим операции, которые выполняются неоднократно в процессе выполнения алгоритма: умножение матрицы на вектор, произведение векторов, расчет нормы вектора, нахождение взвешенной суммы векторов. Эти подзадачи можно разделить на 2 группы: операции между матрицей и вектором (например, умножение матрицы на вектор) и операции между двумя векторами (например, скалярное умножение, взвешенная сумма векторов и пр.). Подзадачи умножения константы на вектор и определение нормы вектора будем относить ко второй группе, так как их трудоемкость одного порядка.

Особенности выполнения операций между матрицей и вектором определены способом распределения входных данных. На рис. 2 схематично изображен процесс параллельного умножения матрицы на вектор на трех процессорах.

[[file:Matr_x_v.png|thumb|center|700px|Рисунок 2. Схема параллельного выполнения операции между матрицей и вектором]]

Заштрихованные участки соответствуют данным, расположенным в памяти процессора исполнителя. Каждый исполнитель получает свою часть результата выполнения операции.

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

[[file:V x v.png|thumb|center|700px|Рисунок 3. Схема параллельного выполнения операции между двумя векторами]]

Таким образом, параллельное выполнение любой из выделенных подзадач привело к распределению вычислительной нагрузки между всеми исполнителями.

==== Объединение результатов расчетов ====

Результатом выполнения рассматриваемых операций является, чаще всего, вектор, части которого расположены на участвовавших в вычислениях процессорах. Для объединения результатов расчета и получения полного вектора на каждом процессоре вычислительной системы необходимо выполнить операцию сбора данных. В качестве обменных взаимодействий в модели с распределённой памятью могут выступать операции массовых коммуникационных обменов. С их помощью каждый процессор передаст свой вычисленный элемент вектора всем остальным процессорам (см. рис. 4).
[[file:Collect.png|thumb|center|700px|Рисунок 4. Принцип сбора результатов вычислений]]

=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===
Алгоритм GMRES достаточно популярен и его реализацию можно найти во многих пакетах прикладных программ.

'''Пример: MATLAB'''
<source lang="matlab">

Итерационный метод минимизации обобщенной невязки реализован в системе MATLAB. Для этого используется функция gmres:

gmres (А, В. restart) — возвращает решение X СЛУ А*Х=В. А —квадратная матрица. Функция gmres начинает итерации от начальной оценки, представляющей собой вектор размера и, состоящий из нулей. Итерации производятся либо до сходимости к решению, либо до появления ошибки, либо до достижения максимального числа итераций. Сходимость достигается, когда относительный остаток norm(B-A*X)/norm(B) меньше или равен заданной погрешности (по умолчанию 1е-6). Максимальное число итераций — минимум из n:restart и 10. Функция gmres (...) имеет и ряд других форм записи, аналогичных описанным для функции bieg(...).

» gmres(A.B)

GMRES(4) converged at Iteration 1(4) to a solution with relative residual le-016

ans =

1.0000

2.0000

3.0000

4.0000
</source>

Список пакетов, в которых присутствует реализация метод минимизации обобщенной невязки:
:1.'''ATLAS''' (Automatically Tuned Linear Algebra Software) – оптимизированная библиотека, включающая реализацию процедур BLAS и часть функциональности LAPACK;
:2.'''AZTEC''' – библиотека параллельных подпрограмм для решения больших систем линейных алгебраических уравнений с разреженными матрицами;
:3.'''BLAS''' (Basic Linear Algebra Subprograms) – библиотека высококачественных процедур, «строительными блоками» для которых являются вектора, матрицы или их части. Уровень 1 BLAS используется для выполнения операций вектор-вектор, уровень 2 :BLAS – для выполнения матрично-векторных операций, наконец, уровень 3 BLAS – для выполнения матрично-матричных операций. Поскольку программы BLAS являются эффективными, переносимыми и легко доступными, они используются как базовые компоненты для развития высококачественного программного обеспечения для задач линейной алгебры. Так были созданы широко известные пакеты LINPACK, EISPACK, которые затем были перекрыты пакетом LAPACK, получившим большое распространение. Перечисленные пакеты разработаны на языке Fortran;
:4.'''BLACS''' (Basic Linear Algebra Communication Subprograms) – набор базовых коммуникационных процедур линейной алгебры, созданных для линейной алгебры. Вычислительная модель состоит из одномерной или двумерной решетки процессов, где каждый процесссодержит часть матрицы или вектора. BLACS используется как коммуникационный слой проекта ScaLAPACK, который переносит библиотеку LAPACK на машины с распределенной памятью;
:5.'''BlockSolve95''' – параллельная библиотека для решения разреженных систем линейных уравнений;
:6.'''BPKIT2''' – пакет блочных способов предобусловливания, ориентированных на разреженные матрицы;
:7.'''CAPSS''' – пакет для параллельного решения разреженных линейных систем;
:8.'''CXML''' (The Compaq Extended Math Library) – расширенная математическая библиотека, включающая в себя часть функциональности BLAS, LAPACK, Direct Sparse Solvers и Iterative-solvers;
:9.'''Direct Sparse Solvers''' – пакет программ для решения разреженных систем прямыми методами;
:10.'''EISPACK''' (Eigensystem Package) – пакет программ решения алгебраической проблемы собственных значений;
:11.'''Expokit''' – пакет программ для решения не больших СЛАУ с плотной матрицей и больших разреженных систем;
:12.'''ILUPACK''' – библиотке, содержащая способы предобусловливания, ориентированная на разреженные СЛАУ. Пакет включает реализацию процедур BLAS, SPARSEKIT. Реализована на языке С и Fortran;
:13.'''IML++''' (Iterative Methods Library) – библиотека итерационных методов решения разреженных СЛАУ, позволяющая использовать несколько простых способов предобусловливания. Пакет включает часть BLAS и MV;
:14.'''Intel MKL''' (Intel Math Kernel Library) включает несколько стандартных библиотек для высокопроизводительных системах (BLAS, LAPACK и FFTPACK – подпрограммы быстрого преобразования Фурье);
:15.'''IOMDRV''' – пакет подпрограмм для решения симметричных и несимметричных линейных систем методами крыловских подпространств;
:16.'''Iterative-solvers''' – пакет подпрограмм решения разреженных систем итерационными методами;
:17.'''ITL''' (Iterative Template Library) – библиотека программ итерационных методов и способов предобусловливания, являющаяся составной частью MTL.
:18.'''ITPACK''' (Iterative Package) – пакет программ для решения разреженных систем итерационными методами;
:19.'''ITSOL''' (The New Sparskit Preconditionning Module) – пакет, содержащий способы предобусловливания, ориентированные на разреженные матрицы. Является составной частью пакета SPARSKIT;
:20.'''JAMA/C++''' – библиотека для решения СЛАУ прямыми методами;
:21.'''LAPACK''' (Linear Algebra Package) – набор реализаций «продвинутых» методов линейной алгебры. LAPACK содержит процедуры для решения систем линейных уравнений, задач нахождения собственных значений и факторизации матриц. Обрабатываются заполненные и ленточные матрицы, но не разреженные матрицы общего вида. Во всех случаях можно обрабатывать действительные и комплексные матрицы с одиночной и удвоенной точностью. Процедуры LAPACK построены таким образом, чтобы как можно больше вычислений выполнялось с помощью обращений к BLAS с использованием всех его трех уровней. Вследствие крупнозернистости операций уровня 3 BLAS, их использование обеспечивает высокую эффективность на многих высокопроизводительных компьютерах, в частности, если производителем создана специализированная реализация. ScaLAPACK является успешным результатом переноса пакета LAPACK на системы с передачей сообщений. Но в таких системах необходимы процедуры, обеспечивающие обмен данными между взаимодействующими процессами. Для этого в ScaLAPACK используется библиотека BLACS;
:22.'''Laspack''' – пакет программ для решения разреженных систем итерационными методами;
:23.'''LGSOLV''' – библиотека для решения СЛАУ прямыми методами;
:24.'''LINPACK''' (Linear Package) – пакет программ решения систем линейных алгебраических уравнений и линейной задачи наименьших квадратов прямыми методами;
:25.'''LinPar''' – пакет предназначенный для решения плохообусловленных СЛАУ, включая прямоугольные. Если для решения задачи необходимо предобусловливание СЛАУ, то оно выполняется отдельно и методы применяются к уже предобусловленной системе. Соответственно, по окончании процесса решения найденный вектор должен быть пересчитан согласно выполненному предобусловливанию. В схемы методов эти процедуры не включаются;
:26.'''MET''' (Matrix Expression Templates) – реализованная на языке C++ программа для инженеров и научных работников;
:27.'''MINOS''' – пакет подпрограмм решения больших разреженных задач линейного и нелинейного программирования;
:28.'''MTL''' (The Matrix Template Library) – реализованная на языке C++ библиотека базовых операций линейной алгебры, позволяющая решать СЛАУ с разреженными матрицами итерационными методами с предобусловлмванием, за счет включенного пакета ITL;
:29.'''MV++''' – небольшая библиотека, содержащая базовые операции линейной алгебры. Данный пакет часто является составной частью более крупных и высокопроизводительных библиотек;
:30.'''ParPre''' – пакет параллельных версий способов предобусловливания, ориентированных на разреженные матрицы, являющийся составной частью PETs;
:31.'''Parallel Algorithms Project''' – пакет параллельных версий итерационных методов Крыловского типа для решения разреженных систем;
:32.'''PASVA''' – пакет подпрограмм решения разреженных систем с блочно-двухдиагональной структурой;
:33.'''PBLAS''' – Параллельные версии базовых процедур линейной алгебры (BLAS) ;
:34.'''PCGPAK''' (Preconditioned Conjugate Gradient PAcKage) – пакет программ для решения симметричных и несимметричных разреженных линейных систем методом сопряженных градиентов;
:35.'''PIM''' (The Parallel Iterative Methods) – набор процедур на Фортран-77, реализующих параллельные версии различных итеративных методов решения разреженных систем линейных уравнений;
:36.'''PSparselib''' (A Portable Library of Parallel Sparse Iterative Solvers) – библиотека параллельных итерационных методов для разреженных линейных систем;
:37.'''PSPASES''' (Parallel Sparse Symmetric Direct Solver) – библиотека параллельных версий прямых методов для решения симметричных линейных систем;
:38.'''RALAPACK''' – пакет подпрограмм для различных операций с разреженными матрицами;
:39.'''ScaLAPACK''' (Scalable LAPACK) – параллельная версия LAPACK. Широкий набор подпрограмм для решения стандартных задач линейной алгебры;
:40.'''SIRSM''' – пакет подпрограмм для решения разреженных несимметричных линейных систем;
:41.'''Software Iterative Methods: GMRESR and BiCGstab(ell)''' – пакет прогамм решения больших разреженных систем с несимметричной матрицей;
:42.'''SPAI''' (Sparse Approximate Inverse Preconditioner) – пакет способов предобусловливания, ориентированных на разреженные матрицы;
:43.'''SPARKS''' – пакет подпрограмм для решения разреженных линейных систем в полунеявных методах Рунге-Кутта численного интегрирования систем обыкновенных дифференциальных уравнений;
:44.'''SparseLib++''' – библиотка, реализованная на языке C++, позволяющая решать разреженные СЛАУ итерационными методами с предобусловливанием. Включает часть процедур BLAS и IML;
:45.'''SPARSKIT''' – мощный пакет для решения разреженных СЛАУ итерационными методами с предобусловливанием. Библиотека реализованна на языке Fortran;
:46.'''SPARSPAK''' (Sparsee Iinear Equations Package) – пакет программ решения разреженных систем линейных алгебраических уравнений с симметричными положительно определенными матрицами;
:47.'''SPLIB''' – библиотека, позволяющая решать СЛАУ с разреженной матрицей итерационными методами с предобусловливанием, реализованная на языке Fortran;
:48.'''SPLP''' (Sparse Linear Programming Subprogram) – пакет программ решения задач линейного программирования;
:49.'''SPOOLES''' – библиотека для решения СЛАУ с разреженной матрицей прямыми методами;
:50.'''SSLES''' – пакет подпрограмм для решения разреженных несимметричных линейных систем;
:51.'''TCHLIB''' – пакет подпрограмм для решения симметричных и несимметричных линейных систем методом Чебышева;
:52.'''TNT''' (Template Numerical Toolkit) – библиотека базовых операций линейной алгебры, ориентированная на разреженные матрицы. Библиотека разработана на языке Fortran;
:53.'''WSMP''' (Watson Sparse Matrix Package) – пакет программ решения разреженных систем линейных алгебраических уравнений;
:54.'''XMP''' – пакет подпрограмм для решения задач линейного программирования;
:55.'''YI2M''' – комплекс программ решения разреженных систем;

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

Обсуждение участника:Анюшева Ирина

2016-11-17T11:13:14Z

Dan: /* Пункт 1.7 */

Участник:Анюшева Ирина/Итерационный метод решения системы линейных алгебраических уравнений GMRES (обобщенный метод минимальных невязок)

2016-11-17T11:12:36Z

Dan:

{{algorithm
| name = GMRES (обобщенный метод минимальных невязок)
| serial_complexity = <math>O(m^2n^2)</math>
| pf_height = 1
| pf_width = 1
| input_data = <math>n^2+2n</math>
| output_data = <math>n</math>
}}

Основные авторы описания: [[U:Анюшева Ирина|Анюшева Ирина]] (614 группа, разделы: 1.1-1.2, 1.7-1.8, 2.7, 3), Исхаков Эльдар (614 группа, разделы 1.3-1.6, 1.9-1.10)

= Свойства и структура алгоритма =
== Общее описание алгоритма ==
Обобщенный метод минимальных невязок (GMRES) для решения системы линейных алгебраических уравнений аппроксимирует решение с помощью вектора в подпространстве Крылова с минимальным остатком. Метод GMRES разработан Ю.Саадом и Мартин Х. Шульцом в 1986 году. Метод по праву считается одним из самых эффективных численных методов решения несимметричных систем. Он гарантирует неувеличение нормы невязки в ходе итерационного процесса, который основан на построении базиса в соответствующей системе подпространстве Крылова <math>K_j(A, r_0)</math>.
Затем решение уточняется некоторой добавкой, представленной в виде разложения по этому базису.

Метод обобщенных минимальных невязок популярен из-за наличия ряда преимуществ: он ошибкоустойчив, допускает эффективное распараллеливание, не требует нахождения параметра релаксации, обладает суперлинейной скоростью сходимости. Однако в чистом виде для больших систем метод не используется из-за чрезвычайно больших затрат памяти. Зато широкое распространение получила перезапускаемая версия метода, подоразумевающая перезапуск метода каждые m итераций. Уменьшение размерности пространства может привести к стагнации метода – процессу, при котором с каждой следующей итерацией норма невязки уменьшается незначительно, либо не уменьшается вовсе.

== Математическое описание алгоритма ==
Исходные данные: система линейных алгебраических уравнений <math>Ax=b</math>, где:

<math>A=(a_{ij})</math> <math>-</math> вещественная матрица размера <math>n \times n</math>;

<math>b</math> и <math>x</math> вектора из <math>n</math> элементов;

<math>x^*</math> <math>-</math> точное решение системы.

Вычисляемые данные: <math>x^{(s)} - </math>приближенное решение системы.

===Ортогонализация Арнольди===
Для построения базиса <math>V</math> в подпространстве Крылова в методе GMRES применяется ортогонализация Арнольди.

Формулы метода:
:<math>
\begin{align}
(h_{i+1,i}v_{i+1}) & = Av_i - \sum_{j = 1}^{i} h_{j,i}v_j, \\
v_1 &= \frac{r_0}{\parallel r_0 \parallel},
\end{align}
</math>
В матрично-векторных обозначениях соотношение может быть записано как
:<math>
\begin{align}
AV_i &= V_i H_i + h_{i+1,i}v_{i+1} e_i^T &=V_{i+1}\overline{H}_i,
\end{align}
</math>
:<math>
\begin{align}
V_i &= [v_1|v_2|...|v_i], \overline{H}_i - \end{align}
</math> верхняя матрица Хессенберга размерности <math>(i+1)\times i</math>

===Минимизация невязки===

Невязку уравнения можно определить как
<math> J(y) = \parallel b- A x\parallel = \parallel b- (Ax_0+V_m y)\parallel =\parallel \beta e_1 - \overline{H}_m y \parallel</math>,
где <math>y -</math> вектор размерности <math>m</math>.

Вектор <math>x_m</math> может быть получен как
<math>x_m = x_0 + V_m y_m</math>, вектор <math>y_m</math> может найден как решение линейной задачи наименьших квадратов размера <math>(m+1)\times m</math>, где <math>m<<n</math>.

Для решения задачи минимизации приведем матрицу <math>\overline{H}_m</math> к верхнему треугольному виду с помощью вращений Гивенса. На шаге
<math>i</math> матрица вращения <math>\Omega_i</math> имеет размеры <math>(m+1)\times (m+1)</math> и имеет следующий вид:

<math>
\Omega_i= \begin{pmatrix}
1 & &&&&&& \\
&\ddots &&&&&&\\
&&1&&&&& \\
&&&c_i&s_i &&& \\
&&&-s_i& c_i &&&\\
&&&&&1&&& \\
&&&&&&\ddots&\\
&&&&&&&1 \\
\end{pmatrix}</math>

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

В алгоритме GMRES присутствуют два ресурсоемких с точки зрения вычислительных мощностей этапа:

* умножение исходной матрицы на вектор при вычислении невязок;

* вычисление скалярных произведений векторов при построении ортонормированного базиса подпространства Крылова.

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

Нижеперечисленные шаги алгоритма и входящие в них операции являются наиболее ресурсоемкими. Они выполняются в приведенном порядке. Каждый из них допускает распараллеливание:

* Вычисление нормы невязки для задачи "начальных" условий;

* Вычисление элементов Хессенберговой матрицы - матрично-векторные умножения и скалярные произведения векторов;

* Вычисление произведений разреженных матриц при минимизации невязки.

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

===Шаги алгоритма===

1. Выбрать произвольное <math>x_0</math>; вычислить <math>r_0=b-Ax_0</math> и <math>v_1=\frac{r_0}{\parallel r_0 \parallel}</math>

2. Задать матрицу <math>\overline{H}_m</math> размерности <math>(m+1)\times m</math> и всем ее элементам присвоить нулевые значения

3. Для <math>j=1,\dots,m</math> выполнять:

* для <math>i=1,\dots,j</math> выполнять: <math>h_{i,j}=(Av_j,v_i)</math>
* <math>\omega_j=Av_j-\sum_{i=1}^j h_{i,j}v_i</math>
* <math>h_{j+1,j}={\parallel \omega_j \parallel}</math>
* <math>v_{j+1}=\frac{\omega_j}{h_{j+1,j}}</math>

4. Вычислить <math>y_m=\arg\min_{y} \parallel \beta e_1 - \overline{H}_my \parallel,\ y \in \mathbb{R}^m</math> и <math>x_m=x_0+V_my_m</math>

5. Вычислить <math>r_m=b-Ax_m</math>. Если достигнутая точность удовлетворительна, остановиться.

Иначе принять <math>x_0=x_m</math> и <math>v_1=\frac{r_m}{\parallel r_m \parallel}</math> и вернуться к пункту 2.

===Решение задачи минимизации невязки===

Для нахождения <math>y_m=\arg\min_{y} \parallel \beta e_1 - \overline{H}_my \parallel</math> необходимо выполнить следующие шаги:

1. Найти <math>m</math> матриц вращений Гивенса <math>\Omega_i(c_i,s_i),\ i=1,\dots,m</math> размера <math>(m+1)\times(m+1)</math>, где <math>s_i=\frac{h_{i+1,i}}{\sqrt{h_{i,i}^2+h_{i+1,i}^2}}</math>, <math>c_i=\frac{h_{i,i}}{\sqrt{h_{i,i}^2+h_{i+1,i}^2}}</math>

2. Вычислить <math>\overline{H}_m^{(m)}=\Omega_1\dots\Omega_m\overline{H}_m</math> и <math>\overline{g}_m=\Omega_1\dots\Omega_m\beta e_1</math>, удалить последнюю строку и последний элемент соответственно и решить СЛАУ с полученной верхнетреугольной матрицей и правой частью. Полученное решение <math>y_m</math> минимизирует исходный функционал.

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

Для выполнения одной итерации алгоритма необходимо произвести:

* <math>3m+1</math> делений;

* <math>2m+1</math> вычислений квадратного корня;

* <math>n^2+\frac{3m+5}{2}n</math> умножений;

* <math>O(\frac{m^2n^2}{2})</math> сложений (вычитаний).

==Информационный граф==
Метод состоит из двух блоков: ортогонализация и минимизация невязки. При ортогонализации основными операциями являются умножение матрицы на вектор и скалярное умножение векторов, для которых возможен параллелизм, что показано в блоке на темно-синем фоне. В блоке <math>min</math> решается задача минимизации невязки, которая, строго говоря, является отдельной самостоятельной задачей.
[[file:gmres.jpg|thumb|center|700px|Рис.1. Информационная структура алгоритма GMRES]]

==Ресурс параллелизма алгоритма==
Для нахождения матрично-векторных произведений при вычислении невязок матрица СЛАУ должна быть подвергнута декомпозиции на строчные блоки, размеры которых определяются требованиями равномерности загрузки. Соответствующим образом подвергается декомпозиции и вектор правой части. Для наиболее эффективного вычисления скалярных произведений и линейных комбинаций векторов базиса каждый из векторов <math>v_j</math> должен быть разбит на блоки равного размера по числу процессов; каждый из процессов при этом хранит соответствующие блоки всех векторов. Обработка вектора решения дублируется на всех процессах.

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

'''Входные данные:'''
* матрица <math>A</math> размера <math>n\times n</math>;
* вектор-столбец <math>b</math> размера <math>n</math>;
* вектор-столбец <math>x_0</math> размера <math>n</math> - начальное приближение;
* натуральное число <math>m<<n</math>, определяющее размерность подпространства Крылова.

'''Выходные данные:'''
* вектор-столбец <math>x</math> размера <math>n</math> - решение системы.

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

* Вычислительная мощность: весьма маленькая и равна <math>m^2</math>, так как <math>m<<n</math>.

* Устойчивость: GMRES в этом плане является очень хорошим методом. Теоретически можно получить точное решение не более чем за <math>n</math> итераций. Однако, очень приемлемые результаты получаются и за <math>m<<n</math> итераций. Однако, есть примеры, в которых видно, что первые <math>m-1</math> итераций дают невязку, равную некой константе, а на итерации под номером <math>m</math> получаем точное решение.

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

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

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

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

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

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

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

==Существующие реализации алгоритма==
* Реализация алгоритма в библиотеке SciPy [https://docs.scipy.org/doc/scipy-0.17.0/reference/generated/scipy.sparse.linalg.gmres.html]
* Реализация алгоритма в библиотеке IML++ [http://math.nist.gov/iml++/gmres.h.txt]
* Библиотека для MATLAB [http://www.mathworks.com/help/matlab/ref/gmres.html]

= Литература=
1. Y. Saad, M.H. Schultz. GMRES: A generalized minimal residual algorithm for solving nonsymmetric linear systems. SIAM J. Sci. Statist. Comput., 7 (1986), pp. 856–869

2. Е.Е. Тыртышников. Методы численного анализа. – Москва: Академия, 2007

3. М.Ю. Баландин, Э.П. Шурина. Некоторые оценки эффективности параллельных алгоритмов решения СЛАУ на подпространствах Крылова. - Вычислительные технологии, том 3, №1, 1998

Участник:Ilya4870/Алгоритм разбиения графа методом рекурсивной координатной бисекции

2016-11-17T11:11:05Z

Dan:

{{Assignment|Dan}}

Основные авторы описания: Габдуллина М.И. (1.1, 1.3, 1.5, 1.9, 2.7), Урюпов И.В. (1.2, 1.4, 1.6, 1.7, 1.8, 1.10), группа м218.

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==

Задача рациональной декомпозиции расчетных сеток возникает при численном моделировании на высокопроизводительных вычислительных системах проблем механики сплошных сред, импульсной энергетики, электродинамики и многих других. Такие задачи сводятся к более общей задачи - разбиение вершин графа. Оптимальным считается разбиение на домены, при котором выровнен суммарный вес вершин в доменах и минимизирован суммарный вес разрезанных ребер (разрезанное ребро – ребро, соединяющее вершины из разных доменов). Одним из методов разбиения вершин графа на равные по мощности блоки является метод рекурсивной координатной бисекции.<ref name="G1"/><ref name="G2"/><ref name="Y"/>

На каждом этапе рекурсивной бисекции область разбивается на две части.
Соотношение размеров частей зависит от количества доменов, которые
должны быть образованы в каждой из частей. Полученные подобласти разбиваются дальше аналогичным образом до тех пор, пока в подобластях не останется по одному домену. При рекурсивной координатной бисекции на этапе разбиения выбирается координатная ось, вдоль которой область имеет наибольшую протяженность. Область разбивается перпендикулярно полученной оси.
Достоинством данного метода является то, что при разбиении на равные домены числа вершин в получаемых доменах отличаются не больше, чем на единицу. Другими достоинствами являются экономичное использование памяти и относительная быстрота работы.<ref name="G1"/>

== Математическое описание алгоритма ==
Пусть <math>G = (V,E)</math> – неориентированный граф, где <math>V = \{v_i\}</math> – множество вершин, <math>E = \{e_{ij}\}</math> – множество рёбер. И вершины, и рёбра, имеют целочисленные веса <math>|v_i|</math> и <math>|e_{ij}|</math>, соответственно.

Декомпозиция является отображением множества вершин <math>V</math> на заданное число <math>p</math> доменов <math>S_j</math> такое, что каждая вершина <math>v_i</math> принадлежит некоторому домену <math>S_j</math>, и <math>S_k \cap S_m = \emptyset</math>.

Суммарный вес вершин в домене <math>S_j</math> равен сумме весов вершин, принадлежащих этому домену:
<math>|S_j| = \sum_{i}{|v_i|}, v_i \in S_j</math>.

Суммарный вес разрезанных рёбер равен сумме весов рёбер, соединяющих вершины из разных доменов:
<math>|E_c|=\sum_{ij}{|e_ij|}, v_i \in S_k, v_j \in S_m, k < m</math>.

Каждый домен <math>S_j</math> является некоторым подграфом <math>G^j = (V^j, E^j)</math> графа <math>G = (V, E)</math>, где <math>V^j \subseteq V, E^j \subseteq E</math>.
Домен является связным, если его граф состоит из одной компоненты связности, то есть между любой парой вершин этого графа существует как минимум один путь.

Требуется найти такое разбиение множества вершин <math>V</math> на заданное число <math>p</math> связных доменов <math>S_j</math>, при котором<ref name="G1"/>:

* <div style="max-width: 50%;">выровнен суммарный вес вершин в доменах: <math>|S_j| \approx |V|/p</math>,<span id="condition1" style="float: right;"><math>(1)</math></span></div>

* <div style="max-width: 50%;">минимизирован суммарный вес разрезанных рёбер: <math>min(|E_c|)</math>.<span id="condition2" style="float: right;"><math>(2)</math></span></div>

Используя обозначения выше, определим:

* Входные данные алгоритма: множество координат вершин <math>C = \{c_i\}</math> графа <math>G = (V, E)</math>, где <math>c_i = (v_i^x, v_i^y, v_i^z)</math> - координаты вершины <math>v_i \in V</math>, число доменов <math>p</math>.

* Выходные данные алгоритма: разбиение множества вершин <math>V</math> на заданное число <math>p</math> доменов <math>S_j</math>.

Основные этапы алгоритма:

* вычисляются протяжённости осей: <math>l_k = |max(v_i^k) - min(v_i^k)|</math> для <math>k = x, y, z</math>,

* производится сортировка множества <math>C</math> по координате, соответствующей наибольшей <math>l_k</math>,

* множество <math>C</math> разбивается на две части в соответствии с новым порядком элементов, то есть перпендикулярно координатной оси, вдоль которой она имеет наибольшую протяжённость; соотношение размеров частей зависит от количества доменов, которые должны быть образованы в каждой из частей,

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

== Вычислительное ядро алгоритма ==
Большую часть времени занимает сортировка массива координат вершин <math>C</math>, выполняемая на каждом шаге рекурсии.
Сортировка может быть выполнена любым способом, в зависимости от реализации. В дальнейшем положим, что используется алгоритм с оптимальной вычислительной сложностью <math>O(nlog_2{n})</math>.

== Макроструктура алгоритма ==
Как записано и в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют сортировки массивов координат вершин <math>C</math>, выполняемые на каждом шаге рекурсии.

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

# Вычисляются минимумы и максимумы по каждой из координат, определяющие параллелепипед, охватывающий вершины данной области. Далее запускается процесс рекурсии, на каждом шаге которого выполняется следующее:
## Определяется координата <math>j</math>, вдоль которой параллелепипед, обрабатывающийся на данном этапе, имеет наибольшую протяженность.
## Определяется количество доменов, которое делится на данном этапе. В левую часть (вершины с меньшей координатой <math>j</math>) попадет половина доменов. Сначала набираются домены нулевого типа, потом, если они закончились, первого, и т.д. до получения нужного числа доменов в левой части. Подсчитывается общее число вершин n1, которое окажется в этих доменах. В правой части будут сформированы оставшиеся домены.
## Пусть все вершины в параллелепипеде имеют координаты <math>j</math>, принадлежащие интервалу <math>[j_{min}, j_{max}]</math>. Интервал делится на <math>K</math> равных малых интервалов. <math>K</math> – некоторая константа. Подсчитываются количества вершин, принадлежащие каждому малому интервалу. Исходя из того, что в левую часть должна попасть <math>n_1</math> вершина с меньшей координатой <math>j</math>, определяется, в какой малый интервал <math>[j_{from}, j_{to}]</math> попадает медиана. Затем вершины из интервала <math>[j_{from}, j_{to}]</math> записываются в отдельный массив, отсортированный по всем координатам. Определяется медиана – последняя вершина, которая попадет в левую часть.
## Если предполагается построение локальных деревьев, для вершины <math>i</math> двоичного дерева запоминаются данные о медиане: ее координаты, номер вершины медианы и номер координаты <math>j</math>, по которой проводилось деление.
## Проводится разделение данных по аналогии с обменной сортировкой с разделением Хоару (быстрая сортировка), чтобы на следующих этапах просматривались только вершины из разбиваемой области. Два указателя, <math>begin</math> и <math>end</math>, выставляются на начало и на конец массива данных, соответственно. Вершина, на которую указывает указатель <math>begin</math>, сравнивается с медианой по всем координатам, и, если она попадает в левую часть параллелепипеда, указатель <math>begin</math> сдвигается к следующей вершине. Так до тех пор, пока указатель <math>begin</math> не остановится на вершине, которая должна попасть в правую часть. Указатель <math>end</math> конца массива сдвигается влево до тех пор, пока не остановится на вершине, которая должна попасть в левую часть. Если указатель <math>begin</math> находится левее указателя <math>end</math>, вершины, на которые указывают указатели, меняются местами, после чего указатель <math>begin</math> сдвигается вправо, а <math>end</math> – влево.Если указатель <math>begin</math> все еще левее указателя <math>end</math>, весь процесс повторяется снова. Если после выхода из цикла указатели указывают на одну и ту же вершину, она сравнивается с медианой по всем координатам, и если вершина попадает в левую часть, указатель <math>begin</math> сдвигается к следующей вершине. Указатель <math>begin</math> определяет начало массива данных правой части.
# По рекурсии левая и правая части отправляются на деление. Левой части передается указатель на начало исходного массива данных и число вершин <math>n_1</math>. Максимальные координаты параллелепипеда остаются теми же, только максимальная координата <math>j</math> приравнивается к координате <math>j</math> медианы. Передается число доменов каждого вида, которое будет в левой части. Номер вершины двоичного дерева, отвечающей за деление левой части, будет равным <math>2i</math>. Правой части передается указатель <math>begin</math> в качестве нового указателя на массив данных и оставшееся число вершин. Минимальная координата <math>j</math> приравнивается к координате медианы. Передаются числа доменов каждого вида. Номер вершины двоичного дерева, отвечающей за деление правой части, будет равным <math>2i + 1</math>.
# Перед делением каждой из частей проверяется, сколько доменов осталось в данной части. Если остался только один домен, то все вершины помещаются в данный домен. Домены считаются по порядку от номера <math>gr_0</math> первого домена. Если предполагается построение локальных деревьев, в лист дерева записывается номер домена. Запоминается максимальный номер вершины. Если в части осталось больше одного домена, она отправляется на деление.

[[file:bisection_1.jpg|thumb|center|700px|Рисунок 1. Пример координатной бисекции на три домена.<ref name="G1"/>]]
Алгоритм работает только с координатами вершин и не учитывает связи между ними, что делает его экономичным по памяти.<ref name="G2"/><ref name="Y"/>

== Последовательная сложность алгоритма ==
Для разбиения графа с количеством вершин <math>n</math> методом рекурсивной координатной бисекции на <math>p</math> доменов требуется:
* для каждого шага рекурсии:
** определить максимум и минимум координат, <math>O(n)</math> операций сравнения,
** отсортировать подобласть по одной из координат, <math>O(nlog_2{n})</math> операций сравнения.
Глубина рекурсии - <math>log_2{p}+1</math>.

Сравнения составляют ''основную часть алгоритма''.

Таким образом, алгоритм имеет последовательную сложность <math>O(n, p) = n \log_2{n} \log_2{p}.</math>

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

Опишем граф алгоритма<ref name="V">Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.</ref> в виде рисунка.
[[File:AepPhDGxoJDcFhdr.png|alt=information graph|thumb|center|900px|Рисунок 2. Информационный граф алгоритма. In - входные данные,LS - локальная сортировка, PS - параллельная сортировка с помощью сортировочной сести, D - декомпозиция, Out - выходные данные<ref name="G1"/>]]

Граф алгоритма состоит из двух групп вершин, соответствующих бисекции по процессам (LS и PS) и локальной бисекции на каждом процессе (D). Первая группа делится на подгруппы, каждая подгруппа содержит некоторое количество сетей параллельной сортировки (PS), каждая из которых может выполнятся независимо от других. Во второй же группе вершин все операции в одной вершине не зависят от других вершин.

== Ресурс параллелизма алгоритма ==
Исходя из того, что метод является геометрическим, алгоритм обладает координатным параллелизмом. Таким образом структура параллельного алгоритма включает в себя следующие этапы<ref name="G2">Головченко Е.Н. Параллельный пакет декомпозиции больших сеток // Математическое моделирование. 2011. Т. 23. № 10. 3-18. URL: http://cyberleninka.ru/article/n/razbienie-bolshih-setok</ref>:
# Начальное распределение вершин по процессорам. Начальное распределение может быть любым, например, в соответствии с порядковыми номерами вершин.
# Определение числа доменов, которые должны быть сформированы на каждом из процессоров, и количества вершин в них.
# Рекурсивная координатная бисекция вершин по процессорам. На каждом этапе сначала вычисляется координатная ось, вдоль которой область имеет наибольшую протяженность. Затем блок вершин бьется на две части перпендикулярно данной оси. Группа процессоров делится на две, далее каждая из групп делит свой блок вершин аналогичным образом. Для разделения блока вершин используется параллельная сортировка. После рекурсивной координатной бисекции вершин по процессорам на процессорах оказывается столько вершин, сколько должно быть в образуемых на них доменах.
# Локальная рекурсивная координатная бисекция вершин по доменам. Дальнейшее разбиение на домены проводится локально на каждом процессоре.

Для разбиения графа <math>G=(V, E), |V|=n</math> на <math>p</math> доменов в параллельном варианте при количестве процессов <math>N_p</math> требуется последовательно выполнить следующие ярусы:
* для бисекции по процессам — <math>log_2{N_p}</math> пар ярусов, содержащих:
** локальную сортировку, при количестве вершин <math>n, \frac{n}{2}, \frac{n}{4},\ldots;</math>
** параллельную сеть сортировки, при количестве элементов <math>n, \frac{n}{2}, \frac{n}{4},\ldots</math>, при количестве процессов <math>N_p, \frac{N_p}{2}, \frac{N_p}{4},\ldots;</math>
* один ярус, содержащий локальную бисекцию на каждом процессе для количества вершин <math>\frac{n}{N_p}.</math>

Таким образом, параллельный вариант алгоритма обладает двухступенчатой структурой. При классификации по высоте ЯПФ его сложность — <math>O\left(\left[m \log_2{m} + \frac{1}{2} \log_2{n} (\log_2{n} + 1)\right]\log_2{N_p} + m \log_2{m} \log_2{p}\right)</math>, где <math>m=\frac{n}{N_p}</math>.
При классификации по ширине ЯПФ его сложность будет <math>O(N_p)</math>.

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

Входные данные алгоритма: множество координат вершин <math>C = \{c_i\}</math> графа <math>G = (V, E)</math>, где <math>c_i = (v_i^x, v_i^y, v_i^z)</math> - координаты вершины <math>v_i \in V</math>. Таким образом, множество координат вершин может быть передано как массив трёхмерных векторов. Число доменов <math>p</math> передается в виде натурального числа, не может превышать число вершин.<ref name="G2"/>

Количество элементов массива входных данных может быть очень большим, например, алгоритм используется для нерегулярных сеток, содержащих <math>10^9</math> и более вершин. В настоящее время такие сетки невозможно разместить в памяти одного процессора (на гексаэдральную сетку, состоящую из <math>1.2 \cdot 10^8</math> ячеек, требуется порядка 200 ГБ), поэтому для декомпозиции нужен параллельный алгоритм.<ref name="G1"/>

Число процессоров, на котором будет считаться вычислительная задача, как правило, заранее неизвестно. Поэтому имеет смысл предварительно однократно разбить сетку на большое число микродоменов, а потом формировать из них домены. Количество микродоменов на несколько порядков меньше числа вершин, поэтому многократное разбиение микродоменов на домены быстрее многократного разбиения всей сетки.

Выходные данные алгоритма: разбиение множества вершин <math>V</math> на заданное число <math>p</math> доменов <math>S_j</math>. Эти данные могут быть записаны как массив четырехмерных векторов координат вершин, четвертой координатой будет номер домена, которому принадлежит вершина.<ref name="G1"/>

== Свойства алгоритма ==
Алгоритм детерминирован в случае использования устойчивой сортировки вершин. Алгоритм устойчив, так как работает с целочисленными данными, ошибки округления отсутствуют.

Вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных, равна <math>O(\log_2{n} \log_2{p})</math>, где <math>n</math> - количество вершин в графе, <math>p</math> - количество доменов.

Так как основной операцией алгоритма является сравнение целых чисел при сортировке, наблюдается дисбаланс арифметических операций по отношению к операциям обращения к памяти. Алгоритм обладает сбалансированностью операций между параллельными ветвями алгоритма, что следует из [[#condition1|условия <math>(1)</math>]] - количество вершин на разных процессах примерно одинаково.

Дуги информационного графа, исходящие из вершины, соответствующей сети сортировки с номером <math>k</math>, имеют степень <math>\frac{N_p}{2^k}, k = 0, 1,\ldots, \log_2{N_p}</math>.
Это означает, что их степень убывает в ходе работы алгоритма от <math>N_p</math> до <math>1</math>.

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

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

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

== Масштабируемость алгоритма и его реализации ==
Проведём исследование масштабируемости параллельной реализации алгоритма разбиения графа методом рекурсивной координатной бисекции согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере [http://hpc.cs.msu.ru/bgp "BlueGene/P"]<ref name="bgp">Gilge, Megan. IBM system blue gene solution blue gene/Q application development. IBM Redbooks, 2014.</ref>, с использованием библиотеки [https://trilinos.org/docs/dev/packages/zoltan2/doc/html/index.html Zoltan2].

Набор и границы значений [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [1 : 512] с множителем 2;
* количество вершин в графе - <math>1.5 \cdot 10^7</math>;
* количество доменов - <math>2048</math>.

В результате проведённых экспериментов был получен следующий диапазон [[Глоссарий#Эффективность реализации|эффективности реализации]] алгоритма:

* минимальная эффективность реализации <math>35%</math>;
* максимальная эффективность реализации <math>94%</math>.

На следующих рисунках приведены графики [[Глоссарий#Ускорение|ускорения]] и [[Глоссарий#Эффективность реализации|эффективности]] выбранной реализации алгоритма разбиения графа методом рекурсивной координатной бисекции в зависимости от числа процессоров.

[[file:RCB_Speedup.png|thumb|center|700px|Рисунок 3. Ускорение алгоритма разбиения графа методом рекурсивной координатной бисекции в зависимости от числа процессоров.]]
[[file:RCB_Efficiency.png|thumb|center|700px|Рисунок 4. Эффективность алгоритма разбиения графа методом рекурсивной координатной бисекции в зависимости от числа процессоров.]]

Построим оценку масштабируемости выбранной реализации алгоритма разбиения графа методом рекурсивной координатной бисекции.
* По числу процессов: <math>-0,0131</math>. При увеличении числа процессов эффективность на рассмотренной области изменений параметров запуска уменьшается. Уменьшение эффективности на рассмотренной области работы параллельной программы объясняется быстрым ростом накладных расходов на организацию параллельного выполнения.

[http://pastebin.com/Ljk8LPnd Исследованная параллельная реализация на языке C++.]

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

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

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

Алгоритм, как и многие другие алгоритмы разбиения графов реализованы в следующих последовательных пакетах декомпозиции графов<ref name="G1">Головченко Е.Н. Декомпозиция расчетных сеток для решения задач механики сплошных сред на высокопроиводительных вычислительных системах. Дисс ... канд. ф.-м.наук. Институт прикладной математики им. М. В. Келдыша РАН, г. Москва URL: http://keldysh.ru/council/3/D00202403/golovchenko_diss.pdf</ref>: METIS, JOSTLE, SCOTCH, CHACO и PARTY.
К параллельным пакетам относятся PARMETIS (параллельная версия пакета METIS), JOSTLE, PT-SCOTCH (параллельная версия пакета SCOTCH) и ZOLTAN.

ParMETIS и METIS распространяются свободно URL: http://glaros.dtc.umn.edu/gkhome/software .

ZOLTAN - свободная лицензия, URL: http://www.cs.sandia.gov/~web1400/1400_download.html .

Также алгоритм реализован в параллельном пакете GridSpiderPar<ref name="Y">Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2012. – 328 с., илл. – (Серия «Суперкомпьютерное образование»), ISBN 978-5-211-06382-2 URL: http://lira.imamod.ru/ITTPMOPS/</ref>, URL: http://lira.imamod.ru/FondProgramm/Decomposition/

= Литература =
<references />

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-11-17T11:09:28Z

Dan:

Автор: [[U:Сергей|Герасимов Сергей]] (619)

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

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

'''Разреженная матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается плотной.

Нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:

~ есть O(n). Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;

~ в каждой строке не превышает 10 в типичном случае;

~ ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.

Огромные разрежённые матрицы часто возникают при решении таких задач, как дифференциальное уравнение в частных производных.

При хранении и преобразовании разрежённых матриц в компьютере бывает полезно, а часто и необходимо, использовать специальные алгоритмы и структуры данных, которые учитывают разрежённую структуру матрицы. Операции и алгоритмы, применяемые для работы с обычными, плотными матрицами, применительно к большим разрежённым матрицам работают относительно медленно и требуют значительных объёмов памяти. Однако разрежённые матрицы могут быть легко сжаты путём записи только своих ненулевых элементов, что снижает требования к компьютерной памяти.

'''Существуют различные форматы хранения разреженных матриц.''' Одни предназначены для хранения матриц специального вида (например, ленточных), другие обеспечивают работу с матрицами общего вида. Ниже рассмотрим некоторые весьма распространенные способы представления разреженных матриц.

По-видимому, наиболее очевидным способом хранения произвольной разреженной матрицы является '''координатный формат''': хранятся только ненулевые элементы матрицы, и их координаты (номера строк и столбцов). При данном подходе хранение матрицы A можно обеспечить в трех одномерных массивах:

~ массив ненулевых элементов матрицы A (обозначим его как values);

~ массив номеров строк матрицы A, соответствующих элементам массива values (обозначим его как rows);

~ массив номеров столбцов матрицы A, соответствующих элементам массива values (обозначим его как cols);

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

Хотя многие математические библиотеки поддерживают матрично-векторные операции в координатном формате, данный формат обеспечивает медленный доступ к элементам матрицы, и является затратным по используемой памяти. В рассмотренном выше примере избыточность по памяти образом проявляется в массиве rows, в котором строчные координаты хранятся неоптимальным образом.

Перейдем далее к рассмотрению более экономных форматов хранения. '''Разреженный строчный формат''' - это одна из наиболее широко используемых схем хранения разреженных матриц. Эта схема предъявляет минимальные требования к памяти и в то же время оказывается очень удобной для нескольких важных операций над разреженными матрицами: сложения, умножения, перестановок строк и столбцов, транспонирования, решения линейных систем с разреженными матрицами коэффициентов как прямыми, так и итерационными методами и т. д.

В соответствии с рассматриваемой схемой для хранения матрицы A требуется три одномерных массива:

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его опять как values);

~ массив номеров столбцов для соответствующих элементов массива values (обозначим его как cols);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его pointer). Описание k-й строки хранится в позициях с pointer[k]-й по (pointer[k+1]–1)-ю массивов values и cols. Если pointer[k]=pointer[k+1], то k-я строка пустая. Если матрица A состоит из n строк, то длина массива pointer будет n+1.

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

Очевидно, что объем памяти, требуемый для хранения вектора pointer, значительно меньше, чем для хранения вектора rows. Более того, разреженный строчный формат обеспечивает эффективный доступ к строчкам матрицы; доступ к столбцам по прежнему затруднен. Поэтому предпочтительно использовать этот способ хранения в тех алгоритмах, в которых преобладают строчные операции.

Существует также '''разреженный столбцовый формат''', который строится аналогичным способом.

Теперь, разобравшись со способами хранения разреженных матриц, можно перейти к ''алгоритму умножения разреженной матрицы на вектор''. Умножение матрицы на вектор является подзадачей для нахождения решений СЛАУ итерационными методами.

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

Пусть матрица размером <math>N\times M</math> содержит в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>

Условимся использовать строчный формат хранения матрицы, который описан выше.

На входе у нас 4 массива: val(ненулевые элементы матрицы), col(номера столбцов), row(массив указателей) и vec(вектор, на который мы умножаем матрицу).

На выходе получим вектор out.

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}, \ i=\overline{0,N-1}</math>, где <math>N</math> - число строк матрицы.

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

Ядром алгоритма является вычисление сумм произведений:

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}</math>

Итого: <math>NZ</math> умножений + <math>x</math> сложений(<math>NZ-N<x<NZ-1</math>).

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

Метод состоит из вычисления неполных скалярных произведений.

[[Файл:sparse.jpg|thumb|center|500px|Рис.1 Умножение разреженной матрицы на вектор]]

Элементы из массива val умножаются на элементы из массива vec с соответствующим индексом. Черным отмечены ненулевые элементы.

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

Предполагается, что матрица представлена в разреженном строчном формате.

for(i=0; i<N; i++)
{
out[i]=0;
for(j=row[i]; j<row[i+1]; j++)
{
out[i] += val[j]*vec[col[j]];
}
}

Внешний цикл - цикл по элементам выходного вектора. Внутренний - цикл по строкам разреженной матрицы.
Во внутреннем цикле реализовано накопление сумм произведений в выходной элемент.
Индекс ''j'' показывает с какого по какой элемент нужно считать из ''val'' (вектор с ненулевыми значениями матрицы), а также позволяет определить в каких столбцах расположены эти значения в матрице (с помощью вектора ''col'').
Минимальное и максимальное значение ''j'' узнается из вектора ''row''.

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

<math>\bullet \ NZ</math> умножений

<math>\bullet \ x</math> сложений(<math>NZ-N<x<NZ-1</math>).

Всего <math>2NZ</math> операций, где <math>NZ</math> - количество ненулевых элементов.

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

Опишем граф алгоритма.

Граф алгоритма состоит из двух групп вершин, расположенных в целочисленных узлах двух областей одной размерности.

'''Первая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a \cdot b</math>. Координаты области следующие:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math> k </math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>. (На рисунке вместо обозначения ''row'' использовано обозначение ''r'').

Результаты операции - '''промежуточные''' данные алгоритма.

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a + b</math>.
Координаты области таковы:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>.

Результат операции:

<math>\cdot</math> при <math>j < k - 1</math> является '''промежуточным''' данным алгоритма;

<math>\cdot</math> при <math>j = k - 1</math> является '''выходным''' данным <math>out[i]</math>.

Описанный граф изображен на Рис.2. Здесь вершины первой группы обозначены красным цветом и отмечены знаком умножения, вершины второй - зелёным цветом и знаком сложения. Вершины, соответствующие входным данным обозначены белым цветом и выходным - синим.

[[Файл:new_sparse.png|thumb|center|1000px|Рис.2 Умножение разреженной матрицы на вектор. Информационный граф]]

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

При наличии бесконечного числа процессоров для умножения разреженной матрицы на вектор потребуется:

~ 1 ярус умножений

~ <math>Z-1</math> операция сложения, где Z - максимальное число ненулевых элементов в строке.

Максимальное число требуемых процессоров - NZ.

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

'''Входные данные:'''

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его как val);

~ массив номеров столбцов для соответствующих элементов массива val (обозначим его как col);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его row);

~ вектор, на который будет умножаться матрица (обозначим его vec).

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

Для матрицы размером <math>N\times M</math>, содержащей в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>,

~ вектор val - NZ элементов;

~ вектор col - NZ элементов;

~ вектор row - N+1 элемент;

~ вектор vec - M элементов.

'''Выходные данные:'''

Вектор out размером N.

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

Соотношение последовательной и параллельной сложности в случае неограниченных ресурсов, как хорошо видно, является ''линейным''.

Вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных – чуть меньше ''единицы''.

Данный алгоритм обладает свойством детерминированности.

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

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

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

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

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

[[Файл:plot_more_points.png|thumb|center|1000px|Рис.3 Умножение разреженной матрицы на вектор. Масштабируемость]]

[[Файл:plot_eff_new.png|thumb|center|1000px|Рис.4 Умножение разреженной матрицы на вектор. Эффективность]]

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

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

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

Эффективная работа с разреженными матрицами реализована во многих библиотеках, например, [https://software.intel.com/en-us/intel-mkl Intel Math Kernel Library], базирующуюся на библиотеках BLAS и LAPACK, также математических пакет [http://matlab.ru/products/matlab Matlab] имеет собственную реализацию.

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

[1] Писсанецки С. Технология разреженных матриц. - М.: Мир, 1988. — 410 с.

[2] https://software.intel.com/sites/default/files/m/d/4/1/d/8/LW_SparseMM_ppt.pdf

Обсуждение участника:Сергей

2016-11-17T11:08:33Z

Dan:

= Правки =
Не удаляйте замечания

= Пункт 2.4 =
[[Участник:Dan|Dan]] ([[Обсуждение участника:Dan|обсуждение]]) 14:08, 17 ноября 2016 (MSK) необходимо доработать:

Требования были такие:
- Реализация: полностью собственная или обращение к библиотечной функции (Intel MKL, PETSc, FFTW, ScaLAPACK). В любом случае, текст исследуемой программы должен быть представлен в отчете.
- Компьютерная платформа может быть любой (Ломоносов, BlueGene или что-то иное). Описание компьютерной платформы должно быть в отчете.
- Должен быть представлен график сильной масштабируемости (зависимости производительности от числа процессов; если при этом
ещё и зависимость от размера задачи - это только в плюс). График должен выглядеть пристойно и понятно, оси и единицы измерения должны быть подписаны. К графику обязательно должны быть словесные пояснения! Требовалось подобрать такие размеры задачи и числа процессоров, чтобы отразить на графике характерные точки, описывающие свойства алгоритма и программы.

Обсуждение участника:Юлия Жосан

2016-11-17T11:03:30Z

Dan:

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-11-15T14:39:59Z

Dan:

{{Assignment|Dan}}

Автор: [[U:Сергей|Герасимов Сергей]] (619)

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

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

'''Разреженная матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается плотной.

Нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:

~ есть O(n). Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;

~ в каждой строке не превышает 10 в типичном случае;

~ ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.

Огромные разрежённые матрицы часто возникают при решении таких задач, как дифференциальное уравнение в частных производных.

При хранении и преобразовании разрежённых матриц в компьютере бывает полезно, а часто и необходимо, использовать специальные алгоритмы и структуры данных, которые учитывают разрежённую структуру матрицы. Операции и алгоритмы, применяемые для работы с обычными, плотными матрицами, применительно к большим разрежённым матрицам работают относительно медленно и требуют значительных объёмов памяти. Однако разрежённые матрицы могут быть легко сжаты путём записи только своих ненулевых элементов, что снижает требования к компьютерной памяти.

'''Существуют различные форматы хранения разреженных матриц.''' Одни предназначены для хранения матриц специального вида (например, ленточных), другие обеспечивают работу с матрицами общего вида. Ниже рассмотрим некоторые весьма распространенные способы представления разреженных матриц.

По-видимому, наиболее очевидным способом хранения произвольной разреженной матрицы является '''координатный формат''': хранятся только ненулевые элементы матрицы, и их координаты (номера строк и столбцов). При данном подходе хранение матрицы A можно обеспечить в трех одномерных массивах:

~ массив ненулевых элементов матрицы A (обозначим его как values);

~ массив номеров строк матрицы A, соответствующих элементам массива values (обозначим его как rows);

~ массив номеров столбцов матрицы A, соответствующих элементам массива values (обозначим его как cols);

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

Хотя многие математические библиотеки поддерживают матрично-векторные операции в координатном формате, данный формат обеспечивает медленный доступ к элементам матрицы, и является затратным по используемой памяти. В рассмотренном выше примере избыточность по памяти образом проявляется в массиве rows, в котором строчные координаты хранятся неоптимальным образом.

Перейдем далее к рассмотрению более экономных форматов хранения. '''Разреженный строчный формат''' - это одна из наиболее широко используемых схем хранения разреженных матриц. Эта схема предъявляет минимальные требования к памяти и в то же время оказывается очень удобной для нескольких важных операций над разреженными матрицами: сложения, умножения, перестановок строк и столбцов, транспонирования, решения линейных систем с разреженными матрицами коэффициентов как прямыми, так и итерационными методами и т. д.

В соответствии с рассматриваемой схемой для хранения матрицы A требуется три одномерных массива:

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его опять как values);

~ массив номеров столбцов для соответствующих элементов массива values (обозначим его как cols);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его pointer). Описание k-й строки хранится в позициях с pointer[k]-й по (pointer[k+1]–1)-ю массивов values и cols. Если pointer[k]=pointer[k+1], то k-я строка пустая. Если матрица A состоит из n строк, то длина массива pointer будет n+1.

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

Очевидно, что объем памяти, требуемый для хранения вектора pointer, значительно меньше, чем для хранения вектора rows. Более того, разреженный строчный формат обеспечивает эффективный доступ к строчкам матрицы; доступ к столбцам по прежнему затруднен. Поэтому предпочтительно использовать этот способ хранения в тех алгоритмах, в которых преобладают строчные операции.

Существует также '''разреженный столбцовый формат''', который строится аналогичным способом.

Теперь, разобравшись со способами хранения разреженных матриц, можно перейти к ''алгоритму умножения разреженной матрицы на вектор''. Умножение матрицы на вектор является подзадачей для нахождения решений СЛАУ итерационными методами.

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

Пусть матрица размером <math>N\times M</math> содержит в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>

Условимся использовать строчный формат хранения матрицы, который описан выше.

На входе у нас 4 массива: val(ненулевые элементы матрицы), col(номера столбцов), row(массив указателей) и vec(вектор, на который мы умножаем матрицу).

На выходе получим вектор out.

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}, \ i=\overline{0,N-1}</math>, где <math>N</math> - число строк матрицы.

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

Ядром алгоритма является вычисление сумм произведений:

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}</math>

Итого: <math>NZ</math> умножений + <math>x</math> сложений(<math>NZ-N<x<NZ-1</math>).

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

Метод состоит из вычисления неполных скалярных произведений.

[[Файл:sparse.jpg|thumb|center|500px|Рис.1 Умножение разреженной матрицы на вектор]]

Элементы из массива val умножаются на элементы из массива vec с соответствующим индексом. Черным отмечены ненулевые элементы.

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

Предполагается, что матрица представлена в разреженном строчном формате.

for(i=0; i<N; i++)
{
out[i]=0;
for(j=row[i]; j<row[i+1]; j++)
{
out[i] += val[j]*vec[col[j]];
}
}

Внешний цикл - цикл по элементам выходного вектора. Внутренний - цикл по строкам разреженной матрицы.
Во внутреннем цикле реализовано накопление сумм произведений в выходной элемент.
Индекс ''j'' показывает с какого по какой элемент нужно считать из ''val'' (вектор с ненулевыми значениями матрицы), а также позволяет определить в каких столбцах расположены эти значения в матрице (с помощью вектора ''col'').
Минимальное и максимальное значение ''j'' узнается из вектора ''row''.

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

<math>\bullet \ NZ</math> умножений

<math>\bullet \ x</math> сложений(<math>NZ-N<x<NZ-1</math>).

Всего <math>2NZ</math> операций, где <math>NZ</math> - количество ненулевых элементов.

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

Опишем граф алгоритма.

Граф алгоритма состоит из двух групп вершин, расположенных в целочисленных узлах двух областей одной размерности.

'''Первая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a \cdot b</math>. Координаты области следующие:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math> k </math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>. (На рисунке вместо обозначения ''row'' использовано обозначение ''r'').

Результаты операции - '''промежуточные''' данные алгоритма.

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a + b</math>.
Координаты области таковы:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>.

Результат операции:

<math>\cdot</math> при <math>j < k - 1</math> является '''промежуточным''' данным алгоритма;

<math>\cdot</math> при <math>j = k - 1</math> является '''выходным''' данным <math>out[i]</math>.

Описанный граф изображен на Рис.2. Здесь вершины первой группы обозначены красным цветом и отмечены знаком умножения, вершины второй - зелёным цветом и знаком сложения. Вершины, соответствующие входным данным обозначены белым цветом и выходным - синим.

[[Файл:new_sparse.png|thumb|center|1000px|Рис.2 Умножение разреженной матрицы на вектор. Информационный граф]]

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

При наличии бесконечного числа процессоров для умножения разреженной матрицы на вектор потребуется:

~ 1 ярус умножений

~ <math>Z-1</math> операция сложения, где Z - максимальное число ненулевых элементов в строке.

Максимальное число требуемых процессоров - NZ.

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

'''Входные данные:'''

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его как val);

~ массив номеров столбцов для соответствующих элементов массива val (обозначим его как col);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его row);

~ вектор, на который будет умножаться матрица (обозначим его vec).

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

Для матрицы размером <math>N\times M</math>, содержащей в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>,

~ вектор val - NZ элементов;

~ вектор col - NZ элементов;

~ вектор row - N+1 элемент;

~ вектор vec - M элементов.

'''Выходные данные:'''

Вектор out размером N.

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

Соотношение последовательной и параллельной сложности в случае неограниченных ресурсов, как хорошо видно, является ''линейным''.

Вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных – чуть меньше ''единицы''.

Данный алгоритм обладает свойством детерминированности.

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

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

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

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

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

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

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

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

Эффективная работа с разреженными матрицами реализована во многих библиотеках, например, [https://software.intel.com/en-us/intel-mkl Intel Math Kernel Library], базирующуюся на библиотеках BLAS и LAPACK, также математических пакет [http://matlab.ru/products/matlab Matlab] имеет собственную реализацию.

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

[1] Писсанецки С. Технология разреженных матриц. - М.: Мир, 1988. — 410 с.

[2] https://software.intel.com/sites/default/files/m/d/4/1/d/8/LW_SparseMM_ppt.pdf

Обсуждение участника:Сергей

2016-11-15T14:39:30Z

Dan:

= Правки =
Не удаляйте замечания

= Содержание =
'''принято''' Следует добавить содержание (рубрикация по разделам) как в шаблоне.

= Пункт 1 =
'''принято''' Все пункты должны именоваться строго по шаблону. например, в данном случае, первый уровень - просто: "Свойства и структура алгоритмов"

= Пункт 1.3 =
'''принято''' Лучше избегать ссылок на соседние пункты. Подразделы д.б. самодостаточны.

= Пункт 1.4 =
'''принято''' ''Подпункты должны быть самодостаточны. Приведите схему или опишите словами. Приведенного описания недостаточно.''

Следует просто привести описание макроструктуры, без ссылки на другие пункты.

= Пункт 1.5 =
'''принято''' ''Пункты должны быть самодостаточны, расширьте описание.''

Добавить описание к псевдокоду.

= Пункт 1.6 =
'''принято''' Указать итоговую сложность.

= Пункт 1.7 =
'''принято''' ''Приведенная схема не является информационным графом, можно ее перенести в раздел макроструктуры, наверное. В п.1.7 необходимо привести информационный граф.''

Оформить как рисунок с номером и подписью. Если рисунок заимствован, надо дать ссылку на источник.

= Пункт 2 =
'''принято''' Аналогично, именование пункта д.б. по шаблону.

= Пункты 2.1-2.6 =
'''принято''' Добавить заголовки. Содержимое подпунктов можно не заполнять.

= Пункт 2.7 =
'''принято''' Добавить ссылки на реализации.

= Литература =
'''принято''' Отсутствует раздел источников, необходимо добавить.

Обсуждение участника:Margarita.gabdullina

2016-11-14T07:30:54Z

Dan:

= Вклад =
'''принято''' Необходимо явно указать вклад каждого соавтора.

= Пункт 1.5 =
'''принято''' Если рисунок не собственный, надо дать ссылку на источник.

= Пункт 1.7 =
'''принято'''

+/-Граф следует снабдить пояснением.
+Рисунок следует оформить как рисунок, с номером. Если заимствован, дать ссылку на источник.

Приведенный рисунок представляет собой некую схему, а требуется привести информационный граф.

= Пункт 1.10 =
'''принято''' Явно не сказано про мощность алгоритма.

Участник:Ilya4870/Алгоритм разбиения графа методом рекурсивной координатной бисекции

2016-11-14T07:30:18Z

Dan:

{{Assignment|Dan}}

Основные авторы описания: Габдуллина М.И. (1.1, 1.3, 1.5, 1.9, 2.7), Урюпов И.В. (1.2, 1.4, 1.6, 1.7, 1.8, 1.10), группа м218.

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==

Задача рациональной декомпозиции расчетных сеток возникает при численном моделировании на высокопроизводительных вычислительных системах проблем механики сплошных сред, импульсной энергетики, электродинамики и многих других. Такие задачи сводятся к более общей задачи - разбиение вершин графа. Оптимальным считается разбиение на домены, при котором выровнен суммарный вес вершин в доменах и минимизирован суммарный вес разрезанных ребер (разрезанное ребро – ребро, соединяющее вершины из разных доменов). Одним из методов разбиения вершин графа на равные по мощности блоки является метод рекурсивной координатной бисекции.<ref name="G1"/><ref name="G2"/><ref name="Y"/>

На каждом этапе рекурсивной бисекции область разбивается на две части.
Соотношение размеров частей зависит от количества доменов, которые
должны быть образованы в каждой из частей. Полученные подобласти разбиваются дальше аналогичным образом до тех пор, пока в подобластях не останется по одному домену. При рекурсивной координатной бисекции на этапе разбиения выбирается координатная ось, вдоль которой область имеет наибольшую протяженность. Область разбивается перпендикулярно полученной оси.
Достоинством данного метода является то, что при разбиении на равные домены числа вершин в получаемых доменах отличаются не больше, чем на единицу. Другими достоинствами являются экономичное использование памяти и относительная быстрота работы.<ref name="G1"/>

== Математическое описание алгоритма ==
Пусть <math>G = (V,E)</math> – неориентированный граф, где <math>V = \{v_i\}</math> – множество вершин, <math>E = \{e_{ij}\}</math> – множество рёбер. И вершины, и рёбра, имеют целочисленные веса <math>|v_i|</math> и <math>|e_{ij}|</math>, соответственно.

Декомпозиция является отображением множества вершин <math>V</math> на заданное число <math>p</math> доменов <math>S_j</math> такое, что каждая вершина <math>v_i</math> принадлежит некоторому домену <math>S_j</math>, и <math>S_k \cap S_m = \emptyset</math>.

Суммарный вес вершин в домене <math>S_j</math> равен сумме весов вершин, принадлежащих этому домену:
<math>|S_j| = \sum_{i}{|v_i|}, v_i \in S_j</math>.

Суммарный вес разрезанных рёбер равен сумме весов рёбер, соединяющих вершины из разных доменов:
<math>|E_c|=\sum_{ij}{|e_ij|}, v_i \in S_k, v_j \in S_m, k < m</math>.

Каждый домен <math>S_j</math> является некоторым подграфом <math>G^j = (V^j, E^j)</math> графа <math>G = (V, E)</math>, где <math>V^j \subseteq V, E^j \subseteq E</math>.
Домен является связным, если его граф состоит из одной компоненты связности, то есть между любой парой вершин этого графа существует как минимум один путь.

Требуется найти такое разбиение множества вершин <math>V</math> на заданное число <math>p</math> связных доменов <math>S_j</math>, при котором<ref name="G1"/>:

* <div style="max-width: 50%;">выровнен суммарный вес вершин в доменах: <math>|S_j| \approx |V|/p</math>,<span id="condition1" style="float: right;"><math>(1)</math></span></div>

* <div style="max-width: 50%;">минимизирован суммарный вес разрезанных рёбер: <math>min(|E_c|)</math>.<span id="condition2" style="float: right;"><math>(2)</math></span></div>

Используя обозначения выше, определим:

* Входные данные алгоритма: множество координат вершин <math>C = \{c_i\}</math> графа <math>G = (V, E)</math>, где <math>c_i = (v_i^x, v_i^y, v_i^z)</math> - координаты вершины <math>v_i \in V</math>, число доменов <math>p</math>.

* Выходные данные алгоритма: разбиение множества вершин <math>V</math> на заданное число <math>p</math> доменов <math>S_j</math>.

Основные этапы алгоритма:

* вычисляются протяжённости осей: <math>l_k = |max(v_i^k) - min(v_i^k)|</math> для <math>k = x, y, z</math>,

* производится сортировка множества <math>C</math> по координате, соответствующей наибольшей <math>l_k</math>,

* множество <math>C</math> разбивается на две части в соответствии с новым порядком элементов, то есть перпендикулярно координатной оси, вдоль которой она имеет наибольшую протяжённость; соотношение размеров частей зависит от количества доменов, которые должны быть образованы в каждой из частей,

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

== Вычислительное ядро алгоритма ==
Большую часть времени занимает сортировка массива координат вершин <math>C</math>, выполняемая на каждом шаге рекурсии.
Сортировка может быть выполнена любым способом, в зависимости от реализации. В дальнейшем положим, что используется алгоритм с оптимальной вычислительной сложностью <math>O(nlog_2{n})</math>.

== Макроструктура алгоритма ==
Как записано и в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют сортировки массивов координат вершин <math>C</math>, выполняемые на каждом шаге рекурсии.

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

# Вычисляются минимумы и максимумы по каждой из координат, определяющие параллелепипед, охватывающий вершины данной области. Далее запускается процесс рекурсии, на каждом шаге которого выполняется следующее:
## Определяется координата <math>j</math>, вдоль которой параллелепипед, обрабатывающийся на данном этапе, имеет наибольшую протяженность.
## Определяется количество доменов, которое делится на данном этапе. В левую часть (вершины с меньшей координатой <math>j</math>) попадет половина доменов. Сначала набираются домены нулевого типа, потом, если они закончились, первого, и т.д. до получения нужного числа доменов в левой части. Подсчитывается общее число вершин n1, которое окажется в этих доменах. В правой части будут сформированы оставшиеся домены.
## Пусть все вершины в параллелепипеде имеют координаты <math>j</math>, принадлежащие интервалу <math>[j_{min}, j_{max}]</math>. Интервал делится на <math>K</math> равных малых интервалов. <math>K</math> – некоторая константа. Подсчитываются количества вершин, принадлежащие каждому малому интервалу. Исходя из того, что в левую часть должна попасть <math>n_1</math> вершина с меньшей координатой <math>j</math>, определяется, в какой малый интервал <math>[j_{from}, j_{to}]</math> попадает медиана. Затем вершины из интервала <math>[j_{from}, j_{to}]</math> записываются в отдельный массив, отсортированный по всем координатам. Определяется медиана – последняя вершина, которая попадет в левую часть.
## Если предполагается построение локальных деревьев, для вершины <math>i</math> двоичного дерева запоминаются данные о медиане: ее координаты, номер вершины медианы и номер координаты <math>j</math>, по которой проводилось деление.
## Проводится разделение данных по аналогии с обменной сортировкой с разделением Хоару (быстрая сортировка), чтобы на следующих этапах просматривались только вершины из разбиваемой области. Два указателя, <math>begin</math> и <math>end</math>, выставляются на начало и на конец массива данных, соответственно. Вершина, на которую указывает указатель <math>begin</math>, сравнивается с медианой по всем координатам, и, если она попадает в левую часть параллелепипеда, указатель <math>begin</math> сдвигается к следующей вершине. Так до тех пор, пока указатель <math>begin</math> не остановится на вершине, которая должна попасть в правую часть. Указатель <math>end</math> конца массива сдвигается влево до тех пор, пока не остановится на вершине, которая должна попасть в левую часть. Если указатель <math>begin</math> находится левее указателя <math>end</math>, вершины, на которые указывают указатели, меняются местами, после чего указатель <math>begin</math> сдвигается вправо, а <math>end</math> – влево.Если указатель <math>begin</math> все еще левее указателя <math>end</math>, весь процесс повторяется снова. Если после выхода из цикла указатели указывают на одну и ту же вершину, она сравнивается с медианой по всем координатам, и если вершина попадает в левую часть, указатель <math>begin</math> сдвигается к следующей вершине. Указатель <math>begin</math> определяет начало массива данных правой части.
# По рекурсии левая и правая части отправляются на деление. Левой части передается указатель на начало исходного массива данных и число вершин <math>n_1</math>. Максимальные координаты параллелепипеда остаются теми же, только максимальная координата <math>j</math> приравнивается к координате <math>j</math> медианы. Передается число доменов каждого вида, которое будет в левой части. Номер вершины двоичного дерева, отвечающей за деление левой части, будет равным <math>2i</math>. Правой части передается указатель <math>begin</math> в качестве нового указателя на массив данных и оставшееся число вершин. Минимальная координата <math>j</math> приравнивается к координате медианы. Передаются числа доменов каждого вида. Номер вершины двоичного дерева, отвечающей за деление правой части, будет равным <math>2i + 1</math>.
# Перед делением каждой из частей проверяется, сколько доменов осталось в данной части. Если остался только один домен, то все вершины помещаются в данный домен. Домены считаются по порядку от номера <math>gr_0</math> первого домена. Если предполагается построение локальных деревьев, в лист дерева записывается номер домена. Запоминается максимальный номер вершины. Если в части осталось больше одного домена, она отправляется на деление.

[[file:bisection_1.jpg|thumb|center|700px|Рисунок 1. Пример координатной бисекции на три домена.<ref name="G1"/>]]
Алгоритм работает только с координатами вершин и не учитывает связи между ними, что делает его экономичным по памяти.<ref name="G2"/><ref name="Y"/>

== Последовательная сложность алгоритма ==
Для разбиения графа с количеством вершин <math>n</math> методом рекурсивной координатной бисекции на <math>p</math> доменов требуется:
* для каждого шага рекурсии:
** определить максимум и минимум координат, <math>O(n)</math> операций сравнения,
** отсортировать подобласть по одной из координат, <math>O(nlog_2{n})</math> операций сравнения.
Глубина рекурсии - <math>log_2{p}+1</math>.

Сравнения составляют ''основную часть алгоритма''.

Таким образом, алгоритм имеет последовательную сложность <math>O(n, p) = n \log_2{n} \log_2{p}.</math>

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

Опишем граф алгоритма<ref name="V">Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.</ref> в виде рисунка.
[[File:AepPhDGxoJDcFhdr.png|alt=information graph|thumb|center|900px|Рисунок 2. Информационный граф алгоритма. In - входные данные,LS - локальная сортировка, PS - параллельная сортировка с помощью сортировочной сести, D - декомпозиция, Out - выходные данные<ref name="G1"/>]]

Граф алгоритма состоит из двух групп вершин, соответствующих бисекции по процессам (LS и PS) и локальной бисекции на каждом процессе (D). Первая группа делится на подгруппы, каждая подгруппа содержит некоторое количество сетей параллельной сортировки (PS), каждая из которых может выполнятся независимо от других. Во второй же группе вершин все операции в одной вершине не зависят от других вершин.

== Ресурс параллелизма алгоритма ==
Исходя из того, что метод является геометрическим, алгоритм обладает координатным параллелизмом. Таким образом структура параллельного алгоритма включает в себя следующие этапы<ref name="G2">Головченко Е.Н. Параллельный пакет декомпозиции больших сеток // Математическое моделирование. 2011. Т. 23. № 10. 3-18. URL: http://cyberleninka.ru/article/n/razbienie-bolshih-setok</ref>:
# Начальное распределение вершин по процессорам. Начальное распределение может быть любым, например, в соответствии с порядковыми номерами вершин.
# Определение числа доменов, которые должны быть сформированы на каждом из процессоров, и количества вершин в них.
# Рекурсивная координатная бисекция вершин по процессорам. На каждом этапе сначала вычисляется координатная ось, вдоль которой область имеет наибольшую протяженность. Затем блок вершин бьется на две части перпендикулярно данной оси. Группа процессоров делится на две, далее каждая из групп делит свой блок вершин аналогичным образом. Для разделения блока вершин используется параллельная сортировка. После рекурсивной координатной бисекции вершин по процессорам на процессорах оказывается столько вершин, сколько должно быть в образуемых на них доменах.
# Локальная рекурсивная координатная бисекция вершин по доменам. Дальнейшее разбиение на домены проводится локально на каждом процессоре.

Для разбиения графа <math>G=(V, E), |V|=n</math> на <math>p</math> доменов в параллельном варианте при количестве процессов <math>N_p</math> требуется последовательно выполнить следующие ярусы:
* для бисекции по процессам — <math>log_2{N_p}</math> пар ярусов, содержащих:
** локальную сортировку, при количестве вершин <math>n, \frac{n}{2}, \frac{n}{4},\ldots;</math>
** параллельную сеть сортировки, при количестве элементов <math>n, \frac{n}{2}, \frac{n}{4},\ldots</math>, при количестве процессов <math>N_p, \frac{N_p}{2}, \frac{N_p}{4},\ldots;</math>
* один ярус, содержащий локальную бисекцию на каждом процессе для количества вершин <math>\frac{n}{N_p}.</math>

Таким образом, параллельный вариант алгоритма обладает двухступенчатой структурой. При классификации по высоте ЯПФ его сложность — <math>O\left(\left[m \log_2{m} + \frac{1}{2} \log_2{n} (\log_2{n} + 1)\right]\log_2{N_p} + m \log_2{m} \log_2{p}\right)</math>, где <math>m=\frac{n}{N_p}</math>.
При классификации по ширине ЯПФ его сложность будет <math>O(N_p)</math>.

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

Входные данные алгоритма: множество координат вершин <math>C = \{c_i\}</math> графа <math>G = (V, E)</math>, где <math>c_i = (v_i^x, v_i^y, v_i^z)</math> - координаты вершины <math>v_i \in V</math>. Таким образом, множество координат вершин может быть передано как массив трёхмерных векторов. Число доменов <math>p</math> передается в виде натурального числа, не может превышать число вершин.<ref name="G2"/>

Количество элементов массива входных данных может быть очень большим, например, алгоритм используется для нерегулярных сеток, содержащих <math>10^9</math> и более вершин. В настоящее время такие сетки невозможно разместить в памяти одного процессора (на гексаэдральную сетку, состоящую из <math>1.2 \cdot 10^8</math> ячеек, требуется порядка 200 ГБ), поэтому для декомпозиции нужен параллельный алгоритм.<ref name="G1"/>

Число процессоров, на котором будет считаться вычислительная задача, как правило, заранее неизвестно. Поэтому имеет смысл предварительно однократно разбить сетку на большое число микродоменов, а потом формировать из них домены. Количество микродоменов на несколько порядков меньше числа вершин, поэтому многократное разбиение микродоменов на домены быстрее многократного разбиения всей сетки.

Выходные данные алгоритма: разбиение множества вершин <math>V</math> на заданное число <math>p</math> доменов <math>S_j</math>. Эти данные могут быть записаны как массив четырехмерных векторов координат вершин, четвертой координатой будет номер домена, которому принадлежит вершина.<ref name="G1"/>

== Свойства алгоритма ==
Алгоритм детерминирован в случае использования устойчивой сортировки вершин. Алгоритм устойчив, так как работает с целочисленными данными, ошибки округления отсутствуют.

Вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных, равна <math>O(\log_2{n} \log_2{p})</math>, где <math>n</math> - количество вершин в графе, <math>p</math> - количество доменов.

Так как основной операцией алгоритма является сравнение целых чисел при сортировке, наблюдается дисбаланс арифметических операций по отношению к операциям обращения к памяти. Алгоритм обладает сбалансированностью операций между параллельными ветвями алгоритма, что следует из [[#condition1|условия <math>(1)</math>]] - количество вершин на разных процессах примерно одинаково.

Дуги информационного графа, исходящие из вершины, соответствующей сети сортировки с номером <math>k</math>, имеют степень <math>\frac{N_p}{2^k}, k = 0, 1,\ldots, \log_2{N_p}</math>.
Это означает, что их степень убывает в ходе работы алгоритма от <math>N_p</math> до <math>1</math>.

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

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

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

== Масштабируемость алгоритма и его реализации ==
Раздел будет добавлен позднее.

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

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

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

Алгоритм, как и многие другие алгоритмы разбиения графов реализованы в следующих последовательных пакетах декомпозиции графов<ref name="G1">Головченко Е.Н. Декомпозиция расчетных сеток для решения задач механики сплошных сред на высокопроиводительных вычислительных системах. Дисс ... канд. ф.-м.наук. Институт прикладной математики им. М. В. Келдыша РАН, г. Москва URL: http://keldysh.ru/council/3/D00202403/golovchenko_diss.pdf</ref>: METIS, JOSTLE, SCOTCH, CHACO и PARTY.
К параллельным пакетам относятся PARMETIS (параллельная версия пакета METIS), JOSTLE, PT-SCOTCH (параллельная версия пакета SCOTCH) и ZOLTAN.

ParMETIS и METIS распространяются свободно URL: http://glaros.dtc.umn.edu/gkhome/software .

ZOLTAN - свободная лицензия, URL: http://www.cs.sandia.gov/~web1400/1400_download.html .

Также алгоритм реализован в параллельном пакете GridSpiderPar<ref name="Y">Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2012. – 328 с., илл. – (Серия «Суперкомпьютерное образование»), ISBN 978-5-211-06382-2 URL: http://lira.imamod.ru/ITTPMOPS/</ref>, URL: http://lira.imamod.ru/FondProgramm/Decomposition/

= Литература =
<references />

Обсуждение участника:Анюшева Ирина

2016-11-14T07:29:23Z

Dan:

= Пункт 1.7 =
'''принято''' Пояснить, что есть что на приведенной схеме. Приведенная схема скорее более уместна в описании макроструктуры, а в п.1.7 требуется информационный граф.

Добавьте инф. граф и не забудьте описать его элементы.

Участник:Анюшева Ирина/Итерационный метод решения системы линейных алгебраических уравнений GMRES (обобщенный метод минимальных невязок)

2016-11-14T07:29:00Z

Dan:

{{Assignment|Dan}}

{{algorithm
| name = GMRES (обобщенный метод минимальных невязок)
| serial_complexity = <math>O(m^2n^2)</math>
| pf_height = 1
| pf_width = 1
| input_data = <math>n^2+2n</math>
| output_data = <math>n</math>
}}

Основные авторы описания: [[U:Анюшева Ирина|Анюшева Ирина]] (614 группа, разделы: 1.1-1.2, 1.7-1.8, 2.7, 3), Исхаков Эльдар (614 группа, разделы 1.3-1.6, 1.9-1.10)

= Свойства и структура алгоритма =
== Общее описание алгоритма ==
Обобщенный метод минимальных невязок (GMRES) для решения системы линейных алгебраических уравнений аппроксимирует решение с помощью вектора в подпространстве Крылова с минимальным остатком. Метод GMRES разработан Ю.Саадом и Мартин Х. Шульцом в 1986 году. Метод по праву считается одним из самых эффективных численных методов решения несимметричных систем. Он гарантирует неувеличение нормы невязки в ходе итерационного процесса, который основан на построении базиса в соответствующей системе подпространстве Крылова <math>K_j(A, r_0)</math>.
Затем решение уточняется некоторой добавкой, представленной в виде разложения по этому базису.

Метод обобщенных минимальных невязок популярен из-за наличия ряда преимуществ: он ошибкоустойчив, допускает эффективное распараллеливание, не требует нахождения параметра релаксации, обладает суперлинейной скоростью сходимости. Однако в чистом виде для больших систем метод не используется из-за чрезвычайно больших затрат памяти. Зато широкое распространение получила перезапускаемая версия метода, подоразумевающая перезапуск метода каждые m итераций. Уменьшение размерности пространства может привести к стагнации метода – процессу, при котором с каждой следующей итерацией норма невязки уменьшается незначительно, либо не уменьшается вовсе.

== Математическое описание алгоритма ==
Исходные данные: система линейных алгебраических уравнений <math>Ax=b</math>, где:

<math>A=(a_{ij})</math> <math>-</math> вещественная матрица размера <math>n \times n</math>;

<math>b</math> и <math>x</math> вектора из <math>n</math> элементов;

<math>x^*</math> <math>-</math> точное решение системы.

Вычисляемые данные: <math>x^{(s)} - </math>приближенное решение системы.

===Ортогонализация Арнольди===
Для построения базиса <math>V</math> в подпространстве Крылова в методе GMRES применяется ортогонализация Арнольди.

Формулы метода:
:<math>
\begin{align}
(h_{i+1,i}v_{i+1}) & = Av_i - \sum_{j = 1}^{i} h_{j,i}v_j, \\
v_1 &= \frac{r_0}{\parallel r_0 \parallel},
\end{align}
</math>
В матрично-векторных обозначениях соотношение может быть записано как
:<math>
\begin{align}
AV_i &= V_i H_i + h_{i+1,i}v_{i+1} e_i^T &=V_{i+1}\overline{H}_i,
\end{align}
</math>
:<math>
\begin{align}
V_i &= [v_1|v_2|...|v_i], \overline{H}_i - \end{align}
</math> верхняя матрица Хессенберга размерности <math>(i+1)\times i</math>

===Минимизация невязки===

Невязку уравнения можно определить как
<math> J(y) = \parallel b- A x\parallel = \parallel b- (Ax_0+V_m y)\parallel =\parallel \beta e_1 - \overline{H}_m y \parallel</math>,
где <math>y -</math> вектор размерности <math>m</math>.

Вектор <math>x_m</math> может быть получен как
<math>x_m = x_0 + V_m y_m</math>, вектор <math>y_m</math> может найден как решение линейной задачи наименьших квадратов размера <math>(m+1)\times m</math>, где <math>m<<n</math>.

Для решения задачи минимизации приведем матрицу <math>\overline{H}_m</math> к верхнему треугольному виду с помощью вращений Гивенса. На шаге
<math>i</math> матрица вращения <math>\Omega_i</math> имеет размеры <math>(m+1)\times (m+1)</math> и имеет следующий вид:

<math>
\Omega_i= \begin{pmatrix}
1 & &&&&&& \\
&\ddots &&&&&&\\
&&1&&&&& \\
&&&c_i&s_i &&& \\
&&&-s_i& c_i &&&\\
&&&&&1&&& \\
&&&&&&\ddots&\\
&&&&&&&1 \\
\end{pmatrix}</math>

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

В алгоритме GMRES присутствуют два ресурсоемких с точки зрения вычислительных мощностей этапа:

* умножение исходной матрицы на вектор при вычислении невязок;

* вычисление скалярных произведений векторов при построении ортонормированного базиса подпространства Крылова.

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

Нижеперечисленные шаги алгоритма и входящие в них операции являются наиболее ресурсоемкими. Они выполняются в приведенном порядке. Каждый из них допускает распараллеливание:

* Вычисление нормы невязки для задачи "начальных" условий;

* Вычисление элементов Хессенберговой матрицы - матрично-векторные умножения и скалярные произведения векторов;

* Вычисление произведений разреженных матриц при минимизации невязки.

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

===Шаги алгоритма===

1. Выбрать произвольное <math>x_0</math>; вычислить <math>r_0=b-Ax_0</math> и <math>v_1=\frac{r_0}{\parallel r_0 \parallel}</math>

2. Задать матрицу <math>\overline{H}_m</math> размерности <math>(m+1)\times m</math> и всем ее элементам присвоить нулевые значения

3. Для <math>j=1,\dots,m</math> выполнять:

* для <math>i=1,\dots,j</math> выполнять: <math>h_{i,j}=(Av_j,v_i)</math>
* <math>\omega_j=Av_j-\sum_{i=1}^j h_{i,j}v_i</math>
* <math>h_{j+1,j}={\parallel \omega_j \parallel}</math>
* <math>v_{j+1}=\frac{\omega_j}{h_{j+1,j}}</math>

4. Вычислить <math>y_m=\arg\min_{y} \parallel \beta e_1 - \overline{H}_my \parallel,\ y \in \mathbb{R}^m</math> и <math>x_m=x_0+V_my_m</math>

5. Вычислить <math>r_m=b-Ax_m</math>. Если достигнутая точность удовлетворительна, остановиться.

Иначе принять <math>x_0=x_m</math> и <math>v_1=\frac{r_m}{\parallel r_m \parallel}</math> и вернуться к пункту 2.

===Решение задачи минимизации невязки===

Для нахождения <math>y_m=\arg\min_{y} \parallel \beta e_1 - \overline{H}_my \parallel</math> необходимо выполнить следующие шаги:

1. Найти <math>m</math> матриц вращений Гивенса <math>\Omega_i(c_i,s_i),\ i=1,\dots,m</math> размера <math>(m+1)\times(m+1)</math>, где <math>s_i=\frac{h_{i+1,i}}{\sqrt{h_{i,i}^2+h_{i+1,i}^2}}</math>, <math>c_i=\frac{h_{i,i}}{\sqrt{h_{i,i}^2+h_{i+1,i}^2}}</math>

2. Вычислить <math>\overline{H}_m^{(m)}=\Omega_1\dots\Omega_m\overline{H}_m</math> и <math>\overline{g}_m=\Omega_1\dots\Omega_m\beta e_1</math>, удалить последнюю строку и последний элемент соответственно и решить СЛАУ с полученной верхнетреугольной матрицей и правой частью. Полученное решение <math>y_m</math> минимизирует исходный функционал.

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

Для выполнения одной итерации алгоритма необходимо произвести:

* <math>3m+1</math> делений;

* <math>2m+1</math> вычислений квадратного корня;

* <math>n^2+\frac{3m+5}{2}n</math> умножений;

* <math>O(\frac{m^2n^2}{2})</math> сложений (вычитаний).

==Информационный граф==
Метод состоит из двух блоков: ортогонализация и минимизация невязки. При ортогонализации основными операциями являются умножение матрицы на вектор и скалярное умножение векторов, для которых возможен параллелизм, что показано в блоке на темно-синем фоне. В блоке <math>min</math> решается задача минимизации невязки, которая, строго говоря, является отдельной самостоятельной задачей.
[[file:gmres.jpg|thumb|center|700px|Рис.1. Информационная структура алгоритма GMRES]]

==Ресурс параллелизма алгоритма==
Для нахождения матрично-векторных произведений при вычислении невязок матрица СЛАУ должна быть подвергнута декомпозиции на строчные блоки, размеры которых определяются требованиями равномерности загрузки. Соответствующим образом подвергается декомпозиции и вектор правой части. Для наиболее эффективного вычисления скалярных произведений и линейных комбинаций векторов базиса каждый из векторов <math>v_j</math> должен быть разбит на блоки равного размера по числу процессов; каждый из процессов при этом хранит соответствующие блоки всех векторов. Обработка вектора решения дублируется на всех процессах.

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

'''Входные данные:'''
* матрица <math>A</math> размера <math>n\times n</math>;
* вектор-столбец <math>b</math> размера <math>n</math>;
* вектор-столбец <math>x_0</math> размера <math>n</math> - начальное приближение;
* натуральное число <math>m<<n</math>, определяющее размерность подпространства Крылова.

'''Выходные данные:'''
* вектор-столбец <math>x</math> размера <math>n</math> - решение системы.

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

* Вычислительная мощность: весьма маленькая и равна <math>m^2</math>, так как <math>m<<n</math>.

* Устойчивость: GMRES в этом плане является очень хорошим методом. Теоретически можно получить точное решение не более чем за <math>n</math> итераций. Однако, очень приемлемые результаты получаются и за <math>m<<n</math> итераций. Однако, есть примеры, в которых видно, что первые <math>m-1</math> итераций дают невязку, равную некой константе, а на итерации под номером <math>m</math> получаем точное решение.

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

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

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

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

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

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

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

==Существующие реализации алгоритма==
* Реализация алгоритма в библиотеке SciPy [https://docs.scipy.org/doc/scipy-0.17.0/reference/generated/scipy.sparse.linalg.gmres.html]
* Реализация алгоритма в библиотеке IML++ [http://math.nist.gov/iml++/gmres.h.txt]
* Библиотека для MATLAB [http://www.mathworks.com/help/matlab/ref/gmres.html]

= Литература=
1. Y. Saad, M.H. Schultz. GMRES: A generalized minimal residual algorithm for solving nonsymmetric linear systems. SIAM J. Sci. Statist. Comput., 7 (1986), pp. 856–869

2. Е.Е. Тыртышников. Методы численного анализа. – Москва: Академия, 2007

3. М.Ю. Баландин, Э.П. Шурина. Некоторые оценки эффективности параллельных алгоритмов решения СЛАУ на подпространствах Крылова. - Вычислительные технологии, том 3, №1, 1998

Участник:Макарова Алёна/Итерационный метод решения системы линейных алгебраических уравнений GMRES (обобщенный метод минимальных невязок)

2016-11-14T07:28:13Z

Dan:

{{Assignment|Dan}}
{{algorithm
| name = Обобщенный метод минимальных невязок
| serial_complexity = <math>O(nm^2)</math>
| input_data = <math>n(n + 1)</math>
| output_data = <math>n</math>
}}

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

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

Метод минимальных невязок представляет собой итерационный метод для численного решения несимметричной системы линейных уравнений. Метод приближает решение вектором в подпространстве Крылова с минимальной невязкой. Чтобы найти этот вектор используется итерация Арнольди.

Впервые метод минимальных невязок был описан в книге Марчука и Кузнецова "Итерационные методы и квадратичные функционалы" <ref> Г.И. Марчук, Ю.А. Кузнецов, Итерационные методы и квадратичные функционалы, Методы вычислительной математики, Новосибирск, 1975, с. 4-143.</ref> и представлял собой геометрическую реализацию метода минимальных невязок.

Алгебраическая реализация метода минимальных невязок была предложена Саадом и Шульцем в 1986 году <ref>Y.Saad, M.H. Schultz, GMRES: A generalized minimal residual algorithm for solving nonsymmetric linear systems, SIAM J. Scientific and Stat. Comp. 7: 856-869 (1986). </ref>. С их подачи за методом закрепилась аббревиатура GMRES (обобщенный метод минимальных невязок).

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

Для решения системы <math>Ax = b</math> с невырожденной матрицей <math>A</math>, выбирается начальное приближение <math>x_0</math>, затем решается редуцированная система <math>Au = r_0</math>, где <math>r_0 = b - Ax_0, x = x_0 + u</math>. Подпространства Крылова строятся для редуцированной системы (в предположении, что <math>r_0 \neq 0</math>).

Пусть <math>x_i = x_0 + y</math>, где <math> y \in \mathcal{K}_i </math>. Невязка имеет вид <math>r_i = r_0 - Ay</math>, а её длина минимальна, в силу теоремы Пифагора, в том и только том случае, когда

:<math>

r_i \perp A\mathcal{K}_i

</math>.

Таким образом, для реализации <math>i</math>-го шага требуется опустить перпендикуляр из вектора <math>r_0</math> на подпространство <math>A\mathcal{K}_i</math>. Проще всего это сделать, если в данном подпространстве уже найден ортогональный базис. <ref> Тыртышников Е. Е. Методы численного анализа — М., Академия, 2007.</ref>.

==== Геометрическая реализация ====

''Геометрическая реализация'' метода минимальных невязок заключается в построении последовательности векторов <math>q_1, q_2,...</math> таким образом, что <math>q_1, q_2,.., q_i</math> дают базис в подпространстве Крылова <math>\mathcal{K}_i</math> и при этом вектора <math>p_1 = Aq_1, ..., p_i = Aq_i</math> образуют ортогональный базис в подпространстве <math>A\mathcal{K}_i</math>. Вектор <math>q_{i+1} \notin \mathcal{K}_i</math> должен обладать следующими свойствами:
:<math>

q_{i+1} \in \mathcal{K}_{i+1}, p_{i+1} = Aq_{i+1} \perp A\mathcal{K}_i

</math>.

Его можно получить с помощью процесса ортогонализации, применённого к вектору <math>p = Aq</math>, где <math>q = Aq_i</math>. В геометрической реализации необходимо хранить две системы векторов: <math>q_1, ..., q_i</math> и <math>p_1, ..., p_i</math>.

==== Алгебраическая реализация ====

''Алгебраическая реализация'' метода минимальных невязок использует лишь одну систему векторов, образующих ортогональные базисы в подпространствах <math>\mathcal{K}_i</math>.

<math>q_1 = r_0/||r_0||_2</math>. Чтобы получить ортонормированный базис <math>q_1, ..., q_{i+1}</math> в <math>\mathcal{K}_{i+1} = \mathcal{K}_{i+1}(r_0, A)</math>, проводим ортогонализацию вектора <math>Aq_i</math> к векторам <math>q_1, ..., q_i</math>. Если <math>Q_i \equiv [q_1, ..., q_i] \in \mathbb{C}^{n*i}</math>, то получим

:<math>

AQ_i = Q_{i+1}\hat{H_i}, \hat{H_i}= \begin{bmatrix} H_i \\ 0 ... 0 & h_{i+1 i} \end{bmatrix},

</math>

где <math>H_i</math> - верхняя хессенбергова матрица порядка <math>i</math>.

Далее рассмотрим <math>QR</math>-разложение прямоугольной матрицы <math>\hat{H_i}</math>:

:<math>

\hat{H_i} = U_iR_i, R_i \in \mathbb{C}^{i*i}

</math>.

Тогда минимум невязки <math>||r_0 - AQ_iy||_2</math> по всем <math>y</math> будет достигаться в том случае, если <math>y = y_i</math> удовлетворяет уравнению

:<math>

R_iy_i = z_i \equiv ||r_0||_2U^T_ie_1, e_1 = \begin{bmatrix} 1 0 ... 0 \end{bmatrix}^T,

</math>.

Матрица <math>R_i</math> невырожденная, следовательно,

:<math>

x_i = x_0 + Q_iy_i = x_0 + Q_iR_i^{-1}z_i

</math>.

==== Сходимость метода ====

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

Но об этом не верно говорить в общем. Согласно теореме (Greenbaum, Pták and Strakoš), для каждой монотонной последовательности <math> a_1,..., a_{m-1}, a_m = 0 </math>, найдётся матрица <math>A</math> такая что <math>||r_n|| = a_n</math> для всех <math>n</math>, где <math>r_n</math> невязка, определенная ранее.

На практике для матрицы порядка <math>n</math> число шагов может оказаться равным <math>n</math>, а норма невязки может оставаться равной норме начальной невязки на всех шагах, кроме последнего.

'''Пример'''

:<math>

\begin{bmatrix} 0 1 & ... \\ 0 0 1 & ... \\...\\... & 01 \\1 & ... \end{bmatrix} \begin{bmatrix} 1 \\ 0 \\...\\ 0 \\ 0 \end{bmatrix} = \begin{bmatrix} 0 \\ 0 \\...\\ 0 \\ 1 \end{bmatrix}

</math>

Если <math> x_0 = 0 </math>, то <math> r_0 = b</math>. Подпространства Крылова получаются такие:

:<math>

\mathcal{K}_i = span \{ e_n, e_{n-1}, ..., e_{n-i+1}\}, i \le i \le n

</math>

Точное решение системы имеет вид <math>x = e_1</math>, а на итерациях получаются следующие векторы:

:<math>

x_0 = x_1 = ... = x_{n-1} = 0, x_n = e_1

</math>.

Для получения оценок требуются дополнительные предположения относительно матрицы коэффициентов.

===== Сходимость для положительно определенной матрицы =====

Если матрица <math>A</math> положительно определена, то
:<math>
\|r_n\| \leq \left( 1-\frac{\lambda_{\mathrm{min}}^2(1/2(A^T + A))}{ \lambda_{\mathrm{max}}(A^T A)} \right)^{n/2} \|r_0\|,
</math>,
где <math>\lambda_{\mathrm{min}}(M)</math> и <math>\lambda_{\mathrm{max}}(M)</math> обозначают наибольшее и наименьшее собственное значение матрицы <math>M</math>, соответственно. <ref>Eisenstat, Elman & Schultz, Thm 3.3. NB all results for GCR also hold for GMRES, cf. Saad & Schultz</ref>

===== Сходимость для симметричной матрицы =====
Если матрица <math>A</math> является симметрично и положительно определена, тогда

:<math>

\|r_n\| \leq \left( \frac{\kappa_2(A)^2-1}{\kappa_2(A)^2} \right)^{n/2} \|r_0\|

</math>,
где <math>\kappa_2(A)</math> число обусловленности матрицы <math>A</math> в Евклидовой норме.

Если не требовать положительной определённости
:<math>
\|r_n\| \le \inf_{p \in P_n} \|p(A)\| \le \kappa_2(V) \inf_{p \in P_n} \max_{\lambda \in \sigma(A)} |p(\lambda)| \|r_0\|, \,
</math>
где <math>P_n</math> обозначает множество полиномов степени не выше <math>n</math> и <math>p(0) = 1</math>, матрица <math>V</math> появляется из спектрального разложения матрицы <math>A</math> и <math>\sigma(A)</math> - спектр матрицы <math>A</math>. Грубо говоря, это означает, что быстрая сходимость имеет место, когда собственные значения матрицы <math>A</math> невелики и <math>A</math> не сильно отклоняется от нормальной матрицы.<ref>Trefethen & Bau, Thm 35.2</ref>

Все эти неравенства связаны с невязкой вместо фактической ошибки, т.е. расстоянием между текущей итерацией и точным решением.

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

Самой трудоёмкой процедурой в методе является <math>QR</math>-разложение <math>\hat{H_i}</math>. В общем случае требуется <math>\mathcal{O}(i^3)</math> арифметических операций, однако то, что <math>\hat{H_i}</math> является хессенберговой матрицей, позволяет сократить требуемый объём до <math>\mathcal{O}(i^2)</math> действий.

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

Алгоритм начинается с выбора начального приближения <math>x_0</math>.
Далее для <math>i = 1,2 ..</math>
: 1. Вычисляем матрицу <math>\hat{H_i}</math>.
: 2. Находим её <math>QR</math>-разложение: <math>\hat{H_i} = U_iR_i</math>.
: 3. Решаем систему <math>R_iy_i = U^T_ie_1</math>.
: 4. Находим приближение <math>x_i = x_0 + Q_iy_i</math>.

Алгоритм завершается, когда норма вектора невязки становится достаточно малой. При большом числе итераций вычислительные затраты и требуемая для хранения векторов <math>p_i</math> память могу оказаться чрезмерно большими. В таких случаях применяют алгоритм с перезапусками (restart): задают максимальную допустимую размерность <math>K</math> пространств Крылова <math>\mathcal{K}_i</math>, и если точность не достигнута, берут полученное приближение в качестве нового начального приближения <math>x^0_{new} = x_K</math>.

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

* Инициализация начальных значений

1. Выбрать начальное приближение <math>x_0</math> и точность решения <math>\epsilon</math>.

2. Для <math> k = 1, 2, .. </math>

* Вычисление невязки

3. <math>r_0 = b - Ax_0</math>, <math>\beta = ||r_0||</math>, <math>q_1 = r_0/\beta</math>.

4. Цикл по <math> j = 1, 2, .. k </math>.

* Ортогонализация Арнольди

5. Для каждого <math> i = 1, 2, .. j </math> вычислим:

:<math>h_{ij} = (Aq_j, q_i)</math>.

6. Построим вектор: <math>z_{j+1} = Aq_j - \sum_{i = 1}^j h_{ij}q_i</math>.

7. Вычислим его норму <math>h_{j+1,j} = ||z_{j+1}||_2</math>.

8. Если <math>h_{j+1,j}</math> = 0, то останавливаемся.

9. Построим очередной вектор базиса <math>q_{j+1} = z_{j+1}/h_{j+1,j}</math>.

10. Конец цикла по <math>j</math>.

11. Процесс требует хранения всех предыдущих элементов базиса:<math>q_1, .. q_k</math>. Будем хранить их в виде матриц <math>Q_k</math>.

* Задача наименьших квадратов

12. Чтобы вычислить <math>x_k = x_0 + Q_ky_k</math>, решаем задачу: <math> y_k = argmin ||r_0 - AP_ky_k||_2</math>.

* Проверка достижения требуемой точности приближения

13. Если <math>||b - Ax_k|| < \epsilon</math>, где <math>x_k = x_0 + Q_ky_k</math> перейти к п.15

14. <math>x_0 = x_k</math>, перейти к п.2

*Конец

15. <math>x^* = x_k</math>

=== Последовательная сложность алгоритма ===
Будем предполагать, что матрица решаемой СЛАУ является разреженной.
Пусть несимметричная матрица <math>A</math> имеет симметричный портрет и число ненулевых элементов в нижнем(верхнем) треугольнике равно <math>k</math>.

При <math> m << n </math> можно говорить, что один GMRES-цикл имеет сложность <math>\mathcal{O}(nm^2)</math>.

Требования по памяти с учетом <math>1 < m << n</math> и <math>k << n</math> составляют <math>\mathcal{O}(mn)</math>.<ref> М.Ю. Баландин, Э.П.Шурина, Некоторые оценки эффективности параллельных алгоритмов решения СЛАУ на подпространствах Крылова, Вычислительные технологии, 1998, Т.3</ref>.

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

Основная и самая трудоёмкая операция в алгоритме - умножение матрицы на вектор. Для этой операции приводится граф вычисления операции.

[[Файл:graf.png|thumb|center|1400px|Рисунок 2. Граф вычислений подзадачи умножения матрицы на вектор<ref> http://ssd.sscc.ru/sites/default/files/content/attach/449/shkorin_-_gmres.pdf</ref>]]

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

В вычислительной схеме присутствуют два интенсивных в вычислительном плане этапа:
:1. Умножение матрицы СЛАУ на вектор (для нахождения невязок).
Для нахождения матрично-векторных произведений при вычислении невязок матрича должна быть подвергнута декомпозиции на строчные блоки.
:2. Нахождение скалярных произведений векторов (при построении ортонормального базиса подпространства Крылова).
Для наиболее эффективного вычисления скалярных проихведений и линейных комбинаций векоров базиса каждый из векторов <math>p_i</math> должен быть разбит на блоки равного размера по числу процессоров.

Кроме того, на хранение векторов базиса приходится бОльшая часть затрат памяти.

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

'''Входные данные: '''
Обязательные параметры:
:<math>A</math> - квадратная матрица ''(n x n)''.
:<math>b</math> - вектор правой части ''(n x 1)''.
Вариативно:
:<math>x_0</math> - начальное приближение (может не передаваться и быть всегда нулевым).
:<math>\epsilon</math> - погрешность (может не передаваться и быть заданным по умолчанию, обычно равна 1e-6).
:Максимальное число итераций.

'''Выходные данные:'''
<math>x^*</math> - решение системы <math>Ax = b</math>

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

:1. Рассматриваемый алгоритм предназначен для решения невырожденных линейных систем большой размерности. При этом симметрия и положительная определенность матрицы не предполагается.

:2. Для систем с разряженной матрицей алгоритм требует гораздо меньшей вычислительной мощности.

:3. Особенностью метода является то, что с целью экономии памяти выбирается некоторая размерность Крылова <math>m</math>, и после того как <math>m</math> базисных векторов построены, решение уточняется.

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

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

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

Реализация GMRES с преобуславливанием на python, доступная в пакете scipy (scipy.sparse.linal)<ref> https://github.com/scipy/scipy/blob/v0.14.0/scipy/sparse/linalg/isolve/iterative.py.</ref>.

<source lang="python">
def gmres(A, b, x0=None, tol=1e-5, restart=None, maxiter=None, xtype=None, M=None, callback=None, restrt=None):
"""
Use Generalized Minimal RESidual iteration to solve A x = b.
Parameters
----------
A : {sparse matrix, dense matrix, LinearOperator}
The real or complex N-by-N matrix of the linear system.
b : {array, matrix}
Right hand side of the linear system. Has shape (N,) or (N,1).
Returns
-------
x : {array, matrix}
The converged solution.
info : int
Provides convergence information:
* 0 : successful exit
* >0 : convergence to tolerance not achieved, number of iterations
* <0 : illegal input or breakdown
Other parameters
----------------
x0 : {array, matrix}
Starting guess for the solution (a vector of zeros by default).
tol : float
Tolerance to achieve. The algorithm terminates when either the relative
or the absolute residual is below `tol`.
restart : int, optional
Number of iterations between restarts. Larger values increase
iteration cost, but may be necessary for convergence.
Default is 20.
maxiter : int, optional
Maximum number of iterations (restart cycles). Iteration will stop
after maxiter steps even if the specified tolerance has not been
achieved.
xtype : {'f','d','F','D'}
This parameter is DEPRECATED --- avoid using it.
The type of the result. If None, then it will be determined from
A.dtype.char and b. If A does not have a typecode method then it
will compute A.matvec(x0) to get a typecode. To save the extra
computation when A does not have a typecode attribute use xtype=0
for the same type as b or use xtype='f','d','F',or 'D'.
This parameter has been superseded by LinearOperator.
M : {sparse matrix, dense matrix, LinearOperator}
Inverse of the preconditioner of A. M should approximate the
inverse of A and be easy to solve for (see Notes). Effective
preconditioning dramatically improves the rate of convergence,
which implies that fewer iterations are needed to reach a given
error tolerance. By default, no preconditioner is used.
callback : function
User-supplied function to call after each iteration. It is called
as callback(rk), where rk is the current residual vector.
restrt : int, optional
DEPRECATED - use `restart` instead.
See Also
--------
LinearOperator
Notes
-----
A preconditioner, P, is chosen such that P is close to A but easy to solve
for. The preconditioner parameter required by this routine is
``M = P^-1``. The inverse should preferably not be calculated
explicitly. Rather, use the following template to produce M::
# Construct a linear operator that computes P^-1 * x.
import scipy.sparse.linalg as spla
M_x = lambda x: spla.spsolve(P, x)
M = spla.LinearOperator((n, n), M_x)
"""

# Change 'restrt' keyword to 'restart'
if restrt is None:
restrt = restart
elif restart is not None:
raise ValueError("Cannot specify both restart and restrt keywords. "
"Preferably use 'restart' only.")

A,M,x,b,postprocess = make_system(A,M,x0,b,xtype)

n = len(b)
if maxiter is None:
maxiter = n*10

if restrt is None:
restrt = 20
restrt = min(restrt, n)

matvec = A.matvec
psolve = M.matvec
ltr = _type_conv[x.dtype.char]
revcom = getattr(_iterative, ltr + 'gmresrevcom')
stoptest = getattr(_iterative, ltr + 'stoptest2')

resid = tol
ndx1 = 1
ndx2 = -1
work = np.zeros((6+restrt)*n,dtype=x.dtype)
work2 = np.zeros((restrt+1)*(2*restrt+2),dtype=x.dtype)
ijob = 1
info = 0
ftflag = True
bnrm2 = -1.0
iter_ = maxiter
old_ijob = ijob
first_pass = True
resid_ready = False
iter_num = 1
while True:
olditer = iter_
x, iter_, resid, info, ndx1, ndx2, sclr1, sclr2, ijob = \
revcom(b, x, restrt, work, work2, iter_, resid, info, ndx1, ndx2, ijob)
# if callback is not None and iter_ > olditer:
# callback(x)
slice1 = slice(ndx1-1, ndx1-1+n)
slice2 = slice(ndx2-1, ndx2-1+n)
if (ijob == -1): # gmres success, update last residual
if resid_ready and callback is not None:
callback(resid)
resid_ready = False

break
elif (ijob == 1):
work[slice2] *= sclr2
work[slice2] += sclr1*matvec(x)
elif (ijob == 2):
work[slice1] = psolve(work[slice2])
if not first_pass and old_ijob == 3:
resid_ready = True

first_pass = False
elif (ijob == 3):
work[slice2] *= sclr2
work[slice2] += sclr1*matvec(work[slice1])
if resid_ready and callback is not None:
callback(resid)
resid_ready = False
iter_num = iter_num+1

elif (ijob == 4):
if ftflag:
info = -1
ftflag = False
bnrm2, resid, info = stoptest(work[slice1], b, bnrm2, tol, info)

old_ijob = ijob
ijob = 2

if iter_num > maxiter:
break

if info >= 0 and resid > tol:
# info isn't set appropriately otherwise
info = maxiter

return postprocess(x), info
</source>

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

==== Локальность реализации алгоритма ====

==== Структура обращений в память и качественная оценка локальности ====
==== Количественная оценка локальности ====
=== Возможные способы и особенности параллельной реализации алгоритма ===

Возможный способ реализации приведен в работе Буренкова С.А.<ref> С.А. Буренков, Организация и исследование эффективных вычислений для решения задач аэроакустики на кластерных архитектурах, Москва, 2014.</ref>. А также рассмотрены особенности параллельной реализации алгоритма.

==== Распределение данных ====

При выполнении параллельного алгоритма решения систем линейных алгебраических уравнений необходимо распределить входные данные наиболее рациональным способом. Матрица коэффициентов разбивается на непрерывные горизонтальные полосы. Распределение вектора правой части и начального приближения выполнено по принципу дублирования, т.е. все элементы векторов скопированы на все процессоры. Для рассматриваемой задачи решения СЛАУ такой подход распределения допустим, т.к. векторы содержат столько же элементов, сколько и одна строка или один столбец матрицы коэффициентов. Если процессор хранит строку матрицы и одиночные элементы векторов правой части и начального приближения, то общее число сохраняемых элементов имеет порядок . Если же процессор хранит строку матрицы и все элементы векторов, то общее число сохраняемых элементов также порядка . Таким образом, при дублировании и при разделении векторов требования к объему памяти из одного класса сложности.

==== Выполнение параллельных операций ====

Рассмотрим операции, которые выполняются неоднократно в процессе выполнения алгоритма: умножение матрицы на вектор, произведение векторов, расчет нормы вектора, нахождение взвешенной суммы векторов. Эти подзадачи можно разделить на 2 группы: операции между матрицей и вектором (например, умножение матрицы на вектор) и операции между двумя векторами (например, скалярное умножение, взвешенная сумма векторов и пр.). Подзадачи умножения константы на вектор и определение нормы вектора будем относить ко второй группе, так как их трудоемкость одного порядка.

Особенности выполнения операций между матрицей и вектором определены способом распределения входных данных. На рис. 2 схематично изображен процесс параллельного умножения матрицы на вектор на трех процессорах.

[[file:Matr_x_v.png|thumb|center|700px|Рисунок 2. Схема параллельного выполнения операции между матрицей и вектором]]

Заштрихованные участки соответствуют данным, расположенным в памяти процессора исполнителя. Каждый исполнитель получает свою часть результата выполнения операции.

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

[[file:V x v.png|thumb|center|700px|Рисунок 3. Схема параллельного выполнения операции между двумя векторами]]

Таким образом, параллельное выполнение любой из выделенных подзадач привело к распределению вычислительной нагрузки между всеми исполнителями.

==== Объединение результатов расчетов ====

Результатом выполнения рассматриваемых операций является, чаще всего, вектор, части которого расположены на участвовавших в вычислениях процессорах. Для объединения результатов расчета и получения полного вектора на каждом процессоре вычислительной системы необходимо выполнить операцию сбора данных. В качестве обменных взаимодействий в модели с распределённой памятью могут выступать операции массовых коммуникационных обменов. С их помощью каждый процессор передаст свой вычисленный элемент вектора всем остальным процессорам (см. рис. 4).
[[file:Collect.png|thumb|center|700px|Рисунок 4. Принцип сбора результатов вычислений]]

=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===
Алгоритм GMRES достаточно популярен и его реализацию можно найти во многих пакетах прикладных программ.

'''Пример: MATLAB'''
<source lang="matlab">

Итерационный метод минимизации обобщенной невязки реализован в системе MATLAB. Для этого используется функция gmres:

gmres (А, В. restart) — возвращает решение X СЛУ А*Х=В. А —квадратная матрица. Функция gmres начинает итерации от начальной оценки, представляющей собой вектор размера и, состоящий из нулей. Итерации производятся либо до сходимости к решению, либо до появления ошибки, либо до достижения максимального числа итераций. Сходимость достигается, когда относительный остаток norm(B-A*X)/norm(B) меньше или равен заданной погрешности (по умолчанию 1е-6). Максимальное число итераций — минимум из n:restart и 10. Функция gmres (...) имеет и ряд других форм записи, аналогичных описанным для функции bieg(...).

» gmres(A.B)

GMRES(4) converged at Iteration 1(4) to a solution with relative residual le-016

ans =

1.0000

2.0000

3.0000

4.0000
</source>

Список пакетов, в которых присутствует реализация метод минимизации обобщенной невязки:
:1.'''ATLAS''' (Automatically Tuned Linear Algebra Software) – оптимизированная библиотека, включающая реализацию процедур BLAS и часть функциональности LAPACK;
:2.'''AZTEC''' – библиотека параллельных подпрограмм для решения больших систем линейных алгебраических уравнений с разреженными матрицами;
:3.'''BLAS''' (Basic Linear Algebra Subprograms) – библиотека высококачественных процедур, «строительными блоками» для которых являются вектора, матрицы или их части. Уровень 1 BLAS используется для выполнения операций вектор-вектор, уровень 2 :BLAS – для выполнения матрично-векторных операций, наконец, уровень 3 BLAS – для выполнения матрично-матричных операций. Поскольку программы BLAS являются эффективными, переносимыми и легко доступными, они используются как базовые компоненты для развития высококачественного программного обеспечения для задач линейной алгебры. Так были созданы широко известные пакеты LINPACK, EISPACK, которые затем были перекрыты пакетом LAPACK, получившим большое распространение. Перечисленные пакеты разработаны на языке Fortran;
:4.'''BLACS''' (Basic Linear Algebra Communication Subprograms) – набор базовых коммуникационных процедур линейной алгебры, созданных для линейной алгебры. Вычислительная модель состоит из одномерной или двумерной решетки процессов, где каждый процесссодержит часть матрицы или вектора. BLACS используется как коммуникационный слой проекта ScaLAPACK, который переносит библиотеку LAPACK на машины с распределенной памятью;
:5.'''BlockSolve95''' – параллельная библиотека для решения разреженных систем линейных уравнений;
:6.'''BPKIT2''' – пакет блочных способов предобусловливания, ориентированных на разреженные матрицы;
:7.'''CAPSS''' – пакет для параллельного решения разреженных линейных систем;
:8.'''CXML''' (The Compaq Extended Math Library) – расширенная математическая библиотека, включающая в себя часть функциональности BLAS, LAPACK, Direct Sparse Solvers и Iterative-solvers;
:9.'''Direct Sparse Solvers''' – пакет программ для решения разреженных систем прямыми методами;
:10.'''EISPACK''' (Eigensystem Package) – пакет программ решения алгебраической проблемы собственных значений;
:11.'''Expokit''' – пакет программ для решения не больших СЛАУ с плотной матрицей и больших разреженных систем;
:12.'''ILUPACK''' – библиотке, содержащая способы предобусловливания, ориентированная на разреженные СЛАУ. Пакет включает реализацию процедур BLAS, SPARSEKIT. Реализована на языке С и Fortran;
:13.'''IML++''' (Iterative Methods Library) – библиотека итерационных методов решения разреженных СЛАУ, позволяющая использовать несколько простых способов предобусловливания. Пакет включает часть BLAS и MV;
:14.'''Intel MKL''' (Intel Math Kernel Library) включает несколько стандартных библиотек для высокопроизводительных системах (BLAS, LAPACK и FFTPACK – подпрограммы быстрого преобразования Фурье);
:15.'''IOMDRV''' – пакет подпрограмм для решения симметричных и несимметричных линейных систем методами крыловских подпространств;
:16.'''Iterative-solvers''' – пакет подпрограмм решения разреженных систем итерационными методами;
:17.'''ITL''' (Iterative Template Library) – библиотека программ итерационных методов и способов предобусловливания, являющаяся составной частью MTL.
:18.'''ITPACK''' (Iterative Package) – пакет программ для решения разреженных систем итерационными методами;
:19.'''ITSOL''' (The New Sparskit Preconditionning Module) – пакет, содержащий способы предобусловливания, ориентированные на разреженные матрицы. Является составной частью пакета SPARSKIT;
:20.'''JAMA/C++''' – библиотека для решения СЛАУ прямыми методами;
:21.'''LAPACK''' (Linear Algebra Package) – набор реализаций «продвинутых» методов линейной алгебры. LAPACK содержит процедуры для решения систем линейных уравнений, задач нахождения собственных значений и факторизации матриц. Обрабатываются заполненные и ленточные матрицы, но не разреженные матрицы общего вида. Во всех случаях можно обрабатывать действительные и комплексные матрицы с одиночной и удвоенной точностью. Процедуры LAPACK построены таким образом, чтобы как можно больше вычислений выполнялось с помощью обращений к BLAS с использованием всех его трех уровней. Вследствие крупнозернистости операций уровня 3 BLAS, их использование обеспечивает высокую эффективность на многих высокопроизводительных компьютерах, в частности, если производителем создана специализированная реализация. ScaLAPACK является успешным результатом переноса пакета LAPACK на системы с передачей сообщений. Но в таких системах необходимы процедуры, обеспечивающие обмен данными между взаимодействующими процессами. Для этого в ScaLAPACK используется библиотека BLACS;
:22.'''Laspack''' – пакет программ для решения разреженных систем итерационными методами;
:23.'''LGSOLV''' – библиотека для решения СЛАУ прямыми методами;
:24.'''LINPACK''' (Linear Package) – пакет программ решения систем линейных алгебраических уравнений и линейной задачи наименьших квадратов прямыми методами;
:25.'''LinPar''' – пакет предназначенный для решения плохообусловленных СЛАУ, включая прямоугольные. Если для решения задачи необходимо предобусловливание СЛАУ, то оно выполняется отдельно и методы применяются к уже предобусловленной системе. Соответственно, по окончании процесса решения найденный вектор должен быть пересчитан согласно выполненному предобусловливанию. В схемы методов эти процедуры не включаются;
:26.'''MET''' (Matrix Expression Templates) – реализованная на языке C++ программа для инженеров и научных работников;
:27.'''MINOS''' – пакет подпрограмм решения больших разреженных задач линейного и нелинейного программирования;
:28.'''MTL''' (The Matrix Template Library) – реализованная на языке C++ библиотека базовых операций линейной алгебры, позволяющая решать СЛАУ с разреженными матрицами итерационными методами с предобусловлмванием, за счет включенного пакета ITL;
:29.'''MV++''' – небольшая библиотека, содержащая базовые операции линейной алгебры. Данный пакет часто является составной частью более крупных и высокопроизводительных библиотек;
:30.'''ParPre''' – пакет параллельных версий способов предобусловливания, ориентированных на разреженные матрицы, являющийся составной частью PETs;
:31.'''Parallel Algorithms Project''' – пакет параллельных версий итерационных методов Крыловского типа для решения разреженных систем;
:32.'''PASVA''' – пакет подпрограмм решения разреженных систем с блочно-двухдиагональной структурой;
:33.'''PBLAS''' – Параллельные версии базовых процедур линейной алгебры (BLAS) ;
:34.'''PCGPAK''' (Preconditioned Conjugate Gradient PAcKage) – пакет программ для решения симметричных и несимметричных разреженных линейных систем методом сопряженных градиентов;
:35.'''PIM''' (The Parallel Iterative Methods) – набор процедур на Фортран-77, реализующих параллельные версии различных итеративных методов решения разреженных систем линейных уравнений;
:36.'''PSparselib''' (A Portable Library of Parallel Sparse Iterative Solvers) – библиотека параллельных итерационных методов для разреженных линейных систем;
:37.'''PSPASES''' (Parallel Sparse Symmetric Direct Solver) – библиотека параллельных версий прямых методов для решения симметричных линейных систем;
:38.'''RALAPACK''' – пакет подпрограмм для различных операций с разреженными матрицами;
:39.'''ScaLAPACK''' (Scalable LAPACK) – параллельная версия LAPACK. Широкий набор подпрограмм для решения стандартных задач линейной алгебры;
:40.'''SIRSM''' – пакет подпрограмм для решения разреженных несимметричных линейных систем;
:41.'''Software Iterative Methods: GMRESR and BiCGstab(ell)''' – пакет прогамм решения больших разреженных систем с несимметричной матрицей;
:42.'''SPAI''' (Sparse Approximate Inverse Preconditioner) – пакет способов предобусловливания, ориентированных на разреженные матрицы;
:43.'''SPARKS''' – пакет подпрограмм для решения разреженных линейных систем в полунеявных методах Рунге-Кутта численного интегрирования систем обыкновенных дифференциальных уравнений;
:44.'''SparseLib++''' – библиотка, реализованная на языке C++, позволяющая решать разреженные СЛАУ итерационными методами с предобусловливанием. Включает часть процедур BLAS и IML;
:45.'''SPARSKIT''' – мощный пакет для решения разреженных СЛАУ итерационными методами с предобусловливанием. Библиотека реализованна на языке Fortran;
:46.'''SPARSPAK''' (Sparsee Iinear Equations Package) – пакет программ решения разреженных систем линейных алгебраических уравнений с симметричными положительно определенными матрицами;
:47.'''SPLIB''' – библиотека, позволяющая решать СЛАУ с разреженной матрицей итерационными методами с предобусловливанием, реализованная на языке Fortran;
:48.'''SPLP''' (Sparse Linear Programming Subprogram) – пакет программ решения задач линейного программирования;
:49.'''SPOOLES''' – библиотека для решения СЛАУ с разреженной матрицей прямыми методами;
:50.'''SSLES''' – пакет подпрограмм для решения разреженных несимметричных линейных систем;
:51.'''TCHLIB''' – пакет подпрограмм для решения симметричных и несимметричных линейных систем методом Чебышева;
:52.'''TNT''' (Template Numerical Toolkit) – библиотека базовых операций линейной алгебры, ориентированная на разреженные матрицы. Библиотека разработана на языке Fortran;
:53.'''WSMP''' (Watson Sparse Matrix Package) – пакет программ решения разреженных систем линейных алгебраических уравнений;
:54.'''XMP''' – пакет подпрограмм для решения задач линейного программирования;
:55.'''YI2M''' – комплекс программ решения разреженных систем;

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

Обсуждение участника:Макарова Алёна

2016-11-14T07:28:10Z

Dan:

= Пункт 1.7 =
'''принято''' Необходимо добавить пояснения, что есть что в приведенном графе.
Если это информационный граф на макроуровне, то для входящих в него значимых операций надо привести соответствующие им информационные графы.

Участник:Obirvalger/Метод рекурсивной координатной бисекции

2016-11-14T07:25:59Z

Dan:

{{Assignment|Dan}}

{{algorithm
| name = Рекурсивная координатная бисекция
| serial_complexity = <math>O(n \log_2{n} \log_2{k})</math>
| pf_height = <math>\log_2{k}</math>
| pf_width = <math>k</math>
| input_data = <math>N|V| + |G|</math>
| output_data = <math>|V|</math>
}}

Авторы: [[Участник:Obirvalger|Гордеев Михаил]] (разделы 1.4, 1.6, 1.8, 1.10), [[Участник:KolmakovEA|Колмаков Евгений]] (разделы 1.1, 1.2, 1.3, 1.5, 1.7, 1.9, 2.7).

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

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

=== Задача декомпозиции графа ===
'''Метод рекурсивной координатной бисекции''' является одним из методов, применяемых для декомпозиции графов <ref>Якобовский М.В. Введение в параллельные методы решения задач: Учебное пособие / Предисл.: В. А. Садовничий. – М.: Издательство Московского университета, 2012. – 328 с., илл. – (Серия «Суперкомпьютерное образование»), ISBN 978-5-211-06382-2 URL: http://lira.imamod.ru/ITTPMOPS/</ref>. В прикладных задачах, как правило, граф
представляет собой сетку в пространстве некоторой размерности. При численном решении задач механики сплошной среды с помощью методов конечных разностей или конечных элементов широко используется геометрический параллелизм, при котором сетка, покрывающая расчётную область, разбивается на множество доменов, каждый из которых обрабатывается отдельным процессором. Основная проблема связана с необходимостью решения задачи статистической балансировки загрузки, то есть равномерного распределения вычислительной нагрузки между процессорами за счёт выбора оптимальной декомпозиции сетки.

=== Критерии декомпозиции ===
В зависимости от специфики решаемой задачи, к виду декомпозиции графов могут быть предъявлены разные требования. Существует много критериев декомпозиции, однако наиболее классическим из них считается минимизация максимального веса исходящих из домена ребёр (в простейшем случае - минимизация числа разрезанных ребер). Среди других критериев можно выделить следующие:
* выделение обособленных доменов;
* минимизация максимальной степени доменов;
* обеспечение связности доменов;
* обеспечение связности множества внутренних узлов доменов.

=== Метод рекурсивной бисекции ===
Метод рекурсивной координатной бисекции является частным случаем более общего '''метода рекурсивной бисекции'''. В этом методе сетка последовательно за <math>k-1</math> шаг делится на <math>k</math> частей. На первом шаге сетка делится на две части, далее каждая из полученных ранее частей также делится на две части и т.п. Конкретные алгоритмы деления сетки на две части (бисекции) и определяют метод рекурсивной бисекции. Соотношение размеров частей зависит количества доменов и процедуры вычисления желаемого числа вершин в каждой из формируемых частей графа.

=== Метод рекурсивной координатной бисекции ===
Для декомпозиции больших сеток применяют параллельные алгоритмы, предполагающие, что сетка уже распределена по процессорным узлам. Они эффективны, только если вершины распределены по процессорам компактными группами, а не произвольно. Однако к моменту начала работы алгоритмов декомпозиции, никакая декомпозиция сетки еще не найдена, поэтому требуется некоторый простой способ предварительного распределения графа по выполняющим декомпозицию процессорам. Для решения этой задачи и используется метод рекурсивной покоординатной бисекции. Несмотря на то, что он уступает по качеству формируемой декомпозиции некоторым другим методам, его целесообразно использовать на предварительном этапе, благодаря скорости работы, ориентированности на распределенную обработку и простоте.

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

=== Выбор координатной оси ===
В зависимости от [[#Критерии декомпозиции|критериев декомпозиции]] и других особенностей задачи могут быть использованы различные критерии выбора координатной оси вдоль, которой будет производится разбиение сетки на две части. Наиболее используемыми являются следующие:
* Протяжённость области вдоль данной оси: для каждой оси вычисляется разность между максимумом и минимумом координат вершин сетки по данной оси, и выбирается ось с наибольшим значением этой величины;
* Число разрезанных ребер при разбиении сетки вдоль данной оси: вершины упорядочиваются вдоль каждой из осей, и выбирается тот вариант, который приводит к наименьшему числу разрезанных ребер;

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

Исходные данные: граф <math>G = (V, E) </math>, вложенный в <math>\mathbb{R}^N</math> (то есть каждая вершина этого графа - это точка в <math>N</math> мерном пространстве), и число <math>k</math> доменов, на которое нужно разбить граф.
Под ''декомпозицией'' графа на <math>k</math> доменов понимается разбиение множества вершин <math>V</math> на <math>k</math> подмножеств <math>V_1, \dots, V_k</math> таких, что

<center><math>V = \bigcup_{i = 1}^k V_i</math> и <math>V_i \cap V_j = \varnothing</math> при <math>i \neq j</math>.</center>

С каждым доменом можно связать порождённый им подграф <math>G(V_i) = (V_i, E_i)</math>, где <math>E_i \subseteq E</math> - множество рёбер, оба конца которых принадлежат домену.

Задача заключается в нахождении декомпозиции <math>V_1, \dots, V_k</math>, доставляющей минимум некоторого функционала (см. [[#Критерии декомпозиции| соответствующий пункт]]), например, числа разрезанных рёбер <math>E_{\mbox{cut}} = |\{(u, v) \in E \mid u \in V_i, v \in V_j, i \neq j\}| = |E| - \sum_{i = 1}^k |E_i|</math>.

Дадим формальное описание алгоритма. Как уже упоминалось, метод основан на алгоритме рекурсивной бисекции, поэтому представляет собой рекурсивную процедуру, на вход которой поступает граф <math>G = (V, E) </math> и число доменов <math>k</math>, на которое нужно разбить множество вершин данного графа. Внутри этой процедуры выполняется следующая последовательность действий:
* в зависимости от числа доменов вычисляется "желаемое" число доменов и вершин в каждой из частей разбиения;
* вызывается процедура координатной бисекции для получения разбиения графа на две части;
* для каждой из двух полученных частей рекурсивно вызывается описываемая процедура (если число доменов для этой части больше единицы).

Процедура координатной бисекции устроена следующим образом:
* [[#Выбор координатной оси| выбирается]] координатная ось <math>m^* \in \{1, \dots, N\}</math>;
** в случае максимизации протяженности: для каждой оси <math>m</math> вычисляется величина <math>l_m = \max_{v \in V} v_m - \min_{v \in V} v_m</math>, и выбирается ось <math>m^* = \arg\max_{m \in \{1, \dots, N\}} l_m</math>;
** в случае минимизации числа разрезанных ребер: вершины упорядочиваются вдоль каждой из осей, для каждой оси вычисляется величина <math>E^m_{\mbox{cut}}</math>, равная числу разрезанных ребер при разбиении вдоль данной оси, и выбирается ось <math>m^* = \arg\max_{m \in \{1, \dots, N\}} E^m_{\mbox{cut}}</math>;
* множество вершин сортируется по возрастанию координаты с номером <math>m^*</math>;
* отсортированный массив вершин делится на две (непрерывные) части в соответствии с желаемым числом вершин в каждой из частей;
**как правило, выбирается индекс <math>i = \lfloor\frac{k+1}{2k}\rfloor \cdot |V|</math>, соответствующий примерно равному разделению текущего графа на части;
* первая часть состоит из вершин <math>v \in V</math> с индексами <math>j \leqslant i</math>, вторая - с индексами <math>j > i</math>.

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма составляют сортировки массива вершин сетки по выбранной координате при каждом из <math>k - 1</math> вызовов процедуры бисекции.

Также, в зависимости от критерия выбора координатной оси, требуются дополнительные вычисления:
*В случае максимизации протяженности при каждом вызове требуется вычисление величины <math>l_m</math>.
*В случае минимизации числа разрезанных ребер при каждом вызове требуется сортировка по каждой из координат (таким образом, при каждом разбиении осуществляется <math>N</math> сортировок).

== Макроструктура алгоритма ==
Как записано в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют множественные (всего <math>k-1</math>) сортировки (функция argsort в коде в [[#Схема реализации последовательного алгоритма |следующем разделе]]).

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

Опишем последовательную реализацию метода рекурсивной координатной бисекции, где выбор оси производится исходя из условия максимизации протяженности вдоль этой оси. Ниже представлен код данного алгоритма на языке Python 3.

<source lang="python">
# Переменная для хранения результата работы алгоритма
partition = []

# V - numpy.ndarray размера |V| x N, k - число доменов
def recursive_bisection(V, k):

global partition

# Если текущая часть графа есть домен, добавляем ее к результату разбиения
if (k <= 1):
partition.append(V)
return

# Вычисляем количество доменов в каждой из частей
k1 = (k + 1) / 2
k2 = k - k1

# Производим разбиение
V1, V2 = bisect(V, k)

# Рекурсивно разбиваем каждую из частей
recursive_bisect(V1, k1)
recursive_bisect(V2, k2)

def bisect(V, k):
# Вычисляем координату с наибольшей протяженностью
t = V.max(axis=0) - V.min(axis=0)
m = t.argmax()

# Сортируем вершины по координате с номером m
V_sorted = V[V[:, m].argsort()]

# Вычисляем индекс для разбиения в соответствии с числом доменов
ind = (k + 1) * V.shape[0] // (2 * k)

return V_sorted[:ind, :], V_sorted[ind:, :]
</source>

Приведённый код предназначен для более подробного описания основных шагов в алгоритме, представляет собой лишь схему и не является максимально эффективным. Это сделано для того, чтобы код был более наглядным. В более эффективной реализации, например, вместо создания массивов в процедуре bisect можно везде оперировать только индексами.

== Последовательная сложность алгоритма ==
Обозначим через <math>D_k(n)</math> сложность алгоритма рекурсивной координатной бисекции для декомпозиции графа с <math>n</math> вершинами на <math>k</math> доменов.

Определим величину <math>D(n) = D_n(n)</math>. Для <math>D(n)</math> имеет место следующее рекуррентное равенство:

<center>
<math>
\begin{array}{l}
D(n) = S(n) + 2D(\frac{n}{2}) \\
D(1) = S(1) = 0. \\
\end{array}
</math>, где <math>S(n)</math> - это сложность алгоритма сортировки массива из <math>n</math> элементов.
</center>

Пусть <math>S(n) = O(n\log_2{n})</math> (например, для сортировки слиянием), тогда по теореме о рекуррентных соотношениях <ref>https://ru.wikipedia.org/wiki/Основная_теорема_о_рекуррентных_соотношениях</ref> для произвольного положительного <math>\varepsilon</math> имеет место оценка <math>D(n) \lesssim n^{1+\varepsilon}</math>.

Величину <math>D_k(n)</math> можно явно посчитать по формуле <math>\sum\limits_{i=0}^{\lceil\log_2{k}\rceil}2^i S(\frac{n}{2^i})</math>. Если использовать сортировку со сложностью <math>S(n) = O(n\log_2{n})</math>, то
<center>
<math>D_k(n) = </math> <math>O(\sum\limits_{i=0}^{\lceil\log_2{k}\rceil}2^i \frac{n}{2^i} \log_2{\frac{n}{2^i}}) = </math> <math>O(n\log_2(\prod\limits_{i=0}^{\lceil\log_2{k}\rceil}\frac{n}{2^i})) = </math> <math>O(n\log_2{\frac{n^{\log_2{k}}}{2^\frac{\log_2{k}(\log_2{k}+1))}{2}}}) =</math> <math> O(n(\log_2{n}\log_2{k} - \frac{\log^2_2{k}}{2})) = </math> <math>O(n\log_2{n}\log_2{k})</math>.
</center>

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

Под операцией в данном пункте будем понимать макрооперацию сортировки. Передача данных происходит после разбиения множества вершин на две части.
Таким образом, информационный граф представляет из себя бинарное дерево с <math>k</math> листьями. На рисунке ниже приведена часть информационного графа для <math>k = 16</math>. Зависимость от числа вершин <math>n</math> учитывается в самих узлах дерева.

<center>
[[Файл:Tree_sort.svg|thumb|center|800px|Рисунок 1. Граф алгоритма.]]
</center>

Высота ярусно-параллельной формы - <math>\log_2{k}</math>.

Ширина ярусно-параллельной формы - <math>k</math>.

Если рассматривать более мелкие операции, используемые в процессе сортировки, то глобально информационный граф будет выглядеть также, однако каждый
узел будет заменён на информационный граф используемого алгоритма сортировки (или <math>N</math> таких графов, если используется критерий минимизации числа разрезов).

== Ресурс параллелизма алгоритма ==
Данный алгоритм обладает координатным параллелизмом.
Для декомпозиции графа с <math>n</math> вершинами на <math>k</math> доменов методом рекурсивной координатной бисекции в параллельном варианте требуется последовательно выполнить <math>\lceil\log_2{k}\rceil</math> ярусов. На <math>i</math>-ом ярусе будет выполнятся <math>2^i</math> операций сортировки.
Рассмотрим два случая распараллеливания нашего алгоритма:
* Параллельное выполнение операций на каждом ярусе с использованием последовательного алгоритма сортировки со сложностью <math>O(n\log_2{n})</math>.
# На первом шаге один процессор производит сортировку всех вершин, разделяет граф на два подграфа и передает однин из подрафов новому процессору.
# На <math>i</math>-ом шаге каждый из уже получивший свой граф процессор производит сортировку всех вершин, разделяет граф на два подграфа и передает однин из подрафов новому процессору.

Тогда сложность нашего алгоритма равна:
<center>
<math>D_k(n) = O(\sum\limits_{i=0}^{\lceil\log_2{k}\rceil}\frac{n}{2^i} \log_2{\frac{n}{2^i}}) = </math> <math>n\sum\limits_{i=0}^{\lceil\log_2{k}\rceil}(\frac{\log_2{n}}{2^i} - \frac{i}{2^i}) = </math> <math>O(n\log_2{n}) - O(n) = O(n\log_2{n})</math>.
</center>

*Параллельное выполнение операций на каждом ярусе с использованием параллельного алгоритма сортировки со сложностью <math>O(\log_2^2{n})</math><ref>https://en.wikipedia.org/wiki/Batcher_odd–even_mergesort</ref>.
На каждом шаге производится параллельная сортировка вершин и разбиение графа на два подграфа.
В этом случае

<center>
<math>D_k(n) = \sum\limits_{i=0}^{\lceil\log_2{k}\rceil}\log^2_2\frac{n}{2^i} = O(\log^2_2{n}\log_2{k}) = O(\log^3_2{n})</math>.
</center>
Известно <ref>https://en.wikipedia.org/wiki/Sorting_algorithm</ref>, что оптимальная параллельная сортировка имеет сложность <math>O(\log_2{n})</math>. В этом случае
<center>
<math>D_k(n) = \sum\limits_{i=0}^{\lceil\log_2{k}\rceil}\log_2\frac{n}{2^i} = O(\log_2{n}\log_2{k})</math>.
</center>

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

'''Входные данные:''' граф <math>G = (V, E) </math>, вложенный в <math>\mathbb{R}^N</math>, и число <math>k</math> частей (доменов), на которое нужно разбить граф. Таким образом, помимо матрицы смежности (или любого другого представления графа) для каждой вершины <math>v \in V</math> задан набор её координат <math>v = (v_1, \dots, v_N) \in \mathbb{R}^N</math>, поэтому <math>V</math> задаётся массивом <math>N</math>-мерных векторов или матрицей размера <math>|V| \times N</math>.

'''Объём входных данных:''' <math>N|V| + |G|</math>, где <math>|G|</math> - объём данных, представляющих граф <math>G</math>, который в общем случае зависит от выбранного представления.

'''Выходные данные:''' <math>k</math> доменов графа <math>G</math>, задающих его декомпозицию.

'''Объём выходных данных:''' <math>|V|</math> - для каждого домена достаточно хранить соответствующие вершинам из этого домена индексы строк в матрице, представляющей множество вершин.

== Свойства алгоритма ==
Соотношение последовательной и параллельной сложности в случае неограниченных ресурсов является ''линейным'' (отношение <math>O(n\log{n})</math> к <math>O(\log{n}))</math>.

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

Так как количество вершин на разных процессорах примерно одинаковое алгоритм является сбалансированным по числу операций на каждом процессоре.

Алгоритм достаточно прост и легко модифицируется в зависимости от критерия декомпозиции.

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

== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==

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

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

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

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

== Существующие реализации алгоритма ==
Описанный алгоритм реализован во многих пакетах декомпозиции графов, включающих в себя и другие версии алгоритма бисекции.

Последовательная версия алгоритма реализована в пакетах Chaco, JOSTLE, [http://glaros.dtc.umn.edu/gkhome/metis/metis/overview METIS], [https://www.labri.fr/perso/pelegrin/scotch/ SCOTCH].

Параллельная версия реализована в пакетах JOSTLE, [http://glaros.dtc.umn.edu/gkhome/metis/parmetis/overview ParMETIS], [https://www.labri.fr/perso/pelegrin/scotch/ PT-SCOTCH].

Стоит отметить, что пакеты METIS и ParMETIS распространяются свободно.

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

[[en:Recursive coordinate bisection method]]

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

2016-11-14T07:25:31Z

Dan:

замечания остались те же:

= Вклад =
'''принято''' Необходимо явно указать вклад каждого соавтора.

= Пункт 1.5 =
'''принято''' Если код не свой, необходимо дать явную ссылку на источник.

Код свой.

= Пункт 1.7 =
'''принято''' Граф следует оформить как рисунок, добавить подпись.
Представленный рисунок отражает схему работы, а требуется привести информационный граф.
Приведенный рисунок можно оставить, но информационный граф надо добавить.

Не могли бы Вы объяснить, почему данный рисунок не удовлетворяет определению [[глоссарий#Граф алгоритма|информационного графа]]?
Вершины соответствуют операциям (у нас указано явно, что под операцией понимается сортировка), дуги - передаче данных
(здесь также все соответствует алгоритму).

'''принято''' В первом приближении решили оставить так.

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

2016-11-10T13:05:39Z

Dan:

замечания остались те же:

= Вклад =
Необходимо явно указать вклад каждого соавтора.

= Пункт 1.5 =
Если код не свой, необходимо дать явную ссылку на источник.

= Пункт 1.7 =
Граф следует оформить как рисунок, добавить подпись.
Представленный рисунок отражает схему работы, а требуется привести информационный граф.
Приведенный рисунок можно оставить, но информационный граф надо добавить.

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

2016-11-10T13:01:52Z

Dan:

замечания остались те же:

= Вклад =
Необходимо явно указать вклад каждого соавтора.

= Пункт 1.5 =
Если код не свой, необходимо дать явную ссылку на источник.

= Пункт 1.7 =
'''принято''' Граф следует оформить как рисунок, добавить подпись.

Участник:Lvs/Итерационный метод решения системы линейных алгебраических уравнений GMRES

2016-11-09T14:48:17Z

Dan:

{{Assignment|Dan}}

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Итерационный метод решения системы линейных алгебраических уравнений GMRES (или обобщенный метод минимальных невязок) используется для решения систем линейных алгебраических уравнений с заданной точностью приближения. Метод основан на процессе Арнольди, посредством которого матрица СЛАУ приводится к (верхней) хессенберговой форме.

== Математическое описание алгоритма ==
Дана система линейных алгебраических уравнений <math>Ax = b</math>, где <math>A</math> - квадратная матрица размера <math>n \times n</math>.

Вычисляется последовательность приближённых решений уравнения <math> x_m </math>, которая сходится к точному решению уравнения <math>x^*</math>.

Подпространство Крылова размерности <math>m</math>, порожденное вектором <math>b</math> и матрицей <math>A</math> – линейное пространство
<math>K_m(A, v)</math>, являющееся линейной оболочкой векторов <math>b, Ab, A^2b, ..., A^{m-1}b</math>.

Приближённое решение считается по формуле <math> x_m = Q_my_m</math>, где <math>Q_m</math> - матрица размера <math>n \times m</math>, составленная из векторов ортонормированного базиса пространства <math>K_m(A, v)</math>, <math>y_m \in \mathbb{R}^m</math>.

Итоговым считается решение, минимизирующее норму невязки (<math>||r||_2 = ||b - Ax_m||_2</math>) с заданной точностью.
== Вычислительное ядро алгоритма ==
Алгоритм Арнольди:
<source>
q[1] = b/||b||
for j = 1, ..., n-1 do
z = Aq[j]; //очередной вектор
for i = 1,..., j do
h[i][j] = (z, q[i]);
z = z − h[i][j]q[i];
end i
h[j+1][j] = ||z||;
if (h[j+1][j] == 0) break;
q[j+1] = z/h[j+1][j];
end j
</source>
Сложность алгоритма <math>O(n^2)</math>.

На каждом шаге алгоритма получаются векторы <math>q_1, q_2, ..., q_m</math>, являющиеся ортонормированным базисом Крыловского пространства <math>K_m(A, b)</math>.

Значения <math>h_{i,j}</math> образуют верхнюю матрицу Хессенберга (обозначим как <math>H_m</math>, размерность <math>m+1 \times m</math>).

<math>H_k = \begin{bmatrix}h_{11} & h_{12} & h_{13} &... & h_{1m-1} & h_{1m} \\ h_{21} & h_{22} & h_{23} & ... & h_{2m-1} & h_{2m} \\ 0 & h_{32} & h_{33} &...& h_{3m-1} & h_{3m} \\ ... & ... & ... & ... & ... & ... \\ 0 & 0 & 0 & ... & h_{m m-1} & h_{mm} \\0 & 0 & 0 & ... & 0 & h_{m+1 m}\end{bmatrix}</math>.

Вектор невязки задан уравнением <math>r_m = H_my_m - ||b - Ax_0||e_1</math>, где <math>x_0</math> - вектор начального приближения. Минимизация второй нормы вектора невязки представляет из себя решение линейной задачи минимальных квадратов размера <math>n</math>.

Приближённое решение вычисляется по формуле <math> x_m = Q_my_m</math> после нахождения соответствующего значения минимизирующего вторую невязку вектора. Сложность вычислений <math>O(nm)</math>
== Макроструктура алгоритма ==
# Алгоритм Арнольди
# Решение линейной задачи минимальных квадратов
# Вычисление решения
== Схема реализации последовательного алгоритма ==
<source>
Вычислить ортонормированный базис размера m
Вычислить минимальное приближение
if (приближение < заданная точность)
Вычислить результат
return;
else
Повторить для m = m+1
</source>
== Последовательная сложность алгоритма ==
Сложность вычислений собственных векторов на каждом шаге - <math>O(n^2)</math>, но может уменьшиться до <math>O(n)</math> при более разреженной матрице.

Сложность решения задачи минимальных квадратов <math>O(m^2)</math>, но при последовательном выполнении алгоритма можно понизить сложность до <math>O(m)</math> путём использования подсчитанных на прошлых итерациях значений.

Сложность вычисления решения <math>O(nm)</math>, поэтому его целесообразно вычислять только в конце.
== Информационный граф ==
Основной ресурс параллелизма - умножение матрицы на вектор. Для этой операции информационный граф представлен на рисунке.

[[file:GraphLvs2FM.jpg|thumb|center|700px|Рис.1. Информационный граф умножения матрицы на вектор]]

== Ресурс параллелизма алгоритма ==
# Параллельное умножение матрицы на вектор выполняется в <math> n </math> ярусов умножений и сложений.
# Шаги алгоритма Арнольди выполняются строго последовательно, однако последующее нахождение невязки можно выполнять параллельно с запуском следующего шага алгоритма.
# Сложность решения задачи минимальных квадратов зависит от используемого алгоритма. В отличие от последовательного метода данные, полученные на прошлых шагах здесь использовать нельзя.
# Вычисление результата выполняется один раз, его можно выполнить параллельно в <math> n </math> ярусов умножений и сложений.

== Входные и выходные данные алгоритма ==
'''Входные данные:''' Матрица <math>A</math>, вектор <math>b</math>, точность <math>t</math>. Объём: <math>n^2 + n + 1</math>

'''Выходные данные:''' Вектор <math>x_m</math>. Объём: <math>n</math>

== Свойства алгоритма ==
Теоретически на каждой итерации алгоритма сложность вычислений составляет <math>n + X</math> операций умножения, где <math>X</math> - сложность алгоритма для решения задачи минимальных квадратов. Таким образом в худшем случае сложность будет примерно равна <math>n^2 + X*n + n</math> операций умножения.

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

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

== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Реализации алгоритма GMRES присутствуют во многих программных продуктах как части стандартных библиотек, например Matlab или DEFORM3D. Также существую отдельные библиотеки, например MGMRES для языка С++.

= Литература =
[1] Тыртышников Е. Е. Методы численного анализа — М., Академия, 2007.

[2] М. Дана, А. Г. Зыков, Х. Д. Икрамов Метод минимальных невязок для специального класса линейных систем с нормальными матрицами коэффициентов - Ж. вычисл. матем. и матем. физ., 2005, том 45, номер 11

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

2016-11-09T14:48:06Z

Dan:

= Пункт 1.7 =
'''принято'''

- Поплыло форматирование: между рисунками из п.1.7 включается содержимое п.1.8 и далее
- Необходимо привести описание, что чему соответствует на рисунках, а лучше перерисовать. Пока это нельзя рассматривать как информационный граф.

= Литература =
'''принято'''

См. именование пункта в шаблоне.