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

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

2016-11-21T19:35:10Z

Зиновьев Владимир: /* Ресурс параллелизма алгоритма */

{{Assignment}}

{{algorithm
| name = Метод Якоби вычисления собственных значений симметричной матрицы ЗП
| serial_complexity = <math>O(n^3)</math>
| pf_height = <math>O(n^2)</math>
| pf_width = <math>O(n)</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>O(n^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-21T19:34:24Z

Зиновьев Владимир: /* Ресурс параллелизма алгоритма */

{{Assignment}}

{{algorithm
| name = Метод Якоби вычисления собственных значений симметричной матрицы ЗП
| serial_complexity = <math>O(n^3)</math>
| pf_height = <math>O(n^2)</math>
| pf_width = <math>O(n)</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>O(N^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-21T19:34:05Z

Зиновьев Владимир: /* Ресурс параллелизма алгоритма */

{{Assignment}}

{{algorithm
| name = Метод Якоби вычисления собственных значений симметричной матрицы ЗП
| serial_complexity = <math>O(n^3)</math>
| pf_height = <math>O(n^2)</math>
| pf_width = <math>O(n)</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>O(n^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-21T19:26:43Z

Зиновьев Владимир:

{{Assignment}}

{{algorithm
| name = Метод Якоби вычисления собственных значений симметричной матрицы ЗП
| serial_complexity = <math>O(n^3)</math>
| pf_height = <math>O(n^2)</math>
| pf_width = <math>O(n)</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-18T20:58:49Z

Зиновьев Владимир:

{{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>). Все же другие элементы матрицы <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

[[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-18T20:57:35Z

Зиновьев Владимир: /* Масштабируемость реализации алгоритма */

{{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

[[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-18T20:53:37Z

Зиновьев Владимир: /* Масштабируемость реализации алгоритма */

{{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

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

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

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

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

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

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

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

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-18T20:49: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>). Все же другие элементы матрицы <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

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

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

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

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

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-18T20:48:44Z

Зиновьев Владимир: /* Масштабируемость реализации алгоритма */

{{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

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

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

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

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-18T20:44:27Z

Зиновьев Владимир: /* Масштабируемость реализации алгоритма */

{{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

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

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

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

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

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-18T20:43:04Z

Зиновьев Владимир: /* Масштабируемость алгоритма и его реализации */

{{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

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

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

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

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

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-18T19:01:17Z

Зиновьев Владимир: /* Свойства алгоритма */

{{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>, то, как видно из формул в пунктах выше, матрицы поворота вырождаются в единичные и матрица на данной итерации не изменяется. Это еще один довод в пользу отказа от выбора наибольшего элемента, т.к. в данном случае произойдет зацикливание алгоритма.

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

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

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

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

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

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

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

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

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

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

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

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

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

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-18T19:00:47Z

Зиновьев Владимир: /* Свойства алгоритма */

{{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>. Вместо этого рекомендуется перебирать по очереди все наддиагональные элементы, большие заданного параметра. В большинстве случаев от 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-11-18T18:57:08Z

Зиновьев Владимир: /* Свойства алгоритма */

{{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>
Таким образом, соотношение сложностей является линейным.
Более того, и вычислительная мощность данного алгоритма линейна.

В алгоритме используется примерно в два раза больше операций умножения, чем сложения.
Отдельно стоит рассмотреть вопрос хранения матрицы А в процессе работы алгоритма. Хранение лишь нижней или верхней части матрицы в виде одномерного массива возможно; более того, хранение в таком виде обеспечивает экономию памяти в 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-11-18T18:54:47Z

Зиновьев Владимир: /* Информационный граф */

{{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>
Таким образом, соотношение сложностей является линейным.
Более того, и вычислительная мощность данного алгоритма линейна.

В алгоритме используется примерно в два раза больше операций умножения, чем сложения.
Одельно стоит рассмотреть вопрос хранения матрицы А в процессе работы алгоритма. Хранение лишь нижней или верхней части матрицы в виде одномерного массива возможно; более того, хранение в таком виде обеспечивает экономию памяти в 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-11-18T18:53:08Z

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

{{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>
Таким образом, соотношение сложностей является линейным.
Более того, и вычислительная мощность данного алгоритма линейна.

В алгоритме используется примерно в два раза больше операций умножения, чем сложения.
Одельно стоит рассмотреть вопрос хранения матрицы А в процессе работы алгоритма. Хранение лишь нижней или верхней части матрицы в виде одномерного массива возможно; более того, хранение в таком виде обеспечивает экономию памяти в 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-11-18T18:48:49Z

Зиновьев Владимир: /* Схема реализации последовательного алгоритма */

{{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)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-11-18T08:43:59Z

Зиновьев Владимир: /* Вычислительное ядро алгоритма */

{{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=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-11-18T08:42: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>
}}

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

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

=== Общее описание алгоритма ===
Задача нахождения собственных значений и собственных векторов матриц(СЗВМ) является одной из основных задач для многих разделов физики. <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> при применении поворота Якоби. Конкретно, изменяются 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-11-17T19:23:28Z

Зиновьев Владимир:

{{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> при применении поворота Якоби. Конкретно, изменяются 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-11-17T19:22:37Z

Зиновьев Владимир:

{{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 остаются неизменными. Число шагов, за которое матрица <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> при применении поворота Якоби. Конкретно, изменяются 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-11-17T17:36: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>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:51: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>

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

Вычислительным ядром отдельной итерации является вычисление элементов матрицы <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: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:47:46Z

Зиновьев Владимир:

{{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:ROT.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-20T14:25:25Z

Зиновьев Владимир:

{{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-15T00:35: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>

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

На отдельной итерации вычислительным ядром является вычисление новых значений элементов матрицы. Конкретно, изменяются 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:32: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>
}}

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

=== Общее описание алгоритма ===
Задача нахождения собственных значений и собственных векторов матриц(СЗВМ) является одной из основных задач для многих разделов физики. С такой вычислительной проблемой приходится сталкиваться, например, при исследовании собственных колебаний различных механических систем, колебательных и электронных спектров молекул и кристаллов. Совершенно принципиальное значение эта проблема приобрела после создания в тридцатых годах прошлого века квантовой механики, которая стала базовой дисциплиной исследования микромира.Кроме того, данная проблема важна в теории автоматического управления, как инструмент исследования устойчивости линейных систем.
Метод Якоби приводит симметричную действительную матрицу к диагональной форме с помощью некоторой (в принципе, бесконечной) последовательности плоских вращений в разных плоскостях исходного 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> сложений и умножений.

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

[[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:30:22Z

Зиновьев Владимир: /* Математическое описание алгоритма */

{{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> сложений и умножений.

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

[[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:26:24Z

Зиновьев Владимир: /* Существующие реализации алгоритма */

{{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>. Таким образом, <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> сложений и умножений.

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

[[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:23: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>
}}

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

=== Общее описание алгоритма ===
Задача нахождения собственных значений и собственных векторов матриц(СЗВМ) является одной из основных задач для многих разделов физики. С такой вычислительной проблемой приходится сталкиваться, например, при исследовании собственных колебаний различных механических систем, колебательных и электронных спектров молекул и кристаллов. Совершенно принципиальное значение эта проблема приобрела после создания в тридцатых годах прошлого века квантовой механики, которая стала базовой дисциплиной исследования микромира.Кроме того, данная проблема важна в теории автоматического управления, как инструмент исследования устойчивости линейных систем.
Метод Якоби приводит симметричную действительную матрицу к диагональной форме с помощью некоторой (в принципе, бесконечной) последовательности плоских вращений в разных плоскостях исходного 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>. Таким образом, <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> сложений и умножений.

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

[[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 приводится аннотация статьи 2012 года, в которой авторы описывают реализацию данного алгоритма на CUDA(Здесь должна быть ссылка).

3)

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

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

2016-10-15T00:19: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>
}}

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

=== Общее описание алгоритма ===
Задача нахождения собственных значений и собственных векторов матриц(СЗВМ) является одной из основных задач для многих разделов физики. С такой вычислительной проблемой приходится сталкиваться, например, при исследовании собственных колебаний различных механических систем, колебательных и электронных спектров молекул и кристаллов. Совершенно принципиальное значение эта проблема приобрела после создания в тридцатых годах прошлого века квантовой механики, которая стала базовой дисциплиной исследования микромира.Кроме того, данная проблема важна в теории автоматического управления, как инструмент исследования устойчивости линейных систем.
Метод Якоби приводит симметричную действительную матрицу к диагональной форме с помощью некоторой (в принципе, бесконечной) последовательности плоских вращений в разных плоскостях исходного 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>. Таким образом, <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> сложений и умножений.

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

[[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 приводится аннотация статьи 2012 года, в которой авторы описывают реализацию данного алгоритма на CUDA(Здесь должна быть ссылка).

3)

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

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

2016-10-15T00:17:05Z

Зиновьев Владимир: /* Математическое описание алгоритма */

{{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>. Таким образом, <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> сложений и умножений.

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

[[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)

2)В цифровой библиотеке ieee.org приводится аннотация статьи 2012 года, в которой авторы описывают реализацию данного алгоритма на CUDA(Здесь должна быть ссылка).

3)

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

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

2016-10-15T00:15:13Z

Зиновьев Владимир: /* Математическое описание алгоритма */

{{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>. Таким образом, <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 =
\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> сложений и умножений.

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

[[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)

2)В цифровой библиотеке ieee.org приводится аннотация статьи 2012 года, в которой авторы описывают реализацию данного алгоритма на CUDA(Здесь должна быть ссылка).

3)

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

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

2016-10-15T00:04:17Z

Зиновьев Владимир:

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

2016-10-14T23:57:54Z

Зиновьев Владимир: /* Симметричность и положительная определённость матрицы */

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

2016-10-14T23:57:17Z

Зиновьев Владимир: /* Информационный граф */

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

2016-10-14T23:56:13Z

Зиновьев Владимир: /* Информационный граф */

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

2016-10-14T23:45:46Z

Зиновьев Владимир: /* Ресурс параллелизма алгоритма */

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

2016-10-12T19:53:09Z

Зиновьев Владимир:

{{algorithm
| name = Метод Якоби вычисления собственных значений симметричной матрицы ЗП
| serial_complexity = <math></math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math></math>
| output_data = <math></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>. Таким образом, <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_i = R(j,k,\theta) \equiv \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>

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

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

=== Схема реализации последовательного алгоритма ===
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-12T19:52:11Z

Зиновьев Владимир:

{{algorithm
| name = Метод Якоби вычисления собственных значений симметричной матрицы ЗП
| serial_complexity = <math></math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math></math>
| output_data = <math></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>. Таким образом, <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_i = R(j,k,\theta) \equiv \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>

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

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

=== Схема реализации последовательного алгоритма ===
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-12T19:40:58Z

Зиновьев Владимир:

{{algorithm
| name = Метод Якоби вычисления собственных значений симметричной матрицы ЗП
| serial_complexity = <math></math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math></math>
| output_data = <math></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 остаются неизменными.

==== Симметричность и положительная определённость матрицы ====

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

=== Математическое описание алгоритма ===
Пусть <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>. Таким образом, <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_i = R(j,k,\theta) \equiv \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>

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

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

=== Схема реализации последовательного алгоритма ===
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-12T18:43:45Z

Зиновьев Владимир:

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

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

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

==== Симметричность и положительная определённость матрицы ====

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

=== Математическое описание алгоритма ===
Пусть <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>. Таким образом, <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_i = R(j,k,\theta) \equiv \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>

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

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

=== Схема реализации последовательного алгоритма ===
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>.

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

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

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

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

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

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

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

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

2016-10-12T18:42:57Z

Зиновьев Владимир: /* Перенос */

== Перенос ==

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

2016-10-12T18:36:57Z

Зиновьев Владимир:

{{algorithm
| name = Разложение Холецкого
| serial_complexity = <math></math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math></math>
| output_data = <math></math>
}}

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

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

==== Симметричность и положительная определённость матрицы ====

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

=== Математическое описание алгоритма ===
Пусть <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>. Таким образом, <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_i = R(j,k,\theta) \equiv \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>

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

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

=== Схема реализации последовательного алгоритма ===
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-12T18:24:22Z

Зиновьев Владимир: /* Общее описание алгоритма */

{{algorithm
| name = Разложение Холецкого
| serial_complexity = <math></math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math></math>
| output_data = <math></math>
}}

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

=== Общее описание алгоритма ===
Задача нахождения собственных значений и собственных векторов матриц(СЗВМ) является одной из основных задач для многих разделов физики. С такой вычислительной проблемой приходится сталкиваться, например, при исследовании собственных колебаний различных механических систем, колебательных и электронных спектров молекул и кристаллов. Совершенно принципиальное значение эта проблема приобрела после создания в тридцатых годах прошлого века квантовой механики, которая стала базовой дисциплиной исследования микромира. Действительно, согласно одному из основных положений квантовой механики, все наблюдаемые величины (т.е. величины, которые могут быть измерены в результате проведения конкретных физических экспериментов) суть собственные значения некоторых бесконечномерных эрмитовых матриц (эрмитовых операторов).
Метод Якоби приводит симметричную действительную матрицу к диагональной форме с помощью некоторой (в принципе, бесконечной) последовательности плоских вращений в разных плоскостях исходного n-мерного векторного пространства. Метод Якоби состоит из некоторой последовательности шагов, на каждом из которых зануляется один из недиагональных элементов (обычно наибольший по модулю), в результате чего старая матрица <math>A_{i-1}</math> преобразуется в некоторую новую матрицу <math>A_{i-1}</math>. Делается это с помощью преобразования подобия, использующего матрицу плоского вращения Ui0j0, которая изменяет лишь две координаты n-мерных векторов, а именно, координаты с номерами i0 и j0. При таком шаге матрица Aнов отличается от матрицы Aст лишь элементами двух строк с номерами i0, j0 и двух столбцов с

==== Симметричность и положительная определённость матрицы ====

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

=== Математическое описание алгоритма ===
Пусть <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>. Таким образом, <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_i = R(j,k,\theta) \equiv \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>

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

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

=== Схема реализации последовательного алгоритма ===
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-12T17:34:53Z

Зиновьев Владимир: Новая страница: «Студент группы 618/2 ВМК МГУ.»

Студент группы 618/2 ВМК МГУ.

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

2016-10-11T21:24:37Z

Зиновьев Владимир: /* Математическое описание алгоритма */

{{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>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>. Таким образом, <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_i = R(j,k,\theta) \equiv \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>

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

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

=== Схема реализации последовательного алгоритма ===
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-11T21:22:30Z

Зиновьев Владимир: /* Математическое описание алгоритма */

{{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>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>. Таким образом, <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_i = R(j,k,\theta) \equiv \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>

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

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

=== Схема реализации последовательного алгоритма ===
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-11T17:20:58Z

Зиновьев Владимир: /* Математическое описание алгоритма */

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

2016-10-10T20:15:08Z

Зиновьев Владимир: /* Математическое описание алгоритма */