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

Обсуждение участницы:Tameeva.a

2016-12-19T15:45:00Z

Tameeva.a: /* По существу (возможны добавления по вычитывании) */

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

=== По существу (возможны добавления по вычитывании) ===

* Если <math>a_{jj}-a_{kk} = 0</math>? --[[Участник:Frolov|Фролов А.В.]] ([[Обсуждение участника:Frolov|обсуждение]]) 16:43, 8 ноября 2016 (MSK)
** Тогда <math>c=1, s=0 \Rightarrow a_{jl}, a_{kl}, a_{jj}, a_{kk}</math> не изменяются на этой итерации. Имеет смысл поставить проверку, чтобы сразу переходить к следующей итерации.
*** В корне неверно. --[[Участник:Frolov|Фролов А.В.]] ([[Обсуждение участника:Frolov|обсуждение]]) 17:22, 17 декабря 2016 (MSK)
**** Для <math>a_{jj}=a_{kk} \qquad \theta=\dfrac{\pi}{4}</math>, <math>s=c=\dfrac{\sqrt{2}}{2}</math>. Внесены изменения в статью для этого случая. [[Участник:Tameeva.a|Tameeva.a]] ([[Обсуждение участника:Tameeva.a|обсуждение]]) 18:44, 19 декабря 2016 (MSK)
* Более существенно - нельзя ли использовать какие-то свойства и частично получить параллелизм между итерациями? --[[Участник:Frolov|Фролов А.В.]] ([[Обсуждение участника:Frolov|обсуждение]]) 17:09, 8 ноября 2016 (MSK)

=== Отсутствующие части ===
* Не указан вклад каждого из авторов статьи. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 11:21, 25 октября 2016 (MSK)
**Исправлено. [[Участник:Tameeva.a|Tameeva.a]] ([[Обсуждение участника:Tameeva.a|обсуждение]]) 20:40, 7 ноября 2016 (MSK)
* Отсутствуют заголовки пунктов 2.2-2.6, соответственно пункт 2.1 должен иметь нумерацию 2.4, а пункт 2.2 должен иметь нумерацию 2.7. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 11:21, 25 октября 2016 (MSK)
**Исправлено. [[Участник:Tameeva.a|Tameeva.a]] ([[Обсуждение участника:Tameeva.a|обсуждение]]) 20:40, 7 ноября 2016 (MSK)

