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

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-11-21T12:51:07Z

Пронин Андрей: /* Ресурс параллелизма алгоритма */

{{algorithm
| name = Метод Якоби вычисления собственных значений симметричной матрицы ЗП
| serial_complexity = <math>O(n^3)</math>
| pf_height = <math>O(n^2)</math>
| pf_width = <math>2n</math>
| input_data = <math>n^2</math>
| output_data = <math>n</math>
}}

Авторы: [[Участник:Зиновьев Владимир|Зиновьев В.С.]] (написание кода, информационный граф, общее и мат описание алгоритма), [[Участник:Пронин Андрей|Пронин А.М.]] (написание кода, информационный граф, вычислительное ядро алгоритма, макроструктура алгоритма). В остальные разделы статьи вклад равноценный.

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

=== Общее описание алгоритма ===
Задача нахождения собственных значений и собственных векторов матриц(СЗВМ) является одной из основных задач для многих разделов физики. <ref>Чечин Г.М., Зехцер М.Ю. Собственные значения и собственные векторы матриц</ref> С такой вычислительной проблемой приходится сталкиваться, например, при исследовании собственных колебаний различных механических систем, колебательных и электронных спектров молекул и кристаллов. Совершенно принципиальное значение эта проблема приобрела после создания в тридцатых годах прошлого века квантовой механики, которая стала базовой дисциплиной исследования микромира.Кроме того, данная проблема важна в теории автоматического управления, как инструмент исследования устойчивости линейных систем.

Метод Якоби приводит симметричную действительную матрицу к диагональной форме с помощью некоторой (в принципе, бесконечной) последовательности плоских вращений в разных плоскостях исходного n-мерного векторного пространства. Метод Якоби состоит из некоторой последовательности шагов, на каждом из которых обнуляется один из внедиагональных элементов (обычно наибольший по модулю), в результате чего старая матрица <math>A_{i}</math> преобразуется в некоторую новую матрицу <math>A_{i+1}</math>. Делается это с помощью преобразования подобия, использующего матрицу плоского вращения <math>J_{i}</math> (подробное описание матрицы плоского вращения приведено ниже в разделе "[[#Математическое описание алгоритма|Математическое описание алгоритма]]"), которая изменяет лишь две координаты <math>n</math>-мерных векторов, а именно, координаты с номерами <math>j</math> и <math>k</math>. При таком шаге матрица <math>A_{i+1}</math> отличается от матрицы <math>A_{i}</math> лишь элементами двух строк с номерами <math>j</math>, <math>k</math> и двух столбцов с теми же номерами (<math>j</math> и <math>k</math>). Все же другие элементы матрицы <math>A</math> остаются неизменными. Число шагов, за которое матрица <math>A</math> приводится таким способом к диагональной форме, в общем случае является бесконечным. (это свойство метода Якоби более подробно рассмотрено в разделе "[[#Свойства алгоритма|Свойства алгоритма]]") В результате метод Якоби представляет собой некоторый бесконечный итерационный процесс, на каждом шаге которого преобразующаяся матрица становится всё более и более близкой к диагональной форме (в смысле уменьшения суммы квадратов всех своих внедиагональных элементов). На практике обычно выбирается заранее заданная погрешность <math>\varepsilon</math> и процесс приведения исходной матрицы к диагональному виду прекращается, когда наибольший по модулю внедиагональный элемент матрицы становится меньше <math>\varepsilon</math>. Таким образом, применяя на практике метод Якоби, мы приводим исходную матрицу к диагональной форме с точностью до некоторой вычислительной погрешности <math>\varepsilon</math> в результате конечного числа шагов. Повышение этой точности требует увеличения числа шагов метода Якоби. В конечном итоге у полученной в результате этого процесса матрицы на диагонали будут находиться все собственные значения (с определённой погрешностью) исходной симметрической матрицы.

==== Симметричность матрицы ====

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

=== Математическое описание алгоритма ===
Пусть <math>A = A_0</math> — симметричная матрица. В методе Якоби для <math>A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,...</math>, которая в конечном счёте сходится к диагональной матрице, у которой диагональными элементами являются все собственные значения матрицы <math>A</math>. Матрица <math>A_{i}</math> получается из матрицы <math>A_{i-1}</math> по формуле
<math>A_{i}=J^{T}_iA_{i-1}J_i ,</math>
где <math>J_i</math> - ортогональная матрица, называемая ''вращением Якоби''. Таким образом,
<math>A_{m}=J^{T}_{m-1}A_{m-1}J_{m-1}</math>
<math>=J^{T}_{m-1}J^{T}_{m-2}A_{m-2}J_{m-2}J_{m-1}</math>
<math>=J^{T}_{m-1}...J^{T}_{0}A_{0}J_{0}...J_{m-1}</math>
<math>=J^{T}AJ</math>
При подходящем выборе вращений <math>J_i</math> матрица <math>A_m</math> для больших <math>m</math> будет близкой к диагональной матрице <math>\Lambda</math> <ref>Дж. Деммель, Вычислительная линейная алгебра. Теория и приложения. Перевод Х.Д.Икрамов</ref>. Таким образом, <math>\Lambda \approx J^{T}AJ</math> или <math>J\Lambda J^{T} \approx A</math>, следовательно, столбцы матрицы <math>J</math> являются собственными значениями матрицы <math>A</math>.
Матрица <math>J_i</math> выбирается таким образом, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}=J^{T}_{i}A_{i}J_{i}</math>:

                                                                            
<math>j</math>
                       
<math>k</math>

<math>
J_i = R(j,k,\theta) \equiv
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & -\sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Угол вращения <math>\theta</math> выбирается так, чтобы элементы <math>(j,k)</math> и <math>(k,j)</math> в <math>A_{i+1}</math> стали нулями. Для того, чтобы найти <math>\theta</math>, составляется уравнение:
:<math>
\begin{bmatrix}
a^{i+1}_{jj}&a^{i+1}_{jk}\\
a^{i+1}_{kj}&a^{i+1}_{kk}\\
\end{bmatrix} =
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix}^T
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix}
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix} =
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} ,
</math>
где <math>\lambda_1</math> и <math>\lambda_2</math> - собственные значения подматрицы
:<math>
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix} .
</math>
Пусть <math>c = \cos(\theta)</math> и <math>s = sin(\theta)</math>, <math>a^{i}_{lk} = a_{lk}</math>. Тогда из предыдущего равенства получаем
:<math>
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} =
\begin{bmatrix}
a_{jj}c^2 + a_{kk}s^2+2sca_{jk}&sc(a_{kk} - a_{jj}) + a_{jk}(c^2-s^2)\\
sc(a_{kk} - a_{jj}) + a_{jk}(c^2-s^2)&a_{jj}s^2 + a_{kk}c^2-2sca_{jk}\\
\end{bmatrix}
.
</math>
Приравнивая внедиагональный элемент к нулю, получаем
:<math>
\frac{a_{jj} - a_{kk}}{2a_{jk}} = \frac{c^2-s^2}{2sc} = ctg(2\theta) = r.
</math>
Пусть <math>tg(\theta) = t = \frac{s}{c}</math> . Заметим, что выполняется квадратное уравнение <math>t^2 + 2rt - 1 = 0</math> . Решая уравнение, получаем <math>t = \frac{sign(r)}{|r| + \sqrt{1+r^2}}</math> . Следовательно <math>c = \frac{1}{\sqrt{1+t^2}}</math>, <math>s = ct</math>

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

Вычислительным ядром отдельной итерации является вычисление элементов матрицы <math>A</math> при применении поворота Якоби. Конкретно, изменяются <math>2</math> строки и <math>2</math> столбца, что означает изменение <math>4n</math> элементов. Отметим, что вычисление нового значения одного элемента требует <math>2</math> операции умножения и одну операцию сложения, что позволяет утверждать, что основной вклад в вычислительное ядро вносят умножения.
Однако в целом, следует отметить, что число операций в алгоритме во многом определяется общим числом итераций, а оно квадратично, в то время как отдельная итерация имеет линейную сложность. Более того, так как алгоритм является итерационным и останавливается при достижении некоторой точности, число итераций может изменяться в зависимости от желаемой точности.

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

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

1) Блок вычисления параметров вращения на текущей итерации (выбор обнуляемого элемента и расчет угла вращения).

2)Блок, реализующий непосредственно вращение Якоби.

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

1)Находится максимальный наддиагональный элемент <math>a_{jk}</math> матрицы <math>A</math>.

2)Вычисляются параметры вращения Якоби:
<math>\tau= \frac{(a_{jj}-a_{kk})}{2a_{jk}}</math>
<math>t=sign(\tau)(|\tau|+\sqrt{1+\tau^2})</math>
<math>c= \frac{1}{1+\sqrt{1+\tau^2}}</math>
<math>s=c*t</math>

3)К текущей матрице <math>A</math> применяются вращения с вычисленными параметрами:
<math>A=R^T(j,k,\theta)*A*R(j,k,\theta)</math>
Стоит отметить, что вычисленные на предыдущем шаге <math>c</math> и <math>s</math> есть <math>\cos {\theta}</math> и <math>\sin {\theta}</math> соответственно.

4)Если матрица <math>A</math> не достаточно близка к диагональной, происходит переход к шагу 1.

Вообще говоря, несмотря на то, что поворот, обеспечивающий обнуление наибольшего внедиагонального элемента, обеспечивает схождение метода за наименьшее число итераций, поиск данного наибольшего элемента добавляет порядка <math>n^2</math> операций сравнения, а возможно и присваивания на каждой итерации.
Поэтому с вычислительной точки зрения выгоднее не выбирать наибольший элемент, а по очереди перебирать все наддиагональные элементы, большие заданного порога.

В последующих разделах рассматривается именно такой вариант алгоритма.

=== Последовательная сложность алгоритма ===
Сначала оценим сложность одной итерации:

1)Так как элементы матрицы никак не упорядоченны, поиск наибольшего элемента линейно зависит от числа элементов над диагональю.
Конкретнее, на данном шаге происходит <math>\frac{n*(n-1)}{2} -1</math> сравнение.

2)<math>3</math> операции деления, <math>2</math> операции взятия корня, <math>4</math> операции умножения и <math>4</math> операции сложения/вычитания.

3)<math>4n</math> операций умножения и <math>2n</math> операций сложения.

4)операция сравнения

В худшем случае количество итераций в теории равняется числу наддиагональных элементов, т.е. <math>\frac{n*(n-1)}{2}</math>
На практике же из-за накопления ошибок вычисления, а так же восстановления уже обнуленных элементов при некоторых вращениях, число операций возрастает.
Вместе с тем, можно утверждать, что порядок числа итераций будет <math>O(N^2)</math>.
Таким образом, суммарная сложность алгоритма составляет <math>O(N^4)</math> сравнений, и <math>O(N^3)</math> сложений и умножений.

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

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

Аналитически информационный граф данного алгоритма можно описать следующим образом:

1)Последовательно идущие макроярусы вычисления параметров текущей итерации и вращения Якоби с этими параметрами.
Число данных ярусов варьируется в зависимости от входных данных, но порядок составляет <math>O(n^2)</math>.

2)Вычисление параметров текущей итерации содержит конечное число операций умножения, сложения и вычисления квадратного корня.

3)Макроярус вращения Якоби содержит вычисление <math>2n+2</math> элементов матрицы и <math>2n-2</math> операций присваивания. На данном ярусе ширина графа достигает максимального значения. Вначале вычисляются значения в строках <math>j</math> и <math>k</math> (это соответствует умножению матрицы <math>R^T</math> на матрицу <math>A</math>). Далее, в силу того, что при умножении результата на матрицу <math>A</math> изменяются только столбцы <math>j</math> и <math>k</math> и итоговая матрица симметрична, можно не пересчитывать значения в столбцах, а получить их простым присваиванием по формуле: <math>a_{pk}=a_{kp}</math>, <math>a_{pj}=a_{jp}</math>, <math>p \neq k,j</math>. Для элементов <math>a_{jj}</math> и <math>a_{kk}</math> необходимо произвести вычисления, аналогичные вычислениям для элементов строк.

Визуальное представление графа алгоритма представлено на схемах ниже:

[[file:SI.jpg|thumb|center|1400px|Рисунок 1. Граф алгоритма на макроуровне. Rarams - вычисление параметров, Rotate - получение <math>A_{i+1}</math> из <math>A_{i}</math>.]]

[[file:exec_params.jpg|thumb|center|1400px|Рисунок 2. Структура блока Params.]]

[[file:ROT1.png|thumb|center|1400px|Рисунок 3. Структура блока Rotate.]]

=== Ресурс параллелизма алгоритма ===
Как видно из представления алгоритма в ярусно-параллельной форме ([[#Информационный граф| п.1.7]]), максимальная ширина ярусов составляет <math>2n</math> вершин.
Для выполнения данного алгоритма в параллельном варианте следует выполнить <math>O(\frac{n(n+1)}{2})</math> итераций.
Рассмотрим отдельную итерацию с точки зрения ярусно-параллельной формы алгоритма.

1)Выполнение 8 ярусов с конечным числом операций сложения, умножения, взятия квадратного корня и нахождения знака.

2)Выполнение 2 ярусов вычисления элементов в изменяемых строках и столбцах.

На данных двух ярусах осуществляется <math>4n</math> умножений и <math>2n</math> сложений. Данный вид параллелизма относится к координатному. Таким образом, при наличии бесконечного числа процессоров, итоговая сложность алгоритма составляет <math>O(\frac{n(n+1)}{2})</math>.

Кроме вышеизложенного, отметим следующую особенность алгоритма.
Пусть вращение <math>J_1</math> изменяет строки и столбцы с номерами <math>j_1</math> и <math>k_1</math>, а вращение <math>J_2</math> изменяет строки и столбцы с номерами <math>j_2</math> и <math>k_2</math>, и при этом выполнено:

<math>j_1 \neq j_2, k_2</math>

<math>k_1 \neq j_2, k_2</math>

Тогда вращения <math>J_1</math> и <math>J_2</math> перестановочны, и их можно выполнять параллельно.
Учитывая перебор обнуляемых элементов поочередно по строкам, данная ситуация достаточно редка. Она не изменяет итоговую сложность алгоритма, но уменьшает высоту ЯПФ на <math>O(N)</math>, а ширину ЯПФ напротив, увеличивает до <math>4n</math>. Таким образом, итоговый алгоритм следует отнести к алгоритмам с шириной ЯПФ <math>O(N)</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': плотная матрица <math>A</math> (элементы <math>a_{ij}</math>); при этом <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>..

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы).
Конкретный вариант хранения данных зависит от реализации. В качестве примеров можно привести хранение в одномерном массиве длины <math>\frac{n (n + 1)}{2}</math> по строкам своей нижней части, хранение в виде так называемого ступенчатого массива (такой вариант двумерного массива, в котором каждая строка имеет свой размер).

'''Выходные данные''': вектор собственных значений <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>) длины <math>n</math>.

=== Свойства алгоритма ===
Параллельная сложность выполнения алгоритма составляет <math>O(\frac{n(n+1)}{2}).</math>
Последовательная сложность выполнения алгоритма составляет <math>O(\frac{n^2(n+1)}{2}).</math>
Таким образом, соотношение сложностей является линейным.
Более того, и вычислительная мощность данного алгоритма линейна.

В алгоритме используется примерно в два раза больше операций умножения, чем сложения.
Отдельно стоит рассмотреть вопрос хранения матрицы <math>A</math> в процессе работы алгоритма. Хранение лишь нижней или верхней части матрицы в виде одномерного массива возможно; более того, хранение в таком виде обеспечивает экономию памяти в <math>2</math> раза и защищает от ассиметричности матрицы в результате накопления математических ошибок. Однако, вычисление индексов <math>i</math> и <math>j</math> элементов <math>a_{ij}</math>, соответствующих данному номеру <math>k</math> вообще говоря требует отдельного цикла, что создает дополнительную нагрузку на процессор.

Кроме того, следует отметить следующие особенности алгоритма:

1)Несмотря на то, что выбор наибольшего наддиагонального элемента, как кандидата на обнуление, кажется оптимальным, на самом деле он таковым не является. При таком выборе элемента, на каждой итерации необходимо находить текущий наибольший элемент в матрице, что требует дополнительных <math>\frac{n*(n-1)}{2}</math> операций сравнения и приводит к увеличению сложности алгоритма до <math>O(n^4)</math>. Вместо этого рекомендуется перебирать по очереди все наддиагональные элементы, большие заданного параметра. В большинстве случаев от <math>4</math> до <math>8</math> полных проходов достаточно для приближения исходной матрицы к диагональной.

2)Если при выборе в качестве обнуляемого элемента <math>a_{ij}</math> элементы <math>a_{ii} = a_{jj}</math>, то, как видно из формул в пунктах выше, матрицы поворота вырождаются в единичные и матрица на данной итерации не изменяется. Это еще один довод в пользу отказа от выбора наибольшего элемента, т.к. в данном случае произойдет зацикливание алгоритма.

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

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

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

==== Локальность реализации алгоритма ====

===== Структура обращений в память и качественная оценка локальности =====

===== Количественная оценка локальности =====

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

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

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

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

Исследование проводилось на 1U сервере со следующими характеристиками:
* 2 x Intel® Xeon® Processor E5-2697 v2;
* 128GB RAM;

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:
* число процессоров [1 : 48] с шагом 1
* размерность матрицы [400:1600] с шагом 200

Использовался компилятор g++ версии 5.4.0 со следующими флагами: -O2, -fopenmp, -std=c++11.
Флаг -O2 является опциональным, и означает уровень оптимизации кода при компиляции. Все прочие флаги строго обязательны при компиляции, т.к. в коде используются функции из стандарта С++11.

[[file:parallel11.jpg|thumb|center|700px|Рисунок 2. Изменение производительности в зависимости от числа процессоров и размерности матрицы.]]

Чтобы продемонстрировать важное свойство алгоритма, приведем так же график производительности в зависимости от числа процессов при размере матрицы 1600*1600

[[file:parallel1600.jpg|thumb|center|700px|Рисунок 2. Изменение производительности в зависимости от числа процессоров при размере матрицы 1600х1600.]]

За <math>1</math> принята производительность при одном процессе.
Как видно, производительность резко увеличивается при добавлении числа потоков в начале и снижается при дальнейшем добавлении.
Это связано с тем, что в одном потоке совершается малое количество арифметических операций. После выполнения операций совершается запись в массив полученных значений, в результате чего возникает конфликт потоков.
Поэтому наиболее оптимальное число потоков <math>8-16</math>, что говорит о слабой масштабируемости данного алгоритма.

[http://pastebin.com/yUyh1ziL Параллельная реализация на языке C++]

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

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

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

1)Библиотека [https://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE] содержит последовательную реализацию алгоритма.

2)В цифровой библиотеке ieee.org приводится [http://ieeexplore.ieee.org/document/6310877/ аннотация] статьи 2012 года, в которой авторы описывают реализацию данного алгоритма на CUDA.

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

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-11-21T12:49:57Z

Пронин Андрей: /* Ресурс параллелизма алгоритма */

{{algorithm
| name = Метод Якоби вычисления собственных значений симметричной матрицы ЗП
| serial_complexity = <math>O(n^3)</math>
| pf_height = <math>O(n^2)</math>
| pf_width = <math>2n</math>
| input_data = <math>n^2</math>
| output_data = <math>n</math>
}}

Авторы: [[Участник:Зиновьев Владимир|Зиновьев В.С.]] (написание кода, информационный граф, общее и мат описание алгоритма), [[Участник:Пронин Андрей|Пронин А.М.]] (написание кода, информационный граф, вычислительное ядро алгоритма, макроструктура алгоритма). В остальные разделы статьи вклад равноценный.

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

=== Общее описание алгоритма ===
Задача нахождения собственных значений и собственных векторов матриц(СЗВМ) является одной из основных задач для многих разделов физики. <ref>Чечин Г.М., Зехцер М.Ю. Собственные значения и собственные векторы матриц</ref> С такой вычислительной проблемой приходится сталкиваться, например, при исследовании собственных колебаний различных механических систем, колебательных и электронных спектров молекул и кристаллов. Совершенно принципиальное значение эта проблема приобрела после создания в тридцатых годах прошлого века квантовой механики, которая стала базовой дисциплиной исследования микромира.Кроме того, данная проблема важна в теории автоматического управления, как инструмент исследования устойчивости линейных систем.

Метод Якоби приводит симметричную действительную матрицу к диагональной форме с помощью некоторой (в принципе, бесконечной) последовательности плоских вращений в разных плоскостях исходного n-мерного векторного пространства. Метод Якоби состоит из некоторой последовательности шагов, на каждом из которых обнуляется один из внедиагональных элементов (обычно наибольший по модулю), в результате чего старая матрица <math>A_{i}</math> преобразуется в некоторую новую матрицу <math>A_{i+1}</math>. Делается это с помощью преобразования подобия, использующего матрицу плоского вращения <math>J_{i}</math> (подробное описание матрицы плоского вращения приведено ниже в разделе "[[#Математическое описание алгоритма|Математическое описание алгоритма]]"), которая изменяет лишь две координаты <math>n</math>-мерных векторов, а именно, координаты с номерами <math>j</math> и <math>k</math>. При таком шаге матрица <math>A_{i+1}</math> отличается от матрицы <math>A_{i}</math> лишь элементами двух строк с номерами <math>j</math>, <math>k</math> и двух столбцов с теми же номерами (<math>j</math> и <math>k</math>). Все же другие элементы матрицы <math>A</math> остаются неизменными. Число шагов, за которое матрица <math>A</math> приводится таким способом к диагональной форме, в общем случае является бесконечным. (это свойство метода Якоби более подробно рассмотрено в разделе "[[#Свойства алгоритма|Свойства алгоритма]]") В результате метод Якоби представляет собой некоторый бесконечный итерационный процесс, на каждом шаге которого преобразующаяся матрица становится всё более и более близкой к диагональной форме (в смысле уменьшения суммы квадратов всех своих внедиагональных элементов). На практике обычно выбирается заранее заданная погрешность <math>\varepsilon</math> и процесс приведения исходной матрицы к диагональному виду прекращается, когда наибольший по модулю внедиагональный элемент матрицы становится меньше <math>\varepsilon</math>. Таким образом, применяя на практике метод Якоби, мы приводим исходную матрицу к диагональной форме с точностью до некоторой вычислительной погрешности <math>\varepsilon</math> в результате конечного числа шагов. Повышение этой точности требует увеличения числа шагов метода Якоби. В конечном итоге у полученной в результате этого процесса матрицы на диагонали будут находиться все собственные значения (с определённой погрешностью) исходной симметрической матрицы.

==== Симметричность матрицы ====

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

=== Математическое описание алгоритма ===
Пусть <math>A = A_0</math> — симметричная матрица. В методе Якоби для <math>A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,...</math>, которая в конечном счёте сходится к диагональной матрице, у которой диагональными элементами являются все собственные значения матрицы <math>A</math>. Матрица <math>A_{i}</math> получается из матрицы <math>A_{i-1}</math> по формуле
<math>A_{i}=J^{T}_iA_{i-1}J_i ,</math>
где <math>J_i</math> - ортогональная матрица, называемая ''вращением Якоби''. Таким образом,
<math>A_{m}=J^{T}_{m-1}A_{m-1}J_{m-1}</math>
<math>=J^{T}_{m-1}J^{T}_{m-2}A_{m-2}J_{m-2}J_{m-1}</math>
<math>=J^{T}_{m-1}...J^{T}_{0}A_{0}J_{0}...J_{m-1}</math>
<math>=J^{T}AJ</math>
При подходящем выборе вращений <math>J_i</math> матрица <math>A_m</math> для больших <math>m</math> будет близкой к диагональной матрице <math>\Lambda</math> <ref>Дж. Деммель, Вычислительная линейная алгебра. Теория и приложения. Перевод Х.Д.Икрамов</ref>. Таким образом, <math>\Lambda \approx J^{T}AJ</math> или <math>J\Lambda J^{T} \approx A</math>, следовательно, столбцы матрицы <math>J</math> являются собственными значениями матрицы <math>A</math>.
Матрица <math>J_i</math> выбирается таким образом, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}=J^{T}_{i}A_{i}J_{i}</math>:

                                                                            
<math>j</math>
                       
<math>k</math>

<math>
J_i = R(j,k,\theta) \equiv
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & -\sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Угол вращения <math>\theta</math> выбирается так, чтобы элементы <math>(j,k)</math> и <math>(k,j)</math> в <math>A_{i+1}</math> стали нулями. Для того, чтобы найти <math>\theta</math>, составляется уравнение:
:<math>
\begin{bmatrix}
a^{i+1}_{jj}&a^{i+1}_{jk}\\
a^{i+1}_{kj}&a^{i+1}_{kk}\\
\end{bmatrix} =
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix}^T
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix}
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix} =
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} ,
</math>
где <math>\lambda_1</math> и <math>\lambda_2</math> - собственные значения подматрицы
:<math>
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix} .
</math>
Пусть <math>c = \cos(\theta)</math> и <math>s = sin(\theta)</math>, <math>a^{i}_{lk} = a_{lk}</math>. Тогда из предыдущего равенства получаем
:<math>
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} =
\begin{bmatrix}
a_{jj}c^2 + a_{kk}s^2+2sca_{jk}&sc(a_{kk} - a_{jj}) + a_{jk}(c^2-s^2)\\
sc(a_{kk} - a_{jj}) + a_{jk}(c^2-s^2)&a_{jj}s^2 + a_{kk}c^2-2sca_{jk}\\
\end{bmatrix}
.
</math>
Приравнивая внедиагональный элемент к нулю, получаем
:<math>
\frac{a_{jj} - a_{kk}}{2a_{jk}} = \frac{c^2-s^2}{2sc} = ctg(2\theta) = r.
</math>
Пусть <math>tg(\theta) = t = \frac{s}{c}</math> . Заметим, что выполняется квадратное уравнение <math>t^2 + 2rt - 1 = 0</math> . Решая уравнение, получаем <math>t = \frac{sign(r)}{|r| + \sqrt{1+r^2}}</math> . Следовательно <math>c = \frac{1}{\sqrt{1+t^2}}</math>, <math>s = ct</math>

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

Вычислительным ядром отдельной итерации является вычисление элементов матрицы <math>A</math> при применении поворота Якоби. Конкретно, изменяются <math>2</math> строки и <math>2</math> столбца, что означает изменение <math>4n</math> элементов. Отметим, что вычисление нового значения одного элемента требует <math>2</math> операции умножения и одну операцию сложения, что позволяет утверждать, что основной вклад в вычислительное ядро вносят умножения.
Однако в целом, следует отметить, что число операций в алгоритме во многом определяется общим числом итераций, а оно квадратично, в то время как отдельная итерация имеет линейную сложность. Более того, так как алгоритм является итерационным и останавливается при достижении некоторой точности, число итераций может изменяться в зависимости от желаемой точности.

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

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

1) Блок вычисления параметров вращения на текущей итерации (выбор обнуляемого элемента и расчет угла вращения).

2)Блок, реализующий непосредственно вращение Якоби.

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

1)Находится максимальный наддиагональный элемент <math>a_{jk}</math> матрицы <math>A</math>.

2)Вычисляются параметры вращения Якоби:
<math>\tau= \frac{(a_{jj}-a_{kk})}{2a_{jk}}</math>
<math>t=sign(\tau)(|\tau|+\sqrt{1+\tau^2})</math>
<math>c= \frac{1}{1+\sqrt{1+\tau^2}}</math>
<math>s=c*t</math>

3)К текущей матрице <math>A</math> применяются вращения с вычисленными параметрами:
<math>A=R^T(j,k,\theta)*A*R(j,k,\theta)</math>
Стоит отметить, что вычисленные на предыдущем шаге <math>c</math> и <math>s</math> есть <math>\cos {\theta}</math> и <math>\sin {\theta}</math> соответственно.

4)Если матрица <math>A</math> не достаточно близка к диагональной, происходит переход к шагу 1.

Вообще говоря, несмотря на то, что поворот, обеспечивающий обнуление наибольшего внедиагонального элемента, обеспечивает схождение метода за наименьшее число итераций, поиск данного наибольшего элемента добавляет порядка <math>n^2</math> операций сравнения, а возможно и присваивания на каждой итерации.
Поэтому с вычислительной точки зрения выгоднее не выбирать наибольший элемент, а по очереди перебирать все наддиагональные элементы, большие заданного порога.

В последующих разделах рассматривается именно такой вариант алгоритма.

=== Последовательная сложность алгоритма ===
Сначала оценим сложность одной итерации:

1)Так как элементы матрицы никак не упорядоченны, поиск наибольшего элемента линейно зависит от числа элементов над диагональю.
Конкретнее, на данном шаге происходит <math>\frac{n*(n-1)}{2} -1</math> сравнение.

2)<math>3</math> операции деления, <math>2</math> операции взятия корня, <math>4</math> операции умножения и <math>4</math> операции сложения/вычитания.

3)<math>4n</math> операций умножения и <math>2n</math> операций сложения.

4)операция сравнения

В худшем случае количество итераций в теории равняется числу наддиагональных элементов, т.е. <math>\frac{n*(n-1)}{2}</math>
На практике же из-за накопления ошибок вычисления, а так же восстановления уже обнуленных элементов при некоторых вращениях, число операций возрастает.
Вместе с тем, можно утверждать, что порядок числа итераций будет <math>O(N^2)</math>.
Таким образом, суммарная сложность алгоритма составляет <math>O(N^4)</math> сравнений, и <math>O(N^3)</math> сложений и умножений.

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

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

Аналитически информационный граф данного алгоритма можно описать следующим образом:

1)Последовательно идущие макроярусы вычисления параметров текущей итерации и вращения Якоби с этими параметрами.
Число данных ярусов варьируется в зависимости от входных данных, но порядок составляет <math>O(n^2)</math>.

2)Вычисление параметров текущей итерации содержит конечное число операций умножения, сложения и вычисления квадратного корня.

3)Макроярус вращения Якоби содержит вычисление <math>2n+2</math> элементов матрицы и <math>2n-2</math> операций присваивания. На данном ярусе ширина графа достигает максимального значения. Вначале вычисляются значения в строках <math>j</math> и <math>k</math> (это соответствует умножению матрицы <math>R^T</math> на матрицу <math>A</math>). Далее, в силу того, что при умножении результата на матрицу <math>A</math> изменяются только столбцы <math>j</math> и <math>k</math> и итоговая матрица симметрична, можно не пересчитывать значения в столбцах, а получить их простым присваиванием по формуле: <math>a_{pk}=a_{kp}</math>, <math>a_{pj}=a_{jp}</math>, <math>p \neq k,j</math>. Для элементов <math>a_{jj}</math> и <math>a_{kk}</math> необходимо произвести вычисления, аналогичные вычислениям для элементов строк.

Визуальное представление графа алгоритма представлено на схемах ниже:

[[file:SI.jpg|thumb|center|1400px|Рисунок 1. Граф алгоритма на макроуровне. Rarams - вычисление параметров, Rotate - получение <math>A_{i+1}</math> из <math>A_{i}</math>.]]

[[file:exec_params.jpg|thumb|center|1400px|Рисунок 2. Структура блока Params.]]

[[file:ROT1.png|thumb|center|1400px|Рисунок 3. Структура блока Rotate.]]

=== Ресурс параллелизма алгоритма ===
Как видно из представления алгоритма в ярусно-параллельной форме ([[#Информационный граф| п.1.7]]), максимальная ширина ярусов составляет <math>2n</math> вершин.
Для выполнения данного алгоритма в параллельном варианте следует выполнить <math>O(\frac{n(n+1)}{2})</math> итераций.
Рассмотрим отдельную итерацию с точки зрения ярусно-параллельной формы алгоритма.

1)Выполнение 8 ярусов с конечным числом операций сложения, умножения, взятия квадратного корня и нахождения знака.

2)Выполнение 2 ярусов вычисления элементов в изменяемых строках и столбцах.

На данных двух ярусах осуществляется <math>4n</math> умножений и <math>2n</math> сложений. Данный вид параллелизма относится к координатному. Таким образом, при наличии бесконечного числа процессоров, итоговая сложность алгоритма составляет <math>O(\frac{n(n+1)}{2})</math>.

Кроме вышеизложенного, отметим следующую особенность алгоритма.
Пусть вращение <math>J_1</math> изменяет строки и столбцы с номерами <math>j_1</math> и <math>k_1</math>, а вращение <math>J_2</math> изменяет строки и столбцы с номерами <math>j_2</math> и <math>k_2</math>, и при этом выполнено:

<math>j_1 \neq j_2, k_2</math>

<math>k_1 \neq j_2, k_2</math>

Тогда вращения <math>J_1</math> и <math>J_2</math> перестановочны, и их можно выполнять параллельно.
Учитывая перебор обнуляемых элементов поочередно, данная ситуация достаточно редка. Она не изменяет итоговую сложность алгоритма, но уменьшает высоту ЯПФ на <math>O(N)</math>, а ширину ЯПФ напротив, увеличивает до <math>4n</math>. Таким образом, итоговый алгоритм следует отнести к алгоритмам с шириной ЯПФ <math>O(N)</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': плотная матрица <math>A</math> (элементы <math>a_{ij}</math>); при этом <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>..

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы).
Конкретный вариант хранения данных зависит от реализации. В качестве примеров можно привести хранение в одномерном массиве длины <math>\frac{n (n + 1)}{2}</math> по строкам своей нижней части, хранение в виде так называемого ступенчатого массива (такой вариант двумерного массива, в котором каждая строка имеет свой размер).

'''Выходные данные''': вектор собственных значений <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>) длины <math>n</math>.

=== Свойства алгоритма ===
Параллельная сложность выполнения алгоритма составляет <math>O(\frac{n(n+1)}{2}).</math>
Последовательная сложность выполнения алгоритма составляет <math>O(\frac{n^2(n+1)}{2}).</math>
Таким образом, соотношение сложностей является линейным.
Более того, и вычислительная мощность данного алгоритма линейна.

В алгоритме используется примерно в два раза больше операций умножения, чем сложения.
Отдельно стоит рассмотреть вопрос хранения матрицы <math>A</math> в процессе работы алгоритма. Хранение лишь нижней или верхней части матрицы в виде одномерного массива возможно; более того, хранение в таком виде обеспечивает экономию памяти в <math>2</math> раза и защищает от ассиметричности матрицы в результате накопления математических ошибок. Однако, вычисление индексов <math>i</math> и <math>j</math> элементов <math>a_{ij}</math>, соответствующих данному номеру <math>k</math> вообще говоря требует отдельного цикла, что создает дополнительную нагрузку на процессор.

Кроме того, следует отметить следующие особенности алгоритма:

1)Несмотря на то, что выбор наибольшего наддиагонального элемента, как кандидата на обнуление, кажется оптимальным, на самом деле он таковым не является. При таком выборе элемента, на каждой итерации необходимо находить текущий наибольший элемент в матрице, что требует дополнительных <math>\frac{n*(n-1)}{2}</math> операций сравнения и приводит к увеличению сложности алгоритма до <math>O(n^4)</math>. Вместо этого рекомендуется перебирать по очереди все наддиагональные элементы, большие заданного параметра. В большинстве случаев от <math>4</math> до <math>8</math> полных проходов достаточно для приближения исходной матрицы к диагональной.

2)Если при выборе в качестве обнуляемого элемента <math>a_{ij}</math> элементы <math>a_{ii} = a_{jj}</math>, то, как видно из формул в пунктах выше, матрицы поворота вырождаются в единичные и матрица на данной итерации не изменяется. Это еще один довод в пользу отказа от выбора наибольшего элемента, т.к. в данном случае произойдет зацикливание алгоритма.

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

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

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

==== Локальность реализации алгоритма ====

===== Структура обращений в память и качественная оценка локальности =====

===== Количественная оценка локальности =====

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

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

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

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

Исследование проводилось на 1U сервере со следующими характеристиками:
* 2 x Intel® Xeon® Processor E5-2697 v2;
* 128GB RAM;

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:
* число процессоров [1 : 48] с шагом 1
* размерность матрицы [400:1600] с шагом 200

Использовался компилятор g++ версии 5.4.0 со следующими флагами: -O2, -fopenmp, -std=c++11.
Флаг -O2 является опциональным, и означает уровень оптимизации кода при компиляции. Все прочие флаги строго обязательны при компиляции, т.к. в коде используются функции из стандарта С++11.

[[file:parallel11.jpg|thumb|center|700px|Рисунок 2. Изменение производительности в зависимости от числа процессоров и размерности матрицы.]]

Чтобы продемонстрировать важное свойство алгоритма, приведем так же график производительности в зависимости от числа процессов при размере матрицы 1600*1600

[[file:parallel1600.jpg|thumb|center|700px|Рисунок 2. Изменение производительности в зависимости от числа процессоров при размере матрицы 1600х1600.]]

За <math>1</math> принята производительность при одном процессе.
Как видно, производительность резко увеличивается при добавлении числа потоков в начале и снижается при дальнейшем добавлении.
Это связано с тем, что в одном потоке совершается малое количество арифметических операций. После выполнения операций совершается запись в массив полученных значений, в результате чего возникает конфликт потоков.
Поэтому наиболее оптимальное число потоков <math>8-16</math>, что говорит о слабой масштабируемости данного алгоритма.

[http://pastebin.com/yUyh1ziL Параллельная реализация на языке C++]

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

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

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

1)Библиотека [https://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE] содержит последовательную реализацию алгоритма.

2)В цифровой библиотеке ieee.org приводится [http://ieeexplore.ieee.org/document/6310877/ аннотация] статьи 2012 года, в которой авторы описывают реализацию данного алгоритма на CUDA.

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

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-11-21T12:42:15Z

Пронин Андрей: /* Ресурс параллелизма алгоритма */

{{algorithm
| name = Метод Якоби вычисления собственных значений симметричной матрицы ЗП
| serial_complexity = <math>O(n^3)</math>
| pf_height = <math>O(n^2)</math>
| pf_width = <math>2n</math>
| input_data = <math>n^2</math>
| output_data = <math>n</math>
}}

Авторы: [[Участник:Зиновьев Владимир|Зиновьев В.С.]] (написание кода, информационный граф, общее и мат описание алгоритма), [[Участник:Пронин Андрей|Пронин А.М.]] (написание кода, информационный граф, вычислительное ядро алгоритма, макроструктура алгоритма). В остальные разделы статьи вклад равноценный.

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

=== Общее описание алгоритма ===
Задача нахождения собственных значений и собственных векторов матриц(СЗВМ) является одной из основных задач для многих разделов физики. <ref>Чечин Г.М., Зехцер М.Ю. Собственные значения и собственные векторы матриц</ref> С такой вычислительной проблемой приходится сталкиваться, например, при исследовании собственных колебаний различных механических систем, колебательных и электронных спектров молекул и кристаллов. Совершенно принципиальное значение эта проблема приобрела после создания в тридцатых годах прошлого века квантовой механики, которая стала базовой дисциплиной исследования микромира.Кроме того, данная проблема важна в теории автоматического управления, как инструмент исследования устойчивости линейных систем.

Метод Якоби приводит симметричную действительную матрицу к диагональной форме с помощью некоторой (в принципе, бесконечной) последовательности плоских вращений в разных плоскостях исходного n-мерного векторного пространства. Метод Якоби состоит из некоторой последовательности шагов, на каждом из которых обнуляется один из внедиагональных элементов (обычно наибольший по модулю), в результате чего старая матрица <math>A_{i}</math> преобразуется в некоторую новую матрицу <math>A_{i+1}</math>. Делается это с помощью преобразования подобия, использующего матрицу плоского вращения <math>J_{i}</math> (подробное описание матрицы плоского вращения приведено ниже в разделе "[[#Математическое описание алгоритма|Математическое описание алгоритма]]"), которая изменяет лишь две координаты <math>n</math>-мерных векторов, а именно, координаты с номерами <math>j</math> и <math>k</math>. При таком шаге матрица <math>A_{i+1}</math> отличается от матрицы <math>A_{i}</math> лишь элементами двух строк с номерами <math>j</math>, <math>k</math> и двух столбцов с теми же номерами (<math>j</math> и <math>k</math>). Все же другие элементы матрицы <math>A</math> остаются неизменными. Число шагов, за которое матрица <math>A</math> приводится таким способом к диагональной форме, в общем случае является бесконечным. (это свойство метода Якоби более подробно рассмотрено в разделе "[[#Свойства алгоритма|Свойства алгоритма]]") В результате метод Якоби представляет собой некоторый бесконечный итерационный процесс, на каждом шаге которого преобразующаяся матрица становится всё более и более близкой к диагональной форме (в смысле уменьшения суммы квадратов всех своих внедиагональных элементов). На практике обычно выбирается заранее заданная погрешность <math>\varepsilon</math> и процесс приведения исходной матрицы к диагональному виду прекращается, когда наибольший по модулю внедиагональный элемент матрицы становится меньше <math>\varepsilon</math>. Таким образом, применяя на практике метод Якоби, мы приводим исходную матрицу к диагональной форме с точностью до некоторой вычислительной погрешности <math>\varepsilon</math> в результате конечного числа шагов. Повышение этой точности требует увеличения числа шагов метода Якоби. В конечном итоге у полученной в результате этого процесса матрицы на диагонали будут находиться все собственные значения (с определённой погрешностью) исходной симметрической матрицы.

==== Симметричность матрицы ====

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

=== Математическое описание алгоритма ===
Пусть <math>A = A_0</math> — симметричная матрица. В методе Якоби для <math>A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,...</math>, которая в конечном счёте сходится к диагональной матрице, у которой диагональными элементами являются все собственные значения матрицы <math>A</math>. Матрица <math>A_{i}</math> получается из матрицы <math>A_{i-1}</math> по формуле
<math>A_{i}=J^{T}_iA_{i-1}J_i ,</math>
где <math>J_i</math> - ортогональная матрица, называемая ''вращением Якоби''. Таким образом,
<math>A_{m}=J^{T}_{m-1}A_{m-1}J_{m-1}</math>
<math>=J^{T}_{m-1}J^{T}_{m-2}A_{m-2}J_{m-2}J_{m-1}</math>
<math>=J^{T}_{m-1}...J^{T}_{0}A_{0}J_{0}...J_{m-1}</math>
<math>=J^{T}AJ</math>
При подходящем выборе вращений <math>J_i</math> матрица <math>A_m</math> для больших <math>m</math> будет близкой к диагональной матрице <math>\Lambda</math> <ref>Дж. Деммель, Вычислительная линейная алгебра. Теория и приложения. Перевод Х.Д.Икрамов</ref>. Таким образом, <math>\Lambda \approx J^{T}AJ</math> или <math>J\Lambda J^{T} \approx A</math>, следовательно, столбцы матрицы <math>J</math> являются собственными значениями матрицы <math>A</math>.
Матрица <math>J_i</math> выбирается таким образом, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}=J^{T}_{i}A_{i}J_{i}</math>:

                                                                            
<math>j</math>
                       
<math>k</math>

<math>
J_i = R(j,k,\theta) \equiv
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & -\sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Угол вращения <math>\theta</math> выбирается так, чтобы элементы <math>(j,k)</math> и <math>(k,j)</math> в <math>A_{i+1}</math> стали нулями. Для того, чтобы найти <math>\theta</math>, составляется уравнение:
:<math>
\begin{bmatrix}
a^{i+1}_{jj}&a^{i+1}_{jk}\\
a^{i+1}_{kj}&a^{i+1}_{kk}\\
\end{bmatrix} =
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix}^T
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix}
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix} =
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} ,
</math>
где <math>\lambda_1</math> и <math>\lambda_2</math> - собственные значения подматрицы
:<math>
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix} .
</math>
Пусть <math>c = \cos(\theta)</math> и <math>s = sin(\theta)</math>, <math>a^{i}_{lk} = a_{lk}</math>. Тогда из предыдущего равенства получаем
:<math>
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} =
\begin{bmatrix}
a_{jj}c^2 + a_{kk}s^2+2sca_{jk}&sc(a_{kk} - a_{jj}) + a_{jk}(c^2-s^2)\\
sc(a_{kk} - a_{jj}) + a_{jk}(c^2-s^2)&a_{jj}s^2 + a_{kk}c^2-2sca_{jk}\\
\end{bmatrix}
.
</math>
Приравнивая внедиагональный элемент к нулю, получаем
:<math>
\frac{a_{jj} - a_{kk}}{2a_{jk}} = \frac{c^2-s^2}{2sc} = ctg(2\theta) = r.
</math>
Пусть <math>tg(\theta) = t = \frac{s}{c}</math> . Заметим, что выполняется квадратное уравнение <math>t^2 + 2rt - 1 = 0</math> . Решая уравнение, получаем <math>t = \frac{sign(r)}{|r| + \sqrt{1+r^2}}</math> . Следовательно <math>c = \frac{1}{\sqrt{1+t^2}}</math>, <math>s = ct</math>

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

Вычислительным ядром отдельной итерации является вычисление элементов матрицы <math>A</math> при применении поворота Якоби. Конкретно, изменяются <math>2</math> строки и <math>2</math> столбца, что означает изменение <math>4n</math> элементов. Отметим, что вычисление нового значения одного элемента требует <math>2</math> операции умножения и одну операцию сложения, что позволяет утверждать, что основной вклад в вычислительное ядро вносят умножения.
Однако в целом, следует отметить, что число операций в алгоритме во многом определяется общим числом итераций, а оно квадратично, в то время как отдельная итерация имеет линейную сложность. Более того, так как алгоритм является итерационным и останавливается при достижении некоторой точности, число итераций может изменяться в зависимости от желаемой точности.

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

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

1) Блок вычисления параметров вращения на текущей итерации (выбор обнуляемого элемента и расчет угла вращения).

2)Блок, реализующий непосредственно вращение Якоби.

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

1)Находится максимальный наддиагональный элемент <math>a_{jk}</math> матрицы <math>A</math>.

2)Вычисляются параметры вращения Якоби:
<math>\tau= \frac{(a_{jj}-a_{kk})}{2a_{jk}}</math>
<math>t=sign(\tau)(|\tau|+\sqrt{1+\tau^2})</math>
<math>c= \frac{1}{1+\sqrt{1+\tau^2}}</math>
<math>s=c*t</math>

3)К текущей матрице <math>A</math> применяются вращения с вычисленными параметрами:
<math>A=R^T(j,k,\theta)*A*R(j,k,\theta)</math>
Стоит отметить, что вычисленные на предыдущем шаге <math>c</math> и <math>s</math> есть <math>\cos {\theta}</math> и <math>\sin {\theta}</math> соответственно.

4)Если матрица <math>A</math> не достаточно близка к диагональной, происходит переход к шагу 1.

Вообще говоря, несмотря на то, что поворот, обеспечивающий обнуление наибольшего внедиагонального элемента, обеспечивает схождение метода за наименьшее число итераций, поиск данного наибольшего элемента добавляет порядка <math>n^2</math> операций сравнения, а возможно и присваивания на каждой итерации.
Поэтому с вычислительной точки зрения выгоднее не выбирать наибольший элемент, а по очереди перебирать все наддиагональные элементы, большие заданного порога.

В последующих разделах рассматривается именно такой вариант алгоритма.

=== Последовательная сложность алгоритма ===
Сначала оценим сложность одной итерации:

1)Так как элементы матрицы никак не упорядоченны, поиск наибольшего элемента линейно зависит от числа элементов над диагональю.
Конкретнее, на данном шаге происходит <math>\frac{n*(n-1)}{2} -1</math> сравнение.

2)<math>3</math> операции деления, <math>2</math> операции взятия корня, <math>4</math> операции умножения и <math>4</math> операции сложения/вычитания.

3)<math>4n</math> операций умножения и <math>2n</math> операций сложения.

4)операция сравнения

В худшем случае количество итераций в теории равняется числу наддиагональных элементов, т.е. <math>\frac{n*(n-1)}{2}</math>
На практике же из-за накопления ошибок вычисления, а так же восстановления уже обнуленных элементов при некоторых вращениях, число операций возрастает.
Вместе с тем, можно утверждать, что порядок числа итераций будет <math>O(N^2)</math>.
Таким образом, суммарная сложность алгоритма составляет <math>O(N^4)</math> сравнений, и <math>O(N^3)</math> сложений и умножений.

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

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

Аналитически информационный граф данного алгоритма можно описать следующим образом:

1)Последовательно идущие макроярусы вычисления параметров текущей итерации и вращения Якоби с этими параметрами.
Число данных ярусов варьируется в зависимости от входных данных, но порядок составляет <math>O(n^2)</math>.

2)Вычисление параметров текущей итерации содержит конечное число операций умножения, сложения и вычисления квадратного корня.

3)Макроярус вращения Якоби содержит вычисление <math>2n+2</math> элементов матрицы и <math>2n-2</math> операций присваивания. На данном ярусе ширина графа достигает максимального значения. Вначале вычисляются значения в строках <math>j</math> и <math>k</math> (это соответствует умножению матрицы <math>R^T</math> на матрицу <math>A</math>). Далее, в силу того, что при умножении результата на матрицу <math>A</math> изменяются только столбцы <math>j</math> и <math>k</math> и итоговая матрица симметрична, можно не пересчитывать значения в столбцах, а получить их простым присваиванием по формуле: <math>a_{pk}=a_{kp}</math>, <math>a_{pj}=a_{jp}</math>, <math>p \neq k,j</math>. Для элементов <math>a_{jj}</math> и <math>a_{kk}</math> необходимо произвести вычисления, аналогичные вычислениям для элементов строк.

Визуальное представление графа алгоритма представлено на схемах ниже:

[[file:SI.jpg|thumb|center|1400px|Рисунок 1. Граф алгоритма на макроуровне. Rarams - вычисление параметров, Rotate - получение <math>A_{i+1}</math> из <math>A_{i}</math>.]]

[[file:exec_params.jpg|thumb|center|1400px|Рисунок 2. Структура блока Params.]]

[[file:ROT1.png|thumb|center|1400px|Рисунок 3. Структура блока Rotate.]]

=== Ресурс параллелизма алгоритма ===
Как видно из представления алгоритма в ярусно-параллельной форме ([[#Информационный граф| п.1.7]]), максимальная ширина ярусов составляет <math>2n</math> вершин.
Для выполнения данного алгоритма в параллельном варианте следует выполнить <math>O(\frac{n(n+1)}{2})</math> итераций.
Рассмотрим отдельную итерацию с точки зрения ярусно-параллельной формы алгоритма.

1)Выполнение 8 ярусов с конечным числом операций сложения, умножения, взятия квадратного корня и нахождения знака.

2)Выполнение 2 ярусов вычисления элементов в изменяемых строках и столбцах.

На данных двух ярусах осуществляется <math>4n</math> умножений и <math>2n</math> сложений. Данный вид параллелизма относится к координатному. Так как каждая последующая итерация алгоритма зависит от предыдущей, их выполнение распараллелить не представляется возможным. Таким образом, при наличии бесконечного числа процессоров, итоговая сложность алгоритма составляет <math>O(\frac{n(n+1)}{2})</math>.

Кроме вышеизложенного, отметим следующую особенность алгоритма.
Пусть вращение <math>J_1</math> изменяет строки и столбцы с номерами <math>j_1</math> и <math>k_1</math>, а вращение <math>J_2</math> изменяет строки и столбцы с номерами <math>j_2</math> и <math>k_2</math>, и при этом выполнено:

<math>j_1 \neq j_2, k_2</math>

<math>k_1 \neq j_2, k_2</math>

Тогда вращения J1 и J2 перестановочны, и их можно выполнять параллельно.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': плотная матрица <math>A</math> (элементы <math>a_{ij}</math>); при этом <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>..

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы).
Конкретный вариант хранения данных зависит от реализации. В качестве примеров можно привести хранение в одномерном массиве длины <math>\frac{n (n + 1)}{2}</math> по строкам своей нижней части, хранение в виде так называемого ступенчатого массива (такой вариант двумерного массива, в котором каждая строка имеет свой размер).

'''Выходные данные''': вектор собственных значений <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>) длины <math>n</math>.

=== Свойства алгоритма ===
Параллельная сложность выполнения алгоритма составляет <math>O(\frac{n(n+1)}{2}).</math>
Последовательная сложность выполнения алгоритма составляет <math>O(\frac{n^2(n+1)}{2}).</math>
Таким образом, соотношение сложностей является линейным.
Более того, и вычислительная мощность данного алгоритма линейна.

В алгоритме используется примерно в два раза больше операций умножения, чем сложения.
Отдельно стоит рассмотреть вопрос хранения матрицы <math>A</math> в процессе работы алгоритма. Хранение лишь нижней или верхней части матрицы в виде одномерного массива возможно; более того, хранение в таком виде обеспечивает экономию памяти в <math>2</math> раза и защищает от ассиметричности матрицы в результате накопления математических ошибок. Однако, вычисление индексов <math>i</math> и <math>j</math> элементов <math>a_{ij}</math>, соответствующих данному номеру <math>k</math> вообще говоря требует отдельного цикла, что создает дополнительную нагрузку на процессор.

Кроме того, следует отметить следующие особенности алгоритма:

1)Несмотря на то, что выбор наибольшего наддиагонального элемента, как кандидата на обнуление, кажется оптимальным, на самом деле он таковым не является. При таком выборе элемента, на каждой итерации необходимо находить текущий наибольший элемент в матрице, что требует дополнительных <math>\frac{n*(n-1)}{2}</math> операций сравнения и приводит к увеличению сложности алгоритма до <math>O(n^4)</math>. Вместо этого рекомендуется перебирать по очереди все наддиагональные элементы, большие заданного параметра. В большинстве случаев от <math>4</math> до <math>8</math> полных проходов достаточно для приближения исходной матрицы к диагональной.

2)Если при выборе в качестве обнуляемого элемента <math>a_{ij}</math> элементы <math>a_{ii} = a_{jj}</math>, то, как видно из формул в пунктах выше, матрицы поворота вырождаются в единичные и матрица на данной итерации не изменяется. Это еще один довод в пользу отказа от выбора наибольшего элемента, т.к. в данном случае произойдет зацикливание алгоритма.

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

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

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

==== Локальность реализации алгоритма ====

===== Структура обращений в память и качественная оценка локальности =====

===== Количественная оценка локальности =====

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

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

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

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

Исследование проводилось на 1U сервере со следующими характеристиками:
* 2 x Intel® Xeon® Processor E5-2697 v2;
* 128GB RAM;

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:
* число процессоров [1 : 48] с шагом 1
* размерность матрицы [400:1600] с шагом 200

Использовался компилятор g++ версии 5.4.0 со следующими флагами: -O2, -fopenmp, -std=c++11.
Флаг -O2 является опциональным, и означает уровень оптимизации кода при компиляции. Все прочие флаги строго обязательны при компиляции, т.к. в коде используются функции из стандарта С++11.

[[file:parallel11.jpg|thumb|center|700px|Рисунок 2. Изменение производительности в зависимости от числа процессоров и размерности матрицы.]]

Чтобы продемонстрировать важное свойство алгоритма, приведем так же график производительности в зависимости от числа процессов при размере матрицы 1600*1600

[[file:parallel1600.jpg|thumb|center|700px|Рисунок 2. Изменение производительности в зависимости от числа процессоров при размере матрицы 1600х1600.]]

За <math>1</math> принята производительность при одном процессе.
Как видно, производительность резко увеличивается при добавлении числа потоков в начале и снижается при дальнейшем добавлении.
Это связано с тем, что в одном потоке совершается малое количество арифметических операций. После выполнения операций совершается запись в массив полученных значений, в результате чего возникает конфликт потоков.
Поэтому наиболее оптимальное число потоков <math>8-16</math>, что говорит о слабой масштабируемости данного алгоритма.

[http://pastebin.com/yUyh1ziL Параллельная реализация на языке C++]

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

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

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

1)Библиотека [https://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE] содержит последовательную реализацию алгоритма.

2)В цифровой библиотеке ieee.org приводится [http://ieeexplore.ieee.org/document/6310877/ аннотация] статьи 2012 года, в которой авторы описывают реализацию данного алгоритма на CUDA.

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

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-11-21T12:39:12Z

Пронин Андрей: /* Ресурс параллелизма алгоритма */

{{algorithm
| name = Метод Якоби вычисления собственных значений симметричной матрицы ЗП
| serial_complexity = <math>O(n^3)</math>
| pf_height = <math>O(n^2)</math>
| pf_width = <math>2n</math>
| input_data = <math>n^2</math>
| output_data = <math>n</math>
}}

Авторы: [[Участник:Зиновьев Владимир|Зиновьев В.С.]] (написание кода, информационный граф, общее и мат описание алгоритма), [[Участник:Пронин Андрей|Пронин А.М.]] (написание кода, информационный граф, вычислительное ядро алгоритма, макроструктура алгоритма). В остальные разделы статьи вклад равноценный.

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

=== Общее описание алгоритма ===
Задача нахождения собственных значений и собственных векторов матриц(СЗВМ) является одной из основных задач для многих разделов физики. <ref>Чечин Г.М., Зехцер М.Ю. Собственные значения и собственные векторы матриц</ref> С такой вычислительной проблемой приходится сталкиваться, например, при исследовании собственных колебаний различных механических систем, колебательных и электронных спектров молекул и кристаллов. Совершенно принципиальное значение эта проблема приобрела после создания в тридцатых годах прошлого века квантовой механики, которая стала базовой дисциплиной исследования микромира.Кроме того, данная проблема важна в теории автоматического управления, как инструмент исследования устойчивости линейных систем.

Метод Якоби приводит симметричную действительную матрицу к диагональной форме с помощью некоторой (в принципе, бесконечной) последовательности плоских вращений в разных плоскостях исходного n-мерного векторного пространства. Метод Якоби состоит из некоторой последовательности шагов, на каждом из которых обнуляется один из внедиагональных элементов (обычно наибольший по модулю), в результате чего старая матрица <math>A_{i}</math> преобразуется в некоторую новую матрицу <math>A_{i+1}</math>. Делается это с помощью преобразования подобия, использующего матрицу плоского вращения <math>J_{i}</math> (подробное описание матрицы плоского вращения приведено ниже в разделе "[[#Математическое описание алгоритма|Математическое описание алгоритма]]"), которая изменяет лишь две координаты <math>n</math>-мерных векторов, а именно, координаты с номерами <math>j</math> и <math>k</math>. При таком шаге матрица <math>A_{i+1}</math> отличается от матрицы <math>A_{i}</math> лишь элементами двух строк с номерами <math>j</math>, <math>k</math> и двух столбцов с теми же номерами (<math>j</math> и <math>k</math>). Все же другие элементы матрицы <math>A</math> остаются неизменными. Число шагов, за которое матрица <math>A</math> приводится таким способом к диагональной форме, в общем случае является бесконечным. (это свойство метода Якоби более подробно рассмотрено в разделе "[[#Свойства алгоритма|Свойства алгоритма]]") В результате метод Якоби представляет собой некоторый бесконечный итерационный процесс, на каждом шаге которого преобразующаяся матрица становится всё более и более близкой к диагональной форме (в смысле уменьшения суммы квадратов всех своих внедиагональных элементов). На практике обычно выбирается заранее заданная погрешность <math>\varepsilon</math> и процесс приведения исходной матрицы к диагональному виду прекращается, когда наибольший по модулю внедиагональный элемент матрицы становится меньше <math>\varepsilon</math>. Таким образом, применяя на практике метод Якоби, мы приводим исходную матрицу к диагональной форме с точностью до некоторой вычислительной погрешности <math>\varepsilon</math> в результате конечного числа шагов. Повышение этой точности требует увеличения числа шагов метода Якоби. В конечном итоге у полученной в результате этого процесса матрицы на диагонали будут находиться все собственные значения (с определённой погрешностью) исходной симметрической матрицы.

==== Симметричность матрицы ====

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

=== Математическое описание алгоритма ===
Пусть <math>A = A_0</math> — симметричная матрица. В методе Якоби для <math>A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,...</math>, которая в конечном счёте сходится к диагональной матрице, у которой диагональными элементами являются все собственные значения матрицы <math>A</math>. Матрица <math>A_{i}</math> получается из матрицы <math>A_{i-1}</math> по формуле
<math>A_{i}=J^{T}_iA_{i-1}J_i ,</math>
где <math>J_i</math> - ортогональная матрица, называемая ''вращением Якоби''. Таким образом,
<math>A_{m}=J^{T}_{m-1}A_{m-1}J_{m-1}</math>
<math>=J^{T}_{m-1}J^{T}_{m-2}A_{m-2}J_{m-2}J_{m-1}</math>
<math>=J^{T}_{m-1}...J^{T}_{0}A_{0}J_{0}...J_{m-1}</math>
<math>=J^{T}AJ</math>
При подходящем выборе вращений <math>J_i</math> матрица <math>A_m</math> для больших <math>m</math> будет близкой к диагональной матрице <math>\Lambda</math> <ref>Дж. Деммель, Вычислительная линейная алгебра. Теория и приложения. Перевод Х.Д.Икрамов</ref>. Таким образом, <math>\Lambda \approx J^{T}AJ</math> или <math>J\Lambda J^{T} \approx A</math>, следовательно, столбцы матрицы <math>J</math> являются собственными значениями матрицы <math>A</math>.
Матрица <math>J_i</math> выбирается таким образом, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}=J^{T}_{i}A_{i}J_{i}</math>:

                                                                            
<math>j</math>
                       
<math>k</math>

<math>
J_i = R(j,k,\theta) \equiv
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & -\sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Угол вращения <math>\theta</math> выбирается так, чтобы элементы <math>(j,k)</math> и <math>(k,j)</math> в <math>A_{i+1}</math> стали нулями. Для того, чтобы найти <math>\theta</math>, составляется уравнение:
:<math>
\begin{bmatrix}
a^{i+1}_{jj}&a^{i+1}_{jk}\\
a^{i+1}_{kj}&a^{i+1}_{kk}\\
\end{bmatrix} =
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix}^T
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix}
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix} =
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} ,
</math>
где <math>\lambda_1</math> и <math>\lambda_2</math> - собственные значения подматрицы
:<math>
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix} .
</math>
Пусть <math>c = \cos(\theta)</math> и <math>s = sin(\theta)</math>, <math>a^{i}_{lk} = a_{lk}</math>. Тогда из предыдущего равенства получаем
:<math>
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} =
\begin{bmatrix}
a_{jj}c^2 + a_{kk}s^2+2sca_{jk}&sc(a_{kk} - a_{jj}) + a_{jk}(c^2-s^2)\\
sc(a_{kk} - a_{jj}) + a_{jk}(c^2-s^2)&a_{jj}s^2 + a_{kk}c^2-2sca_{jk}\\
\end{bmatrix}
.
</math>
Приравнивая внедиагональный элемент к нулю, получаем
:<math>
\frac{a_{jj} - a_{kk}}{2a_{jk}} = \frac{c^2-s^2}{2sc} = ctg(2\theta) = r.
</math>
Пусть <math>tg(\theta) = t = \frac{s}{c}</math> . Заметим, что выполняется квадратное уравнение <math>t^2 + 2rt - 1 = 0</math> . Решая уравнение, получаем <math>t = \frac{sign(r)}{|r| + \sqrt{1+r^2}}</math> . Следовательно <math>c = \frac{1}{\sqrt{1+t^2}}</math>, <math>s = ct</math>

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

Вычислительным ядром отдельной итерации является вычисление элементов матрицы <math>A</math> при применении поворота Якоби. Конкретно, изменяются <math>2</math> строки и <math>2</math> столбца, что означает изменение <math>4n</math> элементов. Отметим, что вычисление нового значения одного элемента требует <math>2</math> операции умножения и одну операцию сложения, что позволяет утверждать, что основной вклад в вычислительное ядро вносят умножения.
Однако в целом, следует отметить, что число операций в алгоритме во многом определяется общим числом итераций, а оно квадратично, в то время как отдельная итерация имеет линейную сложность. Более того, так как алгоритм является итерационным и останавливается при достижении некоторой точности, число итераций может изменяться в зависимости от желаемой точности.

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

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

1) Блок вычисления параметров вращения на текущей итерации (выбор обнуляемого элемента и расчет угла вращения).

2)Блок, реализующий непосредственно вращение Якоби.

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

1)Находится максимальный наддиагональный элемент <math>a_{jk}</math> матрицы <math>A</math>.

2)Вычисляются параметры вращения Якоби:
<math>\tau= \frac{(a_{jj}-a_{kk})}{2a_{jk}}</math>
<math>t=sign(\tau)(|\tau|+\sqrt{1+\tau^2})</math>
<math>c= \frac{1}{1+\sqrt{1+\tau^2}}</math>
<math>s=c*t</math>

3)К текущей матрице <math>A</math> применяются вращения с вычисленными параметрами:
<math>A=R^T(j,k,\theta)*A*R(j,k,\theta)</math>
Стоит отметить, что вычисленные на предыдущем шаге <math>c</math> и <math>s</math> есть <math>\cos {\theta}</math> и <math>\sin {\theta}</math> соответственно.

4)Если матрица <math>A</math> не достаточно близка к диагональной, происходит переход к шагу 1.

Вообще говоря, несмотря на то, что поворот, обеспечивающий обнуление наибольшего внедиагонального элемента, обеспечивает схождение метода за наименьшее число итераций, поиск данного наибольшего элемента добавляет порядка <math>n^2</math> операций сравнения, а возможно и присваивания на каждой итерации.
Поэтому с вычислительной точки зрения выгоднее не выбирать наибольший элемент, а по очереди перебирать все наддиагональные элементы, большие заданного порога.

В последующих разделах рассматривается именно такой вариант алгоритма.

=== Последовательная сложность алгоритма ===
Сначала оценим сложность одной итерации:

1)Так как элементы матрицы никак не упорядоченны, поиск наибольшего элемента линейно зависит от числа элементов над диагональю.
Конкретнее, на данном шаге происходит <math>\frac{n*(n-1)}{2} -1</math> сравнение.

2)<math>3</math> операции деления, <math>2</math> операции взятия корня, <math>4</math> операции умножения и <math>4</math> операции сложения/вычитания.

3)<math>4n</math> операций умножения и <math>2n</math> операций сложения.

4)операция сравнения

В худшем случае количество итераций в теории равняется числу наддиагональных элементов, т.е. <math>\frac{n*(n-1)}{2}</math>
На практике же из-за накопления ошибок вычисления, а так же восстановления уже обнуленных элементов при некоторых вращениях, число операций возрастает.
Вместе с тем, можно утверждать, что порядок числа итераций будет <math>O(N^2)</math>.
Таким образом, суммарная сложность алгоритма составляет <math>O(N^4)</math> сравнений, и <math>O(N^3)</math> сложений и умножений.

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

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

Аналитически информационный граф данного алгоритма можно описать следующим образом:

1)Последовательно идущие макроярусы вычисления параметров текущей итерации и вращения Якоби с этими параметрами.
Число данных ярусов варьируется в зависимости от входных данных, но порядок составляет <math>O(n^2)</math>.

2)Вычисление параметров текущей итерации содержит конечное число операций умножения, сложения и вычисления квадратного корня.

3)Макроярус вращения Якоби содержит вычисление <math>2n+2</math> элементов матрицы и <math>2n-2</math> операций присваивания. На данном ярусе ширина графа достигает максимального значения. Вначале вычисляются значения в строках <math>j</math> и <math>k</math> (это соответствует умножению матрицы <math>R^T</math> на матрицу <math>A</math>). Далее, в силу того, что при умножении результата на матрицу <math>A</math> изменяются только столбцы <math>j</math> и <math>k</math> и итоговая матрица симметрична, можно не пересчитывать значения в столбцах, а получить их простым присваиванием по формуле: <math>a_{pk}=a_{kp}</math>, <math>a_{pj}=a_{jp}</math>, <math>p \neq k,j</math>. Для элементов <math>a_{jj}</math> и <math>a_{kk}</math> необходимо произвести вычисления, аналогичные вычислениям для элементов строк.

Визуальное представление графа алгоритма представлено на схемах ниже:

[[file:SI.jpg|thumb|center|1400px|Рисунок 1. Граф алгоритма на макроуровне. Rarams - вычисление параметров, Rotate - получение <math>A_{i+1}</math> из <math>A_{i}</math>.]]

[[file:exec_params.jpg|thumb|center|1400px|Рисунок 2. Структура блока Params.]]

[[file:ROT1.png|thumb|center|1400px|Рисунок 3. Структура блока Rotate.]]

=== Ресурс параллелизма алгоритма ===
Как видно из представления алгоритма в ярусно-параллельной форме ([[#Информационный граф| п.1.7]]), максимальная ширина ярусов составляет <math>2n</math> вершин.
Для выполнения данного алгоритма в параллельном варианте следует выполнить <math>O(\frac{n(n+1)}{2})</math> итераций.
Рассмотрим отдельную итерацию с точки зрения ярусно-параллельной формы алгоритма.

1)Выполнение 8 ярусов с конечным числом операций сложения, умножения, взятия квадратного корня и нахождения знака.

2)Выполнение 2 ярусов вычисления элементов в изменяемых строках и столбцах.

На данных двух ярусах осуществляется <math>4n</math> умножений и <math>2n</math> сложений. Данный вид параллелизма относится к координатному. Так как каждая последующая итерация алгоритма зависит от предыдущей, их выполнение распараллелить не представляется возможным. Таким образом, при наличии бесконечного числа процессоров, итоговая сложность алгоритма составляет <math>O(\frac{n(n+1)}{2})</math>.

Кроме вышеизложенного, отметим следующую особенность алгоритма.
Пусть вращение <math>J_1</math> изменяет строки и столбцы с номерами <math>j_1</math> и <math>k_1</math>, а вращение <math>J_2</math> изменяет строки и столбцы с номерами <math>j_2</math> и <math>k_2</math>, и при этом выполнено:

<math>j_1 \neq j_2, k_2</math>

<math>k_1 \neq j_2, k_2</math>

=== Входные и выходные данные алгоритма ===
'''Входные данные''': плотная матрица <math>A</math> (элементы <math>a_{ij}</math>); при этом <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>..

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы).
Конкретный вариант хранения данных зависит от реализации. В качестве примеров можно привести хранение в одномерном массиве длины <math>\frac{n (n + 1)}{2}</math> по строкам своей нижней части, хранение в виде так называемого ступенчатого массива (такой вариант двумерного массива, в котором каждая строка имеет свой размер).

'''Выходные данные''': вектор собственных значений <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>) длины <math>n</math>.

=== Свойства алгоритма ===
Параллельная сложность выполнения алгоритма составляет <math>O(\frac{n(n+1)}{2}).</math>
Последовательная сложность выполнения алгоритма составляет <math>O(\frac{n^2(n+1)}{2}).</math>
Таким образом, соотношение сложностей является линейным.
Более того, и вычислительная мощность данного алгоритма линейна.

В алгоритме используется примерно в два раза больше операций умножения, чем сложения.
Отдельно стоит рассмотреть вопрос хранения матрицы <math>A</math> в процессе работы алгоритма. Хранение лишь нижней или верхней части матрицы в виде одномерного массива возможно; более того, хранение в таком виде обеспечивает экономию памяти в <math>2</math> раза и защищает от ассиметричности матрицы в результате накопления математических ошибок. Однако, вычисление индексов <math>i</math> и <math>j</math> элементов <math>a_{ij}</math>, соответствующих данному номеру <math>k</math> вообще говоря требует отдельного цикла, что создает дополнительную нагрузку на процессор.

Кроме того, следует отметить следующие особенности алгоритма:

1)Несмотря на то, что выбор наибольшего наддиагонального элемента, как кандидата на обнуление, кажется оптимальным, на самом деле он таковым не является. При таком выборе элемента, на каждой итерации необходимо находить текущий наибольший элемент в матрице, что требует дополнительных <math>\frac{n*(n-1)}{2}</math> операций сравнения и приводит к увеличению сложности алгоритма до <math>O(n^4)</math>. Вместо этого рекомендуется перебирать по очереди все наддиагональные элементы, большие заданного параметра. В большинстве случаев от <math>4</math> до <math>8</math> полных проходов достаточно для приближения исходной матрицы к диагональной.

2)Если при выборе в качестве обнуляемого элемента <math>a_{ij}</math> элементы <math>a_{ii} = a_{jj}</math>, то, как видно из формул в пунктах выше, матрицы поворота вырождаются в единичные и матрица на данной итерации не изменяется. Это еще один довод в пользу отказа от выбора наибольшего элемента, т.к. в данном случае произойдет зацикливание алгоритма.

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

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

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

==== Локальность реализации алгоритма ====

===== Структура обращений в память и качественная оценка локальности =====

===== Количественная оценка локальности =====

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

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

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

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

Исследование проводилось на 1U сервере со следующими характеристиками:
* 2 x Intel® Xeon® Processor E5-2697 v2;
* 128GB RAM;

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:
* число процессоров [1 : 48] с шагом 1
* размерность матрицы [400:1600] с шагом 200

Использовался компилятор g++ версии 5.4.0 со следующими флагами: -O2, -fopenmp, -std=c++11.
Флаг -O2 является опциональным, и означает уровень оптимизации кода при компиляции. Все прочие флаги строго обязательны при компиляции, т.к. в коде используются функции из стандарта С++11.

[[file:parallel11.jpg|thumb|center|700px|Рисунок 2. Изменение производительности в зависимости от числа процессоров и размерности матрицы.]]

Чтобы продемонстрировать важное свойство алгоритма, приведем так же график производительности в зависимости от числа процессов при размере матрицы 1600*1600

[[file:parallel1600.jpg|thumb|center|700px|Рисунок 2. Изменение производительности в зависимости от числа процессоров при размере матрицы 1600х1600.]]

За <math>1</math> принята производительность при одном процессе.
Как видно, производительность резко увеличивается при добавлении числа потоков в начале и снижается при дальнейшем добавлении.
Это связано с тем, что в одном потоке совершается малое количество арифметических операций. После выполнения операций совершается запись в массив полученных значений, в результате чего возникает конфликт потоков.
Поэтому наиболее оптимальное число потоков <math>8-16</math>, что говорит о слабой масштабируемости данного алгоритма.

[http://pastebin.com/yUyh1ziL Параллельная реализация на языке C++]

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

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

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

1)Библиотека [https://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE] содержит последовательную реализацию алгоритма.

2)В цифровой библиотеке ieee.org приводится [http://ieeexplore.ieee.org/document/6310877/ аннотация] статьи 2012 года, в которой авторы описывают реализацию данного алгоритма на CUDA.

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

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-11-21T12:30:54Z

Пронин Андрей: /* Ресурс параллелизма алгоритма */

{{algorithm
| name = Метод Якоби вычисления собственных значений симметричной матрицы ЗП
| serial_complexity = <math>O(n^3)</math>
| pf_height = <math>O(n^2)</math>
| pf_width = <math>2n</math>
| input_data = <math>n^2</math>
| output_data = <math>n</math>
}}

Авторы: [[Участник:Зиновьев Владимир|Зиновьев В.С.]] (написание кода, информационный граф, общее и мат описание алгоритма), [[Участник:Пронин Андрей|Пронин А.М.]] (написание кода, информационный граф, вычислительное ядро алгоритма, макроструктура алгоритма). В остальные разделы статьи вклад равноценный.

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

=== Общее описание алгоритма ===
Задача нахождения собственных значений и собственных векторов матриц(СЗВМ) является одной из основных задач для многих разделов физики. <ref>Чечин Г.М., Зехцер М.Ю. Собственные значения и собственные векторы матриц</ref> С такой вычислительной проблемой приходится сталкиваться, например, при исследовании собственных колебаний различных механических систем, колебательных и электронных спектров молекул и кристаллов. Совершенно принципиальное значение эта проблема приобрела после создания в тридцатых годах прошлого века квантовой механики, которая стала базовой дисциплиной исследования микромира.Кроме того, данная проблема важна в теории автоматического управления, как инструмент исследования устойчивости линейных систем.

Метод Якоби приводит симметричную действительную матрицу к диагональной форме с помощью некоторой (в принципе, бесконечной) последовательности плоских вращений в разных плоскостях исходного n-мерного векторного пространства. Метод Якоби состоит из некоторой последовательности шагов, на каждом из которых обнуляется один из внедиагональных элементов (обычно наибольший по модулю), в результате чего старая матрица <math>A_{i}</math> преобразуется в некоторую новую матрицу <math>A_{i+1}</math>. Делается это с помощью преобразования подобия, использующего матрицу плоского вращения <math>J_{i}</math> (подробное описание матрицы плоского вращения приведено ниже в разделе "[[#Математическое описание алгоритма|Математическое описание алгоритма]]"), которая изменяет лишь две координаты <math>n</math>-мерных векторов, а именно, координаты с номерами <math>j</math> и <math>k</math>. При таком шаге матрица <math>A_{i+1}</math> отличается от матрицы <math>A_{i}</math> лишь элементами двух строк с номерами <math>j</math>, <math>k</math> и двух столбцов с теми же номерами (<math>j</math> и <math>k</math>). Все же другие элементы матрицы <math>A</math> остаются неизменными. Число шагов, за которое матрица <math>A</math> приводится таким способом к диагональной форме, в общем случае является бесконечным. (это свойство метода Якоби более подробно рассмотрено в разделе "[[#Свойства алгоритма|Свойства алгоритма]]") В результате метод Якоби представляет собой некоторый бесконечный итерационный процесс, на каждом шаге которого преобразующаяся матрица становится всё более и более близкой к диагональной форме (в смысле уменьшения суммы квадратов всех своих внедиагональных элементов). На практике обычно выбирается заранее заданная погрешность <math>\varepsilon</math> и процесс приведения исходной матрицы к диагональному виду прекращается, когда наибольший по модулю внедиагональный элемент матрицы становится меньше <math>\varepsilon</math>. Таким образом, применяя на практике метод Якоби, мы приводим исходную матрицу к диагональной форме с точностью до некоторой вычислительной погрешности <math>\varepsilon</math> в результате конечного числа шагов. Повышение этой точности требует увеличения числа шагов метода Якоби. В конечном итоге у полученной в результате этого процесса матрицы на диагонали будут находиться все собственные значения (с определённой погрешностью) исходной симметрической матрицы.

==== Симметричность матрицы ====

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

=== Математическое описание алгоритма ===
Пусть <math>A = A_0</math> — симметричная матрица. В методе Якоби для <math>A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,...</math>, которая в конечном счёте сходится к диагональной матрице, у которой диагональными элементами являются все собственные значения матрицы <math>A</math>. Матрица <math>A_{i}</math> получается из матрицы <math>A_{i-1}</math> по формуле
<math>A_{i}=J^{T}_iA_{i-1}J_i ,</math>
где <math>J_i</math> - ортогональная матрица, называемая ''вращением Якоби''. Таким образом,
<math>A_{m}=J^{T}_{m-1}A_{m-1}J_{m-1}</math>
<math>=J^{T}_{m-1}J^{T}_{m-2}A_{m-2}J_{m-2}J_{m-1}</math>
<math>=J^{T}_{m-1}...J^{T}_{0}A_{0}J_{0}...J_{m-1}</math>
<math>=J^{T}AJ</math>
При подходящем выборе вращений <math>J_i</math> матрица <math>A_m</math> для больших <math>m</math> будет близкой к диагональной матрице <math>\Lambda</math> <ref>Дж. Деммель, Вычислительная линейная алгебра. Теория и приложения. Перевод Х.Д.Икрамов</ref>. Таким образом, <math>\Lambda \approx J^{T}AJ</math> или <math>J\Lambda J^{T} \approx A</math>, следовательно, столбцы матрицы <math>J</math> являются собственными значениями матрицы <math>A</math>.
Матрица <math>J_i</math> выбирается таким образом, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}=J^{T}_{i}A_{i}J_{i}</math>:

                                                                            
<math>j</math>
                       
<math>k</math>

<math>
J_i = R(j,k,\theta) \equiv
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & -\sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Угол вращения <math>\theta</math> выбирается так, чтобы элементы <math>(j,k)</math> и <math>(k,j)</math> в <math>A_{i+1}</math> стали нулями. Для того, чтобы найти <math>\theta</math>, составляется уравнение:
:<math>
\begin{bmatrix}
a^{i+1}_{jj}&a^{i+1}_{jk}\\
a^{i+1}_{kj}&a^{i+1}_{kk}\\
\end{bmatrix} =
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix}^T
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix}
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix} =
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} ,
</math>
где <math>\lambda_1</math> и <math>\lambda_2</math> - собственные значения подматрицы
:<math>
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix} .
</math>
Пусть <math>c = \cos(\theta)</math> и <math>s = sin(\theta)</math>, <math>a^{i}_{lk} = a_{lk}</math>. Тогда из предыдущего равенства получаем
:<math>
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} =
\begin{bmatrix}
a_{jj}c^2 + a_{kk}s^2+2sca_{jk}&sc(a_{kk} - a_{jj}) + a_{jk}(c^2-s^2)\\
sc(a_{kk} - a_{jj}) + a_{jk}(c^2-s^2)&a_{jj}s^2 + a_{kk}c^2-2sca_{jk}\\
\end{bmatrix}
.
</math>
Приравнивая внедиагональный элемент к нулю, получаем
:<math>
\frac{a_{jj} - a_{kk}}{2a_{jk}} = \frac{c^2-s^2}{2sc} = ctg(2\theta) = r.
</math>
Пусть <math>tg(\theta) = t = \frac{s}{c}</math> . Заметим, что выполняется квадратное уравнение <math>t^2 + 2rt - 1 = 0</math> . Решая уравнение, получаем <math>t = \frac{sign(r)}{|r| + \sqrt{1+r^2}}</math> . Следовательно <math>c = \frac{1}{\sqrt{1+t^2}}</math>, <math>s = ct</math>

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

Вычислительным ядром отдельной итерации является вычисление элементов матрицы <math>A</math> при применении поворота Якоби. Конкретно, изменяются <math>2</math> строки и <math>2</math> столбца, что означает изменение <math>4n</math> элементов. Отметим, что вычисление нового значения одного элемента требует <math>2</math> операции умножения и одну операцию сложения, что позволяет утверждать, что основной вклад в вычислительное ядро вносят умножения.
Однако в целом, следует отметить, что число операций в алгоритме во многом определяется общим числом итераций, а оно квадратично, в то время как отдельная итерация имеет линейную сложность. Более того, так как алгоритм является итерационным и останавливается при достижении некоторой точности, число итераций может изменяться в зависимости от желаемой точности.

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

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

1) Блок вычисления параметров вращения на текущей итерации (выбор обнуляемого элемента и расчет угла вращения).

2)Блок, реализующий непосредственно вращение Якоби.

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

1)Находится максимальный наддиагональный элемент <math>a_{jk}</math> матрицы <math>A</math>.

2)Вычисляются параметры вращения Якоби:
<math>\tau= \frac{(a_{jj}-a_{kk})}{2a_{jk}}</math>
<math>t=sign(\tau)(|\tau|+\sqrt{1+\tau^2})</math>
<math>c= \frac{1}{1+\sqrt{1+\tau^2}}</math>
<math>s=c*t</math>

3)К текущей матрице <math>A</math> применяются вращения с вычисленными параметрами:
<math>A=R^T(j,k,\theta)*A*R(j,k,\theta)</math>
Стоит отметить, что вычисленные на предыдущем шаге <math>c</math> и <math>s</math> есть <math>\cos {\theta}</math> и <math>\sin {\theta}</math> соответственно.

4)Если матрица <math>A</math> не достаточно близка к диагональной, происходит переход к шагу 1.

Вообще говоря, несмотря на то, что поворот, обеспечивающий обнуление наибольшего внедиагонального элемента, обеспечивает схождение метода за наименьшее число итераций, поиск данного наибольшего элемента добавляет порядка <math>n^2</math> операций сравнения, а возможно и присваивания на каждой итерации.
Поэтому с вычислительной точки зрения выгоднее не выбирать наибольший элемент, а по очереди перебирать все наддиагональные элементы, большие заданного порога.

В последующих разделах рассматривается именно такой вариант алгоритма.

=== Последовательная сложность алгоритма ===
Сначала оценим сложность одной итерации:

1)Так как элементы матрицы никак не упорядоченны, поиск наибольшего элемента линейно зависит от числа элементов над диагональю.
Конкретнее, на данном шаге происходит <math>\frac{n*(n-1)}{2} -1</math> сравнение.

2)<math>3</math> операции деления, <math>2</math> операции взятия корня, <math>4</math> операции умножения и <math>4</math> операции сложения/вычитания.

3)<math>4n</math> операций умножения и <math>2n</math> операций сложения.

4)операция сравнения

В худшем случае количество итераций в теории равняется числу наддиагональных элементов, т.е. <math>\frac{n*(n-1)}{2}</math>
На практике же из-за накопления ошибок вычисления, а так же восстановления уже обнуленных элементов при некоторых вращениях, число операций возрастает.
Вместе с тем, можно утверждать, что порядок числа итераций будет <math>O(N^2)</math>.
Таким образом, суммарная сложность алгоритма составляет <math>O(N^4)</math> сравнений, и <math>O(N^3)</math> сложений и умножений.

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

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

Аналитически информационный граф данного алгоритма можно описать следующим образом:

1)Последовательно идущие макроярусы вычисления параметров текущей итерации и вращения Якоби с этими параметрами.
Число данных ярусов варьируется в зависимости от входных данных, но порядок составляет <math>O(n^2)</math>.

2)Вычисление параметров текущей итерации содержит конечное число операций умножения, сложения и вычисления квадратного корня.

3)Макроярус вращения Якоби содержит вычисление <math>2n+2</math> элементов матрицы и <math>2n-2</math> операций присваивания. На данном ярусе ширина графа достигает максимального значения. Вначале вычисляются значения в строках <math>j</math> и <math>k</math> (это соответствует умножению матрицы <math>R^T</math> на матрицу <math>A</math>). Далее, в силу того, что при умножении результата на матрицу <math>A</math> изменяются только столбцы <math>j</math> и <math>k</math> и итоговая матрица симметрична, можно не пересчитывать значения в столбцах, а получить их простым присваиванием по формуле: <math>a_{pk}=a_{kp}</math>, <math>a_{pj}=a_{jp}</math>, <math>p \neq k,j</math>. Для элементов <math>a_{jj}</math> и <math>a_{kk}</math> необходимо произвести вычисления, аналогичные вычислениям для элементов строк.

Визуальное представление графа алгоритма представлено на схемах ниже:

[[file:SI.jpg|thumb|center|1400px|Рисунок 1. Граф алгоритма на макроуровне. Rarams - вычисление параметров, Rotate - получение <math>A_{i+1}</math> из <math>A_{i}</math>.]]

[[file:exec_params.jpg|thumb|center|1400px|Рисунок 2. Структура блока Params.]]

[[file:ROT1.png|thumb|center|1400px|Рисунок 3. Структура блока Rotate.]]

=== Ресурс параллелизма алгоритма ===
Как видно из представления алгоритма в ярусно-параллельной форме ([[#Информационный граф| п.1.7]]), максимальная ширина ярусов составляет <math>2n</math> вершин.
Для выполнения данного алгоритма в параллельном варианте следует выполнить <math>O(\frac{n(n+1)}{2})</math> итераций.
Рассмотрим отдельную итерацию с точки зрения ярусно-параллельной формы алгоритма.

1)Выполнение 8 ярусов с конечным числом операций сложения, умножения, взятия квадратного корня и нахождения знака.

2)Выполнение 2 ярусов вычисления элементов в изменяемых строках и столбцах.

На данных двух ярусах осуществляется <math>4n</math> умножений и <math>2n</math> сложений. Данный вид параллелизма относится к координатному. Так как каждая последующая итерация алгоритма зависит от предыдущей, их выполнение распараллелить не представляется возможным. Таким образом, при наличии бесконечного числа процессоров, итоговая сложность алгоритма составляет <math>O(\frac{n(n+1)}{2})</math>

=== Входные и выходные данные алгоритма ===
'''Входные данные''': плотная матрица <math>A</math> (элементы <math>a_{ij}</math>); при этом <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>..

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы).
Конкретный вариант хранения данных зависит от реализации. В качестве примеров можно привести хранение в одномерном массиве длины <math>\frac{n (n + 1)}{2}</math> по строкам своей нижней части, хранение в виде так называемого ступенчатого массива (такой вариант двумерного массива, в котором каждая строка имеет свой размер).

'''Выходные данные''': вектор собственных значений <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>) длины <math>n</math>.

=== Свойства алгоритма ===
Параллельная сложность выполнения алгоритма составляет <math>O(\frac{n(n+1)}{2}).</math>
Последовательная сложность выполнения алгоритма составляет <math>O(\frac{n^2(n+1)}{2}).</math>
Таким образом, соотношение сложностей является линейным.
Более того, и вычислительная мощность данного алгоритма линейна.

В алгоритме используется примерно в два раза больше операций умножения, чем сложения.
Отдельно стоит рассмотреть вопрос хранения матрицы <math>A</math> в процессе работы алгоритма. Хранение лишь нижней или верхней части матрицы в виде одномерного массива возможно; более того, хранение в таком виде обеспечивает экономию памяти в <math>2</math> раза и защищает от ассиметричности матрицы в результате накопления математических ошибок. Однако, вычисление индексов <math>i</math> и <math>j</math> элементов <math>a_{ij}</math>, соответствующих данному номеру <math>k</math> вообще говоря требует отдельного цикла, что создает дополнительную нагрузку на процессор.

Кроме того, следует отметить следующие особенности алгоритма:

1)Несмотря на то, что выбор наибольшего наддиагонального элемента, как кандидата на обнуление, кажется оптимальным, на самом деле он таковым не является. При таком выборе элемента, на каждой итерации необходимо находить текущий наибольший элемент в матрице, что требует дополнительных <math>\frac{n*(n-1)}{2}</math> операций сравнения и приводит к увеличению сложности алгоритма до <math>O(n^4)</math>. Вместо этого рекомендуется перебирать по очереди все наддиагональные элементы, большие заданного параметра. В большинстве случаев от <math>4</math> до <math>8</math> полных проходов достаточно для приближения исходной матрицы к диагональной.

2)Если при выборе в качестве обнуляемого элемента <math>a_{ij}</math> элементы <math>a_{ii} = a_{jj}</math>, то, как видно из формул в пунктах выше, матрицы поворота вырождаются в единичные и матрица на данной итерации не изменяется. Это еще один довод в пользу отказа от выбора наибольшего элемента, т.к. в данном случае произойдет зацикливание алгоритма.

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

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

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

==== Локальность реализации алгоритма ====

===== Структура обращений в память и качественная оценка локальности =====

===== Количественная оценка локальности =====

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

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

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

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

Исследование проводилось на 1U сервере со следующими характеристиками:
* 2 x Intel® Xeon® Processor E5-2697 v2;
* 128GB RAM;

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:
* число процессоров [1 : 48] с шагом 1
* размерность матрицы [400:1600] с шагом 200

Использовался компилятор g++ версии 5.4.0 со следующими флагами: -O2, -fopenmp, -std=c++11.
Флаг -O2 является опциональным, и означает уровень оптимизации кода при компиляции. Все прочие флаги строго обязательны при компиляции, т.к. в коде используются функции из стандарта С++11.

[[file:parallel11.jpg|thumb|center|700px|Рисунок 2. Изменение производительности в зависимости от числа процессоров и размерности матрицы.]]

Чтобы продемонстрировать важное свойство алгоритма, приведем так же график производительности в зависимости от числа процессов при размере матрицы 1600*1600

[[file:parallel1600.jpg|thumb|center|700px|Рисунок 2. Изменение производительности в зависимости от числа процессоров при размере матрицы 1600х1600.]]

За <math>1</math> принята производительность при одном процессе.
Как видно, производительность резко увеличивается при добавлении числа потоков в начале и снижается при дальнейшем добавлении.
Это связано с тем, что в одном потоке совершается малое количество арифметических операций. После выполнения операций совершается запись в массив полученных значений, в результате чего возникает конфликт потоков.
Поэтому наиболее оптимальное число потоков <math>8-16</math>, что говорит о слабой масштабируемости данного алгоритма.

[http://pastebin.com/yUyh1ziL Параллельная реализация на языке C++]

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

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

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

1)Библиотека [https://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE] содержит последовательную реализацию алгоритма.

2)В цифровой библиотеке ieee.org приводится [http://ieeexplore.ieee.org/document/6310877/ аннотация] статьи 2012 года, в которой авторы описывают реализацию данного алгоритма на CUDA.

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

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-11-21T12:29:50Z

Пронин Андрей: /* Масштабируемость реализации алгоритма */

{{algorithm
| name = Метод Якоби вычисления собственных значений симметричной матрицы ЗП
| serial_complexity = <math>O(n^3)</math>
| pf_height = <math>O(n^2)</math>
| pf_width = <math>2n</math>
| input_data = <math>n^2</math>
| output_data = <math>n</math>
}}

Авторы: [[Участник:Зиновьев Владимир|Зиновьев В.С.]] (написание кода, информационный граф, общее и мат описание алгоритма), [[Участник:Пронин Андрей|Пронин А.М.]] (написание кода, информационный граф, вычислительное ядро алгоритма, макроструктура алгоритма). В остальные разделы статьи вклад равноценный.

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

=== Общее описание алгоритма ===
Задача нахождения собственных значений и собственных векторов матриц(СЗВМ) является одной из основных задач для многих разделов физики. <ref>Чечин Г.М., Зехцер М.Ю. Собственные значения и собственные векторы матриц</ref> С такой вычислительной проблемой приходится сталкиваться, например, при исследовании собственных колебаний различных механических систем, колебательных и электронных спектров молекул и кристаллов. Совершенно принципиальное значение эта проблема приобрела после создания в тридцатых годах прошлого века квантовой механики, которая стала базовой дисциплиной исследования микромира.Кроме того, данная проблема важна в теории автоматического управления, как инструмент исследования устойчивости линейных систем.

Метод Якоби приводит симметричную действительную матрицу к диагональной форме с помощью некоторой (в принципе, бесконечной) последовательности плоских вращений в разных плоскостях исходного n-мерного векторного пространства. Метод Якоби состоит из некоторой последовательности шагов, на каждом из которых обнуляется один из внедиагональных элементов (обычно наибольший по модулю), в результате чего старая матрица <math>A_{i}</math> преобразуется в некоторую новую матрицу <math>A_{i+1}</math>. Делается это с помощью преобразования подобия, использующего матрицу плоского вращения <math>J_{i}</math> (подробное описание матрицы плоского вращения приведено ниже в разделе "[[#Математическое описание алгоритма|Математическое описание алгоритма]]"), которая изменяет лишь две координаты <math>n</math>-мерных векторов, а именно, координаты с номерами <math>j</math> и <math>k</math>. При таком шаге матрица <math>A_{i+1}</math> отличается от матрицы <math>A_{i}</math> лишь элементами двух строк с номерами <math>j</math>, <math>k</math> и двух столбцов с теми же номерами (<math>j</math> и <math>k</math>). Все же другие элементы матрицы <math>A</math> остаются неизменными. Число шагов, за которое матрица <math>A</math> приводится таким способом к диагональной форме, в общем случае является бесконечным. (это свойство метода Якоби более подробно рассмотрено в разделе "[[#Свойства алгоритма|Свойства алгоритма]]") В результате метод Якоби представляет собой некоторый бесконечный итерационный процесс, на каждом шаге которого преобразующаяся матрица становится всё более и более близкой к диагональной форме (в смысле уменьшения суммы квадратов всех своих внедиагональных элементов). На практике обычно выбирается заранее заданная погрешность <math>\varepsilon</math> и процесс приведения исходной матрицы к диагональному виду прекращается, когда наибольший по модулю внедиагональный элемент матрицы становится меньше <math>\varepsilon</math>. Таким образом, применяя на практике метод Якоби, мы приводим исходную матрицу к диагональной форме с точностью до некоторой вычислительной погрешности <math>\varepsilon</math> в результате конечного числа шагов. Повышение этой точности требует увеличения числа шагов метода Якоби. В конечном итоге у полученной в результате этого процесса матрицы на диагонали будут находиться все собственные значения (с определённой погрешностью) исходной симметрической матрицы.

==== Симметричность матрицы ====

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

=== Математическое описание алгоритма ===
Пусть <math>A = A_0</math> — симметричная матрица. В методе Якоби для <math>A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,...</math>, которая в конечном счёте сходится к диагональной матрице, у которой диагональными элементами являются все собственные значения матрицы <math>A</math>. Матрица <math>A_{i}</math> получается из матрицы <math>A_{i-1}</math> по формуле
<math>A_{i}=J^{T}_iA_{i-1}J_i ,</math>
где <math>J_i</math> - ортогональная матрица, называемая ''вращением Якоби''. Таким образом,
<math>A_{m}=J^{T}_{m-1}A_{m-1}J_{m-1}</math>
<math>=J^{T}_{m-1}J^{T}_{m-2}A_{m-2}J_{m-2}J_{m-1}</math>
<math>=J^{T}_{m-1}...J^{T}_{0}A_{0}J_{0}...J_{m-1}</math>
<math>=J^{T}AJ</math>
При подходящем выборе вращений <math>J_i</math> матрица <math>A_m</math> для больших <math>m</math> будет близкой к диагональной матрице <math>\Lambda</math> <ref>Дж. Деммель, Вычислительная линейная алгебра. Теория и приложения. Перевод Х.Д.Икрамов</ref>. Таким образом, <math>\Lambda \approx J^{T}AJ</math> или <math>J\Lambda J^{T} \approx A</math>, следовательно, столбцы матрицы <math>J</math> являются собственными значениями матрицы <math>A</math>.
Матрица <math>J_i</math> выбирается таким образом, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}=J^{T}_{i}A_{i}J_{i}</math>:

                                                                            
<math>j</math>
                       
<math>k</math>

<math>
J_i = R(j,k,\theta) \equiv
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & -\sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Угол вращения <math>\theta</math> выбирается так, чтобы элементы <math>(j,k)</math> и <math>(k,j)</math> в <math>A_{i+1}</math> стали нулями. Для того, чтобы найти <math>\theta</math>, составляется уравнение:
:<math>
\begin{bmatrix}
a^{i+1}_{jj}&a^{i+1}_{jk}\\
a^{i+1}_{kj}&a^{i+1}_{kk}\\
\end{bmatrix} =
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix}^T
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix}
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix} =
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} ,
</math>
где <math>\lambda_1</math> и <math>\lambda_2</math> - собственные значения подматрицы
:<math>
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix} .
</math>
Пусть <math>c = \cos(\theta)</math> и <math>s = sin(\theta)</math>, <math>a^{i}_{lk} = a_{lk}</math>. Тогда из предыдущего равенства получаем
:<math>
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} =
\begin{bmatrix}
a_{jj}c^2 + a_{kk}s^2+2sca_{jk}&sc(a_{kk} - a_{jj}) + a_{jk}(c^2-s^2)\\
sc(a_{kk} - a_{jj}) + a_{jk}(c^2-s^2)&a_{jj}s^2 + a_{kk}c^2-2sca_{jk}\\
\end{bmatrix}
.
</math>
Приравнивая внедиагональный элемент к нулю, получаем
:<math>
\frac{a_{jj} - a_{kk}}{2a_{jk}} = \frac{c^2-s^2}{2sc} = ctg(2\theta) = r.
</math>
Пусть <math>tg(\theta) = t = \frac{s}{c}</math> . Заметим, что выполняется квадратное уравнение <math>t^2 + 2rt - 1 = 0</math> . Решая уравнение, получаем <math>t = \frac{sign(r)}{|r| + \sqrt{1+r^2}}</math> . Следовательно <math>c = \frac{1}{\sqrt{1+t^2}}</math>, <math>s = ct</math>

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

Вычислительным ядром отдельной итерации является вычисление элементов матрицы <math>A</math> при применении поворота Якоби. Конкретно, изменяются <math>2</math> строки и <math>2</math> столбца, что означает изменение <math>4n</math> элементов. Отметим, что вычисление нового значения одного элемента требует <math>2</math> операции умножения и одну операцию сложения, что позволяет утверждать, что основной вклад в вычислительное ядро вносят умножения.
Однако в целом, следует отметить, что число операций в алгоритме во многом определяется общим числом итераций, а оно квадратично, в то время как отдельная итерация имеет линейную сложность. Более того, так как алгоритм является итерационным и останавливается при достижении некоторой точности, число итераций может изменяться в зависимости от желаемой точности.

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

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

1) Блок вычисления параметров вращения на текущей итерации (выбор обнуляемого элемента и расчет угла вращения).

2)Блок, реализующий непосредственно вращение Якоби.

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

1)Находится максимальный наддиагональный элемент <math>a_{jk}</math> матрицы <math>A</math>.

2)Вычисляются параметры вращения Якоби:
<math>\tau= \frac{(a_{jj}-a_{kk})}{2a_{jk}}</math>
<math>t=sign(\tau)(|\tau|+\sqrt{1+\tau^2})</math>
<math>c= \frac{1}{1+\sqrt{1+\tau^2}}</math>
<math>s=c*t</math>

3)К текущей матрице <math>A</math> применяются вращения с вычисленными параметрами:
<math>A=R^T(j,k,\theta)*A*R(j,k,\theta)</math>
Стоит отметить, что вычисленные на предыдущем шаге <math>c</math> и <math>s</math> есть <math>\cos {\theta}</math> и <math>\sin {\theta}</math> соответственно.

4)Если матрица <math>A</math> не достаточно близка к диагональной, происходит переход к шагу 1.

Вообще говоря, несмотря на то, что поворот, обеспечивающий обнуление наибольшего внедиагонального элемента, обеспечивает схождение метода за наименьшее число итераций, поиск данного наибольшего элемента добавляет порядка <math>n^2</math> операций сравнения, а возможно и присваивания на каждой итерации.
Поэтому с вычислительной точки зрения выгоднее не выбирать наибольший элемент, а по очереди перебирать все наддиагональные элементы, большие заданного порога.

В последующих разделах рассматривается именно такой вариант алгоритма.

=== Последовательная сложность алгоритма ===
Сначала оценим сложность одной итерации:

1)Так как элементы матрицы никак не упорядоченны, поиск наибольшего элемента линейно зависит от числа элементов над диагональю.
Конкретнее, на данном шаге происходит <math>\frac{n*(n-1)}{2} -1</math> сравнение.

2)<math>3</math> операции деления, <math>2</math> операции взятия корня, <math>4</math> операции умножения и <math>4</math> операции сложения/вычитания.

3)<math>4n</math> операций умножения и <math>2n</math> операций сложения.

4)операция сравнения

В худшем случае количество итераций в теории равняется числу наддиагональных элементов, т.е. <math>\frac{n*(n-1)}{2}</math>
На практике же из-за накопления ошибок вычисления, а так же восстановления уже обнуленных элементов при некоторых вращениях, число операций возрастает.
Вместе с тем, можно утверждать, что порядок числа итераций будет <math>O(N^2)</math>.
Таким образом, суммарная сложность алгоритма составляет <math>O(N^4)</math> сравнений, и <math>O(N^3)</math> сложений и умножений.

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

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

Аналитически информационный граф данного алгоритма можно описать следующим образом:

1)Последовательно идущие макроярусы вычисления параметров текущей итерации и вращения Якоби с этими параметрами.
Число данных ярусов варьируется в зависимости от входных данных, но порядок составляет <math>O(n^2)</math>.

2)Вычисление параметров текущей итерации содержит конечное число операций умножения, сложения и вычисления квадратного корня.

3)Макроярус вращения Якоби содержит вычисление <math>2n+2</math> элементов матрицы и <math>2n-2</math> операций присваивания. На данном ярусе ширина графа достигает максимального значения. Вначале вычисляются значения в строках <math>j</math> и <math>k</math> (это соответствует умножению матрицы <math>R^T</math> на матрицу <math>A</math>). Далее, в силу того, что при умножении результата на матрицу <math>A</math> изменяются только столбцы <math>j</math> и <math>k</math> и итоговая матрица симметрична, можно не пересчитывать значения в столбцах, а получить их простым присваиванием по формуле: <math>a_{pk}=a_{kp}</math>, <math>a_{pj}=a_{jp}</math>, <math>p \neq k,j</math>. Для элементов <math>a_{jj}</math> и <math>a_{kk}</math> необходимо произвести вычисления, аналогичные вычислениям для элементов строк.

Визуальное представление графа алгоритма представлено на схемах ниже:

[[file:SI.jpg|thumb|center|1400px|Рисунок 1. Граф алгоритма на макроуровне. Rarams - вычисление параметров, Rotate - получение <math>A_{i+1}</math> из <math>A_{i}</math>.]]

[[file:exec_params.jpg|thumb|center|1400px|Рисунок 2. Структура блока Params.]]

[[file:ROT1.png|thumb|center|1400px|Рисунок 3. Структура блока Rotate.]]

=== Ресурс параллелизма алгоритма ===
Как видно из представления алгоритма в ярусно-параллельной форме ([[#Информационный граф| п.1.7]]), максимальная ширина ярусов составляет <math>2n</math> вершин.
Для выполнения данного алгоритма в параллельном варианте следует выполнить <math>O(\frac{n(n+1)}{2})</math> итераций.
Рассмотрим отдельную итерацию с точки зрения ярусно-параллельной формы алгоритма.

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

2)Выполнение 2 ярусов вычисления элементов в изменяемых строках и столбцах.

На данных двух ярусах осуществляется <math>4n</math> умножений и <math>2n</math> сложений. Данный вид параллелизма относится к координатному. Так как каждая последующая итерация алгоритма зависит от предыдущей, их выполнение распараллелить не представляется возможным. Таким образом, при наличии бесконечного числа процессоров, итоговая сложность алгоритма составляет <math>O(\frac{n(n+1)}{2})</math>

=== Входные и выходные данные алгоритма ===
'''Входные данные''': плотная матрица <math>A</math> (элементы <math>a_{ij}</math>); при этом <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>..

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы).
Конкретный вариант хранения данных зависит от реализации. В качестве примеров можно привести хранение в одномерном массиве длины <math>\frac{n (n + 1)}{2}</math> по строкам своей нижней части, хранение в виде так называемого ступенчатого массива (такой вариант двумерного массива, в котором каждая строка имеет свой размер).

'''Выходные данные''': вектор собственных значений <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>) длины <math>n</math>.

=== Свойства алгоритма ===
Параллельная сложность выполнения алгоритма составляет <math>O(\frac{n(n+1)}{2}).</math>
Последовательная сложность выполнения алгоритма составляет <math>O(\frac{n^2(n+1)}{2}).</math>
Таким образом, соотношение сложностей является линейным.
Более того, и вычислительная мощность данного алгоритма линейна.

В алгоритме используется примерно в два раза больше операций умножения, чем сложения.
Отдельно стоит рассмотреть вопрос хранения матрицы <math>A</math> в процессе работы алгоритма. Хранение лишь нижней или верхней части матрицы в виде одномерного массива возможно; более того, хранение в таком виде обеспечивает экономию памяти в <math>2</math> раза и защищает от ассиметричности матрицы в результате накопления математических ошибок. Однако, вычисление индексов <math>i</math> и <math>j</math> элементов <math>a_{ij}</math>, соответствующих данному номеру <math>k</math> вообще говоря требует отдельного цикла, что создает дополнительную нагрузку на процессор.

Кроме того, следует отметить следующие особенности алгоритма:

1)Несмотря на то, что выбор наибольшего наддиагонального элемента, как кандидата на обнуление, кажется оптимальным, на самом деле он таковым не является. При таком выборе элемента, на каждой итерации необходимо находить текущий наибольший элемент в матрице, что требует дополнительных <math>\frac{n*(n-1)}{2}</math> операций сравнения и приводит к увеличению сложности алгоритма до <math>O(n^4)</math>. Вместо этого рекомендуется перебирать по очереди все наддиагональные элементы, большие заданного параметра. В большинстве случаев от <math>4</math> до <math>8</math> полных проходов достаточно для приближения исходной матрицы к диагональной.

2)Если при выборе в качестве обнуляемого элемента <math>a_{ij}</math> элементы <math>a_{ii} = a_{jj}</math>, то, как видно из формул в пунктах выше, матрицы поворота вырождаются в единичные и матрица на данной итерации не изменяется. Это еще один довод в пользу отказа от выбора наибольшего элемента, т.к. в данном случае произойдет зацикливание алгоритма.

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

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

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

==== Локальность реализации алгоритма ====

===== Структура обращений в память и качественная оценка локальности =====

===== Количественная оценка локальности =====

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

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

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

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

Исследование проводилось на 1U сервере со следующими характеристиками:
* 2 x Intel® Xeon® Processor E5-2697 v2;
* 128GB RAM;

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:
* число процессоров [1 : 48] с шагом 1
* размерность матрицы [400:1600] с шагом 200

Использовался компилятор g++ версии 5.4.0 со следующими флагами: -O2, -fopenmp, -std=c++11.
Флаг -O2 является опциональным, и означает уровень оптимизации кода при компиляции. Все прочие флаги строго обязательны при компиляции, т.к. в коде используются функции из стандарта С++11.

[[file:parallel11.jpg|thumb|center|700px|Рисунок 2. Изменение производительности в зависимости от числа процессоров и размерности матрицы.]]

Чтобы продемонстрировать важное свойство алгоритма, приведем так же график производительности в зависимости от числа процессов при размере матрицы 1600*1600

[[file:parallel1600.jpg|thumb|center|700px|Рисунок 2. Изменение производительности в зависимости от числа процессоров при размере матрицы 1600х1600.]]

За <math>1</math> принята производительность при одном процессе.
Как видно, производительность резко увеличивается при добавлении числа потоков в начале и снижается при дальнейшем добавлении.
Это связано с тем, что в одном потоке совершается малое количество арифметических операций. После выполнения операций совершается запись в массив полученных значений, в результате чего возникает конфликт потоков.
Поэтому наиболее оптимальное число потоков <math>8-16</math>, что говорит о слабой масштабируемости данного алгоритма.

[http://pastebin.com/yUyh1ziL Параллельная реализация на языке C++]

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

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

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

1)Библиотека [https://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE] содержит последовательную реализацию алгоритма.

2)В цифровой библиотеке ieee.org приводится [http://ieeexplore.ieee.org/document/6310877/ аннотация] статьи 2012 года, в которой авторы описывают реализацию данного алгоритма на CUDA.

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

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-10-27T21:08:55Z

Пронин Андрей:

{{Assignment}}

{{algorithm
| name = Метод Якоби вычисления собственных значений симметричной матрицы ЗП
| serial_complexity = <math>O(n^3)</math>
| pf_height = <math>O(n^2)</math>
| pf_width = <math>2n</math>
| input_data = <math>n^2</math>
| output_data = <math>n</math>
}}

Авторы: [[Участник:Зиновьев Владимир|Зиновьев В.С.]] (написание кода, информационный граф, общее и мат описание алгоритма), [[Участник:Пронин Андрей|Пронин А.М.]] (написание кода, информационный граф, вычислительное ядро алгоритма, макроструктура алгоритма). В остальные разделы статьи вклад равноценный.

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

=== Общее описание алгоритма ===
Задача нахождения собственных значений и собственных векторов матриц(СЗВМ) является одной из основных задач для многих разделов физики. <ref>Чечин Г.М., Зехцер М.Ю. Собственные значения и собственные векторы матриц</ref> С такой вычислительной проблемой приходится сталкиваться, например, при исследовании собственных колебаний различных механических систем, колебательных и электронных спектров молекул и кристаллов. Совершенно принципиальное значение эта проблема приобрела после создания в тридцатых годах прошлого века квантовой механики, которая стала базовой дисциплиной исследования микромира.Кроме того, данная проблема важна в теории автоматического управления, как инструмент исследования устойчивости линейных систем.

Метод Якоби приводит симметричную действительную матрицу к диагональной форме с помощью некоторой (в принципе, бесконечной) последовательности плоских вращений в разных плоскостях исходного n-мерного векторного пространства. Метод Якоби состоит из некоторой последовательности шагов, на каждом из которых обнуляется один из внедиагональных элементов (обычно наибольший по модулю), в результате чего старая матрица <math>A_{i}</math> преобразуется в некоторую новую матрицу <math>A_{i+1}</math>. Делается это с помощью преобразования подобия, использующего матрицу плоского вращения <math>J_{i}</math> (подробное описание матрицы плоского вращения приведено ниже в разделе "[[#Математическое описание алгоритма|Математическое описание алгоритма]]"), которая изменяет лишь две координаты <math>n</math>-мерных векторов, а именно, координаты с номерами <math>j</math> и <math>k</math>. При таком шаге матрица <math>A_{i+1}</math> отличается от матрицы <math>A_{i}</math> лишь элементами двух строк с номерами <math>j</math>, <math>k</math> и двух столбцов с теми же номерами (<math>j</math> и <math>k</math>). Все же другие элементы матрицы A остаются неизменными. Число шагов, за которое матрица A приводится таким способом к диагональной форме, в общем случае является бесконечным. (это свойство метода Якоби более подробно рассмотрено в разделе "[[#Свойства алгоритма|Свойства алгоритма]]") В результате метод Якоби представляет собой некоторый бесконечный итерационный процесс, на каждом шаге которого преобразующаяся матрица становится всё более и более близкой к диагональной форме (в смысле уменьшения суммы квадратов всех своих внедиагональных элементов). На практике обычно выбирается заранее заданная погрешность <math>\varepsilon</math> и процесс приведения исходной матрицы к диагональному виду прекращается, когда наибольший по модулю внедиагональный элемент матрицы становится меньше <math>\varepsilon</math>. Таким образом, применяя на практике метод Якоби, мы приводим исходную матрицу к диагональной форме с точностью до некоторой вычислительной погрешности <math>\varepsilon</math> в результате конечного числа шагов. Повышение этой точности требует увеличения числа шагов метода Якоби. В конечном итоге у полученной в результате этого процесса матрицы на диагонали будут находиться все собственные значения (с определённой погрешностью) исходной симметрической матрицы.

==== Симметричность матрицы ====

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

=== Математическое описание алгоритма ===
Пусть <math>A = A_0</math> — симметричная матрица. В методе Якоби для <math>A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,...</math>, которая в конечном счёте сходится к диагональной матрице, у которой диагональными элементами являются все собственные значения матрицы <math>A</math>. Матрица <math>A_{i}</math> получается из матрицы <math>A_{i-1}</math> по формуле
<math>A_{i}=J^{T}_iA_{i-1}J_i ,</math>
где <math>J_i</math> - ортогональная матрица, называемая ''вращением Якоби''. Таким образом,
<math>A_{m}=J^{T}_{m-1}A_{m-1}J_{m-1}</math>
<math>=J^{T}_{m-1}J^{T}_{m-2}A_{m-2}J_{m-2}J_{m-1}</math>
<math>=J^{T}_{m-1}...J^{T}_{0}A_{0}J_{0}...J_{m-1}</math>
<math>=J^{T}AJ</math>
При подходящем выборе вращений <math>J_i</math> матрица <math>A_m</math> для больших <math>m</math> будет близкой к диагональной матрице <math>\Lambda</math> <ref>Дж. Деммель, Вычислительная линейная алгебра. Теория и приложения. Перевод Х.Д.Икрамов</ref>. Таким образом, <math>\Lambda \approx J^{T}AJ</math> или <math>J\Lambda J^{T} \approx A</math>, следовательно, столбцы матрицы <math>J</math> являются собственными значениями матрицы <math>A</math>.
Матрица <math>J_i</math> выбирается таким образом, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}=J^{T}_{i}A_{i}J_{i}</math>:

                                                                            
<math>j</math>
                       
<math>k</math>

<math>
J_i = R(j,k,\theta) \equiv
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & -\sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Угол вращения <math>\theta</math> выбирается так, чтобы элементы <math>(j,k)</math> и <math>(k,j)</math> в <math>A_{i+1}</math> стали нулями. Для того, чтобы найти <math>\theta</math>, составляется уравнение:
:<math>
\begin{bmatrix}
a^{i+1}_{jj}&a^{i+1}_{jk}\\
a^{i+1}_{kj}&a^{i+1}_{kk}\\
\end{bmatrix} =
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix}^T
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix}
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix} =
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} ,
</math>
где <math>\lambda_1</math> и <math>\lambda_2</math> - собственные значения подматрицы
:<math>
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix} .
</math>
Пусть <math>c = \cos(\theta)</math> и <math>s = sin(\theta)</math>, <math>a^{i}_{lk} = a_{lk}</math>. Тогда из предыдущего равенства получаем
:<math>
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} =
\begin{bmatrix}
a_{jj}c^2 + a_{kk}s^2+2sca_{jk}&sc(a_{kk} - a{jj}) + a_{jk}(c^2-s^2)\\
sc(a_{kk} - a{jj}) + a_{jk}(c^2-s^2)&a_{jj}s^2 + a_{kk}c^2-2sca_{jk}\\
\end{bmatrix}
.
</math>
Приравнивая внедиагональный элемент к нулю, получаем
:<math>
\frac{a_{jj} - a{kk}}{2a_{jk}} = \frac{c^2-s^2}{2sc} = ctg(2\theta) = r.
</math>
Пусть <math>tg(\theta) = t = \frac{s}{c}</math> . Заметим, что выполняется квадратное уравнение <math>t^2 + 2rt - 1 = 0</math> . Решая уравнение, получаем <math>t = \frac{sign(r)}{|r| + \sqrt{1+r^2}}</math> . Следовательно <math>c = \frac{1}{\sqrt{1+t^2}}</math>, <math>s = ct</math>

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

Вычислительным ядром отдельной итерации является вычисление элементов матрицы <math>A</math> при применении поворота Якоби. Конкретно, изменяются 2 строки и 2 столбца, что означает изменение 4n элементов. Отметим, что вычисление нового значения одного элемента требует 2 операции умножения и одну операцию сложения, что позволяет утверждать, что основной вклад в вычислительное ядро вносят умножения.
Однако в целом, следует отметить, что число операций в алгоритме во многом определяется общим числом итераций, а оно квадратично, в то время как отдельная итерация имеет линейную сложность. Более того, так как алгоритм является итерационным и останавливается при достижении некоторой точности, число итераций может изменяться в зависимости от желаемой точности.

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

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

1) Блок вычисления параметров вращения на текущей итерации (выбор обнуляемого элемента и расчет угла вращения).

2)Блок, реализующий непосредственно вращение Якоби.

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

1)Находится максимальный наддиагональный элемент <math>a_{jk}</math> матрицы <math>A</math>.

2)Вычисляются параметры вращения Якоби:
<math>\tau= \frac{(a_{jj}-a_{kk})}{2a_{jk}}</math>
<math>t=sign(\tau)(|\tau|+\sqrt{1+\tau^2})</math>
<math>c= \frac{1}{1+\sqrt{1+\tau^2}}</math>
<math>s=c*t</math>

3)К текущей матрице А применяются вращения с вычисленными параметрами:
<math>A=R^T(j,k,\theta)*A*R(j,k,\theta)</math>
Стоит отметить, что вычисленные на предыдущем шаге <math>c</math> и <math>s</math> есть <math>\cos {\theta}</math> и <math>\sin {\theta}</math> соответственно.

4)Если матрица А не достаточно близка к диагональной, происходит переход к шагу 1.

Вообще говоря, несмотря на то, что поворот, обеспечивающий обнуление наибольшего внедиагонального элемента, обеспечивает схождение метода за наименьшее число итераций, поиск данного наибольшего элемента добавляет порядка <math>n^2</math> операций сравнения, а возможно и присваивания на каждой итерации.
Поэтому с вычислительной точки зрения выгоднее не выбирать наибольший элемент, а по очереди перебирать все наддиагональные элементы, большие заданного порога.

В последующих разделах рассматривается именно такой вариант алгоритма.

=== Последовательная сложность алгоритма ===
Сначала оценим сложность одной итерации:

1)Так как элементы матрицы никак не упорядоченны, поиск наибольшего элемента линейно зависит от числа элементов над диагональю.
Конкретнее, на данном шаге происходит <math>\frac{n*(n-1)}{2} -1</math> сравнение.

2)3 операции деления, 2 операции взятия корня, 4 операции умножения и 4 операции сложения/вычитания.

3)<math>4*n</math> операций умножения и <math>2*n</math> операций сложения.

4)операция сравнения

В наиболее неудачном случае количество итераций в теории равняется числу наддиагональных элементов, т.е. <math>\frac{n*(n-1)}{2}</math>
На практике же из-за накопления ошибок вычисления а так же восстановления уже обнуленных элементов при некоторых вращениях, число операций возрастает.
Вместе с тем, можно утверждать, что порядок числа итераций можно оценить как <math>O(N^2)</math>.
Таким образом, суммарная сложность алгоритма составляет <math>O(N^4)</math> сравнений, и <math>O(N^3)</math> сложений и умножений.

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

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

Аналитически информационный граф данного алгоритма можно описать следующим образом:

1)Последовательно идущие макроярусы вычисления параметров текущей итерации и вращения Якоби с этими параметрами
Число данных ярусов варьируется в зависимости от входных данных, но порядок составляет <math>O(n^2)</math>.

2)Вычисление параметров текущей итерации содержит конечное число операций умножения, сложения и вычисления квадратного корня.

3)Макроярус вращения Якоби содержит вычисление <math>2n+2</math> элементов матрицы и <math>2n-2</math> операций присваивания. На данном ярусе ширина графа достигает максимального значения. Вначале вычисляются значения в строках <math>j</math> и <math>k</math> (это соответствует умножению матрицы <math>R^T</math> на матрицу <math>A</math>). Далее, в силу того, что при умножении результата на матрицу <math>A</math> изменяются только столбцы <math>j</math> и <math>k</math> и итоговая матрица симметрична, можно не пересчитывать значения в столбцах, а получить их простым присваиванием по формуле: <math>a_{pk}=a_{kp}</math>, <math>a_{pj}=a_{jp}</math>, <math>p \neq k,j</math>. Для элементов <math>a_{jj}</math> и <math>a_{kk}</math> необходимо произвести вычисления, аналогичные вычислениям для элементов строк.

Визуальное представление графа алгоритма представлено на схемах ниже:

[[file:SI.jpg|thumb|center|1400px|Рисунок 1. Граф алгоритма на макроуровне. Rarams - вычисление параметров, Rotate - получение <math>A_{i+1}</math> из <math>A_{i}</math>.]]

[[file:exec_params.jpg|thumb|center|1400px|Рисунок 2. Структура блока Params.]]

[[file:ROT1.png|thumb|center|1400px|Рисунок 3. Структура блока Rotate.]]

=== Ресурс параллелизма алгоритма ===
Как видно из представления алгоритма в ярусно-параллельной форме ([[#Информационный граф| п.1.7]]), максимальная ширина ярусов составляет <math>2n</math> вершин.
Для выполнения данного алгоритма в параллельном варианте следует выполнить <math>O(\frac{n(n+1)}{2})</math> итераций.
Рассмотрим отдельную итерацию с точки зрения ярусно-параллельной формы алгоритма.

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

2)Выполнение 2 ярусов вычисления элементов в изменяемых строках и столбцах.

На данных двух ярусах осуществляется <math>4n</math> умножений и <math>2n</math> сложений. Данный вид параллелизма относится к координатному. Так как каждая последующая итерация алгоритма зависит от предыдущей, их выполнение распараллелить не представляется возможным. Таким образом, при наличии бесконечного числа процессоров, итоговая сложность алгоритма составляет <math>O(\frac{n(n+1)}{2})</math>

=== Входные и выходные данные алгоритма ===
'''Входные данные''': плотная матрица <math>A</math> (элементы <math>a_{ij}</math>); при этом <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>..

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы).
Конкретный вариант хранения данных зависит от реализации. В качестве примеров можно привести хранение в одномерном массиве длины <math>\frac{n (n + 1)}{2}</math> по строкам своей нижней части, хранение в виде так называемого ступенчатого массива (такой вариант двумерного массива, в котором каждая строка имеет свой размер).

'''Выходные данные''': вектор собственных значений <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>) длины <math>n</math>.

=== Свойства алгоритма ===
Параллельная сложность выполнения алгоритма составляет <math>O(\frac{n(n+1)}{2}).</math>
Последовательная сложность выполнения алгоритма составляет <math>O(\frac{n^2(n+1)}{2}).</math>
Таким образом, соотношение сложностей является линейным.
Более того, и вычислительная мощность данного алгоритма линейна.

В алгоритме используется примерно в два раза больше операций умножения, чем сложения.
Одельно стоит рассмотреть вопрос хранения матрицы А в процессе работы алгоритма. Хранение лишь нижней или верхней части матрицы в виде одномерного массива возможно; более того, хранение в таком виде обеспечивает экономию памяти в 2 раза и защищает от ассиметричности матрицы в результате накопления математических ошибок. Однако, вычисление индексов <math>i</math> и <math>j</math> элементов <math>a_{ij}</math>, соответствующих данному номеру <math>k</math> вообще говоря требует отдельного цикла, что создает дополнительную нагрузку на процессор.

Кроме того, следует отметить следующие особенности алгоритма:

1)Несмотря на то, что выбор наибольшего наддиагонального элемента, как кандидата на обнуление, кажется оптимальным, на самом деле он таковым не является. При таком выборе элемента, на каждой итерации необходимо находить текущий наибольший элемент в матрице, что требует дополнительных <math>\frac{n*(n-1)}{2}</math> операций сравнения и приводит к увеличению сложности алгоритма до <math>O(n^4)</math>. Вместо этого рекомендуется перебирать по очереди все наддиагональные элементы, большие заданного параметра. В большинстве случаев от 4 до 8 полных проходов достаточно для приближения исходной матрицы к диагональной.

2)Если при выборе в качестве обнуляемого элемента <math>a_{ij}</math> элементы <math>a_{ii} = a_{jj}</math>, то, как видно из формул в пунктах выше, матрицы поворота вырождаются в единичные и матрица на данной итерации не изменяется. Это еще один довод в пользу отказа от выбора наибольшего элемента, т.к. в данном случае произойдет зацикливание алгоритма.

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

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

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

==== Локальность реализации алгоритма ====

===== Структура обращений в память и качественная оценка локальности =====

===== Количественная оценка локальности =====

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

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

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

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

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

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

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

1)Библиотека [https://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE] содержит последовательную реализацию алгоритма.

2)В цифровой библиотеке ieee.org приводится [http://ieeexplore.ieee.org/document/6310877/ аннотация] статьи 2012 года, в которой авторы описывают реализацию данного алгоритма на CUDA.

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

Обсуждение участника:Зиновьев Владимир

2016-10-27T21:08:32Z

Пронин Андрей: /* Замечания по тексту */

== Статья [[Метод Якоби вычисления собственных значений симметричной матрицы ЗП]] ==

=== Замечания по тексту ===
* Рисунок 3. Структура блока Rotate не является информационным графом: непонятно, что такое "Точка синхронизации потоков" и каким образом в этой вершине используются данные из всех вершин "Вычисление элемента матрицы". [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 10:45, 25 октября 2016 (MSK)

===Исправления===
*Блок Rotate и текст в пункте 1.7 переделаны с учетом замечаний выше.

Обсуждение участника:Зиновьев Владимир

2016-10-27T21:07:52Z

Пронин Андрей: /* Статья Метод Якоби вычисления собственных значений симметричной матрицы ЗП */

== Статья [[Метод Якоби вычисления собственных значений симметричной матрицы ЗП]] ==

=== Замечания по тексту ===
* Рисунок 3. Структура блока Rotate не является информационным графом: непонятно, что такое "Точка синхронизации потоков" и каким образом в этой вершине используются данные из всех вершин "Вычисление элемента матрицы". [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 10:45, 25 октября 2016 (MSK)

*Блок Rotate и текст в пункте 1.7 переделаны с учетом замечаний выше.

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-10-27T20:54:34Z

Пронин Андрей: /* Информационный граф */

{{algorithm
| name = Метод Якоби вычисления собственных значений симметричной матрицы ЗП
| serial_complexity = <math>O(n^3)</math>
| pf_height = <math>O(n^2)</math>
| pf_width = <math>2n</math>
| input_data = <math>n^2</math>
| output_data = <math>n</math>
}}

Авторы: [[Участник:Зиновьев Владимир|Зиновьев В.С.]] (написание кода, информационный граф, общее и мат описание алгоритма), [[Участник:Пронин Андрей|Пронин А.М.]] (написание кода, информационный граф, вычислительное ядро алгоритма, макроструктура алгоритма). В остальные разделы статьи вклад равноценный.

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

=== Общее описание алгоритма ===
Задача нахождения собственных значений и собственных векторов матриц(СЗВМ) является одной из основных задач для многих разделов физики. <ref>Чечин Г.М., Зехцер М.Ю. Собственные значения и собственные векторы матриц</ref> С такой вычислительной проблемой приходится сталкиваться, например, при исследовании собственных колебаний различных механических систем, колебательных и электронных спектров молекул и кристаллов. Совершенно принципиальное значение эта проблема приобрела после создания в тридцатых годах прошлого века квантовой механики, которая стала базовой дисциплиной исследования микромира.Кроме того, данная проблема важна в теории автоматического управления, как инструмент исследования устойчивости линейных систем.

Метод Якоби приводит симметричную действительную матрицу к диагональной форме с помощью некоторой (в принципе, бесконечной) последовательности плоских вращений в разных плоскостях исходного n-мерного векторного пространства. Метод Якоби состоит из некоторой последовательности шагов, на каждом из которых обнуляется один из внедиагональных элементов (обычно наибольший по модулю), в результате чего старая матрица <math>A_{i}</math> преобразуется в некоторую новую матрицу <math>A_{i+1}</math>. Делается это с помощью преобразования подобия, использующего матрицу плоского вращения <math>J_{i}</math> (подробное описание матрицы плоского вращения приведено ниже в разделе "[[#Математическое описание алгоритма|Математическое описание алгоритма]]"), которая изменяет лишь две координаты <math>n</math>-мерных векторов, а именно, координаты с номерами <math>j</math> и <math>k</math>. При таком шаге матрица <math>A_{i+1}</math> отличается от матрицы <math>A_{i}</math> лишь элементами двух строк с номерами <math>j</math>, <math>k</math> и двух столбцов с теми же номерами (<math>j</math> и <math>k</math>). Все же другие элементы матрицы A остаются неизменными. Число шагов, за которое матрица A приводится таким способом к диагональной форме, в общем случае является бесконечным. (это свойство метода Якоби более подробно рассмотрено в разделе "[[#Свойства алгоритма|Свойства алгоритма]]") В результате метод Якоби представляет собой некоторый бесконечный итерационный процесс, на каждом шаге которого преобразующаяся матрица становится всё более и более близкой к диагональной форме (в смысле уменьшения суммы квадратов всех своих внедиагональных элементов). На практике обычно выбирается заранее заданная погрешность <math>\varepsilon</math> и процесс приведения исходной матрицы к диагональному виду прекращается, когда наибольший по модулю внедиагональный элемент матрицы становится меньше <math>\varepsilon</math>. Таким образом, применяя на практике метод Якоби, мы приводим исходную матрицу к диагональной форме с точностью до некоторой вычислительной погрешности <math>\varepsilon</math> в результате конечного числа шагов. Повышение этой точности требует увеличения числа шагов метода Якоби. В конечном итоге у полученной в результате этого процесса матрицы на диагонали будут находиться все собственные значения (с определённой погрешностью) исходной симметрической матрицы.

==== Симметричность матрицы ====

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

=== Математическое описание алгоритма ===
Пусть <math>A = A_0</math> — симметричная матрица. В методе Якоби для <math>A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,...</math>, которая в конечном счёте сходится к диагональной матрице, у которой диагональными элементами являются все собственные значения матрицы <math>A</math>. Матрица <math>A_{i}</math> получается из матрицы <math>A_{i-1}</math> по формуле
<math>A_{i}=J^{T}_iA_{i-1}J_i ,</math>
где <math>J_i</math> - ортогональная матрица, называемая ''вращением Якоби''. Таким образом,
<math>A_{m}=J^{T}_{m-1}A_{m-1}J_{m-1}</math>
<math>=J^{T}_{m-1}J^{T}_{m-2}A_{m-2}J_{m-2}J_{m-1}</math>
<math>=J^{T}_{m-1}...J^{T}_{0}A_{0}J_{0}...J_{m-1}</math>
<math>=J^{T}AJ</math>
При подходящем выборе вращений <math>J_i</math> матрица <math>A_m</math> для больших <math>m</math> будет близкой к диагональной матрице <math>\Lambda</math> <ref>Дж. Деммель, Вычислительная линейная алгебра. Теория и приложения. Перевод Х.Д.Икрамов</ref>. Таким образом, <math>\Lambda \approx J^{T}AJ</math> или <math>J\Lambda J^{T} \approx A</math>, следовательно, столбцы матрицы <math>J</math> являются собственными значениями матрицы <math>A</math>.
Матрица <math>J_i</math> выбирается таким образом, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}=J^{T}_{i}A_{i}J_{i}</math>:

                                                                            
<math>j</math>
                       
<math>k</math>

<math>
J_i = R(j,k,\theta) \equiv
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & -\sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Угол вращения <math>\theta</math> выбирается так, чтобы элементы <math>(j,k)</math> и <math>(k,j)</math> в <math>A_{i+1}</math> стали нулями. Для того, чтобы найти <math>\theta</math>, составляется уравнение:
:<math>
\begin{bmatrix}
a^{i+1}_{jj}&a^{i+1}_{jk}\\
a^{i+1}_{kj}&a^{i+1}_{kk}\\
\end{bmatrix} =
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix}^T
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix}
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix} =
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} ,
</math>
где <math>\lambda_1</math> и <math>\lambda_2</math> - собственные значения подматрицы
:<math>
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix} .
</math>
Пусть <math>c = \cos(\theta)</math> и <math>s = sin(\theta)</math>, <math>a^{i}_{lk} = a_{lk}</math>. Тогда из предыдущего равенства получаем
:<math>
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} =
\begin{bmatrix}
a_{jj}c^2 + a_{kk}s^2+2sca_{jk}&sc(a_{kk} - a{jj}) + a_{jk}(c^2-s^2)\\
sc(a_{kk} - a{jj}) + a_{jk}(c^2-s^2)&a_{jj}s^2 + a_{kk}c^2-2sca_{jk}\\
\end{bmatrix}
.
</math>
Приравнивая внедиагональный элемент к нулю, получаем
:<math>
\frac{a_{jj} - a{kk}}{2a_{jk}} = \frac{c^2-s^2}{2sc} = ctg(2\theta) = r.
</math>
Пусть <math>tg(\theta) = t = \frac{s}{c}</math> . Заметим, что выполняется квадратное уравнение <math>t^2 + 2rt - 1 = 0</math> . Решая уравнение, получаем <math>t = \frac{sign(r)}{|r| + \sqrt{1+r^2}}</math> . Следовательно <math>c = \frac{1}{\sqrt{1+t^2}}</math>, <math>s = ct</math>

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

Вычислительным ядром отдельной итерации является вычисление элементов матрицы <math>A</math> при применении поворота Якоби. Конкретно, изменяются 2 строки и 2 столбца, что означает изменение 4n элементов. Отметим, что вычисление нового значения одного элемента требует 2 операции умножения и одну операцию сложения, что позволяет утверждать, что основной вклад в вычислительное ядро вносят умножения.
Однако в целом, следует отметить, что число операций в алгоритме во многом определяется общим числом итераций, а оно квадратично, в то время как отдельная итерация имеет линейную сложность. Более того, так как алгоритм является итерационным и останавливается при достижении некоторой точности, число итераций может изменяться в зависимости от желаемой точности.

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

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

1) Блок вычисления параметров вращения на текущей итерации (выбор обнуляемого элемента и расчет угла вращения).

2)Блок, реализующий непосредственно вращение Якоби.

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

1)Находится максимальный наддиагональный элемент <math>a_{jk}</math> матрицы <math>A</math>.

2)Вычисляются параметры вращения Якоби:
<math>\tau= \frac{(a_{jj}-a_{kk})}{2a_{jk}}</math>
<math>t=sign(\tau)(|\tau|+\sqrt{1+\tau^2})</math>
<math>c= \frac{1}{1+\sqrt{1+\tau^2}}</math>
<math>s=c*t</math>

3)К текущей матрице А применяются вращения с вычисленными параметрами:
<math>A=R^T(j,k,\theta)*A*R(j,k,\theta)</math>
Стоит отметить, что вычисленные на предыдущем шаге <math>c</math> и <math>s</math> есть <math>\cos {\theta}</math> и <math>\sin {\theta}</math> соответственно.

4)Если матрица А не достаточно близка к диагональной, происходит переход к шагу 1.

Вообще говоря, несмотря на то, что поворот, обеспечивающий обнуление наибольшего внедиагонального элемента, обеспечивает схождение метода за наименьшее число итераций, поиск данного наибольшего элемента добавляет порядка <math>n^2</math> операций сравнения, а возможно и присваивания на каждой итерации.
Поэтому с вычислительной точки зрения выгоднее не выбирать наибольший элемент, а по очереди перебирать все наддиагональные элементы, большие заданного порога.

В последующих разделах рассматривается именно такой вариант алгоритма.

=== Последовательная сложность алгоритма ===
Сначала оценим сложность одной итерации:

1)Так как элементы матрицы никак не упорядоченны, поиск наибольшего элемента линейно зависит от числа элементов над диагональю.
Конкретнее, на данном шаге происходит <math>\frac{n*(n-1)}{2} -1</math> сравнение.

2)3 операции деления, 2 операции взятия корня, 4 операции умножения и 4 операции сложения/вычитания.

3)<math>4*n</math> операций умножения и <math>2*n</math> операций сложения.

4)операция сравнения

В наиболее неудачном случае количество итераций в теории равняется числу наддиагональных элементов, т.е. <math>\frac{n*(n-1)}{2}</math>
На практике же из-за накопления ошибок вычисления а так же восстановления уже обнуленных элементов при некоторых вращениях, число операций возрастает.
Вместе с тем, можно утверждать, что порядок числа итераций можно оценить как <math>O(N^2)</math>.
Таким образом, суммарная сложность алгоритма составляет <math>O(N^4)</math> сравнений, и <math>O(N^3)</math> сложений и умножений.

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

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

Аналитически информационный граф данного алгоритма можно описать следующим образом:

1)Последовательно идущие макроярусы вычисления параметров текущей итерации и вращения Якоби с этими параметрами
Число данных ярусов варьируется в зависимости от входных данных, но порядок составляет <math>O(n^2)</math>.

2)Вычисление параметров текущей итерации содержит конечное число операций умножения, сложения и вычисления квадратного корня.

3)Макроярус вращения Якоби содержит вычисление <math>2n+2</math> элементов матрицы и <math>2n-2</math> операций присваивания. На данном ярусе ширина графа достигает максимального значения. Вначале вычисляются значения в строках <math>j</math> и <math>k</math> (это соответствует умножению матрицы <math>R^T</math> на матрицу <math>A</math>). Далее, в силу того, что при умножении результата на матрицу <math>A</math> изменяются только столбцы <math>j</math> и <math>k</math> и итоговая матрица симметрична, можно не пересчитывать значения в столбцах, а получить их простым присваиванием по формуле: <math>a_{pk}=a_{kp}</math>, <math>a_{pj}=a_{jp}</math>, <math>p \neq k,j</math>. Для элементов <math>a_{jj}</math> и <math>a_{kk}</math> необходимо произвести вычисления, аналогичные вычислениям для элементов строк.

Визуальное представление графа алгоритма представлено на схемах ниже:

[[file:SI.jpg|thumb|center|1400px|Рисунок 1. Граф алгоритма на макроуровне. Rarams - вычисление параметров, Rotate - получение <math>A_{i+1}</math> из <math>A_{i}</math>.]]

[[file:exec_params.jpg|thumb|center|1400px|Рисунок 2. Структура блока Params.]]

[[file:ROT1.png|thumb|center|1400px|Рисунок 3. Структура блока Rotate.]]

=== Ресурс параллелизма алгоритма ===
Как видно из представления алгоритма в ярусно-параллельной форме ([[#Информационный граф| п.1.7]]), максимальная ширина ярусов составляет <math>2n</math> вершин.
Для выполнения данного алгоритма в параллельном варианте следует выполнить <math>O(\frac{n(n+1)}{2})</math> итераций.
Рассмотрим отдельную итерацию с точки зрения ярусно-параллельной формы алгоритма.

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

2)Выполнение 2 ярусов вычисления элементов в изменяемых строках и столбцах.

На данных двух ярусах осуществляется <math>4n</math> умножений и <math>2n</math> сложений. Данный вид параллелизма относится к координатному. Так как каждая последующая итерация алгоритма зависит от предыдущей, их выполнение распараллелить не представляется возможным. Таким образом, при наличии бесконечного числа процессоров, итоговая сложность алгоритма составляет <math>O(\frac{n(n+1)}{2})</math>

=== Входные и выходные данные алгоритма ===
'''Входные данные''': плотная матрица <math>A</math> (элементы <math>a_{ij}</math>); при этом <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>..

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы).
Конкретный вариант хранения данных зависит от реализации. В качестве примеров можно привести хранение в одномерном массиве длины <math>\frac{n (n + 1)}{2}</math> по строкам своей нижней части, хранение в виде так называемого ступенчатого массива (такой вариант двумерного массива, в котором каждая строка имеет свой размер).

'''Выходные данные''': вектор собственных значений <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>) длины <math>n</math>.

=== Свойства алгоритма ===
Параллельная сложность выполнения алгоритма составляет <math>O(\frac{n(n+1)}{2}).</math>
Последовательная сложность выполнения алгоритма составляет <math>O(\frac{n^2(n+1)}{2}).</math>
Таким образом, соотношение сложностей является линейным.
Более того, и вычислительная мощность данного алгоритма линейна.

В алгоритме используется примерно в два раза больше операций умножения, чем сложения.
Одельно стоит рассмотреть вопрос хранения матрицы А в процессе работы алгоритма. Хранение лишь нижней или верхней части матрицы в виде одномерного массива возможно; более того, хранение в таком виде обеспечивает экономию памяти в 2 раза и защищает от ассиметричности матрицы в результате накопления математических ошибок. Однако, вычисление индексов <math>i</math> и <math>j</math> элементов <math>a_{ij}</math>, соответствующих данному номеру <math>k</math> вообще говоря требует отдельного цикла, что создает дополнительную нагрузку на процессор.

Кроме того, следует отметить следующие особенности алгоритма:

1)Несмотря на то, что выбор наибольшего наддиагонального элемента, как кандидата на обнуление, кажется оптимальным, на самом деле он таковым не является. При таком выборе элемента, на каждой итерации необходимо находить текущий наибольший элемент в матрице, что требует дополнительных <math>\frac{n*(n-1)}{2}</math> операций сравнения и приводит к увеличению сложности алгоритма до <math>O(n^4)</math>. Вместо этого рекомендуется перебирать по очереди все наддиагональные элементы, большие заданного параметра. В большинстве случаев от 4 до 8 полных проходов достаточно для приближения исходной матрицы к диагональной.

2)Если при выборе в качестве обнуляемого элемента <math>a_{ij}</math> элементы <math>a_{ii} = a_{jj}</math>, то, как видно из формул в пунктах выше, матрицы поворота вырождаются в единичные и матрица на данной итерации не изменяется. Это еще один довод в пользу отказа от выбора наибольшего элемента, т.к. в данном случае произойдет зацикливание алгоритма.

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

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

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

==== Локальность реализации алгоритма ====

===== Структура обращений в память и качественная оценка локальности =====

===== Количественная оценка локальности =====

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

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

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

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

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

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

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

1)Библиотека [https://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE] содержит последовательную реализацию алгоритма.

2)В цифровой библиотеке ieee.org приводится [http://ieeexplore.ieee.org/document/6310877/ аннотация] статьи 2012 года, в которой авторы описывают реализацию данного алгоритма на CUDA.

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

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-10-27T20:44:58Z

Пронин Андрей: /* Информационный граф */

{{algorithm
| name = Метод Якоби вычисления собственных значений симметричной матрицы ЗП
| serial_complexity = <math>O(n^3)</math>
| pf_height = <math>O(n^2)</math>
| pf_width = <math>2n</math>
| input_data = <math>n^2</math>
| output_data = <math>n</math>
}}

Авторы: [[Участник:Зиновьев Владимир|Зиновьев В.С.]] (написание кода, информационный граф, общее и мат описание алгоритма), [[Участник:Пронин Андрей|Пронин А.М.]] (написание кода, информационный граф, вычислительное ядро алгоритма, макроструктура алгоритма). В остальные разделы статьи вклад равноценный.

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

=== Общее описание алгоритма ===
Задача нахождения собственных значений и собственных векторов матриц(СЗВМ) является одной из основных задач для многих разделов физики. <ref>Чечин Г.М., Зехцер М.Ю. Собственные значения и собственные векторы матриц</ref> С такой вычислительной проблемой приходится сталкиваться, например, при исследовании собственных колебаний различных механических систем, колебательных и электронных спектров молекул и кристаллов. Совершенно принципиальное значение эта проблема приобрела после создания в тридцатых годах прошлого века квантовой механики, которая стала базовой дисциплиной исследования микромира.Кроме того, данная проблема важна в теории автоматического управления, как инструмент исследования устойчивости линейных систем.

Метод Якоби приводит симметричную действительную матрицу к диагональной форме с помощью некоторой (в принципе, бесконечной) последовательности плоских вращений в разных плоскостях исходного n-мерного векторного пространства. Метод Якоби состоит из некоторой последовательности шагов, на каждом из которых обнуляется один из внедиагональных элементов (обычно наибольший по модулю), в результате чего старая матрица <math>A_{i}</math> преобразуется в некоторую новую матрицу <math>A_{i+1}</math>. Делается это с помощью преобразования подобия, использующего матрицу плоского вращения <math>J_{i}</math> (подробное описание матрицы плоского вращения приведено ниже в разделе "[[#Математическое описание алгоритма|Математическое описание алгоритма]]"), которая изменяет лишь две координаты <math>n</math>-мерных векторов, а именно, координаты с номерами <math>j</math> и <math>k</math>. При таком шаге матрица <math>A_{i+1}</math> отличается от матрицы <math>A_{i}</math> лишь элементами двух строк с номерами <math>j</math>, <math>k</math> и двух столбцов с теми же номерами (<math>j</math> и <math>k</math>). Все же другие элементы матрицы A остаются неизменными. Число шагов, за которое матрица A приводится таким способом к диагональной форме, в общем случае является бесконечным. (это свойство метода Якоби более подробно рассмотрено в разделе "[[#Свойства алгоритма|Свойства алгоритма]]") В результате метод Якоби представляет собой некоторый бесконечный итерационный процесс, на каждом шаге которого преобразующаяся матрица становится всё более и более близкой к диагональной форме (в смысле уменьшения суммы квадратов всех своих внедиагональных элементов). На практике обычно выбирается заранее заданная погрешность <math>\varepsilon</math> и процесс приведения исходной матрицы к диагональному виду прекращается, когда наибольший по модулю внедиагональный элемент матрицы становится меньше <math>\varepsilon</math>. Таким образом, применяя на практике метод Якоби, мы приводим исходную матрицу к диагональной форме с точностью до некоторой вычислительной погрешности <math>\varepsilon</math> в результате конечного числа шагов. Повышение этой точности требует увеличения числа шагов метода Якоби. В конечном итоге у полученной в результате этого процесса матрицы на диагонали будут находиться все собственные значения (с определённой погрешностью) исходной симметрической матрицы.

==== Симметричность матрицы ====

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

=== Математическое описание алгоритма ===
Пусть <math>A = A_0</math> — симметричная матрица. В методе Якоби для <math>A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,...</math>, которая в конечном счёте сходится к диагональной матрице, у которой диагональными элементами являются все собственные значения матрицы <math>A</math>. Матрица <math>A_{i}</math> получается из матрицы <math>A_{i-1}</math> по формуле
<math>A_{i}=J^{T}_iA_{i-1}J_i ,</math>
где <math>J_i</math> - ортогональная матрица, называемая ''вращением Якоби''. Таким образом,
<math>A_{m}=J^{T}_{m-1}A_{m-1}J_{m-1}</math>
<math>=J^{T}_{m-1}J^{T}_{m-2}A_{m-2}J_{m-2}J_{m-1}</math>
<math>=J^{T}_{m-1}...J^{T}_{0}A_{0}J_{0}...J_{m-1}</math>
<math>=J^{T}AJ</math>
При подходящем выборе вращений <math>J_i</math> матрица <math>A_m</math> для больших <math>m</math> будет близкой к диагональной матрице <math>\Lambda</math> <ref>Дж. Деммель, Вычислительная линейная алгебра. Теория и приложения. Перевод Х.Д.Икрамов</ref>. Таким образом, <math>\Lambda \approx J^{T}AJ</math> или <math>J\Lambda J^{T} \approx A</math>, следовательно, столбцы матрицы <math>J</math> являются собственными значениями матрицы <math>A</math>.
Матрица <math>J_i</math> выбирается таким образом, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}=J^{T}_{i}A_{i}J_{i}</math>:

                                                                            
<math>j</math>
                       
<math>k</math>

<math>
J_i = R(j,k,\theta) \equiv
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & -\sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Угол вращения <math>\theta</math> выбирается так, чтобы элементы <math>(j,k)</math> и <math>(k,j)</math> в <math>A_{i+1}</math> стали нулями. Для того, чтобы найти <math>\theta</math>, составляется уравнение:
:<math>
\begin{bmatrix}
a^{i+1}_{jj}&a^{i+1}_{jk}\\
a^{i+1}_{kj}&a^{i+1}_{kk}\\
\end{bmatrix} =
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix}^T
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix}
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix} =
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} ,
</math>
где <math>\lambda_1</math> и <math>\lambda_2</math> - собственные значения подматрицы
:<math>
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix} .
</math>
Пусть <math>c = \cos(\theta)</math> и <math>s = sin(\theta)</math>, <math>a^{i}_{lk} = a_{lk}</math>. Тогда из предыдущего равенства получаем
:<math>
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} =
\begin{bmatrix}
a_{jj}c^2 + a_{kk}s^2+2sca_{jk}&sc(a_{kk} - a{jj}) + a_{jk}(c^2-s^2)\\
sc(a_{kk} - a{jj}) + a_{jk}(c^2-s^2)&a_{jj}s^2 + a_{kk}c^2-2sca_{jk}\\
\end{bmatrix}
.
</math>
Приравнивая внедиагональный элемент к нулю, получаем
:<math>
\frac{a_{jj} - a{kk}}{2a_{jk}} = \frac{c^2-s^2}{2sc} = ctg(2\theta) = r.
</math>
Пусть <math>tg(\theta) = t = \frac{s}{c}</math> . Заметим, что выполняется квадратное уравнение <math>t^2 + 2rt - 1 = 0</math> . Решая уравнение, получаем <math>t = \frac{sign(r)}{|r| + \sqrt{1+r^2}}</math> . Следовательно <math>c = \frac{1}{\sqrt{1+t^2}}</math>, <math>s = ct</math>

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

Вычислительным ядром отдельной итерации является вычисление элементов матрицы <math>A</math> при применении поворота Якоби. Конкретно, изменяются 2 строки и 2 столбца, что означает изменение 4n элементов. Отметим, что вычисление нового значения одного элемента требует 2 операции умножения и одну операцию сложения, что позволяет утверждать, что основной вклад в вычислительное ядро вносят умножения.
Однако в целом, следует отметить, что число операций в алгоритме во многом определяется общим числом итераций, а оно квадратично, в то время как отдельная итерация имеет линейную сложность. Более того, так как алгоритм является итерационным и останавливается при достижении некоторой точности, число итераций может изменяться в зависимости от желаемой точности.

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

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

1) Блок вычисления параметров вращения на текущей итерации (выбор обнуляемого элемента и расчет угла вращения).

2)Блок, реализующий непосредственно вращение Якоби.

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

1)Находится максимальный наддиагональный элемент <math>a_{jk}</math> матрицы <math>A</math>.

2)Вычисляются параметры вращения Якоби:
<math>\tau= \frac{(a_{jj}-a_{kk})}{2a_{jk}}</math>
<math>t=sign(\tau)(|\tau|+\sqrt{1+\tau^2})</math>
<math>c= \frac{1}{1+\sqrt{1+\tau^2}}</math>
<math>s=c*t</math>

3)К текущей матрице А применяются вращения с вычисленными параметрами:
<math>A=R^T(j,k,\theta)*A*R(j,k,\theta)</math>
Стоит отметить, что вычисленные на предыдущем шаге <math>c</math> и <math>s</math> есть <math>\cos {\theta}</math> и <math>\sin {\theta}</math> соответственно.

4)Если матрица А не достаточно близка к диагональной, происходит переход к шагу 1.

Вообще говоря, несмотря на то, что поворот, обеспечивающий обнуление наибольшего внедиагонального элемента, обеспечивает схождение метода за наименьшее число итераций, поиск данного наибольшего элемента добавляет порядка <math>n^2</math> операций сравнения, а возможно и присваивания на каждой итерации.
Поэтому с вычислительной точки зрения выгоднее не выбирать наибольший элемент, а по очереди перебирать все наддиагональные элементы, большие заданного порога.

В последующих разделах рассматривается именно такой вариант алгоритма.

=== Последовательная сложность алгоритма ===
Сначала оценим сложность одной итерации:

1)Так как элементы матрицы никак не упорядоченны, поиск наибольшего элемента линейно зависит от числа элементов над диагональю.
Конкретнее, на данном шаге происходит <math>\frac{n*(n-1)}{2} -1</math> сравнение.

2)3 операции деления, 2 операции взятия корня, 4 операции умножения и 4 операции сложения/вычитания.

3)<math>4*n</math> операций умножения и <math>2*n</math> операций сложения.

4)операция сравнения

В наиболее неудачном случае количество итераций в теории равняется числу наддиагональных элементов, т.е. <math>\frac{n*(n-1)}{2}</math>
На практике же из-за накопления ошибок вычисления а так же восстановления уже обнуленных элементов при некоторых вращениях, число операций возрастает.
Вместе с тем, можно утверждать, что порядок числа итераций можно оценить как <math>O(N^2)</math>.
Таким образом, суммарная сложность алгоритма составляет <math>O(N^4)</math> сравнений, и <math>O(N^3)</math> сложений и умножений.

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

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

Аналитически информационный граф данного алгоритма можно описать следующим образом:

1)Последовательно идущие макроярусы вычисления параметров текущей итерации и вращения Якоби с этими параметрами
Число данных ярусов варьируется в зависимости от входных данных, но порядок составляет <math>O(n^2)</math>.

2)Вычисление параметров текущей итерации содержит конечное число операций умножения, сложения и вычисления квадратного корня.

3)Макроярус вращения Якоби содержит вычисление <math>2n+2</math> элементов матрицы и <math>2n-2</math> операций присваивания. На данном ярусе ширина графа достигает максимального значения. Вначале вычисляются значения в строках <math>j</math> и <math>k</math> (это соответствует умножению матрицы <math>R^T</math> на матрицу <math>A</math>). Далее, в силу того, что при умножении результата на матрицу <math>A</math> изменяются только столбцы <math>j</math> и <math>k</math> и итоговая матрица симметрична, можно не пересчитывать значения в столбцах, а получить их простым присваиванием по формуле: <math>a_{pk}=a_{kp}</math>, <math>a_{pj}=a_{jp}</math>, <math>p!=k,j</math>. Для элементов <math>a_{jj}</math> и <math>a_{kk}</math> необходимо произвести вычисления, аналогичные вычислениям для элементов строк.

Визуальное представление графа алгоритма представлено на схемах ниже:

[[file:SI.jpg|thumb|center|1400px|Рисунок 1. Граф алгоритма на макроуровне. Rarams - вычисление параметров, Rotate - получение <math>A_{i+1}</math> из <math>A_{i}</math>.]]

[[file:exec_params.jpg|thumb|center|1400px|Рисунок 2. Структура блока Params.]]

[[file:Rotate.jpg|thumb|center|1400px|Рисунок 3. Структура блока Rotate.]]

=== Ресурс параллелизма алгоритма ===
Как видно из представления алгоритма в ярусно-параллельной форме ([[#Информационный граф| п.1.7]]), максимальная ширина ярусов составляет <math>2n</math> вершин.
Для выполнения данного алгоритма в параллельном варианте следует выполнить <math>O(\frac{n(n+1)}{2})</math> итераций.
Рассмотрим отдельную итерацию с точки зрения ярусно-параллельной формы алгоритма.

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

2)Выполнение 2 ярусов вычисления элементов в изменяемых строках и столбцах.

На данных двух ярусах осуществляется <math>4n</math> умножений и <math>2n</math> сложений. Данный вид параллелизма относится к координатному. Так как каждая последующая итерация алгоритма зависит от предыдущей, их выполнение распараллелить не представляется возможным. Таким образом, при наличии бесконечного числа процессоров, итоговая сложность алгоритма составляет <math>O(\frac{n(n+1)}{2})</math>

=== Входные и выходные данные алгоритма ===
'''Входные данные''': плотная матрица <math>A</math> (элементы <math>a_{ij}</math>); при этом <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>..

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы).
Конкретный вариант хранения данных зависит от реализации. В качестве примеров можно привести хранение в одномерном массиве длины <math>\frac{n (n + 1)}{2}</math> по строкам своей нижней части, хранение в виде так называемого ступенчатого массива (такой вариант двумерного массива, в котором каждая строка имеет свой размер).

'''Выходные данные''': вектор собственных значений <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>) длины <math>n</math>.

=== Свойства алгоритма ===
Параллельная сложность выполнения алгоритма составляет <math>O(\frac{n(n+1)}{2}).</math>
Последовательная сложность выполнения алгоритма составляет <math>O(\frac{n^2(n+1)}{2}).</math>
Таким образом, соотношение сложностей является линейным.
Более того, и вычислительная мощность данного алгоритма линейна.

В алгоритме используется примерно в два раза больше операций умножения, чем сложения.
Одельно стоит рассмотреть вопрос хранения матрицы А в процессе работы алгоритма. Хранение лишь нижней или верхней части матрицы в виде одномерного массива возможно; более того, хранение в таком виде обеспечивает экономию памяти в 2 раза и защищает от ассиметричности матрицы в результате накопления математических ошибок. Однако, вычисление индексов <math>i</math> и <math>j</math> элементов <math>a_{ij}</math>, соответствующих данному номеру <math>k</math> вообще говоря требует отдельного цикла, что создает дополнительную нагрузку на процессор.

Кроме того, следует отметить следующие особенности алгоритма:

1)Несмотря на то, что выбор наибольшего наддиагонального элемента, как кандидата на обнуление, кажется оптимальным, на самом деле он таковым не является. При таком выборе элемента, на каждой итерации необходимо находить текущий наибольший элемент в матрице, что требует дополнительных <math>\frac{n*(n-1)}{2}</math> операций сравнения и приводит к увеличению сложности алгоритма до <math>O(n^4)</math>. Вместо этого рекомендуется перебирать по очереди все наддиагональные элементы, большие заданного параметра. В большинстве случаев от 4 до 8 полных проходов достаточно для приближения исходной матрицы к диагональной.

2)Если при выборе в качестве обнуляемого элемента <math>a_{ij}</math> элементы <math>a_{ii} = a_{jj}</math>, то, как видно из формул в пунктах выше, матрицы поворота вырождаются в единичные и матрица на данной итерации не изменяется. Это еще один довод в пользу отказа от выбора наибольшего элемента, т.к. в данном случае произойдет зацикливание алгоритма.

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

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

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

==== Локальность реализации алгоритма ====

===== Структура обращений в память и качественная оценка локальности =====

===== Количественная оценка локальности =====

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

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

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

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

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

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

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

1)Библиотека [https://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE] содержит последовательную реализацию алгоритма.

2)В цифровой библиотеке ieee.org приводится [http://ieeexplore.ieee.org/document/6310877/ аннотация] статьи 2012 года, в которой авторы описывают реализацию данного алгоритма на CUDA.

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

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-10-27T20:44:31Z

Пронин Андрей: /* Информационный граф */

{{algorithm
| name = Метод Якоби вычисления собственных значений симметричной матрицы ЗП
| serial_complexity = <math>O(n^3)</math>
| pf_height = <math>O(n^2)</math>
| pf_width = <math>2n</math>
| input_data = <math>n^2</math>
| output_data = <math>n</math>
}}

Авторы: [[Участник:Зиновьев Владимир|Зиновьев В.С.]] (написание кода, информационный граф, общее и мат описание алгоритма), [[Участник:Пронин Андрей|Пронин А.М.]] (написание кода, информационный граф, вычислительное ядро алгоритма, макроструктура алгоритма). В остальные разделы статьи вклад равноценный.

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

=== Общее описание алгоритма ===
Задача нахождения собственных значений и собственных векторов матриц(СЗВМ) является одной из основных задач для многих разделов физики. <ref>Чечин Г.М., Зехцер М.Ю. Собственные значения и собственные векторы матриц</ref> С такой вычислительной проблемой приходится сталкиваться, например, при исследовании собственных колебаний различных механических систем, колебательных и электронных спектров молекул и кристаллов. Совершенно принципиальное значение эта проблема приобрела после создания в тридцатых годах прошлого века квантовой механики, которая стала базовой дисциплиной исследования микромира.Кроме того, данная проблема важна в теории автоматического управления, как инструмент исследования устойчивости линейных систем.

Метод Якоби приводит симметричную действительную матрицу к диагональной форме с помощью некоторой (в принципе, бесконечной) последовательности плоских вращений в разных плоскостях исходного n-мерного векторного пространства. Метод Якоби состоит из некоторой последовательности шагов, на каждом из которых обнуляется один из внедиагональных элементов (обычно наибольший по модулю), в результате чего старая матрица <math>A_{i}</math> преобразуется в некоторую новую матрицу <math>A_{i+1}</math>. Делается это с помощью преобразования подобия, использующего матрицу плоского вращения <math>J_{i}</math> (подробное описание матрицы плоского вращения приведено ниже в разделе "[[#Математическое описание алгоритма|Математическое описание алгоритма]]"), которая изменяет лишь две координаты <math>n</math>-мерных векторов, а именно, координаты с номерами <math>j</math> и <math>k</math>. При таком шаге матрица <math>A_{i+1}</math> отличается от матрицы <math>A_{i}</math> лишь элементами двух строк с номерами <math>j</math>, <math>k</math> и двух столбцов с теми же номерами (<math>j</math> и <math>k</math>). Все же другие элементы матрицы A остаются неизменными. Число шагов, за которое матрица A приводится таким способом к диагональной форме, в общем случае является бесконечным. (это свойство метода Якоби более подробно рассмотрено в разделе "[[#Свойства алгоритма|Свойства алгоритма]]") В результате метод Якоби представляет собой некоторый бесконечный итерационный процесс, на каждом шаге которого преобразующаяся матрица становится всё более и более близкой к диагональной форме (в смысле уменьшения суммы квадратов всех своих внедиагональных элементов). На практике обычно выбирается заранее заданная погрешность <math>\varepsilon</math> и процесс приведения исходной матрицы к диагональному виду прекращается, когда наибольший по модулю внедиагональный элемент матрицы становится меньше <math>\varepsilon</math>. Таким образом, применяя на практике метод Якоби, мы приводим исходную матрицу к диагональной форме с точностью до некоторой вычислительной погрешности <math>\varepsilon</math> в результате конечного числа шагов. Повышение этой точности требует увеличения числа шагов метода Якоби. В конечном итоге у полученной в результате этого процесса матрицы на диагонали будут находиться все собственные значения (с определённой погрешностью) исходной симметрической матрицы.

==== Симметричность матрицы ====

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

=== Математическое описание алгоритма ===
Пусть <math>A = A_0</math> — симметричная матрица. В методе Якоби для <math>A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,...</math>, которая в конечном счёте сходится к диагональной матрице, у которой диагональными элементами являются все собственные значения матрицы <math>A</math>. Матрица <math>A_{i}</math> получается из матрицы <math>A_{i-1}</math> по формуле
<math>A_{i}=J^{T}_iA_{i-1}J_i ,</math>
где <math>J_i</math> - ортогональная матрица, называемая ''вращением Якоби''. Таким образом,
<math>A_{m}=J^{T}_{m-1}A_{m-1}J_{m-1}</math>
<math>=J^{T}_{m-1}J^{T}_{m-2}A_{m-2}J_{m-2}J_{m-1}</math>
<math>=J^{T}_{m-1}...J^{T}_{0}A_{0}J_{0}...J_{m-1}</math>
<math>=J^{T}AJ</math>
При подходящем выборе вращений <math>J_i</math> матрица <math>A_m</math> для больших <math>m</math> будет близкой к диагональной матрице <math>\Lambda</math> <ref>Дж. Деммель, Вычислительная линейная алгебра. Теория и приложения. Перевод Х.Д.Икрамов</ref>. Таким образом, <math>\Lambda \approx J^{T}AJ</math> или <math>J\Lambda J^{T} \approx A</math>, следовательно, столбцы матрицы <math>J</math> являются собственными значениями матрицы <math>A</math>.
Матрица <math>J_i</math> выбирается таким образом, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}=J^{T}_{i}A_{i}J_{i}</math>:

                                                                            
<math>j</math>
                       
<math>k</math>

<math>
J_i = R(j,k,\theta) \equiv
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & -\sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Угол вращения <math>\theta</math> выбирается так, чтобы элементы <math>(j,k)</math> и <math>(k,j)</math> в <math>A_{i+1}</math> стали нулями. Для того, чтобы найти <math>\theta</math>, составляется уравнение:
:<math>
\begin{bmatrix}
a^{i+1}_{jj}&a^{i+1}_{jk}\\
a^{i+1}_{kj}&a^{i+1}_{kk}\\
\end{bmatrix} =
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix}^T
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix}
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix} =
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} ,
</math>
где <math>\lambda_1</math> и <math>\lambda_2</math> - собственные значения подматрицы
:<math>
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix} .
</math>
Пусть <math>c = \cos(\theta)</math> и <math>s = sin(\theta)</math>, <math>a^{i}_{lk} = a_{lk}</math>. Тогда из предыдущего равенства получаем
:<math>
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} =
\begin{bmatrix}
a_{jj}c^2 + a_{kk}s^2+2sca_{jk}&sc(a_{kk} - a{jj}) + a_{jk}(c^2-s^2)\\
sc(a_{kk} - a{jj}) + a_{jk}(c^2-s^2)&a_{jj}s^2 + a_{kk}c^2-2sca_{jk}\\
\end{bmatrix}
.
</math>
Приравнивая внедиагональный элемент к нулю, получаем
:<math>
\frac{a_{jj} - a{kk}}{2a_{jk}} = \frac{c^2-s^2}{2sc} = ctg(2\theta) = r.
</math>
Пусть <math>tg(\theta) = t = \frac{s}{c}</math> . Заметим, что выполняется квадратное уравнение <math>t^2 + 2rt - 1 = 0</math> . Решая уравнение, получаем <math>t = \frac{sign(r)}{|r| + \sqrt{1+r^2}}</math> . Следовательно <math>c = \frac{1}{\sqrt{1+t^2}}</math>, <math>s = ct</math>

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

Вычислительным ядром отдельной итерации является вычисление элементов матрицы <math>A</math> при применении поворота Якоби. Конкретно, изменяются 2 строки и 2 столбца, что означает изменение 4n элементов. Отметим, что вычисление нового значения одного элемента требует 2 операции умножения и одну операцию сложения, что позволяет утверждать, что основной вклад в вычислительное ядро вносят умножения.
Однако в целом, следует отметить, что число операций в алгоритме во многом определяется общим числом итераций, а оно квадратично, в то время как отдельная итерация имеет линейную сложность. Более того, так как алгоритм является итерационным и останавливается при достижении некоторой точности, число итераций может изменяться в зависимости от желаемой точности.

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

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

1) Блок вычисления параметров вращения на текущей итерации (выбор обнуляемого элемента и расчет угла вращения).

2)Блок, реализующий непосредственно вращение Якоби.

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

1)Находится максимальный наддиагональный элемент <math>a_{jk}</math> матрицы <math>A</math>.

2)Вычисляются параметры вращения Якоби:
<math>\tau= \frac{(a_{jj}-a_{kk})}{2a_{jk}}</math>
<math>t=sign(\tau)(|\tau|+\sqrt{1+\tau^2})</math>
<math>c= \frac{1}{1+\sqrt{1+\tau^2}}</math>
<math>s=c*t</math>

3)К текущей матрице А применяются вращения с вычисленными параметрами:
<math>A=R^T(j,k,\theta)*A*R(j,k,\theta)</math>
Стоит отметить, что вычисленные на предыдущем шаге <math>c</math> и <math>s</math> есть <math>\cos {\theta}</math> и <math>\sin {\theta}</math> соответственно.

4)Если матрица А не достаточно близка к диагональной, происходит переход к шагу 1.

Вообще говоря, несмотря на то, что поворот, обеспечивающий обнуление наибольшего внедиагонального элемента, обеспечивает схождение метода за наименьшее число итераций, поиск данного наибольшего элемента добавляет порядка <math>n^2</math> операций сравнения, а возможно и присваивания на каждой итерации.
Поэтому с вычислительной точки зрения выгоднее не выбирать наибольший элемент, а по очереди перебирать все наддиагональные элементы, большие заданного порога.

В последующих разделах рассматривается именно такой вариант алгоритма.

=== Последовательная сложность алгоритма ===
Сначала оценим сложность одной итерации:

1)Так как элементы матрицы никак не упорядоченны, поиск наибольшего элемента линейно зависит от числа элементов над диагональю.
Конкретнее, на данном шаге происходит <math>\frac{n*(n-1)}{2} -1</math> сравнение.

2)3 операции деления, 2 операции взятия корня, 4 операции умножения и 4 операции сложения/вычитания.

3)<math>4*n</math> операций умножения и <math>2*n</math> операций сложения.

4)операция сравнения

В наиболее неудачном случае количество итераций в теории равняется числу наддиагональных элементов, т.е. <math>\frac{n*(n-1)}{2}</math>
На практике же из-за накопления ошибок вычисления а так же восстановления уже обнуленных элементов при некоторых вращениях, число операций возрастает.
Вместе с тем, можно утверждать, что порядок числа итераций можно оценить как <math>O(N^2)</math>.
Таким образом, суммарная сложность алгоритма составляет <math>O(N^4)</math> сравнений, и <math>O(N^3)</math> сложений и умножений.

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

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

Аналитически информационный граф данного алгоритма можно описать следующим образом:

1)Последовательно идущие макроярусы вычисления параметров текущей итерации и вращения Якоби с этими параметрами
Число данных ярусов варьируется в зависимости от входных данных, но порядок составляет <math>O(n^2)</math>.

2)Вычисление параметров текущей итерации содержит конечное число операций умножения, сложения и вычисления квадратного корня.

3)Макроярус вращения Якоби содержит вычисление <math>2n+2</math> элементов матрицы и <math>2n-2</math> операций присваивания. На данном ярусе ширина графа достигает максимального значения. Вначале вычисляются значения в строках <math>j</math> и <math>k</math> (это соответствует умножению матрицы <math>R^T</math> на матрицу <math>A</math>). Далее, в силу того, что при умножении результата на матрицу А изменяются только столбцы <math>j</math> и <math>k</math> и итоговая матрица симметрична, можно не пересчитывать значения в столбцах, а получить их простым присваиванием по формуле: <math>a_{pk}=a_{kp}</math>, <math>a_{pj}=a_{jp}</math>, <math>p!=k,j</math>. Для элементов <math>a_{jj}</math> и <math>a_{kk}</math> необходимо произвести вычисления, аналогичные вычислениям для элементов строк.

Визуальное представление графа алгоритма представлено на схемах ниже:

[[file:SI.jpg|thumb|center|1400px|Рисунок 1. Граф алгоритма на макроуровне. Rarams - вычисление параметров, Rotate - получение <math>A_{i+1}</math> из <math>A_{i}</math>.]]

[[file:exec_params.jpg|thumb|center|1400px|Рисунок 2. Структура блока Params.]]

[[file:Rotate.jpg|thumb|center|1400px|Рисунок 3. Структура блока Rotate.]]

=== Ресурс параллелизма алгоритма ===
Как видно из представления алгоритма в ярусно-параллельной форме ([[#Информационный граф| п.1.7]]), максимальная ширина ярусов составляет <math>2n</math> вершин.
Для выполнения данного алгоритма в параллельном варианте следует выполнить <math>O(\frac{n(n+1)}{2})</math> итераций.
Рассмотрим отдельную итерацию с точки зрения ярусно-параллельной формы алгоритма.

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

2)Выполнение 2 ярусов вычисления элементов в изменяемых строках и столбцах.

На данных двух ярусах осуществляется <math>4n</math> умножений и <math>2n</math> сложений. Данный вид параллелизма относится к координатному. Так как каждая последующая итерация алгоритма зависит от предыдущей, их выполнение распараллелить не представляется возможным. Таким образом, при наличии бесконечного числа процессоров, итоговая сложность алгоритма составляет <math>O(\frac{n(n+1)}{2})</math>

=== Входные и выходные данные алгоритма ===
'''Входные данные''': плотная матрица <math>A</math> (элементы <math>a_{ij}</math>); при этом <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>..

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы).
Конкретный вариант хранения данных зависит от реализации. В качестве примеров можно привести хранение в одномерном массиве длины <math>\frac{n (n + 1)}{2}</math> по строкам своей нижней части, хранение в виде так называемого ступенчатого массива (такой вариант двумерного массива, в котором каждая строка имеет свой размер).

'''Выходные данные''': вектор собственных значений <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>) длины <math>n</math>.

=== Свойства алгоритма ===
Параллельная сложность выполнения алгоритма составляет <math>O(\frac{n(n+1)}{2}).</math>
Последовательная сложность выполнения алгоритма составляет <math>O(\frac{n^2(n+1)}{2}).</math>
Таким образом, соотношение сложностей является линейным.
Более того, и вычислительная мощность данного алгоритма линейна.

В алгоритме используется примерно в два раза больше операций умножения, чем сложения.
Одельно стоит рассмотреть вопрос хранения матрицы А в процессе работы алгоритма. Хранение лишь нижней или верхней части матрицы в виде одномерного массива возможно; более того, хранение в таком виде обеспечивает экономию памяти в 2 раза и защищает от ассиметричности матрицы в результате накопления математических ошибок. Однако, вычисление индексов <math>i</math> и <math>j</math> элементов <math>a_{ij}</math>, соответствующих данному номеру <math>k</math> вообще говоря требует отдельного цикла, что создает дополнительную нагрузку на процессор.

Кроме того, следует отметить следующие особенности алгоритма:

1)Несмотря на то, что выбор наибольшего наддиагонального элемента, как кандидата на обнуление, кажется оптимальным, на самом деле он таковым не является. При таком выборе элемента, на каждой итерации необходимо находить текущий наибольший элемент в матрице, что требует дополнительных <math>\frac{n*(n-1)}{2}</math> операций сравнения и приводит к увеличению сложности алгоритма до <math>O(n^4)</math>. Вместо этого рекомендуется перебирать по очереди все наддиагональные элементы, большие заданного параметра. В большинстве случаев от 4 до 8 полных проходов достаточно для приближения исходной матрицы к диагональной.

2)Если при выборе в качестве обнуляемого элемента <math>a_{ij}</math> элементы <math>a_{ii} = a_{jj}</math>, то, как видно из формул в пунктах выше, матрицы поворота вырождаются в единичные и матрица на данной итерации не изменяется. Это еще один довод в пользу отказа от выбора наибольшего элемента, т.к. в данном случае произойдет зацикливание алгоритма.

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

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

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

==== Локальность реализации алгоритма ====

===== Структура обращений в память и качественная оценка локальности =====

===== Количественная оценка локальности =====

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

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

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

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

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

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

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

1)Библиотека [https://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE] содержит последовательную реализацию алгоритма.

2)В цифровой библиотеке ieee.org приводится [http://ieeexplore.ieee.org/document/6310877/ аннотация] статьи 2012 года, в которой авторы описывают реализацию данного алгоритма на CUDA.

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

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-10-27T20:35:00Z

Пронин Андрей: /* Информационный граф */

{{algorithm
| name = Метод Якоби вычисления собственных значений симметричной матрицы ЗП
| serial_complexity = <math>O(n^3)</math>
| pf_height = <math>O(n^2)</math>
| pf_width = <math>2n</math>
| input_data = <math>n^2</math>
| output_data = <math>n</math>
}}

Авторы: [[Участник:Зиновьев Владимир|Зиновьев В.С.]] (написание кода, информационный граф, общее и мат описание алгоритма), [[Участник:Пронин Андрей|Пронин А.М.]] (написание кода, информационный граф, вычислительное ядро алгоритма, макроструктура алгоритма). В остальные разделы статьи вклад равноценный.

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

=== Общее описание алгоритма ===
Задача нахождения собственных значений и собственных векторов матриц(СЗВМ) является одной из основных задач для многих разделов физики. <ref>Чечин Г.М., Зехцер М.Ю. Собственные значения и собственные векторы матриц</ref> С такой вычислительной проблемой приходится сталкиваться, например, при исследовании собственных колебаний различных механических систем, колебательных и электронных спектров молекул и кристаллов. Совершенно принципиальное значение эта проблема приобрела после создания в тридцатых годах прошлого века квантовой механики, которая стала базовой дисциплиной исследования микромира.Кроме того, данная проблема важна в теории автоматического управления, как инструмент исследования устойчивости линейных систем.

Метод Якоби приводит симметричную действительную матрицу к диагональной форме с помощью некоторой (в принципе, бесконечной) последовательности плоских вращений в разных плоскостях исходного n-мерного векторного пространства. Метод Якоби состоит из некоторой последовательности шагов, на каждом из которых обнуляется один из внедиагональных элементов (обычно наибольший по модулю), в результате чего старая матрица <math>A_{i}</math> преобразуется в некоторую новую матрицу <math>A_{i+1}</math>. Делается это с помощью преобразования подобия, использующего матрицу плоского вращения <math>J_{i}</math> (подробное описание матрицы плоского вращения приведено ниже в разделе "[[#Математическое описание алгоритма|Математическое описание алгоритма]]"), которая изменяет лишь две координаты <math>n</math>-мерных векторов, а именно, координаты с номерами <math>j</math> и <math>k</math>. При таком шаге матрица <math>A_{i+1}</math> отличается от матрицы <math>A_{i}</math> лишь элементами двух строк с номерами <math>j</math>, <math>k</math> и двух столбцов с теми же номерами (<math>j</math> и <math>k</math>). Все же другие элементы матрицы A остаются неизменными. Число шагов, за которое матрица A приводится таким способом к диагональной форме, в общем случае является бесконечным. (это свойство метода Якоби более подробно рассмотрено в разделе "[[#Свойства алгоритма|Свойства алгоритма]]") В результате метод Якоби представляет собой некоторый бесконечный итерационный процесс, на каждом шаге которого преобразующаяся матрица становится всё более и более близкой к диагональной форме (в смысле уменьшения суммы квадратов всех своих внедиагональных элементов). На практике обычно выбирается заранее заданная погрешность <math>\varepsilon</math> и процесс приведения исходной матрицы к диагональному виду прекращается, когда наибольший по модулю внедиагональный элемент матрицы становится меньше <math>\varepsilon</math>. Таким образом, применяя на практике метод Якоби, мы приводим исходную матрицу к диагональной форме с точностью до некоторой вычислительной погрешности <math>\varepsilon</math> в результате конечного числа шагов. Повышение этой точности требует увеличения числа шагов метода Якоби. В конечном итоге у полученной в результате этого процесса матрицы на диагонали будут находиться все собственные значения (с определённой погрешностью) исходной симметрической матрицы.

==== Симметричность матрицы ====

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

=== Математическое описание алгоритма ===
Пусть <math>A = A_0</math> — симметричная матрица. В методе Якоби для <math>A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,...</math>, которая в конечном счёте сходится к диагональной матрице, у которой диагональными элементами являются все собственные значения матрицы <math>A</math>. Матрица <math>A_{i}</math> получается из матрицы <math>A_{i-1}</math> по формуле
<math>A_{i}=J^{T}_iA_{i-1}J_i ,</math>
где <math>J_i</math> - ортогональная матрица, называемая ''вращением Якоби''. Таким образом,
<math>A_{m}=J^{T}_{m-1}A_{m-1}J_{m-1}</math>
<math>=J^{T}_{m-1}J^{T}_{m-2}A_{m-2}J_{m-2}J_{m-1}</math>
<math>=J^{T}_{m-1}...J^{T}_{0}A_{0}J_{0}...J_{m-1}</math>
<math>=J^{T}AJ</math>
При подходящем выборе вращений <math>J_i</math> матрица <math>A_m</math> для больших <math>m</math> будет близкой к диагональной матрице <math>\Lambda</math> <ref>Дж. Деммель, Вычислительная линейная алгебра. Теория и приложения. Перевод Х.Д.Икрамов</ref>. Таким образом, <math>\Lambda \approx J^{T}AJ</math> или <math>J\Lambda J^{T} \approx A</math>, следовательно, столбцы матрицы <math>J</math> являются собственными значениями матрицы <math>A</math>.
Матрица <math>J_i</math> выбирается таким образом, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}=J^{T}_{i}A_{i}J_{i}</math>:

                                                                            
<math>j</math>
                       
<math>k</math>

<math>
J_i = R(j,k,\theta) \equiv
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & -\sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Угол вращения <math>\theta</math> выбирается так, чтобы элементы <math>(j,k)</math> и <math>(k,j)</math> в <math>A_{i+1}</math> стали нулями. Для того, чтобы найти <math>\theta</math>, составляется уравнение:
:<math>
\begin{bmatrix}
a^{i+1}_{jj}&a^{i+1}_{jk}\\
a^{i+1}_{kj}&a^{i+1}_{kk}\\
\end{bmatrix} =
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix}^T
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix}
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix} =
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} ,
</math>
где <math>\lambda_1</math> и <math>\lambda_2</math> - собственные значения подматрицы
:<math>
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix} .
</math>
Пусть <math>c = \cos(\theta)</math> и <math>s = sin(\theta)</math>, <math>a^{i}_{lk} = a_{lk}</math>. Тогда из предыдущего равенства получаем
:<math>
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} =
\begin{bmatrix}
a_{jj}c^2 + a_{kk}s^2+2sca_{jk}&sc(a_{kk} - a{jj}) + a_{jk}(c^2-s^2)\\
sc(a_{kk} - a{jj}) + a_{jk}(c^2-s^2)&a_{jj}s^2 + a_{kk}c^2-2sca_{jk}\\
\end{bmatrix}
.
</math>
Приравнивая внедиагональный элемент к нулю, получаем
:<math>
\frac{a_{jj} - a{kk}}{2a_{jk}} = \frac{c^2-s^2}{2sc} = ctg(2\theta) = r.
</math>
Пусть <math>tg(\theta) = t = \frac{s}{c}</math> . Заметим, что выполняется квадратное уравнение <math>t^2 + 2rt - 1 = 0</math> . Решая уравнение, получаем <math>t = \frac{sign(r)}{|r| + \sqrt{1+r^2}}</math> . Следовательно <math>c = \frac{1}{\sqrt{1+t^2}}</math>, <math>s = ct</math>

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

Вычислительным ядром отдельной итерации является вычисление элементов матрицы <math>A</math> при применении поворота Якоби. Конкретно, изменяются 2 строки и 2 столбца, что означает изменение 4n элементов. Отметим, что вычисление нового значения одного элемента требует 2 операции умножения и одну операцию сложения, что позволяет утверждать, что основной вклад в вычислительное ядро вносят умножения.
Однако в целом, следует отметить, что число операций в алгоритме во многом определяется общим числом итераций, а оно квадратично, в то время как отдельная итерация имеет линейную сложность. Более того, так как алгоритм является итерационным и останавливается при достижении некоторой точности, число итераций может изменяться в зависимости от желаемой точности.

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

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

1) Блок вычисления параметров вращения на текущей итерации (выбор обнуляемого элемента и расчет угла вращения).

2)Блок, реализующий непосредственно вращение Якоби.

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

1)Находится максимальный наддиагональный элемент <math>a_{jk}</math> матрицы <math>A</math>.

2)Вычисляются параметры вращения Якоби:
<math>\tau= \frac{(a_{jj}-a_{kk})}{2a_{jk}}</math>
<math>t=sign(\tau)(|\tau|+\sqrt{1+\tau^2})</math>
<math>c= \frac{1}{1+\sqrt{1+\tau^2}}</math>
<math>s=c*t</math>

3)К текущей матрице А применяются вращения с вычисленными параметрами:
<math>A=R^T(j,k,\theta)*A*R(j,k,\theta)</math>
Стоит отметить, что вычисленные на предыдущем шаге <math>c</math> и <math>s</math> есть <math>\cos {\theta}</math> и <math>\sin {\theta}</math> соответственно.

4)Если матрица А не достаточно близка к диагональной, происходит переход к шагу 1.

Вообще говоря, несмотря на то, что поворот, обеспечивающий обнуление наибольшего внедиагонального элемента, обеспечивает схождение метода за наименьшее число итераций, поиск данного наибольшего элемента добавляет порядка <math>n^2</math> операций сравнения, а возможно и присваивания на каждой итерации.
Поэтому с вычислительной точки зрения выгоднее не выбирать наибольший элемент, а по очереди перебирать все наддиагональные элементы, большие заданного порога.

В последующих разделах рассматривается именно такой вариант алгоритма.

=== Последовательная сложность алгоритма ===
Сначала оценим сложность одной итерации:

1)Так как элементы матрицы никак не упорядоченны, поиск наибольшего элемента линейно зависит от числа элементов над диагональю.
Конкретнее, на данном шаге происходит <math>\frac{n*(n-1)}{2} -1</math> сравнение.

2)3 операции деления, 2 операции взятия корня, 4 операции умножения и 4 операции сложения/вычитания.

3)<math>4*n</math> операций умножения и <math>2*n</math> операций сложения.

4)операция сравнения

В наиболее неудачном случае количество итераций в теории равняется числу наддиагональных элементов, т.е. <math>\frac{n*(n-1)}{2}</math>
На практике же из-за накопления ошибок вычисления а так же восстановления уже обнуленных элементов при некоторых вращениях, число операций возрастает.
Вместе с тем, можно утверждать, что порядок числа итераций можно оценить как <math>O(N^2)</math>.
Таким образом, суммарная сложность алгоритма составляет <math>O(N^4)</math> сравнений, и <math>O(N^3)</math> сложений и умножений.

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

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

Аналитически информационный граф данного алгоритма можно описать следующим образом:

1)Последовательно идущие макроярусы вычисления параметров текущей итерации и вращения Якоби с этими параметрами
Число данных ярусов варьируется в зависимости от входных данных, но порядок составляет <math>O(n^2)</math>.

2)Вычисление параметров текущей итерации содержит конечное число операций умножения, сложения и вычисления квадратного корня.

3)Макроярус вращения Якоби содержит вычисление <math>2n+2</math> элементов матрицы и <math>2n-2</math> операций присваивания. На данном ярусе ширина графа достигает максимального значения. Вначале вычисляются значения в строках <math>j</math> и <math>k</math> (это соответствует умножению матрицы <math>R^T</math> на матрицу <math>А</math>). Далее, в силу того, что при умножении результата на матрицу А изменяются только столбцы <math>j</math> и <math>k</math> и итоговая матрица симметрична, можно не пересчитывать значения в столбцах, а получить их простым присваиванием по формуле: <math>a_{pk}=a_{kp}</math>, <math>a_{pj}=a_{jp}</math>, <math>p!=k,j</math>. Для элементов <math>a_{jj}</math> и <math>a_{kk}</math> необходимо произвести вычисления, аналогичные вычислениям для элементов строк.

Визуальное представление графа алгоритма представлено на схемах ниже:

[[file:SI.jpg|thumb|center|1400px|Рисунок 1. Граф алгоритма на макроуровне. Rarams - вычисление параметров, Rotate - получение <math>A_{i+1}</math> из <math>A_{i}</math>.]]

[[file:exec_params.jpg|thumb|center|1400px|Рисунок 2. Структура блока Params.]]

[[file:Rotate.jpg|thumb|center|1400px|Рисунок 3. Структура блока Rotate.]]

=== Ресурс параллелизма алгоритма ===
Как видно из представления алгоритма в ярусно-параллельной форме ([[#Информационный граф| п.1.7]]), максимальная ширина ярусов составляет <math>2n</math> вершин.
Для выполнения данного алгоритма в параллельном варианте следует выполнить <math>O(\frac{n(n+1)}{2})</math> итераций.
Рассмотрим отдельную итерацию с точки зрения ярусно-параллельной формы алгоритма.

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

2)Выполнение 2 ярусов вычисления элементов в изменяемых строках и столбцах.

На данных двух ярусах осуществляется <math>4n</math> умножений и <math>2n</math> сложений. Данный вид параллелизма относится к координатному. Так как каждая последующая итерация алгоритма зависит от предыдущей, их выполнение распараллелить не представляется возможным. Таким образом, при наличии бесконечного числа процессоров, итоговая сложность алгоритма составляет <math>O(\frac{n(n+1)}{2})</math>

=== Входные и выходные данные алгоритма ===
'''Входные данные''': плотная матрица <math>A</math> (элементы <math>a_{ij}</math>); при этом <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>..

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы).
Конкретный вариант хранения данных зависит от реализации. В качестве примеров можно привести хранение в одномерном массиве длины <math>\frac{n (n + 1)}{2}</math> по строкам своей нижней части, хранение в виде так называемого ступенчатого массива (такой вариант двумерного массива, в котором каждая строка имеет свой размер).

'''Выходные данные''': вектор собственных значений <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>) длины <math>n</math>.

=== Свойства алгоритма ===
Параллельная сложность выполнения алгоритма составляет <math>O(\frac{n(n+1)}{2}).</math>
Последовательная сложность выполнения алгоритма составляет <math>O(\frac{n^2(n+1)}{2}).</math>
Таким образом, соотношение сложностей является линейным.
Более того, и вычислительная мощность данного алгоритма линейна.

В алгоритме используется примерно в два раза больше операций умножения, чем сложения.
Одельно стоит рассмотреть вопрос хранения матрицы А в процессе работы алгоритма. Хранение лишь нижней или верхней части матрицы в виде одномерного массива возможно; более того, хранение в таком виде обеспечивает экономию памяти в 2 раза и защищает от ассиметричности матрицы в результате накопления математических ошибок. Однако, вычисление индексов <math>i</math> и <math>j</math> элементов <math>a_{ij}</math>, соответствующих данному номеру <math>k</math> вообще говоря требует отдельного цикла, что создает дополнительную нагрузку на процессор.

Кроме того, следует отметить следующие особенности алгоритма:

1)Несмотря на то, что выбор наибольшего наддиагонального элемента, как кандидата на обнуление, кажется оптимальным, на самом деле он таковым не является. При таком выборе элемента, на каждой итерации необходимо находить текущий наибольший элемент в матрице, что требует дополнительных <math>\frac{n*(n-1)}{2}</math> операций сравнения и приводит к увеличению сложности алгоритма до <math>O(n^4)</math>. Вместо этого рекомендуется перебирать по очереди все наддиагональные элементы, большие заданного параметра. В большинстве случаев от 4 до 8 полных проходов достаточно для приближения исходной матрицы к диагональной.

2)Если при выборе в качестве обнуляемого элемента <math>a_{ij}</math> элементы <math>a_{ii} = a_{jj}</math>, то, как видно из формул в пунктах выше, матрицы поворота вырождаются в единичные и матрица на данной итерации не изменяется. Это еще один довод в пользу отказа от выбора наибольшего элемента, т.к. в данном случае произойдет зацикливание алгоритма.

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

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

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

==== Локальность реализации алгоритма ====

===== Структура обращений в память и качественная оценка локальности =====

===== Количественная оценка локальности =====

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

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

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

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

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

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

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

1)Библиотека [https://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE] содержит последовательную реализацию алгоритма.

2)В цифровой библиотеке ieee.org приводится [http://ieeexplore.ieee.org/document/6310877/ аннотация] статьи 2012 года, в которой авторы описывают реализацию данного алгоритма на CUDA.

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

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-10-27T20:34:16Z

Пронин Андрей: /* Информационный граф */

{{algorithm
| name = Метод Якоби вычисления собственных значений симметричной матрицы ЗП
| serial_complexity = <math>O(n^3)</math>
| pf_height = <math>O(n^2)</math>
| pf_width = <math>2n</math>
| input_data = <math>n^2</math>
| output_data = <math>n</math>
}}

Авторы: [[Участник:Зиновьев Владимир|Зиновьев В.С.]] (написание кода, информационный граф, общее и мат описание алгоритма), [[Участник:Пронин Андрей|Пронин А.М.]] (написание кода, информационный граф, вычислительное ядро алгоритма, макроструктура алгоритма). В остальные разделы статьи вклад равноценный.

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

=== Общее описание алгоритма ===
Задача нахождения собственных значений и собственных векторов матриц(СЗВМ) является одной из основных задач для многих разделов физики. <ref>Чечин Г.М., Зехцер М.Ю. Собственные значения и собственные векторы матриц</ref> С такой вычислительной проблемой приходится сталкиваться, например, при исследовании собственных колебаний различных механических систем, колебательных и электронных спектров молекул и кристаллов. Совершенно принципиальное значение эта проблема приобрела после создания в тридцатых годах прошлого века квантовой механики, которая стала базовой дисциплиной исследования микромира.Кроме того, данная проблема важна в теории автоматического управления, как инструмент исследования устойчивости линейных систем.

Метод Якоби приводит симметричную действительную матрицу к диагональной форме с помощью некоторой (в принципе, бесконечной) последовательности плоских вращений в разных плоскостях исходного n-мерного векторного пространства. Метод Якоби состоит из некоторой последовательности шагов, на каждом из которых обнуляется один из внедиагональных элементов (обычно наибольший по модулю), в результате чего старая матрица <math>A_{i}</math> преобразуется в некоторую новую матрицу <math>A_{i+1}</math>. Делается это с помощью преобразования подобия, использующего матрицу плоского вращения <math>J_{i}</math> (подробное описание матрицы плоского вращения приведено ниже в разделе "[[#Математическое описание алгоритма|Математическое описание алгоритма]]"), которая изменяет лишь две координаты <math>n</math>-мерных векторов, а именно, координаты с номерами <math>j</math> и <math>k</math>. При таком шаге матрица <math>A_{i+1}</math> отличается от матрицы <math>A_{i}</math> лишь элементами двух строк с номерами <math>j</math>, <math>k</math> и двух столбцов с теми же номерами (<math>j</math> и <math>k</math>). Все же другие элементы матрицы A остаются неизменными. Число шагов, за которое матрица A приводится таким способом к диагональной форме, в общем случае является бесконечным. (это свойство метода Якоби более подробно рассмотрено в разделе "[[#Свойства алгоритма|Свойства алгоритма]]") В результате метод Якоби представляет собой некоторый бесконечный итерационный процесс, на каждом шаге которого преобразующаяся матрица становится всё более и более близкой к диагональной форме (в смысле уменьшения суммы квадратов всех своих внедиагональных элементов). На практике обычно выбирается заранее заданная погрешность <math>\varepsilon</math> и процесс приведения исходной матрицы к диагональному виду прекращается, когда наибольший по модулю внедиагональный элемент матрицы становится меньше <math>\varepsilon</math>. Таким образом, применяя на практике метод Якоби, мы приводим исходную матрицу к диагональной форме с точностью до некоторой вычислительной погрешности <math>\varepsilon</math> в результате конечного числа шагов. Повышение этой точности требует увеличения числа шагов метода Якоби. В конечном итоге у полученной в результате этого процесса матрицы на диагонали будут находиться все собственные значения (с определённой погрешностью) исходной симметрической матрицы.

==== Симметричность матрицы ====

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

=== Математическое описание алгоритма ===
Пусть <math>A = A_0</math> — симметричная матрица. В методе Якоби для <math>A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,...</math>, которая в конечном счёте сходится к диагональной матрице, у которой диагональными элементами являются все собственные значения матрицы <math>A</math>. Матрица <math>A_{i}</math> получается из матрицы <math>A_{i-1}</math> по формуле
<math>A_{i}=J^{T}_iA_{i-1}J_i ,</math>
где <math>J_i</math> - ортогональная матрица, называемая ''вращением Якоби''. Таким образом,
<math>A_{m}=J^{T}_{m-1}A_{m-1}J_{m-1}</math>
<math>=J^{T}_{m-1}J^{T}_{m-2}A_{m-2}J_{m-2}J_{m-1}</math>
<math>=J^{T}_{m-1}...J^{T}_{0}A_{0}J_{0}...J_{m-1}</math>
<math>=J^{T}AJ</math>
При подходящем выборе вращений <math>J_i</math> матрица <math>A_m</math> для больших <math>m</math> будет близкой к диагональной матрице <math>\Lambda</math> <ref>Дж. Деммель, Вычислительная линейная алгебра. Теория и приложения. Перевод Х.Д.Икрамов</ref>. Таким образом, <math>\Lambda \approx J^{T}AJ</math> или <math>J\Lambda J^{T} \approx A</math>, следовательно, столбцы матрицы <math>J</math> являются собственными значениями матрицы <math>A</math>.
Матрица <math>J_i</math> выбирается таким образом, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}=J^{T}_{i}A_{i}J_{i}</math>:

                                                                            
<math>j</math>
                       
<math>k</math>

<math>
J_i = R(j,k,\theta) \equiv
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & -\sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Угол вращения <math>\theta</math> выбирается так, чтобы элементы <math>(j,k)</math> и <math>(k,j)</math> в <math>A_{i+1}</math> стали нулями. Для того, чтобы найти <math>\theta</math>, составляется уравнение:
:<math>
\begin{bmatrix}
a^{i+1}_{jj}&a^{i+1}_{jk}\\
a^{i+1}_{kj}&a^{i+1}_{kk}\\
\end{bmatrix} =
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix}^T
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix}
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix} =
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} ,
</math>
где <math>\lambda_1</math> и <math>\lambda_2</math> - собственные значения подматрицы
:<math>
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix} .
</math>
Пусть <math>c = \cos(\theta)</math> и <math>s = sin(\theta)</math>, <math>a^{i}_{lk} = a_{lk}</math>. Тогда из предыдущего равенства получаем
:<math>
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} =
\begin{bmatrix}
a_{jj}c^2 + a_{kk}s^2+2sca_{jk}&sc(a_{kk} - a{jj}) + a_{jk}(c^2-s^2)\\
sc(a_{kk} - a{jj}) + a_{jk}(c^2-s^2)&a_{jj}s^2 + a_{kk}c^2-2sca_{jk}\\
\end{bmatrix}
.
</math>
Приравнивая внедиагональный элемент к нулю, получаем
:<math>
\frac{a_{jj} - a{kk}}{2a_{jk}} = \frac{c^2-s^2}{2sc} = ctg(2\theta) = r.
</math>
Пусть <math>tg(\theta) = t = \frac{s}{c}</math> . Заметим, что выполняется квадратное уравнение <math>t^2 + 2rt - 1 = 0</math> . Решая уравнение, получаем <math>t = \frac{sign(r)}{|r| + \sqrt{1+r^2}}</math> . Следовательно <math>c = \frac{1}{\sqrt{1+t^2}}</math>, <math>s = ct</math>

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

Вычислительным ядром отдельной итерации является вычисление элементов матрицы <math>A</math> при применении поворота Якоби. Конкретно, изменяются 2 строки и 2 столбца, что означает изменение 4n элементов. Отметим, что вычисление нового значения одного элемента требует 2 операции умножения и одну операцию сложения, что позволяет утверждать, что основной вклад в вычислительное ядро вносят умножения.
Однако в целом, следует отметить, что число операций в алгоритме во многом определяется общим числом итераций, а оно квадратично, в то время как отдельная итерация имеет линейную сложность. Более того, так как алгоритм является итерационным и останавливается при достижении некоторой точности, число итераций может изменяться в зависимости от желаемой точности.

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

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

1) Блок вычисления параметров вращения на текущей итерации (выбор обнуляемого элемента и расчет угла вращения).

2)Блок, реализующий непосредственно вращение Якоби.

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

1)Находится максимальный наддиагональный элемент <math>a_{jk}</math> матрицы <math>A</math>.

2)Вычисляются параметры вращения Якоби:
<math>\tau= \frac{(a_{jj}-a_{kk})}{2a_{jk}}</math>
<math>t=sign(\tau)(|\tau|+\sqrt{1+\tau^2})</math>
<math>c= \frac{1}{1+\sqrt{1+\tau^2}}</math>
<math>s=c*t</math>

3)К текущей матрице А применяются вращения с вычисленными параметрами:
<math>A=R^T(j,k,\theta)*A*R(j,k,\theta)</math>
Стоит отметить, что вычисленные на предыдущем шаге <math>c</math> и <math>s</math> есть <math>\cos {\theta}</math> и <math>\sin {\theta}</math> соответственно.

4)Если матрица А не достаточно близка к диагональной, происходит переход к шагу 1.

Вообще говоря, несмотря на то, что поворот, обеспечивающий обнуление наибольшего внедиагонального элемента, обеспечивает схождение метода за наименьшее число итераций, поиск данного наибольшего элемента добавляет порядка <math>n^2</math> операций сравнения, а возможно и присваивания на каждой итерации.
Поэтому с вычислительной точки зрения выгоднее не выбирать наибольший элемент, а по очереди перебирать все наддиагональные элементы, большие заданного порога.

В последующих разделах рассматривается именно такой вариант алгоритма.

=== Последовательная сложность алгоритма ===
Сначала оценим сложность одной итерации:

1)Так как элементы матрицы никак не упорядоченны, поиск наибольшего элемента линейно зависит от числа элементов над диагональю.
Конкретнее, на данном шаге происходит <math>\frac{n*(n-1)}{2} -1</math> сравнение.

2)3 операции деления, 2 операции взятия корня, 4 операции умножения и 4 операции сложения/вычитания.

3)<math>4*n</math> операций умножения и <math>2*n</math> операций сложения.

4)операция сравнения

В наиболее неудачном случае количество итераций в теории равняется числу наддиагональных элементов, т.е. <math>\frac{n*(n-1)}{2}</math>
На практике же из-за накопления ошибок вычисления а так же восстановления уже обнуленных элементов при некоторых вращениях, число операций возрастает.
Вместе с тем, можно утверждать, что порядок числа итераций можно оценить как <math>O(N^2)</math>.
Таким образом, суммарная сложность алгоритма составляет <math>O(N^4)</math> сравнений, и <math>O(N^3)</math> сложений и умножений.

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

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

Аналитически информационный граф данного алгоритма можно описать следующим образом:

1)Последовательно идущие макроярусы вычисления параметров текущей итерации и вращения Якоби с этими параметрами
Число данных ярусов варьируется в зависимости от входных данных, но порядок составляет <math>O(n^2)</math>.

2)Вычисление параметров текущей итерации содержит конечное число операций умножения, сложения и вычисления квадратного корня.

3)Макроярус вращения Якоби содержит вычисление <math>2n+2</math> элементов матрицы и <math>2n-2</math> операций присваивания. На данном ярусе ширина графа достигает максимального значения. Вначале вычисляются значения в строках <math>j</math> и <math>k</math> (это соответствует умножению матрицы <math>R^T</math> на матрицу А). Далее, в силу того, что при умножении результата на матрицу А изменяются только столбцы <math>j</math> и <math>k</math> и итоговая матрица симметрична, можно не пересчитывать значения в столбцах, а получить их простым присваиванием по формуле: <math>a_{pk}=a_{kp}</math>, <math>a_{pj}=a_{jp}</math>, <math>p!=k,j</math>. Для элементов <math>a_{jj}</math> и <math>a_{kk}</math> необходимо произвести вычисления, аналогичные вычислениям для элементов строк.

Визуальное представление графа алгоритма представлено на схемах ниже:

[[file:SI.jpg|thumb|center|1400px|Рисунок 1. Граф алгоритма на макроуровне. Rarams - вычисление параметров, Rotate - получение <math>A_{i+1}</math> из <math>A_{i}</math>.]]

[[file:exec_params.jpg|thumb|center|1400px|Рисунок 2. Структура блока Params.]]

[[file:Rotate.jpg|thumb|center|1400px|Рисунок 3. Структура блока Rotate.]]

=== Ресурс параллелизма алгоритма ===
Как видно из представления алгоритма в ярусно-параллельной форме ([[#Информационный граф| п.1.7]]), максимальная ширина ярусов составляет <math>2n</math> вершин.
Для выполнения данного алгоритма в параллельном варианте следует выполнить <math>O(\frac{n(n+1)}{2})</math> итераций.
Рассмотрим отдельную итерацию с точки зрения ярусно-параллельной формы алгоритма.

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

2)Выполнение 2 ярусов вычисления элементов в изменяемых строках и столбцах.

На данных двух ярусах осуществляется <math>4n</math> умножений и <math>2n</math> сложений. Данный вид параллелизма относится к координатному. Так как каждая последующая итерация алгоритма зависит от предыдущей, их выполнение распараллелить не представляется возможным. Таким образом, при наличии бесконечного числа процессоров, итоговая сложность алгоритма составляет <math>O(\frac{n(n+1)}{2})</math>

=== Входные и выходные данные алгоритма ===
'''Входные данные''': плотная матрица <math>A</math> (элементы <math>a_{ij}</math>); при этом <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>..

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы).
Конкретный вариант хранения данных зависит от реализации. В качестве примеров можно привести хранение в одномерном массиве длины <math>\frac{n (n + 1)}{2}</math> по строкам своей нижней части, хранение в виде так называемого ступенчатого массива (такой вариант двумерного массива, в котором каждая строка имеет свой размер).

'''Выходные данные''': вектор собственных значений <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>) длины <math>n</math>.

=== Свойства алгоритма ===
Параллельная сложность выполнения алгоритма составляет <math>O(\frac{n(n+1)}{2}).</math>
Последовательная сложность выполнения алгоритма составляет <math>O(\frac{n^2(n+1)}{2}).</math>
Таким образом, соотношение сложностей является линейным.
Более того, и вычислительная мощность данного алгоритма линейна.

В алгоритме используется примерно в два раза больше операций умножения, чем сложения.
Одельно стоит рассмотреть вопрос хранения матрицы А в процессе работы алгоритма. Хранение лишь нижней или верхней части матрицы в виде одномерного массива возможно; более того, хранение в таком виде обеспечивает экономию памяти в 2 раза и защищает от ассиметричности матрицы в результате накопления математических ошибок. Однако, вычисление индексов <math>i</math> и <math>j</math> элементов <math>a_{ij}</math>, соответствующих данному номеру <math>k</math> вообще говоря требует отдельного цикла, что создает дополнительную нагрузку на процессор.

Кроме того, следует отметить следующие особенности алгоритма:

1)Несмотря на то, что выбор наибольшего наддиагонального элемента, как кандидата на обнуление, кажется оптимальным, на самом деле он таковым не является. При таком выборе элемента, на каждой итерации необходимо находить текущий наибольший элемент в матрице, что требует дополнительных <math>\frac{n*(n-1)}{2}</math> операций сравнения и приводит к увеличению сложности алгоритма до <math>O(n^4)</math>. Вместо этого рекомендуется перебирать по очереди все наддиагональные элементы, большие заданного параметра. В большинстве случаев от 4 до 8 полных проходов достаточно для приближения исходной матрицы к диагональной.

2)Если при выборе в качестве обнуляемого элемента <math>a_{ij}</math> элементы <math>a_{ii} = a_{jj}</math>, то, как видно из формул в пунктах выше, матрицы поворота вырождаются в единичные и матрица на данной итерации не изменяется. Это еще один довод в пользу отказа от выбора наибольшего элемента, т.к. в данном случае произойдет зацикливание алгоритма.

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

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

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

==== Локальность реализации алгоритма ====

===== Структура обращений в память и качественная оценка локальности =====

===== Количественная оценка локальности =====

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

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

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

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

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

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

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

1)Библиотека [https://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE] содержит последовательную реализацию алгоритма.

2)В цифровой библиотеке ieee.org приводится [http://ieeexplore.ieee.org/document/6310877/ аннотация] статьи 2012 года, в которой авторы описывают реализацию данного алгоритма на CUDA.

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

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-10-15T14:58:01Z

Пронин Андрей:

{{Assignment}}

{{algorithm
| name = Метод Якоби вычисления собственных значений симметричной матрицы ЗП
| serial_complexity = <math>O(n^3)</math>
| pf_height = <math>O(n^2)</math>
| pf_width = <math>2n</math>
| input_data = <math>n^2</math>
| output_data = <math>n</math>
}}

Авторы: Зиновьев В., Пронин А.

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

=== Общее описание алгоритма ===
Задача нахождения собственных значений и собственных векторов матриц(СЗВМ) является одной из основных задач для многих разделов физики. <ref>Чечин Г.М., Зехцер М.Ю. Собственные значения и собственные векторы матриц</ref> С такой вычислительной проблемой приходится сталкиваться, например, при исследовании собственных колебаний различных механических систем, колебательных и электронных спектров молекул и кристаллов. Совершенно принципиальное значение эта проблема приобрела после создания в тридцатых годах прошлого века квантовой механики, которая стала базовой дисциплиной исследования микромира.Кроме того, данная проблема важна в теории автоматического управления, как инструмент исследования устойчивости линейных систем.

Метод Якоби приводит симметричную действительную матрицу к диагональной форме с помощью некоторой (в принципе, бесконечной) последовательности плоских вращений в разных плоскостях исходного n-мерного векторного пространства. Метод Якоби состоит из некоторой последовательности шагов, на каждом из которых обнуляется один из внедиагональных элементов (обычно наибольший по модулю), в результате чего старая матрица <math>A_{i}</math> преобразуется в некоторую новую матрицу <math>A_{i+1}</math>. Делается это с помощью преобразования подобия, использующего матрицу плоского вращения <math>J_{i}</math> (подробное описание матрицы плоского вращения приведено ниже в разделе "[[#Математическое описание алгоритма|Математическое описание алгоритма]]"), которая изменяет лишь две координаты <math>n</math>-мерных векторов, а именно, координаты с номерами <math>j</math> и <math>k</math>. При таком шаге матрица <math>A_{i+1}</math> отличается от матрицы <math>A_{i}</math> лишь элементами двух строк с номерами <math>j</math>, <math>k</math> и двух столбцов с теми же номерами (<math>j</math> и <math>k</math>). Все же другие элементы матрицы A остаются неизменными. Число шагов, за которое матрица A приводится таким способом к диагональной форме, в общем случае является бесконечным. (это свойство метода Якоби более подробно рассмотрено в разделе "[[#Свойства алгоритма|Свойства алгоритма]]") В результате метод Якоби представляет собой некоторый бесконечный итерационный процесс, на каждом шаге которого преобразующаяся матрица становится всё более и более близкой к диагональной форме (в смысле уменьшения суммы квадратов всех своих внедиагональных элементов). На практике обычно выбирается заранее заданная погрешность <math>\varepsilon</math> и процесс приведения исходной матрицы к диагональному виду прекращается, когда наибольший по модулю внедиагональный элемент матрицы становится меньше <math>\varepsilon</math>. Таким образом, применяя на практике метод Якоби, мы приводим исходную матрицу к диагональной форме с точностью до некоторой вычислительной погрешности <math>\varepsilon</math> в результате конечного числа шагов. Повышение этой точности требует увеличения числа шагов метода Якоби. В конечном итоге у полученной в результате этого процесса матрицы на диагонали будут находиться все собственные значения (с определённой погрешностью) исходной симметрической матрицы.

==== Симметричность матрицы ====

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

=== Математическое описание алгоритма ===
Пусть <math>A = A_0</math> — симметричная матрица. В методе Якоби для <math>A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,...</math>, которая в конечном счёте сходится к диагональной матрице, у которой диагональными элементами являются все собственные значения матрицы <math>A</math>. Матрица <math>A_{i}</math> получается из матрицы <math>A_{i-1}</math> по формуле
<math>A_{i}=J^{T}_iA_{i-1}J_i ,</math>
где <math>J_i</math> - ортогональная матрица, называемая ''вращением Якоби''. Таким образом,
<math>A_{m}=J^{T}_{m-1}A_{m-1}J_{m-1}</math>
<math>=J^{T}_{m-1}J^{T}_{m-2}A_{m-2}J_{m-2}J_{m-1}</math>
<math>=J^{T}_{m-1}...J^{T}_{0}A_{0}J_{0}...J_{m-1}</math>
<math>=J^{T}AJ</math>
При подходящем выборе вращений <math>J_i</math> матрица <math>A_m</math> для больших <math>m</math> будет близкой к диагональной матрице <math>\Lambda</math> <ref>Дж. Деммель, Вычислительная линейная алгебра. Теория и приложения. Перевод Х.Д.Икрамов</ref>. Таким образом, <math>\Lambda \approx J^{T}AJ</math> или <math>J\Lambda J^{T} \approx A</math>, следовательно, столбцы матрицы <math>J</math> являются собственными значениями матрицы <math>A</math>.
Матрица <math>J_i</math> выбирается таким образом, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}=J^{T}_{i}A_{i}J_{i}</math>:

                                                                            
<math>j</math>
                       
<math>k</math>

<math>
J_i = R(j,k,\theta) \equiv
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & -\sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Угол вращения <math>\theta</math> выбирается так, чтобы элементы <math>(j,k)</math> и <math>(k,j)</math> в <math>A_{i+1}</math> стали нулями. Для того, чтобы найти <math>\theta</math>, составляется уравнение:
:<math>
\begin{bmatrix}
a^{i+1}_{jj}&a^{i+1}_{jk}\\
a^{i+1}_{kj}&a^{i+1}_{kk}\\
\end{bmatrix} =
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix}^T
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix}
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix} =
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} ,
</math>
где <math>\lambda_1</math> и <math>\lambda_2</math> - собственные значения подматрицы
:<math>
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix} .
</math>
Пусть <math>c = \cos(\theta)</math> и <math>s = sin(\theta)</math>, <math>a^{i}_{lk} = a_{lk}</math>. Тогда из предыдущего равенства получаем
:<math>
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} =
\begin{bmatrix}
a_{jj}c^2 + a_{kk}s^2+2sca_{jk}&sc(a_{kk} - a{jj}) + a_{jk}(c^2-s^2)\\
sc(a_{kk} - a{jj}) + a_{jk}(c^2-s^2)&a_{jj}s^2 + a_{kk}c^2-2sca_{jk}\\
\end{bmatrix}
.
</math>
Приравнивая внедиагональный элемент к нулю, получаем
:<math>
\frac{a_{jj} - a{kk}}{2a_{jk}} = \frac{c^2-s^2}{2sc} = ctg(2\theta) = r.
</math>
Пусть <math>tg(\theta) = t = \frac{s}{c}</math> . Заметим, что выполняется квадратное уравнение <math>t^2 + 2rt - 1 = 0</math> . Решая уравнение, получаем <math>t = \frac{sign(r)}{|r| + \sqrt{1+r^2}}</math> . Следовательно <math>c = \frac{1}{\sqrt{1+t^2}}</math>, <math>s = ct</math>

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

Вычислительным ядром отдельной итерации является вычисление элементов матрицы <math>A</math> при применении поворота Якоби. Конкретно, изменяются 2 строки и 2 столбца, что означает изменение 4n элементов. Отметим, что вычисление нового значения одного элемента требует 2 операции умножения и одну операцию сложения, что позволяет утверждать, что основной вклад в вычислительное ядро вносят умножения.
Однако в целом, следует отметить, что число операций в алгоритме во многом определяется общим числом итераций, а оно квадратично, в то время как отдельная итерация имеет линейную сложность. Более того, так как алгоритм является итерационным и останавливается при достижении некоторой точности, число итераций может изменяться в зависимости от желаемой точности.

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

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

1) Блок вычисления параметров вращения на текущей итерации (выбор обнуляемого элемента и расчет угла вращения).

2)Блок, реализующий непосредственно вращение Якоби.

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

1)Находится максимальный наддиагональный элемент <math>a_{jk}</math> матрицы <math>A</math>.

2)Вычисляются параметры вращения Якоби:
<math>\tau= \frac{(a_{jj}-a_{kk})}{2a_{jk}}</math>
<math>t=sign(\tau)(|\tau|+\sqrt{1+\tau^2})</math>
<math>c= \frac{1}{1+\sqrt{1+\tau^2}}</math>
<math>s=c*t</math>

3)К текущей матрице А применяются вращения с вычисленными параметрами:
<math>A=R^T(j,k,\theta)*A*R(j,k,\theta)</math>
Стоит отметить, что вычисленные на предыдущем шаге <math>c</math> и <math>s</math> есть <math>\cos {\theta}</math> и <math>\sin {\theta}</math> соответственно.

4)Если матрица А не достаточно близка к диагональной, происходит переход к шагу 1.

Вообще говоря, несмотря на то, что поворот, обеспечивающий обнуление наибольшего внедиагонального элемента, обеспечивает схождение метода за наименьшее число итераций, поиск данного наибольшего элемента добавляет порядка <math>n^2</math> операций сравнения, а возможно и присваивания на каждой итерации.
Поэтому с вычислительной точки зрения выгоднее не выбирать наибольший элемент, а по очереди перебирать все наддиагональные элементы, большие заданного порога.

В последующих разделах рассматривается именно такой вариант алгоритма.

=== Последовательная сложность алгоритма ===
Сначала оценим сложность одной итерации:

1)Так как элементы матрицы никак не упорядоченны, поиск наибольшего элемента линейно зависит от числа элементов над диагональю.
Конкретнее, на данном шаге происходит <math>\frac{n*(n-1)}{2} -1</math> сравнение.

2)3 операции деления, 2 операции взятия корня, 4 операции умножения и 4 операции сложения/вычитания.

3)<math>4*n</math> операций умножения и <math>2*n</math> операций сложения.

4)операция сравнения

В наиболее неудачном случае количество итераций в теории равняется числу наддиагональных элементов, т.е. <math>\frac{n*(n-1)}{2}</math>
На практике же из-за накопления ошибок вычисления а так же восстановления уже обнуленных элементов при некоторых вращениях, число операций возрастает.
Вместе с тем, можно утверждать, что порядок числа итераций можно оценить как <math>O(N^2)</math>.
Таким образом, суммарная сложность алгоритма составляет <math>O(N^4)</math> сравнений, и <math>O(N^3)</math> сложений и умножений.

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

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

Аналитически информационный граф данного алгоритма можно описать следующим образом:

1)Последовательно идущие макроярусы вычисления параметров текущей итерации и вращения Якоби с этими параметрами
Число данных ярусов варьируется в зависимости от входных данных, но порядок составляет <math>O(n^2)</math>.

2)Вычисление параметров текущей итерации содержит конечное число операций умножения, сложения и вычисления квадратного корня.

3)Макроярус вращения Якоби содержит вычисление <math>4n</math> элементов матрицы. На данном ярусе ширина графа достигает максимального значения.

Визуальное представление графа алгоритма представлено на схемах ниже:

[[file:SI.jpg|thumb|center|1400px|Рисунок 1. Граф алгоритма на макроуровне. Rarams - вычисление параметров, Rotate - получение <math>A_{i+1}</math> из <math>A_{i}</math>.]]

[[file:exec_params.jpg|thumb|center|1400px|Рисунок 2. Структура блока Params.]]

[[file:Rotate.jpg|thumb|center|1400px|Рисунок 3. Структура блока Rotate.]]

=== Ресурс параллелизма алгоритма ===
Как видно из представления алгоритма в ярусно-параллельной форме ([[#Информационный граф| п.1.7]]), максимальная ширина ярусов составляет <math>2n</math> вершин.
Для выполнения данного алгоритма в параллельном варианте следует выполнить <math>O(\frac{n(n+1)}{2})</math> итераций.
Рассмотрим отдельную итерацию с точки зрения ярусно-параллельной формы алгоритма.

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

2)Выполнение 2 ярусов вычисления элементов в изменяемых строках и столбцах.

На данных двух ярусах осуществляется <math>4n</math> умножений и <math>2n</math> сложений. Данный вид параллелизма относится к координатному. Так как каждая последующая итерация алгоритма зависит от предыдущей, их выполнение распараллелить не представляется возможным. Таким образом, при наличии бесконечного числа процессоров, итоговая сложность алгоритма составляет <math>O(\frac{n(n+1)}{2})</math>

=== Входные и выходные данные алгоритма ===
'''Входные данные''': плотная матрица <math>A</math> (элементы <math>a_{ij}</math>); при этом <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>..

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы).
Конкретный вариант хранения данных зависит от реализации. В качестве примеров можно привести хранение в одномерном массиве длины <math>\frac{n (n + 1)}{2}</math> по строкам своей нижней части, хранение в виде так называемого ступенчатого массива (такой вариант двумерного массива, в котором каждая строка имеет свой размер).

'''Выходные данные''': вектор собственных значений <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>) длины <math>n</math>.

=== Свойства алгоритма ===
Параллельная сложность выполнения алгоритма составляет <math>O(\frac{n(n+1)}{2}).</math>
Последовательная сложность выполнения алгоритма составляет <math>O(\frac{n^2(n+1)}{2}).</math>
Таким образом, соотношение сложностей является линейным.
Более того, и вычислительная мощность данного алгоритма линейна.

В алгоритме используется примерно в два раза больше операций умножения, чем сложения.
Одельно стоит рассмотреть вопрос хранения матрицы А в процессе работы алгоритма. Хранение лишь нижней или верхней части матрицы в виде одномерного массива возможно; более того, хранение в таком виде обеспечивает экономию памяти в 2 раза и защищает от ассиметричности матрицы в результате накопления математических ошибок. Однако, вычисление индексов <math>i</math> и <math>j</math> элементов <math>a_{ij}</math>, соответствующих данному номеру <math>k</math> вообще говоря требует отдельного цикла, что создает дополнительную нагрузку на процессор.

Кроме того, следует отметить следующие особенности алгоритма:

1)Несмотря на то, что выбор наибольшего наддиагонального элемента, как кандидата на обнуление, кажется оптимальным, на самом деле он таковым не является. При таком выборе элемента, на каждой итерации необходимо находить текущий наибольший элемент в матрице, что требует дополнительных <math>\frac{n*(n-1)}{2}</math> операций сравнения и приводит к увеличению сложности алгоритма до <math>O(n^4)</math>. Вместо этого рекомендуется перебирать по очереди все наддиагональные элементы, большие заданного параметра. В большинстве случаев от 4 до 8 полных проходов достаточно для приближения исходной матрицы к диагональной.

2)Если при выборе в качестве обнуляемого элемента <math>a_{ij}</math> элементы <math>a_{ii} = a_{jj}</math>, то, как видно из формул в пунктах выше, матрицы поворота вырождаются в единичные и матрица на данной итерации не изменяется. Это еще один довод в пользу отказа от выбора наибольшего элемента, т.к. в данном случае произойдет зацикливание алгоритма.

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

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

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

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

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

1)Библиотека [https://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE] содержит последовательную реализацию алгоритма.

2)В цифровой библиотеке ieee.org приводится [http://ieeexplore.ieee.org/document/6310877/ аннотация] статьи 2012 года, в которой авторы описывают реализацию данного алгоритма на CUDA.

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

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-10-15T14:56:05Z

Пронин Андрей:

{{Assignment}}

{{algorithm
| name = Метод Якоби вычисления собственных значений симметричной матрицы ЗП
| serial_complexity = <math>O(n^3)</math>
| pf_height = <math>O(n^2)</math>
| pf_width = <math>2n</math>
| input_data = <math>n^2</math>
| output_data = <math>n</math>
}}

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

=== Общее описание алгоритма ===
Задача нахождения собственных значений и собственных векторов матриц(СЗВМ) является одной из основных задач для многих разделов физики. <ref>Чечин Г.М., Зехцер М.Ю. Собственные значения и собственные векторы матриц</ref> С такой вычислительной проблемой приходится сталкиваться, например, при исследовании собственных колебаний различных механических систем, колебательных и электронных спектров молекул и кристаллов. Совершенно принципиальное значение эта проблема приобрела после создания в тридцатых годах прошлого века квантовой механики, которая стала базовой дисциплиной исследования микромира.Кроме того, данная проблема важна в теории автоматического управления, как инструмент исследования устойчивости линейных систем.

Метод Якоби приводит симметричную действительную матрицу к диагональной форме с помощью некоторой (в принципе, бесконечной) последовательности плоских вращений в разных плоскостях исходного n-мерного векторного пространства. Метод Якоби состоит из некоторой последовательности шагов, на каждом из которых обнуляется один из внедиагональных элементов (обычно наибольший по модулю), в результате чего старая матрица <math>A_{i}</math> преобразуется в некоторую новую матрицу <math>A_{i+1}</math>. Делается это с помощью преобразования подобия, использующего матрицу плоского вращения <math>J_{i}</math> (подробное описание матрицы плоского вращения приведено ниже в разделе "[[#Математическое описание алгоритма|Математическое описание алгоритма]]"), которая изменяет лишь две координаты <math>n</math>-мерных векторов, а именно, координаты с номерами <math>j</math> и <math>k</math>. При таком шаге матрица <math>A_{i+1}</math> отличается от матрицы <math>A_{i}</math> лишь элементами двух строк с номерами <math>j</math>, <math>k</math> и двух столбцов с теми же номерами (<math>j</math> и <math>k</math>). Все же другие элементы матрицы A остаются неизменными. Число шагов, за которое матрица A приводится таким способом к диагональной форме, в общем случае является бесконечным. (это свойство метода Якоби более подробно рассмотрено в разделе "[[#Свойства алгоритма|Свойства алгоритма]]") В результате метод Якоби представляет собой некоторый бесконечный итерационный процесс, на каждом шаге которого преобразующаяся матрица становится всё более и более близкой к диагональной форме (в смысле уменьшения суммы квадратов всех своих внедиагональных элементов). На практике обычно выбирается заранее заданная погрешность <math>\varepsilon</math> и процесс приведения исходной матрицы к диагональному виду прекращается, когда наибольший по модулю внедиагональный элемент матрицы становится меньше <math>\varepsilon</math>. Таким образом, применяя на практике метод Якоби, мы приводим исходную матрицу к диагональной форме с точностью до некоторой вычислительной погрешности <math>\varepsilon</math> в результате конечного числа шагов. Повышение этой точности требует увеличения числа шагов метода Якоби. В конечном итоге у полученной в результате этого процесса матрицы на диагонали будут находиться все собственные значения (с определённой погрешностью) исходной симметрической матрицы.

==== Симметричность матрицы ====

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

=== Математическое описание алгоритма ===
Пусть <math>A = A_0</math> — симметричная матрица. В методе Якоби для <math>A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,...</math>, которая в конечном счёте сходится к диагональной матрице, у которой диагональными элементами являются все собственные значения матрицы <math>A</math>. Матрица <math>A_{i}</math> получается из матрицы <math>A_{i-1}</math> по формуле
<math>A_{i}=J^{T}_iA_{i-1}J_i ,</math>
где <math>J_i</math> - ортогональная матрица, называемая ''вращением Якоби''. Таким образом,
<math>A_{m}=J^{T}_{m-1}A_{m-1}J_{m-1}</math>
<math>=J^{T}_{m-1}J^{T}_{m-2}A_{m-2}J_{m-2}J_{m-1}</math>
<math>=J^{T}_{m-1}...J^{T}_{0}A_{0}J_{0}...J_{m-1}</math>
<math>=J^{T}AJ</math>
При подходящем выборе вращений <math>J_i</math> матрица <math>A_m</math> для больших <math>m</math> будет близкой к диагональной матрице <math>\Lambda</math> <ref>Дж. Деммель, Вычислительная линейная алгебра. Теория и приложения. Перевод Х.Д.Икрамов</ref>. Таким образом, <math>\Lambda \approx J^{T}AJ</math> или <math>J\Lambda J^{T} \approx A</math>, следовательно, столбцы матрицы <math>J</math> являются собственными значениями матрицы <math>A</math>.
Матрица <math>J_i</math> выбирается таким образом, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}=J^{T}_{i}A_{i}J_{i}</math>:

                                                                            
<math>j</math>
                       
<math>k</math>

<math>
J_i = R(j,k,\theta) \equiv
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & -\sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Угол вращения <math>\theta</math> выбирается так, чтобы элементы <math>(j,k)</math> и <math>(k,j)</math> в <math>A_{i+1}</math> стали нулями. Для того, чтобы найти <math>\theta</math>, составляется уравнение:
:<math>
\begin{bmatrix}
a^{i+1}_{jj}&a^{i+1}_{jk}\\
a^{i+1}_{kj}&a^{i+1}_{kk}\\
\end{bmatrix} =
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix}^T
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix}
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix} =
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} ,
</math>
где <math>\lambda_1</math> и <math>\lambda_2</math> - собственные значения подматрицы
:<math>
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix} .
</math>
Пусть <math>c = \cos(\theta)</math> и <math>s = sin(\theta)</math>, <math>a^{i}_{lk} = a_{lk}</math>. Тогда из предыдущего равенства получаем
:<math>
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} =
\begin{bmatrix}
a_{jj}c^2 + a_{kk}s^2+2sca_{jk}&sc(a_{kk} - a{jj}) + a_{jk}(c^2-s^2)\\
sc(a_{kk} - a{jj}) + a_{jk}(c^2-s^2)&a_{jj}s^2 + a_{kk}c^2-2sca_{jk}\\
\end{bmatrix}
.
</math>
Приравнивая внедиагональный элемент к нулю, получаем
:<math>
\frac{a_{jj} - a{kk}}{2a_{jk}} = \frac{c^2-s^2}{2sc} = ctg(2\theta) = r.
</math>
Пусть <math>tg(\theta) = t = \frac{s}{c}</math> . Заметим, что выполняется квадратное уравнение <math>t^2 + 2rt - 1 = 0</math> . Решая уравнение, получаем <math>t = \frac{sign(r)}{|r| + \sqrt{1+r^2}}</math> . Следовательно <math>c = \frac{1}{\sqrt{1+t^2}}</math>, <math>s = ct</math>

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

Вычислительным ядром отдельной итерации является вычисление элементов матрицы <math>A</math> при применении поворота Якоби. Конкретно, изменяются 2 строки и 2 столбца, что означает изменение 4n элементов. Отметим, что вычисление нового значения одного элемента требует 2 операции умножения и одну операцию сложения, что позволяет утверждать, что основной вклад в вычислительное ядро вносят умножения.
Однако в целом, следует отметить, что число операций в алгоритме во многом определяется общим числом итераций, а оно квадратично, в то время как отдельная итерация имеет линейную сложность. Более того, так как алгоритм является итерационным и останавливается при достижении некоторой точности, число итераций может изменяться в зависимости от желаемой точности.

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

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

1) Блок вычисления параметров вращения на текущей итерации (выбор обнуляемого элемента и расчет угла вращения).

2)Блок, реализующий непосредственно вращение Якоби.

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

1)Находится максимальный наддиагональный элемент <math>a_{jk}</math> матрицы <math>A</math>.

2)Вычисляются параметры вращения Якоби:
<math>\tau= \frac{(a_{jj}-a_{kk})}{2a_{jk}}</math>
<math>t=sign(\tau)(|\tau|+\sqrt{1+\tau^2})</math>
<math>c= \frac{1}{1+\sqrt{1+\tau^2}}</math>
<math>s=c*t</math>

3)К текущей матрице А применяются вращения с вычисленными параметрами:
<math>A=R^T(j,k,\theta)*A*R(j,k,\theta)</math>
Стоит отметить, что вычисленные на предыдущем шаге <math>c</math> и <math>s</math> есть <math>\cos {\theta}</math> и <math>\sin {\theta}</math> соответственно.

4)Если матрица А не достаточно близка к диагональной, происходит переход к шагу 1.

Вообще говоря, несмотря на то, что поворот, обеспечивающий обнуление наибольшего внедиагонального элемента, обеспечивает схождение метода за наименьшее число итераций, поиск данного наибольшего элемента добавляет порядка <math>n^2</math> операций сравнения, а возможно и присваивания на каждой итерации.
Поэтому с вычислительной точки зрения выгоднее не выбирать наибольший элемент, а по очереди перебирать все наддиагональные элементы, большие заданного порога.

В последующих разделах рассматривается именно такой вариант алгоритма.

=== Последовательная сложность алгоритма ===
Сначала оценим сложность одной итерации:

1)Так как элементы матрицы никак не упорядоченны, поиск наибольшего элемента линейно зависит от числа элементов над диагональю.
Конкретнее, на данном шаге происходит <math>\frac{n*(n-1)}{2} -1</math> сравнение.

2)3 операции деления, 2 операции взятия корня, 4 операции умножения и 4 операции сложения/вычитания.

3)<math>4*n</math> операций умножения и <math>2*n</math> операций сложения.

4)операция сравнения

В наиболее неудачном случае количество итераций в теории равняется числу наддиагональных элементов, т.е. <math>\frac{n*(n-1)}{2}</math>
На практике же из-за накопления ошибок вычисления а так же восстановления уже обнуленных элементов при некоторых вращениях, число операций возрастает.
Вместе с тем, можно утверждать, что порядок числа итераций можно оценить как <math>O(N^2)</math>.
Таким образом, суммарная сложность алгоритма составляет <math>O(N^4)</math> сравнений, и <math>O(N^3)</math> сложений и умножений.

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

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

Аналитически информационный граф данного алгоритма можно описать следующим образом:

1)Последовательно идущие макроярусы вычисления параметров текущей итерации и вращения Якоби с этими параметрами
Число данных ярусов варьируется в зависимости от входных данных, но порядок составляет <math>O(n^2)</math>.

2)Вычисление параметров текущей итерации содержит конечное число операций умножения, сложения и вычисления квадратного корня.

3)Макроярус вращения Якоби содержит вычисление <math>4n</math> элементов матрицы. На данном ярусе ширина графа достигает максимального значения.

Визуальное представление графа алгоритма представлено на схемах ниже:

[[file:SI.jpg|thumb|center|1400px|Рисунок 1. Граф алгоритма на макроуровне. Rarams - вычисление параметров, Rotate - получение <math>A_{i+1}</math> из <math>A_{i}</math>.]]

[[file:exec_params.jpg|thumb|center|1400px|Рисунок 2. Структура блока Params.]]

[[file:Rotate.jpg|thumb|center|1400px|Рисунок 3. Структура блока Rotate.]]

=== Ресурс параллелизма алгоритма ===
Как видно из представления алгоритма в ярусно-параллельной форме ([[#Информационный граф| п.1.7]]), максимальная ширина ярусов составляет <math>2n</math> вершин.
Для выполнения данного алгоритма в параллельном варианте следует выполнить <math>O(\frac{n(n+1)}{2})</math> итераций.
Рассмотрим отдельную итерацию с точки зрения ярусно-параллельной формы алгоритма.

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

2)Выполнение 2 ярусов вычисления элементов в изменяемых строках и столбцах.

На данных двух ярусах осуществляется <math>4n</math> умножений и <math>2n</math> сложений. Данный вид параллелизма относится к координатному. Так как каждая последующая итерация алгоритма зависит от предыдущей, их выполнение распараллелить не представляется возможным. Таким образом, при наличии бесконечного числа процессоров, итоговая сложность алгоритма составляет <math>O(\frac{n(n+1)}{2})</math>

=== Входные и выходные данные алгоритма ===
'''Входные данные''': плотная матрица <math>A</math> (элементы <math>a_{ij}</math>); при этом <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>..

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы).
Конкретный вариант хранения данных зависит от реализации. В качестве примеров можно привести хранение в одномерном массиве длины <math>\frac{n (n + 1)}{2}</math> по строкам своей нижней части, хранение в виде так называемого ступенчатого массива (такой вариант двумерного массива, в котором каждая строка имеет свой размер).

'''Выходные данные''': вектор собственных значений <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>) длины <math>n</math>.

=== Свойства алгоритма ===
Параллельная сложность выполнения алгоритма составляет <math>O(\frac{n(n+1)}{2}).</math>
Последовательная сложность выполнения алгоритма составляет <math>O(\frac{n^2(n+1)}{2}).</math>
Таким образом, соотношение сложностей является линейным.
Более того, и вычислительная мощность данного алгоритма линейна.

В алгоритме используется примерно в два раза больше операций умножения, чем сложения.
Одельно стоит рассмотреть вопрос хранения матрицы А в процессе работы алгоритма. Хранение лишь нижней или верхней части матрицы в виде одномерного массива возможно; более того, хранение в таком виде обеспечивает экономию памяти в 2 раза и защищает от ассиметричности матрицы в результате накопления математических ошибок. Однако, вычисление индексов <math>i</math> и <math>j</math> элементов <math>a_{ij}</math>, соответствующих данному номеру <math>k</math> вообще говоря требует отдельного цикла, что создает дополнительную нагрузку на процессор.

Кроме того, следует отметить следующие особенности алгоритма:

1)Несмотря на то, что выбор наибольшего наддиагонального элемента, как кандидата на обнуление, кажется оптимальным, на самом деле он таковым не является. При таком выборе элемента, на каждой итерации необходимо находить текущий наибольший элемент в матрице, что требует дополнительных <math>\frac{n*(n-1)}{2}</math> операций сравнения и приводит к увеличению сложности алгоритма до <math>O(n^4)</math>. Вместо этого рекомендуется перебирать по очереди все наддиагональные элементы, большие заданного параметра. В большинстве случаев от 4 до 8 полных проходов достаточно для приближения исходной матрицы к диагональной.

2)Если при выборе в качестве обнуляемого элемента <math>a_{ij}</math> элементы <math>a_{ii} = a_{jj}</math>, то, как видно из формул в пунктах выше, матрицы поворота вырождаются в единичные и матрица на данной итерации не изменяется. Это еще один довод в пользу отказа от выбора наибольшего элемента, т.к. в данном случае произойдет зацикливание алгоритма.

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

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

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

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

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

1)Библиотека [https://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE] содержит последовательную реализацию алгоритма.

2)В цифровой библиотеке ieee.org приводится [http://ieeexplore.ieee.org/document/6310877/ аннотация] статьи 2012 года, в которой авторы описывают реализацию данного алгоритма на CUDA.

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

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-10-15T14:51:54Z

Пронин Андрей: /* Схема реализации последовательного алгоритма */

{{algorithm
| name = Метод Якоби вычисления собственных значений симметричной матрицы ЗП
| serial_complexity = <math>O(n^3)</math>
| pf_height = <math>O(n^2)</math>
| pf_width = <math>2n</math>
| input_data = <math>n^2</math>
| output_data = <math>n</math>
}}

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

=== Общее описание алгоритма ===
Задача нахождения собственных значений и собственных векторов матриц(СЗВМ) является одной из основных задач для многих разделов физики. <ref>Чечин Г.М., Зехцер М.Ю. Собственные значения и собственные векторы матриц</ref> С такой вычислительной проблемой приходится сталкиваться, например, при исследовании собственных колебаний различных механических систем, колебательных и электронных спектров молекул и кристаллов. Совершенно принципиальное значение эта проблема приобрела после создания в тридцатых годах прошлого века квантовой механики, которая стала базовой дисциплиной исследования микромира.Кроме того, данная проблема важна в теории автоматического управления, как инструмент исследования устойчивости линейных систем.

Метод Якоби приводит симметричную действительную матрицу к диагональной форме с помощью некоторой (в принципе, бесконечной) последовательности плоских вращений в разных плоскостях исходного n-мерного векторного пространства. Метод Якоби состоит из некоторой последовательности шагов, на каждом из которых обнуляется один из внедиагональных элементов (обычно наибольший по модулю), в результате чего старая матрица <math>A_{i}</math> преобразуется в некоторую новую матрицу <math>A_{i+1}</math>. Делается это с помощью преобразования подобия, использующего матрицу плоского вращения <math>J_{i}</math> (подробное описание матрицы плоского вращения приведено ниже в разделе "[[#Математическое описание алгоритма|Математическое описание алгоритма]]"), которая изменяет лишь две координаты <math>n</math>-мерных векторов, а именно, координаты с номерами <math>j</math> и <math>k</math>. При таком шаге матрица <math>A_{i+1}</math> отличается от матрицы <math>A_{i}</math> лишь элементами двух строк с номерами <math>j</math>, <math>k</math> и двух столбцов с теми же номерами (<math>j</math> и <math>k</math>). Все же другие элементы матрицы A остаются неизменными. Число шагов, за которое матрица A приводится таким способом к диагональной форме, в общем случае является бесконечным. (это свойство метода Якоби более подробно рассмотрено в разделе "[[#Свойства алгоритма|Свойства алгоритма]]") В результате метод Якоби представляет собой некоторый бесконечный итерационный процесс, на каждом шаге которого преобразующаяся матрица становится всё более и более близкой к диагональной форме (в смысле уменьшения суммы квадратов всех своих внедиагональных элементов). На практике обычно выбирается заранее заданная погрешность <math>\varepsilon</math> и процесс приведения исходной матрицы к диагональному виду прекращается, когда наибольший по модулю внедиагональный элемент матрицы становится меньше <math>\varepsilon</math>. Таким образом, применяя на практике метод Якоби, мы приводим исходную матрицу к диагональной форме с точностью до некоторой вычислительной погрешности <math>\varepsilon</math> в результате конечного числа шагов. Повышение этой точности требует увеличения числа шагов метода Якоби. В конечном итоге у полученной в результате этого процесса матрицы на диагонали будут находиться все собственные значения (с определённой погрешностью) исходной симметрической матрицы.

==== Симметричность матрицы ====

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

=== Математическое описание алгоритма ===
Пусть <math>A = A_0</math> — симметричная матрица. В методе Якоби для <math>A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,...</math>, которая в конечном счёте сходится к диагональной матрице, у которой диагональными элементами являются все собственные значения матрицы <math>A</math>. Матрица <math>A_{i}</math> получается из матрицы <math>A_{i-1}</math> по формуле
<math>A_{i}=J^{T}_iA_{i-1}J_i ,</math>
где <math>J_i</math> - ортогональная матрица, называемая ''вращением Якоби''. Таким образом,
<math>A_{m}=J^{T}_{m-1}A_{m-1}J_{m-1}</math>
<math>=J^{T}_{m-1}J^{T}_{m-2}A_{m-2}J_{m-2}J_{m-1}</math>
<math>=J^{T}_{m-1}...J^{T}_{0}A_{0}J_{0}...J_{m-1}</math>
<math>=J^{T}AJ</math>
При подходящем выборе вращений <math>J_i</math> матрица <math>A_m</math> для больших <math>m</math> будет близкой к диагональной матрице <math>\Lambda</math> <ref>Дж. Деммель, Вычислительная линейная алгебра. Теория и приложения. Перевод Х.Д.Икрамов</ref>. Таким образом, <math>\Lambda \approx J^{T}AJ</math> или <math>J\Lambda J^{T} \approx A</math>, следовательно, столбцы матрицы <math>J</math> являются собственными значениями матрицы <math>A</math>.
Матрица <math>J_i</math> выбирается таким образом, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}=J^{T}_{i}A_{i}J_{i}</math>:

                                                                            
<math>j</math>
                       
<math>k</math>

<math>
J_i = R(j,k,\theta) \equiv
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & -\sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Угол вращения <math>\theta</math> выбирается так, чтобы элементы <math>(j,k)</math> и <math>(k,j)</math> в <math>A_{i+1}</math> стали нулями. Для того, чтобы найти <math>\theta</math>, составляется уравнение:
:<math>
\begin{bmatrix}
a^{i+1}_{jj}&a^{i+1}_{jk}\\
a^{i+1}_{kj}&a^{i+1}_{kk}\\
\end{bmatrix} =
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix}^T
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix}
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix} =
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} ,
</math>
где <math>\lambda_1</math> и <math>\lambda_2</math> - собственные значения подматрицы
:<math>
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix} .
</math>
Пусть <math>c = \cos(\theta)</math> и <math>s = sin(\theta)</math>, <math>a^{i}_{lk} = a_{lk}</math>. Тогда из предыдущего равенства получаем
:<math>
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} =
\begin{bmatrix}
a_{jj}c^2 + a_{kk}s^2+2sca_{jk}&sc(a_{kk} - a{jj}) + a_{jk}(c^2-s^2)\\
sc(a_{kk} - a{jj}) + a_{jk}(c^2-s^2)&a_{jj}s^2 + a_{kk}c^2-2sca_{jk}\\
\end{bmatrix}
.
</math>
Приравнивая внедиагональный элемент к нулю, получаем
:<math>
\frac{a_{jj} - a{kk}}{2a_{jk}} = \frac{c^2-s^2}{2sc} = ctg(2\theta) = r.
</math>
Пусть <math>tg(\theta) = t = \frac{s}{c}</math> . Заметим, что выполняется квадратное уравнение <math>t^2 + 2rt - 1 = 0</math> . Решая уравнение, получаем <math>t = \frac{sign(r)}{|r| + \sqrt{1+r^2}}</math> . Следовательно <math>c = \frac{1}{\sqrt{1+t^2}}</math>, <math>s = ct</math>

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

Вычислительным ядром отдельной итерации является вычисление элементов матрицы <math>A</math> при применении поворота Якоби. Конкретно, изменяются 2 строки и 2 столбца, что означает изменение 4n элементов. Отметим, что вычисление нового значения одного элемента требует 2 операции умножения и одну операцию сложения, что позволяет утверждать, что основной вклад в вычислительное ядро вносят умножения.
Однако в целом, следует отметить, что число операций в алгоритме во многом определяется общим числом итераций, а оно квадратично, в то время как отдельная итерация имеет линейную сложность. Более того, так как алгоритм является итерационным и останавливается при достижении некоторой точности, число итераций может изменяться в зависимости от желаемой точности.

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

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

1) Блок вычисления параметров вращения на текущей итерации (выбор обнуляемого элемента и расчет угла вращения).

2)Блок, реализующий непосредственно вращение Якоби.

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

1)Находится максимальный наддиагональный элемент <math>a_{jk}</math> матрицы <math>A</math>.

2)Вычисляются параметры вращения Якоби:
<math>\tau= \frac{(a_{jj}-a_{kk})}{2a_{jk}}</math>
<math>t=sign(\tau)(|\tau|+\sqrt{1+\tau^2})</math>
<math>c= \frac{1}{1+\sqrt{1+\tau^2}}</math>
<math>s=c*t</math>

3)К текущей матрице А применяются вращения с вычисленными параметрами:
<math>A=R^T(j,k,\theta)*A*R(j,k,\theta)</math>
Стоит отметить, что вычисленные на предыдущем шаге <math>c</math> и <math>s</math> есть <math>\cos {\theta}</math> и <math>\sin {\theta}</math> соответственно.

4)Если матрица А не достаточно близка к диагональной, происходит переход к шагу 1.

Вообще говоря, несмотря на то, что поворот, обеспечивающий обнуление наибольшего внедиагонального элемента, обеспечивает схождение метода за наименьшее число итераций, поиск данного наибольшего элемента добавляет порядка <math>n^2</math> операций сравнения, а возможно и присваивания на каждой итерации.
Поэтому с вычислительной точки зрения выгоднее не выбирать наибольший элемент, а по очереди перебирать все наддиагональные элементы, большие заданного порога.

В последующих разделах рассматривается именно такой вариант алгоритма.

=== Последовательная сложность алгоритма ===
Сначала оценим сложность одной итерации:

1)Так как элементы матрицы никак не упорядоченны, поиск наибольшего элемента линейно зависит от числа элементов над диагональю.
Конкретнее, на данном шаге происходит <math>\frac{n*(n-1)}{2} -1</math> сравнение.

2)3 операции деления, 2 операции взятия корня, 4 операции умножения и 4 операции сложения/вычитания.

3)<math>4*n</math> операций умножения и <math>2*n</math> операций сложения.

4)операция сравнения

В наиболее неудачном случае количество итераций в теории равняется числу наддиагональных элементов, т.е. <math>\frac{n*(n-1)}{2}</math>
На практике же из-за накопления ошибок вычисления а так же восстановления уже обнуленных элементов при некоторых вращениях, число операций возрастает.
Вместе с тем, можно утверждать, что порядок числа итераций можно оценить как <math>O(N^2)</math>.
Таким образом, суммарная сложность алгоритма составляет <math>O(N^4)</math> сравнений, и <math>O(N^3)</math> сложений и умножений.

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

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

Аналитически информационный граф данного алгоритма можно описать следующим образом:

1)Последовательно идущие макроярусы вычисления параметров текущей итерации и вращения Якоби с этими параметрами
Число данных ярусов варьируется в зависимости от входных данных, но порядок составляет <math>O(n^2)</math>.

2)Вычисление параметров текущей итерации содержит конечное число операций умножения, сложения и вычисления квадратного корня.

3)Макроярус вращения Якоби содержит вычисление <math>4n</math> элементов матрицы. На данном ярусе ширина графа достигает максимального значения.

Визуальное представление графа алгоритма представлено на схемах ниже:

[[file:SI.jpg|thumb|center|1400px|Рисунок 1. Граф алгоритма на макроуровне. Rarams - вычисление параметров, Rotate - получение <math>A_{i+1}</math> из <math>A_{i}</math>.]]

[[file:exec_params.jpg|thumb|center|1400px|Рисунок 2. Структура блока Params.]]

[[file:Rotate.jpg|thumb|center|1400px|Рисунок 3. Структура блока Rotate.]]

=== Ресурс параллелизма алгоритма ===
Как видно из представления алгоритма в ярусно-параллельной форме ([[#Информационный граф| п.1.7]]), максимальная ширина ярусов составляет <math>2n</math> вершин.
Для выполнения данного алгоритма в параллельном варианте следует выполнить <math>O(\frac{n(n+1)}{2})</math> итераций.
Рассмотрим отдельную итерацию с точки зрения ярусно-параллельной формы алгоритма.

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

2)Выполнение 2 ярусов вычисления элементов в изменяемых строках и столбцах.

На данных двух ярусах осуществляется <math>4n</math> умножений и <math>2n</math> сложений. Данный вид параллелизма относится к координатному. Так как каждая последующая итерация алгоритма зависит от предыдущей, их выполнение распараллелить не представляется возможным. Таким образом, при наличии бесконечного числа процессоров, итоговая сложность алгоритма составляет <math>O(\frac{n(n+1)}{2})</math>

=== Входные и выходные данные алгоритма ===
'''Входные данные''': плотная матрица <math>A</math> (элементы <math>a_{ij}</math>); при этом <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>..

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы).
Конкретный вариант хранения данных зависит от реализации. В качестве примеров можно привести хранение в одномерном массиве длины <math>\frac{n (n + 1)}{2}</math> по строкам своей нижней части, хранение в виде так называемого ступенчатого массива (такой вариант двумерного массива, в котором каждая строка имеет свой размер).

'''Выходные данные''': вектор собственных значений <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>) длины <math>n</math>.

=== Свойства алгоритма ===
Параллельная сложность выполнения алгоритма составляет <math>O(\frac{n(n+1)}{2}).</math>
Последовательная сложность выполнения алгоритма составляет <math>O(\frac{n^2(n+1)}{2}).</math>
Таким образом, соотношение сложностей является линейным.
Более того, и вычислительная мощность данного алгоритма линейна.

В алгоритме используется примерно в два раза больше операций умножения, чем сложения.
Одельно стоит рассмотреть вопрос хранения матрицы А в процессе работы алгоритма. Хранение лишь нижней или верхней части матрицы в виде одномерного массива возможно; более того, хранение в таком виде обеспечивает экономию памяти в 2 раза и защищает от ассиметричности матрицы в результате накопления математических ошибок. Однако, вычисление индексов <math>i</math> и <math>j</math> элементов <math>a_{ij}</math>, соответствующих данному номеру <math>k</math> вообще говоря требует отдельного цикла, что создает дополнительную нагрузку на процессор.

Кроме того, следует отметить следующие особенности алгоритма:

1)Несмотря на то, что выбор наибольшего наддиагонального элемента, как кандидата на обнуление, кажется оптимальным, на самом деле он таковым не является. При таком выборе элемента, на каждой итерации необходимо находить текущий наибольший элемент в матрице, что требует дополнительных <math>\frac{n*(n-1)}{2}</math> операций сравнения и приводит к увеличению сложности алгоритма до <math>O(n^4)</math>. Вместо этого рекомендуется перебирать по очереди все наддиагональные элементы, большие заданного параметра. В большинстве случаев от 4 до 8 полных проходов достаточно для приближения исходной матрицы к диагональной.

2)Если при выборе в качестве обнуляемого элемента <math>a_{ij}</math> элементы <math>a_{ii} = a_{jj}</math>, то, как видно из формул в пунктах выше, матрицы поворота вырождаются в единичные и матрица на данной итерации не изменяется. Это еще один довод в пользу отказа от выбора наибольшего элемента, т.к. в данном случае произойдет зацикливание алгоритма.

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

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

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

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

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

1)Библиотека [https://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE] содержит последовательную реализацию алгоритма.

2)В цифровой библиотеке ieee.org приводится [http://ieeexplore.ieee.org/document/6310877/ аннотация] статьи 2012 года, в которой авторы описывают реализацию данного алгоритма на CUDA.

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

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-10-15T14:47:38Z

Пронин Андрей: /* Существующие реализации алгоритма */

{{algorithm
| name = Метод Якоби вычисления собственных значений симметричной матрицы ЗП
| serial_complexity = <math>O(n^3)</math>
| pf_height = <math>O(n^2)</math>
| pf_width = <math>2n</math>
| input_data = <math>n^2</math>
| output_data = <math>n</math>
}}

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

=== Общее описание алгоритма ===
Задача нахождения собственных значений и собственных векторов матриц(СЗВМ) является одной из основных задач для многих разделов физики. <ref>Чечин Г.М., Зехцер М.Ю. Собственные значения и собственные векторы матриц</ref> С такой вычислительной проблемой приходится сталкиваться, например, при исследовании собственных колебаний различных механических систем, колебательных и электронных спектров молекул и кристаллов. Совершенно принципиальное значение эта проблема приобрела после создания в тридцатых годах прошлого века квантовой механики, которая стала базовой дисциплиной исследования микромира.Кроме того, данная проблема важна в теории автоматического управления, как инструмент исследования устойчивости линейных систем.

Метод Якоби приводит симметричную действительную матрицу к диагональной форме с помощью некоторой (в принципе, бесконечной) последовательности плоских вращений в разных плоскостях исходного n-мерного векторного пространства. Метод Якоби состоит из некоторой последовательности шагов, на каждом из которых обнуляется один из внедиагональных элементов (обычно наибольший по модулю), в результате чего старая матрица <math>A_{i}</math> преобразуется в некоторую новую матрицу <math>A_{i+1}</math>. Делается это с помощью преобразования подобия, использующего матрицу плоского вращения <math>J_{i}</math> (подробное описание матрицы плоского вращения приведено ниже в разделе "[[#Математическое описание алгоритма|Математическое описание алгоритма]]"), которая изменяет лишь две координаты <math>n</math>-мерных векторов, а именно, координаты с номерами <math>j</math> и <math>k</math>. При таком шаге матрица <math>A_{i+1}</math> отличается от матрицы <math>A_{i}</math> лишь элементами двух строк с номерами <math>j</math>, <math>k</math> и двух столбцов с теми же номерами (<math>j</math> и <math>k</math>). Все же другие элементы матрицы A остаются неизменными. Число шагов, за которое матрица A приводится таким способом к диагональной форме, в общем случае является бесконечным. (это свойство метода Якоби более подробно рассмотрено в разделе "[[#Свойства алгоритма|Свойства алгоритма]]") В результате метод Якоби представляет собой некоторый бесконечный итерационный процесс, на каждом шаге которого преобразующаяся матрица становится всё более и более близкой к диагональной форме (в смысле уменьшения суммы квадратов всех своих внедиагональных элементов). На практике обычно выбирается заранее заданная погрешность <math>\varepsilon</math> и процесс приведения исходной матрицы к диагональному виду прекращается, когда наибольший по модулю внедиагональный элемент матрицы становится меньше <math>\varepsilon</math>. Таким образом, применяя на практике метод Якоби, мы приводим исходную матрицу к диагональной форме с точностью до некоторой вычислительной погрешности <math>\varepsilon</math> в результате конечного числа шагов. Повышение этой точности требует увеличения числа шагов метода Якоби. В конечном итоге у полученной в результате этого процесса матрицы на диагонали будут находиться все собственные значения (с определённой погрешностью) исходной симметрической матрицы.

==== Симметричность матрицы ====

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

=== Математическое описание алгоритма ===
Пусть <math>A = A_0</math> — симметричная матрица. В методе Якоби для <math>A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,...</math>, которая в конечном счёте сходится к диагональной матрице, у которой диагональными элементами являются все собственные значения матрицы <math>A</math>. Матрица <math>A_{i}</math> получается из матрицы <math>A_{i-1}</math> по формуле
<math>A_{i}=J^{T}_iA_{i-1}J_i ,</math>
где <math>J_i</math> - ортогональная матрица, называемая ''вращением Якоби''. Таким образом,
<math>A_{m}=J^{T}_{m-1}A_{m-1}J_{m-1}</math>
<math>=J^{T}_{m-1}J^{T}_{m-2}A_{m-2}J_{m-2}J_{m-1}</math>
<math>=J^{T}_{m-1}...J^{T}_{0}A_{0}J_{0}...J_{m-1}</math>
<math>=J^{T}AJ</math>
При подходящем выборе вращений <math>J_i</math> матрица <math>A_m</math> для больших <math>m</math> будет близкой к диагональной матрице <math>\Lambda</math> <ref>Дж. Деммель, Вычислительная линейная алгебра. Теория и приложения. Перевод Х.Д.Икрамов</ref>. Таким образом, <math>\Lambda \approx J^{T}AJ</math> или <math>J\Lambda J^{T} \approx A</math>, следовательно, столбцы матрицы <math>J</math> являются собственными значениями матрицы <math>A</math>.
Матрица <math>J_i</math> выбирается таким образом, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}=J^{T}_{i}A_{i}J_{i}</math>:

                                                                            
<math>j</math>
                       
<math>k</math>

<math>
J_i = R(j,k,\theta) \equiv
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & -\sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Угол вращения <math>\theta</math> выбирается так, чтобы элементы <math>(j,k)</math> и <math>(k,j)</math> в <math>A_{i+1}</math> стали нулями. Для того, чтобы найти <math>\theta</math>, составляется уравнение:
:<math>
\begin{bmatrix}
a^{i+1}_{jj}&a^{i+1}_{jk}\\
a^{i+1}_{kj}&a^{i+1}_{kk}\\
\end{bmatrix} =
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix}^T
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix}
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix} =
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} ,
</math>
где <math>\lambda_1</math> и <math>\lambda_2</math> - собственные значения подматрицы
:<math>
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix} .
</math>
Пусть <math>c = \cos(\theta)</math> и <math>s = sin(\theta)</math>, <math>a^{i}_{lk} = a_{lk}</math>. Тогда из предыдущего равенства получаем
:<math>
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} =
\begin{bmatrix}
a_{jj}c^2 + a_{kk}s^2+2sca_{jk}&sc(a_{kk} - a{jj}) + a_{jk}(c^2-s^2)\\
sc(a_{kk} - a{jj}) + a_{jk}(c^2-s^2)&a_{jj}s^2 + a_{kk}c^2-2sca_{jk}\\
\end{bmatrix}
.
</math>
Приравнивая внедиагональный элемент к нулю, получаем
:<math>
\frac{a_{jj} - a{kk}}{2a_{jk}} = \frac{c^2-s^2}{2sc} = ctg(2\theta) = r.
</math>
Пусть <math>tg(\theta) = t = \frac{s}{c}</math> . Заметим, что выполняется квадратное уравнение <math>t^2 + 2rt - 1 = 0</math> . Решая уравнение, получаем <math>t = \frac{sign(r)}{|r| + \sqrt{1+r^2}}</math> . Следовательно <math>c = \frac{1}{\sqrt{1+t^2}}</math>, <math>s = ct</math>

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

Вычислительным ядром отдельной итерации является вычисление элементов матрицы <math>A</math> при применении поворота Якоби. Конкретно, изменяются 2 строки и 2 столбца, что означает изменение 4n элементов. Отметим, что вычисление нового значения одного элемента требует 2 операции умножения и одну операцию сложения, что позволяет утверждать, что основной вклад в вычислительное ядро вносят умножения.
Однако в целом, следует отметить, что число операций в алгоритме во многом определяется общим числом итераций, а оно квадратично, в то время как отдельная итерация имеет линейную сложность. Более того, так как алгоритм является итерационным и останавливается при достижении некоторой точности, число итераций может изменяться в зависимости от желаемой точности.

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

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

1) Блок вычисления параметров вращения на текущей итерации (выбор обнуляемого элемента и расчет угла вращения).

2)Блок, реализующий непосредственно вращение Якоби.

=== Схема реализации последовательного алгоритма ===
Канонический вариант:
1)Находится максимальный наддиагональный элемент <math>a_{jk}</math> матрицы <math>A</math>.

2)Вычисляются параметры вращения Якоби:
<math>\tau= \frac{(a_{jj}-a_{kk})}{2a_{jk}}</math>
<math>t=sign(\tau)(|\tau|+\sqrt{1+\tau^2})</math>
<math>c= \frac{1}{1+\sqrt{1+\tau^2}}</math>
<math>s=c*t</math>

3)К текущей матрице А применяются вращения с вычисленными параметрами:
<math>A=R^T(j,k,\theta)*A*R(j,k,\theta)</math>
Стоит отметить, что вычисленные на предыдущем шаге <math>c</math> и <math>s</math> есть <math>\cos {\theta}</math> и <math>\sin {\theta}</math> соответственно.

4)Если матрица А не достаточно близка к диагональной, происходит переход к шагу 1.

Вообще говоря, несмотря на то, что поворот, обеспечивающий обнуление наибольшего внедиагонального элемента, обеспечивает схождение метода за наименьшее число итераций, поиск данного наибольшего элемента добавляет порядка <math>n^2</math> операций сравнения, а возможно и присваивания на каждой итерации.
Поэтому с вычислительной точки зрения выгоднее не выбирать наибольший элемент, а по очереди перебирать все наддиагональные элементы, большие заданного порога.

В последующих разделах рассматривается именно такой вариант алгоритма.

=== Последовательная сложность алгоритма ===
Сначала оценим сложность одной итерации:

1)Так как элементы матрицы никак не упорядоченны, поиск наибольшего элемента линейно зависит от числа элементов над диагональю.
Конкретнее, на данном шаге происходит <math>\frac{n*(n-1)}{2} -1</math> сравнение.

2)3 операции деления, 2 операции взятия корня, 4 операции умножения и 4 операции сложения/вычитания.

3)<math>4*n</math> операций умножения и <math>2*n</math> операций сложения.

4)операция сравнения

В наиболее неудачном случае количество итераций в теории равняется числу наддиагональных элементов, т.е. <math>\frac{n*(n-1)}{2}</math>
На практике же из-за накопления ошибок вычисления а так же восстановления уже обнуленных элементов при некоторых вращениях, число операций возрастает.
Вместе с тем, можно утверждать, что порядок числа итераций можно оценить как <math>O(N^2)</math>.
Таким образом, суммарная сложность алгоритма составляет <math>O(N^4)</math> сравнений, и <math>O(N^3)</math> сложений и умножений.

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

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

Аналитически информационный граф данного алгоритма можно описать следующим образом:

1)Последовательно идущие макроярусы вычисления параметров текущей итерации и вращения Якоби с этими параметрами
Число данных ярусов варьируется в зависимости от входных данных, но порядок составляет <math>O(n^2)</math>.

2)Вычисление параметров текущей итерации содержит конечное число операций умножения, сложения и вычисления квадратного корня.

3)Макроярус вращения Якоби содержит вычисление <math>4n</math> элементов матрицы. На данном ярусе ширина графа достигает максимального значения.

Визуальное представление графа алгоритма представлено на схемах ниже:

[[file:SI.jpg|thumb|center|1400px|Рисунок 1. Граф алгоритма на макроуровне. Rarams - вычисление параметров, Rotate - получение <math>A_{i+1}</math> из <math>A_{i}</math>.]]

[[file:exec_params.jpg|thumb|center|1400px|Рисунок 2. Структура блока Params.]]

[[file:Rotate.jpg|thumb|center|1400px|Рисунок 3. Структура блока Rotate.]]

=== Ресурс параллелизма алгоритма ===
Как видно из представления алгоритма в ярусно-параллельной форме ([[#Информационный граф| п.1.7]]), максимальная ширина ярусов составляет <math>2n</math> вершин.
Для выполнения данного алгоритма в параллельном варианте следует выполнить <math>O(\frac{n(n+1)}{2})</math> итераций.
Рассмотрим отдельную итерацию с точки зрения ярусно-параллельной формы алгоритма.

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

2)Выполнение 2 ярусов вычисления элементов в изменяемых строках и столбцах.

На данных двух ярусах осуществляется <math>4n</math> умножений и <math>2n</math> сложений. Данный вид параллелизма относится к координатному. Так как каждая последующая итерация алгоритма зависит от предыдущей, их выполнение распараллелить не представляется возможным. Таким образом, при наличии бесконечного числа процессоров, итоговая сложность алгоритма составляет <math>O(\frac{n(n+1)}{2})</math>

=== Входные и выходные данные алгоритма ===
'''Входные данные''': плотная матрица <math>A</math> (элементы <math>a_{ij}</math>); при этом <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>..

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы).
Конкретный вариант хранения данных зависит от реализации. В качестве примеров можно привести хранение в одномерном массиве длины <math>\frac{n (n + 1)}{2}</math> по строкам своей нижней части, хранение в виде так называемого ступенчатого массива (такой вариант двумерного массива, в котором каждая строка имеет свой размер).

'''Выходные данные''': вектор собственных значений <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>) длины <math>n</math>.

=== Свойства алгоритма ===
Параллельная сложность выполнения алгоритма составляет <math>O(\frac{n(n+1)}{2}).</math>
Последовательная сложность выполнения алгоритма составляет <math>O(\frac{n^2(n+1)}{2}).</math>
Таким образом, соотношение сложностей является линейным.
Более того, и вычислительная мощность данного алгоритма линейна.

В алгоритме используется примерно в два раза больше операций умножения, чем сложения.
Одельно стоит рассмотреть вопрос хранения матрицы А в процессе работы алгоритма. Хранение лишь нижней или верхней части матрицы в виде одномерного массива возможно; более того, хранение в таком виде обеспечивает экономию памяти в 2 раза и защищает от ассиметричности матрицы в результате накопления математических ошибок. Однако, вычисление индексов <math>i</math> и <math>j</math> элементов <math>a_{ij}</math>, соответствующих данному номеру <math>k</math> вообще говоря требует отдельного цикла, что создает дополнительную нагрузку на процессор.

Кроме того, следует отметить следующие особенности алгоритма:

1)Несмотря на то, что выбор наибольшего наддиагонального элемента, как кандидата на обнуление, кажется оптимальным, на самом деле он таковым не является. При таком выборе элемента, на каждой итерации необходимо находить текущий наибольший элемент в матрице, что требует дополнительных <math>\frac{n*(n-1)}{2}</math> операций сравнения и приводит к увеличению сложности алгоритма до <math>O(n^4)</math>. Вместо этого рекомендуется перебирать по очереди все наддиагональные элементы, большие заданного параметра. В большинстве случаев от 4 до 8 полных проходов достаточно для приближения исходной матрицы к диагональной.

2)Если при выборе в качестве обнуляемого элемента <math>a_{ij}</math> элементы <math>a_{ii} = a_{jj}</math>, то, как видно из формул в пунктах выше, матрицы поворота вырождаются в единичные и матрица на данной итерации не изменяется. Это еще один довод в пользу отказа от выбора наибольшего элемента, т.к. в данном случае произойдет зацикливание алгоритма.

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

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

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

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

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

1)Библиотека [https://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE] содержит последовательную реализацию алгоритма.

2)В цифровой библиотеке ieee.org приводится [http://ieeexplore.ieee.org/document/6310877/ аннотация] статьи 2012 года, в которой авторы описывают реализацию данного алгоритма на CUDA.

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

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-10-15T14:38:02Z

Пронин Андрей: /* Ресурс параллелизма алгоритма */

{{algorithm
| name = Метод Якоби вычисления собственных значений симметричной матрицы ЗП
| serial_complexity = <math>O(n^3)</math>
| pf_height = <math>O(n^2)</math>
| pf_width = <math>2n</math>
| input_data = <math>n^2</math>
| output_data = <math>n</math>
}}

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

=== Общее описание алгоритма ===
Задача нахождения собственных значений и собственных векторов матриц(СЗВМ) является одной из основных задач для многих разделов физики. <ref>Чечин Г.М., Зехцер М.Ю. Собственные значения и собственные векторы матриц</ref> С такой вычислительной проблемой приходится сталкиваться, например, при исследовании собственных колебаний различных механических систем, колебательных и электронных спектров молекул и кристаллов. Совершенно принципиальное значение эта проблема приобрела после создания в тридцатых годах прошлого века квантовой механики, которая стала базовой дисциплиной исследования микромира.Кроме того, данная проблема важна в теории автоматического управления, как инструмент исследования устойчивости линейных систем.

Метод Якоби приводит симметричную действительную матрицу к диагональной форме с помощью некоторой (в принципе, бесконечной) последовательности плоских вращений в разных плоскостях исходного n-мерного векторного пространства. Метод Якоби состоит из некоторой последовательности шагов, на каждом из которых обнуляется один из внедиагональных элементов (обычно наибольший по модулю), в результате чего старая матрица <math>A_{i}</math> преобразуется в некоторую новую матрицу <math>A_{i+1}</math>. Делается это с помощью преобразования подобия, использующего матрицу плоского вращения <math>J_{i}</math> (подробное описание матрицы плоского вращения приведено ниже в разделе "[[#Математическое описание алгоритма|Математическое описание алгоритма]]"), которая изменяет лишь две координаты <math>n</math>-мерных векторов, а именно, координаты с номерами <math>j</math> и <math>k</math>. При таком шаге матрица <math>A_{i+1}</math> отличается от матрицы <math>A_{i}</math> лишь элементами двух строк с номерами <math>j</math>, <math>k</math> и двух столбцов с теми же номерами (<math>j</math> и <math>k</math>). Все же другие элементы матрицы A остаются неизменными. Число шагов, за которое матрица A приводится таким способом к диагональной форме, в общем случае является бесконечным. (это свойство метода Якоби более подробно рассмотрено в разделе "[[#Свойства алгоритма|Свойства алгоритма]]") В результате метод Якоби представляет собой некоторый бесконечный итерационный процесс, на каждом шаге которого преобразующаяся матрица становится всё более и более близкой к диагональной форме (в смысле уменьшения суммы квадратов всех своих внедиагональных элементов). На практике обычно выбирается заранее заданная погрешность <math>\varepsilon</math> и процесс приведения исходной матрицы к диагональному виду прекращается, когда наибольший по модулю внедиагональный элемент матрицы становится меньше <math>\varepsilon</math>. Таким образом, применяя на практике метод Якоби, мы приводим исходную матрицу к диагональной форме с точностью до некоторой вычислительной погрешности <math>\varepsilon</math> в результате конечного числа шагов. Повышение этой точности требует увеличения числа шагов метода Якоби. В конечном итоге у полученной в результате этого процесса матрицы на диагонали будут находиться все собственные значения (с определённой погрешностью) исходной симметрической матрицы.

==== Симметричность матрицы ====

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

=== Математическое описание алгоритма ===
Пусть <math>A = A_0</math> — симметричная матрица. В методе Якоби для <math>A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,...</math>, которая в конечном счёте сходится к диагональной матрице, у которой диагональными элементами являются все собственные значения матрицы <math>A</math>. Матрица <math>A_{i}</math> получается из матрицы <math>A_{i-1}</math> по формуле
<math>A_{i}=J^{T}_iA_{i-1}J_i ,</math>
где <math>J_i</math> - ортогональная матрица, называемая ''вращением Якоби''. Таким образом,
<math>A_{m}=J^{T}_{m-1}A_{m-1}J_{m-1}</math>
<math>=J^{T}_{m-1}J^{T}_{m-2}A_{m-2}J_{m-2}J_{m-1}</math>
<math>=J^{T}_{m-1}...J^{T}_{0}A_{0}J_{0}...J_{m-1}</math>
<math>=J^{T}AJ</math>
При подходящем выборе вращений <math>J_i</math> матрица <math>A_m</math> для больших <math>m</math> будет близкой к диагональной матрице <math>\Lambda</math> <ref>Дж. Деммель, Вычислительная линейная алгебра. Теория и приложения. Перевод Х.Д.Икрамов</ref>. Таким образом, <math>\Lambda \approx J^{T}AJ</math> или <math>J\Lambda J^{T} \approx A</math>, следовательно, столбцы матрицы <math>J</math> являются собственными значениями матрицы <math>A</math>.
Матрица <math>J_i</math> выбирается таким образом, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}=J^{T}_{i}A_{i}J_{i}</math>:

                                                                            
<math>j</math>
                       
<math>k</math>

<math>
J_i = R(j,k,\theta) \equiv
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & -\sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Угол вращения <math>\theta</math> выбирается так, чтобы элементы <math>(j,k)</math> и <math>(k,j)</math> в <math>A_{i+1}</math> стали нулями. Для того, чтобы найти <math>\theta</math>, составляется уравнение:
:<math>
\begin{bmatrix}
a^{i+1}_{jj}&a^{i+1}_{jk}\\
a^{i+1}_{kj}&a^{i+1}_{kk}\\
\end{bmatrix} =
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix}^T
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix}
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix} =
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} ,
</math>
где <math>\lambda_1</math> и <math>\lambda_2</math> - собственные значения подматрицы
:<math>
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix} .
</math>
Пусть <math>c = \cos(\theta)</math> и <math>s = sin(\theta)</math>, <math>a^{i}_{lk} = a_{lk}</math>. Тогда из предыдущего равенства получаем
:<math>
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} =
\begin{bmatrix}
a_{jj}c^2 + a_{kk}s^2+2sca_{jk}&sc(a_{kk} - a{jj}) + a_{jk}(c^2-s^2)\\
sc(a_{kk} - a{jj}) + a_{jk}(c^2-s^2)&a_{jj}s^2 + a_{kk}c^2-2sca_{jk}\\
\end{bmatrix}
.
</math>
Приравнивая внедиагональный элемент к нулю, получаем
:<math>
\frac{a_{jj} - a{kk}}{2a_{jk}} = \frac{c^2-s^2}{2sc} = ctg(2\theta) = r.
</math>
Пусть <math>tg(\theta) = t = \frac{s}{c}</math> . Заметим, что выполняется квадратное уравнение <math>t^2 + 2rt - 1 = 0</math> . Решая уравнение, получаем <math>t = \frac{sign(r)}{|r| + \sqrt{1+r^2}}</math> . Следовательно <math>c = \frac{1}{\sqrt{1+t^2}}</math>, <math>s = ct</math>

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

Вычислительным ядром отдельной итерации является вычисление элементов матрицы <math>A</math> при применении поворота Якоби. Конкретно, изменяются 2 строки и 2 столбца, что означает изменение 4n элементов. Отметим, что вычисление нового значения одного элемента требует 2 операции умножения и одну операцию сложения, что позволяет утверждать, что основной вклад в вычислительное ядро вносят умножения.
Однако в целом, следует отметить, что число операций в алгоритме во многом определяется общим числом итераций, а оно квадратично, в то время как отдельная итерация имеет линейную сложность. Более того, так как алгоритм является итерационным и останавливается при достижении некоторой точности, число итераций может изменяться в зависимости от желаемой точности.

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

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

1) Блок вычисления параметров вращения на текущей итерации (выбор обнуляемого элемента и расчет угла вращения).

2)Блок, реализующий непосредственно вращение Якоби.

=== Схема реализации последовательного алгоритма ===
Канонический вариант:
1)Находится максимальный наддиагональный элемент <math>a_{jk}</math> матрицы <math>A</math>.

2)Вычисляются параметры вращения Якоби:
<math>\tau= \frac{(a_{jj}-a_{kk})}{2a_{jk}}</math>
<math>t=sign(\tau)(|\tau|+\sqrt{1+\tau^2})</math>
<math>c= \frac{1}{1+\sqrt{1+\tau^2}}</math>
<math>s=c*t</math>

3)К текущей матрице А применяются вращения с вычисленными параметрами:
<math>A=R^T(j,k,\theta)*A*R(j,k,\theta)</math>
Стоит отметить, что вычисленные на предыдущем шаге <math>c</math> и <math>s</math> есть <math>\cos {\theta}</math> и <math>\sin {\theta}</math> соответственно.

4)Если матрица А не достаточно близка к диагональной, происходит переход к шагу 1.

Вообще говоря, несмотря на то, что поворот, обеспечивающий обнуление наибольшего внедиагонального элемента, обеспечивает схождение метода за наименьшее число итераций, поиск данного наибольшего элемента добавляет порядка <math>n^2</math> операций сравнения, а возможно и присваивания на каждой итерации.
Поэтому с вычислительной точки зрения выгоднее не выбирать наибольший элемент, а по очереди перебирать все наддиагональные элементы, большие заданного порога.

В последующих разделах рассматривается именно такой вариант алгоритма.

=== Последовательная сложность алгоритма ===
Сначала оценим сложность одной итерации:

1)Так как элементы матрицы никак не упорядоченны, поиск наибольшего элемента линейно зависит от числа элементов над диагональю.
Конкретнее, на данном шаге происходит <math>\frac{n*(n-1)}{2} -1</math> сравнение.

2)3 операции деления, 2 операции взятия корня, 4 операции умножения и 4 операции сложения/вычитания.

3)<math>4*n</math> операций умножения и <math>2*n</math> операций сложения.

4)операция сравнения

В наиболее неудачном случае количество итераций в теории равняется числу наддиагональных элементов, т.е. <math>\frac{n*(n-1)}{2}</math>
На практике же из-за накопления ошибок вычисления а так же восстановления уже обнуленных элементов при некоторых вращениях, число операций возрастает.
Вместе с тем, можно утверждать, что порядок числа итераций можно оценить как <math>O(N^2)</math>.
Таким образом, суммарная сложность алгоритма составляет <math>O(N^4)</math> сравнений, и <math>O(N^3)</math> сложений и умножений.

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

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

Аналитически информационный граф данного алгоритма можно описать следующим образом:

1)Последовательно идущие макроярусы вычисления параметров текущей итерации и вращения Якоби с этими параметрами
Число данных ярусов варьируется в зависимости от входных данных, но порядок составляет <math>O(n^2)</math>.

2)Вычисление параметров текущей итерации содержит конечное число операций умножения, сложения и вычисления квадратного корня.

3)Макроярус вращения Якоби содержит вычисление <math>4n</math> элементов матрицы. На данном ярусе ширина графа достигает максимального значения.

Визуальное представление графа алгоритма представлено на схемах ниже:

[[file:SI.jpg|thumb|center|1400px|Рисунок 1. Граф алгоритма на макроуровне. Rarams - вычисление параметров, Rotate - получение <math>A_{i+1}</math> из <math>A_{i}</math>.]]

[[file:exec_params.jpg|thumb|center|1400px|Рисунок 2. Структура блока Params.]]

[[file:Rotate.jpg|thumb|center|1400px|Рисунок 3. Структура блока Rotate.]]

=== Ресурс параллелизма алгоритма ===
Как видно из представления алгоритма в ярусно-параллельной форме ([[#Информационный граф| п.1.7]]), максимальная ширина ярусов составляет <math>2n</math> вершин.
Для выполнения данного алгоритма в параллельном варианте следует выполнить <math>O(\frac{n(n+1)}{2})</math> итераций.
Рассмотрим отдельную итерацию с точки зрения ярусно-параллельной формы алгоритма.

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

2)Выполнение 2 ярусов вычисления элементов в изменяемых строках и столбцах.

На данных двух ярусах осуществляется <math>4n</math> умножений и <math>2n</math> сложений. Данный вид параллелизма относится к координатному. Так как каждая последующая итерация алгоритма зависит от предыдущей, их выполнение распараллелить не представляется возможным. Таким образом, при наличии бесконечного числа процессоров, итоговая сложность алгоритма составляет <math>O(\frac{n(n+1)}{2})</math>

=== Входные и выходные данные алгоритма ===
'''Входные данные''': плотная матрица <math>A</math> (элементы <math>a_{ij}</math>); при этом <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>..

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы).
Конкретный вариант хранения данных зависит от реализации. В качестве примеров можно привести хранение в одномерном массиве длины <math>\frac{n (n + 1)}{2}</math> по строкам своей нижней части, хранение в виде так называемого ступенчатого массива (такой вариант двумерного массива, в котором каждая строка имеет свой размер).

'''Выходные данные''': вектор собственных значений <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>) длины <math>n</math>.

=== Свойства алгоритма ===
Параллельная сложность выполнения алгоритма составляет <math>O(\frac{n(n+1)}{2}).</math>
Последовательная сложность выполнения алгоритма составляет <math>O(\frac{n^2(n+1)}{2}).</math>
Таким образом, соотношение сложностей является линейным.
Более того, и вычислительная мощность данного алгоритма линейна.

В алгоритме используется примерно в два раза больше операций умножения, чем сложения.
Одельно стоит рассмотреть вопрос хранения матрицы А в процессе работы алгоритма. Хранение лишь нижней или верхней части матрицы в виде одномерного массива возможно; более того, хранение в таком виде обеспечивает экономию памяти в 2 раза и защищает от ассиметричности матрицы в результате накопления математических ошибок. Однако, вычисление индексов <math>i</math> и <math>j</math> элементов <math>a_{ij}</math>, соответствующих данному номеру <math>k</math> вообще говоря требует отдельного цикла, что создает дополнительную нагрузку на процессор.

Кроме того, следует отметить следующие особенности алгоритма:

1)Несмотря на то, что выбор наибольшего наддиагонального элемента, как кандидата на обнуление, кажется оптимальным, на самом деле он таковым не является. При таком выборе элемента, на каждой итерации необходимо находить текущий наибольший элемент в матрице, что требует дополнительных <math>\frac{n*(n-1)}{2}</math> операций сравнения и приводит к увеличению сложности алгоритма до <math>O(n^4)</math>. Вместо этого рекомендуется перебирать по очереди все наддиагональные элементы, большие заданного параметра. В большинстве случаев от 4 до 8 полных проходов достаточно для приближения исходной матрицы к диагональной.

2)Если при выборе в качестве обнуляемого элемента <math>a_{ij}</math> элементы <math>a_{ii} = a_{jj}</math>, то, как видно из формул в пунктах выше, матрицы поворота вырождаются в единичные и матрица на данной итерации не изменяется. Это еще один довод в пользу отказа от выбора наибольшего элемента, т.к. в данном случае произойдет зацикливание алгоритма.

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

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

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

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

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

1)Библиотека [https://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE] содержит последовательную реализацию алгоритма.

2)В цифровой библиотеке ieee.org приводится [http://ieeexplore.ieee.org/document/6310877/ аннотация] статьи 2012 года, в которой авторы описывают реализацию данного алгоритма на CUDA.

3)

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

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-10-15T14:36:16Z

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

{{algorithm
| name = Метод Якоби вычисления собственных значений симметричной матрицы ЗП
| serial_complexity = <math>O(n^3)</math>
| pf_height = <math>O(n^2)</math>
| pf_width = <math>2n</math>
| input_data = <math>n^2</math>
| output_data = <math>n</math>
}}

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

=== Общее описание алгоритма ===
Задача нахождения собственных значений и собственных векторов матриц(СЗВМ) является одной из основных задач для многих разделов физики. <ref>Чечин Г.М., Зехцер М.Ю. Собственные значения и собственные векторы матриц</ref> С такой вычислительной проблемой приходится сталкиваться, например, при исследовании собственных колебаний различных механических систем, колебательных и электронных спектров молекул и кристаллов. Совершенно принципиальное значение эта проблема приобрела после создания в тридцатых годах прошлого века квантовой механики, которая стала базовой дисциплиной исследования микромира.Кроме того, данная проблема важна в теории автоматического управления, как инструмент исследования устойчивости линейных систем.

Метод Якоби приводит симметричную действительную матрицу к диагональной форме с помощью некоторой (в принципе, бесконечной) последовательности плоских вращений в разных плоскостях исходного n-мерного векторного пространства. Метод Якоби состоит из некоторой последовательности шагов, на каждом из которых обнуляется один из внедиагональных элементов (обычно наибольший по модулю), в результате чего старая матрица <math>A_{i}</math> преобразуется в некоторую новую матрицу <math>A_{i+1}</math>. Делается это с помощью преобразования подобия, использующего матрицу плоского вращения <math>J_{i}</math> (подробное описание матрицы плоского вращения приведено ниже в разделе "[[#Математическое описание алгоритма|Математическое описание алгоритма]]"), которая изменяет лишь две координаты <math>n</math>-мерных векторов, а именно, координаты с номерами <math>j</math> и <math>k</math>. При таком шаге матрица <math>A_{i+1}</math> отличается от матрицы <math>A_{i}</math> лишь элементами двух строк с номерами <math>j</math>, <math>k</math> и двух столбцов с теми же номерами (<math>j</math> и <math>k</math>). Все же другие элементы матрицы A остаются неизменными. Число шагов, за которое матрица A приводится таким способом к диагональной форме, в общем случае является бесконечным. (это свойство метода Якоби более подробно рассмотрено в разделе "[[#Свойства алгоритма|Свойства алгоритма]]") В результате метод Якоби представляет собой некоторый бесконечный итерационный процесс, на каждом шаге которого преобразующаяся матрица становится всё более и более близкой к диагональной форме (в смысле уменьшения суммы квадратов всех своих внедиагональных элементов). На практике обычно выбирается заранее заданная погрешность <math>\varepsilon</math> и процесс приведения исходной матрицы к диагональному виду прекращается, когда наибольший по модулю внедиагональный элемент матрицы становится меньше <math>\varepsilon</math>. Таким образом, применяя на практике метод Якоби, мы приводим исходную матрицу к диагональной форме с точностью до некоторой вычислительной погрешности <math>\varepsilon</math> в результате конечного числа шагов. Повышение этой точности требует увеличения числа шагов метода Якоби. В конечном итоге у полученной в результате этого процесса матрицы на диагонали будут находиться все собственные значения (с определённой погрешностью) исходной симметрической матрицы.

==== Симметричность матрицы ====

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

=== Математическое описание алгоритма ===
Пусть <math>A = A_0</math> — симметричная матрица. В методе Якоби для <math>A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,...</math>, которая в конечном счёте сходится к диагональной матрице, у которой диагональными элементами являются все собственные значения матрицы <math>A</math>. Матрица <math>A_{i}</math> получается из матрицы <math>A_{i-1}</math> по формуле
<math>A_{i}=J^{T}_iA_{i-1}J_i ,</math>
где <math>J_i</math> - ортогональная матрица, называемая ''вращением Якоби''. Таким образом,
<math>A_{m}=J^{T}_{m-1}A_{m-1}J_{m-1}</math>
<math>=J^{T}_{m-1}J^{T}_{m-2}A_{m-2}J_{m-2}J_{m-1}</math>
<math>=J^{T}_{m-1}...J^{T}_{0}A_{0}J_{0}...J_{m-1}</math>
<math>=J^{T}AJ</math>
При подходящем выборе вращений <math>J_i</math> матрица <math>A_m</math> для больших <math>m</math> будет близкой к диагональной матрице <math>\Lambda</math> <ref>Дж. Деммель, Вычислительная линейная алгебра. Теория и приложения. Перевод Х.Д.Икрамов</ref>. Таким образом, <math>\Lambda \approx J^{T}AJ</math> или <math>J\Lambda J^{T} \approx A</math>, следовательно, столбцы матрицы <math>J</math> являются собственными значениями матрицы <math>A</math>.
Матрица <math>J_i</math> выбирается таким образом, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}=J^{T}_{i}A_{i}J_{i}</math>:

                                                                            
<math>j</math>
                       
<math>k</math>

<math>
J_i = R(j,k,\theta) \equiv
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & -\sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Угол вращения <math>\theta</math> выбирается так, чтобы элементы <math>(j,k)</math> и <math>(k,j)</math> в <math>A_{i+1}</math> стали нулями. Для того, чтобы найти <math>\theta</math>, составляется уравнение:
:<math>
\begin{bmatrix}
a^{i+1}_{jj}&a^{i+1}_{jk}\\
a^{i+1}_{kj}&a^{i+1}_{kk}\\
\end{bmatrix} =
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix}^T
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix}
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix} =
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} ,
</math>
где <math>\lambda_1</math> и <math>\lambda_2</math> - собственные значения подматрицы
:<math>
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix} .
</math>
Пусть <math>c = \cos(\theta)</math> и <math>s = sin(\theta)</math>, <math>a^{i}_{lk} = a_{lk}</math>. Тогда из предыдущего равенства получаем
:<math>
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} =
\begin{bmatrix}
a_{jj}c^2 + a_{kk}s^2+2sca_{jk}&sc(a_{kk} - a{jj}) + a_{jk}(c^2-s^2)\\
sc(a_{kk} - a{jj}) + a_{jk}(c^2-s^2)&a_{jj}s^2 + a_{kk}c^2-2sca_{jk}\\
\end{bmatrix}
.
</math>
Приравнивая внедиагональный элемент к нулю, получаем
:<math>
\frac{a_{jj} - a{kk}}{2a_{jk}} = \frac{c^2-s^2}{2sc} = ctg(2\theta) = r.
</math>
Пусть <math>tg(\theta) = t = \frac{s}{c}</math> . Заметим, что выполняется квадратное уравнение <math>t^2 + 2rt - 1 = 0</math> . Решая уравнение, получаем <math>t = \frac{sign(r)}{|r| + \sqrt{1+r^2}}</math> . Следовательно <math>c = \frac{1}{\sqrt{1+t^2}}</math>, <math>s = ct</math>

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

Вычислительным ядром отдельной итерации является вычисление элементов матрицы <math>A</math> при применении поворота Якоби. Конкретно, изменяются 2 строки и 2 столбца, что означает изменение 4n элементов. Отметим, что вычисление нового значения одного элемента требует 2 операции умножения и одну операцию сложения, что позволяет утверждать, что основной вклад в вычислительное ядро вносят умножения.
Однако в целом, следует отметить, что число операций в алгоритме во многом определяется общим числом итераций, а оно квадратично, в то время как отдельная итерация имеет линейную сложность. Более того, так как алгоритм является итерационным и останавливается при достижении некоторой точности, число итераций может изменяться в зависимости от желаемой точности.

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

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

1) Блок вычисления параметров вращения на текущей итерации (выбор обнуляемого элемента и расчет угла вращения).

2)Блок, реализующий непосредственно вращение Якоби.

=== Схема реализации последовательного алгоритма ===
Канонический вариант:
1)Находится максимальный наддиагональный элемент <math>a_{jk}</math> матрицы <math>A</math>.

2)Вычисляются параметры вращения Якоби:
<math>\tau= \frac{(a_{jj}-a_{kk})}{2a_{jk}}</math>
<math>t=sign(\tau)(|\tau|+\sqrt{1+\tau^2})</math>
<math>c= \frac{1}{1+\sqrt{1+\tau^2}}</math>
<math>s=c*t</math>

3)К текущей матрице А применяются вращения с вычисленными параметрами:
<math>A=R^T(j,k,\theta)*A*R(j,k,\theta)</math>
Стоит отметить, что вычисленные на предыдущем шаге <math>c</math> и <math>s</math> есть <math>\cos {\theta}</math> и <math>\sin {\theta}</math> соответственно.

4)Если матрица А не достаточно близка к диагональной, происходит переход к шагу 1.

Вообще говоря, несмотря на то, что поворот, обеспечивающий обнуление наибольшего внедиагонального элемента, обеспечивает схождение метода за наименьшее число итераций, поиск данного наибольшего элемента добавляет порядка <math>n^2</math> операций сравнения, а возможно и присваивания на каждой итерации.
Поэтому с вычислительной точки зрения выгоднее не выбирать наибольший элемент, а по очереди перебирать все наддиагональные элементы, большие заданного порога.

В последующих разделах рассматривается именно такой вариант алгоритма.

=== Последовательная сложность алгоритма ===
Сначала оценим сложность одной итерации:

1)Так как элементы матрицы никак не упорядоченны, поиск наибольшего элемента линейно зависит от числа элементов над диагональю.
Конкретнее, на данном шаге происходит <math>\frac{n*(n-1)}{2} -1</math> сравнение.

2)3 операции деления, 2 операции взятия корня, 4 операции умножения и 4 операции сложения/вычитания.

3)<math>4*n</math> операций умножения и <math>2*n</math> операций сложения.

4)операция сравнения

В наиболее неудачном случае количество итераций в теории равняется числу наддиагональных элементов, т.е. <math>\frac{n*(n-1)}{2}</math>
На практике же из-за накопления ошибок вычисления а так же восстановления уже обнуленных элементов при некоторых вращениях, число операций возрастает.
Вместе с тем, можно утверждать, что порядок числа итераций можно оценить как <math>O(N^2)</math>.
Таким образом, суммарная сложность алгоритма составляет <math>O(N^4)</math> сравнений, и <math>O(N^3)</math> сложений и умножений.

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

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

Аналитически информационный граф данного алгоритма можно описать следующим образом:

1)Последовательно идущие макроярусы вычисления параметров текущей итерации и вращения Якоби с этими параметрами
Число данных ярусов варьируется в зависимости от входных данных, но порядок составляет <math>O(n^2)</math>.

2)Вычисление параметров текущей итерации содержит конечное число операций умножения, сложения и вычисления квадратного корня.

3)Макроярус вращения Якоби содержит вычисление <math>4n</math> элементов матрицы. На данном ярусе ширина графа достигает максимального значения.

Визуальное представление графа алгоритма представлено на схемах ниже:

[[file:SI.jpg|thumb|center|1400px|Рисунок 1. Граф алгоритма на макроуровне. Rarams - вычисление параметров, Rotate - получение <math>A_{i+1}</math> из <math>A_{i}</math>.]]

[[file:exec_params.jpg|thumb|center|1400px|Рисунок 2. Структура блока Params.]]

[[file:Rotate.jpg|thumb|center|1400px|Рисунок 3. Структура блока Rotate.]]

=== Ресурс параллелизма алгоритма ===
Как видно из представления алгоритма в ярусно-параллельной форме ([[#Информационный граф| п.1.7]]), максимальная ширина ярусов составляет <math>2n</math> вершин.
Для выполнения данного алгоритма в параллельном варианте следует выполнить <math>O(\frac{n(n+1)}{2})</math> итераций.
Рассмотрим отдельную итерацию с точки зрения ярусно-параллельной формы алгоритма.

1)Выполнение *число_ярусов* ярусов с конечным числом операций

2)Выполнение 2 ярусов вычисления элементов в изменяемых строках и столбцах.

На данных двух ярусах осуществляется <math>4n</math> умножений и <math>2n</math> сложений. Данный вид параллелизма относится к координатному. Так как каждая последующая итерация алгоритма зависит от предыдущей, их выполнение распараллелить не представляется возможным. Таким образом, при наличии бесконечного числа процессоров, итоговая сложность алгоритма составляет <math>O(\frac{n(n+1)}{2})</math>

=== Входные и выходные данные алгоритма ===
'''Входные данные''': плотная матрица <math>A</math> (элементы <math>a_{ij}</math>); при этом <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>..

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы).
Конкретный вариант хранения данных зависит от реализации. В качестве примеров можно привести хранение в одномерном массиве длины <math>\frac{n (n + 1)}{2}</math> по строкам своей нижней части, хранение в виде так называемого ступенчатого массива (такой вариант двумерного массива, в котором каждая строка имеет свой размер).

'''Выходные данные''': вектор собственных значений <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>) длины <math>n</math>.

=== Свойства алгоритма ===
Параллельная сложность выполнения алгоритма составляет <math>O(\frac{n(n+1)}{2}).</math>
Последовательная сложность выполнения алгоритма составляет <math>O(\frac{n^2(n+1)}{2}).</math>
Таким образом, соотношение сложностей является линейным.
Более того, и вычислительная мощность данного алгоритма линейна.

В алгоритме используется примерно в два раза больше операций умножения, чем сложения.
Одельно стоит рассмотреть вопрос хранения матрицы А в процессе работы алгоритма. Хранение лишь нижней или верхней части матрицы в виде одномерного массива возможно; более того, хранение в таком виде обеспечивает экономию памяти в 2 раза и защищает от ассиметричности матрицы в результате накопления математических ошибок. Однако, вычисление индексов <math>i</math> и <math>j</math> элементов <math>a_{ij}</math>, соответствующих данному номеру <math>k</math> вообще говоря требует отдельного цикла, что создает дополнительную нагрузку на процессор.

Кроме того, следует отметить следующие особенности алгоритма:

1)Несмотря на то, что выбор наибольшего наддиагонального элемента, как кандидата на обнуление, кажется оптимальным, на самом деле он таковым не является. При таком выборе элемента, на каждой итерации необходимо находить текущий наибольший элемент в матрице, что требует дополнительных <math>\frac{n*(n-1)}{2}</math> операций сравнения и приводит к увеличению сложности алгоритма до <math>O(n^4)</math>. Вместо этого рекомендуется перебирать по очереди все наддиагональные элементы, большие заданного параметра. В большинстве случаев от 4 до 8 полных проходов достаточно для приближения исходной матрицы к диагональной.

2)Если при выборе в качестве обнуляемого элемента <math>a_{ij}</math> элементы <math>a_{ii} = a_{jj}</math>, то, как видно из формул в пунктах выше, матрицы поворота вырождаются в единичные и матрица на данной итерации не изменяется. Это еще один довод в пользу отказа от выбора наибольшего элемента, т.к. в данном случае произойдет зацикливание алгоритма.

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

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

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

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

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

1)Библиотека [https://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE] содержит последовательную реализацию алгоритма.

2)В цифровой библиотеке ieee.org приводится [http://ieeexplore.ieee.org/document/6310877/ аннотация] статьи 2012 года, в которой авторы описывают реализацию данного алгоритма на CUDA.

3)

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

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-10-15T14:35:55Z

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

{{algorithm
| name = Метод Якоби вычисления собственных значений симметричной матрицы ЗП
| serial_complexity = <math>O(n^3)</math>
| pf_height = <math>O(n^2)</math>
| pf_width = <math>2n</math>
| input_data = <math>n^2</math>
| output_data = <math>n</math>
}}

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

=== Общее описание алгоритма ===
Задача нахождения собственных значений и собственных векторов матриц(СЗВМ) является одной из основных задач для многих разделов физики. <ref>Чечин Г.М., Зехцер М.Ю. Собственные значения и собственные векторы матриц</ref> С такой вычислительной проблемой приходится сталкиваться, например, при исследовании собственных колебаний различных механических систем, колебательных и электронных спектров молекул и кристаллов. Совершенно принципиальное значение эта проблема приобрела после создания в тридцатых годах прошлого века квантовой механики, которая стала базовой дисциплиной исследования микромира.Кроме того, данная проблема важна в теории автоматического управления, как инструмент исследования устойчивости линейных систем.

Метод Якоби приводит симметричную действительную матрицу к диагональной форме с помощью некоторой (в принципе, бесконечной) последовательности плоских вращений в разных плоскостях исходного n-мерного векторного пространства. Метод Якоби состоит из некоторой последовательности шагов, на каждом из которых обнуляется один из внедиагональных элементов (обычно наибольший по модулю), в результате чего старая матрица <math>A_{i}</math> преобразуется в некоторую новую матрицу <math>A_{i+1}</math>. Делается это с помощью преобразования подобия, использующего матрицу плоского вращения <math>J_{i}</math> (подробное описание матрицы плоского вращения приведено ниже в разделе "[[#Математическое описание алгоритма|Математическое описание алгоритма]]"), которая изменяет лишь две координаты <math>n</math>-мерных векторов, а именно, координаты с номерами <math>j</math> и <math>k</math>. При таком шаге матрица <math>A_{i+1}</math> отличается от матрицы <math>A_{i}</math> лишь элементами двух строк с номерами <math>j</math>, <math>k</math> и двух столбцов с теми же номерами (<math>j</math> и <math>k</math>). Все же другие элементы матрицы A остаются неизменными. Число шагов, за которое матрица A приводится таким способом к диагональной форме, в общем случае является бесконечным. (это свойство метода Якоби более подробно рассмотрено в разделе "[[#Свойства алгоритма|Свойства алгоритма]]") В результате метод Якоби представляет собой некоторый бесконечный итерационный процесс, на каждом шаге которого преобразующаяся матрица становится всё более и более близкой к диагональной форме (в смысле уменьшения суммы квадратов всех своих внедиагональных элементов). На практике обычно выбирается заранее заданная погрешность <math>\varepsilon</math> и процесс приведения исходной матрицы к диагональному виду прекращается, когда наибольший по модулю внедиагональный элемент матрицы становится меньше <math>\varepsilon</math>. Таким образом, применяя на практике метод Якоби, мы приводим исходную матрицу к диагональной форме с точностью до некоторой вычислительной погрешности <math>\varepsilon</math> в результате конечного числа шагов. Повышение этой точности требует увеличения числа шагов метода Якоби. В конечном итоге у полученной в результате этого процесса матрицы на диагонали будут находиться все собственные значения (с определённой погрешностью) исходной симметрической матрицы.

==== Симметричность матрицы ====

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

=== Математическое описание алгоритма ===
Пусть <math>A = A_0</math> — симметричная матрица. В методе Якоби для <math>A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,...</math>, которая в конечном счёте сходится к диагональной матрице, у которой диагональными элементами являются все собственные значения матрицы <math>A</math>. Матрица <math>A_{i}</math> получается из матрицы <math>A_{i-1}</math> по формуле
<math>A_{i}=J^{T}_iA_{i-1}J_i ,</math>
где <math>J_i</math> - ортогональная матрица, называемая ''вращением Якоби''. Таким образом,
<math>A_{m}=J^{T}_{m-1}A_{m-1}J_{m-1}</math>
<math>=J^{T}_{m-1}J^{T}_{m-2}A_{m-2}J_{m-2}J_{m-1}</math>
<math>=J^{T}_{m-1}...J^{T}_{0}A_{0}J_{0}...J_{m-1}</math>
<math>=J^{T}AJ</math>
При подходящем выборе вращений <math>J_i</math> матрица <math>A_m</math> для больших <math>m</math> будет близкой к диагональной матрице <math>\Lambda</math> <ref>Дж. Деммель, Вычислительная линейная алгебра. Теория и приложения. Перевод Х.Д.Икрамов</ref>. Таким образом, <math>\Lambda \approx J^{T}AJ</math> или <math>J\Lambda J^{T} \approx A</math>, следовательно, столбцы матрицы <math>J</math> являются собственными значениями матрицы <math>A</math>.
Матрица <math>J_i</math> выбирается таким образом, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}=J^{T}_{i}A_{i}J_{i}</math>:

                                                                            
<math>j</math>
                       
<math>k</math>

<math>
J_i = R(j,k,\theta) \equiv
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & -\sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Угол вращения <math>\theta</math> выбирается так, чтобы элементы <math>(j,k)</math> и <math>(k,j)</math> в <math>A_{i+1}</math> стали нулями. Для того, чтобы найти <math>\theta</math>, составляется уравнение:
:<math>
\begin{bmatrix}
a^{i+1}_{jj}&a^{i+1}_{jk}\\
a^{i+1}_{kj}&a^{i+1}_{kk}\\
\end{bmatrix} =
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix}^T
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix}
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix} =
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} ,
</math>
где <math>\lambda_1</math> и <math>\lambda_2</math> - собственные значения подматрицы
:<math>
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix} .
</math>
Пусть <math>c = \cos(\theta)</math> и <math>s = sin(\theta)</math>, <math>a^{i}_{lk} = a_{lk}</math>. Тогда из предыдущего равенства получаем
:<math>
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} =
\begin{bmatrix}
a_{jj}c^2 + a_{kk}s^2+2sca_{jk}&sc(a_{kk} - a{jj}) + a_{jk}(c^2-s^2)\\
sc(a_{kk} - a{jj}) + a_{jk}(c^2-s^2)&a_{jj}s^2 + a_{kk}c^2-2sca_{jk}\\
\end{bmatrix}
.
</math>
Приравнивая внедиагональный элемент к нулю, получаем
:<math>
\frac{a_{jj} - a{kk}}{2a_{jk}} = \frac{c^2-s^2}{2sc} = ctg(2\theta) = r.
</math>
Пусть <math>tg(\theta) = t = \frac{s}{c}</math> . Заметим, что выполняется квадратное уравнение <math>t^2 + 2rt - 1 = 0</math> . Решая уравнение, получаем <math>t = \frac{sign(r)}{|r| + \sqrt{1+r^2}}</math> . Следовательно <math>c = \frac{1}{\sqrt{1+t^2}}</math>, <math>s = ct</math>

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

Вычислительным ядром отдельной итерации является вычисление элементов матрицы <math>A</math> при применении поворота Якоби. Конкретно, изменяются 2 строки и 2 столбца, что означает изменение 4n элементов. Отметим, что вычисление нового значения одного элемента требует 2 операции умножения и одну операцию сложения, что позволяет утверждать, что основной вклад в вычислительное ядро вносят умножения.
Однако в целом, следует отметить, что число операций в алгоритме во многом определяется общим числом итераций, а оно квадратично, в то время как отдельная итерация имеет линейную сложность. Более того, так как алгоритм является итерационным и останавливается при достижении некоторой точности, число итераций может изменяться в зависимости от желаемой точности.

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

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

1) Блок вычисления параметров вращения на текущей итерации (выбор обнуляемого элемента и расчет угла вращения).

2)Блок, реализующий непосредственно вращение Якоби.

=== Схема реализации последовательного алгоритма ===
Канонический вариант:
1)Находится максимальный наддиагональный элемент <math>a_{jk}</math> матрицы <math>A</math>.

2)Вычисляются параметры вращения Якоби:
<math>\tau= \frac{(a_{jj}-a_{kk})}{2a_{jk}}</math>
<math>t=sign(\tau)(|\tau|+\sqrt{1+\tau^2})</math>
<math>c= \frac{1}{1+\sqrt{1+\tau^2}}</math>
<math>s=c*t</math>

3)К текущей матрице А применяются вращения с вычисленными параметрами:
<math>A=R^T(j,k,\theta)*A*R(j,k,\theta)</math>
Стоит отметить, что вычисленные на предыдущем шаге <math>c</math> и <math>s</math> есть <math>\cos {\theta}</math> и <math>\sin {\theta}</math> соответственно.

4)Если матрица А не достаточно близка к диагональной, происходит переход к шагу 1.

Вообще говоря, несмотря на то, что поворот, обеспечивающий обнуление наибольшего внедиагонального элемента, обеспечивает схождение метода за наименьшее число итераций, поиск данного наибольшего элемента добавляет порядка <math>n^2</math> операций сравнения, а возможно и присваивания на каждой итерации.
Поэтому с вычислительной точки зрения выгоднее не выбирать наибольший элемент, а по очереди перебирать все наддиагональные элементы, большие заданного порога.

В последующих разделах рассматривается именно такой вариант алгоритма.

=== Последовательная сложность алгоритма ===
Сначала оценим сложность одной итерации:

1)Так как элементы матрицы никак не упорядоченны, поиск наибольшего элемента линейно зависит от числа элементов над диагональю.
Конкретнее, на данном шаге происходит <math>\frac{n*(n-1)}{2} -1</math> сравнение.

2)3 операции деления, 2 операции взятия корня, 4 операции умножения и 4 операции сложения/вычитания.

3)<math>4*n</math> операций умножения и <math>2*n</math> операций сложения.

4)операция сравнения

В наиболее неудачном случае количество итераций в теории равняется числу наддиагональных элементов, т.е. <math>\frac{n*(n-1)}{2}</math>
На практике же из-за накопления ошибок вычисления а так же восстановления уже обнуленных элементов при некоторых вращениях, число операций возрастает.
Вместе с тем, можно утвержать, что порядок числа итераций можно оценить как <math>O(N^2)</math>.
Таким образом, суммарная сложность алгоритма составляет <math>O(N^4)</math> сравнений, и <math>O(N^3)</math> сложений и умножений.

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

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

Аналитически информационный граф данного алгоритма можно описать следующим образом:

1)Последовательно идущие макроярусы вычисления параметров текущей итерации и вращения Якоби с этими параметрами
Число данных ярусов варьируется в зависимости от входных данных, но порядок составляет <math>O(n^2)</math>.

2)Вычисление параметров текущей итерации содержит конечное число операций умножения, сложения и вычисления квадратного корня.

3)Макроярус вращения Якоби содержит вычисление <math>4n</math> элементов матрицы. На данном ярусе ширина графа достигает максимального значения.

Визуальное представление графа алгоритма представлено на схемах ниже:

[[file:SI.jpg|thumb|center|1400px|Рисунок 1. Граф алгоритма на макроуровне. Rarams - вычисление параметров, Rotate - получение <math>A_{i+1}</math> из <math>A_{i}</math>.]]

[[file:exec_params.jpg|thumb|center|1400px|Рисунок 2. Структура блока Params.]]

[[file:Rotate.jpg|thumb|center|1400px|Рисунок 3. Структура блока Rotate.]]

=== Ресурс параллелизма алгоритма ===
Как видно из представления алгоритма в ярусно-параллельной форме ([[#Информационный граф| п.1.7]]), максимальная ширина ярусов составляет <math>2n</math> вершин.
Для выполнения данного алгоритма в параллельном варианте следует выполнить <math>O(\frac{n(n+1)}{2})</math> итераций.
Рассмотрим отдельную итерацию с точки зрения ярусно-параллельной формы алгоритма.

1)Выполнение *число_ярусов* ярусов с конечным числом операций

2)Выполнение 2 ярусов вычисления элементов в изменяемых строках и столбцах.

На данных двух ярусах осуществляется <math>4n</math> умножений и <math>2n</math> сложений. Данный вид параллелизма относится к координатному. Так как каждая последующая итерация алгоритма зависит от предыдущей, их выполнение распараллелить не представляется возможным. Таким образом, при наличии бесконечного числа процессоров, итоговая сложность алгоритма составляет <math>O(\frac{n(n+1)}{2})</math>

=== Входные и выходные данные алгоритма ===
'''Входные данные''': плотная матрица <math>A</math> (элементы <math>a_{ij}</math>); при этом <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>..

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы).
Конкретный вариант хранения данных зависит от реализации. В качестве примеров можно привести хранение в одномерном массиве длины <math>\frac{n (n + 1)}{2}</math> по строкам своей нижней части, хранение в виде так называемого ступенчатого массива (такой вариант двумерного массива, в котором каждая строка имеет свой размер).

'''Выходные данные''': вектор собственных значений <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>) длины <math>n</math>.

=== Свойства алгоритма ===
Параллельная сложность выполнения алгоритма составляет <math>O(\frac{n(n+1)}{2}).</math>
Последовательная сложность выполнения алгоритма составляет <math>O(\frac{n^2(n+1)}{2}).</math>
Таким образом, соотношение сложностей является линейным.
Более того, и вычислительная мощность данного алгоритма линейна.

В алгоритме используется примерно в два раза больше операций умножения, чем сложения.
Одельно стоит рассмотреть вопрос хранения матрицы А в процессе работы алгоритма. Хранение лишь нижней или верхней части матрицы в виде одномерного массива возможно; более того, хранение в таком виде обеспечивает экономию памяти в 2 раза и защищает от ассиметричности матрицы в результате накопления математических ошибок. Однако, вычисление индексов <math>i</math> и <math>j</math> элементов <math>a_{ij}</math>, соответствующих данному номеру <math>k</math> вообще говоря требует отдельного цикла, что создает дополнительную нагрузку на процессор.

Кроме того, следует отметить следующие особенности алгоритма:

1)Несмотря на то, что выбор наибольшего наддиагонального элемента, как кандидата на обнуление, кажется оптимальным, на самом деле он таковым не является. При таком выборе элемента, на каждой итерации необходимо находить текущий наибольший элемент в матрице, что требует дополнительных <math>\frac{n*(n-1)}{2}</math> операций сравнения и приводит к увеличению сложности алгоритма до <math>O(n^4)</math>. Вместо этого рекомендуется перебирать по очереди все наддиагональные элементы, большие заданного параметра. В большинстве случаев от 4 до 8 полных проходов достаточно для приближения исходной матрицы к диагональной.

2)Если при выборе в качестве обнуляемого элемента <math>a_{ij}</math> элементы <math>a_{ii} = a_{jj}</math>, то, как видно из формул в пунктах выше, матрицы поворота вырождаются в единичные и матрица на данной итерации не изменяется. Это еще один довод в пользу отказа от выбора наибольшего элемента, т.к. в данном случае произойдет зацикливание алгоритма.

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

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

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

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

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

1)Библиотека [https://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE] содержит последовательную реализацию алгоритма.

2)В цифровой библиотеке ieee.org приводится [http://ieeexplore.ieee.org/document/6310877/ аннотация] статьи 2012 года, в которой авторы описывают реализацию данного алгоритма на CUDA.

3)

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

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-10-15T14:30:51Z

Пронин Андрей: /* Схема реализации последовательного алгоритма */

{{algorithm
| name = Метод Якоби вычисления собственных значений симметричной матрицы ЗП
| serial_complexity = <math>O(n^3)</math>
| pf_height = <math>O(n^2)</math>
| pf_width = <math>2n</math>
| input_data = <math>n^2</math>
| output_data = <math>n</math>
}}

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

=== Общее описание алгоритма ===
Задача нахождения собственных значений и собственных векторов матриц(СЗВМ) является одной из основных задач для многих разделов физики. <ref>Чечин Г.М., Зехцер М.Ю. Собственные значения и собственные векторы матриц</ref> С такой вычислительной проблемой приходится сталкиваться, например, при исследовании собственных колебаний различных механических систем, колебательных и электронных спектров молекул и кристаллов. Совершенно принципиальное значение эта проблема приобрела после создания в тридцатых годах прошлого века квантовой механики, которая стала базовой дисциплиной исследования микромира.Кроме того, данная проблема важна в теории автоматического управления, как инструмент исследования устойчивости линейных систем.

Метод Якоби приводит симметричную действительную матрицу к диагональной форме с помощью некоторой (в принципе, бесконечной) последовательности плоских вращений в разных плоскостях исходного n-мерного векторного пространства. Метод Якоби состоит из некоторой последовательности шагов, на каждом из которых обнуляется один из внедиагональных элементов (обычно наибольший по модулю), в результате чего старая матрица <math>A_{i}</math> преобразуется в некоторую новую матрицу <math>A_{i+1}</math>. Делается это с помощью преобразования подобия, использующего матрицу плоского вращения <math>J_{i}</math> (подробное описание матрицы плоского вращения приведено ниже в разделе "[[#Математическое описание алгоритма|Математическое описание алгоритма]]"), которая изменяет лишь две координаты <math>n</math>-мерных векторов, а именно, координаты с номерами <math>j</math> и <math>k</math>. При таком шаге матрица <math>A_{i+1}</math> отличается от матрицы <math>A_{i}</math> лишь элементами двух строк с номерами <math>j</math>, <math>k</math> и двух столбцов с теми же номерами (<math>j</math> и <math>k</math>). Все же другие элементы матрицы A остаются неизменными. Число шагов, за которое матрица A приводится таким способом к диагональной форме, в общем случае является бесконечным. (это свойство метода Якоби более подробно рассмотрено в разделе "[[#Свойства алгоритма|Свойства алгоритма]]") В результате метод Якоби представляет собой некоторый бесконечный итерационный процесс, на каждом шаге которого преобразующаяся матрица становится всё более и более близкой к диагональной форме (в смысле уменьшения суммы квадратов всех своих внедиагональных элементов). На практике обычно выбирается заранее заданная погрешность <math>\varepsilon</math> и процесс приведения исходной матрицы к диагональному виду прекращается, когда наибольший по модулю внедиагональный элемент матрицы становится меньше <math>\varepsilon</math>. Таким образом, применяя на практике метод Якоби, мы приводим исходную матрицу к диагональной форме с точностью до некоторой вычислительной погрешности <math>\varepsilon</math> в результате конечного числа шагов. Повышение этой точности требует увеличения числа шагов метода Якоби. В конечном итоге у полученной в результате этого процесса матрицы на диагонали будут находиться все собственные значения (с определённой погрешностью) исходной симметрической матрицы.

==== Симметричность матрицы ====

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

=== Математическое описание алгоритма ===
Пусть <math>A = A_0</math> — симметричная матрица. В методе Якоби для <math>A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,...</math>, которая в конечном счёте сходится к диагональной матрице, у которой диагональными элементами являются все собственные значения матрицы <math>A</math>. Матрица <math>A_{i}</math> получается из матрицы <math>A_{i-1}</math> по формуле
<math>A_{i}=J^{T}_iA_{i-1}J_i ,</math>
где <math>J_i</math> - ортогональная матрица, называемая ''вращением Якоби''. Таким образом,
<math>A_{m}=J^{T}_{m-1}A_{m-1}J_{m-1}</math>
<math>=J^{T}_{m-1}J^{T}_{m-2}A_{m-2}J_{m-2}J_{m-1}</math>
<math>=J^{T}_{m-1}...J^{T}_{0}A_{0}J_{0}...J_{m-1}</math>
<math>=J^{T}AJ</math>
При подходящем выборе вращений <math>J_i</math> матрица <math>A_m</math> для больших <math>m</math> будет близкой к диагональной матрице <math>\Lambda</math> <ref>Дж. Деммель, Вычислительная линейная алгебра. Теория и приложения. Перевод Х.Д.Икрамов</ref>. Таким образом, <math>\Lambda \approx J^{T}AJ</math> или <math>J\Lambda J^{T} \approx A</math>, следовательно, столбцы матрицы <math>J</math> являются собственными значениями матрицы <math>A</math>.
Матрица <math>J_i</math> выбирается таким образом, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}=J^{T}_{i}A_{i}J_{i}</math>:

                                                                            
<math>j</math>
                       
<math>k</math>

<math>
J_i = R(j,k,\theta) \equiv
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & -\sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Угол вращения <math>\theta</math> выбирается так, чтобы элементы <math>(j,k)</math> и <math>(k,j)</math> в <math>A_{i+1}</math> стали нулями. Для того, чтобы найти <math>\theta</math>, составляется уравнение:
:<math>
\begin{bmatrix}
a^{i+1}_{jj}&a^{i+1}_{jk}\\
a^{i+1}_{kj}&a^{i+1}_{kk}\\
\end{bmatrix} =
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix}^T
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix}
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix} =
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} ,
</math>
где <math>\lambda_1</math> и <math>\lambda_2</math> - собственные значения подматрицы
:<math>
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix} .
</math>
Пусть <math>c = \cos(\theta)</math> и <math>s = sin(\theta)</math>, <math>a^{i}_{lk} = a_{lk}</math>. Тогда из предыдущего равенства получаем
:<math>
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} =
\begin{bmatrix}
a_{jj}c^2 + a_{kk}s^2+2sca_{jk}&sc(a_{kk} - a{jj}) + a_{jk}(c^2-s^2)\\
sc(a_{kk} - a{jj}) + a_{jk}(c^2-s^2)&a_{jj}s^2 + a_{kk}c^2-2sca_{jk}\\
\end{bmatrix}
.
</math>
Приравнивая внедиагональный элемент к нулю, получаем
:<math>
\frac{a_{jj} - a{kk}}{2a_{jk}} = \frac{c^2-s^2}{2sc} = ctg(2\theta) = r.
</math>
Пусть <math>tg(\theta) = t = \frac{s}{c}</math> . Заметим, что выполняется квадратное уравнение <math>t^2 + 2rt - 1 = 0</math> . Решая уравнение, получаем <math>t = \frac{sign(r)}{|r| + \sqrt{1+r^2}}</math> . Следовательно <math>c = \frac{1}{\sqrt{1+t^2}}</math>, <math>s = ct</math>

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

Вычислительным ядром отдельной итерации является вычисление элементов матрицы <math>A</math> при применении поворота Якоби. Конкретно, изменяются 2 строки и 2 столбца, что означает изменение 4n элементов. Отметим, что вычисление нового значения одного элемента требует 2 операции умножения и одну операцию сложения, что позволяет утверждать, что основной вклад в вычислительное ядро вносят умножения.
Однако в целом, следует отметить, что число операций в алгоритме во многом определяется общим числом итераций, а оно квадратично, в то время как отдельная итерация имеет линейную сложность. Более того, так как алгоритм является итерационным и останавливается при достижении некоторой точности, число итераций может изменяться в зависимости от желаемой точности.

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

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

1) Блок вычисления параметров вращения на текущей итерации (выбор обнуляемого элемента и расчет угла вращения).

2)Блок, реализующий непосредственно вращение Якоби.

=== Схема реализации последовательного алгоритма ===
Канонический вариант:
1)Находится максимальный наддиагональный элемент <math>a_{jk}</math> матрицы <math>A</math>.

2)Вычисляются параметры вращения Якоби:
<math>\tau= \frac{(a_{jj}-a_{kk})}{2a_{jk}}</math>
<math>t=sign(\tau)(|\tau|+\sqrt{1+\tau^2})</math>
<math>c= \frac{1}{1+\sqrt{1+\tau^2}}</math>
<math>s=c*t</math>

3)К текущей матрице А применяются вращения с вычисленными параметрами:
<math>A=R^T(j,k,\theta)*A*R(j,k,\theta)</math>
Стоит отметить, что вычисленные на предыдущем шаге <math>c</math> и <math>s</math> есть <math>\cos {\theta}</math> и <math>\sin {\theta}</math> соответственно.

4)Если матрица А не достаточно близка к диагональной, происходит переход к шагу 1.

Вообще говоря, несмотря на то, что поворот, обеспечивающий обнуление наибольшего внедиагонального элемента, обеспечивает схождение метода за наименьшее число итераций, поиск данного наибольшего элемента добавляет порядка <math>n^2</math> операций сравнения, а возможно и присваивания на каждой итерации.
Поэтому с вычислительной точки зрения выгоднее не выбирать наибольший элемент, а по очереди перебирать все наддиагональные элементы, большие заданного порога.

В последующих разделах рассматривается именно такой вариант алгоритма.

=== Последовательная сложность алгоритма ===
Сначала оценим сложность одной итерации:

1)Так как элементы матрицы никак не упорядоченны, поиск наибольшего элемента линейно зависит от числа элементов над диагональю.
Конкретнее, на данном шаге происходит <math>\frac{n*(n-1)}{2} -1</math> сравнение.

2)3 операции деления, 2 операции взятия корня, 4 операции умножения и 4 операции сложения/вычитания.

3)<math>4*n</math> операций умножения и <math>2*n</math> операций сложения.

4)операция сравнения

В наиболее неудачном случае количество итераций равняется числу наддиагональных элементов, т.е. <math>\frac{n*(n-1)}{2}</math>.
Таким образом, суммарная сложность алгоритма составляет <math>O(N^4)</math> сравнений, и <math>O(N^3)</math> сложений и умножений.

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

Аналитически информационный граф данного алгоритма можно описать следующим образом:

1)Последовательно идущие макроярусы вычисления параметров текущей итерации и вращения Якоби с этими параметрами
Число данных ярусов варьируется в зависимости от входных данных, но порядок составляет <math>O(n^2)</math>.

2)Вычисление параметров текущей итерации содержит конечное число операций умножения, сложения и вычисления квадратного корня.

3)Макроярус вращения Якоби содержит вычисление <math>4n</math> элементов матрицы. На данном ярусе ширина графа достигает максимального значения.

Визуальное представление графа алгоритма представлено на схемах ниже:

[[file:SI.jpg|thumb|center|1400px|Рисунок 1. Граф алгоритма на макроуровне. Rarams - вычисление параметров, Rotate - получение <math>A_{i+1}</math> из <math>A_{i}</math>.]]

[[file:exec_params.jpg|thumb|center|1400px|Рисунок 2. Структура блока Params.]]

[[file:Rotate.jpg|thumb|center|1400px|Рисунок 3. Структура блока Rotate.]]

=== Ресурс параллелизма алгоритма ===
Как видно из представления алгоритма в ярусно-параллельной форме ([[#Информационный граф| п.1.7]]), максимальная ширина ярусов составляет <math>2n</math> вершин.
Для выполнения данного алгоритма в параллельном варианте следует выполнить <math>O(\frac{n(n+1)}{2})</math> итераций.
Рассмотрим отдельную итерацию с точки зрения ярусно-параллельной формы алгоритма.

1)Выполнение *число_ярусов* ярусов с конечным числом операций

2)Выполнение 2 ярусов вычисления элементов в изменяемых строках и столбцах.

На данных двух ярусах осуществляется <math>4n</math> умножений и <math>2n</math> сложений. Данный вид параллелизма относится к координатному. Так как каждая последующая итерация алгоритма зависит от предыдущей, их выполнение распараллелить не представляется возможным. Таким образом, при наличии бесконечного числа процессоров, итоговая сложность алгоритма составляет <math>O(\frac{n(n+1)}{2})</math>

=== Входные и выходные данные алгоритма ===
'''Входные данные''': плотная матрица <math>A</math> (элементы <math>a_{ij}</math>); при этом <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>..

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы).
Конкретный вариант хранения данных зависит от реализации. В качестве примеров можно привести хранение в одномерном массиве длины <math>\frac{n (n + 1)}{2}</math> по строкам своей нижней части, хранение в виде так называемого ступенчатого массива (такой вариант двумерного массива, в котором каждая строка имеет свой размер).

'''Выходные данные''': вектор собственных значений <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>) длины <math>n</math>.

=== Свойства алгоритма ===
Параллельная сложность выполнения алгоритма составляет <math>O(\frac{n(n+1)}{2}).</math>
Последовательная сложность выполнения алгоритма составляет <math>O(\frac{n^2(n+1)}{2}).</math>
Таким образом, соотношение сложностей является линейным.
Более того, и вычислительная мощность данного алгоритма линейна.

В алгоритме используется примерно в два раза больше операций умножения, чем сложения.
Одельно стоит рассмотреть вопрос хранения матрицы А в процессе работы алгоритма. Хранение лишь нижней или верхней части матрицы в виде одномерного массива возможно; более того, хранение в таком виде обеспечивает экономию памяти в 2 раза и защищает от ассиметричности матрицы в результате накопления математических ошибок. Однако, вычисление индексов <math>i</math> и <math>j</math> элементов <math>a_{ij}</math>, соответствующих данному номеру <math>k</math> вообще говоря требует отдельного цикла, что создает дополнительную нагрузку на процессор.

Кроме того, следует отметить следующие особенности алгоритма:

1)Несмотря на то, что выбор наибольшего наддиагонального элемента, как кандидата на обнуление, кажется оптимальным, на самом деле он таковым не является. При таком выборе элемента, на каждой итерации необходимо находить текущий наибольший элемент в матрице, что требует дополнительных <math>\frac{n*(n-1)}{2}</math> операций сравнения и приводит к увеличению сложности алгоритма до <math>O(n^4)</math>. Вместо этого рекомендуется перебирать по очереди все наддиагональные элементы, большие заданного параметра. В большинстве случаев от 4 до 8 полных проходов достаточно для приближения исходной матрицы к диагональной.

2)Если при выборе в качестве обнуляемого элемента <math>a_{ij}</math> элементы <math>a_{ii} = a_{jj}</math>, то, как видно из формул в пунктах выше, матрицы поворота вырождаются в единичные и матрица на данной итерации не изменяется. Это еще один довод в пользу отказа от выбора наибольшего элемента, т.к. в данном случае произойдет зацикливание алгоритма.

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

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

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

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

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

1)Библиотека [https://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE] содержит последовательную реализацию алгоритма.

2)В цифровой библиотеке ieee.org приводится [http://ieeexplore.ieee.org/document/6310877/ аннотация] статьи 2012 года, в которой авторы описывают реализацию данного алгоритма на CUDA.

3)

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

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-10-15T14:25:03Z

Пронин Андрей: /* Вычислительное ядро алгоритма */

{{algorithm
| name = Метод Якоби вычисления собственных значений симметричной матрицы ЗП
| serial_complexity = <math>O(n^3)</math>
| pf_height = <math>O(n^2)</math>
| pf_width = <math>2n</math>
| input_data = <math>n^2</math>
| output_data = <math>n</math>
}}

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

=== Общее описание алгоритма ===
Задача нахождения собственных значений и собственных векторов матриц(СЗВМ) является одной из основных задач для многих разделов физики. <ref>Чечин Г.М., Зехцер М.Ю. Собственные значения и собственные векторы матриц</ref> С такой вычислительной проблемой приходится сталкиваться, например, при исследовании собственных колебаний различных механических систем, колебательных и электронных спектров молекул и кристаллов. Совершенно принципиальное значение эта проблема приобрела после создания в тридцатых годах прошлого века квантовой механики, которая стала базовой дисциплиной исследования микромира.Кроме того, данная проблема важна в теории автоматического управления, как инструмент исследования устойчивости линейных систем.

Метод Якоби приводит симметричную действительную матрицу к диагональной форме с помощью некоторой (в принципе, бесконечной) последовательности плоских вращений в разных плоскостях исходного n-мерного векторного пространства. Метод Якоби состоит из некоторой последовательности шагов, на каждом из которых обнуляется один из внедиагональных элементов (обычно наибольший по модулю), в результате чего старая матрица <math>A_{i}</math> преобразуется в некоторую новую матрицу <math>A_{i+1}</math>. Делается это с помощью преобразования подобия, использующего матрицу плоского вращения <math>J_{i}</math> (подробное описание матрицы плоского вращения приведено ниже в разделе "[[#Математическое описание алгоритма|Математическое описание алгоритма]]"), которая изменяет лишь две координаты <math>n</math>-мерных векторов, а именно, координаты с номерами <math>j</math> и <math>k</math>. При таком шаге матрица <math>A_{i+1}</math> отличается от матрицы <math>A_{i}</math> лишь элементами двух строк с номерами <math>j</math>, <math>k</math> и двух столбцов с теми же номерами (<math>j</math> и <math>k</math>). Все же другие элементы матрицы A остаются неизменными. Число шагов, за которое матрица A приводится таким способом к диагональной форме, в общем случае является бесконечным. (это свойство метода Якоби более подробно рассмотрено в разделе "[[#Свойства алгоритма|Свойства алгоритма]]") В результате метод Якоби представляет собой некоторый бесконечный итерационный процесс, на каждом шаге которого преобразующаяся матрица становится всё более и более близкой к диагональной форме (в смысле уменьшения суммы квадратов всех своих внедиагональных элементов). На практике обычно выбирается заранее заданная погрешность <math>\varepsilon</math> и процесс приведения исходной матрицы к диагональному виду прекращается, когда наибольший по модулю внедиагональный элемент матрицы становится меньше <math>\varepsilon</math>. Таким образом, применяя на практике метод Якоби, мы приводим исходную матрицу к диагональной форме с точностью до некоторой вычислительной погрешности <math>\varepsilon</math> в результате конечного числа шагов. Повышение этой точности требует увеличения числа шагов метода Якоби. В конечном итоге у полученной в результате этого процесса матрицы на диагонали будут находиться все собственные значения (с определённой погрешностью) исходной симметрической матрицы.

==== Симметричность матрицы ====

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

=== Математическое описание алгоритма ===
Пусть <math>A = A_0</math> — симметричная матрица. В методе Якоби для <math>A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,...</math>, которая в конечном счёте сходится к диагональной матрице, у которой диагональными элементами являются все собственные значения матрицы <math>A</math>. Матрица <math>A_{i}</math> получается из матрицы <math>A_{i-1}</math> по формуле
<math>A_{i}=J^{T}_iA_{i-1}J_i ,</math>
где <math>J_i</math> - ортогональная матрица, называемая ''вращением Якоби''. Таким образом,
<math>A_{m}=J^{T}_{m-1}A_{m-1}J_{m-1}</math>
<math>=J^{T}_{m-1}J^{T}_{m-2}A_{m-2}J_{m-2}J_{m-1}</math>
<math>=J^{T}_{m-1}...J^{T}_{0}A_{0}J_{0}...J_{m-1}</math>
<math>=J^{T}AJ</math>
При подходящем выборе вращений <math>J_i</math> матрица <math>A_m</math> для больших <math>m</math> будет близкой к диагональной матрице <math>\Lambda</math> <ref>Дж. Деммель, Вычислительная линейная алгебра. Теория и приложения. Перевод Х.Д.Икрамов</ref>. Таким образом, <math>\Lambda \approx J^{T}AJ</math> или <math>J\Lambda J^{T} \approx A</math>, следовательно, столбцы матрицы <math>J</math> являются собственными значениями матрицы <math>A</math>.
Матрица <math>J_i</math> выбирается таким образом, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}=J^{T}_{i}A_{i}J_{i}</math>:

                                                                            
<math>j</math>
                       
<math>k</math>

<math>
J_i = R(j,k,\theta) \equiv
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & -\sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Угол вращения <math>\theta</math> выбирается так, чтобы элементы <math>(j,k)</math> и <math>(k,j)</math> в <math>A_{i+1}</math> стали нулями. Для того, чтобы найти <math>\theta</math>, составляется уравнение:
:<math>
\begin{bmatrix}
a^{i+1}_{jj}&a^{i+1}_{jk}\\
a^{i+1}_{kj}&a^{i+1}_{kk}\\
\end{bmatrix} =
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix}^T
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix}
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix} =
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} ,
</math>
где <math>\lambda_1</math> и <math>\lambda_2</math> - собственные значения подматрицы
:<math>
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix} .
</math>
Пусть <math>c = \cos(\theta)</math> и <math>s = sin(\theta)</math>, <math>a^{i}_{lk} = a_{lk}</math>. Тогда из предыдущего равенства получаем
:<math>
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} =
\begin{bmatrix}
a_{jj}c^2 + a_{kk}s^2+2sca_{jk}&sc(a_{kk} - a{jj}) + a_{jk}(c^2-s^2)\\
sc(a_{kk} - a{jj}) + a_{jk}(c^2-s^2)&a_{jj}s^2 + a_{kk}c^2-2sca_{jk}\\
\end{bmatrix}
.
</math>
Приравнивая внедиагональный элемент к нулю, получаем
:<math>
\frac{a_{jj} - a{kk}}{2a_{jk}} = \frac{c^2-s^2}{2sc} = ctg(2\theta) = r.
</math>
Пусть <math>tg(\theta) = t = \frac{s}{c}</math> . Заметим, что выполняется квадратное уравнение <math>t^2 + 2rt - 1 = 0</math> . Решая уравнение, получаем <math>t = \frac{sign(r)}{|r| + \sqrt{1+r^2}}</math> . Следовательно <math>c = \frac{1}{\sqrt{1+t^2}}</math>, <math>s = ct</math>

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

Вычислительным ядром отдельной итерации является вычисление элементов матрицы <math>A</math> при применении поворота Якоби. Конкретно, изменяются 2 строки и 2 столбца, что означает изменение 4n элементов. Отметим, что вычисление нового значения одного элемента требует 2 операции умножения и одну операцию сложения, что позволяет утверждать, что основной вклад в вычислительное ядро вносят умножения.
Однако в целом, следует отметить, что число операций в алгоритме во многом определяется общим числом итераций, а оно квадратично, в то время как отдельная итерация имеет линейную сложность. Более того, так как алгоритм является итерационным и останавливается при достижении некоторой точности, число итераций может изменяться в зависимости от желаемой точности.

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

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

1) Блок вычисления параметров вращения на текущей итерации (выбор обнуляемого элемента и расчет угла вращения).

2)Блок, реализующий непосредственно вращение Якоби.

=== Схема реализации последовательного алгоритма ===
1)Находится максимальный наддиагональный элемент <math>a_{jk}</math> матрицы <math>A</math>.

2)Вычисляются параметры вращения Якоби:
<math>\tau= \frac{(a_{jj}-a_{kk})}{2a_{jk}}</math>
<math>t=sign(\tau)(|\tau|+\sqrt{1+\tau^2})</math>
<math>c= \frac{1}{1+\sqrt{1+\tau^2}}</math>
<math>s=c*t</math>

3)К текущей матрице А применяются вращения с вычисленными параметрами:
<math>A=R^T(j,k,\theta)*A*R(j,k,\theta)</math>
Стоит отметить, что вычисленные на предыдущем шаге <math>c</math> и <math>s</math> есть <math>\cos {\theta}</math> и <math>\sin {\theta}</math> соответственно.

4)Если матрица А не достаточно близка к диагональной, происходит переход к шагу 1.

Стоит отметить, что за <math>\frac{n*(n-1)}{2}</math> итераций алгоритма гарантируется получение результата, т.к. сумма квадратов наддиагональных элементов матрицы А на каждой итерации уменьшается на <math>a_{jk}^2</math>.

=== Последовательная сложность алгоритма ===
Сначала оценим сложность одной итерации:

1)Так как элементы матрицы никак не упорядоченны, поиск наибольшего элемента линейно зависит от числа элементов над диагональю.
Конкретнее, на данном шаге происходит <math>\frac{n*(n-1)}{2} -1</math> сравнение.

2)3 операции деления, 2 операции взятия корня, 4 операции умножения и 4 операции сложения/вычитания.

3)<math>4*n</math> операций умножения и <math>2*n</math> операций сложения.

4)операция сравнения

В наиболее неудачном случае количество итераций равняется числу наддиагональных элементов, т.е. <math>\frac{n*(n-1)}{2}</math>.
Таким образом, суммарная сложность алгоритма составляет <math>O(N^4)</math> сравнений, и <math>O(N^3)</math> сложений и умножений.

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

Аналитически информационный граф данного алгоритма можно описать следующим образом:

1)Последовательно идущие макроярусы вычисления параметров текущей итерации и вращения Якоби с этими параметрами
Число данных ярусов варьируется в зависимости от входных данных, но порядок составляет <math>O(n^2)</math>.

2)Вычисление параметров текущей итерации содержит конечное число операций умножения, сложения и вычисления квадратного корня.

3)Макроярус вращения Якоби содержит вычисление <math>4n</math> элементов матрицы. На данном ярусе ширина графа достигает максимального значения.

Визуальное представление графа алгоритма представлено на схемах ниже:

[[file:SI.jpg|thumb|center|1400px|Рисунок 1. Граф алгоритма на макроуровне. Rarams - вычисление параметров, Rotate - получение <math>A_{i+1}</math> из <math>A_{i}</math>.]]

[[file:exec_params.jpg|thumb|center|1400px|Рисунок 2. Структура блока Params.]]

[[file:Rotate.jpg|thumb|center|1400px|Рисунок 3. Структура блока Rotate.]]

=== Ресурс параллелизма алгоритма ===
Как видно из представления алгоритма в ярусно-параллельной форме ([[#Информационный граф| п.1.7]]), максимальная ширина ярусов составляет <math>2n</math> вершин.
Для выполнения данного алгоритма в параллельном варианте следует выполнить <math>O(\frac{n(n+1)}{2})</math> итераций.
Рассмотрим отдельную итерацию с точки зрения ярусно-параллельной формы алгоритма.

1)Выполнение *число_ярусов* ярусов с конечным числом операций

2)Выполнение 2 ярусов вычисления элементов в изменяемых строках и столбцах.

На данных двух ярусах осуществляется <math>4n</math> умножений и <math>2n</math> сложений. Данный вид параллелизма относится к координатному. Так как каждая последующая итерация алгоритма зависит от предыдущей, их выполнение распараллелить не представляется возможным. Таким образом, при наличии бесконечного числа процессоров, итоговая сложность алгоритма составляет <math>O(\frac{n(n+1)}{2})</math>

=== Входные и выходные данные алгоритма ===
'''Входные данные''': плотная матрица <math>A</math> (элементы <math>a_{ij}</math>); при этом <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>..

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы).
Конкретный вариант хранения данных зависит от реализации. В качестве примеров можно привести хранение в одномерном массиве длины <math>\frac{n (n + 1)}{2}</math> по строкам своей нижней части, хранение в виде так называемого ступенчатого массива (такой вариант двумерного массива, в котором каждая строка имеет свой размер).

'''Выходные данные''': вектор собственных значений <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>) длины <math>n</math>.

=== Свойства алгоритма ===
Параллельная сложность выполнения алгоритма составляет <math>O(\frac{n(n+1)}{2}).</math>
Последовательная сложность выполнения алгоритма составляет <math>O(\frac{n^2(n+1)}{2}).</math>
Таким образом, соотношение сложностей является линейным.
Более того, и вычислительная мощность данного алгоритма линейна.

В алгоритме используется примерно в два раза больше операций умножения, чем сложения.
Одельно стоит рассмотреть вопрос хранения матрицы А в процессе работы алгоритма. Хранение лишь нижней или верхней части матрицы в виде одномерного массива возможно; более того, хранение в таком виде обеспечивает экономию памяти в 2 раза и защищает от ассиметричности матрицы в результате накопления математических ошибок. Однако, вычисление индексов <math>i</math> и <math>j</math> элементов <math>a_{ij}</math>, соответствующих данному номеру <math>k</math> вообще говоря требует отдельного цикла, что создает дополнительную нагрузку на процессор.

Кроме того, следует отметить следующие особенности алгоритма:

1)Несмотря на то, что выбор наибольшего наддиагонального элемента, как кандидата на обнуление, кажется оптимальным, на самом деле он таковым не является. При таком выборе элемента, на каждой итерации необходимо находить текущий наибольший элемент в матрице, что требует дополнительных <math>\frac{n*(n-1)}{2}</math> операций сравнения и приводит к увеличению сложности алгоритма до <math>O(n^4)</math>. Вместо этого рекомендуется перебирать по очереди все наддиагональные элементы, большие заданного параметра. В большинстве случаев от 4 до 8 полных проходов достаточно для приближения исходной матрицы к диагональной.

2)Если при выборе в качестве обнуляемого элемента <math>a_{ij}</math> элементы <math>a_{ii} = a_{jj}</math>, то, как видно из формул в пунктах выше, матрицы поворота вырождаются в единичные и матрица на данной итерации не изменяется. Это еще один довод в пользу отказа от выбора наибольшего элемента, т.к. в данном случае произойдет зацикливание алгоритма.

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

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

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

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

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

1)Библиотека [https://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE] содержит последовательную реализацию алгоритма.

2)В цифровой библиотеке ieee.org приводится [http://ieeexplore.ieee.org/document/6310877/ аннотация] статьи 2012 года, в которой авторы описывают реализацию данного алгоритма на CUDA.

3)

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

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-10-15T14:23:38Z

Пронин Андрей: /* Вычислительное ядро алгоритма */

{{algorithm
| name = Метод Якоби вычисления собственных значений симметричной матрицы ЗП
| serial_complexity = <math>O(n^3)</math>
| pf_height = <math>O(n^2)</math>
| pf_width = <math>2n</math>
| input_data = <math>n^2</math>
| output_data = <math>n</math>
}}

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

=== Общее описание алгоритма ===
Задача нахождения собственных значений и собственных векторов матриц(СЗВМ) является одной из основных задач для многих разделов физики. <ref>Чечин Г.М., Зехцер М.Ю. Собственные значения и собственные векторы матриц</ref> С такой вычислительной проблемой приходится сталкиваться, например, при исследовании собственных колебаний различных механических систем, колебательных и электронных спектров молекул и кристаллов. Совершенно принципиальное значение эта проблема приобрела после создания в тридцатых годах прошлого века квантовой механики, которая стала базовой дисциплиной исследования микромира.Кроме того, данная проблема важна в теории автоматического управления, как инструмент исследования устойчивости линейных систем.

Метод Якоби приводит симметричную действительную матрицу к диагональной форме с помощью некоторой (в принципе, бесконечной) последовательности плоских вращений в разных плоскостях исходного n-мерного векторного пространства. Метод Якоби состоит из некоторой последовательности шагов, на каждом из которых обнуляется один из внедиагональных элементов (обычно наибольший по модулю), в результате чего старая матрица <math>A_{i}</math> преобразуется в некоторую новую матрицу <math>A_{i+1}</math>. Делается это с помощью преобразования подобия, использующего матрицу плоского вращения <math>J_{i}</math> (подробное описание матрицы плоского вращения приведено ниже в разделе "[[#Математическое описание алгоритма|Математическое описание алгоритма]]"), которая изменяет лишь две координаты <math>n</math>-мерных векторов, а именно, координаты с номерами <math>j</math> и <math>k</math>. При таком шаге матрица <math>A_{i+1}</math> отличается от матрицы <math>A_{i}</math> лишь элементами двух строк с номерами <math>j</math>, <math>k</math> и двух столбцов с теми же номерами (<math>j</math> и <math>k</math>). Все же другие элементы матрицы A остаются неизменными. Число шагов, за которое матрица A приводится таким способом к диагональной форме, в общем случае является бесконечным. (это свойство метода Якоби более подробно рассмотрено в разделе "[[#Свойства алгоритма|Свойства алгоритма]]") В результате метод Якоби представляет собой некоторый бесконечный итерационный процесс, на каждом шаге которого преобразующаяся матрица становится всё более и более близкой к диагональной форме (в смысле уменьшения суммы квадратов всех своих внедиагональных элементов). На практике обычно выбирается заранее заданная погрешность <math>\varepsilon</math> и процесс приведения исходной матрицы к диагональному виду прекращается, когда наибольший по модулю внедиагональный элемент матрицы становится меньше <math>\varepsilon</math>. Таким образом, применяя на практике метод Якоби, мы приводим исходную матрицу к диагональной форме с точностью до некоторой вычислительной погрешности <math>\varepsilon</math> в результате конечного числа шагов. Повышение этой точности требует увеличения числа шагов метода Якоби. В конечном итоге у полученной в результате этого процесса матрицы на диагонали будут находиться все собственные значения (с определённой погрешностью) исходной симметрической матрицы.

==== Симметричность матрицы ====

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

=== Математическое описание алгоритма ===
Пусть <math>A = A_0</math> — симметричная матрица. В методе Якоби для <math>A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,...</math>, которая в конечном счёте сходится к диагональной матрице, у которой диагональными элементами являются все собственные значения матрицы <math>A</math>. Матрица <math>A_{i}</math> получается из матрицы <math>A_{i-1}</math> по формуле
<math>A_{i}=J^{T}_iA_{i-1}J_i ,</math>
где <math>J_i</math> - ортогональная матрица, называемая ''вращением Якоби''. Таким образом,
<math>A_{m}=J^{T}_{m-1}A_{m-1}J_{m-1}</math>
<math>=J^{T}_{m-1}J^{T}_{m-2}A_{m-2}J_{m-2}J_{m-1}</math>
<math>=J^{T}_{m-1}...J^{T}_{0}A_{0}J_{0}...J_{m-1}</math>
<math>=J^{T}AJ</math>
При подходящем выборе вращений <math>J_i</math> матрица <math>A_m</math> для больших <math>m</math> будет близкой к диагональной матрице <math>\Lambda</math> <ref>Дж. Деммель, Вычислительная линейная алгебра. Теория и приложения. Перевод Х.Д.Икрамов</ref>. Таким образом, <math>\Lambda \approx J^{T}AJ</math> или <math>J\Lambda J^{T} \approx A</math>, следовательно, столбцы матрицы <math>J</math> являются собственными значениями матрицы <math>A</math>.
Матрица <math>J_i</math> выбирается таким образом, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}=J^{T}_{i}A_{i}J_{i}</math>:

                                                                            
<math>j</math>
                       
<math>k</math>

<math>
J_i = R(j,k,\theta) \equiv
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & -\sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Угол вращения <math>\theta</math> выбирается так, чтобы элементы <math>(j,k)</math> и <math>(k,j)</math> в <math>A_{i+1}</math> стали нулями. Для того, чтобы найти <math>\theta</math>, составляется уравнение:
:<math>
\begin{bmatrix}
a^{i+1}_{jj}&a^{i+1}_{jk}\\
a^{i+1}_{kj}&a^{i+1}_{kk}\\
\end{bmatrix} =
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix}^T
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix}
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix} =
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} ,
</math>
где <math>\lambda_1</math> и <math>\lambda_2</math> - собственные значения подматрицы
:<math>
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix} .
</math>
Пусть <math>c = \cos(\theta)</math> и <math>s = sin(\theta)</math>, <math>a^{i}_{lk} = a_{lk}</math>. Тогда из предыдущего равенства получаем
:<math>
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} =
\begin{bmatrix}
a_{jj}c^2 + a_{kk}s^2+2sca_{jk}&sc(a_{kk} - a{jj}) + a_{jk}(c^2-s^2)\\
sc(a_{kk} - a{jj}) + a_{jk}(c^2-s^2)&a_{jj}s^2 + a_{kk}c^2-2sca_{jk}\\
\end{bmatrix}
.
</math>
Приравнивая внедиагональный элемент к нулю, получаем
:<math>
\frac{a_{jj} - a{kk}}{2a_{jk}} = \frac{c^2-s^2}{2sc} = ctg(2\theta) = r.
</math>
Пусть <math>tg(\theta) = t = \frac{s}{c}</math> . Заметим, что выполняется квадратное уравнение <math>t^2 + 2rt - 1 = 0</math> . Решая уравнение, получаем <math>t = \frac{sign(r)}{|r| + \sqrt{1+r^2}}</math> . Следовательно <math>c = \frac{1}{\sqrt{1+t^2}}</math>, <math>s = ct</math>

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

Вычислительным ядром отдельной итерации является вычисление элементов матрицы <math>А</math> при применении поворота Якоби. Конкретно, изменяются 2 строки и 2 столбца, что означает изменение 4n элементов. Отметим, что вычисление нового значения одного элемента требует 2 операции умножения и одну операцию сложения, что позволяет утверждать, что основной вклад в вычислительное ядро вносят умножения.
Однако в целом, следует отметить, что число операций в алгоритме во многом определяется общим числом итераций, а оно квадратично, в то время как отдельная итерация имеет линейную сложность. Более того, так как алгоритм является итерационным и останавливается при достижении некоторой точности, число итераций может изменяться в зависимости от желаемой точности.

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

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

1) Блок вычисления параметров вращения на текущей итерации (выбор обнуляемого элемента и расчет угла вращения).

2)Блок, реализующий непосредственно вращение Якоби.

=== Схема реализации последовательного алгоритма ===
1)Находится максимальный наддиагональный элемент <math>a_{jk}</math> матрицы <math>A</math>.

2)Вычисляются параметры вращения Якоби:
<math>\tau= \frac{(a_{jj}-a_{kk})}{2a_{jk}}</math>
<math>t=sign(\tau)(|\tau|+\sqrt{1+\tau^2})</math>
<math>c= \frac{1}{1+\sqrt{1+\tau^2}}</math>
<math>s=c*t</math>

3)К текущей матрице А применяются вращения с вычисленными параметрами:
<math>A=R^T(j,k,\theta)*A*R(j,k,\theta)</math>
Стоит отметить, что вычисленные на предыдущем шаге <math>c</math> и <math>s</math> есть <math>\cos {\theta}</math> и <math>\sin {\theta}</math> соответственно.

4)Если матрица А не достаточно близка к диагональной, происходит переход к шагу 1.

Стоит отметить, что за <math>\frac{n*(n-1)}{2}</math> итераций алгоритма гарантируется получение результата, т.к. сумма квадратов наддиагональных элементов матрицы А на каждой итерации уменьшается на <math>a_{jk}^2</math>.

=== Последовательная сложность алгоритма ===
Сначала оценим сложность одной итерации:

1)Так как элементы матрицы никак не упорядоченны, поиск наибольшего элемента линейно зависит от числа элементов над диагональю.
Конкретнее, на данном шаге происходит <math>\frac{n*(n-1)}{2} -1</math> сравнение.

2)3 операции деления, 2 операции взятия корня, 4 операции умножения и 4 операции сложения/вычитания.

3)<math>4*n</math> операций умножения и <math>2*n</math> операций сложения.

4)операция сравнения

В наиболее неудачном случае количество итераций равняется числу наддиагональных элементов, т.е. <math>\frac{n*(n-1)}{2}</math>.
Таким образом, суммарная сложность алгоритма составляет <math>O(N^4)</math> сравнений, и <math>O(N^3)</math> сложений и умножений.

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

Аналитически информационный граф данного алгоритма можно описать следующим образом:

1)Последовательно идущие макроярусы вычисления параметров текущей итерации и вращения Якоби с этими параметрами
Число данных ярусов варьируется в зависимости от входных данных, но порядок составляет <math>O(n^2)</math>.

2)Вычисление параметров текущей итерации содержит конечное число операций умножения, сложения и вычисления квадратного корня.

3)Макроярус вращения Якоби содержит вычисление <math>4n</math> элементов матрицы. На данном ярусе ширина графа достигает максимального значения.

Визуальное представление графа алгоритма представлено на схемах ниже:

[[file:SI.jpg|thumb|center|1400px|Рисунок 1. Граф алгоритма на макроуровне. Rarams - вычисление параметров, Rotate - получение <math>A_{i+1}</math> из <math>A_{i}</math>.]]

[[file:exec_params.jpg|thumb|center|1400px|Рисунок 2. Структура блока Params.]]

[[file:Rotate.jpg|thumb|center|1400px|Рисунок 3. Структура блока Rotate.]]

=== Ресурс параллелизма алгоритма ===
Как видно из представления алгоритма в ярусно-параллельной форме ([[#Информационный граф| п.1.7]]), максимальная ширина ярусов составляет <math>2n</math> вершин.
Для выполнения данного алгоритма в параллельном варианте следует выполнить <math>O(\frac{n(n+1)}{2})</math> итераций.
Рассмотрим отдельную итерацию с точки зрения ярусно-параллельной формы алгоритма.

1)Выполнение *число_ярусов* ярусов с конечным числом операций

2)Выполнение 2 ярусов вычисления элементов в изменяемых строках и столбцах.

На данных двух ярусах осуществляется <math>4n</math> умножений и <math>2n</math> сложений. Данный вид параллелизма относится к координатному. Так как каждая последующая итерация алгоритма зависит от предыдущей, их выполнение распараллелить не представляется возможным. Таким образом, при наличии бесконечного числа процессоров, итоговая сложность алгоритма составляет <math>O(\frac{n(n+1)}{2})</math>

=== Входные и выходные данные алгоритма ===
'''Входные данные''': плотная матрица <math>A</math> (элементы <math>a_{ij}</math>); при этом <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>..

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы).
Конкретный вариант хранения данных зависит от реализации. В качестве примеров можно привести хранение в одномерном массиве длины <math>\frac{n (n + 1)}{2}</math> по строкам своей нижней части, хранение в виде так называемого ступенчатого массива (такой вариант двумерного массива, в котором каждая строка имеет свой размер).

'''Выходные данные''': вектор собственных значений <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>) длины <math>n</math>.

=== Свойства алгоритма ===
Параллельная сложность выполнения алгоритма составляет <math>O(\frac{n(n+1)}{2}).</math>
Последовательная сложность выполнения алгоритма составляет <math>O(\frac{n^2(n+1)}{2}).</math>
Таким образом, соотношение сложностей является линейным.
Более того, и вычислительная мощность данного алгоритма линейна.

В алгоритме используется примерно в два раза больше операций умножения, чем сложения.
Одельно стоит рассмотреть вопрос хранения матрицы А в процессе работы алгоритма. Хранение лишь нижней или верхней части матрицы в виде одномерного массива возможно; более того, хранение в таком виде обеспечивает экономию памяти в 2 раза и защищает от ассиметричности матрицы в результате накопления математических ошибок. Однако, вычисление индексов <math>i</math> и <math>j</math> элементов <math>a_{ij}</math>, соответствующих данному номеру <math>k</math> вообще говоря требует отдельного цикла, что создает дополнительную нагрузку на процессор.

Кроме того, следует отметить следующие особенности алгоритма:

1)Несмотря на то, что выбор наибольшего наддиагонального элемента, как кандидата на обнуление, кажется оптимальным, на самом деле он таковым не является. При таком выборе элемента, на каждой итерации необходимо находить текущий наибольший элемент в матрице, что требует дополнительных <math>\frac{n*(n-1)}{2}</math> операций сравнения и приводит к увеличению сложности алгоритма до <math>O(n^4)</math>. Вместо этого рекомендуется перебирать по очереди все наддиагональные элементы, большие заданного параметра. В большинстве случаев от 4 до 8 полных проходов достаточно для приближения исходной матрицы к диагональной.

2)Если при выборе в качестве обнуляемого элемента <math>a_{ij}</math> элементы <math>a_{ii} = a_{jj}</math>, то, как видно из формул в пунктах выше, матрицы поворота вырождаются в единичные и матрица на данной итерации не изменяется. Это еще один довод в пользу отказа от выбора наибольшего элемента, т.к. в данном случае произойдет зацикливание алгоритма.

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

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

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

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

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

1)Библиотека [https://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE] содержит последовательную реализацию алгоритма.

2)В цифровой библиотеке ieee.org приводится [http://ieeexplore.ieee.org/document/6310877/ аннотация] статьи 2012 года, в которой авторы описывают реализацию данного алгоритма на CUDA.

3)

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

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-10-15T14:11:36Z

Пронин Андрей: /* Общее описание алгоритма */

{{algorithm
| name = Метод Якоби вычисления собственных значений симметричной матрицы ЗП
| serial_complexity = <math>O(n^3)</math>
| pf_height = <math>O(n^2)</math>
| pf_width = <math>2n</math>
| input_data = <math>n^2</math>
| output_data = <math>n</math>
}}

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

=== Общее описание алгоритма ===
Задача нахождения собственных значений и собственных векторов матриц(СЗВМ) является одной из основных задач для многих разделов физики. <ref>Чечин Г.М., Зехцер М.Ю. Собственные значения и собственные векторы матриц</ref> С такой вычислительной проблемой приходится сталкиваться, например, при исследовании собственных колебаний различных механических систем, колебательных и электронных спектров молекул и кристаллов. Совершенно принципиальное значение эта проблема приобрела после создания в тридцатых годах прошлого века квантовой механики, которая стала базовой дисциплиной исследования микромира.Кроме того, данная проблема важна в теории автоматического управления, как инструмент исследования устойчивости линейных систем.

Метод Якоби приводит симметричную действительную матрицу к диагональной форме с помощью некоторой (в принципе, бесконечной) последовательности плоских вращений в разных плоскостях исходного n-мерного векторного пространства. Метод Якоби состоит из некоторой последовательности шагов, на каждом из которых обнуляется один из внедиагональных элементов (обычно наибольший по модулю), в результате чего старая матрица <math>A_{i}</math> преобразуется в некоторую новую матрицу <math>A_{i+1}</math>. Делается это с помощью преобразования подобия, использующего матрицу плоского вращения <math>J_{i}</math> (подробное описание матрицы плоского вращения приведено ниже в разделе "[[#Математическое описание алгоритма|Математическое описание алгоритма]]"), которая изменяет лишь две координаты <math>n</math>-мерных векторов, а именно, координаты с номерами <math>j</math> и <math>k</math>. При таком шаге матрица <math>A_{i+1}</math> отличается от матрицы <math>A_{i}</math> лишь элементами двух строк с номерами <math>j</math>, <math>k</math> и двух столбцов с теми же номерами (<math>j</math> и <math>k</math>). Все же другие элементы матрицы A остаются неизменными. Число шагов, за которое матрица A приводится таким способом к диагональной форме, в общем случае является бесконечным. (это свойство метода Якоби более подробно рассмотрено в разделе "[[#Свойства алгоритма|Свойства алгоритма]]") В результате метод Якоби представляет собой некоторый бесконечный итерационный процесс, на каждом шаге которого преобразующаяся матрица становится всё более и более близкой к диагональной форме (в смысле уменьшения суммы квадратов всех своих внедиагональных элементов). На практике обычно выбирается заранее заданная погрешность <math>\varepsilon</math> и процесс приведения исходной матрицы к диагональному виду прекращается, когда наибольший по модулю внедиагональный элемент матрицы становится меньше <math>\varepsilon</math>. Таким образом, применяя на практике метод Якоби, мы приводим исходную матрицу к диагональной форме с точностью до некоторой вычислительной погрешности <math>\varepsilon</math> в результате конечного числа шагов. Повышение этой точности требует увеличения числа шагов метода Якоби. В конечном итоге у полученной в результате этого процесса матрицы на диагонали будут находиться все собственные значения (с определённой погрешностью) исходной симметрической матрицы.

==== Симметричность матрицы ====

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

=== Математическое описание алгоритма ===
Пусть <math>A = A_0</math> — симметричная матрица. В методе Якоби для <math>A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,...</math>, которая в конечном счёте сходится к диагональной матрице, у которой диагональными элементами являются все собственные значения матрицы <math>A</math>. Матрица <math>A_{i}</math> получается из матрицы <math>A_{i-1}</math> по формуле
<math>A_{i}=J^{T}_iA_{i-1}J_i ,</math>
где <math>J_i</math> - ортогональная матрица, называемая ''вращением Якоби''. Таким образом,
<math>A_{m}=J^{T}_{m-1}A_{m-1}J_{m-1}</math>
<math>=J^{T}_{m-1}J^{T}_{m-2}A_{m-2}J_{m-2}J_{m-1}</math>
<math>=J^{T}_{m-1}...J^{T}_{0}A_{0}J_{0}...J_{m-1}</math>
<math>=J^{T}AJ</math>
При подходящем выборе вращений <math>J_i</math> матрица <math>A_m</math> для больших <math>m</math> будет близкой к диагональной матрице <math>\Lambda</math> <ref>Дж. Деммель, Вычислительная линейная алгебра. Теория и приложения. Перевод Х.Д.Икрамов</ref>. Таким образом, <math>\Lambda \approx J^{T}AJ</math> или <math>J\Lambda J^{T} \approx A</math>, следовательно, столбцы матрицы <math>J</math> являются собственными значениями матрицы <math>A</math>.
Матрица <math>J_i</math> выбирается таким образом, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}=J^{T}_{i}A_{i}J_{i}</math>:

                                                                            
<math>j</math>
                       
<math>k</math>

<math>
J_i = R(j,k,\theta) \equiv
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & -\sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Угол вращения <math>\theta</math> выбирается так, чтобы элементы <math>(j,k)</math> и <math>(k,j)</math> в <math>A_{i+1}</math> стали нулями. Для того, чтобы найти <math>\theta</math>, составляется уравнение:
:<math>
\begin{bmatrix}
a^{i+1}_{jj}&a^{i+1}_{jk}\\
a^{i+1}_{kj}&a^{i+1}_{kk}\\
\end{bmatrix} =
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix}^T
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix}
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix} =
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} ,
</math>
где <math>\lambda_1</math> и <math>\lambda_2</math> - собственные значения подматрицы
:<math>
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix} .
</math>
Пусть <math>c = \cos(\theta)</math> и <math>s = sin(\theta)</math>, <math>a^{i}_{lk} = a_{lk}</math>. Тогда из предыдущего равенства получаем
:<math>
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} =
\begin{bmatrix}
a_{jj}c^2 + a_{kk}s^2+2sca_{jk}&sc(a_{kk} - a{jj}) + a_{jk}(c^2-s^2)\\
sc(a_{kk} - a{jj}) + a_{jk}(c^2-s^2)&a_{jj}s^2 + a_{kk}c^2-2sca_{jk}\\
\end{bmatrix}
.
</math>
Приравнивая внедиагональный элемент к нулю, получаем
:<math>
\frac{a_{jj} - a{kk}}{2a_{jk}} = \frac{c^2-s^2}{2sc} = ctg(2\theta) = r.
</math>
Пусть <math>tg(\theta) = t = \frac{s}{c}</math> . Заметим, что выполняется квадратное уравнение <math>t^2 + 2rt - 1 = 0</math> . Решая уравнение, получаем <math>t = \frac{sign(r)}{|r| + \sqrt{1+r^2}}</math> . Следовательно <math>c = \frac{1}{\sqrt{1+t^2}}</math>, <math>s = ct</math>

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

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

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

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

1) Блок вычисления параметров вращения на текущей итерации (выбор обнуляемого элемента и расчет угла вращения).

2)Блок, реализующий непосредственно вращение Якоби.

=== Схема реализации последовательного алгоритма ===
1)Находится максимальный наддиагональный элемент <math>a_{jk}</math> матрицы <math>A</math>.

2)Вычисляются параметры вращения Якоби:
<math>\tau= \frac{(a_{jj}-a_{kk})}{2a_{jk}}</math>
<math>t=sign(\tau)(|\tau|+\sqrt{1+\tau^2})</math>
<math>c= \frac{1}{1+\sqrt{1+\tau^2}}</math>
<math>s=c*t</math>

3)К текущей матрице А применяются вращения с вычисленными параметрами:
<math>A=R^T(j,k,\theta)*A*R(j,k,\theta)</math>
Стоит отметить, что вычисленные на предыдущем шаге <math>c</math> и <math>s</math> есть <math>\cos {\theta}</math> и <math>\sin {\theta}</math> соответственно.

4)Если матрица А не достаточно близка к диагональной, происходит переход к шагу 1.

Стоит отметить, что за <math>\frac{n*(n-1)}{2}</math> итераций алгоритма гарантируется получение результата, т.к. сумма квадратов наддиагональных элементов матрицы А на каждой итерации уменьшается на <math>a_{jk}^2</math>.

=== Последовательная сложность алгоритма ===
Сначала оценим сложность одной итерации:

1)Так как элементы матрицы никак не упорядоченны, поиск наибольшего элемента линейно зависит от числа элементов над диагональю.
Конкретнее, на данном шаге происходит <math>\frac{n*(n-1)}{2} -1</math> сравнение.

2)3 операции деления, 2 операции взятия корня, 4 операции умножения и 4 операции сложения/вычитания.

3)<math>4*n</math> операций умножения и <math>2*n</math> операций сложения.

4)операция сравнения

В наиболее неудачном случае количество итераций равняется числу наддиагональных элементов, т.е. <math>\frac{n*(n-1)}{2}</math>.
Таким образом, суммарная сложность алгоритма составляет <math>O(N^4)</math> сравнений, и <math>O(N^3)</math> сложений и умножений.

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

Аналитически информационный граф данного алгоритма можно описать следующим образом:

1)Последовательно идущие макроярусы вычисления параметров текущей итерации и вращения Якоби с этими параметрами
Число данных ярусов варьируется в зависимости от входных данных, но порядок составляет <math>O(n^2)</math>.

2)Вычисление параметров текущей итерации содержит конечное число операций умножения, сложения и вычисления квадратного корня.

3)Макроярус вращения Якоби содержит вычисление <math>4n</math> элементов матрицы. На данном ярусе ширина графа достигает максимального значения.

Визуальное представление графа алгоритма представлено на схемах ниже:

[[file:SI.jpg|thumb|center|1400px|Рисунок 1. Граф алгоритма на макроуровне. Rarams - вычисление параметров, Rotate - получение <math>A_{i+1}</math> из <math>A_{i}</math>.]]

[[file:exec_params.jpg|thumb|center|1400px|Рисунок 2. Структура блока Params.]]

[[file:Rotate.jpg|thumb|center|1400px|Рисунок 3. Структура блока Rotate.]]

=== Ресурс параллелизма алгоритма ===
Как видно из представления алгоритма в ярусно-параллельной форме ([[#Информационный граф| п.1.7]]), максимальная ширина ярусов составляет <math>2n</math> вершин.
Для выполнения данного алгоритма в параллельном варианте следует выполнить <math>O(\frac{n(n+1)}{2})</math> итераций.
Рассмотрим отдельную итерацию с точки зрения ярусно-параллельной формы алгоритма.

1)Выполнение *число_ярусов* ярусов с конечным числом операций

2)Выполнение 2 ярусов вычисления элементов в изменяемых строках и столбцах.

На данных двух ярусах осуществляется <math>4n</math> умножений и <math>2n</math> сложений. Данный вид параллелизма относится к координатному. Так как каждая последующая итерация алгоритма зависит от предыдущей, их выполнение распараллелить не представляется возможным. Таким образом, при наличии бесконечного числа процессоров, итоговая сложность алгоритма составляет <math>O(\frac{n(n+1)}{2})</math>

=== Входные и выходные данные алгоритма ===
'''Входные данные''': плотная матрица <math>A</math> (элементы <math>a_{ij}</math>); при этом <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>..

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы).
Конкретный вариант хранения данных зависит от реализации. В качестве примеров можно привести хранение в одномерном массиве длины <math>\frac{n (n + 1)}{2}</math> по строкам своей нижней части, хранение в виде так называемого ступенчатого массива (такой вариант двумерного массива, в котором каждая строка имеет свой размер).

'''Выходные данные''': вектор собственных значений <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>) длины <math>n</math>.

=== Свойства алгоритма ===
Параллельная сложность выполнения алгоритма составляет <math>O(\frac{n(n+1)}{2}).</math>
Последовательная сложность выполнения алгоритма составляет <math>O(\frac{n^2(n+1)}{2}).</math>
Таким образом, соотношение сложностей является линейным.
Более того, и вычислительная мощность данного алгоритма линейна.

В алгоритме используется примерно в два раза больше операций умножения, чем сложения.
Одельно стоит рассмотреть вопрос хранения матрицы А в процессе работы алгоритма. Хранение лишь нижней или верхней части матрицы в виде одномерного массива возможно; более того, хранение в таком виде обеспечивает экономию памяти в 2 раза и защищает от ассиметричности матрицы в результате накопления математических ошибок. Однако, вычисление индексов <math>i</math> и <math>j</math> элементов <math>a_{ij}</math>, соответствующих данному номеру <math>k</math> вообще говоря требует отдельного цикла, что создает дополнительную нагрузку на процессор.

Кроме того, следует отметить следующие особенности алгоритма:

1)Несмотря на то, что выбор наибольшего наддиагонального элемента, как кандидата на обнуление, кажется оптимальным, на самом деле он таковым не является. При таком выборе элемента, на каждой итерации необходимо находить текущий наибольший элемент в матрице, что требует дополнительных <math>\frac{n*(n-1)}{2}</math> операций сравнения и приводит к увеличению сложности алгоритма до <math>O(n^4)</math>. Вместо этого рекомендуется перебирать по очереди все наддиагональные элементы, большие заданного параметра. В большинстве случаев от 4 до 8 полных проходов достаточно для приближения исходной матрицы к диагональной.

2)Если при выборе в качестве обнуляемого элемента <math>a_{ij}</math> элементы <math>a_{ii} = a_{jj}</math>, то, как видно из формул в пунктах выше, матрицы поворота вырождаются в единичные и матрица на данной итерации не изменяется. Это еще один довод в пользу отказа от выбора наибольшего элемента, т.к. в данном случае произойдет зацикливание алгоритма.

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

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

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

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

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

1)Библиотека [https://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE] содержит последовательную реализацию алгоритма.

2)В цифровой библиотеке ieee.org приводится [http://ieeexplore.ieee.org/document/6310877/ аннотация] статьи 2012 года, в которой авторы описывают реализацию данного алгоритма на CUDA.

3)

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

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-10-15T00:34:29Z

Пронин Андрей: /* Информационный граф */

{{algorithm
| name = Метод Якоби вычисления собственных значений симметричной матрицы ЗП
| serial_complexity = <math>O(n^3)</math>
| pf_height = <math>O(n^2)</math>
| pf_width = <math>2n</math>
| input_data = <math>n^2</math>
| output_data = <math>n</math>
}}

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

=== Общее описание алгоритма ===
Задача нахождения собственных значений и собственных векторов матриц(СЗВМ) является одной из основных задач для многих разделов физики. С такой вычислительной проблемой приходится сталкиваться, например, при исследовании собственных колебаний различных механических систем, колебательных и электронных спектров молекул и кристаллов. Совершенно принципиальное значение эта проблема приобрела после создания в тридцатых годах прошлого века квантовой механики, которая стала базовой дисциплиной исследования микромира.Кроме того, данная проблема важна в теории автоматического управления, как инструмент исследования устойчивости линейных систем.
Метод Якоби приводит симметричную действительную матрицу к диагональной форме с помощью некоторой (в принципе, бесконечной) последовательности плоских вращений в разных плоскостях исходного n-мерного векторного пространства. Метод Якоби состоит из некоторой последовательности шагов, на каждом из которых обнуляется один из недиагональных элементов (обычно наибольший по модулю), в результате чего старая матрица <math>A_{i}</math> преобразуется в некоторую новую матрицу <math>A_{i+1}</math>. Делается это с помощью преобразования подобия, использующего матрицу плоского вращения <math>J_{i}</math> (подробное описание матрицы плоского вращения приведено ниже в разделе "[[#Математическое описание алгоритма|Математическое описание алгоритма]]"), которая изменяет лишь две координаты <math>n</math>-мерных векторов, а именно, координаты с номерами <math>j</math> и <math>k</math>. При таком шаге матрица <math>A_{i+1}</math> отличается от матрицы <math>A_{i}</math> лишь элементами двух строк с номерами <math>j</math>, <math>k</math> и двух столбцов с теми же номерами (<math>j</math> и <math>k</math>). Все же другие элементы матрицы A остаются неизменными. Число шагов, за которое матрица A приводится таким способом к диагональной форме, в общем случае является бесконечным. (это свойство метода Якоби более подробно рассмотрено в разделе "[[#Свойства алгоритма|Свойства алгоритма]]") В результате метод Якоби представляет собой некоторый бесконечный итерационный процесс, на каждом шаге которого преобразующаяся матрица становится всё более и более близкой к диагональной форме (в смысле уменьшения суммы квадратов всех своих недиагональных элементов). На практике обычно выбирается заранее заданная погрешность <math>\varepsilon</math> и процесс приведения исходной матрицы к диагональному виду прекращается, когда наибольший по модулю внедиагональный элемент матрицы становится меньше <math>\varepsilon</math>. Таким образом, применяя на практике метод Якоби, мы приводим исходную матрицу к диагональной форме с точностью до некоторой вычислительной погрешности <math>\varepsilon</math> в результате конечного числа шагов. Повышение этой точности требует увеличения числа шагов метода Якоби. В конечном итоге у полученной в результате этого процесса матрицы на диагонали будут находиться все собственные значения (с определённой погрешностью) исходной симметрической матрицы.

==== Симметричность матрицы ====

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

=== Математическое описание алгоритма ===
Пусть <math>A = A_0</math> — симметричная матрица. В методе Якоби для <math>A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,...</math>, которая в конечном счёте сходится к диагональной матрице, у которой диагональными элементами являются все собственные значения матрицы <math>A</math>. Матрица <math>A_{i}</math> получается из матрицы <math>A_{i-1}</math> по формуле
<math>A_{i}=J^{T}_iA_{i-1}J_i ,</math>
где <math>J_i</math> - ортогональная матрица, называемая ''вращением Якоби''. Таким образом,
<math>A_{m}=J^{T}_{m-1}A_{m-1}J_{m-1}</math>
<math>=J^{T}_{m-1}J^{T}_{m-2}A_{m-2}J_{m-2}J_{m-1}</math>
<math>=J^{T}_{m-1}...J^{T}_{0}A_{0}J_{0}...J_{m-1}</math>
<math>=J^{T}AJ</math>
При подходящем выборе вращений <math>J_i</math> матрица <math>A_m</math> для больших <math>m</math> будет близкой к диагональной матрице <math>\Lambda</math> <ref>Дж. Деммель, Вычислительная линейная алгебра. Теория и приложения. Перевод Х.Д.Икрамов</ref>. Таким образом, <math>\Lambda \approx J^{T}AJ</math> или <math>J\Lambda J^{T} \approx A</math>, следовательно, столбцы матрицы <math>J</math> являются собственными значениями матрицы <math>A</math>.
Матрица <math>J_i</math> выбирается таким образом, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}=J^{T}_{i}A_{i}J_{i}</math>:

                                                                            
<math>j</math>
                       
<math>k</math>

<math>
J_i = R(j,k,\theta) \equiv
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & -\sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Угол вращения <math>\theta</math> выбирается так, чтобы элементы <math>(j,k)</math> и <math>(k,j)</math> в <math>A_{i+1}</math> стали нулями. Для того, чтобы найти <math>\theta</math>, составляется уравнение:
:<math>
\begin{bmatrix}
a^{i+1}_{jj}&a^{i+1}_{jk}\\
a^{i+1}_{kj}&a^{i+1}_{kk}\\
\end{bmatrix} =
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix}^T
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix}
\begin{bmatrix}
\cos(\theta)&-\sin(\theta)\\
\sin(\theta)&\cos(\theta)\\
\end{bmatrix} =
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} ,
</math>
где <math>\lambda_1</math> и <math>\lambda_2</math> - собственные значения подматрицы
:<math>
\begin{bmatrix}
a^{i}_{jj}&a^{i}_{jk}\\
a^{i}_{kj}&a^{i}_{kk}\\
\end{bmatrix} .
</math>
Пусть <math>c = \cos(\theta)</math> и <math>s = sin(\theta)</math>, <math>a^{i}_{lk} = a_{lk}</math>. Тогда из предыдущего равенства получаем
:<math>
\begin{bmatrix}
\lambda_1&0\\
0&\lambda_2\\
\end{bmatrix} =
\begin{bmatrix}
a_{jj}c^2 + a_{kk}s^2+2sca_{jk}&sc(a_{kk} - a{jj}) + a_{jk}(c^2-s^2)\\
sc(a_{kk} - a{jj}) + a_{jk}(c^2-s^2)&a_{jj}s^2 + a_{kk}c^2-2sca_{jk}\\
\end{bmatrix}
.
</math>
Приравнивая внедиагональный элемент к нулю, получаем
:<math>
\frac{a_{jj} - a{kk}}{2a_{jk}} = \frac{c^2-s^2}{2sc} = ctg(2\theta) = r.
</math>
Пусть <math>tg(\theta) = t = \frac{s}{c}</math> . Заметим, что выполняется квадратное уравнение <math>t^2 + 2rt - 1 = 0</math> . Решая уравнение, получаем <math>t = \frac{sign(r)}{|r| + \sqrt{1+r^2}}</math> . Следовательно <math>c = \frac{1}{\sqrt{1+t^2}}</math>, <math>s = ct</math>

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

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

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

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

1) Блок вычисления параметров вращения на текущей итерации (выбор обнуляемого элемента и расчет угла вращения).

2)Блок, реализующий непосредственно вращение Якоби.

=== Схема реализации последовательного алгоритма ===
1)Находится максимальный наддиагональный элемент <math>a_{jk}</math> матрицы <math>A</math>.

2)Вычисляются параметры вращения Якоби:
<math>\tau= \frac{(a_{jj}-a_{kk})}{2a_{jk}}</math>
<math>t=sign(\tau)(|\tau|+\sqrt{1+\tau^2})</math>
<math>c= \frac{1}{1+\sqrt{1+\tau^2}}</math>
<math>s=c*t</math>

3)К текущей матрице А применяются вращения с вычисленными параметрами:
<math>A=R^T(j,k,\theta)*A*R(j,k,\theta)</math>
Стоит отметить, что вычисленные на предыдущем шаге <math>c</math> и <math>s</math> есть <math>\cos {\theta}</math> и <math>\sin {\theta}</math> соответственно.

4)Если матрица А не достаточно близка к диагональной, происходит переход к шагу 1.

Стоит отметить, что за <math>\frac{n*(n-1)}{2}</math> итераций алгоритма гарантируется получение результата, т.к. сумма квадратов наддиагональных элементов матрицы А на каждой итерации уменьшается на <math>a_{jk}^2</math>.

=== Последовательная сложность алгоритма ===
Сначала оценим сложность одной итерации:

1)Так как элементы матрицы никак не упорядоченны, поиск наибольшего элемента линейно зависит от числа элементов над диагональю.
Конкретнее, на данном шаге происходит <math>\frac{n*(n-1)}{2} -1</math> сравнение.

2)3 операции деления, 2 операции взятия корня, 4 операции умножения и 4 операции сложения/вычитания.

3)<math>4*n</math> операций умножения и <math>2*n</math> операций сложения.

4)операция сравнения

В наиболее неудачном случае количество итераций равняется числу наддиагональных элементов, т.е. <math>\frac{n*(n-1)}{2}</math>.
Таким образом, суммарная сложность алгоритма составляет <math>O(N^4)</math> сравнений, и <math>O(N^3)</math> сложений и умножений.

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

Аналитически информационный граф данного алгоритма можно описать следующим образом:

1)Последовательно идущие макроярусы вычисления параметров текущей итерации и вращения Якоби с этими параметрами
Число данных ярусов варьируется в зависимости от входных данных, но порядок составляет <math>O(n^2)</math>.

2)Вычисление параметров текущей итерации содержит конечное число операций умножения, сложения и вычисления квадратного корня.

3)Макроярус вращения Якоби содержит вычисление <math>4n</math> элементов матрицы. На данном ярусе ширина графа достигает максимального значения.

Визуальное представление графа алгоритма представлено на схемах ниже:

[[file:SI.jpg|thumb|center|1400px|Рисунок 1. Граф алгоритма на макроуровне. Rarams - вычисление параметров, Rotate - получение <math>A_{i+1}</math> из <math>A_{i}</math>.]]

[[file:exec_params.jpg|thumb|center|1400px|Рисунок 2. Структура блока Params.]]

[[file:Rotate.jpg|thumb|center|1400px|Рисунок 3. Структура блока Rotate.]]

=== Ресурс параллелизма алгоритма ===
Как видно из представления алгоритма в ярусно-параллельной форме ([[#Информационный граф| п.1.7]]), максимальная ширина ярусов составляет <math>2n</math> вершин.
Для выполнения данного алгоритма в параллельном варианте следует выполнить <math>O(\frac{n(n+1)}{2})</math> итераций.
Рассмотрим отдельную итерацию с точки зрения ярусно-параллельной формы алгоритма.

1)Выполнение *число_ярусов* ярусов с конечным числом операций

2)Выполнение 2 ярусов вычисления элементов в изменяемых строках и столбцах.

На данных двух ярусах осуществляется <math>4n</math> умножений и <math>2n</math> сложений. Данный вид параллелизма относится к координатному. Так как каждая последующая итерация алгоритма зависит от предыдущей, их выполнение распараллелить не представляется возможным. Таким образом, при наличии бесконечного числа процессоров, итоговая сложность алгоритма составляет <math>O(\frac{n(n+1)}{2})</math>

=== Входные и выходные данные алгоритма ===
'''Входные данные''': плотная матрица <math>A</math> (элементы <math>a_{ij}</math>); при этом <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>..

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы).
Конкретный вариант хранения данных зависит от реализации. В качестве примеров можно привести хранение в одномерном массиве длины <math>\frac{n (n + 1)}{2}</math> по строкам своей нижней части, хранение в виде так называемого ступенчатого массива (такой вариант двумерного массива, в котором каждая строка имеет свой размер).

'''Выходные данные''': вектор собственных значений <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>) длины <math>n</math>.

=== Свойства алгоритма ===
Параллельная сложность выполнения алгоритма составляет <math>O(\frac{n(n+1)}{2}).</math>
Последовательная сложность выполнения алгоритма составляет <math>O(\frac{n^2(n+1)}{2}).</math>
Таким образом, соотношение сложностей является линейным.
Более того, и вычислительная мощность данного алгоритма линейна.

В алгоритме используется примерно в два раза больше операций умножения, чем сложения.
Одельно стоит рассмотреть вопрос хранения матрицы А в процессе работы алгоритма. Хранение лишь нижней или верхней части матрицы в виде одномерного массива возможно; более того, хранение в таком виде обеспечивает экономию памяти в 2 раза и защищает от ассиметричности матрицы в результате накопления математических ошибок. Однако, вычисление индексов <math>i</math> и <math>j</math> элементов <math>a_{ij}</math>, соответствующих данному номеру <math>k</math> вообще говоря требует отдельного цикла, что создает дополнительную нагрузку на процессор.

Кроме того, следует отметить следующие особенности алгоритма:

1)Несмотря на то, что выбор наибольшего наддиагонального элемента, как кандидата на обнуление, кажется оптимальным, на самом деле он таковым не является. При таком выборе элемента, на каждой итерации необходимо находить текущий наибольший элемент в матрице, что требует дополнительных <math>\frac{n*(n-1)}{2}</math> операций сравнения и приводит к увеличению сложности алгоритма до <math>O(n^4)</math>. Вместо этого рекомендуется перебирать по очереди все наддиагональные элементы, большие заданного параметра. В большинстве случаев от 4 до 8 полных проходов достаточно для приближения исходной матрицы к диагональной.

2)Если при выборе в качестве обнуляемого элемента <math>a_{ij}</math> элементы <math>a_{ii} = a_{jj}</math>, то, как видно из формул в пунктах выше, матрицы поворота вырождаются в единичные и матрица на данной итерации не изменяется. Это еще один довод в пользу отказа от выбора наибольшего элемента, т.к. в данном случае произойдет зацикливание алгоритма.

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

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

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

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

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

1)Библиотека [https://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE] содержит последовательную реализацию алгоритма.

2)В цифровой библиотеке ieee.org приводится [http://ieeexplore.ieee.org/document/6310877/ аннотация] статьи 2012 года, в которой авторы описывают реализацию данного алгоритма на CUDA.

3)

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

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-10-15T00:18:40Z

Пронин Андрей: /* Существующие реализации алгоритма */

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-10-15T00:12:36Z

Пронин Андрей: /* Вычислительное ядро алгоритма */

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-10-14T23:55:58Z

Пронин Андрей: /* Макроструктура алгоритма */

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-10-14T23:55:04Z

Пронин Андрей: /* Макроструктура алгоритма */

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-10-14T23:45:57Z

Пронин Андрей: /* Существующие реализации алгоритма */

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-10-14T23:32:27Z

Пронин Андрей: /* Общее описание алгоритма */

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-10-14T23:06:18Z

Пронин Андрей: /* Свойства алгоритма */

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-10-14T22:25:13Z

Пронин Андрей: /* Ресурс параллелизма алгоритма */

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-10-14T22:14:53Z

Пронин Андрей: /* Ресурс параллелизма алгоритма */

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-10-14T22:00:39Z

Пронин Андрей: /* Ресурс параллелизма алгоритма */

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-10-14T21:52:15Z

Пронин Андрей:

Участник:Пронин Андрей

2016-10-12T18:34:19Z

Пронин Андрей: Новая страница: «Студент 614 группы ВМК МГУ»

Студент 614 группы ВМК МГУ

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-10-10T20:10:25Z

Пронин Андрей: /* Входные и выходные данные алгоритма */

{{algorithm
| name = Разложение Холецкого
| serial_complexity = <math></math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math></math>
| output_data = <math></math>
}}

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

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

==== Симметричность и положительная определённость матрицы ====

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

=== Математическое описание алгоритма ===
Пусть <math>A = A_0</math> — симметричная матрица. В методе Якоби для <math>A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,...</math>, которая в конечном счёте сходится к диагональной матрице, у которой диагональными элементами являются все собственные значения матрицы <math>A</math>. Матрица <math>A_{i}</math> получается из матрицы <math>A_{i-1}</math> по формуле

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

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

=== Схема реализации последовательного алгоритма ===
1)Находится максимальный наддиагональный элемент <math>a_{jk}</math> матрицы <math>A</math>.

2)Вычисляются параметры вращения Якоби:
<math>\tau= \frac{(a_{jj}-a_{kk})}{2a_{jk}}</math>
<math>t=sign(\tau)(|\tau|+\sqrt{1+\tau^2})</math>
<math>c= \frac{1}{1+\sqrt{1+\tau^2}}</math>
<math>s=c*t</math>

3)К текущей матрице А применяются вращения с вычисленными параметрами:
<math>A=R^T(j,k,\theta)*A*R(j,k,\theta)</math>
Стоит отметить, что вычисленные на предыдущем шаге <math>c</math> и <math>s</math> есть <math>\cos {\theta}</math> и <math>\sin {\theta}</math> соответственно.

4)Если матрица А не достаточно близка к диагональной, происходит переход к шагу 1.

Стоит отметить, что за <math>\frac{n*(n-1)}{2}</math> итераций алгоритма гарантируется получение результата, т.к. сумма квадратов наддиагональных элементов матрицы А на каждой итерации уменьшается на <math>a_{jk}^2</math>.

=== Последовательная сложность алгоритма ===
Сначала оценим сложность одной итерации:

1)Так как элементы матрицы никак не упорядоченны, поиск наибольшего элемента линейно зависит от числа элементов над диагональю.
Конкретнее, на данном шаге происходит <math>\frac{n*(n-1)}{2} -1</math> сравнение.

2)3 операции деления, 2 операции взятия корня, 4 операции умножения и 4 операции сложения/вычитания.

3)<math>4*n</math> операций умножения и <math>2*n</math> операций сложения.

4)операция сравнения

В наиболее неудачном случае количество итераций равняется числу наддиагональных элементов, т.е. <math>\frac{n*(n-1)}{2}</math>.
Таким образом, суммарная сложность алгоритма составляет <math>O(N^4)</math> сравнений, и <math>O(N^3)</math> сложений и умножений.

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

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

=== Входные и выходные данные алгоритма ===
'''Входные данные''': плотная матрица <math>A</math> (элементы <math>a_{ij}</math>); при этом <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>..

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы).
Конкретный вариант хранения данных зависит от реализации. В качестве примеров можно привести хранение в одномерном массиве длины <math>\frac{n (n + 1)}{2}</math> по строкам своей нижней части, хранение в виде так называемого ступенчатого массива (такой вариант двумерного массива, в котором каждая строка имеет свой размер).

'''Выходные данные''': вектор собственных значений <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>) длины <math>n</math>.

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

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

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

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

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

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

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

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-10-10T20:10:05Z

Пронин Андрей: /* Входные и выходные данные алгоритма */

{{algorithm
| name = Разложение Холецкого
| serial_complexity = <math></math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math></math>
| output_data = <math></math>
}}

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

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

==== Симметричность и положительная определённость матрицы ====

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

=== Математическое описание алгоритма ===
Пусть <math>A = A_0</math> — симметричная матрица. В методе Якоби для <math>A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,...</math>, которая в конечном счёте сходится к диагональной матрице, у которой диагональными элементами являются все собственные значения матрицы <math>A</math>. Матрица <math>A_{i}</math> получается из матрицы <math>A_{i-1}</math> по формуле

, а <math>G = G(i, j, \theta)</math> — матрица вращения. Тогда

: <math>A'=G^\top A G</math>

симметрична и подобна матрице <math>A</math>.

Более того, <math>A'</math> содержит следующие компоненты:

: <math>\begin{align}
A'_{ii} &= c^2\, A_{ii} - 2\, s c \,A_{ij} + s^2\, A_{jj} \\
A'_{jj} &= s^2 \,A_{ii} + 2 s c\, A_{ij} + c^2 \, A_{jj} \\
A'_{ij} &= A'_{ji} = (c^2 - s^2 ) \, A_{ij} + s c \, (A_{ii} - A_{jj} ) \\
A'_{ik} &= A'_{ki} = c \, A_{ik} - s \, A_{jk} & k \ne i,j \\
A'_{jk} &= A'_{kj} = s \, A_{ik} + c \, A_{jk} & k \ne i,j \\
A'_{kl} &= A_{kl} &k,l \ne i,j
\end{align}</math>

где <math>s = \sin \theta</math> и <math>c = \cos \theta</math>.

Поскольку <math>G</math> — ортогональная матрица, у матриц <math>A</math> и <math>A'</math> равны фробениусовы нормы <math>||\cdot||_F</math> (корни из сумм квадратов всех компонент), причём мы можем выбрать <math>\theta</math> так, чтобы <math>A'_{ij} = 0</math>, и в этом случае <math>A'</math> будет иметь бóльшую сумму квадратов диагональных элементов:

: <math> A'_{ij} = \cos(2\theta) A_{ij} + \tfrac{1}{2} \sin(2\theta) (A_{ii} - A_{jj}) </math>

Приравнивая это нулю, получим

: <math> \operatorname{tg}(2\theta) = \frac{2 A_{ij}}{A_{jj} - A_{ii}} </math>

Если <math> A_{jj} = A_{ii} </math>, то

: <math> \theta = \frac{\pi} {4} . </math>

Чтобы достичь оптимального эффекта, необходимо потребовать, чтобы <math>A_{ij}</math> был наибольшим по модулю внедиагональным элементом, т. н. ''опорным'' элементом.

Метод Якоби для собственных значений производит вращения до тех пор, пока матрица не станет почти диагональной. Тогда элементы на диагонали аппроксимируют собственные значения матрицы <math>A</math>.

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

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

=== Схема реализации последовательного алгоритма ===
1)Находится максимальный наддиагональный элемент <math>a_{jk}</math> матрицы <math>A</math>.

2)Вычисляются параметры вращения Якоби:
<math>\tau= \frac{(a_{jj}-a_{kk})}{2a_{jk}}</math>
<math>t=sign(\tau)(|\tau|+\sqrt{1+\tau^2})</math>
<math>c= \frac{1}{1+\sqrt{1+\tau^2}}</math>
<math>s=c*t</math>

3)К текущей матрице А применяются вращения с вычисленными параметрами:
<math>A=R^T(j,k,\theta)*A*R(j,k,\theta)</math>
Стоит отметить, что вычисленные на предыдущем шаге <math>c</math> и <math>s</math> есть <math>\cos {\theta}</math> и <math>\sin {\theta}</math> соответственно.

4)Если матрица А не достаточно близка к диагональной, происходит переход к шагу 1.

Стоит отметить, что за <math>\frac{n*(n-1)}{2}</math> итераций алгоритма гарантируется получение результата, т.к. сумма квадратов наддиагональных элементов матрицы А на каждой итерации уменьшается на <math>a_{jk}^2</math>.

=== Последовательная сложность алгоритма ===
Сначала оценим сложность одной итерации:

1)Так как элементы матрицы никак не упорядоченны, поиск наибольшего элемента линейно зависит от числа элементов над диагональю.
Конкретнее, на данном шаге происходит <math>\frac{n*(n-1)}{2} -1</math> сравнение.

2)3 операции деления, 2 операции взятия корня, 4 операции умножения и 4 операции сложения/вычитания.

3)<math>4*n</math> операций умножения и <math>2*n</math> операций сложения.

4)операция сравнения

В наиболее неудачном случае количество итераций равняется числу наддиагональных элементов, т.е. <math>\frac{n*(n-1)}{2}</math>.
Таким образом, суммарная сложность алгоритма составляет <math>O(N^4)</math> сравнений, и <math>O(N^3)</math> сложений и умножений.

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

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

=== Входные и выходные данные алгоритма ===
'''Входные данные''': плотная матрица <math>A</math> (элементы <math>a_{ij}</math>); при этом <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>..

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы).
Конкретный вариант хранения данных зависит от реализации. В качестве примеров можно привести хранение в одномерном массиве длины <math>\frac{n (n + 1)}{2}</math> по строкам своей нижней части, хранение в виде так называемого ступенчатого массива (такой вариант двумерного массива, в котором каждая строка имеет свой размер).

'''Выходные данные''': вектор собственных значений <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>) длины <math>N</math>.

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

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

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

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

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

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

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

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-10-10T20:08:54Z

Пронин Андрей: /* Входные и выходные данные алгоритма */

{{algorithm
| name = Разложение Холецкого
| serial_complexity = <math></math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math></math>
| output_data = <math></math>
}}

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

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

==== Симметричность и положительная определённость матрицы ====

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

=== Математическое описание алгоритма ===
Пусть <math>A</math> — симметричная матрица, а <math>G = G(i, j, \theta)</math> — матрица вращения. Тогда

: <math>A'=G^\top A G</math>

симметрична и подобна матрице <math>A</math>.

Более того, <math>A'</math> содержит следующие компоненты:

: <math>\begin{align}
A'_{ii} &= c^2\, A_{ii} - 2\, s c \,A_{ij} + s^2\, A_{jj} \\
A'_{jj} &= s^2 \,A_{ii} + 2 s c\, A_{ij} + c^2 \, A_{jj} \\
A'_{ij} &= A'_{ji} = (c^2 - s^2 ) \, A_{ij} + s c \, (A_{ii} - A_{jj} ) \\
A'_{ik} &= A'_{ki} = c \, A_{ik} - s \, A_{jk} & k \ne i,j \\
A'_{jk} &= A'_{kj} = s \, A_{ik} + c \, A_{jk} & k \ne i,j \\
A'_{kl} &= A_{kl} &k,l \ne i,j
\end{align}</math>

где <math>s = \sin \theta</math> и <math>c = \cos \theta</math>.

Поскольку <math>G</math> — ортогональная матрица, у матриц <math>A</math> и <math>A'</math> равны фробениусовы нормы <math>||\cdot||_F</math> (корни из сумм квадратов всех компонент), причём мы можем выбрать <math>\theta</math> так, чтобы <math>A'_{ij} = 0</math>, и в этом случае <math>A'</math> будет иметь бóльшую сумму квадратов диагональных элементов:

: <math> A'_{ij} = \cos(2\theta) A_{ij} + \tfrac{1}{2} \sin(2\theta) (A_{ii} - A_{jj}) </math>

Приравнивая это нулю, получим

: <math> \operatorname{tg}(2\theta) = \frac{2 A_{ij}}{A_{jj} - A_{ii}} </math>

Если <math> A_{jj} = A_{ii} </math>, то

: <math> \theta = \frac{\pi} {4} . </math>

Чтобы достичь оптимального эффекта, необходимо потребовать, чтобы <math>A_{ij}</math> был наибольшим по модулю внедиагональным элементом, т. н. ''опорным'' элементом.

Метод Якоби для собственных значений производит вращения до тех пор, пока матрица не станет почти диагональной. Тогда элементы на диагонали аппроксимируют собственные значения матрицы <math>A</math>.

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

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

=== Схема реализации последовательного алгоритма ===
1)Находится максимальный наддиагональный элемент <math>a_{jk}</math> матрицы <math>A</math>.

2)Вычисляются параметры вращения Якоби:
<math>\tau= \frac{(a_{jj}-a_{kk})}{2a_{jk}}</math>
<math>t=sign(\tau)(|\tau|+\sqrt{1+\tau^2})</math>
<math>c= \frac{1}{1+\sqrt{1+\tau^2}}</math>
<math>s=c*t</math>

3)К текущей матрице А применяются вращения с вычисленными параметрами:
<math>A=R^T(j,k,\theta)*A*R(j,k,\theta)</math>
Стоит отметить, что вычисленные на предыдущем шаге <math>c</math> и <math>s</math> есть <math>\cos {\theta}</math> и <math>\sin {\theta}</math> соответственно.

4)Если матрица А не достаточно близка к диагональной, происходит переход к шагу 1.

Стоит отметить, что за <math>\frac{n*(n-1)}{2}</math> итераций алгоритма гарантируется получение результата, т.к. сумма квадратов наддиагональных элементов матрицы А на каждой итерации уменьшается на <math>a_{jk}^2</math>.

=== Последовательная сложность алгоритма ===
Сначала оценим сложность одной итерации:

1)Так как элементы матрицы никак не упорядоченны, поиск наибольшего элемента линейно зависит от числа элементов над диагональю.
Конкретнее, на данном шаге происходит <math>\frac{n*(n-1)}{2} -1</math> сравнение.

2)3 операции деления, 2 операции взятия корня, 4 операции умножения и 4 операции сложения/вычитания.

3)<math>4*n</math> операций умножения и <math>2*n</math> операций сложения.

4)операция сравнения

В наиболее неудачном случае количество итераций равняется числу наддиагональных элементов, т.е. <math>\frac{n*(n-1)}{2}</math>.
Таким образом, суммарная сложность алгоритма составляет <math>O(N^4)</math> сравнений, и <math>O(N^3)</math> сложений и умножений.

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

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

=== Входные и выходные данные алгоритма ===
'''Входные данные''': плотная матрица <math>A</math> (элементы <math>a_{ij}</math>); при этом <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>..

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы).
Конкретный вариант хранения данных зависит от реализации. В качестве примеров можно привести хранение в одномерном массиве длины <math>\frac{n (n + 1)}{2}</math> по строкам своей нижней части, хранение в виде так называемого ступенчатого массива (такой вариант двумерного массива, в котором каждая строка имеет свой размер).

'''Выходные данные''': вектор собственных значений <math>\Lambda</math> длины <math>N</math>.

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

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

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

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

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

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

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

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-10-10T20:08:32Z

Пронин Андрей: /* Входные и выходные данные алгоритма */

{{algorithm
| name = Разложение Холецкого
| serial_complexity = <math></math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math></math>
| output_data = <math></math>
}}

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

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

==== Симметричность и положительная определённость матрицы ====

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

=== Математическое описание алгоритма ===
Пусть <math>A</math> — симметричная матрица, а <math>G = G(i, j, \theta)</math> — матрица вращения. Тогда

: <math>A'=G^\top A G</math>

симметрична и подобна матрице <math>A</math>.

Более того, <math>A'</math> содержит следующие компоненты:

: <math>\begin{align}
A'_{ii} &= c^2\, A_{ii} - 2\, s c \,A_{ij} + s^2\, A_{jj} \\
A'_{jj} &= s^2 \,A_{ii} + 2 s c\, A_{ij} + c^2 \, A_{jj} \\
A'_{ij} &= A'_{ji} = (c^2 - s^2 ) \, A_{ij} + s c \, (A_{ii} - A_{jj} ) \\
A'_{ik} &= A'_{ki} = c \, A_{ik} - s \, A_{jk} & k \ne i,j \\
A'_{jk} &= A'_{kj} = s \, A_{ik} + c \, A_{jk} & k \ne i,j \\
A'_{kl} &= A_{kl} &k,l \ne i,j
\end{align}</math>

где <math>s = \sin \theta</math> и <math>c = \cos \theta</math>.

Поскольку <math>G</math> — ортогональная матрица, у матриц <math>A</math> и <math>A'</math> равны фробениусовы нормы <math>||\cdot||_F</math> (корни из сумм квадратов всех компонент), причём мы можем выбрать <math>\theta</math> так, чтобы <math>A'_{ij} = 0</math>, и в этом случае <math>A'</math> будет иметь бóльшую сумму квадратов диагональных элементов:

: <math> A'_{ij} = \cos(2\theta) A_{ij} + \tfrac{1}{2} \sin(2\theta) (A_{ii} - A_{jj}) </math>

Приравнивая это нулю, получим

: <math> \operatorname{tg}(2\theta) = \frac{2 A_{ij}}{A_{jj} - A_{ii}} </math>

Если <math> A_{jj} = A_{ii} </math>, то

: <math> \theta = \frac{\pi} {4} . </math>

Чтобы достичь оптимального эффекта, необходимо потребовать, чтобы <math>A_{ij}</math> был наибольшим по модулю внедиагональным элементом, т. н. ''опорным'' элементом.

Метод Якоби для собственных значений производит вращения до тех пор, пока матрица не станет почти диагональной. Тогда элементы на диагонали аппроксимируют собственные значения матрицы <math>A</math>.

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

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

=== Схема реализации последовательного алгоритма ===
1)Находится максимальный наддиагональный элемент <math>a_{jk}</math> матрицы <math>A</math>.

2)Вычисляются параметры вращения Якоби:
<math>\tau= \frac{(a_{jj}-a_{kk})}{2a_{jk}}</math>
<math>t=sign(\tau)(|\tau|+\sqrt{1+\tau^2})</math>
<math>c= \frac{1}{1+\sqrt{1+\tau^2}}</math>
<math>s=c*t</math>

3)К текущей матрице А применяются вращения с вычисленными параметрами:
<math>A=R^T(j,k,\theta)*A*R(j,k,\theta)</math>
Стоит отметить, что вычисленные на предыдущем шаге <math>c</math> и <math>s</math> есть <math>\cos {\theta}</math> и <math>\sin {\theta}</math> соответственно.

4)Если матрица А не достаточно близка к диагональной, происходит переход к шагу 1.

Стоит отметить, что за <math>\frac{n*(n-1)}{2}</math> итераций алгоритма гарантируется получение результата, т.к. сумма квадратов наддиагональных элементов матрицы А на каждой итерации уменьшается на <math>a_{jk}^2</math>.

=== Последовательная сложность алгоритма ===
Сначала оценим сложность одной итерации:

1)Так как элементы матрицы никак не упорядоченны, поиск наибольшего элемента линейно зависит от числа элементов над диагональю.
Конкретнее, на данном шаге происходит <math>\frac{n*(n-1)}{2} -1</math> сравнение.

2)3 операции деления, 2 операции взятия корня, 4 операции умножения и 4 операции сложения/вычитания.

3)<math>4*n</math> операций умножения и <math>2*n</math> операций сложения.

4)операция сравнения

В наиболее неудачном случае количество итераций равняется числу наддиагональных элементов, т.е. <math>\frac{n*(n-1)}{2}</math>.
Таким образом, суммарная сложность алгоритма составляет <math>O(N^4)</math> сравнений, и <math>O(N^3)</math> сложений и умножений.

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

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

=== Входные и выходные данные алгоритма ===
'''Входные данные''': плотная матрица <math>A</math> (элементы <math>a_{ij}</math>); при этом <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>..
'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы).
Конкретный вариант хранения данных зависит от реализации. В качестве примеров можно привести хранение в одномерном массиве длины <math>\frac{n (n + 1)}{2}</math> по строкам своей нижней части, хранение в виде так называемого ступенчатого массива (такой вариант двумерного массива, в котором каждая строка имеет свой размер).

'''Выходные данные''': вектор собственных значений <math>\Lambda</math> длины <math>N</math>.

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

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

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

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

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

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

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

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-10-10T19:50:40Z

Пронин Андрей: /* Схема реализации последовательного алгоритма */

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-10-10T19:40:50Z

Пронин Андрей: /* Программная реализация алгоритма */

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-10-07T10:24:55Z

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

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-10-07T10:18:38Z

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

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-10-07T10:07:15Z

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

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-10-07T09:48:02Z

Пронин Андрей: /* Схема реализации последовательного алгоритма */

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-10-07T09:47:31Z

Пронин Андрей: /* Схема реализации последовательного алгоритма */

Участник:Зиновьев Владимир/Метод Якоби вычисления собственных значений симметричной матрицы ЗП

2016-10-07T09:39:12Z

Пронин Андрей: /* Схема реализации последовательного алгоритма */