=== Замечания по тексту ===
* Представленное на рис.1 не является графом алгоритма: по определению в нём не должно быть управляющих вершин, также не вполне понятны вершины с данными; непонятны также разноцветные дуги. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 11:21, 25 октября 2016 (MSK)
** Граф на рис.1 является малопонятным - структура вычислений не показана и спрятана в макровершинах, зелёные макровершины почему-то имеют то один вход, то два, а то три - они каждый раз соответствуют разным вычислениям? И почему на рисунке 3 оси, хотя граф выглядит совершенно двумерным? Чему вообще соответствуют эти оси? [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 10:32, 1 ноября 2016 (MSK)

# Граф упрощен до версии без управляющих вершин и входных и выходных данных.
# Дуги окрашены в цвет вершин, из которых выходят (при изображении графа руководствовались [https://algowiki-project.org/ru/Стандарт_визуализации_ГА стандартом визуализации ГА]: "Цвет любой дуги графа рекомендуется задавать в соответствии с цветом вершины операции, из которой выходит эта дуга.")
# Добавлены рис. 2–4 с внутренней структурой макровершин.
# Различное количество входов имеют зеленые вершины различных типов (с вычислением <math>A_{jj, kk}</math> и с вычислением <math>A_{jl,kl}</math>). Также на второй и последующих итерациях используются только предыдущие вычисления, а на первой могут использоваться и входные значения, не обозначенные на графе. В описании графа отображена разница входных и выходных данных каждой вершины для первой и последующих итераций.
# Ось Х – выполнение операций внутри каждой итерации, ось Y – итерации. Ось Z введена (возможно, несколько искусственно) для отражения параллельности вычисления зеленых вершин. Таким образом, каждая группа вершин одной итерации расположена в плоскости, параллельной OXZ. Возможные исправления: отобразить эти плоскости для каждой итерации (например, пунктиром) либо удалить ось Z.
[[Участник:Tameeva.a|Tameeva.a]] ([[Обсуждение участника:Tameeva.a|обсуждение]]) 23:54, 7 ноября 2016 (MSK)

* В разделе 1.8 все шаги имеют номер 1. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 10:32, 1 ноября 2016 (MSK)
**Исправлено. [[Участник:Tameeva.a|Tameeva.a]] ([[Обсуждение участника:Tameeva.a|обсуждение]]) 23:54, 7 ноября 2016 (MSK)

* Не заполнен раздел 2.4 описания. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:41, 16 ноября 2016 (MSK)
**Раздел добавлен [[Участник:Tameeva.a|Tameeva.a]] ([[Обсуждение участника:Tameeva.a|обсуждение]]) 12:19, 29 ноября 2016 (MSK)
* В разделе 2.4 не приведены все параметры запуска теста - какой компилятор, с какими опциями использовался, какие версии библиотек, на каких узлах проводился запуск и т.д. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 11:05, 30 ноября 2016 (MSK)

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

2016-12-19T15:39:31Z

Tameeva.a:

{{Assignment|ASA}}

{{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>\frac{n (n + 1)}{2}</math>
| output_data = <math>n</math>
}}

Основные авторы описания: [[Участник:Tameeva.a|А. Тамеева]] (разделы [[#Общее описание алгоритма|1.1]], [[#Математическое описание алгоритма|1.2]], [[#Вычислительное ядро алгоритма|1.3]]), [[Участник:AKukhtinov|А. Кухтинов]] (разделы [[#Макроструктура алгоритма|1.4]], [[#Схема реализации последовательного алгоритма|1.5]], [[#Входные и выходные данные алгоритма|1.9]]). Вклад в остальные разделы считаем равным.

=ЧАСТЬ. Свойства и структура алгоритмов=
== Общее описание алгоритма ==

Метод Якоби вычисления собственных значений симметричной матрицы — итерационный алгоритм, названный в честь предложившего его для конкретной матрицы 7 × 7 в 1846 году Карла Густава Якоба Якоби<ref>Jacobi, C.G.J. (1846). «[http://resolver.sub.uni-goettingen.de/purl/?GDZPPN002144522 Über ein leichtes Verfahren, die in der Theorie der Säkularstörungen vorkommenden Gleichungen numerisch aufzulösen]» (German). Crelle's Journal 30: 51–94.</ref>. Исторически старейший метод для решения симметрической проблемы собственных значений получил широкое применение только в 1950-х годах с появлением компьютеров. Преимуществом метода является более точное вычисление малых собственных значений по сравнению с конкурирующими алгоритмами.

Суть алгоритма — приведение симметрической матрицы к диагональной с собственными значениями на диагонали путем вращения.

==Математическое описание алгоритма<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>==
Исходные данные: симметрическая матрица <math>A=\{a_{ij}\}</math>.

Вычисляемые данные: диагональная матрица <math>\Lambda=\{\lambda_{ii}\}</math>. Диагональные элементы <math>\Lambda</math> — собственные значения матрицы <math>A</math>, столбцы — приближенные собственные вектора матрицы <math>A</math>.

По заданной матрице <math>A=A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,\ldots, A_m</math>, сходящихся к <math>\Lambda</math>.

<math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math> J_i</math> — ортогональная матрица, называемая вращением Якоби.

Матрица <math>J_i</math> выбирается так, чтобы обнулить элементы <math>(j,k)</math> и <math>(k,j)</math> матрицы <math>A_{i+1}</math>:

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

<math>
\begin{align}
J_i = R(j,k,\theta) = \begin{matrix} \\ \\ \\ j \\ \\ k \\ \\ \\ \\ \end{matrix} \begin{bmatrix} & 1 & & & & & & & & \\ & & 1 & & & & & & & \\ & & & \ddots & & & & & & \\ & & & & \cos(\theta) & & -\sin(\theta) & & & \\ & & & & & \ddots & & & & \\ & & & & \sin(\theta) & & \cos(\theta) & & & \\ & & & & & & & \ddots & & \\ & & & & & & & & 1 & \\ & & & & & & & & & 1 \\ \end{bmatrix}
\end{align}
</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>s = \sin \theta</math> и <math>c = \cos \theta</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>\dfrac{a_{jj}-a_{kk}}{2a_{jk}}=\dfrac{c^2-s^2}{2sc}=\dfrac{\cos2\theta}{\sin2\theta}=\operatorname{ctg}2\theta\equiv\tau</math>.

При <math>a_{jj}=a_{kk}</math>, <math>\theta=\dfrac{\pi}{4}</math>. Тогда <math>s=\dfrac{\sqrt{2}}{2}</math>, <math>c=\dfrac{\sqrt{2}}{2}</math>. В противном случае переходим к вычислениям <math>s, c</math>.

Положим <math>tg\theta=t=\dfrac{s}{c}</math>. Тогда <math>t^2+2t\tau-1=0</math>.

Решая квадратное уравнение, получим:
<math>t=\dfrac{\operatorname{sign}\tau}{\left|\tau\right|+\sqrt{1+\tau^2}}, c=\dfrac{1}{\sqrt{1+t^2}}, s=t\cdot c.</math>

==Вычислительное ядро алгоритма==
Вычислительное ядро алгоритма составляют вычисления элементов матрицы <math>A</math> в процессе применения матрицы поворота <math>J</math> :

1. Вычисления элементов <math>a_{jl}^{(i+1)} = a_{lj}^{(i+1)}</math> и <math>a_{kl}^{(i+1)} = a_{lk}^{(i+1)}</math> (каждое <math>(n-2)</math> раз):

<math>\begin{align}
a_{jl}^{(i+1)} = a_{lj}^{(i+1)} = c \, a_{jl}^{(i)} - s \, a_{kl}^{(i)}, l \ne j,k;\\
a_{kl}^{(i+1)} = a_{lk}^{(i+1)} = s \, a_{jl}^{(i)} + c \, a_{kl}^{(i)}, l \ne j,k.
\end{align}</math>

2. Вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>:

<math>\begin{align}
a_{jj}^{(i+1)} &= c^2\, a_{jj}^{(i)} - 2\, s c \,a_{jk}^{(i)} + s^2\, a_{kk}^{(i)}; \\
a_{kk}^{(i+1)} &= s^2 \,a_{jj}^{(i)} + 2 s c\, a_{jk}^{(i)} + c^2 \, a_{kk}^{(i)}.
\end{align}</math>

== Макроструктура алгоритма ==
Макроструктуру алгоритма можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246, алгоритм 5.6)</ref>:

repeat
выбрать пару индексов j, k
обратиться к процедуре JacobiRotation(A,j,k)
пока А не станет достаточно близка к диагональной матрице

==Схема реализации последовательного алгоритма==
В классическом алгоритме Якоби для обнуления на текущей итерации выбирался наибольший элемент <math>a_{jk}</math>. Поиск наибольшего элемента слишком замедляет процесс вычислений (нужно провести поиск среди <math>\dfrac{n^2-n}{2}</math> элементов, прежде чем выполнить вращение стоимостью в <math>O(n)</math> флопов), поэтому для практических вычислений выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

Таким образом, алгоритм можно описать так<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 247, алгоритм 5.8)</ref>:

repeat
for j=1 to n-1
for k=j+1 to n
выполнить процедуру '''''JacobiRotation'''(A, j, k)''
end for
end for
пока A не достаточно близка к диагональной матрице

Процедура '''''JacobiRotation'''(A, j, k)'':

if <math>|a_{jk}|</math> не слишком мал
if <math>a_{jj}=a_{jk}</math>
<math>\theta=\dfrac{\pi}{4}</math>
end if
else
<math>\begin{align}
\tau &= \frac{a_{jj}-a_{kk}}{2\,a_{jk}} \\
t &= \frac{sign(\tau)}{|\tau|+\sqrt{1+\tau^2}} \\
c &= \frac{1}{\sqrt{1+t^2}} \\
s &= c\cdot t
\end{align}</math>
end else
<math>
A = J_i^T\cdot A\cdot J_i, \qquad
J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
</math>
end if
==Последовательная сложность алгоритма==
Для одной итерации вычислений собственных значений матрицы порядка <math>n</math> методом Якоби требуется:

Для вычислительного ядра:

*<math>4\,n+6</math> умножений,
*<math>2n</math> сложений.

Для остальной части алгоритма:

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

Умножения и сложения (вычитания) составляют основную часть алгоритма.

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

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

==Информационный граф==
Опишем граф алгоритма аналитически и в виде рисунка.

Граф алгоритма состоит из трёх групп вершин:

1. '''''Calculate c,s''''' — вычисление <math>c, s</math> согласно формулам в [[#Схема реализации последовательного алгоритма|схеме реализации последовательного алгоритма.]]

Аргументы функции:
*<math>a^{(i+1)}_{jj}, a^{(i+1)}_{kk}</math>:
** Первая итерация — элементы входных данных: диагональные элементы матрицы <math>A</math>;
** Последующие — результаты вычислений вершины второй группы.
* <math>a^{(i+1)}_{jk}</math>
** Первая итерация — элементы входных данных <math>a_{jk}</math>
** Последующие — результаты вычислений вершины третьей группы.

Результаты выполнения функции являются ''промежуточными данными'' алгоритма.

2. <math>A_{jj}, A_{kk}</math> — вычисление <math>a^{(i+1)}_{jj}, a^{(i+1)}_{kk}</math> согласно формулам в разделе [[#Вычислительное ядро алгоритма|Вычислительное ядро алгоритма]].

Аргументы функции:
* <math>c, s</math> — результаты вычислений вершины первой группы.
* <math>a^{(i)}_{jj}, a^{(i)}_{kk}</math>:
** Первая итерация — элементы входных данных <math>a_{jj}, a_{kk}</math>;
** Последующие — результаты вычислений вершины второй группы.
* <math>a^{(i)}_{jk}</math>:
** Первая итерация — элементы входных данных <math>a_{jk}</math>;
** Последующие — результаты вычислений вершины третьей группы.

Результат выполнения функции является ''выходным данным'' алгоритма.

3. <math>A_{jl}, A_{kl}</math> — вычисление <math>a^{(i+1)}_{jl},a^{(i+1)}_{kl},l\ne j,k</math> согласно формулам в разделе [[#Вычислительное ядро алгоритма|Вычислительное ядро алгоритма]].

Аргументы функции:
* <math>c, s</math> — результаты вычислений вершины первой группы.
* <math>a^{(i)}_{jl}, a^{(i)}_{kl}</math>:
** Первая итерация — элементы входных данных <math>a_{jl},l\ne j,k</math>;
** Последующие — результаты вычислений вершины третьей группы.

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

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

[[File:Jacobi.png|800px|thumb|center|Рисунок 1. Граф алгоритма без отображения входных и выходных данных. ]]

<center>
<div class="thumb">
<div class="thumbinner" style="width:800px">
<gallery widths=500px heights=750px>
File:calculate_cs_block.png|Рисунок 2. Структура вершины '''''Calculate c,s'''''.
</gallery>
<gallery widths=500px heights=500px>
File:Akk_block.png|Рисунок 3. Структура вершины <math>A_{jj}, A_{kk}</math> (вычисление <math>a_{jj}, a_{kk}</math>).
File:Ajl_block.png|Рисунок 4. Структура вершины <math>A_{jl}, A_{kl}</math> (вычисление <math>a_{jl},a_{kl},l\ne j,k</math>). Количество входных и выходных значений, а также количество операций на каждом уровне указано слева.
</gallery>
</div>
</div>
</center>
==Ресурс параллелизма алгоритма==

Каждая итерация алгоритма для матрицы порядка <math>n</math> заключается в последовательном выполнении следующих ярусов:

# Вычисление <math>c, s</math> (последовательно всего <math>4</math> умножений, <math>3</math> делений, <math>4</math> сложений (вычитаний), <math>2</math> операции извлечения квадратного корня, <math>1</math> операция сравнения, <math>1</math> операция взятия модуля)
# Поворот матрицы <math>A</math> с параллельным вычислением элементов матрицы <math>a_{jl, kl}^{(i+1)}</math>, (высота этой части яруса – 2 операции, ширина – <math>4(n-2)</math>) и элементов <math>a_{jj,kk}^{(i+1)}</math> (высота этой части яруса – 4 операции, ширина — 5).

Суммарное количество итераций зависит от входных данных и заданного значения погрешности <math>\epsilon</math>. Один цикл (полный проход по внедиагональным элементам) осуществляется за <math>N = \frac{n(n-1)}{2}</math> итераций.

Таким образом, при классификации по высоте ЯПФ метод Якоби относится к алгоритмам со сложностью <math>O(n^2)</math> , а при классификации по ширине ЯПФ — к алгоритмам со сложностью <math>O(n)</math>.

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

1. Плотная матрица <math>A=\{a_{ij}\}, A\in\R^{n\times n}</math>. Дополнительные ограничения:
* <math>A</math> — симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

2. Число двойной точности <math>\epsilon</math>, определяющее допустимый порядок малости внедиагональных элементов.

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

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

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

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

==Свойства алгоритма==
Из существующих алгоритмов вычисления собственных значений симметричной матрицы метод Якоби является самым медленным (в среднем для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 248)</ref>). Его преимущество заключается в том, что он не предполагает первоначального приведения матрицы к трехдиагональной форме. Также метод до сих пор используется на практике для вычисления малых собственных чисел и отвечающих им собственных векторов, так как он делает это с гораздо большей точностью, чем другие методы<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244)</ref>.

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

Метод Якоби не детерминирован, так как является итерационным алгоритмом с выходом по точности: число итераций зависит от входных данных и порогового значения.

=ЧАСТЬ. Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
Исследование проводилось на суперкомпьютере "Ломоносов" Суперкомпьютерного комплекса Московского университета.
Использовался компилятор gcc версии 5.2 c флагами -fopenmp и -std=c++0x.

Набор и границы значений изменяемых параметров запуска реализации алгоритма:
*число процессоров [1 : 48] с шагом 4;
*размер матрицы [500 : 1500].

[[File:res1.png|800px|thumb|center|Рисунок 5. Зависимость времени выполнения алгоритма от размера матриц и количества процессоров.]]

Из рис. 6 видно, что при 20-24 процессорах производительность максимальная.
[[File:2d.png|800px|thumb|center|Рисунок 6. Зависимость времени выполнения алгоритма от количества процессоров для фиксированного размера матрицы 500*500.]]

[http://pastebin.com/edit/cSEYa6ih Реализация на C++ с использованием технологии OpenMP.]

==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
Библиотека [https://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE] содержит последовательную реализацию алгоритма.

Существует также [http://ieeexplore.ieee.org/document/6310877/ параллельная реализация] метода на платформе CUDA.

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

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

2016-11-30T15:59:38Z

Tameeva.a:

{{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>\frac{n (n + 1)}{2}</math>
| output_data = <math>n</math>
}}

Основные авторы описания: [[Участник:Tameeva.a|А. Тамеева]] (разделы [[#Общее описание алгоритма|1.1]], [[#Математическое описание алгоритма|1.2]], [[#Вычислительное ядро алгоритма|1.3]]), [[Участник:AKukhtinov|А. Кухтинов]] (разделы [[#Макроструктура алгоритма|1.4]], [[#Схема реализации последовательного алгоритма|1.5]], [[#Входные и выходные данные алгоритма|1.9]]). Вклад в остальные разделы считаем равным.

=ЧАСТЬ. Свойства и структура алгоритмов=
== Общее описание алгоритма ==

Метод Якоби вычисления собственных значений симметричной матрицы — итерационный алгоритм, названный в честь предложившего его для конкретной матрицы 7 × 7 в 1846 году Карла Густава Якоба Якоби<ref>Jacobi, C.G.J. (1846). «[http://resolver.sub.uni-goettingen.de/purl/?GDZPPN002144522 Über ein leichtes Verfahren, die in der Theorie der Säkularstörungen vorkommenden Gleichungen numerisch aufzulösen]» (German). Crelle's Journal 30: 51–94.</ref>. Исторически старейший метод для решения симметрической проблемы собственных значений получил широкое применение только в 1950-х годах с появлением компьютеров. Преимуществом метода является более точное вычисление малых собственных значений по сравнению с конкурирующими алгоритмами.

Суть алгоритма — приведение симметрической матрицы к диагональной с собственными значениями на диагонали путем вращения.

==Математическое описание алгоритма<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>==
Исходные данные: симметрическая матрица <math>A=\{a_{ij}\}</math>.

Вычисляемые данные: диагональная матрица <math>\Lambda=\{\lambda_{ii}\}</math>. Диагональные элементы <math>\Lambda</math> — собственные значения матрицы <math>A</math>, столбцы — приближенные собственные вектора матрицы <math>A</math>.

По заданной матрице <math>A=A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,\ldots, A_m</math>, сходящихся к <math>\Lambda</math>.

<math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math> J_i</math> — ортогональная матрица, называемая вращением Якоби.

Матрица <math>J_i</math> выбирается так, чтобы обнулить элементы <math>(j,k)</math> и <math>(k,j)</math> матрицы <math>A_{i+1}</math>:

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

<math>
\begin{align}
J_i = R(j,k,\theta) = \begin{matrix} \\ \\ \\ j \\ \\ k \\ \\ \\ \\ \end{matrix} \begin{bmatrix} & 1 & & & & & & & & \\ & & 1 & & & & & & & \\ & & & \ddots & & & & & & \\ & & & & \cos(\theta) & & -\sin(\theta) & & & \\ & & & & & \ddots & & & & \\ & & & & \sin(\theta) & & \cos(\theta) & & & \\ & & & & & & & \ddots & & \\ & & & & & & & & 1 & \\ & & & & & & & & & 1 \\ \end{bmatrix}
\end{align}
</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>s = \sin \theta</math> и <math>c = \cos \theta</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>\dfrac{a_{jj}-a_{kk}}{2a_{jk}}=\dfrac{c^2-s^2}{2sc}=\dfrac{\cos2\theta}{\sin2\theta}=\operatorname{ctg}2\theta\equiv\tau</math>

Положим <math>tg\theta=t=\dfrac{s}{c}</math>. Тогда <math>t^2+2t\tau-1=0</math>.

Решая квадратное уравнение, получим:
<math>t=\dfrac{\operatorname{sign}\tau}{\left|\tau\right|+\sqrt{1+\tau^2}}, c=\dfrac{1}{\sqrt{1+t^2}}, s=t\cdot c.</math>

==Вычислительное ядро алгоритма==
Вычислительное ядро алгоритма составляют вычисления элементов матрицы <math>A</math> в процессе применения матрицы поворота <math>J</math> :

1. Вычисления элементов <math>a_{jl}^{(i+1)} = a_{lj}^{(i+1)}</math> и <math>a_{kl}^{(i+1)} = a_{lk}^{(i+1)}</math> (каждое <math>(n-2)</math> раз):

<math>\begin{align}
a_{jl}^{(i+1)} = a_{lj}^{(i+1)} = c \, a_{jl}^{(i)} - s \, a_{kl}^{(i)}, l \ne j,k;\\
a_{kl}^{(i+1)} = a_{lk}^{(i+1)} = s \, a_{jl}^{(i)} + c \, a_{kl}^{(i)}, l \ne j,k.
\end{align}</math>

2. Вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>:

<math>\begin{align}
a_{jj}^{(i+1)} &= c^2\, a_{jj}^{(i)} - 2\, s c \,a_{jk}^{(i)} + s^2\, a_{kk}^{(i)}; \\
a_{kk}^{(i+1)} &= s^2 \,a_{jj}^{(i)} + 2 s c\, a_{jk}^{(i)} + c^2 \, a_{kk}^{(i)}.
\end{align}</math>

== Макроструктура алгоритма ==
Макроструктуру алгоритма можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246, алгоритм 5.6)</ref>:

repeat
выбрать пару индексов j, k
обратиться к процедуре JacobiRotation(A,j,k)
пока А не станет достаточно близка к диагональной матрице

==Схема реализации последовательного алгоритма==
В классическом алгоритме Якоби для обнуления на текущей итерации выбирался наибольший элемент <math>a_{jk}</math>. Поиск наибольшего элемента слишком замедляет процесс вычислений (нужно провести поиск среди <math>\dfrac{n^2-n}{2}</math> элементов, прежде чем выполнить вращение стоимостью в <math>O(n)</math> флопов), поэтому для практических вычислений выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

Таким образом, алгоритм можно описать так<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 247, алгоритм 5.8)</ref>:

repeat
for j=1 to n-1
for k=j+1 to n
выполнить процедуру '''''JacobiRotation'''(A, j, k)''
end for
end for
пока A не достаточно близка к диагональной матрице

Процедура '''''JacobiRotation'''(A, j, k)'':

if <math>|a_{jk}|</math> не слишком мал
<math>\begin{align}
\tau &= \frac{a_{jj}-a_{kk}}{2\,a_{jk}} \\
t &= \frac{sign(\tau)}{|\tau|+\sqrt{1+\tau^2}} \\
c &= \frac{1}{\sqrt{1+t^2}} \\
s &= c\cdot t \\
A &= J_i^T\cdot A\cdot J_i, \qquad
J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}
</math>
end if
==Последовательная сложность алгоритма==
Для одной итерации вычислений собственных значений матрицы порядка <math>n</math> методом Якоби требуется:

Для вычислительного ядра:

*<math>4\,n+6</math> умножений,
*<math>2n</math> сложений.

Для остальной части алгоритма:

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

Умножения и сложения (вычитания) составляют основную часть алгоритма.

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

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

==Информационный граф==
Опишем граф алгоритма аналитически и в виде рисунка.

Граф алгоритма состоит из трёх групп вершин:

1. '''''Calculate c,s''''' — вычисление <math>c, s</math> согласно формулам в [[#Схема реализации последовательного алгоритма|схеме реализации последовательного алгоритма.]]

Аргументы функции:
*<math>a^{(i+1)}_{jj}, a^{(i+1)}_{kk}</math>:
** Первая итерация — элементы входных данных: диагональные элементы матрицы <math>A</math>;
** Последующие — результаты вычислений вершины второй группы.
* <math>a^{(i+1)}_{jk}</math>
** Первая итерация — элементы входных данных <math>a_{jk}</math>
** Последующие — результаты вычислений вершины третьей группы.

Результаты выполнения функции являются ''промежуточными данными'' алгоритма.

2. <math>A_{jj}, A_{kk}</math> — вычисление <math>a^{(i+1)}_{jj}, a^{(i+1)}_{kk}</math> согласно формулам в разделе [[#Вычислительное ядро алгоритма|Вычислительное ядро алгоритма]].

Аргументы функции:
* <math>c, s</math> — результаты вычислений вершины первой группы.
* <math>a^{(i)}_{jj}, a^{(i)}_{kk}</math>:
** Первая итерация — элементы входных данных <math>a_{jj}, a_{kk}</math>;
** Последующие — результаты вычислений вершины второй группы.
* <math>a^{(i)}_{jk}</math>:
** Первая итерация — элементы входных данных <math>a_{jk}</math>;
** Последующие — результаты вычислений вершины третьей группы.

Результат выполнения функции является ''выходным данным'' алгоритма.

3. <math>A_{jl}, A_{kl}</math> — вычисление <math>a^{(i+1)}_{jl},a^{(i+1)}_{kl},l\ne j,k</math> согласно формулам в разделе [[#Вычислительное ядро алгоритма|Вычислительное ядро алгоритма]].

Аргументы функции:
* <math>c, s</math> — результаты вычислений вершины первой группы.
* <math>a^{(i)}_{jl}, a^{(i)}_{kl}</math>:
** Первая итерация — элементы входных данных <math>a_{jl},l\ne j,k</math>;
** Последующие — результаты вычислений вершины третьей группы.

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

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

[[File:Jacobi.png|800px|thumb|center|Рисунок 1. Граф алгоритма без отображения входных и выходных данных. ]]

<center>
<div class="thumb">
<div class="thumbinner" style="width:800px">
<gallery widths=500px heights=750px>
File:calculate_cs_block.png|Рисунок 2. Структура вершины '''''Calculate c,s'''''.
</gallery>
<gallery widths=500px heights=500px>
File:Akk_block.png|Рисунок 3. Структура вершины <math>A_{jj}, A_{kk}</math> (вычисление <math>a_{jj}, a_{kk}</math>).
File:Ajl_block.png|Рисунок 4. Структура вершины <math>A_{jl}, A_{kl}</math> (вычисление <math>a_{jl},a_{kl},l\ne j,k</math>). Количество входных и выходных значений, а также количество операций на каждом уровне указано слева.
</gallery>
</div>
</div>
</center>
==Ресурс параллелизма алгоритма==

Каждая итерация алгоритма для матрицы порядка <math>n</math> заключается в последовательном выполнении следующих ярусов:

# Вычисление <math>c, s</math> (последовательно всего <math>4</math> умножений, <math>3</math> делений, <math>4</math> сложений (вычитаний), <math>2</math> операции извлечения квадратного корня, <math>1</math> операция сравнения, <math>1</math> операция взятия модуля)
# Поворот матрицы <math>A</math> с параллельным вычислением элементов матрицы <math>a_{jl, kl}^{(i+1)}</math>, (высота этой части яруса – 2 операции, ширина – <math>4(n-2)</math>) и элементов <math>a_{jj,kk}^{(i+1)}</math> (высота этой части яруса – 4 операции, ширина — 5).

Суммарное количество итераций зависит от входных данных и заданного значения погрешности <math>\epsilon</math>. Один цикл (полный проход по внедиагональным элементам) осуществляется за <math>N = \frac{n(n-1)}{2}</math> итераций.

Таким образом, при классификации по высоте ЯПФ метод Якоби относится к алгоритмам со сложностью <math>O(n^2)</math> , а при классификации по ширине ЯПФ — к алгоритмам со сложностью <math>O(n)</math>.

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

1. Плотная матрица <math>A=\{a_{ij}\}, A\in\R^{n\times n}</math>. Дополнительные ограничения:
* <math>A</math> — симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

2. Число двойной точности <math>\epsilon</math>, определяющее допустимый порядок малости внедиагональных элементов.

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

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

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

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

==Свойства алгоритма==
Из существующих алгоритмов вычисления собственных значений симметричной матрицы метод Якоби является самым медленным (в среднем для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 248)</ref>). Его преимущество заключается в том, что он не предполагает первоначального приведения матрицы к трехдиагональной форме. Также метод до сих пор используется на практике для вычисления малых собственных чисел и отвечающих им собственных векторов, так как он делает это с гораздо большей точностью, чем другие методы<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244)</ref>.

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

Метод Якоби не детерминирован, так как является итерационным алгоритмом с выходом по точности: число итераций зависит от входных данных и порогового значения.

=ЧАСТЬ. Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
Исследование проводилось на суперкомпьютере "Ломоносов" Суперкомпьютерного комплекса Московского университета.
Использовался компилятор gcc версии 5.2 c флагами -fopenmp и -std=c++0x.

Набор и границы значений изменяемых параметров запуска реализации алгоритма:
*число процессоров [1 : 48] с шагом 4;
*размер матрицы [500 : 1500].

[[File:res1.png|800px|thumb|center|Рисунок 5. Зависимость времени выполнения алгоритма от размера матриц и количества процессоров.]]

Из рис. 6 видно, что при 20-24 процессорах производительность максимальная.
[[File:2d.png|800px|thumb|center|Рисунок 6. Зависимость времени выполнения алгоритма от количества процессоров для фиксированного размера матрицы 500*500.]]

[http://pastebin.com/edit/cSEYa6ih Реализация на C++ с использованием технологии OpenMP.]

==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
Библиотека [https://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE] содержит последовательную реализацию алгоритма.

Существует также [http://ieeexplore.ieee.org/document/6310877/ параллельная реализация] метода на платформе CUDA.

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

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

2016-11-30T15:57:50Z

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

{{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>\frac{n (n + 1)}{2}</math>
| output_data = <math>n</math>
}}

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

=ЧАСТЬ. Свойства и структура алгоритмов=
== Общее описание алгоритма ==

Метод Якоби вычисления собственных значений симметричной матрицы — итерационный алгоритм, названный в честь предложившего его для конкретной матрицы 7 × 7 в 1846 году Карла Густава Якоба Якоби<ref>Jacobi, C.G.J. (1846). «[http://resolver.sub.uni-goettingen.de/purl/?GDZPPN002144522 Über ein leichtes Verfahren, die in der Theorie der Säkularstörungen vorkommenden Gleichungen numerisch aufzulösen]» (German). Crelle's Journal 30: 51–94.</ref>. Исторически старейший метод для решения симметрической проблемы собственных значений получил широкое применение только в 1950-х годах с появлением компьютеров. Преимуществом метода является более точное вычисление малых собственных значений по сравнению с конкурирующими алгоритмами.

Суть алгоритма — приведение симметрической матрицы к диагональной с собственными значениями на диагонали путем вращения.

==Математическое описание алгоритма<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>==
Исходные данные: симметрическая матрица <math>A=\{a_{ij}\}</math>.

Вычисляемые данные: диагональная матрица <math>\Lambda=\{\lambda_{ii}\}</math>. Диагональные элементы <math>\Lambda</math> — собственные значения матрицы <math>A</math>, столбцы — приближенные собственные вектора матрицы <math>A</math>.

По заданной матрице <math>A=A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,\ldots, A_m</math>, сходящихся к <math>\Lambda</math>.

<math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math> J_i</math> — ортогональная матрица, называемая вращением Якоби.

Матрица <math>J_i</math> выбирается так, чтобы обнулить элементы <math>(j,k)</math> и <math>(k,j)</math> матрицы <math>A_{i+1}</math>:

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

<math>
\begin{align}
J_i = R(j,k,\theta) = \begin{matrix} \\ \\ \\ j \\ \\ k \\ \\ \\ \\ \end{matrix} \begin{bmatrix} & 1 & & & & & & & & \\ & & 1 & & & & & & & \\ & & & \ddots & & & & & & \\ & & & & \cos(\theta) & & -\sin(\theta) & & & \\ & & & & & \ddots & & & & \\ & & & & \sin(\theta) & & \cos(\theta) & & & \\ & & & & & & & \ddots & & \\ & & & & & & & & 1 & \\ & & & & & & & & & 1 \\ \end{bmatrix}
\end{align}
</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>s = \sin \theta</math> и <math>c = \cos \theta</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>\dfrac{a_{jj}-a_{kk}}{2a_{jk}}=\dfrac{c^2-s^2}{2sc}=\dfrac{\cos2\theta}{\sin2\theta}=\operatorname{ctg}2\theta\equiv\tau</math>

Положим <math>tg\theta=t=\dfrac{s}{c}</math>. Тогда <math>t^2+2t\tau-1=0</math>.

Решая квадратное уравнение, получим:
<math>t=\dfrac{\operatorname{sign}\tau}{\left|\tau\right|+\sqrt{1+\tau^2}}, c=\dfrac{1}{\sqrt{1+t^2}}, s=t\cdot c.</math>

==Вычислительное ядро алгоритма==
Вычислительное ядро алгоритма составляют вычисления элементов матрицы <math>A</math> в процессе применения матрицы поворота <math>J</math> :

1. Вычисления элементов <math>a_{jl}^{(i+1)} = a_{lj}^{(i+1)}</math> и <math>a_{kl}^{(i+1)} = a_{lk}^{(i+1)}</math> (каждое <math>(n-2)</math> раз):

<math>\begin{align}
a_{jl}^{(i+1)} = a_{lj}^{(i+1)} = c \, a_{jl}^{(i)} - s \, a_{kl}^{(i)}, l \ne j,k;\\
a_{kl}^{(i+1)} = a_{lk}^{(i+1)} = s \, a_{jl}^{(i)} + c \, a_{kl}^{(i)}, l \ne j,k.
\end{align}</math>

2. Вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>:

<math>\begin{align}
a_{jj}^{(i+1)} &= c^2\, a_{jj}^{(i)} - 2\, s c \,a_{jk}^{(i)} + s^2\, a_{kk}^{(i)}; \\
a_{kk}^{(i+1)} &= s^2 \,a_{jj}^{(i)} + 2 s c\, a_{jk}^{(i)} + c^2 \, a_{kk}^{(i)}.
\end{align}</math>

== Макроструктура алгоритма ==
Макроструктуру алгоритма можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246, алгоритм 5.6)</ref>:

repeat
выбрать пару индексов j, k
обратиться к процедуре JacobiRotation(A,j,k)
пока А не станет достаточно близка к диагональной матрице

==Схема реализации последовательного алгоритма==
В классическом алгоритме Якоби для обнуления на текущей итерации выбирался наибольший элемент <math>a_{jk}</math>. Поиск наибольшего элемента слишком замедляет процесс вычислений (нужно провести поиск среди <math>\dfrac{n^2-n}{2}</math> элементов, прежде чем выполнить вращение стоимостью в <math>O(n)</math> флопов), поэтому для практических вычислений выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

Таким образом, алгоритм можно описать так<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 247, алгоритм 5.8)</ref>:

repeat
for j=1 to n-1
for k=j+1 to n
выполнить процедуру '''''JacobiRotation'''(A, j, k)''
end for
end for
пока A не достаточно близка к диагональной матрице

Процедура '''''JacobiRotation'''(A, j, k)'':

if <math>|a_{jk}|</math> не слишком мал
<math>\begin{align}
\tau &= \frac{a_{jj}-a_{kk}}{2\,a_{jk}} \\
t &= \frac{sign(\tau)}{|\tau|+\sqrt{1+\tau^2}} \\
c &= \frac{1}{\sqrt{1+t^2}} \\
s &= c\cdot t \\
A &= J_i^T\cdot A\cdot J_i, \qquad
J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}
</math>
end if
==Последовательная сложность алгоритма==
Для одной итерации вычислений собственных значений матрицы порядка <math>n</math> методом Якоби требуется:

Для вычислительного ядра:

*<math>4\,n+6</math> умножений,
*<math>2n</math> сложений.

Для остальной части алгоритма:

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

Умножения и сложения (вычитания) составляют основную часть алгоритма.

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

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

==Информационный граф==
Опишем граф алгоритма аналитически и в виде рисунка.

Граф алгоритма состоит из трёх групп вершин:

1. '''''Calculate c,s''''' — вычисление <math>c, s</math> согласно формулам в [[#Схема реализации последовательного алгоритма|схеме реализации последовательного алгоритма.]]

Аргументы функции:
*<math>a^{(i+1)}_{jj}, a^{(i+1)}_{kk}</math>:
** Первая итерация — элементы входных данных: диагональные элементы матрицы <math>A</math>;
** Последующие — результаты вычислений вершины второй группы.
* <math>a^{(i+1)}_{jk}</math>
** Первая итерация — элементы входных данных <math>a_{jk}</math>
** Последующие — результаты вычислений вершины третьей группы.

Результаты выполнения функции являются ''промежуточными данными'' алгоритма.

2. <math>A_{jj}, A_{kk}</math> — вычисление <math>a^{(i+1)}_{jj}, a^{(i+1)}_{kk}</math> согласно формулам в разделе [[#Вычислительное ядро алгоритма|Вычислительное ядро алгоритма]].

Аргументы функции:
* <math>c, s</math> — результаты вычислений вершины первой группы.
* <math>a^{(i)}_{jj}, a^{(i)}_{kk}</math>:
** Первая итерация — элементы входных данных <math>a_{jj}, a_{kk}</math>;
** Последующие — результаты вычислений вершины второй группы.
* <math>a^{(i)}_{jk}</math>:
** Первая итерация — элементы входных данных <math>a_{jk}</math>;
** Последующие — результаты вычислений вершины третьей группы.

Результат выполнения функции является ''выходным данным'' алгоритма.

3. <math>A_{jl}, A_{kl}</math> — вычисление <math>a^{(i+1)}_{jl},a^{(i+1)}_{kl},l\ne j,k</math> согласно формулам в разделе [[#Вычислительное ядро алгоритма|Вычислительное ядро алгоритма]].

Аргументы функции:
* <math>c, s</math> — результаты вычислений вершины первой группы.
* <math>a^{(i)}_{jl}, a^{(i)}_{kl}</math>:
** Первая итерация — элементы входных данных <math>a_{jl},l\ne j,k</math>;
** Последующие — результаты вычислений вершины третьей группы.

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

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

[[File:Jacobi.png|800px|thumb|center|Рисунок 1. Граф алгоритма без отображения входных и выходных данных. ]]

<center>
<div class="thumb">
<div class="thumbinner" style="width:800px">
<gallery widths=500px heights=750px>
File:calculate_cs_block.png|Рисунок 2. Структура вершины '''''Calculate c,s'''''.
</gallery>
<gallery widths=500px heights=500px>
File:Akk_block.png|Рисунок 3. Структура вершины <math>A_{jj}, A_{kk}</math> (вычисление <math>a_{jj}, a_{kk}</math>).
File:Ajl_block.png|Рисунок 4. Структура вершины <math>A_{jl}, A_{kl}</math> (вычисление <math>a_{jl},a_{kl},l\ne j,k</math>). Количество входных и выходных значений, а также количество операций на каждом уровне указано слева.
</gallery>
</div>
</div>
</center>
==Ресурс параллелизма алгоритма==

Каждая итерация алгоритма для матрицы порядка <math>n</math> заключается в последовательном выполнении следующих ярусов:

# Вычисление <math>c, s</math> (последовательно всего <math>4</math> умножений, <math>3</math> делений, <math>4</math> сложений (вычитаний), <math>2</math> операции извлечения квадратного корня, <math>1</math> операция сравнения, <math>1</math> операция взятия модуля)
# Поворот матрицы <math>A</math> с параллельным вычислением элементов матрицы <math>a_{jl, kl}^{(i+1)}</math>, (высота этой части яруса – 2 операции, ширина – <math>4(n-2)</math>) и элементов <math>a_{jj,kk}^{(i+1)}</math> (высота этой части яруса – 4 операции, ширина — 5).

Суммарное количество итераций зависит от входных данных и заданного значения погрешности <math>\epsilon</math>. Один цикл (полный проход по внедиагональным элементам) осуществляется за <math>N = \frac{n(n-1)}{2}</math> итераций.

Таким образом, при классификации по высоте ЯПФ метод Якоби относится к алгоритмам со сложностью <math>O(n^2)</math> , а при классификации по ширине ЯПФ — к алгоритмам со сложностью <math>O(n)</math>.

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

1. Плотная матрица <math>A=\{a_{ij}\}, A\in\R^{n\times n}</math>. Дополнительные ограничения:
* <math>A</math> — симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

2. Число двойной точности <math>\epsilon</math>, определяющее допустимый порядок малости внедиагональных элементов.

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

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

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

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

==Свойства алгоритма==
Из существующих алгоритмов вычисления собственных значений симметричной матрицы метод Якоби является самым медленным (в среднем для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 248)</ref>). Его преимущество заключается в том, что он не предполагает первоначального приведения матрицы к трехдиагональной форме. Также метод до сих пор используется на практике для вычисления малых собственных чисел и отвечающих им собственных векторов, так как он делает это с гораздо большей точностью, чем другие методы<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244)</ref>.

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

Метод Якоби не детерминирован, так как является итерационным алгоритмом с выходом по точности: число итераций зависит от входных данных и порогового значения.

=ЧАСТЬ. Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
===Масштабируемость алгоритма===
===Масштабируемость реализации алгоритма===
Исследование проводилось на суперкомпьютере "Ломоносов" Суперкомпьютерного комплекса Московского университета.
Использовался компилятор gcc версии 5.2 c флагами -fopenmp и -std=c++0x.
Набор и границы значений изменяемых параметров запуска реализации алгоритма:
*число процессоров [1 : 48] с шагом 4;
*размер матрицы [500 : 1500].

[[File:res1.png|800px|thumb|center|Рисунок 5. Зависимость времени выполнения алгоритма от размера матриц и количества процессоров.]]

Из рис. 6 видно, что при 20-24 процессорах производительность максимальная.
[[File:2d.png|800px|thumb|center|Рисунок 6. Зависимость времени выполнения алгоритма от количества процессоров для фиксированного размера матрицы 500*500.]]

[http://pastebin.com/edit/cSEYa6ih Реализация на C++ с использованием технологии OpenMP.]

==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
Библиотека [https://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE] содержит последовательную реализацию алгоритма.

Существует также [http://ieeexplore.ieee.org/document/6310877/ параллельная реализация] метода на платформе CUDA.

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

Обсуждение участницы:Tameeva.a

2016-11-29T09:19:20Z

Tameeva.a: /* Замечания по тексту */

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

=== По существу (возможны добавления по вычитывании) ===

* Если <math>a_{jj}-a_{kk} = 0</math>? --[[Участник:Frolov|Фролов А.В.]] ([[Обсуждение участника:Frolov|обсуждение]]) 16:43, 8 ноября 2016 (MSK)
** Тогда <math>c=1, s=0 \Rightarrow a_{jl}, a_{kl}, a_{jj}, a_{kk}</math> не изменяются на этой итерации. Имеет смысл поставить проверку, чтобы сразу переходить к следующей итерации.
* Более существенно - нельзя ли использовать какие-то свойства и частично получить параллелизм между итерациями? --[[Участник:Frolov|Фролов А.В.]] ([[Обсуждение участника:Frolov|обсуждение]]) 17:09, 8 ноября 2016 (MSK)

=== Отсутствующие части ===
* Не указан вклад каждого из авторов статьи. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 11:21, 25 октября 2016 (MSK)
**Исправлено. [[Участник:Tameeva.a|Tameeva.a]] ([[Обсуждение участника:Tameeva.a|обсуждение]]) 20:40, 7 ноября 2016 (MSK)
* Отсутствуют заголовки пунктов 2.2-2.6, соответственно пункт 2.1 должен иметь нумерацию 2.4, а пункт 2.2 должен иметь нумерацию 2.7. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 11:21, 25 октября 2016 (MSK)
**Исправлено. [[Участник:Tameeva.a|Tameeva.a]] ([[Обсуждение участника:Tameeva.a|обсуждение]]) 20:40, 7 ноября 2016 (MSK)

=== Замечания по тексту ===
* Представленное на рис.1 не является графом алгоритма: по определению в нём не должно быть управляющих вершин, также не вполне понятны вершины с данными; непонятны также разноцветные дуги. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 11:21, 25 октября 2016 (MSK)
** Граф на рис.1 является малопонятным - структура вычислений не показана и спрятана в макровершинах, зелёные макровершины почему-то имеют то один вход, то два, а то три - они каждый раз соответствуют разным вычислениям? И почему на рисунке 3 оси, хотя граф выглядит совершенно двумерным? Чему вообще соответствуют эти оси? [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 10:32, 1 ноября 2016 (MSK)

# Граф упрощен до версии без управляющих вершин и входных и выходных данных.
# Дуги окрашены в цвет вершин, из которых выходят (при изображении графа руководствовались [https://algowiki-project.org/ru/Стандарт_визуализации_ГА стандартом визуализации ГА]: "Цвет любой дуги графа рекомендуется задавать в соответствии с цветом вершины операции, из которой выходит эта дуга.")
# Добавлены рис. 2–4 с внутренней структурой макровершин.
# Различное количество входов имеют зеленые вершины различных типов (с вычислением <math>A_{jj, kk}</math> и с вычислением <math>A_{jl,kl}</math>). Также на второй и последующих итерациях используются только предыдущие вычисления, а на первой могут использоваться и входные значения, не обозначенные на графе. В описании графа отображена разница входных и выходных данных каждой вершины для первой и последующих итераций.
# Ось Х – выполнение операций внутри каждой итерации, ось Y – итерации. Ось Z введена (возможно, несколько искусственно) для отражения параллельности вычисления зеленых вершин. Таким образом, каждая группа вершин одной итерации расположена в плоскости, параллельной OXZ. Возможные исправления: отобразить эти плоскости для каждой итерации (например, пунктиром) либо удалить ось Z.
[[Участник:Tameeva.a|Tameeva.a]] ([[Обсуждение участника:Tameeva.a|обсуждение]]) 23:54, 7 ноября 2016 (MSK)

* В разделе 1.8 все шаги имеют номер 1. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 10:32, 1 ноября 2016 (MSK)
**Исправлено. [[Участник:Tameeva.a|Tameeva.a]] ([[Обсуждение участника:Tameeva.a|обсуждение]]) 23:54, 7 ноября 2016 (MSK)

* Не заполнен раздел 2.4 описания. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:41, 16 ноября 2016 (MSK)
**Раздел добавлен [[Участник:Tameeva.a|Tameeva.a]] ([[Обсуждение участника:Tameeva.a|обсуждение]]) 12:19, 29 ноября 2016 (MSK)

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

2016-11-28T21:05:04Z

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

{{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>\frac{n (n + 1)}{2}</math>
| output_data = <math>n</math>
}}

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

=ЧАСТЬ. Свойства и структура алгоритмов=
== Общее описание алгоритма ==

Метод Якоби вычисления собственных значений симметричной матрицы — итерационный алгоритм, названный в честь предложившего его для конкретной матрицы 7 × 7 в 1846 году Карла Густава Якоба Якоби<ref>Jacobi, C.G.J. (1846). «[http://resolver.sub.uni-goettingen.de/purl/?GDZPPN002144522 Über ein leichtes Verfahren, die in der Theorie der Säkularstörungen vorkommenden Gleichungen numerisch aufzulösen]» (German). Crelle's Journal 30: 51–94.</ref>. Исторически старейший метод для решения симметрической проблемы собственных значений получил широкое применение только в 1950-х годах с появлением компьютеров. Преимуществом метода является более точное вычисление малых собственных значений по сравнению с конкурирующими алгоритмами.

Суть алгоритма — приведение симметрической матрицы к диагональной с собственными значениями на диагонали путем вращения.

==Математическое описание алгоритма<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>==
Исходные данные: симметрическая матрица <math>A=\{a_{ij}\}</math>.

Вычисляемые данные: диагональная матрица <math>\Lambda=\{\lambda_{ii}\}</math>. Диагональные элементы <math>\Lambda</math> — собственные значения матрицы <math>A</math>, столбцы — приближенные собственные вектора матрицы <math>A</math>.

По заданной матрице <math>A=A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,\ldots, A_m</math>, сходящихся к <math>\Lambda</math>.

<math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math> J_i</math> — ортогональная матрица, называемая вращением Якоби.

Матрица <math>J_i</math> выбирается так, чтобы обнулить элементы <math>(j,k)</math> и <math>(k,j)</math> матрицы <math>A_{i+1}</math>:

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

<math>
\begin{align}
J_i = R(j,k,\theta) = \begin{matrix} \\ \\ \\ j \\ \\ k \\ \\ \\ \\ \end{matrix} \begin{bmatrix} & 1 & & & & & & & & \\ & & 1 & & & & & & & \\ & & & \ddots & & & & & & \\ & & & & \cos(\theta) & & -\sin(\theta) & & & \\ & & & & & \ddots & & & & \\ & & & & \sin(\theta) & & \cos(\theta) & & & \\ & & & & & & & \ddots & & \\ & & & & & & & & 1 & \\ & & & & & & & & & 1 \\ \end{bmatrix}
\end{align}
</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>s = \sin \theta</math> и <math>c = \cos \theta</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>\dfrac{a_{jj}-a_{kk}}{2a_{jk}}=\dfrac{c^2-s^2}{2sc}=\dfrac{\cos2\theta}{\sin2\theta}=\operatorname{ctg}2\theta\equiv\tau</math>

Положим <math>tg\theta=t=\dfrac{s}{c}</math>. Тогда <math>t^2+2t\tau-1=0</math>.

Решая квадратное уравнение, получим:
<math>t=\dfrac{\operatorname{sign}\tau}{\left|\tau\right|+\sqrt{1+\tau^2}}, c=\dfrac{1}{\sqrt{1+t^2}}, s=t\cdot c.</math>

==Вычислительное ядро алгоритма==
Вычислительное ядро алгоритма составляют вычисления элементов матрицы <math>A</math> в процессе применения матрицы поворота <math>J</math> :

1. Вычисления элементов <math>a_{jl}^{(i+1)} = a_{lj}^{(i+1)}</math> и <math>a_{kl}^{(i+1)} = a_{lk}^{(i+1)}</math> (каждое <math>(n-2)</math> раз):

<math>\begin{align}
a_{jl}^{(i+1)} = a_{lj}^{(i+1)} = c \, a_{jl}^{(i)} - s \, a_{kl}^{(i)}, l \ne j,k;\\
a_{kl}^{(i+1)} = a_{lk}^{(i+1)} = s \, a_{jl}^{(i)} + c \, a_{kl}^{(i)}, l \ne j,k.
\end{align}</math>

2. Вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>:

<math>\begin{align}
a_{jj}^{(i+1)} &= c^2\, a_{jj}^{(i)} - 2\, s c \,a_{jk}^{(i)} + s^2\, a_{kk}^{(i)}; \\
a_{kk}^{(i+1)} &= s^2 \,a_{jj}^{(i)} + 2 s c\, a_{jk}^{(i)} + c^2 \, a_{kk}^{(i)}.
\end{align}</math>

== Макроструктура алгоритма ==
Макроструктуру алгоритма можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246, алгоритм 5.6)</ref>:

repeat
выбрать пару индексов j, k
обратиться к процедуре JacobiRotation(A,j,k)
пока А не станет достаточно близка к диагональной матрице

==Схема реализации последовательного алгоритма==
В классическом алгоритме Якоби для обнуления на текущей итерации выбирался наибольший элемент <math>a_{jk}</math>. Поиск наибольшего элемента слишком замедляет процесс вычислений (нужно провести поиск среди <math>\dfrac{n^2-n}{2}</math> элементов, прежде чем выполнить вращение стоимостью в <math>O(n)</math> флопов), поэтому для практических вычислений выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

Таким образом, алгоритм можно описать так<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 247, алгоритм 5.8)</ref>:

repeat
for j=1 to n-1
for k=j+1 to n
выполнить процедуру '''''JacobiRotation'''(A, j, k)''
end for
end for
пока A не достаточно близка к диагональной матрице

Процедура '''''JacobiRotation'''(A, j, k)'':

if <math>|a_{jk}|</math> не слишком мал
<math>\begin{align}
\tau &= \frac{a_{jj}-a_{kk}}{2\,a_{jk}} \\
t &= \frac{sign(\tau)}{|\tau|+\sqrt{1+\tau^2}} \\
c &= \frac{1}{\sqrt{1+t^2}} \\
s &= c\cdot t \\
A &= J_i^T\cdot A\cdot J_i, \qquad
J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}
</math>
end if
==Последовательная сложность алгоритма==
Для одной итерации вычислений собственных значений матрицы порядка <math>n</math> методом Якоби требуется:

Для вычислительного ядра:

*<math>4\,n+6</math> умножений,
*<math>2n</math> сложений.

Для остальной части алгоритма:

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

Умножения и сложения (вычитания) составляют основную часть алгоритма.

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

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

==Информационный граф==
Опишем граф алгоритма аналитически и в виде рисунка.

Граф алгоритма состоит из трёх групп вершин:

1. '''''Calculate c,s''''' — вычисление <math>c, s</math> согласно формулам в [[#Схема реализации последовательного алгоритма|схеме реализации последовательного алгоритма.]]

Аргументы функции:
*<math>a^{(i+1)}_{jj}, a^{(i+1)}_{kk}</math>:
** Первая итерация — элементы входных данных: диагональные элементы матрицы <math>A</math>;
** Последующие — результаты вычислений вершины второй группы.
* <math>a^{(i+1)}_{jk}</math>
** Первая итерация — элементы входных данных <math>a_{jk}</math>
** Последующие — результаты вычислений вершины третьей группы.

Результаты выполнения функции являются ''промежуточными данными'' алгоритма.

2. <math>A_{jj}, A_{kk}</math> — вычисление <math>a^{(i+1)}_{jj}, a^{(i+1)}_{kk}</math> согласно формулам в разделе [[#Вычислительное ядро алгоритма|Вычислительное ядро алгоритма]].

Аргументы функции:
* <math>c, s</math> — результаты вычислений вершины первой группы.
* <math>a^{(i)}_{jj}, a^{(i)}_{kk}</math>:
** Первая итерация — элементы входных данных <math>a_{jj}, a_{kk}</math>;
** Последующие — результаты вычислений вершины второй группы.
* <math>a^{(i)}_{jk}</math>:
** Первая итерация — элементы входных данных <math>a_{jk}</math>;
** Последующие — результаты вычислений вершины третьей группы.

Результат выполнения функции является ''выходным данным'' алгоритма.

3. <math>A_{jl}, A_{kl}</math> — вычисление <math>a^{(i+1)}_{jl},a^{(i+1)}_{kl},l\ne j,k</math> согласно формулам в разделе [[#Вычислительное ядро алгоритма|Вычислительное ядро алгоритма]].

Аргументы функции:
* <math>c, s</math> — результаты вычислений вершины первой группы.
* <math>a^{(i)}_{jl}, a^{(i)}_{kl}</math>:
** Первая итерация — элементы входных данных <math>a_{jl},l\ne j,k</math>;
** Последующие — результаты вычислений вершины третьей группы.

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

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

[[File:Jacobi.png|800px|thumb|center|Рисунок 1. Граф алгоритма без отображения входных и выходных данных. ]]

<center>
<div class="thumb">
<div class="thumbinner" style="width:800px">
<gallery widths=500px heights=750px>
File:calculate_cs_block.png|Рисунок 2. Структура вершины '''''Calculate c,s'''''.
</gallery>
<gallery widths=500px heights=500px>
File:Akk_block.png|Рисунок 3. Структура вершины <math>A_{jj}, A_{kk}</math> (вычисление <math>a_{jj}, a_{kk}</math>).
File:Ajl_block.png|Рисунок 4. Структура вершины <math>A_{jl}, A_{kl}</math> (вычисление <math>a_{jl},a_{kl},l\ne j,k</math>). Количество входных и выходных значений, а также количество операций на каждом уровне указано слева.
</gallery>
</div>
</div>
</center>
==Ресурс параллелизма алгоритма==

Каждая итерация алгоритма для матрицы порядка <math>n</math> заключается в последовательном выполнении следующих ярусов:

# Вычисление <math>c, s</math> (последовательно всего <math>4</math> умножений, <math>3</math> делений, <math>4</math> сложений (вычитаний), <math>2</math> операции извлечения квадратного корня, <math>1</math> операция сравнения, <math>1</math> операция взятия модуля)
# Поворот матрицы <math>A</math> с параллельным вычислением элементов матрицы <math>a_{jl, kl}^{(i+1)}</math>, (высота этой части яруса – 2 операции, ширина – <math>4(n-2)</math>) и элементов <math>a_{jj,kk}^{(i+1)}</math> (высота этой части яруса – 4 операции, ширина — 5).

Суммарное количество итераций зависит от входных данных и заданного значения погрешности <math>\epsilon</math>. Один цикл (полный проход по внедиагональным элементам) осуществляется за <math>N = \frac{n(n-1)}{2}</math> итераций.

Таким образом, при классификации по высоте ЯПФ метод Якоби относится к алгоритмам со сложностью <math>O(n^2)</math> , а при классификации по ширине ЯПФ — к алгоритмам со сложностью <math>O(n)</math>.

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

1. Плотная матрица <math>A=\{a_{ij}\}, A\in\R^{n\times n}</math>. Дополнительные ограничения:
* <math>A</math> — симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

2. Число двойной точности <math>\epsilon</math>, определяющее допустимый порядок малости внедиагональных элементов.

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

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

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

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

==Свойства алгоритма==
Из существующих алгоритмов вычисления собственных значений симметричной матрицы метод Якоби является самым медленным (в среднем для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 248)</ref>). Его преимущество заключается в том, что он не предполагает первоначального приведения матрицы к трехдиагональной форме. Также метод до сих пор используется на практике для вычисления малых собственных чисел и отвечающих им собственных векторов, так как он делает это с гораздо большей точностью, чем другие методы<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244)</ref>.

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

Метод Якоби не детерминирован, так как является итерационным алгоритмом с выходом по точности: число итераций зависит от входных данных и порогового значения.

=ЧАСТЬ. Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
===Масштабируемость алгоритма===
===Масштабируемость реализации алгоритма===
Исследование проводилось на суперкомпьютере "Ломоносов" Суперкомпьютерного комплекса Московского университета.

Набор и границы значений изменяемых параметров запуска реализации алгоритма:
*число процессоров [1 : 48] с шагом 4;
*размер матрицы [500 : 1500].

[[File:res1.png|800px|thumb|center|Рисунок 5. Зависимость времени выполнения алгоритма от размера матриц и количества процессоров.]]

Из рис. 6 видно, что при 20-24 процессорах производительность максимальная.
[[File:2d.png|800px|thumb|center|Рисунок 6. Зависимость времени выполнения алгоритма от количества процессоров для фиксированного размера матрицы 500*500.]]

[http://pastebin.com/edit/cSEYa6ih Реализация на C++.]

==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
Библиотека [https://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE] содержит последовательную реализацию алгоритма.

Существует также [http://ieeexplore.ieee.org/document/6310877/ параллельная реализация] метода на платформе CUDA.

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

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

2016-11-28T20:54:51Z

Tameeva.a:

{{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>\frac{n (n + 1)}{2}</math>
| output_data = <math>n</math>
}}

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

=ЧАСТЬ. Свойства и структура алгоритмов=
== Общее описание алгоритма ==

Метод Якоби вычисления собственных значений симметричной матрицы — итерационный алгоритм, названный в честь предложившего его для конкретной матрицы 7 × 7 в 1846 году Карла Густава Якоба Якоби<ref>Jacobi, C.G.J. (1846). «[http://resolver.sub.uni-goettingen.de/purl/?GDZPPN002144522 Über ein leichtes Verfahren, die in der Theorie der Säkularstörungen vorkommenden Gleichungen numerisch aufzulösen]» (German). Crelle's Journal 30: 51–94.</ref>. Исторически старейший метод для решения симметрической проблемы собственных значений получил широкое применение только в 1950-х годах с появлением компьютеров. Преимуществом метода является более точное вычисление малых собственных значений по сравнению с конкурирующими алгоритмами.

Суть алгоритма — приведение симметрической матрицы к диагональной с собственными значениями на диагонали путем вращения.

==Математическое описание алгоритма<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>==
Исходные данные: симметрическая матрица <math>A=\{a_{ij}\}</math>.

Вычисляемые данные: диагональная матрица <math>\Lambda=\{\lambda_{ii}\}</math>. Диагональные элементы <math>\Lambda</math> — собственные значения матрицы <math>A</math>, столбцы — приближенные собственные вектора матрицы <math>A</math>.

По заданной матрице <math>A=A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,\ldots, A_m</math>, сходящихся к <math>\Lambda</math>.

<math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math> J_i</math> — ортогональная матрица, называемая вращением Якоби.

Матрица <math>J_i</math> выбирается так, чтобы обнулить элементы <math>(j,k)</math> и <math>(k,j)</math> матрицы <math>A_{i+1}</math>:

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

<math>
\begin{align}
J_i = R(j,k,\theta) = \begin{matrix} \\ \\ \\ j \\ \\ k \\ \\ \\ \\ \end{matrix} \begin{bmatrix} & 1 & & & & & & & & \\ & & 1 & & & & & & & \\ & & & \ddots & & & & & & \\ & & & & \cos(\theta) & & -\sin(\theta) & & & \\ & & & & & \ddots & & & & \\ & & & & \sin(\theta) & & \cos(\theta) & & & \\ & & & & & & & \ddots & & \\ & & & & & & & & 1 & \\ & & & & & & & & & 1 \\ \end{bmatrix}
\end{align}
</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>s = \sin \theta</math> и <math>c = \cos \theta</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>\dfrac{a_{jj}-a_{kk}}{2a_{jk}}=\dfrac{c^2-s^2}{2sc}=\dfrac{\cos2\theta}{\sin2\theta}=\operatorname{ctg}2\theta\equiv\tau</math>

Положим <math>tg\theta=t=\dfrac{s}{c}</math>. Тогда <math>t^2+2t\tau-1=0</math>.

Решая квадратное уравнение, получим:
<math>t=\dfrac{\operatorname{sign}\tau}{\left|\tau\right|+\sqrt{1+\tau^2}}, c=\dfrac{1}{\sqrt{1+t^2}}, s=t\cdot c.</math>

==Вычислительное ядро алгоритма==
Вычислительное ядро алгоритма составляют вычисления элементов матрицы <math>A</math> в процессе применения матрицы поворота <math>J</math> :

1. Вычисления элементов <math>a_{jl}^{(i+1)} = a_{lj}^{(i+1)}</math> и <math>a_{kl}^{(i+1)} = a_{lk}^{(i+1)}</math> (каждое <math>(n-2)</math> раз):

<math>\begin{align}
a_{jl}^{(i+1)} = a_{lj}^{(i+1)} = c \, a_{jl}^{(i)} - s \, a_{kl}^{(i)}, l \ne j,k;\\
a_{kl}^{(i+1)} = a_{lk}^{(i+1)} = s \, a_{jl}^{(i)} + c \, a_{kl}^{(i)}, l \ne j,k.
\end{align}</math>

2. Вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>:

<math>\begin{align}
a_{jj}^{(i+1)} &= c^2\, a_{jj}^{(i)} - 2\, s c \,a_{jk}^{(i)} + s^2\, a_{kk}^{(i)}; \\
a_{kk}^{(i+1)} &= s^2 \,a_{jj}^{(i)} + 2 s c\, a_{jk}^{(i)} + c^2 \, a_{kk}^{(i)}.
\end{align}</math>

== Макроструктура алгоритма ==
Макроструктуру алгоритма можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246, алгоритм 5.6)</ref>:

repeat
выбрать пару индексов j, k
обратиться к процедуре JacobiRotation(A,j,k)
пока А не станет достаточно близка к диагональной матрице

==Схема реализации последовательного алгоритма==
В классическом алгоритме Якоби для обнуления на текущей итерации выбирался наибольший элемент <math>a_{jk}</math>. Поиск наибольшего элемента слишком замедляет процесс вычислений (нужно провести поиск среди <math>\dfrac{n^2-n}{2}</math> элементов, прежде чем выполнить вращение стоимостью в <math>O(n)</math> флопов), поэтому для практических вычислений выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

Таким образом, алгоритм можно описать так<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 247, алгоритм 5.8)</ref>:

repeat
for j=1 to n-1
for k=j+1 to n
выполнить процедуру '''''JacobiRotation'''(A, j, k)''
end for
end for
пока A не достаточно близка к диагональной матрице

Процедура '''''JacobiRotation'''(A, j, k)'':

if <math>|a_{jk}|</math> не слишком мал
<math>\begin{align}
\tau &= \frac{a_{jj}-a_{kk}}{2\,a_{jk}} \\
t &= \frac{sign(\tau)}{|\tau|+\sqrt{1+\tau^2}} \\
c &= \frac{1}{\sqrt{1+t^2}} \\
s &= c\cdot t \\
A &= J_i^T\cdot A\cdot J_i, \qquad
J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}
</math>
end if
==Последовательная сложность алгоритма==
Для одной итерации вычислений собственных значений матрицы порядка <math>n</math> методом Якоби требуется:

Для вычислительного ядра:

*<math>4\,n+6</math> умножений,
*<math>2n</math> сложений.

Для остальной части алгоритма:

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

Умножения и сложения (вычитания) составляют основную часть алгоритма.

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

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

==Информационный граф==
Опишем граф алгоритма аналитически и в виде рисунка.

Граф алгоритма состоит из трёх групп вершин:

1. '''''Calculate c,s''''' — вычисление <math>c, s</math> согласно формулам в [[#Схема реализации последовательного алгоритма|схеме реализации последовательного алгоритма.]]

Аргументы функции:
*<math>a^{(i+1)}_{jj}, a^{(i+1)}_{kk}</math>:
** Первая итерация — элементы входных данных: диагональные элементы матрицы <math>A</math>;
** Последующие — результаты вычислений вершины второй группы.
* <math>a^{(i+1)}_{jk}</math>
** Первая итерация — элементы входных данных <math>a_{jk}</math>
** Последующие — результаты вычислений вершины третьей группы.

Результаты выполнения функции являются ''промежуточными данными'' алгоритма.

2. <math>A_{jj}, A_{kk}</math> — вычисление <math>a^{(i+1)}_{jj}, a^{(i+1)}_{kk}</math> согласно формулам в разделе [[#Вычислительное ядро алгоритма|Вычислительное ядро алгоритма]].

Аргументы функции:
* <math>c, s</math> — результаты вычислений вершины первой группы.
* <math>a^{(i)}_{jj}, a^{(i)}_{kk}</math>:
** Первая итерация — элементы входных данных <math>a_{jj}, a_{kk}</math>;
** Последующие — результаты вычислений вершины второй группы.
* <math>a^{(i)}_{jk}</math>:
** Первая итерация — элементы входных данных <math>a_{jk}</math>;
** Последующие — результаты вычислений вершины третьей группы.

Результат выполнения функции является ''выходным данным'' алгоритма.

3. <math>A_{jl}, A_{kl}</math> — вычисление <math>a^{(i+1)}_{jl},a^{(i+1)}_{kl},l\ne j,k</math> согласно формулам в разделе [[#Вычислительное ядро алгоритма|Вычислительное ядро алгоритма]].

Аргументы функции:
* <math>c, s</math> — результаты вычислений вершины первой группы.
* <math>a^{(i)}_{jl}, a^{(i)}_{kl}</math>:
** Первая итерация — элементы входных данных <math>a_{jl},l\ne j,k</math>;
** Последующие — результаты вычислений вершины третьей группы.

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

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

[[File:Jacobi.png|800px|thumb|center|Рисунок 1. Граф алгоритма без отображения входных и выходных данных. ]]

<center>
<div class="thumb">
<div class="thumbinner" style="width:800px">
<gallery widths=500px heights=750px>
File:calculate_cs_block.png|Рисунок 2. Структура вершины '''''Calculate c,s'''''.
</gallery>
<gallery widths=500px heights=500px>
File:Akk_block.png|Рисунок 3. Структура вершины <math>A_{jj}, A_{kk}</math> (вычисление <math>a_{jj}, a_{kk}</math>).
File:Ajl_block.png|Рисунок 4. Структура вершины <math>A_{jl}, A_{kl}</math> (вычисление <math>a_{jl},a_{kl},l\ne j,k</math>). Количество входных и выходных значений, а также количество операций на каждом уровне указано слева.
</gallery>
</div>
</div>
</center>
==Ресурс параллелизма алгоритма==

Каждая итерация алгоритма для матрицы порядка <math>n</math> заключается в последовательном выполнении следующих ярусов:

# Вычисление <math>c, s</math> (последовательно всего <math>4</math> умножений, <math>3</math> делений, <math>4</math> сложений (вычитаний), <math>2</math> операции извлечения квадратного корня, <math>1</math> операция сравнения, <math>1</math> операция взятия модуля)
# Поворот матрицы <math>A</math> с параллельным вычислением элементов матрицы <math>a_{jl, kl}^{(i+1)}</math>, (высота этой части яруса – 2 операции, ширина – <math>4(n-2)</math>) и элементов <math>a_{jj,kk}^{(i+1)}</math> (высота этой части яруса – 4 операции, ширина — 5).

Суммарное количество итераций зависит от входных данных и заданного значения погрешности <math>\epsilon</math>. Один цикл (полный проход по внедиагональным элементам) осуществляется за <math>N = \frac{n(n-1)}{2}</math> итераций.

Таким образом, при классификации по высоте ЯПФ метод Якоби относится к алгоритмам со сложностью <math>O(n^2)</math> , а при классификации по ширине ЯПФ — к алгоритмам со сложностью <math>O(n)</math>.

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

1. Плотная матрица <math>A=\{a_{ij}\}, A\in\R^{n\times n}</math>. Дополнительные ограничения:
* <math>A</math> — симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

2. Число двойной точности <math>\epsilon</math>, определяющее допустимый порядок малости внедиагональных элементов.

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

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

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

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

==Свойства алгоритма==
Из существующих алгоритмов вычисления собственных значений симметричной матрицы метод Якоби является самым медленным (в среднем для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 248)</ref>). Его преимущество заключается в том, что он не предполагает первоначального приведения матрицы к трехдиагональной форме. Также метод до сих пор используется на практике для вычисления малых собственных чисел и отвечающих им собственных векторов, так как он делает это с гораздо большей точностью, чем другие методы<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244)</ref>.

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

Метод Якоби не детерминирован, так как является итерационным алгоритмом с выходом по точности: число итераций зависит от входных данных и порогового значения.

=ЧАСТЬ. Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
===Масштабируемость алгоритма===
===Масштабируемость реализации алгоритма===
Исследование проводилось на суперкомпьютере "Ломоносов" Суперкомпьютерного комплекса Московского университета.

Набор и границы значений изменяемых параметров запуска реализации алгоритма:
*число процессоров [1 : 48] с шагом 4;
*размер матрицы [500 : 1500].

[[File:res1.png|800px|thumb|center|Рисунок 5. Зависимость времени выполнения алгоритма от размера матриц и количества процессоров. ]]

Из рис. 6 видно, что при 20-24 процессорах производительность максимальная.
[[File:2d.png|800px|thumb|center|Рисунок 6. Зависимость времени выполнения алгоритма от количества процессоров для фиксированного размера матрицы 500*500. ]]
==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
Библиотека [https://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE] содержит последовательную реализацию алгоритма.

Существует также [http://ieeexplore.ieee.org/document/6310877/ параллельная реализация] метода на платформе CUDA.

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

Обсуждение участницы:Tameeva.a

2016-11-21T17:05:52Z

Tameeva.a: /* По существу (возможны добавления по вычитывании) */

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

=== По существу (возможны добавления по вычитывании) ===

* Если <math>a_{jj}-a_{kk} = 0</math>? --[[Участник:Frolov|Фролов А.В.]] ([[Обсуждение участника:Frolov|обсуждение]]) 16:43, 8 ноября 2016 (MSK)
** Тогда <math>c=1, s=0 \Rightarrow a_{jl}, a_{kl}, a_{jj}, a_{kk}</math> не изменяются на этой итерации. Имеет смысл поставить проверку, чтобы сразу переходить к следующей итерации.
* Более существенно - нельзя ли использовать какие-то свойства и частично получить параллелизм между итерациями? --[[Участник:Frolov|Фролов А.В.]] ([[Обсуждение участника:Frolov|обсуждение]]) 17:09, 8 ноября 2016 (MSK)

=== Отсутствующие части ===
* Не указан вклад каждого из авторов статьи. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 11:21, 25 октября 2016 (MSK)
**Исправлено. [[Участник:Tameeva.a|Tameeva.a]] ([[Обсуждение участника:Tameeva.a|обсуждение]]) 20:40, 7 ноября 2016 (MSK)
* Отсутствуют заголовки пунктов 2.2-2.6, соответственно пункт 2.1 должен иметь нумерацию 2.4, а пункт 2.2 должен иметь нумерацию 2.7. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 11:21, 25 октября 2016 (MSK)
**Исправлено. [[Участник:Tameeva.a|Tameeva.a]] ([[Обсуждение участника:Tameeva.a|обсуждение]]) 20:40, 7 ноября 2016 (MSK)

=== Замечания по тексту ===
* Представленное на рис.1 не является графом алгоритма: по определению в нём не должно быть управляющих вершин, также не вполне понятны вершины с данными; непонятны также разноцветные дуги. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 11:21, 25 октября 2016 (MSK)
** Граф на рис.1 является малопонятным - структура вычислений не показана и спрятана в макровершинах, зелёные макровершины почему-то имеют то один вход, то два, а то три - они каждый раз соответствуют разным вычислениям? И почему на рисунке 3 оси, хотя граф выглядит совершенно двумерным? Чему вообще соответствуют эти оси? [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 10:32, 1 ноября 2016 (MSK)

# Граф упрощен до версии без управляющих вершин и входных и выходных данных.
# Дуги окрашены в цвет вершин, из которых выходят (при изображении графа руководствовались [https://algowiki-project.org/ru/Стандарт_визуализации_ГА стандартом визуализации ГА]: "Цвет любой дуги графа рекомендуется задавать в соответствии с цветом вершины операции, из которой выходит эта дуга.")
# Добавлены рис. 2–4 с внутренней структурой макровершин.
# Различное количество входов имеют зеленые вершины различных типов (с вычислением <math>A_{jj, kk}</math> и с вычислением <math>A_{jl,kl}</math>). Также на второй и последующих итерациях используются только предыдущие вычисления, а на первой могут использоваться и входные значения, не обозначенные на графе. В описании графа отображена разница входных и выходных данных каждой вершины для первой и последующих итераций.
# Ось Х – выполнение операций внутри каждой итерации, ось Y – итерации. Ось Z введена (возможно, несколько искусственно) для отражения параллельности вычисления зеленых вершин. Таким образом, каждая группа вершин одной итерации расположена в плоскости, параллельной OXZ. Возможные исправления: отобразить эти плоскости для каждой итерации (например, пунктиром) либо удалить ось Z.
[[Участник:Tameeva.a|Tameeva.a]] ([[Обсуждение участника:Tameeva.a|обсуждение]]) 23:54, 7 ноября 2016 (MSK)

* В разделе 1.8 все шаги имеют номер 1. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 10:32, 1 ноября 2016 (MSK)
**Исправлено. [[Участник:Tameeva.a|Tameeva.a]] ([[Обсуждение участника:Tameeva.a|обсуждение]]) 23:54, 7 ноября 2016 (MSK)

* Не заполнен раздел 2.4 описания. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:41, 16 ноября 2016 (MSK)

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

2016-11-07T22:35:36Z

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

{{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>\frac{n (n + 1)}{2}</math>
| output_data = <math>n</math>
}}

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

=ЧАСТЬ. Свойства и структура алгоритмов=
== Общее описание алгоритма ==

Метод Якоби вычисления собственных значений симметричной матрицы — итерационный алгоритм, названный в честь предложившего его для конкретной матрицы 7 × 7 в 1846 году Карла Густава Якоба Якоби<ref>Jacobi, C.G.J. (1846). «[http://resolver.sub.uni-goettingen.de/purl/?GDZPPN002144522 Über ein leichtes Verfahren, die in der Theorie der Säkularstörungen vorkommenden Gleichungen numerisch aufzulösen]» (German). Crelle's Journal 30: 51–94.</ref>. Исторически старейший метод для решения симметрической проблемы собственных значений получил широкое применение только в 1950-х годах с появлением компьютеров. Преимуществом метода является более точное вычисление малых собственных значений по сравнению с конкурирующими алгоритмами.

Суть алгоритма — приведение симметрической матрицы к диагональной с собственными значениями на диагонали путем вращения.

==Математическое описание алгоритма<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>==
Исходные данные: симметрическая матрица <math>A=\{a_{ij}\}</math>.

Вычисляемые данные: диагональная матрица <math>\Lambda=\{\lambda_{ii}\}</math>. Диагональные элементы <math>\Lambda</math> — собственные значения матрицы <math>A</math>, столбцы — приближенные собственные вектора матрицы <math>A</math>.

По заданной матрице <math>A=A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,\ldots, A_m</math>, сходящихся к <math>\Lambda</math>.

<math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math> J_i</math> — ортогональная матрица, называемая вращением Якоби.

Матрица <math>J_i</math> выбирается так, чтобы обнулить элементы <math>(j,k)</math> и <math>(k,j)</math> матрицы <math>A_{i+1}</math>:

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

<math>
\begin{align}
J_i = R(j,k,\theta) = \begin{matrix} \\ \\ \\ j \\ \\ k \\ \\ \\ \\ \end{matrix} \begin{bmatrix} & 1 & & & & & & & & \\ & & 1 & & & & & & & \\ & & & \ddots & & & & & & \\ & & & & \cos(\theta) & & -\sin(\theta) & & & \\ & & & & & \ddots & & & & \\ & & & & \sin(\theta) & & \cos(\theta) & & & \\ & & & & & & & \ddots & & \\ & & & & & & & & 1 & \\ & & & & & & & & & 1 \\ \end{bmatrix}
\end{align}
</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>s = \sin \theta</math> и <math>c = \cos \theta</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>\dfrac{a_{jj}-a_{kk}}{2a_{jk}}=\dfrac{c^2-s^2}{2sc}=\dfrac{\cos2\theta}{\sin2\theta}=\operatorname{ctg}2\theta\equiv\tau</math>

Положим <math>tg\theta=t=\dfrac{s}{c}</math>. Тогда <math>t^2+2t\tau-1=0</math>.

Решая квадратное уравнение, получим:
<math>t=\dfrac{\operatorname{sign}\tau}{\left|\tau\right|+\sqrt{1+\tau^2}}, c=\dfrac{1}{\sqrt{1+t^2}}, s=t\cdot c.</math>

==Вычислительное ядро алгоритма==
Вычислительное ядро алгоритма составляют вычисления элементов матрицы <math>A</math> в процессе применения матрицы поворота <math>J</math> :

1. Вычисления элементов <math>a_{jl}^{(i+1)} = a_{lj}^{(i+1)}</math> и <math>a_{kl}^{(i+1)} = a_{lk}^{(i+1)}</math> (каждое <math>(n-2)</math> раз):

<math>\begin{align}
a_{jl}^{(i+1)} = a_{lj}^{(i+1)} = c \, a_{jl}^{(i)} - s \, a_{kl}^{(i)}, l \ne j,k;\\
a_{kl}^{(i+1)} = a_{lk}^{(i+1)} = s \, a_{jl}^{(i)} + c \, a_{kl}^{(i)}, l \ne j,k.
\end{align}</math>

2. Вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>:

<math>\begin{align}
a_{jj}^{(i+1)} &= c^2\, a_{jj}^{(i)} - 2\, s c \,a_{jk}^{(i)} + s^2\, a_{kk}^{(i)}; \\
a_{kk}^{(i+1)} &= s^2 \,a_{jj}^{(i)} + 2 s c\, a_{jk}^{(i)} + c^2 \, a_{kk}^{(i)}.
\end{align}</math>

== Макроструктура алгоритма ==
Макроструктуру алгоритма можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246, алгоритм 5.6)</ref>:

repeat
выбрать пару индексов j, k
обратиться к процедуре JacobiRotation(A,j,k)
пока А не станет достаточно близка к диагональной матрице

==Схема реализации последовательного алгоритма==
В классическом алгоритме Якоби для обнуления на текущей итерации выбирался наибольший элемент <math>a_{jk}</math>. Поиск наибольшего элемента слишком замедляет процесс вычислений (нужно провести поиск среди <math>\dfrac{n^2-n}{2}</math> элементов, прежде чем выполнить вращение стоимостью в <math>O(n)</math> флопов), поэтому для практических вычислений выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

Таким образом, алгоритм можно описать так<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 247, алгоритм 5.8)</ref>:

repeat
for j=1 to n-1
for k=j+1 to n
выполнить процедуру '''''JacobiRotation'''(A, j, k)''
end for
end for
пока A не достаточно близка к диагональной матрице

Процедура '''''JacobiRotation'''(A, j, k)'':

if <math>|a_{jk}|</math> не слишком мал
<math>\begin{align}
\tau &= \frac{a_{jj}-a_{kk}}{2\,a_{jk}} \\
t &= \frac{sign(\tau)}{|\tau|+\sqrt{1+\tau^2}} \\
c &= \frac{1}{\sqrt{1+t^2}} \\
s &= c\cdot t \\
A &= J_i^T\cdot A\cdot J_i, \qquad
J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}
</math>
end if
==Последовательная сложность алгоритма==
Для одной итерации вычислений собственных значений матрицы порядка <math>n</math> методом Якоби требуется:

Для вычислительного ядра:

*<math>4\,n+6</math> умножений,
*<math>2n</math> сложений.

Для остальной части алгоритма:

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

Умножения и сложения (вычитания) составляют основную часть алгоритма.

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

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

==Информационный граф==
Опишем граф алгоритма аналитически и в виде рисунка.

Граф алгоритма состоит из трёх групп вершин:

1. '''''Calculate c,s''''' — вычисление <math>c, s</math> согласно формулам в [[#Схема реализации последовательного алгоритма|схеме реализации последовательного алгоритма.]]

Аргументы функции:
*<math>a^{(i+1)}_{jj}, a^{(i+1)}_{kk}</math>:
** Первая итерация — элементы входных данных: диагональные элементы матрицы <math>A</math>;
** Последующие — результаты вычислений вершины второй группы.
* <math>a^{(i+1)}_{jk}</math>
** Первая итерация — элементы входных данных <math>a_{jk}</math>
** Последующие — результаты вычислений вершины третьей группы.

Результаты выполнения функции являются ''промежуточными данными'' алгоритма.

2. <math>A_{jj}, A_{kk}</math> — вычисление <math>a^{(i+1)}_{jj}, a^{(i+1)}_{kk}</math> согласно формулам в разделе [[#Вычислительное ядро алгоритма|Вычислительное ядро алгоритма]].

Аргументы функции:
* <math>c, s</math> — результаты вычислений вершины первой группы.
* <math>a^{(i)}_{jj}, a^{(i)}_{kk}</math>:
** Первая итерация — элементы входных данных <math>a_{jj}, a_{kk}</math>;
** Последующие — результаты вычислений вершины второй группы.
* <math>a^{(i)}_{jk}</math>:
** Первая итерация — элементы входных данных <math>a_{jk}</math>;
** Последующие — результаты вычислений вершины третьей группы.

Результат выполнения функции является ''выходным данным'' алгоритма.

3. <math>A_{jl}, A_{kl}</math> — вычисление <math>a^{(i+1)}_{jl},a^{(i+1)}_{kl},l\ne j,k</math> согласно формулам в разделе [[#Вычислительное ядро алгоритма|Вычислительное ядро алгоритма]].

Аргументы функции:
* <math>c, s</math> — результаты вычислений вершины первой группы.
* <math>a^{(i)}_{jl}, a^{(i)}_{kl}</math>:
** Первая итерация — элементы входных данных <math>a_{jl},l\ne j,k</math>;
** Последующие — результаты вычислений вершины третьей группы.

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

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

[[File:Jacobi.png|800px|thumb|center|Рисунок 1. Граф алгоритма без отображения входных и выходных данных. ]]

<center>
<div class="thumb">
<div class="thumbinner" style="width:800px">
<gallery widths=500px heights=750px>
File:calculate_cs_block.png|Рисунок 2. Структура вершины '''''Calculate c,s'''''.
</gallery>
<gallery widths=500px heights=500px>
File:Akk_block.png|Рисунок 3. Структура вершины <math>A_{jj}, A_{kk}</math> (вычисление <math>a_{jj}, a_{kk}</math>).
File:Ajl_block.png|Рисунок 4. Структура вершины <math>A_{jl}, A_{kl}</math> (вычисление <math>a_{jl},a_{kl},l\ne j,k</math>). Количество входных и выходных значений, а также количество операций на каждом уровне указано слева.
</gallery>
</div>
</div>
</center>
==Ресурс параллелизма алгоритма==

Каждая итерация алгоритма для матрицы порядка <math>n</math> заключается в последовательном выполнении следующих ярусов:

# Вычисление <math>c, s</math> (последовательно всего <math>4</math> умножений, <math>3</math> делений, <math>4</math> сложений (вычитаний), <math>2</math> операции извлечения квадратного корня, <math>1</math> операция сравнения, <math>1</math> операция взятия модуля)
# Поворот матрицы <math>A</math> с параллельным вычислением элементов матрицы <math>a_{jl, kl}^{(i+1)}</math>, (высота этой части яруса – 2 операции, ширина – <math>4(n-2)</math>) и элементов <math>a_{jj,kk}^{(i+1)}</math> (высота этой части яруса – 4 операции, ширина — 5).

Суммарное количество итераций зависит от входных данных и заданного значения погрешности <math>\epsilon</math>. Один цикл (полный проход по внедиагональным элементам) осуществляется за <math>N = \frac{n(n-1)}{2}</math> итераций.

Таким образом, при классификации по высоте ЯПФ метод Якоби относится к алгоритмам со сложностью <math>O(n^2)</math> , а при классификации по ширине ЯПФ — к алгоритмам со сложностью <math>O(n)</math>.

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

1. Плотная матрица <math>A=\{a_{ij}\}, A\in\R^{n\times n}</math>. Дополнительные ограничения:
* <math>A</math> — симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

2. Число двойной точности <math>\epsilon</math>, определяющее допустимый порядок малости внедиагональных элементов.

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

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

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

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

==Свойства алгоритма==
Из существующих алгоритмов вычисления собственных значений симметричной матрицы метод Якоби является самым медленным (в среднем для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 248)</ref>). Его преимущество заключается в том, что он не предполагает первоначального приведения матрицы к трехдиагональной форме. Также метод до сих пор используется на практике для вычисления малых собственных чисел и отвечающих им собственных векторов, так как он делает это с гораздо большей точностью, чем другие методы<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244)</ref>.

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

Метод Якоби не детерминирован, так как является итерационным алгоритмом с выходом по точности: число итераций зависит от входных данных и порогового значения.

=ЧАСТЬ. Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
===Масштабируемость алгоритма===
===Масштабируемость реализации алгоритма===
==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
Библиотека [https://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE] содержит последовательную реализацию алгоритма.

Существует также [http://ieeexplore.ieee.org/document/6310877/ параллельная реализация] метода на платформе CUDA.

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

Обсуждение участницы:Tameeva.a

2016-11-07T20:55:21Z

Tameeva.a: /* Замечания по тексту */

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

=== Отсутствующие части ===
* Не указан вклад каждого из авторов статьи. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 11:21, 25 октября 2016 (MSK)
**Исправлено. [[Участник:Tameeva.a|Tameeva.a]] ([[Обсуждение участника:Tameeva.a|обсуждение]]) 20:40, 7 ноября 2016 (MSK)
* Отсутствуют заголовки пунктов 2.2-2.6, соответственно пункт 2.1 должен иметь нумерацию 2.4, а пункт 2.2 должен иметь нумерацию 2.7. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 11:21, 25 октября 2016 (MSK)
**Исправлено. [[Участник:Tameeva.a|Tameeva.a]] ([[Обсуждение участника:Tameeva.a|обсуждение]]) 20:40, 7 ноября 2016 (MSK)

=== Замечания по тексту ===
* Представленное на рис.1 не является графом алгоритма: по определению в нём не должно быть управляющих вершин, также не вполне понятны вершины с данными; непонятны также разноцветные дуги. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 11:21, 25 октября 2016 (MSK)
** Граф на рис.1 является малопонятным - структура вычислений не показана и спрятана в макровершинах, зелёные макровершины почему-то имеют то один вход, то два, а то три - они каждый раз соответствуют разным вычислениям? И почему на рисунке 3 оси, хотя граф выглядит совершенно двумерным? Чему вообще соответствуют эти оси? [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 10:32, 1 ноября 2016 (MSK)

# Граф упрощен до версии без управляющих вершин и входных и выходных данных.
# Дуги окрашены в цвет вершин, из которых выходят (при изображении графа руководствовались [https://algowiki-project.org/ru/Стандарт_визуализации_ГА стандартом визуализации ГА]: "Цвет любой дуги графа рекомендуется задавать в соответствии с цветом вершины операции, из которой выходит эта дуга.")
# Добавлены рис. 2–4 с внутренней структурой макровершин.
# Различное количество входов имеют зеленые вершины различных типов (с вычислением <math>A_{jj, kk}</math> и с вычислением <math>A_{jl,kl}</math>). Также на второй и последующих итерациях используются только предыдущие вычисления, а на первой могут использоваться и входные значения, не обозначенные на графе. В описании графа отображена разница входных и выходных данных каждой вершины для первой и последующих итераций.
# Ось Х – выполнение операций внутри каждой итерации, ось Y – итерации. Ось Z введена (возможно, несколько искусственно) для отражения параллельности вычисления зеленых вершин. Таким образом, каждая группа вершин одной итерации расположена в плоскости, параллельной OXZ. Возможные исправления: отобразить эти плоскости для каждой итерации (например, пунктиром) либо удалить ось Z.
[[Участник:Tameeva.a|Tameeva.a]] ([[Обсуждение участника:Tameeva.a|обсуждение]]) 23:54, 7 ноября 2016 (MSK)

* В разделе 1.8 все шаги имеют номер 1. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 10:32, 1 ноября 2016 (MSK)
**Исправлено. [[Участник:Tameeva.a|Tameeva.a]] ([[Обсуждение участника:Tameeva.a|обсуждение]]) 23:54, 7 ноября 2016 (MSK)

Обсуждение участницы:Tameeva.a

2016-11-07T17:40:20Z

Tameeva.a: /* Отсутствующие части */

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

2016-11-07T17:38:13Z

Tameeva.a:

{{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>\frac{n (n + 1)}{2}</math>
| output_data = <math>n</math>
}}

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

=ЧАСТЬ. Свойства и структура алгоритмов=
== Общее описание алгоритма ==

Метод Якоби вычисления собственных значений симметричной матрицы — итерационный алгоритм, названный в честь предложившего его для конкретной матрицы 7 × 7 в 1846 году Карла Густава Якоба Якоби<ref>Jacobi, C.G.J. (1846). «[http://resolver.sub.uni-goettingen.de/purl/?GDZPPN002144522 Über ein leichtes Verfahren, die in der Theorie der Säkularstörungen vorkommenden Gleichungen numerisch aufzulösen]» (German). Crelle's Journal 30: 51–94.</ref>. Исторически старейший метод для решения симметрической проблемы собственных значений получил широкое применение только в 1950-х годах с появлением компьютеров. Преимуществом метода является более точное вычисление малых собственных значений по сравнению с конкурирующими алгоритмами.

Суть алгоритма — приведение симметрической матрицы к диагональной с собственными значениями на диагонали путем вращения.

==Математическое описание алгоритма<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>==
Исходные данные: симметрическая матрица <math>A=\{a_{ij}\}</math>.

Вычисляемые данные: диагональная матрица <math>\Lambda=\{\lambda_{ii}\}</math>. Диагональные элементы <math>\Lambda</math> — собственные значения матрицы <math>A</math>, столбцы — приближенные собственные вектора матрицы <math>A</math>.

По заданной матрице <math>A=A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,\ldots, A_m</math>, сходящихся к <math>\Lambda</math>.

<math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math> J_i</math> — ортогональная матрица, называемая вращением Якоби.

Матрица <math>J_i</math> выбирается так, чтобы обнулить элементы <math>(j,k)</math> и <math>(k,j)</math> матрицы <math>A_{i+1}</math>:

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

<math>
\begin{align}
J_i = R(j,k,\theta) = \begin{matrix} \\ \\ \\ j \\ \\ k \\ \\ \\ \\ \end{matrix} \begin{bmatrix} & 1 & & & & & & & & \\ & & 1 & & & & & & & \\ & & & \ddots & & & & & & \\ & & & & \cos(\theta) & & -\sin(\theta) & & & \\ & & & & & \ddots & & & & \\ & & & & \sin(\theta) & & \cos(\theta) & & & \\ & & & & & & & \ddots & & \\ & & & & & & & & 1 & \\ & & & & & & & & & 1 \\ \end{bmatrix}
\end{align}
</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>s = \sin \theta</math> и <math>c = \cos \theta</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>\dfrac{a_{jj}-a_{kk}}{2a_{jk}}=\dfrac{c^2-s^2}{2sc}=\dfrac{\cos2\theta}{\sin2\theta}=\operatorname{ctg}2\theta\equiv\tau</math>

Положим <math>tg\theta=t=\dfrac{s}{c}</math>. Тогда <math>t^2+2t\tau-1=0</math>.

Решая квадратное уравнение, получим:
<math>t=\dfrac{\operatorname{sign}\tau}{\left|\tau\right|+\sqrt{1+\tau^2}}, c=\dfrac{1}{\sqrt{1+t^2}}, s=t\cdot c.</math>

==Вычислительное ядро алгоритма==
Вычислительное ядро алгоритма составляют вычисления элементов матрицы <math>A</math> в процессе применения матрицы поворота <math>J</math> :

1. Вычисления элементов <math>a_{jl}^{(i+1)} = a_{lj}^{(i+1)}</math> и <math>a_{kl}^{(i+1)} = a_{lk}^{(i+1)}</math> (каждое <math>(n-2)</math> раз):

<math>\begin{align}
a_{jl}^{(i+1)} = a_{lj}^{(i+1)} = c \, a_{jl}^{(i)} - s \, a_{kl}^{(i)}, l \ne j,k;\\
a_{kl}^{(i+1)} = a_{lk}^{(i+1)} = s \, a_{jl}^{(i)} + c \, a_{kl}^{(i)}, l \ne j,k.
\end{align}</math>

2. Вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>:

<math>\begin{align}
a_{jj}^{(i+1)} &= c^2\, a_{jj}^{(i)} - 2\, s c \,a_{jk}^{(i)} + s^2\, a_{kk}^{(i)}; \\
a_{kk}^{(i+1)} &= s^2 \,a_{jj}^{(i)} + 2 s c\, a_{jk}^{(i)} + c^2 \, a_{kk}^{(i)}.
\end{align}</math>

== Макроструктура алгоритма ==
Макроструктуру алгоритма можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246, алгоритм 5.6)</ref>:

repeat
выбрать пару индексов j, k
обратиться к процедуре JacobiRotation(A,j,k)
пока А не станет достаточно близка к диагональной матрице

==Схема реализации последовательного алгоритма==
В классическом алгоритме Якоби для обнуления на текущей итерации выбирался наибольший элемент <math>a_{jk}</math>. Поиск наибольшего элемента слишком замедляет процесс вычислений (нужно провести поиск среди <math>\dfrac{n^2-n}{2}</math> элементов, прежде чем выполнить вращение стоимостью в <math>O(n)</math> флопов), поэтому для практических вычислений выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

Таким образом, алгоритм можно описать так<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 247, алгоритм 5.8)</ref>:

repeat
for j=1 to n-1
for k=j+1 to n
выполнить процедуру '''''JacobiRotation'''(A, j, k)''
end for
end for
пока A не достаточно близка к диагональной матрице

Процедура '''''JacobiRotation'''(A, j, k)'':

if <math>|a_{jk}|</math> не слишком мал
<math>\begin{align}
\tau &= \frac{a_{jj}-a_{kk}}{2\,a_{jk}} \\
t &= \frac{sign(\tau)}{|\tau|+\sqrt{1+\tau^2}} \\
c &= \frac{1}{\sqrt{1+t^2}} \\
s &= c\cdot t \\
A &= J_i^T\cdot A\cdot J_i, \qquad
J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}
</math>
end if
==Последовательная сложность алгоритма==
Для одной итерации вычислений собственных значений матрицы порядка <math>n</math> методом Якоби требуется:

Для вычислительного ядра:

*<math>4\,n+6</math> умножений,
*<math>2n</math> сложений.

Для остальной части алгоритма:

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

Умножения и сложения (вычитания) составляют основную часть алгоритма.

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

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

==Информационный граф==
Опишем граф алгоритма аналитически и в виде рисунка.

Граф алгоритма состоит из трёх групп вершин:

1. '''''Calculate c,s''''' — вычисление <math>c, s</math> согласно формулам в [[#Схема реализации последовательного алгоритма|схеме реализации последовательного алгоритма.]]

Аргументы функции:
*<math>a^{(i+1)}_{jj}, a^{(i+1)}_{kk}</math>:
** Первая итерация — элементы входных данных: диагональные элементы матрицы <math>A</math>;
** Последующие — результаты вычислений вершины второй группы.
* <math>a^{(i+1)}_{jk}</math>
** Первая итерация — элементы входных данных <math>a_{jk}</math>
** Последующие — результаты вычислений вершины третьей группы.

Результаты выполнения функции являются ''промежуточными данными'' алгоритма.

2. <math>A_{jj}, A_{kk}</math> — вычисление <math>a^{(i+1)}_{jj}, a^{(i+1)}_{kk}</math> согласно формулам в разделе [[#Вычислительное ядро алгоритма|Вычислительное ядро алгоритма]].

Аргументы функции:
* <math>c, s</math> — результаты вычислений вершины первой группы.
* <math>a^{(i)}_{jj}, a^{(i)}_{kk}</math>:
** Первая итерация — элементы входных данных <math>a_{jj}, a_{kk}</math>;
** Последующие — результаты вычислений вершины второй группы.
* <math>a^{(i)}_{jk}</math>:
** Первая итерация — элементы входных данных <math>a_{jk}</math>;
** Последующие — результаты вычислений вершины третьей группы.

Результат выполнения функции является ''выходным данным'' алгоритма.

3. <math>A_{jl}, A_{kl}</math> — вычисление <math>a^{(i+1)}_{jl},a^{(i+1)}_{kl},l\ne j,k</math> согласно формулам в разделе [[#Вычислительное ядро алгоритма|Вычислительное ядро алгоритма]].

Аргументы функции:
* <math>c, s</math> — результаты вычислений вершины первой группы.
* <math>a^{(i)}_{jl}, a^{(i)}_{kl}</math>:
** Первая итерация — элементы входных данных <math>a_{jl},l\ne j,k</math>;
** Последующие — результаты вычислений вершины третьей группы.

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

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

[[File:Jacobi.png|800px|thumb|center|Рисунок 1. Граф алгоритма без отображения входных и выходных данных. ]]

<center>
<div class="thumb">
<div class="thumbinner" style="width:800px">
<gallery widths=500px heights=750px>
File:calculate_cs_block.png|Рисунок 2. Структура вершины '''''Calculate c,s'''''.
</gallery>
<gallery widths=500px heights=500px>
File:Akk_block.png|Рисунок 3. Структура вершины <math>A_{jj}, A_{kk}</math> (вычисление <math>a_{jj}, a_{kk}</math>).
File:Ajl_block.png|Рисунок 4. Структура вершины <math>A_{jl}, A_{kl}</math> (вычисление <math>a_{jl},a_{kl},l\ne j,k</math>). Количество входных и выходных значений, а также количество операций на каждом уровне указано слева.
</gallery>
</div>
</div>
</center>
==Ресурс параллелизма алгоритма==

Для выполнения каждой итерации требуется последовательно выполнить следующие ярусы (для матрицы порядка <math>n</math>):
# Вычислить норму матрицы и сравнить с <math>\epsilon</math> (параллельное вычисление <math>\frac{n(n-1)}{2}</math> умножений, далее последовательно <math>\frac{n(n-1)}{2}-1</math> сложений, <math>1</math> операция взятия квадратного корня, <math>1</math> операция сравнения)
# Вычислить <math>\tau, t, c, s</math> (последовательно всего <math>4</math> умножений, <math>3</math> делений, <math>4</math> сложений (вычитаний), <math>2</math> операции извлечения квадратного корня, <math>1</math> операция сравнения, <math>1</math> операция взятия модуля)
# Поворот матрицы <math>A</math> с параллельным выполнением <math>2(n-2)</math> операций вычисления элементов матрицы <math>a_{jl}^{(i+1)} = a_{lj}^{(i+1)}</math>   и   <math>a_{kl}^{(i+1)} = a_{lk}^{(i+1)}</math>,   <math>m \ne j,k</math>, а также <math>2</math> операций вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>.

Суммарное количество итераций зависит от входных данных и заданного значения погрешности <math>\epsilon</math>. Один цикл (полный проход по внедиагональным элементам) осуществляется за <math>N = \frac{n(n-1)}{2}</math> итераций.

Таким образом, при классификации по высоте ЯПФ метод Якоби относится к алгоритмам со сложностью <math>O(n^2)</math> , а при классификации по ширине ЯПФ — к алгоритмам со сложностью <math>O(n)</math>.

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

1. Плотная матрица <math>A=\{a_{ij}\}, A\in\R^{n\times n}</math>. Дополнительные ограничения:
* <math>A</math> — симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

2. Число двойной точности <math>\epsilon</math>, определяющее допустимый порядок малости внедиагональных элементов.

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

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

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

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

==Свойства алгоритма==
Из существующих алгоритмов вычисления собственных значений симметричной матрицы метод Якоби является самым медленным (в среднем для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 248)</ref>). Его преимущество заключается в том, что он не предполагает первоначального приведения матрицы к трехдиагональной форме. Также метод до сих пор используется на практике для вычисления малых собственных чисел и отвечающих им собственных векторов, так как он делает это с гораздо большей точностью, чем другие методы<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244)</ref>.

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

Метод Якоби не детерминирован, так как является итерационным алгоритмом с выходом по точности: число итераций зависит от входных данных и порогового значения.

=ЧАСТЬ. Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
===Масштабируемость алгоритма===
===Масштабируемость реализации алгоритма===
==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
Библиотека [https://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE] содержит последовательную реализацию алгоритма.

Существует также [http://ieeexplore.ieee.org/document/6310877/ параллельная реализация] метода на платформе CUDA.

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

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

2016-11-02T16:22:32Z

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

{{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>\frac{n (n + 1)}{2}</math>
| output_data = <math>n</math>
}}

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

=ЧАСТЬ. Свойства и структура алгоритмов=
== Общее описание алгоритма ==

Метод Якоби вычисления собственных значений симметричной матрицы — итерационный алгоритм, названный в честь предложившего его для конкретной матрицы 7 × 7 в 1846 году Карла Густава Якоба Якоби<ref>Jacobi, C.G.J. (1846). «[http://resolver.sub.uni-goettingen.de/purl/?GDZPPN002144522 Über ein leichtes Verfahren, die in der Theorie der Säkularstörungen vorkommenden Gleichungen numerisch aufzulösen]» (German). Crelle's Journal 30: 51–94.</ref>. Исторически старейший метод для решения симметрической проблемы собственных значений получил широкое применение только в 1950-х годах с появлением компьютеров. Преимуществом метода является более точное вычисление малых собственных значений по сравнению с конкурирующими алгоритмами.

Суть алгоритма — приведение симметрической матрицы к диагональной с собственными значениями на диагонали путем вращения.

==Математическое описание алгоритма<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>==
Исходные данные: симметрическая матрица <math>A=\{a_{ij}\}</math>.

Вычисляемые данные: диагональная матрица <math>\Lambda=\{\lambda_{ii}\}</math>. Диагональные элементы <math>\Lambda</math> — собственные значения матрицы <math>A</math>, столбцы — приближенные собственные вектора матрицы <math>A</math>.

По заданной матрице <math>A=A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,\ldots, A_m</math>, сходящихся к <math>\Lambda</math>.

<math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math> J_i</math> — ортогональная матрица, называемая вращением Якоби.

Матрица <math>J_i</math> выбирается так, чтобы обнулить элементы <math>(j,k)</math> и <math>(k,j)</math> матрицы <math>A_{i+1}</math>:

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

<math>
\begin{align}
J_i = R(j,k,\theta) = \begin{matrix} \\ \\ \\ j \\ \\ k \\ \\ \\ \\ \end{matrix} \begin{bmatrix} & 1 & & & & & & & & \\ & & 1 & & & & & & & \\ & & & \ddots & & & & & & \\ & & & & \cos(\theta) & & -\sin(\theta) & & & \\ & & & & & \ddots & & & & \\ & & & & \sin(\theta) & & \cos(\theta) & & & \\ & & & & & & & \ddots & & \\ & & & & & & & & 1 & \\ & & & & & & & & & 1 \\ \end{bmatrix}
\end{align}
</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>s = \sin \theta</math> и <math>c = \cos \theta</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>\dfrac{a_{jj}-a_{kk}}{2a_{jk}}=\dfrac{c^2-s^2}{2sc}=\dfrac{\cos2\theta}{\sin2\theta}=\operatorname{ctg}2\theta\equiv\tau</math>

Положим <math>tg\theta=t=\dfrac{s}{c}</math>. Тогда <math>t^2+2t\tau-1=0</math>.

Решая квадратное уравнение, получим:
<math>t=\dfrac{\operatorname{sign}\tau}{\left|\tau\right|+\sqrt{1+\tau^2}}, c=\dfrac{1}{\sqrt{1+t^2}}, s=t\cdot c.</math>

==Вычислительное ядро алгоритма==
Вычислительное ядро алгоритма составляют вычисления элементов матрицы <math>A</math> в процессе применения матрицы поворота <math>J</math> :

1. Вычисления элементов <math>a_{jl}^{(i+1)} = a_{lj}^{(i+1)}</math> и <math>a_{kl}^{(i+1)} = a_{lk}^{(i+1)}</math> (каждое <math>(n-2)</math> раз):

<math>\begin{align}
a_{jl}^{(i+1)} = a_{lj}^{(i+1)} = c \, a_{jl}^{(i)} - s \, a_{kl}^{(i)}, l \ne j,k;\\
a_{kl}^{(i+1)} = a_{lk}^{(i+1)} = s \, a_{jl}^{(i)} + c \, a_{kl}^{(i)}, l \ne j,k.
\end{align}</math>

2. Вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>:

<math>\begin{align}
a_{jj}^{(i+1)} &= c^2\, a_{jj}^{(i)} - 2\, s c \,a_{jk}^{(i)} + s^2\, a_{kk}^{(i)}; \\
a_{kk}^{(i+1)} &= s^2 \,a_{jj}^{(i)} + 2 s c\, a_{jk}^{(i)} + c^2 \, a_{kk}^{(i)}.
\end{align}</math>

== Макроструктура алгоритма ==
Макроструктуру алгоритма можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246, алгоритм 5.6)</ref>:

repeat
выбрать пару индексов j, k
обратиться к процедуре JacobiRotation(A,j,k)
пока А не станет достаточно близка к диагональной матрице

==Схема реализации последовательного алгоритма==
В классическом алгоритме Якоби для обнуления на текущей итерации выбирался наибольший элемент <math>a_{jk}</math>. Поиск наибольшего элемента слишком замедляет процесс вычислений (нужно провести поиск среди <math>\dfrac{n^2-n}{2}</math> элементов, прежде чем выполнить вращение стоимостью в <math>O(n)</math> флопов), поэтому для практических вычислений выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

Таким образом, алгоритм можно описать так<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 247, алгоритм 5.8)</ref>:

repeat
for j=1 to n-1
for k=j+1 to n
выполнить процедуру '''''JacobiRotation'''(A, j, k)''
end for
end for
пока A не достаточно близка к диагональной матрице

Процедура '''''JacobiRotation'''(A, j, k)'':

if <math>|a_{jk}|</math> не слишком мал
<math>\begin{align}
\tau &= \frac{a_{jj}-a_{kk}}{2\,a_{jk}} \\
t &= \frac{sign(\tau)}{|\tau|+\sqrt{1+\tau^2}} \\
c &= \frac{1}{\sqrt{1+t^2}} \\
s &= c\cdot t \\
A &= J_i^T\cdot A\cdot J_i, \qquad
J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}
</math>
end if
==Последовательная сложность алгоритма==
Для одной итерации вычислений собственных значений матрицы порядка <math>n</math> методом Якоби требуется:

Для вычислительного ядра:

*<math>4\,n+6</math> умножений,
*<math>2n</math> сложений.

Для остальной части алгоритма:

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

Умножения и сложения (вычитания) составляют основную часть алгоритма.

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

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

==Информационный граф==
Опишем граф алгоритма аналитически и в виде рисунка.

Граф алгоритма состоит из трёх групп вершин:

1. '''''Calculate c,s''''' — вычисление <math>c, s</math> согласно формулам в [[#Схема реализации последовательного алгоритма|схеме реализации последовательного алгоритма.]]

Аргументы функции:
*<math>a^{(i+1)}_{jj}, a^{(i+1)}_{kk}</math>:
** Первая итерация — элементы входных данных: диагональные элементы матрицы <math>A</math>;
** Последующие — результаты вычислений вершины третьей группы.
* <math>a^{(i+1)}_{jk}</math>
** Первая итерация — элементы входных данных <math>a_{jk}</math>
** Последующие — результаты вычислений вершины четвертой группы.

Результаты выполнения функции являются ''промежуточными данными'' алгоритма.

2. <math>A_{jj}, A_{kk}</math> — вычисление <math>a^{(i+1)}_{jj}, a^{(i+1)}_{kk}</math> согласно формулам в разделе [[#Вычислительное ядро алгоритма|Вычислительное ядро алгоритма]].

Аргументы функции:
* <math>c, s</math> — результаты вычислений вершины второй группы.
* <math>a^{(i)}_{jj}, a^{(i)}_{kk}</math>:
** Первая итерация — элементы входных данных <math>a_{jj}, a_{kk}</math>;
** Последующие — результаты вычислений вершины третьей группы.
* <math>a^{(i)}_{jk}</math>:
** Первая итерация — элементы входных данных <math>a_{jk}</math>;
** Последующие — результаты вычислений вершины четвертой группы.

Результат выполнения функции является ''выходным данным'' алгоритма.

3. <math>A_{jl}, A_{kl}</math> — вычисление <math>a^{(i+1)}_{jl},a^{(i+1)}_{kl},l\ne j,k</math> согласно формулам в разделе [[#Вычислительное ядро алгоритма|Вычислительное ядро алгоритма]].

Аргументы функции:
* <math>c, s</math> — результаты вычислений вершины второй группы.
* <math>a^{(i)}_{jl}, a^{(i)}_{kl}</math>:
** Первая итерация — элементы входных данных <math>a_{jl},l\ne j,k</math>;
** Последующие — результаты вычислений вершины четвертой группы.

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

Описанный граф для четырех итераций представлен на рисунке. Входные и выходные данные не отображены, дублирующие друг друга дуги даны как одна.[[File:Jacobi.png|600px|thumb|center|Рисунок 1. Граф алгоритма без отображения входных и выходных данных.]]

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

Для выполнения каждой итерации требуется последовательно выполнить следующие ярусы (для матрицы порядка <math>n</math>):
# Вычислить норму матрицы и сравнить с <math>\epsilon</math> (параллельное вычисление <math>\frac{n(n-1)}{2}</math> умножений, далее последовательно <math>\frac{n(n-1)}{2}-1</math> сложений, <math>1</math> операция взятия квадратного корня, <math>1</math> операция сравнения)
# Вычислить <math>\tau, t, c, s</math> (последовательно всего <math>4</math> умножений, <math>3</math> делений, <math>4</math> сложений (вычитаний), <math>2</math> операции извлечения квадратного корня, <math>1</math> операция сравнения, <math>1</math> операция взятия модуля)
# Поворот матрицы <math>A</math> с параллельным выполнением <math>2(n-2)</math> операций вычисления элементов матрицы <math>a_{jl}^{(i+1)} = a_{lj}^{(i+1)}</math>   и   <math>a_{kl}^{(i+1)} = a_{lk}^{(i+1)}</math>,   <math>m \ne j,k</math>, а также <math>2</math> операций вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>.

Суммарное количество итераций зависит от входных данных и заданного значения погрешности <math>\epsilon</math>. Один цикл (полный проход по внедиагональным элементам) осуществляется за <math>N = \frac{n(n-1)}{2}</math> итераций.

Таким образом, при классификации по высоте ЯПФ метод Якоби относится к алгоритмам со сложностью <math>O(n^2)</math> , а при классификации по ширине ЯПФ — к алгоритмам со сложностью <math>O(n)</math>.

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

1. Плотная матрица <math>A=\{a_{ij}\}, A\in\R^{n\times n}</math>. Дополнительные ограничения:
* <math>A</math> — симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

2. Число двойной точности <math>\epsilon</math>, определяющее допустимый порядок малости внедиагональных элементов.

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

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

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

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

==Свойства алгоритма==
Из существующих алгоритмов вычисления собственных значений симметричной матрицы метод Якоби является самым медленным (в среднем для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 248)</ref>). Его преимущество заключается в том, что он не предполагает первоначального приведения матрицы к трехдиагональной форме. Также метод до сих пор используется на практике для вычисления малых собственных чисел и отвечающих им собственных векторов, так как он делает это с гораздо большей точностью, чем другие методы<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244)</ref>.

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

Метод Якоби не детерминирован, так как является итерационным алгоритмом с выходом по точности: число итераций зависит от входных данных и порогового значения.

=ЧАСТЬ. Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
===Масштабируемость алгоритма===
===Масштабируемость реализации алгоритма===
==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
Библиотека [https://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE] содержит последовательную реализацию алгоритма.

Существует также [http://ieeexplore.ieee.org/document/6310877/ параллельная реализация] метода на платформе CUDA.

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

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

2016-10-31T15:41:15Z

Tameeva.a:

{{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>\frac{n (n + 1)}{2}</math>
| output_data = <math>n</math>
}}

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

=ЧАСТЬ. Свойства и структура алгоритмов=
== Общее описание алгоритма ==

Метод Якоби вычисления собственных значений симметричной матрицы — итерационный алгоритм, названный в честь предложившего его для конкретной матрицы 7 × 7 в 1846 году Карла Густава Якоба Якоби<ref>Jacobi, C.G.J. (1846). «[http://resolver.sub.uni-goettingen.de/purl/?GDZPPN002144522 Über ein leichtes Verfahren, die in der Theorie der Säkularstörungen vorkommenden Gleichungen numerisch aufzulösen]» (German). Crelle's Journal 30: 51–94.</ref>. Исторически старейший метод для решения симметрической проблемы собственных значений получил широкое применение только в 1950-х годах с появлением компьютеров. Преимуществом метода является более точное вычисление малых собственных значений по сравнению с конкурирующими алгоритмами.

Суть алгоритма — приведение симметрической матрицы к диагональной с собственными значениями на диагонали путем вращения.

==Математическое описание алгоритма<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>==
Исходные данные: симметрическая матрица <math>A=\{a_{ij}\}</math>.

Вычисляемые данные: диагональная матрица <math>\Lambda=\{\lambda_{ii}\}</math>. Диагональные элементы <math>\Lambda</math> — собственные значения матрицы <math>A</math>, столбцы — приближенные собственные вектора матрицы <math>A</math>.

По заданной матрице <math>A=A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,\ldots, A_m</math>, сходящихся к <math>\Lambda</math>.

<math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math> J_i</math> — ортогональная матрица, называемая вращением Якоби.

Матрица <math>J_i</math> выбирается так, чтобы обнулить элементы <math>(j,k)</math> и <math>(k,j)</math> матрицы <math>A_{i+1}</math>:

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

<math>
\begin{align}
J_i = R(j,k,\theta) = \begin{matrix} \\ \\ \\ j \\ \\ k \\ \\ \\ \\ \end{matrix} \begin{bmatrix} & 1 & & & & & & & & \\ & & 1 & & & & & & & \\ & & & \ddots & & & & & & \\ & & & & \cos(\theta) & & -\sin(\theta) & & & \\ & & & & & \ddots & & & & \\ & & & & \sin(\theta) & & \cos(\theta) & & & \\ & & & & & & & \ddots & & \\ & & & & & & & & 1 & \\ & & & & & & & & & 1 \\ \end{bmatrix}
\end{align}
</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>s = \sin \theta</math> и <math>c = \cos \theta</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>\dfrac{a_{jj}-a_{kk}}{2a_{jk}}=\dfrac{c^2-s^2}{2sc}=\dfrac{\cos2\theta}{\sin2\theta}=\operatorname{ctg}2\theta\equiv\tau</math>

Положим <math>tg\theta=t=\dfrac{s}{c}</math>. Тогда <math>t^2+2t\tau-1=0</math>.

Решая квадратное уравнение, получим:
<math>t=\dfrac{\operatorname{sign}\tau}{\left|\tau\right|+\sqrt{1+\tau^2}}, c=\dfrac{1}{\sqrt{1+t^2}}, s=t\cdot c.</math>

==Вычислительное ядро алгоритма==
Вычислительное ядро алгоритма составляют вычисления элементов матрицы <math>A</math> в процессе применения матрицы поворота <math>J</math> :

1. Вычисления элементов <math>a_{jl}^{(i+1)} = a_{lj}^{(i+1)}</math> и <math>a_{kl}^{(i+1)} = a_{lk}^{(i+1)}</math> (каждое <math>(n-2)</math> раз):

<math>\begin{align}
a_{jl}^{(i+1)} = a_{lj}^{(i+1)} = c \, a_{jl}^{(i)} - s \, a_{kl}^{(i)}, l \ne j,k;\\
a_{kl}^{(i+1)} = a_{lk}^{(i+1)} = s \, a_{jl}^{(i)} + c \, a_{kl}^{(i)}, l \ne j,k.
\end{align}</math>

2. Вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>:

<math>\begin{align}
a_{jj}^{(i+1)} &= c^2\, a_{jj}^{(i)} - 2\, s c \,a_{jk}^{(i)} + s^2\, a_{kk}^{(i)}; \\
a_{kk}^{(i+1)} &= s^2 \,a_{jj}^{(i)} + 2 s c\, a_{jk}^{(i)} + c^2 \, a_{kk}^{(i)}.
\end{align}</math>

== Макроструктура алгоритма ==
Макроструктуру алгоритма можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246, алгоритм 5.6)</ref>:

repeat
выбрать пару индексов j, k
обратиться к процедуре JacobiRotation(A,j,k)
пока А не станет достаточно близка к диагональной матрице

==Схема реализации последовательного алгоритма==
В классическом алгоритме Якоби для обнуления на текущей итерации выбирался наибольший элемент <math>a_{jk}</math>. Поиск наибольшего элемента слишком замедляет процесс вычислений (нужно провести поиск среди <math>\dfrac{n^2-n}{2}</math> элементов, прежде чем выполнить вращение стоимостью в <math>O(n)</math> флопов), поэтому для практических вычислений выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

Таким образом, алгоритм можно описать так<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 247, алгоритм 5.8)</ref>:

repeat
for j=1 to n-1
for k=j+1 to n
выполнить процедуру '''''JacobiRotation'''(A, j, k)''
end for
end for
пока A не достаточно близка к диагональной матрице

Процедура '''''JacobiRotation'''(A, j, k)'':

if <math>|a_{jk}|</math> не слишком мал
<math>\begin{align}
\tau &= \frac{a_{jj}-a_{kk}}{2\,a_{jk}} \\
t &= \frac{sign(\tau)}{|\tau|+\sqrt{1+\tau^2}} \\
c &= \frac{1}{\sqrt{1+t^2}} \\
s &= c\cdot t \\
A &= J_i^T\cdot A\cdot J_i, \qquad
J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}
</math>
end if
==Последовательная сложность алгоритма==
Для одной итерации вычислений собственных значений матрицы порядка <math>n</math> методом Якоби требуется:

Для вычислительного ядра:

*<math>4\,n+6</math> умножений,
*<math>2n</math> сложений.

Для остальной части алгоритма:

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

Умножения и сложения (вычитания) составляют основную часть алгоритма.

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

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

==Информационный граф==
Опишем граф алгоритма аналитически и в виде рисунка.

Граф алгоритма состоит из трёх групп вершин:

1. '''''Calculate c,s''''' — вычисление <math>c, s</math> согласно формулам в [[#Схема реализации последовательного алгоритма|схеме реализации последовательного алгоритма.]]

Аргументы функции:
*<math>a^{(i+1)}_{jj}, a^{(i+1)}_{kk}</math>:
** Первая итерация — элементы входных данных: диагональные элементы матрицы <math>A</math>;
** Последующие — результаты вычислений вершины третьей группы.
* <math>a^{(i+1)}_{jk}</math>
** Первая итерация — элементы входных данных <math>a_{jk}</math>
** Последующие — результаты вычислений вершины четвертой группы.

Результаты выполнения функции являются ''промежуточными данными'' алгоритма.

2. <math>A_{jj}, A_{kk}</math> — вычисление <math>a^{(i+1)}_{jj}, a^{(i+1)}_{kk}</math> согласно формулам в разделе [[#Вычислительное ядро алгоритма|Вычислительное ядро алгоритма]].

Аргументы функции:
* <math>c, s</math> — результаты вычислений вершины второй группы.
* <math>a^{(i)}_{jj}, a^{(i)}_{kk}</math>:
** Первая итерация — элементы входных данных <math>a_{jj}, a_{kk}</math>;
** Последующие — результаты вычислений вершины третьей группы.
* <math>a^{(i)}_{jk}</math>:
** Первая итерация — элементы входных данных <math>a_{jk}</math>;
** Последующие — результаты вычислений вершины четвертой группы.

Результат выполнения функции является ''выходным данным'' алгоритма.

3. <math>A_{jl}, A_{kl}</math> — вычисление <math>a^{(i+1)}_{jl},a^{(i+1)}_{kl},l\ne j,k</math> согласно формулам в разделе [[#Вычислительное ядро алгоритма|Вычислительное ядро алгоритма]].

Аргументы функции:
* <math>c, s</math> — результаты вычислений вершины второй группы.
* <math>a^{(i)}_{jl}, a^{(i)}_{kl}</math>:
** Первая итерация — элементы входных данных <math>a_{jl},l\ne j,k</math>;
** Последующие — результаты вычислений вершины четвертой группы.

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

Описанный граф для четырех итераций представлен на рисунке. Входные и выходные данные не отображены, дублирующие друг друга дуги даны как одна.[[File:Jacobi.png|600px|thumb|center|Рисунок 1. Граф алгоритма без отображения входных и выходных данных.]]

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

Для выполнения каждой итерации требуется последовательно выполнить следующие ярусы (для матрицы порядка <math>n</math>):
# Вычислить норму матрицы и сравнить с <math>\epsilon</math> (параллельное вычисление <math>\frac{n(n-1)}{2}</math> умножений, далее последовательно <math>\frac{n(n-1)}{2}-1</math> сложений, <math>1</math> операция взятия квадратного корня, <math>1</math> операция сравнения )

# Вычислить <math>\tau, t, c, s</math> (последовательно всего <math>4</math> умножений, <math>3</math> делений, <math>4</math> сложений (вычитаний), <math>2</math> операции извлечения квадратного корня, <math>1</math> операция сравнения, <math>1</math> операция взятия модуля)

# Поворот матрицы <math>A</math> с параллельным выполнением <math>2(n-2)</math> операций вычисления элементов матрицы <math>a_{jl}^{(i+1)} = a_{lj}^{(i+1)}</math>   и   <math>a_{kl}^{(i+1)} = a_{lk}^{(i+1)}</math>,   <math>m \ne j,k</math>, а также <math>2</math> операций вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>.

Суммарное количество итераций зависит от входных данных и заданного значения погрешности <math>\epsilon</math>. Один цикл (полный проход по внедиагональным элементам) осуществляется за <math>N = \frac{n(n-1)}{2}</math> итераций.

Таким образом, при классификации по высоте ЯПФ метод Якоби относится к алгоритмам со сложностью <math>O(n^2)</math> , а при классификации по ширине ЯПФ — к алгоритмам со сложностью <math>O(n)</math>.

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

1. Плотная матрица <math>A=\{a_{ij}\}, A\in\R^{n\times n}</math>. Дополнительные ограничения:
* <math>A</math> — симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

2. Число двойной точности <math>\epsilon</math>, определяющее допустимый порядок малости внедиагональных элементов.

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

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

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

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

==Свойства алгоритма==
Из существующих алгоритмов вычисления собственных значений симметричной матрицы метод Якоби является самым медленным (в среднем для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 248)</ref>). Его преимущество заключается в том, что он не предполагает первоначального приведения матрицы к трехдиагональной форме. Также метод до сих пор используется на практике для вычисления малых собственных чисел и отвечающих им собственных векторов, так как он делает это с гораздо большей точностью, чем другие методы<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244)</ref>.

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

Метод Якоби не детерминирован, так как является итерационным алгоритмом с выходом по точности: число итераций зависит от входных данных и порогового значения.

=ЧАСТЬ. Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
===Масштабируемость алгоритма===
===Масштабируемость реализации алгоритма===
==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
Библиотека [https://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE] содержит последовательную реализацию алгоритма.

Существует также [http://ieeexplore.ieee.org/document/6310877/ параллельная реализация] метода на платформе CUDA.

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

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

2016-10-31T15:40:17Z

Tameeva.a: /* Информационный граф */

{{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>\frac{n (n + 1)}{2}</math>
| output_data = <math>n</math>
}}

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

=ЧАСТЬ. Свойства и структура алгоритмов=
== Общее описание алгоритма ==

Метод Якоби вычисления собственных значений симметричной матрицы — итерационный алгоритм, названный в честь предложившего его для конкретной матрицы 7 × 7 в 1846 году Карла Густава Якоба Якоби<ref>Jacobi, C.G.J. (1846). «[http://resolver.sub.uni-goettingen.de/purl/?GDZPPN002144522 Über ein leichtes Verfahren, die in der Theorie der Säkularstörungen vorkommenden Gleichungen numerisch aufzulösen]» (German). Crelle's Journal 30: 51–94.</ref>. Исторически старейший метод для решения симметрической проблемы собственных значений получил широкое применение только в 1950-х годах с появлением компьютеров. Преимуществом метода является более точное вычисление малых собственных значений по сравнению с конкурирующими алгоритмами.

Суть алгоритма — приведение симметрической матрицы к диагональной с собственными значениями на диагонали путем вращения.

==Математическое описание алгоритма<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>==
Исходные данные: симметрическая матрица <math>A=\{a_{ij}\}</math>.

Вычисляемые данные: диагональная матрица <math>\Lambda=\{\lambda_{ii}\}</math>. Диагональные элементы <math>\Lambda</math> — собственные значения матрицы <math>A</math>, столбцы — приближенные собственные вектора матрицы <math>A</math>.

По заданной матрице <math>A=A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,\ldots, A_m</math>, сходящихся к <math>\Lambda</math>.

<math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math> J_i</math> — ортогональная матрица, называемая вращением Якоби.

Матрица <math>J_i</math> выбирается так, чтобы обнулить элементы <math>(j,k)</math> и <math>(k,j)</math> матрицы <math>A_{i+1}</math>:

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

<math>
\begin{align}
J_i = R(j,k,\theta) = \begin{matrix} \\ \\ \\ j \\ \\ k \\ \\ \\ \\ \end{matrix} \begin{bmatrix} & 1 & & & & & & & & \\ & & 1 & & & & & & & \\ & & & \ddots & & & & & & \\ & & & & \cos(\theta) & & -\sin(\theta) & & & \\ & & & & & \ddots & & & & \\ & & & & \sin(\theta) & & \cos(\theta) & & & \\ & & & & & & & \ddots & & \\ & & & & & & & & 1 & \\ & & & & & & & & & 1 \\ \end{bmatrix}
\end{align}
</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>s = \sin \theta</math> и <math>c = \cos \theta</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>\dfrac{a_{jj}-a_{kk}}{2a_{jk}}=\dfrac{c^2-s^2}{2sc}=\dfrac{\cos2\theta}{\sin2\theta}=\operatorname{ctg}2\theta\equiv\tau</math>

Положим <math>tg\theta=t=\dfrac{s}{c}</math>. Тогда <math>t^2+2t\tau-1=0</math>.

Решая квадратное уравнение, получим:
<math>t=\dfrac{\operatorname{sign}\tau}{\left|\tau\right|+\sqrt{1+\tau^2}}, c=\dfrac{1}{\sqrt{1+t^2}}, s=t\cdot c.</math>

==Вычислительное ядро алгоритма==
Вычислительное ядро алгоритма составляют вычисления элементов матрицы <math>A</math> в процессе применения матрицы поворота <math>J</math> :

1. Вычисления элементов <math>a_{jl}^{(i+1)} = a_{lj}^{(i+1)}</math> и <math>a_{kl}^{(i+1)} = a_{lk}^{(i+1)}</math> (каждое <math>(n-2)</math> раз):

<math>\begin{align}
a_{jl}^{(i+1)} = a_{lj}^{(i+1)} = c \, a_{jl}^{(i)} - s \, a_{kl}^{(i)}, l \ne j,k;\\
a_{kl}^{(i+1)} = a_{lk}^{(i+1)} = s \, a_{jl}^{(i)} + c \, a_{kl}^{(i)}, l \ne j,k.
\end{align}</math>

2. Вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>:

<math>\begin{align}
a_{jj}^{(i+1)} &= c^2\, a_{jj}^{(i)} - 2\, s c \,a_{jk}^{(i)} + s^2\, a_{kk}^{(i)}; \\
a_{kk}^{(i+1)} &= s^2 \,a_{jj}^{(i)} + 2 s c\, a_{jk}^{(i)} + c^2 \, a_{kk}^{(i)}.
\end{align}</math>

== Макроструктура алгоритма ==
Макроструктуру алгоритма можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246, алгоритм 5.6)</ref>:

repeat
выбрать пару индексов j, k
обратиться к процедуре JacobiRotation(A,j,k)
пока А не станет достаточно близка к диагональной матрице

==Схема реализации последовательного алгоритма==
В классическом алгоритме Якоби для обнуления на текущей итерации выбирался наибольший элемент <math>a_{jk}</math>. Поиск наибольшего элемента слишком замедляет процесс вычислений (нужно провести поиск среди <math>\dfrac{n^2-n}{2}</math> элементов, прежде чем выполнить вращение стоимостью в <math>O(n)</math> флопов), поэтому для практических вычислений выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

Таким образом, алгоритм можно описать так<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 247, алгоритм 5.8)</ref>:

repeat
for j=1 to n-1
for k=j+1 to n
выполнить процедуру '''''JacobiRotation'''(A, j, k)''
end for
end for
пока A не достаточно близка к диагональной матрице

Процедура '''''JacobiRotation'''(A, j, k)'':

if <math>|a_{jk}|</math> не слишком мал
<math>\begin{align}
\tau &= \frac{a_{jj}-a_{kk}}{2\,a_{jk}} \\
t &= \frac{sign(\tau)}{|\tau|+\sqrt{1+\tau^2}} \\
c &= \frac{1}{\sqrt{1+t^2}} \\
s &= c\cdot t \\
A &= J_i^T\cdot A\cdot J_i, \qquad
J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}
</math>
end if
==Последовательная сложность алгоритма==
Для одной итерации вычислений собственных значений матрицы порядка <math>n</math> методом Якоби требуется:

Для вычислительного ядра:

*<math>4\,n+6</math> умножений,
*<math>2n</math> сложений.

Для остальной части алгоритма:

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

Умножения и сложения (вычитания) составляют основную часть алгоритма.

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

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

==Информационный граф==
Опишем граф алгоритма аналитически и в виде рисунка.

Граф алгоритма состоит из трёх групп вершин:

1. '''''Calculate c,s''''' — вычисление <math>c, s</math> согласно формулам в [[#Схема реализации последовательного алгоритма|схеме реализации последовательного алгоритма.]]

Аргументы функции:
*<math>a^{(i+1)}_{jj}, a^{(i+1)}_{kk}</math>:
** Первая итерация — элементы входных данных: диагональные элементы матрицы <math>A</math>;
** Последующие — результаты вычислений вершины третьей группы.
* <math>a^{(i+1)}_{jk}</math>
** Первая итерация — элементы входных данных <math>a_{jk}</math>
** Последующие — результаты вычислений вершины четвертой группы.

Результаты выполнения функции являются ''промежуточными данными'' алгоритма.

2. <math>A_{jj}, A_{kk}</math> — вычисление <math>a^{(i+1)}_{jj}, a^{(i+1)}_{kk}</math> согласно формулам в разделе [[#Вычислительное ядро алгоритма|Вычислительное ядро алгоритма]].

Аргументы функции:
* <math>c, s</math> — результаты вычислений вершины второй группы.
* <math>a^{(i)}_{jj}, a^{(i)}_{kk}</math>:
** Первая итерация — элементы входных данных <math>a_{jj}, a_{kk}</math>;
** Последующие — результаты вычислений вершины третьей группы.
* <math>a^{(i)}_{jk}</math>:
** Первая итерация — элементы входных данных <math>a_{jk}</math>;
** Последующие — результаты вычислений вершины четвертой группы.

Результат выполнения функции является ''выходным данным'' алгоритма.

3. <math>A_{jl}, A_{kl}</math> — вычисление <math>a^{(i+1)}_{jl},a^{(i+1)}_{kl},l\ne j,k</math> согласно формулам в разделе [[#Вычислительное ядро алгоритма|Вычислительное ядро алгоритма]].

Аргументы функции:
* <math>c, s</math> — результаты вычислений вершины второй группы.
* <math>a^{(i)}_{jl}, a^{(i)}_{kl}</math>:
** Первая итерация — элементы входных данных <math>a_{jl},l\ne j,k</math>;
** Последующие — результаты вычислений вершины четвертой группы.

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

Описанный граф для четырех итераций представлен на рисунке. Входные и выходные данные не отображены, дублирующие друг друга дуги даны как одна.[[File:Jacobi.png|600px|thumb|center|Рисунок 1. Граф алгоритма без отображения входных и выходных данных.]]

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

Для выполнения каждой итерации требуется последовательно выполнить следующие ярусы (для матрицы порядка <math>n</math>):
# Вычислить норму матрицы и сравнить с <math>\epsilon</math> (параллельное вычисление <math>\frac{n(n-1)}{2}</math> умножений, далее последовательно <math>\frac{n(n-1)}{2}-1</math> сложений, <math>1</math> операция взятия квадратного корня, <math>1</math> операция сравнения )

# Вычислить <math>\tau, t, c, s</math> (последовательно всего <math>4</math> умножений, <math>3</math> делений, <math>4</math> сложений (вычитаний), <math>2</math> операции извлечения квадратного корня, <math>1</math> операция сравнения, <math>1</math> операция взятия модуля)

# Поворот матрицы <math>A</math> с параллельным выполнением <math>2(n-2)</math> операций вычисления элементов матрицы <math>a_{jl}^{(i+1)} = a_{lj}^{(i+1)}</math>   и   <math>a_{kl}^{(i+1)} = a_{lk}^{(i+1)}</math>,   <math>m \ne j,k</math>, а также <math>2</math> операций вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>.

Суммарное количество итераций зависит от входных данных и заданного значения погрешности <math>\epsilon</math>. Один цикл (полный проход по внедиагональным элементам) осуществляется за <math>N = \frac{n(n-1)}{2}</math> итераций.

Таким образом, при классификации по высоте ЯПФ метод Якоби относится к алгоритмам со сложностью <math>O(n^2)</math> , а при классификации по ширине ЯПФ — к алгоритмам со сложностью <math>O(n)</math>.

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

1. Плотная матрица <math>A=\{a_{ij}\}, A\in\R^{n\times n}</math>. Дополнительные ограничения:
* <math>A</math> — симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

2. Число двойной точности <math>\epsilon</math>, определяющее допустимый порядок малости внедиагональных элементов.

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

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

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

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

==Свойства алгоритма==
Из существующих алгоритмов вычисления собственных значений симметричной матрицы метод Якоби является самым медленным (в среднем для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 248)</ref>). Его преимущество заключается в том, что он не предполагает первоначального приведения матрицы к трехдиагональной форме. Также метод до сих пор используется на практике для вычисления малых собственных чисел и отвечающих им собственных векторов, так как он делает это с гораздо большей точностью, чем другие методы<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244)</ref>.

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

Метод Якоби не детерминирован, так как является итерационным алгоритмом с выходом по точности: число итераций зависит от входных данных и порогового значения.

=ЧАСТЬ. Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
===Масштабируемость алгоритма===
===Масштабируемость реализации алгоритма===
==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
Библиотека [https://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE] содержит последовательную реализацию алгоритма.

Существует также [http://ieeexplore.ieee.org/document/6310877/ параллельная реализация] метода на платформе CUDA.

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

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

2016-10-31T15:39:55Z

Tameeva.a: /* Информационный граф */

{{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>\frac{n (n + 1)}{2}</math>
| output_data = <math>n</math>
}}

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

=ЧАСТЬ. Свойства и структура алгоритмов=
== Общее описание алгоритма ==

Метод Якоби вычисления собственных значений симметричной матрицы — итерационный алгоритм, названный в честь предложившего его для конкретной матрицы 7 × 7 в 1846 году Карла Густава Якоба Якоби<ref>Jacobi, C.G.J. (1846). «[http://resolver.sub.uni-goettingen.de/purl/?GDZPPN002144522 Über ein leichtes Verfahren, die in der Theorie der Säkularstörungen vorkommenden Gleichungen numerisch aufzulösen]» (German). Crelle's Journal 30: 51–94.</ref>. Исторически старейший метод для решения симметрической проблемы собственных значений получил широкое применение только в 1950-х годах с появлением компьютеров. Преимуществом метода является более точное вычисление малых собственных значений по сравнению с конкурирующими алгоритмами.

Суть алгоритма — приведение симметрической матрицы к диагональной с собственными значениями на диагонали путем вращения.

==Математическое описание алгоритма<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>==
Исходные данные: симметрическая матрица <math>A=\{a_{ij}\}</math>.

Вычисляемые данные: диагональная матрица <math>\Lambda=\{\lambda_{ii}\}</math>. Диагональные элементы <math>\Lambda</math> — собственные значения матрицы <math>A</math>, столбцы — приближенные собственные вектора матрицы <math>A</math>.

По заданной матрице <math>A=A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,\ldots, A_m</math>, сходящихся к <math>\Lambda</math>.

<math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math> J_i</math> — ортогональная матрица, называемая вращением Якоби.

Матрица <math>J_i</math> выбирается так, чтобы обнулить элементы <math>(j,k)</math> и <math>(k,j)</math> матрицы <math>A_{i+1}</math>:

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

<math>
\begin{align}
J_i = R(j,k,\theta) = \begin{matrix} \\ \\ \\ j \\ \\ k \\ \\ \\ \\ \end{matrix} \begin{bmatrix} & 1 & & & & & & & & \\ & & 1 & & & & & & & \\ & & & \ddots & & & & & & \\ & & & & \cos(\theta) & & -\sin(\theta) & & & \\ & & & & & \ddots & & & & \\ & & & & \sin(\theta) & & \cos(\theta) & & & \\ & & & & & & & \ddots & & \\ & & & & & & & & 1 & \\ & & & & & & & & & 1 \\ \end{bmatrix}
\end{align}
</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>s = \sin \theta</math> и <math>c = \cos \theta</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>\dfrac{a_{jj}-a_{kk}}{2a_{jk}}=\dfrac{c^2-s^2}{2sc}=\dfrac{\cos2\theta}{\sin2\theta}=\operatorname{ctg}2\theta\equiv\tau</math>

Положим <math>tg\theta=t=\dfrac{s}{c}</math>. Тогда <math>t^2+2t\tau-1=0</math>.

Решая квадратное уравнение, получим:
<math>t=\dfrac{\operatorname{sign}\tau}{\left|\tau\right|+\sqrt{1+\tau^2}}, c=\dfrac{1}{\sqrt{1+t^2}}, s=t\cdot c.</math>

==Вычислительное ядро алгоритма==
Вычислительное ядро алгоритма составляют вычисления элементов матрицы <math>A</math> в процессе применения матрицы поворота <math>J</math> :

1. Вычисления элементов <math>a_{jl}^{(i+1)} = a_{lj}^{(i+1)}</math> и <math>a_{kl}^{(i+1)} = a_{lk}^{(i+1)}</math> (каждое <math>(n-2)</math> раз):

<math>\begin{align}
a_{jl}^{(i+1)} = a_{lj}^{(i+1)} = c \, a_{jl}^{(i)} - s \, a_{kl}^{(i)}, l \ne j,k;\\
a_{kl}^{(i+1)} = a_{lk}^{(i+1)} = s \, a_{jl}^{(i)} + c \, a_{kl}^{(i)}, l \ne j,k.
\end{align}</math>

2. Вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>:

<math>\begin{align}
a_{jj}^{(i+1)} &= c^2\, a_{jj}^{(i)} - 2\, s c \,a_{jk}^{(i)} + s^2\, a_{kk}^{(i)}; \\
a_{kk}^{(i+1)} &= s^2 \,a_{jj}^{(i)} + 2 s c\, a_{jk}^{(i)} + c^2 \, a_{kk}^{(i)}.
\end{align}</math>

== Макроструктура алгоритма ==
Макроструктуру алгоритма можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246, алгоритм 5.6)</ref>:

repeat
выбрать пару индексов j, k
обратиться к процедуре JacobiRotation(A,j,k)
пока А не станет достаточно близка к диагональной матрице

==Схема реализации последовательного алгоритма==
В классическом алгоритме Якоби для обнуления на текущей итерации выбирался наибольший элемент <math>a_{jk}</math>. Поиск наибольшего элемента слишком замедляет процесс вычислений (нужно провести поиск среди <math>\dfrac{n^2-n}{2}</math> элементов, прежде чем выполнить вращение стоимостью в <math>O(n)</math> флопов), поэтому для практических вычислений выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

Таким образом, алгоритм можно описать так<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 247, алгоритм 5.8)</ref>:

repeat
for j=1 to n-1
for k=j+1 to n
выполнить процедуру '''''JacobiRotation'''(A, j, k)''
end for
end for
пока A не достаточно близка к диагональной матрице

Процедура '''''JacobiRotation'''(A, j, k)'':

if <math>|a_{jk}|</math> не слишком мал
<math>\begin{align}
\tau &= \frac{a_{jj}-a_{kk}}{2\,a_{jk}} \\
t &= \frac{sign(\tau)}{|\tau|+\sqrt{1+\tau^2}} \\
c &= \frac{1}{\sqrt{1+t^2}} \\
s &= c\cdot t \\
A &= J_i^T\cdot A\cdot J_i, \qquad
J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}
</math>
end if
==Последовательная сложность алгоритма==
Для одной итерации вычислений собственных значений матрицы порядка <math>n</math> методом Якоби требуется:

Для вычислительного ядра:

*<math>4\,n+6</math> умножений,
*<math>2n</math> сложений.

Для остальной части алгоритма:

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

Умножения и сложения (вычитания) составляют основную часть алгоритма.

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

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

==Информационный граф==
Опишем граф алгоритма аналитически и в виде рисунка.

Граф алгоритма состоит из трёх групп вершин:

1. '''''Calculate c,s''''' — вычисление <math>c, s</math> согласно формулам в [[#Схема реализации последовательного алгоритма|схеме реализации последовательного алгоритма.]]

Аргументы функции:
*<math>a^{(i+1)}_{jj}, a^{(i+1)}_{kk}</math>:
** Первая итерация — элементы входных данных: диагональные элементы матрицы <math>A</math>;
** Последующие — результаты вычислений вершины третьей группы.
* <math>a^{(i+1)}_{jk}</math>
** Первая итерация — элементы входных данных <math>a_{jk}</math>
** Последующие — результаты вычислений вершины четвертой группы.

Результаты выполнения функции являются ''промежуточными данными'' алгоритма.

2. <math>A_{jj}, A_{kk}</math> — вычисление <math>a^{(i+1)}_{jj}, a^{(i+1)}_{kk}</math> согласно формулам в разделе [[#Вычислительное ядро алгоритма|Вычислительное ядро алгоритма]].

Аргументы функции:
* <math>c, s</math> — результаты вычислений вершины второй группы.
* <math>a^{(i)}_{jj}, a^{(i)}_{kk}</math>:
** Первая итерация — элементы входных данных <math>a_{jj}, a_{kk}</math>;
** Последующие — результаты вычислений вершины третьей группы.
* <math>a^{(i)}_{jk}</math>:
** Первая итерация — элементы входных данных <math>a_{jk}</math>;
** Последующие — результаты вычислений вершины четвертой группы.

Результат выполнения функции является ''выходным данным'' алгоритма.

3. <math>A_{jl}, A_{kl}</math> — вычисление <math>a^{(i+1)}_{jl},a^{(i+1)}_{kl},l\ne j,k</math> согласно формулам в разделе [[#Вычислительное ядро алгоритма|Вычислительное ядро алгоритма]].

Аргументы функции:
* <math>c, s</math> — результаты вычислений вершины второй группы.
* <math>a^{(i)}_{jl}, a^{(i)}_{kl}</math>:
** Первая итерация — элементы входных данных <math>a_{jl},l\ne j,k</math>;
** Последующие — результаты вычислений вершины четвертой группы.

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

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

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

Для выполнения каждой итерации требуется последовательно выполнить следующие ярусы (для матрицы порядка <math>n</math>):
# Вычислить норму матрицы и сравнить с <math>\epsilon</math> (параллельное вычисление <math>\frac{n(n-1)}{2}</math> умножений, далее последовательно <math>\frac{n(n-1)}{2}-1</math> сложений, <math>1</math> операция взятия квадратного корня, <math>1</math> операция сравнения )

# Вычислить <math>\tau, t, c, s</math> (последовательно всего <math>4</math> умножений, <math>3</math> делений, <math>4</math> сложений (вычитаний), <math>2</math> операции извлечения квадратного корня, <math>1</math> операция сравнения, <math>1</math> операция взятия модуля)

# Поворот матрицы <math>A</math> с параллельным выполнением <math>2(n-2)</math> операций вычисления элементов матрицы <math>a_{jl}^{(i+1)} = a_{lj}^{(i+1)}</math>   и   <math>a_{kl}^{(i+1)} = a_{lk}^{(i+1)}</math>,   <math>m \ne j,k</math>, а также <math>2</math> операций вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>.

Суммарное количество итераций зависит от входных данных и заданного значения погрешности <math>\epsilon</math>. Один цикл (полный проход по внедиагональным элементам) осуществляется за <math>N = \frac{n(n-1)}{2}</math> итераций.

Таким образом, при классификации по высоте ЯПФ метод Якоби относится к алгоритмам со сложностью <math>O(n^2)</math> , а при классификации по ширине ЯПФ — к алгоритмам со сложностью <math>O(n)</math>.

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

1. Плотная матрица <math>A=\{a_{ij}\}, A\in\R^{n\times n}</math>. Дополнительные ограничения:
* <math>A</math> — симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

2. Число двойной точности <math>\epsilon</math>, определяющее допустимый порядок малости внедиагональных элементов.

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

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

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

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

==Свойства алгоритма==
Из существующих алгоритмов вычисления собственных значений симметричной матрицы метод Якоби является самым медленным (в среднем для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 248)</ref>). Его преимущество заключается в том, что он не предполагает первоначального приведения матрицы к трехдиагональной форме. Также метод до сих пор используется на практике для вычисления малых собственных чисел и отвечающих им собственных векторов, так как он делает это с гораздо большей точностью, чем другие методы<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244)</ref>.

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

Метод Якоби не детерминирован, так как является итерационным алгоритмом с выходом по точности: число итераций зависит от входных данных и порогового значения.

=ЧАСТЬ. Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
===Масштабируемость алгоритма===
===Масштабируемость реализации алгоритма===
==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
Библиотека [https://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE] содержит последовательную реализацию алгоритма.

Существует также [http://ieeexplore.ieee.org/document/6310877/ параллельная реализация] метода на платформе CUDA.

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

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

2016-10-31T15:37:11Z

Tameeva.a:

{{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>\frac{n (n + 1)}{2}</math>
| output_data = <math>n</math>
}}

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

=ЧАСТЬ. Свойства и структура алгоритмов=
== Общее описание алгоритма ==

Метод Якоби вычисления собственных значений симметричной матрицы — итерационный алгоритм, названный в честь предложившего его для конкретной матрицы 7 × 7 в 1846 году Карла Густава Якоба Якоби<ref>Jacobi, C.G.J. (1846). «[http://resolver.sub.uni-goettingen.de/purl/?GDZPPN002144522 Über ein leichtes Verfahren, die in der Theorie der Säkularstörungen vorkommenden Gleichungen numerisch aufzulösen]» (German). Crelle's Journal 30: 51–94.</ref>. Исторически старейший метод для решения симметрической проблемы собственных значений получил широкое применение только в 1950-х годах с появлением компьютеров. Преимуществом метода является более точное вычисление малых собственных значений по сравнению с конкурирующими алгоритмами.

Суть алгоритма — приведение симметрической матрицы к диагональной с собственными значениями на диагонали путем вращения.

==Математическое описание алгоритма<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>==
Исходные данные: симметрическая матрица <math>A=\{a_{ij}\}</math>.

Вычисляемые данные: диагональная матрица <math>\Lambda=\{\lambda_{ii}\}</math>. Диагональные элементы <math>\Lambda</math> — собственные значения матрицы <math>A</math>, столбцы — приближенные собственные вектора матрицы <math>A</math>.

По заданной матрице <math>A=A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,\ldots, A_m</math>, сходящихся к <math>\Lambda</math>.

<math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math> J_i</math> — ортогональная матрица, называемая вращением Якоби.

Матрица <math>J_i</math> выбирается так, чтобы обнулить элементы <math>(j,k)</math> и <math>(k,j)</math> матрицы <math>A_{i+1}</math>:

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

<math>
\begin{align}
J_i = R(j,k,\theta) = \begin{matrix} \\ \\ \\ j \\ \\ k \\ \\ \\ \\ \end{matrix} \begin{bmatrix} & 1 & & & & & & & & \\ & & 1 & & & & & & & \\ & & & \ddots & & & & & & \\ & & & & \cos(\theta) & & -\sin(\theta) & & & \\ & & & & & \ddots & & & & \\ & & & & \sin(\theta) & & \cos(\theta) & & & \\ & & & & & & & \ddots & & \\ & & & & & & & & 1 & \\ & & & & & & & & & 1 \\ \end{bmatrix}
\end{align}
</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>s = \sin \theta</math> и <math>c = \cos \theta</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>\dfrac{a_{jj}-a_{kk}}{2a_{jk}}=\dfrac{c^2-s^2}{2sc}=\dfrac{\cos2\theta}{\sin2\theta}=\operatorname{ctg}2\theta\equiv\tau</math>

Положим <math>tg\theta=t=\dfrac{s}{c}</math>. Тогда <math>t^2+2t\tau-1=0</math>.

Решая квадратное уравнение, получим:
<math>t=\dfrac{\operatorname{sign}\tau}{\left|\tau\right|+\sqrt{1+\tau^2}}, c=\dfrac{1}{\sqrt{1+t^2}}, s=t\cdot c.</math>

==Вычислительное ядро алгоритма==
Вычислительное ядро алгоритма составляют вычисления элементов матрицы <math>A</math> в процессе применения матрицы поворота <math>J</math> :

1. Вычисления элементов <math>a_{jl}^{(i+1)} = a_{lj}^{(i+1)}</math> и <math>a_{kl}^{(i+1)} = a_{lk}^{(i+1)}</math> (каждое <math>(n-2)</math> раз):

<math>\begin{align}
a_{jl}^{(i+1)} = a_{lj}^{(i+1)} = c \, a_{jl}^{(i)} - s \, a_{kl}^{(i)}, l \ne j,k;\\
a_{kl}^{(i+1)} = a_{lk}^{(i+1)} = s \, a_{jl}^{(i)} + c \, a_{kl}^{(i)}, l \ne j,k.
\end{align}</math>

2. Вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>:

<math>\begin{align}
a_{jj}^{(i+1)} &= c^2\, a_{jj}^{(i)} - 2\, s c \,a_{jk}^{(i)} + s^2\, a_{kk}^{(i)}; \\
a_{kk}^{(i+1)} &= s^2 \,a_{jj}^{(i)} + 2 s c\, a_{jk}^{(i)} + c^2 \, a_{kk}^{(i)}.
\end{align}</math>

== Макроструктура алгоритма ==
Макроструктуру алгоритма можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246, алгоритм 5.6)</ref>:

repeat
выбрать пару индексов j, k
обратиться к процедуре JacobiRotation(A,j,k)
пока А не станет достаточно близка к диагональной матрице

==Схема реализации последовательного алгоритма==
В классическом алгоритме Якоби для обнуления на текущей итерации выбирался наибольший элемент <math>a_{jk}</math>. Поиск наибольшего элемента слишком замедляет процесс вычислений (нужно провести поиск среди <math>\dfrac{n^2-n}{2}</math> элементов, прежде чем выполнить вращение стоимостью в <math>O(n)</math> флопов), поэтому для практических вычислений выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

Таким образом, алгоритм можно описать так<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 247, алгоритм 5.8)</ref>:

repeat
for j=1 to n-1
for k=j+1 to n
выполнить процедуру '''''JacobiRotation'''(A, j, k)''
end for
end for
пока A не достаточно близка к диагональной матрице

Процедура '''''JacobiRotation'''(A, j, k)'':

if <math>|a_{jk}|</math> не слишком мал
<math>\begin{align}
\tau &= \frac{a_{jj}-a_{kk}}{2\,a_{jk}} \\
t &= \frac{sign(\tau)}{|\tau|+\sqrt{1+\tau^2}} \\
c &= \frac{1}{\sqrt{1+t^2}} \\
s &= c\cdot t \\
A &= J_i^T\cdot A\cdot J_i, \qquad
J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}
</math>
end if
==Последовательная сложность алгоритма==
Для одной итерации вычислений собственных значений матрицы порядка <math>n</math> методом Якоби требуется:

Для вычислительного ядра:

*<math>4\,n+6</math> умножений,
*<math>2n</math> сложений.

Для остальной части алгоритма:

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

Умножения и сложения (вычитания) составляют основную часть алгоритма.

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

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

==Информационный граф==
Опишем граф алгоритма аналитически и в виде рисунка.

Граф алгоритма состоит из трёх групп вершин:

1. '''''Calculate c,s''''' — вычисление <math>c, s</math> согласно формулам в [[#Схема реализации последовательного алгоритма|схеме реализации последовательного алгоритма.]]

Аргументы функции:
*<math>a^{(i+1)}_{jj}, a^{(i+1)}_{kk}</math>:
** Первая итерация — элементы входных данных: диагональные элементы матрицы <math>A</math>;
** Последующие — результаты вычислений вершины третьей группы.
* <math>a^{(i+1)}_{jk}</math>
** Первая итерация — элементы входных данных <math>a_{jk}</math>
** Последующие — результаты вычислений вершины четвертой группы.

Результаты выполнения функции являются ''промежуточными данными'' алгоритма.

2. <math>A_{jj}, A_{kk}</math> — вычисление <math>a^{(i+1)}_{jj}, a^{(i+1)}_{kk}</math> согласно формулам в разделе [[#Вычислительное ядро алгоритма|Вычислительное ядро алгоритма]].

Аргументы функции:
* <math>c, s</math> — результаты вычислений вершины второй группы.
* <math>a^{(i)}_{jj}, a^{(i)}_{kk}</math>:
** Первая итерация — элементы входных данных <math>a_{jj}, a_{kk}</math>;
** Последующие — результаты вычислений вершины третьей группы.
* <math>a^{(i)}_{jk}</math>:
** Первая итерация — элементы входных данных <math>a_{jk}</math>;
** Последующие — результаты вычислений вершины четвертой группы.

Результат выполнения функции является ''выходным данным'' алгоритма.

3. <math>A_{jl}, A_{kl}</math> — вычисление <math>a^{(i+1)}_{jl},a^{(i+1)}_{kl},l\ne j,k</math> согласно формулам в разделе [[#Вычислительное ядро алгоритма|Вычислительное ядро алгоритма]].

Аргументы функции:
* <math>c, s</math> — результаты вычислений вершины второй группы.
* <math>a^{(i)}_{jl}, a^{(i)}_{kl}</math>:
** Первая итерация — элементы входных данных <math>a_{jl},l\ne j,k</math>;
** Последующие — результаты вычислений вершины четвертой группы.

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

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

[[File:Jacobi.png|800px|thumb|center|Рисунок 1. Граф алгоритма без отображения входных и выходных данных.]]

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

Для выполнения каждой итерации требуется последовательно выполнить следующие ярусы (для матрицы порядка <math>n</math>):
# Вычислить норму матрицы и сравнить с <math>\epsilon</math> (параллельное вычисление <math>\frac{n(n-1)}{2}</math> умножений, далее последовательно <math>\frac{n(n-1)}{2}-1</math> сложений, <math>1</math> операция взятия квадратного корня, <math>1</math> операция сравнения )

# Вычислить <math>\tau, t, c, s</math> (последовательно всего <math>4</math> умножений, <math>3</math> делений, <math>4</math> сложений (вычитаний), <math>2</math> операции извлечения квадратного корня, <math>1</math> операция сравнения, <math>1</math> операция взятия модуля)

# Поворот матрицы <math>A</math> с параллельным выполнением <math>2(n-2)</math> операций вычисления элементов матрицы <math>a_{jl}^{(i+1)} = a_{lj}^{(i+1)}</math>   и   <math>a_{kl}^{(i+1)} = a_{lk}^{(i+1)}</math>,   <math>m \ne j,k</math>, а также <math>2</math> операций вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>.

Суммарное количество итераций зависит от входных данных и заданного значения погрешности <math>\epsilon</math>. Один цикл (полный проход по внедиагональным элементам) осуществляется за <math>N = \frac{n(n-1)}{2}</math> итераций.

Таким образом, при классификации по высоте ЯПФ метод Якоби относится к алгоритмам со сложностью <math>O(n^2)</math> , а при классификации по ширине ЯПФ — к алгоритмам со сложностью <math>O(n)</math>.

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

1. Плотная матрица <math>A=\{a_{ij}\}, A\in\R^{n\times n}</math>. Дополнительные ограничения:
* <math>A</math> — симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

2. Число двойной точности <math>\epsilon</math>, определяющее допустимый порядок малости внедиагональных элементов.

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

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

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

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

==Свойства алгоритма==
Из существующих алгоритмов вычисления собственных значений симметричной матрицы метод Якоби является самым медленным (в среднем для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 248)</ref>). Его преимущество заключается в том, что он не предполагает первоначального приведения матрицы к трехдиагональной форме. Также метод до сих пор используется на практике для вычисления малых собственных чисел и отвечающих им собственных векторов, так как он делает это с гораздо большей точностью, чем другие методы<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244)</ref>.

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

Метод Якоби не детерминирован, так как является итерационным алгоритмом с выходом по точности: число итераций зависит от входных данных и порогового значения.

=ЧАСТЬ. Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
===Масштабируемость алгоритма===
===Масштабируемость реализации алгоритма===
==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
Библиотека [https://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE] содержит последовательную реализацию алгоритма.

Существует также [http://ieeexplore.ieee.org/document/6310877/ параллельная реализация] метода на платформе CUDA.

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

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

2016-10-26T13:25:35Z

Tameeva.a:

{{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>\frac{n (n + 1)}{2}</math>
| output_data = <math>n</math>
}}

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

=ЧАСТЬ. Свойства и структура алгоритмов=
== Общее описание алгоритма ==

Метод Якоби вычисления собственных значений симметричной матрицы — итерационный алгоритм, названный в честь предложившего его для конкретной матрицы 7 × 7 в 1846 году Карла Густава Якоба Якоби<ref>Jacobi, C.G.J. (1846). «[http://resolver.sub.uni-goettingen.de/purl/?GDZPPN002144522 Über ein leichtes Verfahren, die in der Theorie der Säkularstörungen vorkommenden Gleichungen numerisch aufzulösen]» (German). Crelle's Journal 30: 51–94.</ref>. Исторически старейший метод для решения симметрической проблемы собственных значений получил широкое применение только в 1950-х годах с появлением компьютеров. Преимуществом метода является более точное вычисление малых собственных значений по сравнению с конкурирующими алгоритмами.

Суть алгоритма — приведение симметрической матрицы к диагональной с собственными значениями на диагонали путем вращения.

==Математическое описание алгоритма<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>==
Исходные данные: симметрическая матрица <math>A=\{a_{ij}\}</math>.

Вычисляемые данные: диагональная матрица <math>\Lambda=\{\lambda_{ii}\}</math>. Диагональные элементы <math>\Lambda</math> — собственные значения матрицы <math>A</math>, столбцы — приближенные собственные вектора матрицы <math>A</math>.

По заданной матрице <math>A=A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,\ldots, A_m</math>, сходящихся к <math>\Lambda</math>.

<math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math> J_i</math> — ортогональная матрица, называемая вращением Якоби.

Матрица <math>J_i</math> выбирается так, чтобы обнулить элементы <math>(j,k)</math> и <math>(k,j)</math> матрицы <math>A_{i+1}</math>:

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

<math>
\begin{align}
J_i = R(j,k,\theta) = \begin{matrix} \\ \\ \\ j \\ \\ k \\ \\ \\ \\ \end{matrix} \begin{bmatrix} & 1 & & & & & & & & \\ & & 1 & & & & & & & \\ & & & \ddots & & & & & & \\ & & & & \cos(\theta) & & -\sin(\theta) & & & \\ & & & & & \ddots & & & & \\ & & & & \sin(\theta) & & \cos(\theta) & & & \\ & & & & & & & \ddots & & \\ & & & & & & & & 1 & \\ & & & & & & & & & 1 \\ \end{bmatrix}
\end{align}
</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>s = \sin \theta</math> и <math>c = \cos \theta</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>\dfrac{a_{jj}-a_{kk}}{2a_{jk}}=\dfrac{c^2-s^2}{2sc}=\dfrac{\cos2\theta}{\sin2\theta}=\operatorname{ctg}2\theta\equiv\tau</math>

Положим <math>tg\theta=t=\dfrac{s}{c}</math>. Тогда <math>t^2+2t\tau-1=0</math>.

Решая квадратное уравнение, получим:
<math>t=\dfrac{\operatorname{sign}\tau}{\left|\tau\right|+\sqrt{1+\tau^2}}, c=\dfrac{1}{\sqrt{1+t^2}}, s=t\cdot c.</math>

==Вычислительное ядро алгоритма==
Вычислительное ядро алгоритма составляют вычисления элементов матрицы <math>A</math> в процессе применения матрицы поворота <math>J</math> :

1. Вычисления элементов <math>a_{jl}^{(i+1)} = a_{lj}^{(i+1)}</math> и <math>a_{kl}^{(i+1)} = a_{lk}^{(i+1)}</math> (каждое <math>(n-2)</math> раз):

<math>\begin{align}
a_{jl}^{(i+1)} = a_{lj}^{(i+1)} = c \, a_{jl}^{(i)} - s \, a_{kl}^{(i)}, l \ne j,k;\\
a_{kl}^{(i+1)} = a_{lk}^{(i+1)} = s \, a_{jl}^{(i)} + c \, a_{kl}^{(i)}, l \ne j,k.
\end{align}</math>

2. Вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>:

<math>\begin{align}
a_{jj}^{(i+1)} &= c^2\, a_{jj}^{(i)} - 2\, s c \,a_{jk}^{(i)} + s^2\, a_{kk}^{(i)}; \\
a_{kk}^{(i+1)} &= s^2 \,a_{jj}^{(i)} + 2 s c\, a_{jk}^{(i)} + c^2 \, a_{kk}^{(i)}.
\end{align}</math>

== Макроструктура алгоритма ==
Макроструктуру алгоритма можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246, алгоритм 5.6)</ref>:

repeat
выбрать пару индексов j, k
обратиться к процедуре JacobiRotation(A,j,k)
пока А не станет достаточно близка к диагональной матрице

==Схема реализации последовательного алгоритма==
В классическом алгоритме Якоби для обнуления на текущей итерации выбирался наибольший элемент <math>a_{jk}</math>. Поиск наибольшего элемента слишком замедляет процесс вычислений (нужно провести поиск среди <math>\dfrac{n^2-n}{2}</math> элементов, прежде чем выполнить вращение стоимостью в <math>O(n)</math> флопов), поэтому для практических вычислений выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

Таким образом, алгоритм можно описать так<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 247, алгоритм 5.8)</ref>:

repeat
for j=1 to n-1
for k=j+1 to n
выполнить процедуру '''''JacobiRotation'''(A, j, k)''
end for
end for
пока A не достаточно близка к диагональной матрице

Процедура '''''JacobiRotation'''(A, j, k)'':

if <math>|a_{jk}|</math> не слишком мал
<math>\begin{align}
\tau &= \frac{a_{jj}-a_{kk}}{2\,a_{jk}} \\
t &= \frac{sign(\tau)}{|\tau|+\sqrt{1+\tau^2}} \\
c &= \frac{1}{\sqrt{1+t^2}} \\
s &= c\cdot t \\
A &= J_i^T\cdot A\cdot J_i, \qquad
J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}
</math>
end if
==Последовательная сложность алгоритма==
Для одной итерации вычислений собственных значений матрицы порядка <math>n</math> методом Якоби требуется:

Для вычислительного ядра:

*<math>4\,n+6</math> умножений,
*<math>2n</math> сложений.

Для остальной части алгоритма:

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

Умножения и сложения (вычитания) составляют основную часть алгоритма.

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

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

==Информационный граф==
Опишем граф алгоритма аналитически и в виде рисунка.

Граф алгоритма состоит из четырёх групп вершин:

1. '''''Off>eps''''' — сравнение матрицы с диагональной: вычисление нормы наддиагональных элементов <math>of\!f(A)=\sqrt{\sum\limits_{1 \le j < k \le n} a_{jk}^2}</math> и сравнение с <math>\epsilon</math>.

Аргументы функции:
*<math>a_{jk}</math>
** Первая итерация — элементы входных данных: наддиагональные элементы матрицы <math>A</math>;
** Последующие — результаты вычислений вершины четвертой группы (<math>a^{i+1}_{jl},a^{i+1}_{kl},l\ne j,k</math>);
*<math>\epsilon</math> — элемент входных данных.

Результат выполнения функции является ''промежуточным данным'' алгоритма.

2. '''''Calculate c,s''''' — вычисление <math>c, s</math> согласно формулам в [[#Схема реализации последовательного алгоритма|схеме реализации последовательного алгоритма.]]

Аргументы функции:
*<math>a^{(i+1)}_{jj}, a^{(i+1)}_{kk}</math>:
** Первая итерация — элементы входных данных: диагональные элементы матрицы <math>A</math>;
** Последующие — результаты вычислений вершины третьей группы.
* <math>a^{(i+1)}_{jk}</math>
** Первая итерация — элементы входных данных <math>a_{jk}</math>
** Последующие — результаты вычислений вершины четвертой группы.

Результаты выполнения функции являются ''промежуточными данными'' алгоритма.

3. <math>A_{jj}, A_{kk}</math> — вычисление <math>a^{(i+1)}_{jj}, a^{(i+1)}_{kk}</math> согласно формулам в разделе [[#Вычислительное ядро алгоритма|Вычислительное ядро алгоритма]].

Аргументы функции:
* <math>c, s</math> — результаты вычислений вершины второй группы.
* <math>a^{(i)}_{jj}, a^{(i)}_{kk}</math>:
** Первая итерация — элементы входных данных <math>a_{jj}, a_{kk}</math>;
** Последующие — результаты вычислений вершины третьей группы.
* <math>a^{(i)}_{jk}</math>:
** Первая итерация — элементы входных данных <math>a_{jk}</math>;
** Последующие — результаты вычислений вершины четвертой группы.

Результат выполнения функции является ''выходным данным'' алгоритма.

4. <math>A_{jl}, A_{kl}</math> — вычисление <math>a^{(i+1)}_{jl},a^{(i+1)}_{kl},l\ne j,k</math> согласно формулам в разделе [[#Вычислительное ядро алгоритма|Вычислительное ядро алгоритма]].

Аргументы функции:
* <math>c, s</math> — результаты вычислений вершины второй группы.
* <math>a^{(i)}_{jl}, a^{(i)}_{kl}</math>:
** Первая итерация — элементы входных данных <math>a_{jl},l\ne j,k</math>;
** Последующие — результаты вычислений вершины четвертой группы.

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

Описанный граф для четырех итераций представлен на рисунке. К графу добавлены вершины, соответствующие входным (желтый цвет) и выходным (фиолетовый цвет) данным. Дублирующие друг друга дуги даны как одна.
[[File:Jacobi.png|800px|thumb|center|Рисунок 1. Граф алгоритма с отображением входных и выходных данных.]]

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

Для выполнения каждой итерации требуется последовательно выполнить следующие ярусы (для матрицы порядка <math>n</math>):
# Вычислить норму матрицы и сравнить с <math>\epsilon</math> (параллельное вычисление <math>\frac{n(n-1)}{2}</math> умножений, далее последовательно <math>\frac{n(n-1)}{2}-1</math> сложений, <math>1</math> операция взятия квадратного корня, <math>1</math> операция сравнения )

# Вычислить <math>\tau, t, c, s</math> (последовательно всего <math>4</math> умножений, <math>3</math> делений, <math>4</math> сложений (вычитаний), <math>2</math> операции извлечения квадратного корня, <math>1</math> операция сравнения, <math>1</math> операция взятия модуля)

# Поворот матрицы <math>A</math> с параллельным выполнением <math>2(n-2)</math> операций вычисления элементов матрицы <math>a_{jl}^{(i+1)} = a_{lj}^{(i+1)}</math>   и   <math>a_{kl}^{(i+1)} = a_{lk}^{(i+1)}</math>,   <math>m \ne j,k</math>, а также <math>2</math> операций вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>.

Суммарное количество итераций зависит от входных данных и заданного значения погрешности <math>\epsilon</math>. Один цикл (полный проход по внедиагональным элементам) осуществляется за <math>N = \frac{n(n-1)}{2}</math> итераций.

Таким образом, при классификации по высоте ЯПФ метод Якоби относится к алгоритмам со сложностью <math>O(n^2)</math> , а при классификации по ширине ЯПФ — к алгоритмам со сложностью <math>O(n)</math>.

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

1. Плотная матрица <math>A=\{a_{ij}\}, A\in\R^{n\times n}</math>. Дополнительные ограничения:
* <math>A</math> — симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

2. Число двойной точности <math>\epsilon</math>, определяющее допустимый порядок малости внедиагональных элементов.

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

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

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

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

==Свойства алгоритма==
Из существующих алгоритмов вычисления собственных значений симметричной матрицы метод Якоби является самым медленным (в среднем для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 248)</ref>). Его преимущество заключается в том, что он не предполагает первоначального приведения матрицы к трехдиагональной форме. Также метод до сих пор используется на практике для вычисления малых собственных чисел и отвечающих им собственных векторов, так как он делает это с гораздо большей точностью, чем другие методы<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244)</ref>.

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

Метод Якоби не детерминирован, так как является итерационным алгоритмом с выходом по точности: число итераций зависит от входных данных и порогового значения.

Дуги информационного графа, исходящие из вершин, соответствующих вычислениям значений <math>c</math> и <math>s</math>, образуют пучки рассылок линейной мощности.

=ЧАСТЬ. Программная реализация алгоритма=
==Особенности реализации последовательного алгоритма==
==Локальность данных и вычислений==
==Возможные способы и особенности параллельной реализации алгоритма==
==Масштабируемость алгоритма и его реализации==
===Масштабируемость алгоритма===
===Масштабируемость реализации алгоритма===
==Динамические характеристики и эффективность реализации алгоритма==
==Выводы для классов архитектур==
==Существующие реализации алгоритма==
Библиотека [https://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE] содержит последовательную реализацию алгоритма.

Существует также [http://ieeexplore.ieee.org/document/6310877/ параллельная реализация] метода на платформе CUDA.

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

Участница:Tameeva.a/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-15T20:09:38Z

Tameeva.a: /* Информационный граф */

{{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>\frac{n (n + 1)}{2}</math>
| output_data = <math>n</math>
}}

Основные авторы описания: [[Участник:Tameeva.a|А. Тамеева]], [[Участник:AKukhtinov|А. Кухтинов]].

=ЧАСТЬ. Свойства и структура алгоритмов=
== Общее описание алгоритма ==

Метод Якоби вычисления собственных значений симметричной матрицы — итерационный алгоритм, названный в честь предложившего его для конкретной матрицы 7 × 7 в 1846 году Карла Густава Якоба Якоби<ref>Jacobi, C.G.J. (1846). «[http://resolver.sub.uni-goettingen.de/purl/?GDZPPN002144522 Über ein leichtes Verfahren, die in der Theorie der Säkularstörungen vorkommenden Gleichungen numerisch aufzulösen]» (German). Crelle's Journal 30: 51–94.</ref>. Исторически старейший метод для решения симметрической проблемы собственных значений получил широкое применение только в 1950-х годах с появлением компьютеров. Преимуществом метода является более точное вычисление малых собственных значений по сравнению с конкурирующими алгоритмами.

Суть алгоритма — приведение симметрической матрицы к диагональной с собственными значениями на диагонали путем вращения.

== Математическое описание алгоритма<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>==
Исходные данные: симметрическая матрица <math>A=\{a_{ij}\}</math>.

Вычисляемые данные: диагональная матрица <math>\Lambda=\{\lambda_{ii}\}</math>. Диагональные элементы <math>\Lambda</math> — собственные значения матрицы <math>A</math>, столбцы — приближенные собственные вектора матрицы <math>A</math>.

По заданной матрице <math>A=A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,\ldots, A_m</math>, сходящихся к <math>\Lambda</math>.

<math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math> J_i</math> — ортогональная матрица, называемая вращением Якоби.

Матрица <math>J_i</math> выбирается так, чтобы обнулить элементы <math>(j,k)</math> и <math>(k,j)</math> матрицы <math>A_{i+1}</math>:

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

<math>
\begin{align}
J_i = R(j,k,\theta) = \begin{matrix} \\ \\ \\ j \\ \\ k \\ \\ \\ \\ \end{matrix} \begin{bmatrix} & 1 & & & & & & & & \\ & & 1 & & & & & & & \\ & & & \ddots & & & & & & \\ & & & & \cos(\theta) & & -\sin(\theta) & & & \\ & & & & & \ddots & & & & \\ & & & & \sin(\theta) & & \cos(\theta) & & & \\ & & & & & & & \ddots & & \\ & & & & & & & & 1 & \\ & & & & & & & & & 1 \\ \end{bmatrix}
\end{align}
</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>s = \sin \theta</math> и <math>c = \cos \theta</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>\dfrac{a_{jj}-a_{kk}}{2a_{jk}}=\dfrac{c^2-s^2}{2sc}=\dfrac{\cos2\theta}{\sin2\theta}=\operatorname{ctg}2\theta\equiv\tau</math>

Положим <math>tg\theta=t=\dfrac{s}{c}</math>. Тогда <math>t^2+2t\tau-1=0</math>.

Решая квадратное уравнение, получим:
<math>t=\dfrac{\operatorname{sign}\tau}{\left|\tau\right|+\sqrt{1+\tau^2}}, c=\dfrac{1}{\sqrt{1+t^2}}, s=t\cdot c.</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма составляют вычисления элементов матрицы <math>A</math> в процессе применения матрицы поворота <math>J</math> :

1. Вычисления элементов <math>a_{jl}^{(i+1)} = a_{lj}^{(i+1)}</math> и <math>a_{kl}^{(i+1)} = a_{lk}^{(i+1)}</math> (каждое <math>(n-2)</math> раз):

<math>\begin{align}
a_{jl}^{(i+1)} = a_{lj}^{(i+1)} = c \, a_{jl}^{(i)} - s \, a_{kl}^{(i)}, l \ne j,k;\\
a_{kl}^{(i+1)} = a_{lk}^{(i+1)} = s \, a_{jl}^{(i)} + c \, a_{kl}^{(i)}, l \ne j,k.
\end{align}</math>

2. Вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>:

<math>\begin{align}
a_{jj}^{(i+1)} &= c^2\, a_{jj}^{(i)} - 2\, s c \,a_{jk}^{(i)} + s^2\, a_{kk}^{(i)}; \\
a_{kk}^{(i+1)} &= s^2 \,a_{jj}^{(i)} + 2 s c\, a_{jk}^{(i)} + c^2 \, a_{kk}^{(i)}.
\end{align}</math>

== Макроструктура алгоритма ==
Макроструктуру алгоритма можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246, алгоритм 5.6)</ref>:

repeat
выбрать пару индексов j, k
обратиться к процедуре JacobiRotation(A,j,k)
пока А не станет достаточно близка к диагональной матрице

==Схема реализации последовательного алгоритма==
В классическом алгоритме Якоби для обнуления на текущей итерации выбирался наибольший элемент <math>a_{jk}</math>. Поиск наибольшего элемента слишком замедляет процесс вычислений (нужно провести поиск среди <math>\dfrac{n^2-n}{2}</math> элементов, прежде чем выполнить вращение стоимостью в <math>O(n)</math> флопов), поэтому для практических вычислений выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

Таким образом, алгоритм можно описать так<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 247, алгоритм 5.8)</ref>:

repeat
for j=1 to n-1
for k=j+1 to n
выполнить процедуру '''''JacobiRotation'''(A, j, k)''
end for
end for
пока A не достаточно близка к диагональной матрице

Процедура '''''JacobiRotation'''(A, j, k)'':

if <math>|a_{jk}|</math> не слишком мал
<math>\begin{align}
\tau &= \frac{a_{jj}-a_{kk}}{2\,a_{jk}} \\
t &= \frac{sign(\tau)}{|\tau|+\sqrt{1+\tau^2}} \\
c &= \frac{1}{\sqrt{1+t^2}} \\
s &= c\cdot t \\
A &= J_i^T\cdot A\cdot J_i, \qquad
J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}
</math>
end if
==Последовательная сложность алгоритма==
Для одной итерации вычислений собственных значений матрицы порядка <math>n</math> методом Якоби требуется:

Для вычислительного ядра:

*<math>4\,n+6</math> умножений,
*<math>2n</math> сложений.

Для остальной части алгоритма:

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

Умножения и сложения (вычитания) составляют основную часть алгоритма.

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

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

==Информационный граф==
Опишем граф алгоритма аналитически и в виде рисунка.

Граф алгоритма состоит из четырёх групп вершин:

1. '''''Off>eps''''' — сравнение матрицы с диагональной: вычисление нормы наддиагональных элементов <math>of\!f(A)=\sqrt{\sum\limits_{1 \le j < k \le n} a_{jk}^2}</math> и сравнение с <math>\epsilon</math>.

Аргументы функции:
*<math>a_{jk}</math>
** Первая итерация — элементы входных данных: наддиагональные элементы матрицы <math>A</math>;
** Последующие — результаты вычислений вершины четвертой группы (<math>a^{i+1}_{jl},a^{i+1}_{kl},l\ne j,k</math>);
*<math>\epsilon</math> — элемент входных данных.

Результат выполнения функции является ''промежуточным данным'' алгоритма.

2. '''''Calculate c,s''''' — вычисление <math>c, s</math> согласно формулам в [[#Схема реализации последовательного алгоритма|схеме реализации последовательного алгоритма.]]

Аргументы функции:
*<math>a^{(i+1)}_{jj}, a^{(i+1)}_{kk}</math>:
** Первая итерация — элементы входных данных: диагональные элементы матрицы <math>A</math>;
** Последующие — результаты вычислений вершины третьей группы.
* <math>a^{(i+1)}_{jk}</math>
** Первая итерация — элементы входных данных <math>a_{jk}</math>
** Последующие — результаты вычислений вершины четвертой группы.

Результаты выполнения функции являются ''промежуточными данными'' алгоритма.

3. <math>A_{jj}, A_{kk}</math> — вычисление <math>a^{(i+1)}_{jj}, a^{(i+1)}_{kk}</math> согласно формулам в разделе [[#Вычислительное ядро алгоритма|Вычислительное ядро алгоритма]].

Аргументы функции:
* <math>c, s</math> — результаты вычислений вершины второй группы.
* <math>a^{(i)}_{jj}, a^{(i)}_{kk}</math>:
** Первая итерация — элементы входных данных <math>a_{jj}, a_{kk}</math>;
** Последующие — результаты вычислений вершины третьей группы.
* <math>a^{(i)}_{jk}</math>:
** Первая итерация — элементы входных данных <math>a_{jk}</math>;
** Последующие — результаты вычислений вершины четвертой группы.

Результат выполнения функции является ''выходным данным'' алгоритма.

4. <math>A_{jl}, A_{kl}</math> — вычисление <math>a^{(i+1)}_{jl},a^{(i+1)}_{kl},l\ne j,k</math> согласно формулам в разделе [[#Вычислительное ядро алгоритма|Вычислительное ядро алгоритма]].

Аргументы функции:
* <math>c, s</math> — результаты вычислений вершины второй группы.
* <math>a^{(i)}_{jl}, a^{(i)}_{kl}</math>:
** Первая итерация — элементы входных данных <math>a_{jl},l\ne j,k</math>;
** Последующие — результаты вычислений вершины четвертой группы.

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

Описанный граф для четырех итераций представлен на рисунке. К графу добавлены вершины, соответствующие входным (желтый цвет) и выходным (фиолетовый цвет) данным. Дублирующие друг друга дуги даны как одна.
[[File:Jacobi.png|800px|thumb|center|Рисунок 1. Граф алгоритма с отображением входных и выходных данных.]]

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

Для выполнения каждой итерации требуется последовательно выполнить следующие ярусы (для матрицы порядка <math>n</math>):
# Вычислить норму матрицы и сравнить с <math>\epsilon</math> (параллельное вычисление <math>\frac{n(n-1)}{2}</math> умножений, далее последовательно <math>\frac{n(n-1)}{2}-1</math> сложений, <math>1</math> операция взятия квадратного корня, <math>1</math> операция сравнения )

# Вычислить <math>\tau, t, c, s</math> (последовательно всего <math>4</math> умножений, <math>3</math> делений, <math>4</math> сложений (вычитаний), <math>2</math> операции извлечения квадратного корня, <math>1</math> операция сравнения, <math>1</math> операция взятия модуля)

# Поворот матрицы <math>A</math> с параллельным выполнением <math>2(n-2)</math> операций вычисления элементов матрицы <math>a_{jl}^{(i+1)} = a_{lj}^{(i+1)}</math>   и   <math>a_{kl}^{(i+1)} = a_{lk}^{(i+1)}</math>,   <math>m \ne j,k</math>, а также <math>2</math> операций вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>.

Суммарное количество итераций зависит от входных данных и заданного значения погрешности <math>\epsilon</math>. Один цикл (полный проход по внедиагональным элементам) осуществляется за <math>N = \frac{n(n-1)}{2}</math> итераций.

Таким образом, при классификации по высоте ЯПФ метод Якоби относится к алгоритмам со сложностью <math>O(n^2)</math> , а при классификации по ширине ЯПФ — к алгоритмам со сложностью <math>O(n)</math>.

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

1. Плотная матрица <math>A=\{a_{ij}\}, A\in\R^{n\times n}</math>. Дополнительные ограничения:
* <math>A</math> — симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

2. Число двойной точности <math>\epsilon</math>, определяющее допустимый порядок малости внедиагональных элементов.

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

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

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

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

==Свойства алгоритма==
Из существующих алгоритмов вычисления собственных значений симметричной матрицы метод Якоби является самым медленным (в среднем для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 248)</ref>). Его преимущество заключается в том, что он не предполагает первоначального приведения матрицы к трехдиагональной форме. Также метод до сих пор используется на практике для вычисления малых собственных чисел и отвечающих им собственных векторов, так как он делает это с гораздо большей точностью, чем другие методы<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244)</ref>.

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

Метод Якоби не детерминирован, так как является итерационным алгоритмом с выходом по точности: число итераций зависит от входных данных и порогового значения.

Дуги информационного графа, исходящие из вершин, соответствующих вычислениям значений <math>c</math> и <math>s</math>, образуют пучки рассылок линейной мощности.

=ЧАСТЬ. Программная реализация алгоритма=
==Масштабируемость алгоритма и его реализации==
==Существующие реализации алгоритма==
Библиотека [https://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE] содержит последовательную реализацию алгоритма.

Существует также [http://ieeexplore.ieee.org/document/6310877/ параллельная реализация] метода на платформе CUDA.

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

Участница:Tameeva.a/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-15T19:57:39Z

Tameeva.a: /* Информационный граф */

{{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>\frac{n (n + 1)}{2}</math>
| output_data = <math>n</math>
}}

Основные авторы описания: [[Участник:Tameeva.a|А. Тамеева]], [[Участник:AKukhtinov|А. Кухтинов]].

=ЧАСТЬ. Свойства и структура алгоритмов=
== Общее описание алгоритма ==

Метод Якоби вычисления собственных значений симметричной матрицы — итерационный алгоритм, названный в честь предложившего его для конкретной матрицы 7 × 7 в 1846 году Карла Густава Якоба Якоби<ref>Jacobi, C.G.J. (1846). «[http://resolver.sub.uni-goettingen.de/purl/?GDZPPN002144522 Über ein leichtes Verfahren, die in der Theorie der Säkularstörungen vorkommenden Gleichungen numerisch aufzulösen]» (German). Crelle's Journal 30: 51–94.</ref>. Исторически старейший метод для решения симметрической проблемы собственных значений получил широкое применение только в 1950-х годах с появлением компьютеров. Преимуществом метода является более точное вычисление малых собственных значений по сравнению с конкурирующими алгоритмами.

Суть алгоритма — приведение симметрической матрицы к диагональной с собственными значениями на диагонали путем вращения.

== Математическое описание алгоритма<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>==
Исходные данные: симметрическая матрица <math>A=\{a_{ij}\}</math>.

Вычисляемые данные: диагональная матрица <math>\Lambda=\{\lambda_{ii}\}</math>. Диагональные элементы <math>\Lambda</math> — собственные значения матрицы <math>A</math>, столбцы — приближенные собственные вектора матрицы <math>A</math>.

По заданной матрице <math>A=A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,\ldots, A_m</math>, сходящихся к <math>\Lambda</math>.

<math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math> J_i</math> — ортогональная матрица, называемая вращением Якоби.

Матрица <math>J_i</math> выбирается так, чтобы обнулить элементы <math>(j,k)</math> и <math>(k,j)</math> матрицы <math>A_{i+1}</math>:

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

<math>
\begin{align}
J_i = R(j,k,\theta) = \begin{matrix} \\ \\ \\ j \\ \\ k \\ \\ \\ \\ \end{matrix} \begin{bmatrix} & 1 & & & & & & & & \\ & & 1 & & & & & & & \\ & & & \ddots & & & & & & \\ & & & & \cos(\theta) & & -\sin(\theta) & & & \\ & & & & & \ddots & & & & \\ & & & & \sin(\theta) & & \cos(\theta) & & & \\ & & & & & & & \ddots & & \\ & & & & & & & & 1 & \\ & & & & & & & & & 1 \\ \end{bmatrix}
\end{align}
</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>s = \sin \theta</math> и <math>c = \cos \theta</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>\dfrac{a_{jj}-a_{kk}}{2a_{jk}}=\dfrac{c^2-s^2}{2sc}=\dfrac{\cos2\theta}{\sin2\theta}=\operatorname{ctg}2\theta\equiv\tau</math>

Положим <math>tg\theta=t=\dfrac{s}{c}</math>. Тогда <math>t^2+2t\tau-1=0</math>.

Решая квадратное уравнение, получим:
<math>t=\dfrac{\operatorname{sign}\tau}{\left|\tau\right|+\sqrt{1+\tau^2}}, c=\dfrac{1}{\sqrt{1+t^2}}, s=t\cdot c.</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма составляют вычисления элементов матрицы <math>A</math> в процессе применения матрицы поворота <math>J</math> :

1. Вычисления элементов <math>a_{jl}^{(i+1)} = a_{lj}^{(i+1)}</math> и <math>a_{kl}^{(i+1)} = a_{lk}^{(i+1)}</math> (каждое <math>(n-2)</math> раз):

<math>\begin{align}
a_{jl}^{(i+1)} = a_{lj}^{(i+1)} = c \, a_{jl}^{(i)} - s \, a_{kl}^{(i)}, l \ne j,k;\\
a_{kl}^{(i+1)} = a_{lk}^{(i+1)} = s \, a_{jl}^{(i)} + c \, a_{kl}^{(i)}, l \ne j,k.
\end{align}</math>

2. Вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>:

<math>\begin{align}
a_{jj}^{(i+1)} &= c^2\, a_{jj}^{(i)} - 2\, s c \,a_{jk}^{(i)} + s^2\, a_{kk}^{(i)}; \\
a_{kk}^{(i+1)} &= s^2 \,a_{jj}^{(i)} + 2 s c\, a_{jk}^{(i)} + c^2 \, a_{kk}^{(i)}.
\end{align}</math>

== Макроструктура алгоритма ==
Макроструктуру алгоритма можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246, алгоритм 5.6)</ref>:

repeat
выбрать пару индексов j, k
обратиться к процедуре JacobiRotation(A,j,k)
пока А не станет достаточно близка к диагональной матрице

==Схема реализации последовательного алгоритма==
В классическом алгоритме Якоби для обнуления на текущей итерации выбирался наибольший элемент <math>a_{jk}</math>. Поиск наибольшего элемента слишком замедляет процесс вычислений (нужно провести поиск среди <math>\dfrac{n^2-n}{2}</math> элементов, прежде чем выполнить вращение стоимостью в <math>O(n)</math> флопов), поэтому для практических вычислений выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

Таким образом, алгоритм можно описать так<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 247, алгоритм 5.8)</ref>:

repeat
for j=1 to n-1
for k=j+1 to n
выполнить процедуру '''''JacobiRotation'''(A, j, k)''
end for
end for
пока A не достаточно близка к диагональной матрице

Процедура '''''JacobiRotation'''(A, j, k)'':

if <math>|a_{jk}|</math> не слишком мал
<math>\begin{align}
\tau &= \frac{a_{jj}-a_{kk}}{2\,a_{jk}} \\
t &= \frac{sign(\tau)}{|\tau|+\sqrt{1+\tau^2}} \\
c &= \frac{1}{\sqrt{1+t^2}} \\
s &= c\cdot t \\
A &= J_i^T\cdot A\cdot J_i, \qquad
J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}
</math>
end if
==Последовательная сложность алгоритма==
Для одной итерации вычислений собственных значений матрицы порядка <math>n</math> методом Якоби требуется:

Для вычислительного ядра:

*<math>4\,n+6</math> умножений,
*<math>2n</math> сложений.

Для остальной части алгоритма:

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

Умножения и сложения (вычитания) составляют основную часть алгоритма.

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

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

==Информационный граф==
Опишем граф алгоритма аналитически и в виде рисунка.

Граф алгоритма состоит из четырёх групп вершин:

1. '''''Off>eps''''' — сравнение матрицы с диагональной: вычисление нормы наддиагональных элементов <math>of\!f(A)=\sqrt{\sum\limits_{1 \le j < k \le n} a_{jk}^2}</math> и сравнение с <math>\epsilon</math>.

Аргументы функции:
*<math>a_{jk}</math>
** Первая итерация — элементы входных данных: наддиагональные элементы матрицы <math>A</math>;
** Последующие — результаты вычислений вершины четвертой группы (<math>a^{i+1}_{jl},a^{i+1}_{kl},l\ne j,k</math>);
*<math>\epsilon</math> — элемент входных данных.

Результат выполнения функции является ''промежуточным данным'' алгоритма.

2. '''''Calculate c,s''''' — вычисление <math>c, s</math> согласно формулам в [[#Схема реализации последовательного алгоритма|схеме реализации последовательного алгоритма.]]

Аргументы функции:
*<math>a^{i+1}_{jj}, a^{i+1}_{kk}</math>:
** Первая итерация — элементы входных данных: диагональные элементы матрицы <math>A</math>;
** Последующие — результаты вычислений вершины третьей группы.
* <math>a^{i+1}_{jk}</math>
** Первая итерация — элементы входных данных <math>a_{jk}</math>
** Последующие — результаты вычислений вершины четвертой группы.

Результаты выполнения функции являются ''промежуточными данными'' алгоритма.

3. <math>A_{jj}, A_{kk}</math> — вычисление <math>a^{i+1}_{jj}, a^{i+1}_{kk}</math> согласно формулам в разделе [[#Вычислительное ядро алгоритма|Вычислительное ядро алгоритма]].

Аргументы функции:
* <math>c, s</math> — результаты вычислений вершины второй группы.
* <math>a^{i}_{jj}, a^{i}_{kk}</math>:
** Первая итерация — элементы входных данных <math>a_{jj}, a_{kk}</math>;
** Последующие — результаты вычислений вершины третьей группы <math>a^{i}_{jj}, a^{i}_{kk}</math>.
* <math>a^{i}_{jk}</math>:
** Первая итерация — элементы входных данных <math>a_{jk}</math>;
** Последующие — результаты вычислений вершины четвертой группы.

Результат выполнения функции является ''выходным данным'' алгоритма.

4. <math>A_{jl}, A_{kl}</math> — вычисление <math>a^{i+1}_{jl},a^{i+1}_{kl},l\ne j,k</math> согласно формулам в разделе [[#Вычислительное ядро алгоритма|Вычислительное ядро алгоритма]].

Аргументы функции:
* <math>c, s</math> — результаты вычислений вершины второй группы.
* <math>a^{(i)}_{jl}, a^{(i)}_{kl}</math>:
** Первая итерация — элементы входных данных <math>a_{jl},l\ne j,k</math>;
** Последующие — результаты вычислений вершины четвертой группы.

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

Описанный граф для четырех итераций представлен на рисунке. К графу добавлены вершины, соответствующие входным (желтый цвет) и выходным (фиолетовый цвет) данным. Дублирующие друг друга дуги даны как одна.
[[File:Jacobi.png|800px|thumb|center|Рисунок 1. Граф алгоритма с отображением входных и выходных данных.]]

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

Для выполнения каждой итерации требуется последовательно выполнить следующие ярусы (для матрицы порядка <math>n</math>):
# Вычислить норму матрицы и сравнить с <math>\epsilon</math> (параллельное вычисление <math>\frac{n(n-1)}{2}</math> умножений, далее последовательно <math>\frac{n(n-1)}{2}-1</math> сложений, <math>1</math> операция взятия квадратного корня, <math>1</math> операция сравнения )

# Вычислить <math>\tau, t, c, s</math> (последовательно всего <math>4</math> умножений, <math>3</math> делений, <math>4</math> сложений (вычитаний), <math>2</math> операции извлечения квадратного корня, <math>1</math> операция сравнения, <math>1</math> операция взятия модуля)

# Поворот матрицы <math>A</math> с параллельным выполнением <math>2(n-2)</math> операций вычисления элементов матрицы <math>a_{jl}^{(i+1)} = a_{lj}^{(i+1)}</math>   и   <math>a_{kl}^{(i+1)} = a_{lk}^{(i+1)}</math>,   <math>m \ne j,k</math>, а также <math>2</math> операций вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>.

Суммарное количество итераций зависит от входных данных и заданного значения погрешности <math>\epsilon</math>. Один цикл (полный проход по внедиагональным элементам) осуществляется за <math>N = \frac{n(n-1)}{2}</math> итераций.

Таким образом, при классификации по высоте ЯПФ метод Якоби относится к алгоритмам со сложностью <math>O(n^2)</math> , а при классификации по ширине ЯПФ — к алгоритмам со сложностью <math>O(n)</math>.

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

1. Плотная матрица <math>A=\{a_{ij}\}, A\in\R^{n\times n}</math>. Дополнительные ограничения:
* <math>A</math> — симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

2. Число двойной точности <math>\epsilon</math>, определяющее допустимый порядок малости внедиагональных элементов.

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

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

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

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

==Свойства алгоритма==
Из существующих алгоритмов вычисления собственных значений симметричной матрицы метод Якоби является самым медленным (в среднем для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 248)</ref>). Его преимущество заключается в том, что он не предполагает первоначального приведения матрицы к трехдиагональной форме. Также метод до сих пор используется на практике для вычисления малых собственных чисел и отвечающих им собственных векторов, так как он делает это с гораздо большей точностью, чем другие методы<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244)</ref>.

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

Метод Якоби не детерминирован, так как является итерационным алгоритмом с выходом по точности: число итераций зависит от входных данных и порогового значения.

Дуги информационного графа, исходящие из вершин, соответствующих вычислениям значений <math>c</math> и <math>s</math>, образуют пучки рассылок линейной мощности.

=ЧАСТЬ. Программная реализация алгоритма=
==Масштабируемость алгоритма и его реализации==
==Существующие реализации алгоритма==
Библиотека [https://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE] содержит последовательную реализацию алгоритма.

Существует также [http://ieeexplore.ieee.org/document/6310877/ параллельная реализация] метода на платформе CUDA.

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

Участница:Tameeva.a/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-15T19:57:13Z

Tameeva.a:

{{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>\frac{n (n + 1)}{2}</math>
| output_data = <math>n</math>
}}

Основные авторы описания: [[Участник:Tameeva.a|А. Тамеева]], [[Участник:AKukhtinov|А. Кухтинов]].

=ЧАСТЬ. Свойства и структура алгоритмов=
== Общее описание алгоритма ==

Метод Якоби вычисления собственных значений симметричной матрицы — итерационный алгоритм, названный в честь предложившего его для конкретной матрицы 7 × 7 в 1846 году Карла Густава Якоба Якоби<ref>Jacobi, C.G.J. (1846). «[http://resolver.sub.uni-goettingen.de/purl/?GDZPPN002144522 Über ein leichtes Verfahren, die in der Theorie der Säkularstörungen vorkommenden Gleichungen numerisch aufzulösen]» (German). Crelle's Journal 30: 51–94.</ref>. Исторически старейший метод для решения симметрической проблемы собственных значений получил широкое применение только в 1950-х годах с появлением компьютеров. Преимуществом метода является более точное вычисление малых собственных значений по сравнению с конкурирующими алгоритмами.

Суть алгоритма — приведение симметрической матрицы к диагональной с собственными значениями на диагонали путем вращения.

== Математическое описание алгоритма<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>==
Исходные данные: симметрическая матрица <math>A=\{a_{ij}\}</math>.

Вычисляемые данные: диагональная матрица <math>\Lambda=\{\lambda_{ii}\}</math>. Диагональные элементы <math>\Lambda</math> — собственные значения матрицы <math>A</math>, столбцы — приближенные собственные вектора матрицы <math>A</math>.

По заданной матрице <math>A=A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,\ldots, A_m</math>, сходящихся к <math>\Lambda</math>.

<math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math> J_i</math> — ортогональная матрица, называемая вращением Якоби.

Матрица <math>J_i</math> выбирается так, чтобы обнулить элементы <math>(j,k)</math> и <math>(k,j)</math> матрицы <math>A_{i+1}</math>:

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

<math>
\begin{align}
J_i = R(j,k,\theta) = \begin{matrix} \\ \\ \\ j \\ \\ k \\ \\ \\ \\ \end{matrix} \begin{bmatrix} & 1 & & & & & & & & \\ & & 1 & & & & & & & \\ & & & \ddots & & & & & & \\ & & & & \cos(\theta) & & -\sin(\theta) & & & \\ & & & & & \ddots & & & & \\ & & & & \sin(\theta) & & \cos(\theta) & & & \\ & & & & & & & \ddots & & \\ & & & & & & & & 1 & \\ & & & & & & & & & 1 \\ \end{bmatrix}
\end{align}
</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>s = \sin \theta</math> и <math>c = \cos \theta</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>\dfrac{a_{jj}-a_{kk}}{2a_{jk}}=\dfrac{c^2-s^2}{2sc}=\dfrac{\cos2\theta}{\sin2\theta}=\operatorname{ctg}2\theta\equiv\tau</math>

Положим <math>tg\theta=t=\dfrac{s}{c}</math>. Тогда <math>t^2+2t\tau-1=0</math>.

Решая квадратное уравнение, получим:
<math>t=\dfrac{\operatorname{sign}\tau}{\left|\tau\right|+\sqrt{1+\tau^2}}, c=\dfrac{1}{\sqrt{1+t^2}}, s=t\cdot c.</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма составляют вычисления элементов матрицы <math>A</math> в процессе применения матрицы поворота <math>J</math> :

1. Вычисления элементов <math>a_{jl}^{(i+1)} = a_{lj}^{(i+1)}</math> и <math>a_{kl}^{(i+1)} = a_{lk}^{(i+1)}</math> (каждое <math>(n-2)</math> раз):

<math>\begin{align}
a_{jl}^{(i+1)} = a_{lj}^{(i+1)} = c \, a_{jl}^{(i)} - s \, a_{kl}^{(i)}, l \ne j,k;\\
a_{kl}^{(i+1)} = a_{lk}^{(i+1)} = s \, a_{jl}^{(i)} + c \, a_{kl}^{(i)}, l \ne j,k.
\end{align}</math>

2. Вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>:

<math>\begin{align}
a_{jj}^{(i+1)} &= c^2\, a_{jj}^{(i)} - 2\, s c \,a_{jk}^{(i)} + s^2\, a_{kk}^{(i)}; \\
a_{kk}^{(i+1)} &= s^2 \,a_{jj}^{(i)} + 2 s c\, a_{jk}^{(i)} + c^2 \, a_{kk}^{(i)}.
\end{align}</math>

== Макроструктура алгоритма ==
Макроструктуру алгоритма можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246, алгоритм 5.6)</ref>:

repeat
выбрать пару индексов j, k
обратиться к процедуре JacobiRotation(A,j,k)
пока А не станет достаточно близка к диагональной матрице

==Схема реализации последовательного алгоритма==
В классическом алгоритме Якоби для обнуления на текущей итерации выбирался наибольший элемент <math>a_{jk}</math>. Поиск наибольшего элемента слишком замедляет процесс вычислений (нужно провести поиск среди <math>\dfrac{n^2-n}{2}</math> элементов, прежде чем выполнить вращение стоимостью в <math>O(n)</math> флопов), поэтому для практических вычислений выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

Таким образом, алгоритм можно описать так<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 247, алгоритм 5.8)</ref>:

repeat
for j=1 to n-1
for k=j+1 to n
выполнить процедуру '''''JacobiRotation'''(A, j, k)''
end for
end for
пока A не достаточно близка к диагональной матрице

Процедура '''''JacobiRotation'''(A, j, k)'':

if <math>|a_{jk}|</math> не слишком мал
<math>\begin{align}
\tau &= \frac{a_{jj}-a_{kk}}{2\,a_{jk}} \\
t &= \frac{sign(\tau)}{|\tau|+\sqrt{1+\tau^2}} \\
c &= \frac{1}{\sqrt{1+t^2}} \\
s &= c\cdot t \\
A &= J_i^T\cdot A\cdot J_i, \qquad
J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}
</math>
end if
==Последовательная сложность алгоритма==
Для одной итерации вычислений собственных значений матрицы порядка <math>n</math> методом Якоби требуется:

Для вычислительного ядра:

*<math>4\,n+6</math> умножений,
*<math>2n</math> сложений.

Для остальной части алгоритма:

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

Умножения и сложения (вычитания) составляют основную часть алгоритма.

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

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

==Информационный граф==
Опишем граф алгоритма аналитически и в виде рисунка.

Граф алгоритма состоит из четырёх групп вершин:

1. '''''Off>eps''''' — сравнение матрицы с диагональной: вычисление нормы наддиагональных элементов <math>of\!f(A)=\sqrt{\sum\limits_{1 \le j < k \le n} a_{jk}^2}</math> и сравнение с <math>\epsilon</math>.

Аргументы функции:
*<math>a_{jk}</math>
** Первая итерация — элементы входных данных: наддиагональные элементы матрицы <math>A</math>;
** Последующие — результаты вычислений вершины четвертой группы (<math>a^{i+1}_{jl},a^{i+1}_{kl},l\ne j,k</math>);
*<math>\epsilon</math> — элемент входных данных.

Результат выполнения функции является ''промежуточным данным'' алгоритма.

2. '''''Calculate c,s''''' — вычисление <math>c, s</math> согласно формулам в [[#Схема реализации последовательного алгоритма|схеме реализации последовательного алгоритма.]]

Аргументы функции:
*<math>a^{i+1}_{jj}, a^{i+1}_{kk}</math>:
** Первая итерация — элементы входных данных: диагональные элементы матрицы <math>A</math>;
** Последующие — результаты вычислений вершины третьей группы.
* <math>a^{i+1}_{jk}</math>
** Первая итерация — элементы входных данных <math>a_{jk}</math>
** Последующие — результаты вычислений вершины четвертой группы.

Результаты выполнения функции являются ''промежуточными данными'' алгоритма.

3. <math>A_{jj}, A_{kk}</math> — вычисление <math>a^{i+1}_{jj}, a^{i+1}_{kk}</math> согласно формулам в разделе[[#Вычислительное ядро алгоритма|Вычислительное ядро алгоритма]].

Аргументы функции:
* <math>c, s</math> — результаты вычислений вершины второй группы.
* <math>a^{i}_{jj}, a^{i}_{kk}</math>:
** Первая итерация — элементы входных данных <math>a_{jj}, a_{kk}</math>;
** Последующие — результаты вычислений вершины третьей группы <math>a^{i}_{jj}, a^{i}_{kk}</math>.
* <math>a^{i}_{jk}</math>:
** Первая итерация — элементы входных данных <math>a_{jk}</math>;
** Последующие — результаты вычислений вершины четвертой группы.

Результат выполнения функции является ''выходным данным'' алгоритма.

4. <math>A_{jl}, A_{kl}</math> — вычисление <math>a^{i+1}_{jl},a^{i+1}_{kl},l\ne j,k</math> согласно формулам в разделе[[#Вычислительное ядро алгоритма|Вычислительное ядро алгоритма]].

Аргументы функции:
* <math>c, s</math> — результаты вычислений вершины второй группы.
* <math>a^{(i)}_{jl}, a^{(i)}_{kl}</math>:
** Первая итерация — элементы входных данных <math>a_{jl},l\ne j,k</math>;
** Последующие — результаты вычислений вершины четвертой группы.

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

Описанный граф для четырех итераций представлен на рисунке. К графу добавлены вершины, соответствующие входным (желтый цвет) и выходным (фиолетовый цвет) данным. Дублирующие друг друга дуги даны как одна.
[[File:Jacobi.png|800px|thumb|center|Рисунок 1. Граф алгоритма с отображением входных и выходных данных.]]

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

Для выполнения каждой итерации требуется последовательно выполнить следующие ярусы (для матрицы порядка <math>n</math>):
# Вычислить норму матрицы и сравнить с <math>\epsilon</math> (параллельное вычисление <math>\frac{n(n-1)}{2}</math> умножений, далее последовательно <math>\frac{n(n-1)}{2}-1</math> сложений, <math>1</math> операция взятия квадратного корня, <math>1</math> операция сравнения )

# Вычислить <math>\tau, t, c, s</math> (последовательно всего <math>4</math> умножений, <math>3</math> делений, <math>4</math> сложений (вычитаний), <math>2</math> операции извлечения квадратного корня, <math>1</math> операция сравнения, <math>1</math> операция взятия модуля)

# Поворот матрицы <math>A</math> с параллельным выполнением <math>2(n-2)</math> операций вычисления элементов матрицы <math>a_{jl}^{(i+1)} = a_{lj}^{(i+1)}</math>   и   <math>a_{kl}^{(i+1)} = a_{lk}^{(i+1)}</math>,   <math>m \ne j,k</math>, а также <math>2</math> операций вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>.

Суммарное количество итераций зависит от входных данных и заданного значения погрешности <math>\epsilon</math>. Один цикл (полный проход по внедиагональным элементам) осуществляется за <math>N = \frac{n(n-1)}{2}</math> итераций.

Таким образом, при классификации по высоте ЯПФ метод Якоби относится к алгоритмам со сложностью <math>O(n^2)</math> , а при классификации по ширине ЯПФ — к алгоритмам со сложностью <math>O(n)</math>.

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

1. Плотная матрица <math>A=\{a_{ij}\}, A\in\R^{n\times n}</math>. Дополнительные ограничения:
* <math>A</math> — симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

2. Число двойной точности <math>\epsilon</math>, определяющее допустимый порядок малости внедиагональных элементов.

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

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

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

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

==Свойства алгоритма==
Из существующих алгоритмов вычисления собственных значений симметричной матрицы метод Якоби является самым медленным (в среднем для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 248)</ref>). Его преимущество заключается в том, что он не предполагает первоначального приведения матрицы к трехдиагональной форме. Также метод до сих пор используется на практике для вычисления малых собственных чисел и отвечающих им собственных векторов, так как он делает это с гораздо большей точностью, чем другие методы<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244)</ref>.

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

Метод Якоби не детерминирован, так как является итерационным алгоритмом с выходом по точности: число итераций зависит от входных данных и порогового значения.

Дуги информационного графа, исходящие из вершин, соответствующих вычислениям значений <math>c</math> и <math>s</math>, образуют пучки рассылок линейной мощности.

=ЧАСТЬ. Программная реализация алгоритма=
==Масштабируемость алгоритма и его реализации==
==Существующие реализации алгоритма==
Библиотека [https://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE] содержит последовательную реализацию алгоритма.

Существует также [http://ieeexplore.ieee.org/document/6310877/ параллельная реализация] метода на платформе CUDA.

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

Участница:Tameeva.a/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-15T19:48:33Z

Tameeva.a:

{{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>\frac{n (n + 1)}{2}</math>
| output_data = <math>n</math>
}}

Основные авторы описания: [[Участник:Tameeva.a|А. Тамеева]], [[Участник:AKukhtinov|А. Кухтинов]].

=ЧАСТЬ. Свойства и структура алгоритмов=
== Общее описание алгоритма ==

Метод Якоби вычисления собственных значений симметричной матрицы — итерационный алгоритм, названный в честь предложившего его для конкретной матрицы 7 × 7 в 1846 году Карла Густава Якоба Якоби<ref>Jacobi, C.G.J. (1846). «[http://resolver.sub.uni-goettingen.de/purl/?GDZPPN002144522 Über ein leichtes Verfahren, die in der Theorie der Säkularstörungen vorkommenden Gleichungen numerisch aufzulösen]» (German). Crelle's Journal 30: 51–94.</ref>. Исторически старейший метод для решения симметрической проблемы собственных значений получил широкое применение только в 1950-х годах с появлением компьютеров. Преимуществом метода является более точное вычисление малых собственных значений по сравнению с конкурирующими алгоритмами.

Суть алгоритма — приведение симметрической матрицы к диагональной с собственными значениями на диагонали путем вращения.

== Математическое описание алгоритма<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>==
Исходные данные: симметрическая матрица <math>A=\{a_{ij}\}</math>.

Вычисляемые данные: диагональная матрица <math>\Lambda=\{\lambda_{ii}\}</math>. Диагональные элементы <math>\Lambda</math> — собственные значения матрицы <math>A</math>, столбцы — приближенные собственные вектора матрицы <math>A</math>.

По заданной матрице <math>A=A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,\ldots, A_m</math>, сходящихся к <math>\Lambda</math>.

<math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math> J_i</math> — ортогональная матрица, называемая вращением Якоби.

Матрица <math>J_i</math> выбирается так, чтобы обнулить элементы <math>(j,k)</math> и <math>(k,j)</math> матрицы <math>A_{i+1}</math>:

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

<math>
\begin{align}
J_i = R(j,k,\theta) = \begin{matrix} \\ \\ \\ j \\ \\ k \\ \\ \\ \\ \end{matrix} \begin{bmatrix} & 1 & & & & & & & & \\ & & 1 & & & & & & & \\ & & & \ddots & & & & & & \\ & & & & \cos(\theta) & & -\sin(\theta) & & & \\ & & & & & \ddots & & & & \\ & & & & \sin(\theta) & & \cos(\theta) & & & \\ & & & & & & & \ddots & & \\ & & & & & & & & 1 & \\ & & & & & & & & & 1 \\ \end{bmatrix}
\end{align}
</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>s = \sin \theta</math> и <math>c = \cos \theta</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>\dfrac{a_{jj}-a_{kk}}{2a_{jk}}=\dfrac{c^2-s^2}{2sc}=\dfrac{\cos2\theta}{\sin2\theta}=\operatorname{ctg}2\theta\equiv\tau</math>

Положим <math>tg\theta=t=\dfrac{s}{c}</math>. Тогда <math>t^2+2t\tau-1=0</math>.

Решая квадратное уравнение, получим:
<math>t=\dfrac{\operatorname{sign}\tau}{\left|\tau\right|+\sqrt{1+\tau^2}}, c=\dfrac{1}{\sqrt{1+t^2}}, s=t\cdot c.</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма составляют вычисления элементов матрицы <math>A</math> в процессе применения матрицы поворота <math>J</math> :

1. Вычисления элементов <math>a_{jl}^{(i+1)} = a_{lj}^{(i+1)}</math> и <math>a_{kl}^{(i+1)} = a_{lk}^{(i+1)}</math> (каждое <math>(n-2)</math> раз):

<math>\begin{align}
a_{jl}^{(i+1)} = a_{lj}^{(i+1)} = c \, a_{jl}^{(i)} - s \, a_{kl}^{(i)}, l \ne j,k;\\
a_{kl}^{(i+1)} = a_{lk}^{(i+1)} = s \, a_{jl}^{(i)} + c \, a_{kl}^{(i)}, l \ne j,k.
\end{align}</math>

2. Вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>:

<math>\begin{align}
a_{jj}^{(i+1)} &= c^2\, a_{jj}^{(i)} - 2\, s c \,a_{jk}^{(i)} + s^2\, a_{kk}^{(i)}; \\
a_{kk}^{(i+1)} &= s^2 \,a_{jj}^{(i)} + 2 s c\, a_{jk}^{(i)} + c^2 \, a_{kk}^{(i)}.
\end{align}</math>

== Макроструктура алгоритма ==
Макроструктуру алгоритма можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246, алгоритм 5.6)</ref>:

repeat
выбрать пару индексов j, k
обратиться к процедуре JacobiRotation(A,j,k)
пока А не станет достаточно близка к диагональной матрице

==Схема реализации последовательного алгоритма==
В классическом алгоритме Якоби для обнуления на текущей итерации выбирался наибольший элемент <math>a_{jk}</math>. Поиск наибольшего элемента слишком замедляет процесс вычислений (нужно провести поиск среди <math>\dfrac{n^2-n}{2}</math> элементов, прежде чем выполнить вращение стоимостью в <math>O(n)</math> флопов), поэтому для практических вычислений выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

Таким образом, алгоритм можно описать так<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 247, алгоритм 5.8)</ref>:

repeat
for j=1 to n-1
for k=j+1 to n
выполнить процедуру '''''JacobiRotation'''(A, j, k)''
end for
end for
пока A не достаточно близка к диагональной матрице

Процедура '''''JacobiRotation'''(A, j, k)'':

if <math>|a_{jk}|</math> не слишком мал
<math>\begin{align}
\tau &= \frac{a_{jj}-a_{kk}}{2\,a_{jk}} \\
t &= \frac{sign(\tau)}{|\tau|+\sqrt{1+\tau^2}} \\
c &= \frac{1}{\sqrt{1+t^2}} \\
s &= c\cdot t \\
A &= J_i^T\cdot A\cdot J_i, \qquad
J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}
</math>
end if
==Последовательная сложность алгоритма==
Для одной итерации вычислений собственных значений матрицы порядка <math>n</math> методом Якоби требуется:

Для вычислительного ядра:

*<math>4\,n+6</math> умножений,
*<math>2n</math> сложений.

Для остальной части алгоритма:

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

Умножения и сложения (вычитания) составляют основную часть алгоритма.

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

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

==Информационный граф==
Опишем граф алгоритма аналитически и в виде рисунка.

Граф алгоритма состоит из четырёх групп вершин:

1. '''''Off>eps''''' — сравнение матрицы с диагональной: вычисление нормы наддиагональных элементов <math>of\!f(A)=\sqrt{\sum\limits_{1 \le j < k \le n} a_{jk}^2}</math> и сравнение с <math>\epsilon</math>.

Аргументы функции:
*<math>a_{jk}</math>
** Первая итерация — элементы входных данных: наддиагональные элементы матрицы <math>A</math> и ;
** Последующие — результаты вычислений вершины четвертой группы (<math>a^{i+1}_{jl},a^{i+1}_{kl},l\ne j,k</math>);
*<math>\epsilon</math> — элемент входных данных.

Результат выполнения функции является ''промежуточным данным'' алгоритма.

2. '''''Calculate c,s''''' — вычисление <math>c, s</math> согласно формулам в [[#Схема реализации последовательного алгоритма|схеме реализации последовательного алгоритма.]]

Аргументы функции:
*<math>a^{i+1}_{jj}, a^{i+1}_{kk}</math>:
** Первая итерация — элементы входных данных: диагональные элементы матрицы <math>A</math>;
** Последующие — результаты вычислений вершины третьей группы.
* <math>a^{i+1}_{jk}</math>:
** Первая итерация — элементы входных данных <math>a_{jk}</math>
** Последующие — результаты вычислений вершины четвертой группы.

Результаты выполнения функции являются ''промежуточными данными'' алгоритма.

3. <math>A_{jj}, A_{kk}</math> — вычисление <math>a^{i+1}_{jj}, a^{i+1}_{kk}</math>

Аргументы функции:
* <math>c, s</math> — результаты вычислений вершины второй группы.
* <math>a^{i}_{jj}, a^{i}_{kk}</math>:
** Первая итерация — элементы входных данных <math>a_{jj}, a_{kk}</math>;
** Последующие — результаты вычислений вершины третьей группы <math>a^{i}_{jj}, a^{i}_{kk}</math>.
* <math>a^{i}_{jk}</math>:
** Первая итерация — элементы входных данных <math>a_{jk}</math>;
** Последующие — результаты вычислений вершины четвертой группы.

Результат выполнения функции является ''выходным данным'' алгоритма.

4. <math>A_{jl}, A_{kl}</math> — вычисление <math>a^{i+1}_{jl},a^{i+1}_{kl},l\ne j,k</math>

Аргументы функции:
* <math>c, s</math> — результаты вычислений вершины второй группы.
* <math>a^{(i)}_{jl}, a^{(i)}_{kl}</math>:
** Первая итерация — элементы входных данных <math>a_{jl},l\ne j,k</math>;
** Последующие — результаты вычислений вершины четвертой группы.

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

Описанный граф для четырех итераций представлен на рисунке. К графу добавлены вершины, соответствующие входным (желтый цвет) и выходным (фиолетовый цвет) данным. Дублирующие друг друга дуги даны как одна.
[[File:Jacobi.png|800px|thumb|center|Рисунок 1. Граф алгоритма с отображением входных и выходных данных.]]

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

Для выполнения каждой итерации требуется последовательно выполнить следующие ярусы (для матрицы порядка <math>n</math>):
# Вычислить норму матрицы и сравнить с <math>\epsilon</math> (параллельное вычисление <math>\frac{n(n-1)}{2}</math> умножений, далее последовательно <math>\frac{n(n-1)}{2}-1</math> сложений, <math>1</math> операция взятия квадратного корня, <math>1</math> операция сравнения )

# Вычислить <math>\tau, t, c, s</math> (последовательно всего <math>4</math> умножений, <math>3</math> делений, <math>4</math> сложений (вычитаний), <math>2</math> операции извлечения квадратного корня, <math>1</math> операция сравнения, <math>1</math> операция взятия модуля)

# Поворот матрицы <math>A</math> с параллельным выполнением <math>2(n-2)</math> операций вычисления элементов матрицы <math>a_{jl}^{(i+1)} = a_{lj}^{(i+1)}</math>   и   <math>a_{kl}^{(i+1)} = a_{lk}^{(i+1)}</math>,   <math>m \ne j,k</math>, а также <math>2</math> операций вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>.

Суммарное количество итераций зависит от входных данных и заданного значения погрешности <math>\epsilon</math>. Один цикл (полный проход по внедиагональным элементам) осуществляется за <math>N = \frac{n(n-1)}{2}</math> итераций.

Таким образом, при классификации по высоте ЯПФ метод Якоби относится к алгоритмам со сложностью <math>O(n^2)</math> , а при классификации по ширине ЯПФ — к алгоритмам со сложностью <math>O(n)</math>.

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

1. Плотная матрица <math>A=\{a_{ij}\}, A\in\R^{n\times n}</math>. Дополнительные ограничения:
* <math>A</math> — симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

2. Число двойной точности <math>\epsilon</math>, определяющее допустимый порядок малости внедиагональных элементов.

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

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

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

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

==Свойства алгоритма==
Из существующих алгоритмов вычисления собственных значений симметричной матрицы метод Якоби является самым медленным (в среднем для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 248)</ref>). Его преимущество заключается в том, что он не предполагает первоначального приведения матрицы к трехдиагональной форме. Также метод до сих пор используется на практике для вычисления малых собственных чисел и отвечающих им собственных векторов, так как он делает это с гораздо большей точностью, чем другие методы<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244)</ref>.

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

Метод Якоби не детерминирован, так как является итерационным алгоритмом с выходом по точности: число итераций зависит от входных данных и порогового значения.

Дуги информационного графа, исходящие из вершин, соответствующих вычислениям значений <math>c</math> и <math>s</math>, образуют пучки рассылок линейной мощности.

=ЧАСТЬ. Программная реализация алгоритма=
==Масштабируемость алгоритма и его реализации==
==Существующие реализации алгоритма==
Библиотека [https://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE] содержит последовательную реализацию алгоритма.

Существует также [http://ieeexplore.ieee.org/document/6310877/ параллельная реализация] метода на платформе CUDA.

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

Участница:Tameeva.a/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-15T19:25:10Z

Tameeva.a:

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

Основные авторы описания: [[Участник:Tameeva.a|А. Тамеева]], [[Участник:AKukhtinov|А. Кухтинов]].

=ЧАСТЬ. Свойства и структура алгоритмов=
== Общее описание алгоритма ==

Метод Якоби вычисления собственных значений симметричной матрицы — итерационный алгоритм, названный в честь предложившего его для конкретной матрицы 7 × 7 в 1846 году Карла Густава Якоба Якоби<ref>Jacobi, C.G.J. (1846). «[http://resolver.sub.uni-goettingen.de/purl/?GDZPPN002144522 Über ein leichtes Verfahren, die in der Theorie der Säkularstörungen vorkommenden Gleichungen numerisch aufzulösen]» (German). Crelle's Journal 30: 51–94.</ref>. Исторически старейший метод для решения симметрической проблемы собственных значений получил широкое применение только в 1950-х годах с появлением компьютеров. Преимуществом метода является более точное вычисление малых собственных значений по сравнению с конкурирующими алгоритмами.

Суть алгоритма — приведение симметрической матрицы к диагональной с собственными значениями на диагонали путем вращения.

== Математическое описание алгоритма<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>==
Исходные данные: симметрическая матрица <math>A=\{a_{ij}\}</math>.

Вычисляемые данные: диагональная матрица <math>\Lambda=\{\lambda_{ii}\}</math>. Диагональные элементы <math>\Lambda</math> — собственные значения матрицы <math>A</math>, столбцы — приближенные собственные вектора матрицы <math>A</math>.

По заданной матрице <math>A=A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,\ldots, A_m</math>, сходящихся к <math>\Lambda</math>.

<math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math> J_i</math> — ортогональная матрица, называемая вращением Якоби.

Матрица <math>J_i</math> выбирается так, чтобы обнулить элементы <math>(j,k)</math> и <math>(k,j)</math> матрицы <math>A_{i+1}</math>:

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

<math>
\begin{align}
J_i = R(j,k,\theta) = \begin{matrix} \\ \\ \\ j \\ \\ k \\ \\ \\ \\ \end{matrix} \begin{bmatrix} & 1 & & & & & & & & \\ & & 1 & & & & & & & \\ & & & \ddots & & & & & & \\ & & & & \cos(\theta) & & -\sin(\theta) & & & \\ & & & & & \ddots & & & & \\ & & & & \sin(\theta) & & \cos(\theta) & & & \\ & & & & & & & \ddots & & \\ & & & & & & & & 1 & \\ & & & & & & & & & 1 \\ \end{bmatrix}
\end{align}
</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>s = \sin \theta</math> и <math>c = \cos \theta</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>\dfrac{a_{jj}-a_{kk}}{2a_{jk}}=\dfrac{c^2-s^2}{2sc}=\dfrac{\cos2\theta}{\sin2\theta}=\operatorname{ctg}2\theta\equiv\tau</math>

Положим <math>tg\theta=t=\dfrac{s}{c}</math>. Тогда <math>t^2+2t\tau-1=0</math>.

Решая квадратное уравнение, получим:
<math>t=\dfrac{\operatorname{sign}\tau}{\left|\tau\right|+\sqrt{1+\tau^2}}, c=\dfrac{1}{\sqrt{1+t^2}}, s=t\cdot c.</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма составляют вычисления элементов матрицы <math>A</math> в процессе применения матрицы поворота <math>J</math> :

1. Вычисления элементов <math>a_{jl}^{(i+1)} = a_{lj}^{(i+1)}</math> и <math>a_{kl}^{(i+1)} = a_{lk}^{(i+1)}</math> (каждое <math>(n-2)</math> раз):

<math>\begin{align}
a_{jl}^{(i+1)} = a_{lj}^{(i+1)} = c \, a_{jl}^{(i)} - s \, a_{kl}^{(i)}, l \ne j,k;\\
a_{kl}^{(i+1)} = a_{lk}^{(i+1)} = s \, a_{jl}^{(i)} + c \, a_{kl}^{(i)}, l \ne j,k.
\end{align}</math>

2. Вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>:

<math>\begin{align}
a_{jj}^{(i+1)} &= c^2\, a_{jj}^{(i)} - 2\, s c \,a_{jk}^{(i)} + s^2\, a_{kk}^{(i)}; \\
a_{kk}^{(i+1)} &= s^2 \,a_{jj}^{(i)} + 2 s c\, a_{jk}^{(i)} + c^2 \, a_{kk}^{(i)}.
\end{align}</math>

== Макроструктура алгоритма ==
Макроструктуру алгоритма можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246, алгоритм 5.6)</ref>:

repeat
выбрать пару индексов j, k
обратиться к процедуре JacobiRotation(A,j,k)
пока А не станет достаточно близка к диагональной матрице

==Схема реализации последовательного алгоритма==
В классическом алгоритме Якоби для обнуления на текущей итерации выбирался наибольший элемент <math>a_{jk}</math>. Поиск наибольшего элемента слишком замедляет процесс вычислений (нужно провести поиск среди <math>\dfrac{n^2-n}{2}</math> элементов, прежде чем выполнить вращение стоимостью в <math>O(n)</math> флопов), поэтому для практических вычислений выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

Таким образом, алгоритм можно описать так<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 247, алгоритм 5.8)</ref>:

repeat
for j=1 to n-1
for k=j+1 to n
выполнить процедуру '''''JacobiRotation'''(A, j, k)''
end for
end for
пока A не достаточно близка к диагональной матрице

Процедура '''''JacobiRotation'''(A, j, k)'':

if <math>|a_{jk}|</math> не слишком мал
<math>\begin{align}
\tau &= \frac{a_{jj}-a_{kk}}{2\,a_{jk}} \\
t &= \frac{sign(\tau)}{|\tau|+\sqrt{1+\tau^2}} \\
c &= \frac{1}{\sqrt{1+t^2}} \\
s &= c\cdot t \\
A &= J_i^T\cdot A\cdot J_i, \qquad
J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}
</math>
end if
==Последовательная сложность алгоритма==
Для одной итерации вычислений собственных значений матрицы порядка <math>n</math> методом Якоби требуется:

Для вычислительного ядра:

*<math>4\,n+6</math> умножений,
*<math>2n</math> сложений.

Для остальной части алгоритма:

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

Умножения и сложения (вычитания) составляют основную часть алгоритма.

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

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

==Информационный граф==
Опишем граф алгоритма аналитически и в виде рисунка.

Граф алгоритма состоит из четырёх групп вершин:

1. '''''Off>eps''''' — сравнение матрицы с диагональной: вычисление нормы наддиагональных элементов <math>of\!f(A)=\sqrt{\sum\limits_{1 \le j < k \le n} a_{jk}^2}</math> и сравнение с <math>\epsilon</math>

(<math>\frac{n(n-1)}{2}</math> умножений, <math>\frac{n(n-1)}{2}-1</math> сложений, <math>1</math> операция взятия квадратного корня, <math>1</math> операция сравнения)

Аргументы функции:
*<math>a_{jk}</math>
** Первая итерация — элементы входных данных: наддиагональные элементы матрицы <math>A</math> и ;
** Последующие — результаты вычислений вершины четвертой группы (<math>a^{i+1}_{jl},a^{i+1}_{kl},l\ne j,k</math>);
*<math>\epsilon</math> — элемент входных данных.

Результат выполнения функции является ''промежуточным данным'' алгоритма.

2. '''''Calculate c,s''''' — вычисление <math>c, s</math>.

Аргументы функции:
*<math>a^{i+1}_{jj}, a^{i+1}_{kk}</math>:
** Первая итерация — элементы входных данных: диагональные элементы матрицы <math>A</math>;
** Последующие — результаты вычислений вершины третьей группы.
* <math>a^{i+1}_{jk}</math>:
** Первая итерация — элементы входных данных <math>a_{jk}</math>
** Последующие — результаты вычислений вершины четвертой группы a^{i+1}_{jk}.

Результаты выполнения функции являются ''промежуточными данными'' алгоритма.

3. <math>A_{jj}, A_{kk}</math> — вычисление <math>a^{i+1}_{jj}, a^{i+1}_{kk}</math>

Аргументы функции:
* <math>c, s</math> — результаты вычислений вершины второй группы.
* <math>a^{i}_{jj}, a^{i}_{kk}</math>:
** Первая итерация — элементы входных данных <math>a_{jj}, a_{kk}</math>;
** Последующие — результаты вычислений вершины третьей группы <math>a^{i}_{jj}, a^{i}_{kk}</math>.
* <math>a^{i}_{jk}</math>:
** Первая итерация — элементы входных данных <math>a_{jk}</math>;
** Последующие — результаты вычислений вершины четвертой группы.

Результат выполнения функции является ''выходным данным'' алгоритма.

4. <math>A_{jl}, A_{kl}</math> — вычисление <math>a^{i+1}_{jl},a^{i+1}_{kl},l\ne j,k</math>

Аргументы функции:
* <math>c, s</math> — результаты вычислений вершины второй группы.
* <math>a^{i}_{jl}, a^{i}_{kl}</math>:
** Первая итерация — элементы входных данных <math>a_{jl},l\ne j,k</math>;
** Последующие — результаты вычислений вершины четвертой группы.

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

Описанный граф для четырех итераций представлен на рисунке. К графу добавлены вершины, соответствующие входным (желтый цвет) и выходным (фиолетовый цвет) данным. Дублирующие друг друга дуги даны как одна.
[[File:Jacobi.png|800px|thumb|center|Рисунок 1. Граф алгоритма с отображением входных и выходных данных.]]

==Ресурс параллелизма алгоритма==
==Входные и выходные данные алгоритма==
'''Входные данные:'''

1. Плотная матрица <math>A=\{a_{ij}\}, A\in\R^{n\times n}</math>. Дополнительные ограничения:
* <math>A</math> — симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

2. Число двойной точности <math>\epsilon</math>, определяющее допустимый порядок малости внедиагональных элементов.

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

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

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

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

==Свойства алгоритма==
Из существующихалгоритмов вычисления собственных значений симметричной матрицы метод Якоби является самым медленным. Его преимущество заключается в том, что он не предполагает первоначального приведения матрицы к трехдиагональной форме. Также метод до сих пор используется на практике для вычисления малых собственных чисел и отвечающих им собственных векторов, так как он делает это с гораздо большей точностью, чем другие методы<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244)</ref>.

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

Метод Якоби не детерминирован, так как является итерационным алгоритмом с выходом по точности: число итераций зависит от входных данных и порогового значения.

Дуги информационного графа, исходящие из вершин, соответствующих вычислениям значений <math>c</math> и <math>s</math>, образуют пучки рассылок линейной мощности.

=ЧАСТЬ. Программная реализация алгоритма=
==Масштабируемость алгоритма и его реализации==
==Существующие реализации алгоритма==
Библиотека [https://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE] содержит последовательную реализацию алгоритма.

Существует также [http://ieeexplore.ieee.org/document/6310877/ параллельная реализация] метода на платформе CUDA.

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

Участница:Tameeva.a/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-15T19:24:10Z

Tameeva.a: /* Информационный граф */

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

Основные авторы описания: [[Участник:Tameeva.a|А. Тамеева]], [[Участник:AKukhtinov|А. Кухтинов]].

=ЧАСТЬ. Свойства и структура алгоритмов=
== Общее описание алгоритма ==

Метод Якоби вычисления собственных значений симметричной матрицы — итерационный алгоритм, названный в честь предложившего его для конкретной матрицы 7 × 7 в 1846 году Карла Густава Якоба Якоби<ref>Jacobi, C.G.J. (1846). «[http://resolver.sub.uni-goettingen.de/purl/?GDZPPN002144522 Über ein leichtes Verfahren, die in der Theorie der Säkularstörungen vorkommenden Gleichungen numerisch aufzulösen]» (German). Crelle's Journal 30: 51–94.</ref>. Исторически старейший метод для решения симметрической проблемы собственных значений получил широкое применение только в 1950-х годах с появлением компьютеров. Преимуществом метода является более точное вычисление малых собственных значений по сравнению с конкурирующими алгоритмами.

Суть алгоритма — приведение симметрической матрицы к диагональной с собственными значениями на диагонали путем вращения.

== Математическое описание алгоритма<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>==
Исходные данные: симметрическая матрица <math>A=\{a_{ij}\}</math>.

Вычисляемые данные: диагональная матрица <math>\Lambda=\{\lambda_{ii}\}</math>. Диагональные элементы <math>\Lambda</math> — собственные значения матрицы <math>A</math>, столбцы — приближенные собственные вектора матрицы <math>A</math>.

По заданной матрице <math>A=A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,\ldots, A_m</math>, сходящихся к <math>\Lambda</math>.

<math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math> J_i</math> — ортогональная матрица, называемая вращением Якоби.

Матрица <math>J_i</math> выбирается так, чтобы обнулить элементы <math>(j,k)</math> и <math>(k,j)</math> матрицы <math>A_{i+1}</math>:

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

<math>
\begin{align}
J_i = R(j,k,\theta) = \begin{matrix} \\ \\ \\ j \\ \\ k \\ \\ \\ \\ \end{matrix} \begin{bmatrix} & 1 & & & & & & & & \\ & & 1 & & & & & & & \\ & & & \ddots & & & & & & \\ & & & & \cos(\theta) & & -\sin(\theta) & & & \\ & & & & & \ddots & & & & \\ & & & & \sin(\theta) & & \cos(\theta) & & & \\ & & & & & & & \ddots & & \\ & & & & & & & & 1 & \\ & & & & & & & & & 1 \\ \end{bmatrix}
\end{align}
</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>s = \sin \theta</math> и <math>c = \cos \theta</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>\dfrac{a_{jj}-a_{kk}}{2a_{jk}}=\dfrac{c^2-s^2}{2sc}=\dfrac{\cos2\theta}{\sin2\theta}=\operatorname{ctg}2\theta\equiv\tau</math>

Положим <math>tg\theta=t=\dfrac{s}{c}</math>. Тогда <math>t^2+2t\tau-1=0</math>.

Решая квадратное уравнение, получим:
<math>t=\dfrac{\operatorname{sign}\tau}{\left|\tau\right|+\sqrt{1+\tau^2}}, c=\dfrac{1}{\sqrt{1+t^2}}, s=t\cdot c.</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма составляют вычисления элементов матрицы <math>A</math> в процессе применения матрицы поворота <math>J</math> :

1. Вычисления элементов <math>a_{jl}^{(i+1)} = a_{lj}^{(i+1)}</math> и <math>a_{kl}^{(i+1)} = a_{lk}^{(i+1)}</math> (каждое <math>(n-2)</math> раз):

<math>\begin{align}
a_{jl}^{(i+1)} = a_{lj}^{(i+1)} = c \, a_{jl}^{(i)} - s \, a_{kl}^{(i)}, l \ne j,k;\\
a_{kl}^{(i+1)} = a_{lk}^{(i+1)} = s \, a_{jl}^{(i)} + c \, a_{kl}^{(i)}, l \ne j,k.
\end{align}</math>

2. Вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>:

<math>\begin{align}
a_{jj}^{(i+1)} &= c^2\, a_{jj}^{(i)} - 2\, s c \,a_{jk}^{(i)} + s^2\, a_{kk}^{(i)}; \\
a_{kk}^{(i+1)} &= s^2 \,a_{jj}^{(i)} + 2 s c\, a_{jk}^{(i)} + c^2 \, a_{kk}^{(i)}.
\end{align}</math>

== Макроструктура алгоритма ==
Макроструктуру алгоритма можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246, алгоритм 5.6)</ref>:

repeat
выбрать пару индексов j, k
обратиться к процедуре JacobiRotation(A,j,k)
пока А не станет достаточно близка к диагональной матрице

==Схема реализации последовательного алгоритма==
В классическом алгоритме Якоби для обнуления на текущей итерации выбирался наибольший элемент <math>a_{jk}</math>. Поиск наибольшего элемента слишком замедляет процесс вычислений (нужно провести поиск среди <math>\dfrac{n^2-n}{2}</math> элементов, прежде чем выполнить вращение стоимостью в <math>O(n)</math> флопов), поэтому для практических вычислений выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

Таким образом, алгоритм можно описать так<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 247, алгоритм 5.8)</ref>:

repeat
for j=1 to n-1
for k=j+1 to n
выполнить процедуру '''''JacobiRotation'''(A, j, k)''
end for
end for
пока A не достаточно близка к диагональной матрице

Процедура '''''JacobiRotation'''(A, j, k)'':

if <math>|a_{jk}|</math> не слишком мал
<math>\begin{align}
\tau &= \frac{a_{jj}-a_{kk}}{2\,a_{jk}} \\
t &= \frac{sign(\tau)}{|\tau|+\sqrt{1+\tau^2}} \\
c &= \frac{1}{\sqrt{1+t^2}} \\
s &= c\cdot t \\
A &= J_i^T\cdot A\cdot J_i, \qquad
J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}
</math>
end if
==Последовательная сложность алгоритма==
Для одной итерации вычислений собственных значений матрицы порядка <math>n</math> методом Якоби требуется:

Для вычислительного ядра:

*<math>4\,n+6</math> умножений,
*<math>2n</math> сложений.

Для остальной части алгоритма:

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

Умножения и сложения (вычитания) составляют основную часть алгоритма.

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

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

Опишем граф алгоритма аналитически и в виде рисунка.

Граф алгоритма состоит из четырёх групп вершин:

1. '''''Off>eps''''' — сравнение матрицы с диагональной: вычисление нормы наддиагональных элементов <math>of\!f(A)=\sqrt{\sum\limits_{1 \le j < k \le n} a_{jk}^2}</math> и сравнение с <math>\epsilon</math>

(<math>\frac{n(n-1)}{2}</math> умножений, <math>\frac{n(n-1)}{2}-1</math> сложений, <math>1</math> операция взятия квадратного корня, <math>1</math> операция сравнения)

Аргументы функции:
*<math>a_{jk}</math>
** Первая итерация — элементы входных данных: наддиагональные элементы матрицы <math>A</math> и ;
** Последующие — результаты вычислений вершины четвертой группы (<math>a^{i+1}_{jl},a^{i+1}_{kl},l\ne j,k</math>);
*<math>\epsilon</math> — элемент входных данных.

Результат выполнения функции является ''промежуточным данным'' алгоритма.

2. '''''Calculate c,s''''' — вычисление <math>c, s</math>.

Аргументы функции:
*<math>a^{i+1}_{jj}, a^{i+1}_{kk}</math>:
** Первая итерация — элементы входных данных: диагональные элементы матрицы <math>A</math>;
** Последующие — результаты вычислений вершины третьей группы.
* <math>a^{i+1}_{jk}</math>:
** Первая итерация — элементы входных данных <math>a_{jk}</math>
** Последующие — результаты вычислений вершины четвертой группы a^{i+1}_{jk}.

Результаты выполнения функции являются ''промежуточными данными'' алгоритма.

3. <math>A_{jj}, A_{kk}</math> — вычисление <math>a^{i+1}_{jj}, a^{i+1}_{kk}</math>

Аргументы функции:
* <math>c, s</math> — результаты вычислений вершины второй группы.
* <math>a^{i}_{jj}, a^{i}_{kk}</math>:
** Первая итерация — элементы входных данных <math>a_{jj}, a_{kk}</math>;
** Последующие — результаты вычислений вершины третьей группы <math>a^{i}_{jj}, a^{i}_{kk}</math>.
* <math>a^{i}_{jk}</math>:
** Первая итерация — элементы входных данных <math>a_{jk}</math>;
** Последующие — результаты вычислений вершины четвертой группы.

Результат выполнения функции является ''выходным данным'' алгоритма.

4. <math>A_{jl}, A_{kl}</math> — вычисление <math>a^{i+1}_{jl},a^{i+1}_{kl},l\ne j,k</math>

Аргументы функции:
* <math>c, s</math> — результаты вычислений вершины второй группы.
* <math>a^{i}_{jl}, a^{i}_{kl}</math>:
** Первая итерация — элементы входных данных <math>a_{jl},l\ne j,k</math>;
** Последующие — результаты вычислений вершины четвертой группы.

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

Описанный граф для четырех итераций представлен на рисунке. К графу добавлены вершины, соответствующие входным (желтый цвет) и выходным (фиолетовый цвет) данным. Дублирующие друг друга дуги даны как одна.
[[File:Jacobi.png|800px|thumb|center|Рисунок 1. Граф алгоритма с отображением входных и выходных данных.]]

==Ресурс параллелизма алгоритма==
==Входные и выходные данные алгоритма==
'''Входные данные:'''

1. Плотная матрица <math>A=\{a_{ij}\}, A\in\R^{n\times n}</math>. Дополнительные ограничения:
* <math>A</math> — симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

2. Число двойной точности <math>\epsilon</math>, определяющее допустимый порядок малости внедиагональных элементов.

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

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

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

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

==Свойства алгоритма==
Из существующихалгоритмов вычисления собственных значений симметричной матрицы метод Якоби является самым медленным. Его преимущество заключается в том, что он не предполагает первоначального приведения матрицы к трехдиагональной форме. Также метод до сих пор используется на практике для вычисления малых собственных чисел и отвечающих им собственных векторов, так как он делает это с гораздо большей точностью, чем другие методы<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244)</ref>.

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

Метод Якоби не детерминирован, так как является итерационным алгоритмом с выходом по точности: число итераций зависит от входных данных и порогового значения.

Дуги информационного графа, исходящие из вершин, соответствующих вычислениям значений <math>c</math> и <math>s</math>, образуют пучки рассылок линейной мощности.

=ЧАСТЬ. Программная реализация алгоритма=
==Масштабируемость алгоритма и его реализации==
==Существующие реализации алгоритма==
Библиотека [https://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE] содержит последовательную реализацию алгоритма.

Существует также [http://ieeexplore.ieee.org/document/6310877/ параллельная реализация] метода на платформе CUDA.

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

Участница:Tameeva.a/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-15T17:59:46Z

Tameeva.a: /* Входные и выходные данные алгоритма */

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

Основные авторы описания: [[Участник:Tameeva.a|А. Тамеева]], [[Участник:AKukhtinov|А. Кухтинов]].

=ЧАСТЬ. Свойства и структура алгоритмов=
== Общее описание алгоритма ==

Метод Якоби вычисления собственных значений симметричной матрицы — итерационный алгоритм, названный в честь предложившего его для конкретной матрицы 7 × 7 в 1846 году Карла Густава Якоба Якоби<ref>Jacobi, C.G.J. (1846). «[http://resolver.sub.uni-goettingen.de/purl/?GDZPPN002144522 Über ein leichtes Verfahren, die in der Theorie der Säkularstörungen vorkommenden Gleichungen numerisch aufzulösen]» (German). Crelle's Journal 30: 51–94.</ref>. Исторически старейший метод для решения симметрической проблемы собственных значений получил широкое применение только в 1950-х годах с появлением компьютеров. Преимуществом метода является более точное вычисление малых собственных значений по сравнению с конкурирующими алгоритмами.

Суть алгоритма — приведение симметрической матрицы к диагональной с собственными значениями на диагонали путем вращения.

== Математическое описание алгоритма<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>==
Исходные данные: симметрическая матрица <math>A=\{a_{ij}\}</math>.

Вычисляемые данные: диагональная матрица <math>\Lambda=\{\lambda_{ii}\}</math>. Диагональные элементы <math>\Lambda</math> — собственные значения матрицы <math>A</math>, столбцы — приближенные собственные вектора матрицы <math>A</math>.

По заданной матрице <math>A=A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,\ldots, A_m</math>, сходящихся к <math>\Lambda</math>.

<math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math> J_i</math> — ортогональная матрица, называемая вращением Якоби.

Матрица <math>J_i</math> выбирается так, чтобы обнулить элементы <math>(j,k)</math> и <math>(k,j)</math> матрицы <math>A_{i+1}</math>:

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

<math>
\begin{align}
J_i = R(j,k,\theta) = \begin{matrix} \\ \\ \\ j \\ \\ k \\ \\ \\ \\ \end{matrix} \begin{bmatrix} & 1 & & & & & & & & \\ & & 1 & & & & & & & \\ & & & \ddots & & & & & & \\ & & & & \cos(\theta) & & -\sin(\theta) & & & \\ & & & & & \ddots & & & & \\ & & & & \sin(\theta) & & \cos(\theta) & & & \\ & & & & & & & \ddots & & \\ & & & & & & & & 1 & \\ & & & & & & & & & 1 \\ \end{bmatrix}
\end{align}
</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>s = \sin \theta</math> и <math>c = \cos \theta</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>\dfrac{a_{jj}-a_{kk}}{2a_{jk}}=\dfrac{c^2-s^2}{2sc}=\dfrac{\cos2\theta}{\sin2\theta}=\operatorname{ctg}2\theta\equiv\tau</math>

Положим <math>tg\theta=t=\dfrac{s}{c}</math>. Тогда <math>t^2+2t\tau-1=0</math>.

Решая квадратное уравнение, получим:
<math>t=\dfrac{\operatorname{sign}\tau}{\left|\tau\right|+\sqrt{1+\tau^2}}, c=\dfrac{1}{\sqrt{1+t^2}}, s=t\cdot c.</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма составляют вычисления элементов матрицы <math>A</math> в процессе применения матрицы поворота <math>J</math> :

1. Вычисления элементов <math>a_{jl}^{(i+1)} = a_{lj}^{(i+1)}</math> и <math>a_{kl}^{(i+1)} = a_{lk}^{(i+1)}</math> (каждое <math>(n-2)</math> раз):

<math>\begin{align}
a_{jl}^{(i+1)} = a_{lj}^{(i+1)} = c \, a_{jl}^{(i)} - s \, a_{kl}^{(i)}, l \ne j,k;\\
a_{kl}^{(i+1)} = a_{lk}^{(i+1)} = s \, a_{jl}^{(i)} + c \, a_{kl}^{(i)}, l \ne j,k.
\end{align}</math>

2. Вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>:

<math>\begin{align}
a_{jj}^{(i+1)} &= c^2\, a_{jj}^{(i)} - 2\, s c \,a_{jk}^{(i)} + s^2\, a_{kk}^{(i)}; \\
a_{kk}^{(i+1)} &= s^2 \,a_{jj}^{(i)} + 2 s c\, a_{jk}^{(i)} + c^2 \, a_{kk}^{(i)}.
\end{align}</math>

== Макроструктура алгоритма ==
Макроструктуру алгоритма можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246, алгоритм 5.6)</ref>:

repeat
выбрать пару индексов j, k
обратиться к процедуре JacobiRotation(A,j,k)
пока А не станет достаточно близка к диагональной матрице

==Схема реализации последовательного алгоритма==
В классическом алгоритме Якоби для обнуления на текущей итерации выбирался наибольший элемент <math>a_{jk}</math>. Поиск наибольшего элемента слишком замедляет процесс вычислений (нужно провести поиск среди <math>\dfrac{n^2-n}{2}</math> элементов, прежде чем выполнить вращение стоимостью в <math>O(n)</math> флопов), поэтому для практических вычислений выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

Таким образом, алгоритм можно описать так<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 247, алгоритм 5.8)</ref>:

repeat
for j=1 to n-1
for k=j+1 to n
выполнить процедуру '''''JacobiRotation'''(A, j, k)''
end for
end for
пока A не достаточно близка к диагональной матрице

Процедура '''''JacobiRotation'''(A, j, k)'':

if <math>|a_{jk}|</math> не слишком мал
<math>\begin{align}
\tau &= \frac{a_{jj}-a_{kk}}{2\,a_{jk}} \\
t &= \frac{sign(\tau)}{|\tau|+\sqrt{1+\tau^2}} \\
c &= \frac{1}{\sqrt{1+t^2}} \\
s &= c\cdot t \\
A &= J_i^T\cdot A\cdot J_i, \qquad
J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}
</math>
end if
==Последовательная сложность алгоритма==
Для одной итерации вычислений собственных значений матрицы порядка <math>n</math> методом Якоби требуется:

Для вычислительного ядра:

*<math>4\,n+6</math> умножений,
*<math>2n</math> сложений.

Для остальной части алгоритма:

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

Умножения и сложения (вычитания) составляют основную часть алгоритма.

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

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

==Информационный граф==
==Ресурс параллелизма алгоритма==
==Входные и выходные данные алгоритма==
'''Входные данные:'''

1. Плотная матрица <math>A=\{a_{ij}\}, A\in\R^{n\times n}</math>. Дополнительные ограничения:
* <math>A</math> — симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

2. Число двойной точности <math>\epsilon</math>, определяющее допустимый порядок малости внедиагональных элементов.

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

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

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

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

==Свойства алгоритма==
Из существующихалгоритмов вычисления собственных значений симметричной матрицы метод Якоби является самым медленным. Его преимущество заключается в том, что он не предполагает первоначального приведения матрицы к трехдиагональной форме. Также метод до сих пор используется на практике для вычисления малых собственных чисел и отвечающих им собственных векторов, так как он делает это с гораздо большей точностью, чем другие методы<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244)</ref>.

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

Метод Якоби не детерминирован, так как является итерационным алгоритмом с выходом по точности: число итераций зависит от входных данных и порогового значения.

Дуги информационного графа, исходящие из вершин, соответствующих вычислениям значений <math>c</math> и <math>s</math>, образуют пучки рассылок линейной мощности.

=ЧАСТЬ. Программная реализация алгоритма=
==Масштабируемость алгоритма и его реализации==
==Существующие реализации алгоритма==
Библиотека [https://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE] содержит последовательную реализацию алгоритма.

Существует также [http://ieeexplore.ieee.org/document/6310877/ параллельная реализация] метода на платформе CUDA.

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

Участница:Tameeva.a/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-15T17:59:26Z

Tameeva.a: /* Входные и выходные данные алгоритма */

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

Основные авторы описания: [[Участник:Tameeva.a|А. Тамеева]], [[Участник:AKukhtinov|А. Кухтинов]].

=ЧАСТЬ. Свойства и структура алгоритмов=
== Общее описание алгоритма ==

Метод Якоби вычисления собственных значений симметричной матрицы — итерационный алгоритм, названный в честь предложившего его для конкретной матрицы 7 × 7 в 1846 году Карла Густава Якоба Якоби<ref>Jacobi, C.G.J. (1846). «[http://resolver.sub.uni-goettingen.de/purl/?GDZPPN002144522 Über ein leichtes Verfahren, die in der Theorie der Säkularstörungen vorkommenden Gleichungen numerisch aufzulösen]» (German). Crelle's Journal 30: 51–94.</ref>. Исторически старейший метод для решения симметрической проблемы собственных значений получил широкое применение только в 1950-х годах с появлением компьютеров. Преимуществом метода является более точное вычисление малых собственных значений по сравнению с конкурирующими алгоритмами.

Суть алгоритма — приведение симметрической матрицы к диагональной с собственными значениями на диагонали путем вращения.

== Математическое описание алгоритма<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>==
Исходные данные: симметрическая матрица <math>A=\{a_{ij}\}</math>.

Вычисляемые данные: диагональная матрица <math>\Lambda=\{\lambda_{ii}\}</math>. Диагональные элементы <math>\Lambda</math> — собственные значения матрицы <math>A</math>, столбцы — приближенные собственные вектора матрицы <math>A</math>.

По заданной матрице <math>A=A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,\ldots, A_m</math>, сходящихся к <math>\Lambda</math>.

<math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math> J_i</math> — ортогональная матрица, называемая вращением Якоби.

Матрица <math>J_i</math> выбирается так, чтобы обнулить элементы <math>(j,k)</math> и <math>(k,j)</math> матрицы <math>A_{i+1}</math>:

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

<math>
\begin{align}
J_i = R(j,k,\theta) = \begin{matrix} \\ \\ \\ j \\ \\ k \\ \\ \\ \\ \end{matrix} \begin{bmatrix} & 1 & & & & & & & & \\ & & 1 & & & & & & & \\ & & & \ddots & & & & & & \\ & & & & \cos(\theta) & & -\sin(\theta) & & & \\ & & & & & \ddots & & & & \\ & & & & \sin(\theta) & & \cos(\theta) & & & \\ & & & & & & & \ddots & & \\ & & & & & & & & 1 & \\ & & & & & & & & & 1 \\ \end{bmatrix}
\end{align}
</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>s = \sin \theta</math> и <math>c = \cos \theta</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>\dfrac{a_{jj}-a_{kk}}{2a_{jk}}=\dfrac{c^2-s^2}{2sc}=\dfrac{\cos2\theta}{\sin2\theta}=\operatorname{ctg}2\theta\equiv\tau</math>

Положим <math>tg\theta=t=\dfrac{s}{c}</math>. Тогда <math>t^2+2t\tau-1=0</math>.

Решая квадратное уравнение, получим:
<math>t=\dfrac{\operatorname{sign}\tau}{\left|\tau\right|+\sqrt{1+\tau^2}}, c=\dfrac{1}{\sqrt{1+t^2}}, s=t\cdot c.</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма составляют вычисления элементов матрицы <math>A</math> в процессе применения матрицы поворота <math>J</math> :

1. Вычисления элементов <math>a_{jl}^{(i+1)} = a_{lj}^{(i+1)}</math> и <math>a_{kl}^{(i+1)} = a_{lk}^{(i+1)}</math> (каждое <math>(n-2)</math> раз):

<math>\begin{align}
a_{jl}^{(i+1)} = a_{lj}^{(i+1)} = c \, a_{jl}^{(i)} - s \, a_{kl}^{(i)}, l \ne j,k;\\
a_{kl}^{(i+1)} = a_{lk}^{(i+1)} = s \, a_{jl}^{(i)} + c \, a_{kl}^{(i)}, l \ne j,k.
\end{align}</math>

2. Вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>:

<math>\begin{align}
a_{jj}^{(i+1)} &= c^2\, a_{jj}^{(i)} - 2\, s c \,a_{jk}^{(i)} + s^2\, a_{kk}^{(i)}; \\
a_{kk}^{(i+1)} &= s^2 \,a_{jj}^{(i)} + 2 s c\, a_{jk}^{(i)} + c^2 \, a_{kk}^{(i)}.
\end{align}</math>

== Макроструктура алгоритма ==
Макроструктуру алгоритма можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246, алгоритм 5.6)</ref>:

repeat
выбрать пару индексов j, k
обратиться к процедуре JacobiRotation(A,j,k)
пока А не станет достаточно близка к диагональной матрице

==Схема реализации последовательного алгоритма==
В классическом алгоритме Якоби для обнуления на текущей итерации выбирался наибольший элемент <math>a_{jk}</math>. Поиск наибольшего элемента слишком замедляет процесс вычислений (нужно провести поиск среди <math>\dfrac{n^2-n}{2}</math> элементов, прежде чем выполнить вращение стоимостью в <math>O(n)</math> флопов), поэтому для практических вычислений выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

Таким образом, алгоритм можно описать так<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 247, алгоритм 5.8)</ref>:

repeat
for j=1 to n-1
for k=j+1 to n
выполнить процедуру '''''JacobiRotation'''(A, j, k)''
end for
end for
пока A не достаточно близка к диагональной матрице

Процедура '''''JacobiRotation'''(A, j, k)'':

if <math>|a_{jk}|</math> не слишком мал
<math>\begin{align}
\tau &= \frac{a_{jj}-a_{kk}}{2\,a_{jk}} \\
t &= \frac{sign(\tau)}{|\tau|+\sqrt{1+\tau^2}} \\
c &= \frac{1}{\sqrt{1+t^2}} \\
s &= c\cdot t \\
A &= J_i^T\cdot A\cdot J_i, \qquad
J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}
</math>
end if
==Последовательная сложность алгоритма==
Для одной итерации вычислений собственных значений матрицы порядка <math>n</math> методом Якоби требуется:

Для вычислительного ядра:

*<math>4\,n+6</math> умножений,
*<math>2n</math> сложений.

Для остальной части алгоритма:

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

Умножения и сложения (вычитания) составляют основную часть алгоритма.

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

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

==Информационный граф==
==Ресурс параллелизма алгоритма==
==Входные и выходные данные алгоритма==
'''Входные данные:'''
1. Плотная матрица <math>A=\{a_{ij}\}, A\in\R^{n\times n}</math>. Дополнительные ограничения:
* <math>A</math> — симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

2. Число двойной точности <math>\epsilon</math>, определяющее допустимый порядок малости внедиагональных элементов.

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

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

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

==Свойства алгоритма==
Из существующихалгоритмов вычисления собственных значений симметричной матрицы метод Якоби является самым медленным. Его преимущество заключается в том, что он не предполагает первоначального приведения матрицы к трехдиагональной форме. Также метод до сих пор используется на практике для вычисления малых собственных чисел и отвечающих им собственных векторов, так как он делает это с гораздо большей точностью, чем другие методы<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244)</ref>.

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

Метод Якоби не детерминирован, так как является итерационным алгоритмом с выходом по точности: число итераций зависит от входных данных и порогового значения.

Дуги информационного графа, исходящие из вершин, соответствующих вычислениям значений <math>c</math> и <math>s</math>, образуют пучки рассылок линейной мощности.

=ЧАСТЬ. Программная реализация алгоритма=
==Масштабируемость алгоритма и его реализации==
==Существующие реализации алгоритма==
Библиотека [https://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE] содержит последовательную реализацию алгоритма.

Существует также [http://ieeexplore.ieee.org/document/6310877/ параллельная реализация] метода на платформе CUDA.

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

Участница:Tameeva.a/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-15T17:53:31Z

Tameeva.a: /* Свойства алгоритма */

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

Основные авторы описания: [[Участник:Tameeva.a|А. Тамеева]], [[Участник:AKukhtinov|А. Кухтинов]].

=ЧАСТЬ. Свойства и структура алгоритмов=
== Общее описание алгоритма ==

Метод Якоби вычисления собственных значений симметричной матрицы — итерационный алгоритм, названный в честь предложившего его для конкретной матрицы 7 × 7 в 1846 году Карла Густава Якоба Якоби<ref>Jacobi, C.G.J. (1846). «[http://resolver.sub.uni-goettingen.de/purl/?GDZPPN002144522 Über ein leichtes Verfahren, die in der Theorie der Säkularstörungen vorkommenden Gleichungen numerisch aufzulösen]» (German). Crelle's Journal 30: 51–94.</ref>. Исторически старейший метод для решения симметрической проблемы собственных значений получил широкое применение только в 1950-х годах с появлением компьютеров. Преимуществом метода является более точное вычисление малых собственных значений по сравнению с конкурирующими алгоритмами.

Суть алгоритма — приведение симметрической матрицы к диагональной с собственными значениями на диагонали путем вращения.

== Математическое описание алгоритма<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>==
Исходные данные: симметрическая матрица <math>A=\{a_{ij}\}</math>.

Вычисляемые данные: диагональная матрица <math>\Lambda=\{\lambda_{ii}\}</math>. Диагональные элементы <math>\Lambda</math> — собственные значения матрицы <math>A</math>, столбцы — приближенные собственные вектора матрицы <math>A</math>.

По заданной матрице <math>A=A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,\ldots, A_m</math>, сходящихся к <math>\Lambda</math>.

<math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math> J_i</math> — ортогональная матрица, называемая вращением Якоби.

Матрица <math>J_i</math> выбирается так, чтобы обнулить элементы <math>(j,k)</math> и <math>(k,j)</math> матрицы <math>A_{i+1}</math>:

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

<math>
\begin{align}
J_i = R(j,k,\theta) = \begin{matrix} \\ \\ \\ j \\ \\ k \\ \\ \\ \\ \end{matrix} \begin{bmatrix} & 1 & & & & & & & & \\ & & 1 & & & & & & & \\ & & & \ddots & & & & & & \\ & & & & \cos(\theta) & & -\sin(\theta) & & & \\ & & & & & \ddots & & & & \\ & & & & \sin(\theta) & & \cos(\theta) & & & \\ & & & & & & & \ddots & & \\ & & & & & & & & 1 & \\ & & & & & & & & & 1 \\ \end{bmatrix}
\end{align}
</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>s = \sin \theta</math> и <math>c = \cos \theta</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>\dfrac{a_{jj}-a_{kk}}{2a_{jk}}=\dfrac{c^2-s^2}{2sc}=\dfrac{\cos2\theta}{\sin2\theta}=\operatorname{ctg}2\theta\equiv\tau</math>

Положим <math>tg\theta=t=\dfrac{s}{c}</math>. Тогда <math>t^2+2t\tau-1=0</math>.

Решая квадратное уравнение, получим:
<math>t=\dfrac{\operatorname{sign}\tau}{\left|\tau\right|+\sqrt{1+\tau^2}}, c=\dfrac{1}{\sqrt{1+t^2}}, s=t\cdot c.</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро алгоритма составляют вычисления элементов матрицы <math>A</math> в процессе применения матрицы поворота <math>J</math> :

1. Вычисления элементов <math>a_{jl}^{(i+1)} = a_{lj}^{(i+1)}</math> и <math>a_{kl}^{(i+1)} = a_{lk}^{(i+1)}</math> (каждое <math>(n-2)</math> раз):

<math>\begin{align}
a_{jl}^{(i+1)} = a_{lj}^{(i+1)} = c \, a_{jl}^{(i)} - s \, a_{kl}^{(i)}, l \ne j,k;\\
a_{kl}^{(i+1)} = a_{lk}^{(i+1)} = s \, a_{jl}^{(i)} + c \, a_{kl}^{(i)}, l \ne j,k.
\end{align}</math>

2. Вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>:

<math>\begin{align}
a_{jj}^{(i+1)} &= c^2\, a_{jj}^{(i)} - 2\, s c \,a_{jk}^{(i)} + s^2\, a_{kk}^{(i)}; \\
a_{kk}^{(i+1)} &= s^2 \,a_{jj}^{(i)} + 2 s c\, a_{jk}^{(i)} + c^2 \, a_{kk}^{(i)}.
\end{align}</math>

== Макроструктура алгоритма ==
Макроструктуру алгоритма можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246, алгоритм 5.6)</ref>:

repeat
выбрать пару индексов j, k
обратиться к процедуре JacobiRotation(A,j,k)
пока А не станет достаточно близка к диагональной матрице

==Схема реализации последовательного алгоритма==
В классическом алгоритме Якоби для обнуления на текущей итерации выбирался наибольший элемент <math>a_{jk}</math>. Поиск наибольшего элемента слишком замедляет процесс вычислений (нужно провести поиск среди <math>\dfrac{n^2-n}{2}</math> элементов, прежде чем выполнить вращение стоимостью в <math>O(n)</math> флопов), поэтому для практических вычислений выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

Таким образом, алгоритм можно описать так<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 247, алгоритм 5.8)</ref>:

repeat
for j=1 to n-1
for k=j+1 to n
выполнить процедуру '''''JacobiRotation'''(A, j, k)''
end for
end for
пока A не достаточно близка к диагональной матрице

Процедура '''''JacobiRotation'''(A, j, k)'':

if <math>|a_{jk}|</math> не слишком мал
<math>\begin{align}
\tau &= \frac{a_{jj}-a_{kk}}{2\,a_{jk}} \\
t &= \frac{sign(\tau)}{|\tau|+\sqrt{1+\tau^2}} \\
c &= \frac{1}{\sqrt{1+t^2}} \\
s &= c\cdot t \\
A &= J_i^T\cdot A\cdot J_i, \qquad
J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}
</math>
end if
==Последовательная сложность алгоритма==
Для одной итерации вычислений собственных значений матрицы порядка <math>n</math> методом Якоби требуется:

Для вычислительного ядра:

*<math>4\,n+6</math> умножений,
*<math>2n</math> сложений.

Для остальной части алгоритма:

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

Умножения и сложения (вычитания) составляют основную часть алгоритма.

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

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

==Информационный граф==
==Ресурс параллелизма алгоритма==
==Входные и выходные данные алгоритма==
'''Входные данные:''' плотная матрица <math>A=\{a_{ij}\}, A\in\R^{n\times n}</math>. Дополнительные ограничения:
* <math>A</math> — симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

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

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

'''Объём выходных данных:''' <math>n</math>
==Свойства алгоритма==
Из существующихалгоритмов вычисления собственных значений симметричной матрицы метод Якоби является самым медленным. Его преимущество заключается в том, что он не предполагает первоначального приведения матрицы к трехдиагональной форме. Также метод до сих пор используется на практике для вычисления малых собственных чисел и отвечающих им собственных векторов, так как он делает это с гораздо большей точностью, чем другие методы<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244)</ref>.

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

Метод Якоби не детерминирован, так как является итерационным алгоритмом с выходом по точности: число итераций зависит от входных данных и порогового значения.

Дуги информационного графа, исходящие из вершин, соответствующих вычислениям значений <math>c</math> и <math>s</math>, образуют пучки рассылок линейной мощности.

=ЧАСТЬ. Программная реализация алгоритма=
==Масштабируемость алгоритма и его реализации==
==Существующие реализации алгоритма==
Библиотека [https://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE] содержит последовательную реализацию алгоритма.

Существует также [http://ieeexplore.ieee.org/document/6310877/ параллельная реализация] метода на платформе CUDA.

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

Участница:Tameeva.a/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-15T17:40:30Z

Tameeva.a: /* Существующие реализации алгоритма */

Участница:Tameeva.a/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-15T10:12:14Z

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

Участница:Tameeva.a/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-15T09:50:28Z

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

Участница:Tameeva.a/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-15T09:49:28Z

Tameeva.a: /* Математическое описание алгоритмаДж. Деммель «Вычислительная линейная алгебра» (стр. 244-245) */

Участница:Tameeva.a/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-15T09:46:46Z

Tameeva.a: /* Математическое описание алгоритмаДж. Деммель «Вычислительная линейная алгебра» (стр. 244-245) */

Участница:Tameeva.a/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-15T09:44:38Z

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

Участница:Tameeva.a/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-14T07:14:13Z

Tameeva.a: /* Свойства алгоритма */

Участница:Tameeva.a/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-13T19:12:06Z

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

Участница:Tameeva.a/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-13T19:05:59Z

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

Участница:Tameeva.a/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-12T19:01:19Z

Tameeva.a: /* Общее описание алгоритма */

Участница:Tameeva.a/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-12T18:59:13Z

Tameeva.a:

Участница:Tameeva.a/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-12T18:42:55Z

Tameeva.a:

Участница:Tameeva.a/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-12T17:28:53Z

Tameeva.a:

Участница:Tameeva.a/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-12T17:26:09Z

Tameeva.a:

Участница:Tameeva.a/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-12T17:08:18Z

Tameeva.a:

=ЧАСТЬ. Свойства и структура алгоритмов=
== Общее описание алгоритма ==

Метод Якоби вычисления собственных значений симметричной матрицы — итерационный алгоритм, названный в честь предложившего его в 1846 году Карла Густава Якоба Якоби. Исторически старейший метод для решения проблемы собственных значений получил широкое применение только в 1950-х годах с появлением компьютеров. Преимуществом метода является более точное вычисление малых собственных значений по сравнению с конкурирующими алгоритмами.

Суть алгоритма — приведение симметрической матрицы к диагональной с собственными значениями на диагонали путем вращения.

== Математическое описание алгоритма ==
Исходные данные: симметрическая матрица <math>A=\{a_{ij}\}</math>.

Вычисляемые данные: диагональная матрица <math>\Lambda=\{\lambda_{ii}\}</math>. Диагональные элементы <math>\Lambda</math> — собственные значения матрицы <math>A</math>, столбцы — приближенные собственные вектора.

По заданной матрице <math>A=A_0</math> строится последовательность ортогонально подобных матриц <math>A_1, A_2,\ldots, A_m</math>, сходящихся к <math>\Lambda</math>.

<math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math> J_i</math> — ортогональная матрица, называемая вращением Якоби.

Матрица <math>J_i</math> выбирается так, чтобы обнулить элементы <math>(j,k)</math> и <math>(k,j)</math> матрицы <math>A_{i+1}</math>:

<math>
\begin{matrix}j & & & & & & & & k \end{matrix}</math>

<math>
\begin{align}
J_i = R(j,k,\theta) = \begin{matrix} \\ \\ j \\ \\ \\ \\ \\k \\ \\ \end{matrix} \begin{bmatrix} & 1 & & & & & & & & \\ & & 1 & & & & & & & \\ & & & \ddots & & & & & & \\ & & & & \cos(\theta) & & -\sin(\theta) & & & \\ & & & & & \ddots & & & & \\ & & & & \sin(\theta) & & \cos(\theta) & & & \\ & & & & & & & \ddots & & \\ & & & & & & & & 1 & \\ & & & & & & & & & 1 \\ \end{bmatrix}
\end{align}
</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>s = \sin \theta</math> и <math>c = \cos \theta</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>\dfrac{a_{jj}-a_{kk}}{2a_{jk}}=\dfrac{c^2-s^2}{2sc}=\dfrac{\cos2\theta}{\sin2\theta}=\operatorname{ctg}2\theta\equiv\tau</math>

Положим <math>tg\theta=t=\dfrac{s}{c}</math>. Тогда <math>t^2+2t\tau-1=0</math>.

Решая квадратное уравнение, получим:
<math>t=\dfrac{\operatorname{sign}\tau}{\left|\tau\right|+\sqrt{1+\tau^2}}, c=\dfrac{1}{\sqrt{1+t^2}}, s=t\cdot c.</math>

== Вычислительное ядро алгоритма ==
Вычислительное ядро состоит из вычислений элементов матрицы <math>a_{jl}^{(i+1)} = a_{lj}^{(i+1)}</math> и <math>a_{kl}^{(i+1)} = a_{lk}^{(i+1)}</math> в процессе применения матрицы поворота <math>J</math> к матрице <math>A</math>:

<math>a_{jl}^{(i+1)} = a_{lj}^{(i+1)} = c \, a_{jl}^{(i)} - s \, a_{kl}^{(i)}, l \ne j,k</math>

<math>a_{kl}^{(i+1)} = a_{lk}^{(i+1)} = s \, a_{jl}^{(i)} + c \, a_{kl}^{(i)}, l \ne j,k,
</math>

каждое из которых повторяется по <math>(n-2)</math> раза.
== Макроструктура алгоритма ==
Макроструктуру алгоритма можно описать следующим образом:

repeat
выбрать пару индексов j, k
обратиться к процедуре JacobiRotation(A,j,k)
пока А не станет достаточно близка к диагональной матрице

==Схема реализации последовательного алгоритма==
В классическом алгоритме Якоби для обнуления на текущей итерации выбирался наибольший элемент <math>a_{jk}</math>. Поиск наибольшего элемента слишком замедляет процесс вычислений (нужно провести поиск среди <math>\dfrac{n^2-n}{2}</math> элементов, прежде чем выполнить вращение стоимостью в <math>O(n)</math> флопов), поэтому для практических вычислений выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

Таким образом, алгоритм можно описать так:

repeat
for j=1 to n-1
for k=j+1 to n
выполнить процедуру '''''JacobiRotation'''(A, j, k)''
end for
end for
пока A не достаточно близка к диагональной матрице

Процедура '''''JacobiRotation'''(A, j, k)'':

if <math>|a_{jk}|</math> не слишком мал
<math>\begin{align}
\tau &= \frac{a_{jj}-a_{kk}}{2\,a_{jk}} \\
t &= \frac{sign(\tau)}{|\tau|+\sqrt{1+\tau^2}} \\
c &= \frac{1}{\sqrt{1+t^2}} \\
s &= c\cdot t \\
A &= J_i^T\cdot A\cdot J_i, \qquad
J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}
</math>
end if
==Последовательная сложность алгоритма==
Для вычисления собственных значений вещественной симметричной матрицы порядка <math>n</math> методом Якоби требуется:

Для вычислительного ядра:

<math>2\,n(n-1)(n-2)</math> умножений,

<math>n(n-1)(n-2)</math> сложений.

Для остальной части алгоритма:

<math>\frac{3\,n(n-1)}{2}</math> умножений,

<math>\frac{3\,n(n-1)}{2}</math> делений,

<math>\frac{5\,n(n-1)}{2}</math> сложений (вычитаний),

<math>n(n-1)</math> операций извлечения квадратного корня.
Умножения и сложения (вычитания) составляют основную часть алгоритма.

Таким образом, при классификации по последовательной сложности метод Якоби вычисления собственных значений симметричной матрицы относится к алгоритмам с ''кубической сложностью''.
==Информационный граф==
==Ресурс параллелизма алгоритма==
==Входные и выходные данные алгоритма==
'''Входные данные:''' плотная матрица <math>A=\{a_{ij}\}, A\in\R^{n\times n}</math>. Дополнительные ограничения:
<math>A</math> — симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

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

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

'''Объём выходных данных:''' <math>n</math>
==Свойства алгоритма==
=ЧАСТЬ. Программная реализация алгоритма=
=Литература=

Участница:Tameeva.a/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-12T16:19:30Z

Tameeva.a:

Участница:Tameeva.a/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-12T16:17:25Z

Tameeva.a:

Участница:Tameeva.a/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-12T16:16:36Z

Tameeva.a:

Участница:Tameeva.a/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-12T15:36:55Z

Tameeva.a:

Участница:Tameeva.a/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-12T15:34:55Z

Tameeva.a:

Участница:Tameeva.a/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-12T15:34:31Z

Tameeva.a:

Участница:Tameeva.a/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-12T14:11:09Z

Tameeva.a: Новая страница: «=ЧАСТЬ. Свойства и структура алгоритмов= == Общее описание алгоритма == Метод Якоби вычисл…»