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

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

2016-12-07T16:31:50Z

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

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

Авторы описания: [[Участник: Galkina|А.С.Галкина]] (входные и выходные данные, математическое описание алгоритма и др.), [[Участник: Игорь|И.А.Плахов]] (ресурс параллелизма алгоритма,последовательная сложность алгоритма и др.) Вклад авторов считать равноценным.

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

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

Метод Якоби — итерационный алгоритм для вычисления собственных значений и собственных векторов вещественной симметричной матрицы. Карл Густав Якоб Якоби, в честь которого назван этот метод, предложил его в 1846 году, хотя использоваться он начал только в 1950-х годах с появлением компьютеров.
Суть алгоритма заключается в том, чтобы по заданной симметрической матрице <math>A = A_0</math> построить последовательность ортогонально подобных матриц <math>A_1,A_2,\dotsc,A_m</math>, сходящуюся к диагональной матрице, на диагонали которой стоят собственные значения. Для построения этой последовательности применяется специально подобранная матрица поворота <math>J_i</math>, такая что норма наддиагональной части <math>of\!f(A)=\sqrt{\sum\limits_{1 \le j < k \le n} a_{jk}^2}</math> уменьшается при каждом повороте матрицы <math>A</math>. Вычисление останавливается, когда угол поворота становится близок к нулю, либо когда максимальный внедиагональный элемент становится меньше заранее выбранного порогового значения.

=== Математическое описание алгоритма ===
Исходные данные: симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>).

Матрица <math>A_{i+1}</math> получается из <math>A_i</math> по формуле <math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math>J_i</math> — ортогональная матрица, называемая ''вращением Якоби''.
При подходящем выборе <math>J_i</math> матрица <math>A_m</math> для больших m будет близка к диагональной матрице <math>\Lambda</math>.

Матрица <math>J_i</math> выбирается так, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}</math> <ref name="VVVVVV">Деммель Дж. Вычислительная линейная алгебра. - М.: МИР, 2001 - С. 244-248</ref>.



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

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

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>. Тогда матрица <math>A_{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)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Можно выбрать <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>. Отсюда получим равенство

: <math> \frac{a_{jj}^{(i)} - a_{kk}^{(i)}}{2 a_{jk}^{(i)}} = \frac{c^2 - s^2}{2sc} = \frac{\cos (2\theta)}{\sin (2\theta)} = \operatorname{ctg}(2\theta) \equiv \tau </math>.

Если <math> a_{jj}^{(i)} = a_{kk}^{(i)}</math>, то <math>\theta = \frac{\pi}{4}</math>.

Положим <math>t = \frac{s}{c} = \operatorname{tg}(\theta)</math> и заметим, что <math>t^2 - 2t\tau + 1 = 0</math>. Решая квадратное уравнение, находим <math>t = \frac{\operatorname{sign}(\tau)}{|\tau| + \sqrt{1+\tau^2}}, c = \frac{1}{\sqrt{1+t^2}}, s = tc</math>.

Выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

=== Вычислительное ядро алгоритма ===
Рассматривая отдельную итерацию, можно считать, что вычислительное ядро составляют множественные вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>   в процессе применения матрицы поворота <math>J_i</math> к матрице <math>A</math>:
: <math>\begin{align}
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k,
\end{align}</math>

каждое из которых повторяется по <math> (n-2) </math> раза, а также вычисление элементов <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>

=== Макроструктура алгоритма ===
Основную часть метода составляет процедура применения вращения к матрице <math>A</math>, которая в дальнейшем будет обозначена как '''''Jakobi-Rotation<math>(A,j,k)</math>'''''.

Эту процедуру, в свою очередь, можно разделить на две логические части:
# Определение угла поворота <math>\theta</math> по элементам матрицы <math>a_{jj}</math>, <math>a_{kk}</math> и <math>a_{jk}</math>;
# Поворот матрицы <math>A</math> (изменяются лишь строки и столбцы, соответствующие индексам <math>j</math> и  <math>k</math>).

=== Схема реализации последовательного алгоритма ===
Алгоритм можно описать следующим образом <ref name="VVVVVV" />:

1. Выбрать пару индексов j,k
2. Обратиться к процедуре '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
Если <math>A</math> не достаточно близка к диагональной матрице, перейти к шагу 1.

Существует несколько способов выбора пары <math>j,k</math>. Наиболее простой и быстрый способ — построчный циклический обход внедиагональных элементов матрицы <math>A</math>:

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

Процедура '''''Jakobi-Rotation<math>(A,j,k)</math>''''' — это следующий алгоритм:
Если <math>|a_{jk}|</math> достаточно мал, вычисление заканчивается. В противном случае выполняются следующие действия:
1. Если <math>a_{jj}==a_{kk}</math>, то угол <math>\theta=\frac{\pi}{4}</math>.
В остальных случаях находим параметры <math>\tau,\ t,\ c,\ s</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\,t
\end{align}</math>
2. Выполняется поворот матрицы (изменяются лишь строки и столбцы, соответствующие индексам <math>i</math> и <math>j</math>):
<math>A = R^T(j,k,\theta)\cdot A\cdot R(j,k,\theta), \qquad J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta </math>

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

Для осуществления одной итерации метода Якоби для матрицы размера <math>(n\times n)</math> требуется выполнить:

Для вычислительного ядра —
* <math> 4n+4 </math> умножений,
* <math> 2n+2 </math> сложений.

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

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

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

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

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

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

'''Первой''' группе вершин (J) соответствует вычисление значений c и s.

'''Второй''' группе вершин (А) соответствует вычисление значений элементов <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>.

'''Третьей''' группе вершин (B) соответствует вычисление значений элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>.



[[File:Информационный_граф_метода_якоби.png|none|thumb|2000px|Рисунок 1. Граф одной итерации алгоритма без отображения входных и выходных данных.]]

[[File:ГрафJ.png|none|thumb|2000px|Рисунок 2. Внутренний граф вершин J с входными параметрами <math>x = a_{jj}^{(i)}, y = a_{kk}^{(i)}, z = a_{jk}^{(i)}</math>.]]

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

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

После этого выполняется ярус, отвечающий за применение поворота к матрице <math>A</math> с параллельным выполнением <math>2(n-2)</math> операций вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math> , а также 2 операций вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>. Наибольшее количество операций содержится в вычислении последних двух элементов (по 6 умножений и 3 сложения).

Суммарное количество итераций зависит от входных данных и заданного значения погрешности. Один "цикл" (полный проход по внедиагональным элементам) осуществляется за <math>N = \frac{n(n-1)}{2}</math> итераций. Асимптотически метод сходится квадратично <ref>Wilkinson J. H. The Algebraic Eigenvalue Problem // Oxford University Press, UK, 1965, P. 270</ref>. Как правило, для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов <ref name="VVVVVV" />.

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

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

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

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

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

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

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

Метод Якоби является самым медленным из имеющихся алгоритмов вычисления собственных значений симметричной матрицы. Тем не менее, он способен вычислять малые собственные числа и отвечающие им собственные векторы с гораздо большей точностью, чем другие методы <ref name="VVVVVV" />. Кроме того, он не предполагает первоначального приведения матрицы к трехдиагональной форме.

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

Вычислительная мощность алгоритма линейна.

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

Дуги информационного графа, исходящие из вершин, соответствующих вычислениям значений <math>c</math> и <math>s</math>, образуют пучки рассылок линейной мощности.

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Исследование масштабируемости проводилось на суперкомпьютере "Ломоносов" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского Государственного Университета имени М.В. Ломоносова]. Алгоритм реализован на языке C++ с использованием средств MPI. Компиляция производилась с помощью команды mpicxx с использованием компилятора Intel с OpenMPI и библиотеки MKL. Были подключены следующие модули: openmpi/1.5.5-icc, intel/13.1.0, mkl/4.0.2.146. Программа была запущена в очередях test и regular4.

Значения изменяемых параметров запуска реализации алгоритма:
* число процессов: 2, 4, 8, 16, 32, 64;
* число элементов в матрице: 900, 3600, 8100, 14400, 22500, 32400, 44100, 57600, 72900, 90000.

На следующих рисунках приведены графики времени выполнения и производительности выбранной реализации алгоритма в зависимости от изменяемых параметров запуска

[[File:jacobi_time.jpg|thumb|center|1500px|Рисунок 3. Изменение времени выполнения в зависимости от числа процессов и размера входной матрицы]]
[[File:jacobi_perform.jpg|thumb|center|1500px|Рисунок 4. Изменение производительности в зависимости от числа процессов и размера входной матрицы]]

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

Реализация алгоритма доступна по [http://pastebin.com/juwPJRhH ссылке].

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

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

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

Существует библиотека JACOBI_EIGENVALUE, реализующая последовательный вариант метода Якоби на языках программирования [http://people.sc.fsu.edu/~jburkardt/c_src/jacobi_eigenvalue/jacobi_eigenvalue.html С], [http://people.sc.fsu.edu/~jburkardt/cpp_src/jacobi_eigenvalue/jacobi_eigenvalue.html С++], [http://people.sc.fsu.edu/~jburkardt/f77_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN77], [http://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN90], [http://people.sc.fsu.edu/~jburkardt/m_src/jacobi_eigenvalue/jacobi_eigenvalue.html MATLAB], [http://people.sc.fsu.edu/~jburkardt/py_src/jacobi_eigenvalue/jacobi_eigenvalue.html Python].
Данная библиотека распространяется по лицензии [http://people.sc.fsu.edu/~jburkardt/txt/gnu_lgpl.txt GNU LESSER GENERAL PUBLIC LICENSE].

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

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

<references \>

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

2016-11-21T20:14:37Z

Игорь:

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

Авторы описания: [[Участник: Galkina|А.С.Галкина]] (входные и выходные данные, математическое описание алгоритма и др.), [[Участник: Игорь|И.А.Плахов]] (ресурс параллелизма алгоритма,последовательная сложность алгоритма и др.) Вклад авторов считать равноценным.

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

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

Метод Якоби — итерационный алгоритм для вычисления собственных значений и собственных векторов вещественной симметричной матрицы. Карл Густав Якоб Якоби, в честь которого назван этот метод, предложил его в 1846 году, хотя использоваться он начал только в 1950-х годах с появлением компьютеров.
Суть алгоритма заключается в том, чтобы по заданной симметрической матрице <math>A = A_0</math> построить последовательность ортогонально подобных матриц <math>A_1,A_2,\dotsc,A_m</math>, сходящуюся к диагональной матрице, на диагонали которой стоят собственные значения. Для построения этой последовательности применяется специально подобранная матрица поворота <math>J_i</math>, такая что норма наддиагональной части <math>of\!f(A)=\sqrt{\sum\limits_{1 \le j < k \le n} a_{jk}^2}</math> уменьшается при каждом повороте матрицы <math>A</math>. Вычисление останавливается, когда угол поворота становится близок к нулю, либо когда максимальный внедиагональный элемент становится меньше заранее выбранного порогового значения.

=== Математическое описание алгоритма ===
Исходные данные: симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>).

Матрица <math>A_{i+1}</math> получается из <math>A_i</math> по формуле <math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math>J_i</math> — ортогональная матрица, называемая ''вращением Якоби''.
При подходящем выборе <math>J_i</math> матрица <math>A_m</math> для больших m будет близка к диагональной матрице <math>\Lambda</math>.

Матрица <math>J_i</math> выбирается так, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}</math> <ref name="VVVVVV">Деммель Дж. Вычислительная линейная алгебра. - М.: МИР, 2001 - С. 244-248</ref>.



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

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

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>. Тогда матрица <math>A_{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)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Можно выбрать <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>. Отсюда получим равенство

: <math> \frac{a_{jj}^{(i)} - a_{kk}^{(i)}}{2 a_{jk}^{(i)}} = \frac{c^2 - s^2}{2sc} = \frac{\cos (2\theta)}{\sin (2\theta)} = \operatorname{ctg}(2\theta) \equiv \tau </math>.

Если <math> a_{jj}^{(i)} = a_{kk}^{(i)}</math>, то <math>\theta = \frac{\pi}{4}</math>.

Положим <math>t = \frac{s}{c} = \operatorname{tg}(\theta)</math> и заметим, что <math>t^2 - 2t\tau + 1 = 0</math>. Решая квадратное уравнение, находим <math>t = \frac{\operatorname{sign}(\tau)}{|\tau| + \sqrt{1+\tau^2}}, c = \frac{1}{\sqrt{1+t^2}}, s = tc</math>.

Выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

=== Вычислительное ядро алгоритма ===
Рассматривая отдельную итерацию, можно считать, что вычислительное ядро составляют множественные вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>   в процессе применения матрицы поворота <math>J_i</math> к матрице <math>A</math>:
: <math>\begin{align}
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k,
\end{align}</math>

каждое из которых повторяется по <math> (n-2) </math> раза, а также вычисление элементов <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>

=== Макроструктура алгоритма ===
Основную часть метода составляет процедура применения вращения к матрице <math>A</math>, которая в дальнейшем будет обозначена как '''''Jakobi-Rotation<math>(A,j,k)</math>'''''.

Эту процедуру, в свою очередь, можно разделить на две логические части:
# Определение угла поворота <math>\theta</math> по элементам матрицы <math>a_{jj}</math>, <math>a_{kk}</math> и <math>a_{jk}</math>;
# Поворот матрицы <math>A</math> (изменяются лишь строки и столбцы, соответствующие индексам <math>j</math> и  <math>k</math>).

=== Схема реализации последовательного алгоритма ===
Алгоритм можно описать следующим образом <ref name="VVVVVV" />:

repeat
выбрать пару индексов j,k
обратиться к процедуре '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
пока <math>A</math> не достаточно близка к диагональной матрице

Существует несколько способов выбора пары <math>j,k</math>. Наиболее простой и быстрый способ — построчный циклический обход внедиагональных элементов матрицы <math>A</math>:

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

Процедура '''''Jakobi-Rotation<math>(A,j,k)</math>''''' — это следующий алгоритм:
if <math>|a_{jk}|</math> не слишком мал
if <math>a_{jj}==a_{kk}</math>
<math>\theta=\frac{\Pi}{4}</math>
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\,t
\end{align}</math>
end if
<math>A = R^T(j,k,\theta)\cdot A\cdot R(j,k,\theta), \qquad J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta </math>
end if

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

Для осуществления одной итерации метода Якоби для матрицы размера <math>(n\times n)</math> требуется выполнить:

Для вычислительного ядра —
* <math> 4n+4 </math> умножений,
* <math> 2n+2 </math> сложений.

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

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

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

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

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

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

'''Первой''' группе вершин (J) соответствует вычисление значений c и s.

'''Второй''' группе вершин (А) соответствует вычисление значений элементов <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>.

'''Третьей''' группе вершин (B) соответствует вычисление значений элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>.



[[File:Информационный_граф_метода_якоби.png|none|thumb|2000px|Рисунок 1. Граф одной итерации алгоритма без отображения входных и выходных данных.]]

[[File:ГрафJ.png|none|thumb|2000px|Рисунок 2. Внутренний граф вершин J с входными параметрами <math>x = a_{jj}^{(i)}, y = a_{kk}^{(i)}, z = a_{jk}^{(i)}</math>.]]

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

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

После этого выполняется ярус, отвечающий за применение поворота к матрице <math>A</math> с параллельным выполнением <math>2(n-2)</math> операций вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math> , а также 2 операций вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>. Наибольшее количество операций содержится в вычислении последних двух элементов (по 6 умножений и 3 сложения).

Суммарное количество итераций зависит от входных данных и заданного значения погрешности. Один "цикл" (полный проход по внедиагональным элементам) осуществляется за <math>N = \frac{n(n-1)}{2}</math> итераций. Асимптотически метод сходится квадратично <ref>Wilkinson J. H. The Algebraic Eigenvalue Problem // Oxford University Press, UK, 1965, P. 270</ref>. Как правило, для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов <ref name="VVVVVV" />.

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

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

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

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

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

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

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

Метод Якоби является самым медленным из имеющихся алгоритмов вычисления собственных значений симметричной матрицы. Тем не менее, он способен вычислять малые собственные числа и отвечающие им собственные векторы с гораздо большей точностью, чем другие методы <ref name="VVVVVV" />. Кроме того, он не предполагает первоначального приведения матрицы к трехдиагональной форме.

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

Вычислительная мощность алгоритма линейна.

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

Дуги информационного графа, исходящие из вершин, соответствующих вычислениям значений <math>c</math> и <math>s</math>, образуют пучки рассылок линейной мощности.

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Исследование масштабируемости проводилось на суперкомпьютере "Ломоносов" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского Государственного Университета имени М.В. Ломоносова]. Алгоритм реализован на языке C++ с использованием средств MPI. Компиляция производилась с помощью команды mpicxx с использованием компилятора Intel с OpenMPI и библиотеки MKL. Были подключены следующие модули: openmpi/1.5.5-icc, intel/13.1.0, mkl/4.0.2.146. Программа была запущена в очередях test и regular4.

Значения изменяемых параметров запуска реализации алгоритма:
* число процессов: 2, 4, 8, 16, 32, 64;
* число элементов в матрице: 900, 3600, 8100, 14400, 22500, 32400, 44100, 57600, 72900, 90000.

На следующих рисунках приведены графики времени выполнения и производительности выбранной реализации алгоритма в зависимости от изменяемых параметров запуска

[[File:jacobi_time.jpg|thumb|center|1500px|Рисунок 3. Изменение времени выполнения в зависимости от числа процессов и размера входной матрицы]]
[[File:jacobi_perform.jpg|thumb|center|1500px|Рисунок 4. Изменение производительности в зависимости от числа процессов и размера входной матрицы]]

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

Реализация алгоритма доступна по [http://pastebin.com/juwPJRhH ссылке].

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

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

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

Существует библиотека JACOBI_EIGENVALUE, реализующая последовательный вариант метода Якоби на языках программирования [http://people.sc.fsu.edu/~jburkardt/c_src/jacobi_eigenvalue/jacobi_eigenvalue.html С], [http://people.sc.fsu.edu/~jburkardt/cpp_src/jacobi_eigenvalue/jacobi_eigenvalue.html С++], [http://people.sc.fsu.edu/~jburkardt/f77_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN77], [http://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN90], [http://people.sc.fsu.edu/~jburkardt/m_src/jacobi_eigenvalue/jacobi_eigenvalue.html MATLAB], [http://people.sc.fsu.edu/~jburkardt/py_src/jacobi_eigenvalue/jacobi_eigenvalue.html Python].
Данная библиотека распространяется по лицензии [http://people.sc.fsu.edu/~jburkardt/txt/gnu_lgpl.txt GNU LESSER GENERAL PUBLIC LICENSE].

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

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

<references \>

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

2016-11-21T19:53:37Z

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

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

Авторы описания: [[Участник: Galkina|А.С.Галкина]] (входные и выходные данные, математическое описание алгоритма и др.), [[Участник: Игорь|И.А.Плахов]] (ресурс параллелизма алгоритма,последовательная сложность алгоритма и др.) Вклад авторов считать равноценным.

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

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

Метод Якоби — итерационный алгоритм для вычисления собственных значений и собственных векторов вещественной симметричной матрицы. Карл Густав Якоб Якоби, в честь которого назван этот метод, предложил его в 1846 году, хотя использоваться он начал только в 1950-х годах с появлением компьютеров.
Суть алгоритма заключается в том, чтобы по заданной симметрической матрице <math>A = A_0</math> построить последовательность ортогонально подобных матриц <math>A_1,A_2,\dotsc,A_m</math>, сходящуюся к диагональной матрице, на диагонали которой стоят собственные значения. Для построения этой последовательности применяется специально подобранная матрица поворота <math>J_i</math>, такая что норма наддиагональной части <math>of\!f(A)=\sqrt{\sum\limits_{1 \le j < k \le n} a_{jk}^2}</math> уменьшается при каждом повороте матрицы <math>A</math>. Вычисление останавливается, когда угол поворота становится близок к нулю, либо когда максимальный внедиагональный элемент становится меньше заранее выбранного порогового значения.

=== Математическое описание алгоритма ===
Исходные данные: симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>).

Матрица <math>A_{i+1}</math> получается из <math>A_i</math> по формуле <math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math>J_i</math> — ортогональная матрица, называемая ''вращением Якоби''.
При подходящем выборе <math>J_i</math> матрица <math>A_m</math> для больших m будет близка к диагональной матрице <math>\Lambda</math>.

Матрица <math>J_i</math> выбирается так, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}</math> <ref name="VVVVVV">Деммель Дж. Вычислительная линейная алгебра. - М.: МИР, 2001 - С. 244-248</ref>.



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

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

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>. Тогда матрица <math>A_{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)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Можно выбрать <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>. Отсюда получим равенство

: <math> \frac{a_{jj}^{(i)} - a_{kk}^{(i)}}{2 a_{jk}^{(i)}} = \frac{c^2 - s^2}{2sc} = \frac{\cos (2\theta)}{\sin (2\theta)} = \operatorname{ctg}(2\theta) \equiv \tau </math>.

Если <math> a_{jj}^{(i)} = a_{kk}^{(i)}</math>, то <math>\theta = \frac{\pi}{4}</math>.

Положим <math>t = \frac{s}{c} = \operatorname{tg}(\theta)</math> и заметим, что <math>t^2 - 2t\tau + 1 = 0</math>. Решая квадратное уравнение, находим <math>t = \frac{\operatorname{sign}(\tau)}{|\tau| + \sqrt{1+\tau^2}}, c = \frac{1}{\sqrt{1+t^2}}, s = tc</math>.

Выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

=== Вычислительное ядро алгоритма ===
Рассматривая отдельную итерацию, можно считать, что вычислительное ядро составляют множественные вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>   в процессе применения матрицы поворота <math>J_i</math> к матрице <math>A</math>:
: <math>\begin{align}
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k,
\end{align}</math>

каждое из которых повторяется по <math> (n-2) </math> раза, а также вычисление элементов <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>

=== Макроструктура алгоритма ===
Основную часть метода составляет процедура применения вращения к матрице <math>A</math>, которая в дальнейшем будет обозначена как '''''Jakobi-Rotation<math>(A,j,k)</math>'''''.

Эту процедуру, в свою очередь, можно разделить на две логические части:
# Определение угла поворота <math>\theta</math> по элементам матрицы <math>a_{jj}</math>, <math>a_{kk}</math> и <math>a_{jk}</math>;
# Поворот матрицы <math>A</math> (изменяются лишь строки и столбцы, соответствующие индексам <math>j</math> и  <math>k</math>).

=== Схема реализации последовательного алгоритма ===
Алгоритм можно описать следующим образом <ref name="VVVVVV" />:

repeat
выбрать пару индексов j,k
обратиться к процедуре '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
пока <math>A</math> не достаточно близка к диагональной матрице

Существует несколько способов выбора пары <math>j,k</math>. Наиболее простой и быстрый способ — построчный циклический обход внедиагональных элементов матрицы <math>A</math>:

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

Процедура '''''Jakobi-Rotation<math>(A,j,k)</math>''''' — это следующий алгоритм:
if <math>|a_{jk}|</math> не слишком мал
if <math>a_{jj}==a_{kk}</math>
<math>\theta=\frac{\Pi}{4}</math>
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\,t
\end{align}</math>
end if
<math>A = R^T(j,k,\theta)\cdot A\cdot R(j,k,\theta), \qquad J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta </math>
end if

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

Для осуществления одной итерации метода Якоби для матрицы размера <math>(n\times n)</math> требуется выполнить:

Для вычислительного ядра —
* <math> 4n+4 </math> умножений,
* <math> 2n+2 </math> сложений.

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

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

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

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

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

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

'''Первой''' группе вершин (J) соответствует вычисление значений c и s.

'''Второй''' группе вершин (А) соответствует вычисление значений элементов <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>.

'''Третьей''' группе вершин (B) соответствует вычисление значений элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>.



[[File:Информационный_граф_метода_якоби.png|none|thumb|2000px|Рисунок 1. Граф одной итерации алгоритма без отображения входных и выходных данных.]]

[[File:ГрафJ.png|none|thumb|2000px|Рисунок 2. Внутренний граф вершин J с входными параметрами <math>x = a_{jj}^{(i)}, y = a_{kk}^{(i)}, z = a_{jk}^{(i)}</math>.]]

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

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

После этого выполняется ярус, отвечающий за применение поворота к матрице <math>A</math> с параллельным выполнением <math>2(n-2)</math> операций вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math> , а также 2 операций вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>. Наибольшее количество операций содержится в вычислении последних двух элементов (по 6 умножений и 3 сложения).

Суммарное количество итераций зависит от входных данных и заданного значения погрешности. Один "цикл" (полный проход по внедиагональным элементам) осуществляется за <math>N = \frac{n(n-1)}{2}</math> итераций. Асимптотически метод сходится квадратично <ref>Wilkinson J. H. The Algebraic Eigenvalue Problem // Oxford University Press, UK, 1965, P. 270</ref>. Как правило, для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов <ref name="VVVVVV" />.

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

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

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

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

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

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

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

Метод Якоби является самым медленным из имеющихся алгоритмов вычисления собственных значений симметричной матрицы. Тем не менее, он способен вычислять малые собственные числа и отвечающие им собственные векторы с гораздо большей точностью, чем другие методы <ref name="VVVVVV" />. Кроме того, он не предполагает первоначального приведения матрицы к трехдиагональной форме.

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

Вычислительная мощность алгоритма линейна.

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

Дуги информационного графа, исходящие из вершин, соответствующих вычислениям значений <math>c</math> и <math>s</math>, образуют пучки рассылок линейной мощности.

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Исследование масштабируемости проводилось на суперкомпьютере "Ломоносов" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского Государственного Университета имени М.В. Ломоносова]. Алгоритм реализован на языке C++ с использованием средств MPI. Компиляция производилась с помощью команды mpicxx с использованием компилятора Intel с OpenMPI и библиотеки MKL. Были подключены следующие модули: openmpi/1.5.5-icc, intel/13.1.0, mkl/4.0.2.146. Программа была запущена в очередях test и regular4.

Значения изменяемых параметров запуска реализации алгоритма:
* число процессов: 2, 4, 8, 16, 32, 64;
* число элементов в матрице: 900, 3600, 8100, 14400, 22500, 32400, 44100, 57600, 72900, 90000.

На следующих рисунках приведены графики времени выполнения и производительности выбранной реализации алгоритма в зависимости от изменяемых параметров запуска

[[File:jacobi_time.jpg|thumb|center|1500px|Рисунок 3. Изменение времени выполнения в зависимости от числа процессов и размера входной матрицы]]
[[File:jacobi_perform.jpg|thumb|center|1500px|Рисунок 4. Изменение производительности в зависимости от числа процессов и размера входной матрицы]]

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

Реализация алгоритма доступна по [http://pastebin.com/juwPJRhH ссылке].

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

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

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

Существует библиотека JACOBI_EIGENVALUE, реализующая последовательный вариант метода Якоби на языках программирования [http://people.sc.fsu.edu/~jburkardt/c_src/jacobi_eigenvalue/jacobi_eigenvalue.html С], [http://people.sc.fsu.edu/~jburkardt/cpp_src/jacobi_eigenvalue/jacobi_eigenvalue.html С++], [http://people.sc.fsu.edu/~jburkardt/f77_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN77], [http://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN90], [http://people.sc.fsu.edu/~jburkardt/m_src/jacobi_eigenvalue/jacobi_eigenvalue.html MATLAB], [http://people.sc.fsu.edu/~jburkardt/py_src/jacobi_eigenvalue/jacobi_eigenvalue.html Python].
Данная библиотека распространяется по лицензии [http://people.sc.fsu.edu/~jburkardt/txt/gnu_lgpl.txt GNU LESSER GENERAL PUBLIC LICENSE].

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

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

<references \>

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

2016-11-21T19:50:47Z

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

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

Авторы описания: [[Участник: Galkina|А.С.Галкина]] (входные и выходные данные, математическое описание алгоритма и др.), [[Участник: Игорь|И.А.Плахов]] (ресурс параллелизма алгоритма,последовательная сложность алгоритма и др.) Вклад авторов считать равноценным.

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

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

Метод Якоби — итерационный алгоритм для вычисления собственных значений и собственных векторов вещественной симметричной матрицы. Карл Густав Якоб Якоби, в честь которого назван этот метод, предложил его в 1846 году, хотя использоваться он начал только в 1950-х годах с появлением компьютеров.
Суть алгоритма заключается в том, чтобы по заданной симметрической матрице <math>A = A_0</math> построить последовательность ортогонально подобных матриц <math>A_1,A_2,\dotsc,A_m</math>, сходящуюся к диагональной матрице, на диагонали которой стоят собственные значения. Для построения этой последовательности применяется специально подобранная матрица поворота <math>J_i</math>, такая что норма наддиагональной части <math>of\!f(A)=\sqrt{\sum\limits_{1 \le j < k \le n} a_{jk}^2}</math> уменьшается при каждом повороте матрицы <math>A</math>. Вычисление останавливается, когда угол поворота становится близок к нулю, либо когда максимальный внедиагональный элемент становится меньше заранее выбранного порогового значения.

=== Математическое описание алгоритма ===
Исходные данные: симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>).

Матрица <math>A_{i+1}</math> получается из <math>A_i</math> по формуле <math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math>J_i</math> — ортогональная матрица, называемая ''вращением Якоби''.
При подходящем выборе <math>J_i</math> матрица <math>A_m</math> для больших m будет близка к диагональной матрице <math>\Lambda</math>.

Матрица <math>J_i</math> выбирается так, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}</math> <ref name="VVVVVV">Деммель Дж. Вычислительная линейная алгебра. - М.: МИР, 2001 - С. 244-248</ref>.



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

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

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>. Тогда матрица <math>A_{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)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Можно выбрать <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>. Отсюда получим равенство

: <math> \frac{a_{jj}^{(i)} - a_{kk}^{(i)}}{2 a_{jk}^{(i)}} = \frac{c^2 - s^2}{2sc} = \frac{\cos (2\theta)}{\sin (2\theta)} = \operatorname{ctg}(2\theta) \equiv \tau </math>.

Если <math> a_{jj}^{(i)} = a_{kk}^{(i)}</math>, то <math>\theta = \frac{\pi}{4}</math>.

Положим <math>t = \frac{s}{c} = \operatorname{tg}(\theta)</math> и заметим, что <math>t^2 - 2t\tau + 1 = 0</math>. Решая квадратное уравнение, находим <math>t = \frac{\operatorname{sign}(\tau)}{|\tau| + \sqrt{1+\tau^2}}, c = \frac{1}{\sqrt{1+t^2}}, s = tc</math>.

Выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

=== Вычислительное ядро алгоритма ===
Рассматривая отдельную итерацию, можно считать, что вычислительное ядро составляют множественные вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>   в процессе применения матрицы поворота <math>J_i</math> к матрице <math>A</math>:
: <math>\begin{align}
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k,
\end{align}</math>

каждое из которых повторяется по <math> (n-2) </math> раза, а также вычисление элементов <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>

=== Макроструктура алгоритма ===
Основную часть метода составляет процедура применения вращения к матрице <math>A</math>, которая в дальнейшем будет обозначена как '''''Jakobi-Rotation<math>(A,j,k)</math>'''''.

Эту процедуру, в свою очередь, можно разделить на две логические части:
# Определение угла поворота <math>\theta</math> по элементам матрицы <math>a_{jj}</math>, <math>a_{kk}</math> и <math>a_{jk}</math>;
# Поворот матрицы <math>A</math> (изменяются лишь строки и столбцы, соответствующие индексам <math>j</math> и  <math>k</math>).

=== Схема реализации последовательного алгоритма ===
Алгоритм можно описать следующим образом <ref name="VVVVVV" />:

repeat
выбрать пару индексов j,k
обратиться к процедуре '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
пока <math>A</math> не достаточно близка к диагональной матрице

Существует несколько способов выбора пары <math>j,k</math>. Наиболее простой и быстрый способ — построчный циклический обход внедиагональных элементов матрицы <math>A</math>:

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

Процедура '''''Jakobi-Rotation<math>(A,j,k)</math>''''' — это следующий алгоритм:
if <math>|a_{jk}|</math> не слишком мал
if <math>a_{jj}==a_{kk}</math>
<math>\theta=\frac{\Pi}{4}</math>
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\,t
\end{align}</math>
end if
<math>A = R^T(j,k,\theta)\cdot A\cdot R(j,k,\theta), \qquad J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta </math>
end if

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

Для осуществления одной итерации метода Якоби для матрицы размера <math>(n\times n)</math> требуется выполнить:

Для вычислительного ядра —
* <math> 4n+4 </math> умножений,
* <math> 2n+2 </math> сложений.

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

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

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

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

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

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

'''Первой''' группе вершин (J) соответствует вычисление значений c и s.

'''Второй''' группе вершин (А) соответствует вычисление значений элементов <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>.

'''Третьей''' группе вершин (B) соответствует вычисление значений элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>.



[[File:Информационный_граф_метода_якоби.png|none|thumb|2000px|Рисунок 1. Граф одной итерации алгоритма без отображения входных и выходных данных.]]

[[File:ГрафJ.png|none|thumb|2000px|Рисунок 2. Внутренний граф вершин J с входными параметрами <math>x = a_{jj}^{(i)}, y = a_{kk}^{(i)}, z = a_{jk}^{(i)}</math>.]]

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

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

После этого выполняется ярус, отвечающий за применение поворота к матрице <math>A</math> с параллельным выполнением <math>2(n-2)</math> операций вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math> , а также 2 операций вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>. Наибольшее количество операций содержится в вычислении последних двух элементов (по 6 умножений и 3 сложения).

Суммарное количество итераций зависит от входных данных и заданного значения погрешности. Один "цикл" (полный проход по внедиагональным элементам) осуществляется за <math>N = \frac{n(n-1)}{2}</math> итераций. Асимптотически метод сходится квадратично <ref>Wilkinson J. H. The Algebraic Eigenvalue Problem // Oxford University Press, UK, 1965, P. 270</ref>. Как правило, для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов <ref name="VVVVVV" />.

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

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

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

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

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

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

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

Метод Якоби является самым медленным из имеющихся алгоритмов вычисления собственных значений симметричной матрицы. Тем не менее, он способен вычислять малые собственные числа и отвечающие им собственные векторы с гораздо большей точностью, чем другие методы <ref name="VVVVVV" />. Кроме того, он не предполагает первоначального приведения матрицы к трехдиагональной форме.

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

Вычислительная мощность алгоритма линейна.

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

Дуги информационного графа, исходящие из вершин, соответствующих вычислениям значений <math>c</math> и <math>s</math>, образуют пучки рассылок линейной мощности.

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Исследование масштабируемости проводилось на суперкомпьютере "Ломоносов" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского Государственного Университета имени М.В. Ломоносова]. Алгоритм реализован на языке C++ с использованием средств MPI. Компиляция производилась с помощью команды mpicxx с использованием компилятора Intel с OpenMPI и библиотеки MKL. Были подключены следующие модули: openmpi/1.5.5-icc, intel/13.1.0, mkl/4.0.2.146. Программа была запущена в очередях test и regular4.

Значения изменяемых параметров запуска реализации алгоритма:
* число процессов: 2, 4, 8, 16, 32, 64;
* число элементов в матрице: 900, 3600, 8100, 14400, 22500, 32400, 44100, 57600, 72900, 90000.

На следующих рисунках приведены графики времени выполнения и производительности выбранной реализации алгоритма в зависимости от изменяемых параметров запуска

[[File:jacobi_time.jpg|thumb|center|1500px|Рисунок 3. Изменение времени выполнения в зависимости от числа процессов и размера входной матрицы]]
[[File:jacobi_perform.jpg|thumb|center|1500px|Рисунок 4. Изменение производительности в зависимости от числа процессов и размера входной матрицы]]

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

Реализация алгоритма доступна по [http://pastebin.com/juwPJRhH ссылке].

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

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

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

Существует библиотека JACOBI_EIGENVALUE, реализующая последовательный вариант метода Якоби на языках программирования [http://people.sc.fsu.edu/~jburkardt/c_src/jacobi_eigenvalue/jacobi_eigenvalue.html С], [http://people.sc.fsu.edu/~jburkardt/cpp_src/jacobi_eigenvalue/jacobi_eigenvalue.html С++], [http://people.sc.fsu.edu/~jburkardt/f77_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN77], [http://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN90], [http://people.sc.fsu.edu/~jburkardt/m_src/jacobi_eigenvalue/jacobi_eigenvalue.html MATLAB], [http://people.sc.fsu.edu/~jburkardt/py_src/jacobi_eigenvalue/jacobi_eigenvalue.html Python].
Данная библиотека распространяется по лицензии [http://people.sc.fsu.edu/~jburkardt/txt/gnu_lgpl.txt GNU LESSER GENERAL PUBLIC LICENSE].

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

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

<references \>

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

2016-11-21T19:47:31Z

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

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

Авторы описания: [[Участник: Galkina|А.С.Галкина]] (входные и выходные данные, математическое описание алгоритма и др.), [[Участник: Игорь|И.А.Плахов]] (ресурс параллелизма алгоритма,последовательная сложность алгоритма и др.) Вклад авторов считать равноценным.

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

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

Метод Якоби — итерационный алгоритм для вычисления собственных значений и собственных векторов вещественной симметричной матрицы. Карл Густав Якоб Якоби, в честь которого назван этот метод, предложил его в 1846 году, хотя использоваться он начал только в 1950-х годах с появлением компьютеров.
Суть алгоритма заключается в том, чтобы по заданной симметрической матрице <math>A = A_0</math> построить последовательность ортогонально подобных матриц <math>A_1,A_2,\dotsc,A_m</math>, сходящуюся к диагональной матрице, на диагонали которой стоят собственные значения. Для построения этой последовательности применяется специально подобранная матрица поворота <math>J_i</math>, такая что норма наддиагональной части <math>of\!f(A)=\sqrt{\sum\limits_{1 \le j < k \le n} a_{jk}^2}</math> уменьшается при каждом повороте матрицы <math>A</math>. Вычисление останавливается, когда угол поворота становится близок к нулю, либо когда максимальный внедиагональный элемент становится меньше заранее выбранного порогового значения.

=== Математическое описание алгоритма ===
Исходные данные: симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>).

Матрица <math>A_{i+1}</math> получается из <math>A_i</math> по формуле <math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math>J_i</math> — ортогональная матрица, называемая ''вращением Якоби''.
При подходящем выборе <math>J_i</math> матрица <math>A_m</math> для больших m будет близка к диагональной матрице <math>\Lambda</math>.

Матрица <math>J_i</math> выбирается так, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}</math> <ref name="VVVVVV">Деммель Дж. Вычислительная линейная алгебра. - М.: МИР, 2001 - С. 244-248</ref>.



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

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

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>. Тогда матрица <math>A_{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)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Можно выбрать <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>. Отсюда получим равенство

: <math> \frac{a_{jj}^{(i)} - a_{kk}^{(i)}}{2 a_{jk}^{(i)}} = \frac{c^2 - s^2}{2sc} = \frac{\cos (2\theta)}{\sin (2\theta)} = \operatorname{ctg}(2\theta) \equiv \tau </math>.

Если <math> a_{jj}^{(i)} = a_{kk}^{(i)}</math>, то <math>\theta = \frac{\pi}{4}</math>.

Положим <math>t = \frac{s}{c} = \operatorname{tg}(\theta)</math> и заметим, что <math>t^2 - 2t\tau + 1 = 0</math>. Решая квадратное уравнение, находим <math>t = \frac{\operatorname{sign}(\tau)}{|\tau| + \sqrt{1+\tau^2}}, c = \frac{1}{\sqrt{1+t^2}}, s = tc</math>.

Выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

=== Вычислительное ядро алгоритма ===
Рассматривая отдельную итерацию, можно считать, что вычислительное ядро составляют множественные вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>   в процессе применения матрицы поворота <math>J_i</math> к матрице <math>A</math>:
: <math>\begin{align}
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k,
\end{align}</math>

каждое из которых повторяется по <math> (n-2) </math> раза, а также вычисление элементов <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>

=== Макроструктура алгоритма ===
Основную часть метода составляет процедура применения вращения к матрице <math>A</math>, которая в дальнейшем будет обозначена как '''''Jakobi-Rotation<math>(A,j,k)</math>'''''.

Эту процедуру, в свою очередь, можно разделить на две логические части:
# Определение угла поворота <math>\theta</math> по элементам матрицы <math>a_{jj}</math>, <math>a_{kk}</math> и <math>a_{jk}</math>;
# Поворот матрицы <math>A</math> (изменяются лишь строки и столбцы, соответствующие индексам <math>j</math> и  <math>k</math>).

=== Схема реализации последовательного алгоритма ===
Алгоритм можно описать следующим образом <ref name="VVVVVV" />:

repeat
выбрать пару индексов j,k
обратиться к процедуре '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
пока <math>A</math> не достаточно близка к диагональной матрице

Существует несколько способов выбора пары <math>j,k</math>. Наиболее простой и быстрый способ — построчный циклический обход внедиагональных элементов матрицы <math>A</math>:

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

Процедура '''''Jakobi-Rotation<math>(A,j,k)</math>''''' — это следующий алгоритм:
if <math>|a_{jk}|</math> не слишком мал
if <math>a_{jj}==a_{kk}</math>
<math>\theta=\frac{\Pi}{4}</math>
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\,t
\end{align}</math>
end if
<math>A = R^T(j,k,\theta)\cdot A\cdot R(j,k,\theta), \qquad J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta </math>
end if

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

Для осуществления одной итерации метода Якоби для матрицы размера <math>(n\times n)</math> требуется выполнить:

Для вычислительного ядра —
* <math> 4n+4 </math> умножений,
* <math> 2n+2 </math> сложений.

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

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

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

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

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

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

'''Первой''' группе вершин (J) соответствует вычисление значений c и s.

'''Второй''' группе вершин (А) соответствует вычисление значений элементов <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>.

'''Третьей''' группе вершин (B) соответствует вычисление значений элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>.



[[File:Информационный_граф_метода_якоби.png|none|thumb|2000px|Рисунок 1. Граф одной итерации алгоритма без отображения входных и выходных данных.]]

[[File:ГрафJ.png|none|thumb|2000px|Рисунок 2. Внутренний граф вершин J с входными параметрами <math>x = a_{jj}^{(i)}, y = a_{kk}^{(i)}, z = a_{jk}^{(i)}</math>.]]

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

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

После этого выполняется ярус, отвечающий за применение поворота к матрице <math>A</math> с параллельным выполнением <math>2(n-2)</math> операций вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math> , а также 2 операций вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>. Наибольшее количество операций содержится в вычислении последних двух элементов (по 6 умножений и 3 сложения).

Суммарное количество итераций зависит от входных данных и заданного значения погрешности. Один "цикл" (полный проход по внедиагональным элементам) осуществляется за <math>N = \frac{n(n-1)}{2}</math> итераций. Асимптотически метод сходится квадратично <ref>Wilkinson J. H. The Algebraic Eigenvalue Problem // Oxford University Press, UK, 1965, P. 270</ref>. Как правило, для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов <ref name="VVVVVV" />.

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

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

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

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

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

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

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

Метод Якоби является самым медленным из имеющихся алгоритмов вычисления собственных значений симметричной матрицы. Тем не менее, он способен вычислять малые собственные числа и отвечающие им собственные векторы с гораздо большей точностью, чем другие методы <ref name="VVVVVV" />. Кроме того, он не предполагает первоначального приведения матрицы к трехдиагональной форме.

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

Вычислительная мощность алгоритма линейна.

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

Дуги информационного графа, исходящие из вершин, соответствующих вычислениям значений <math>c</math> и <math>s</math>, образуют пучки рассылок линейной мощности.

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Исследование масштабируемости проводилось на суперкомпьютере "Ломоносов" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского Государственного Университета имени М.В. Ломоносова]. Алгоритм реализован на языке C++ с использованием средств MPI. Компиляция производилась с помощью команды mpicxx с использованием компилятора Intel с OpenMPI и библиотеки MKL. Были подключены следующие модули: openmpi/1.5.5-icc, intel/13.1.0, mkl/4.0.2.146.

Значения изменяемых параметров запуска реализации алгоритма:
* число процессов: 2, 4, 8, 16, 32, 64;
* число элементов в матрице: 900, 3600, 8100, 14400, 22500, 32400, 44100, 57600, 72900, 90000.

На следующих рисунках приведены графики времени выполнения и производительности выбранной реализации алгоритма в зависимости от изменяемых параметров запуска

[[File:jacobi_time.jpg|thumb|center|1500px|Рисунок 3. Изменение времени выполнения в зависимости от числа процессов и размера входной матрицы]]
[[File:jacobi_perform.jpg|thumb|center|1500px|Рисунок 4. Изменение производительности в зависимости от числа процессов и размера входной матрицы]]

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

Реализация алгоритма доступна по [http://pastebin.com/juwPJRhH ссылке].

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

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

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

Существует библиотека JACOBI_EIGENVALUE, реализующая последовательный вариант метода Якоби на языках программирования [http://people.sc.fsu.edu/~jburkardt/c_src/jacobi_eigenvalue/jacobi_eigenvalue.html С], [http://people.sc.fsu.edu/~jburkardt/cpp_src/jacobi_eigenvalue/jacobi_eigenvalue.html С++], [http://people.sc.fsu.edu/~jburkardt/f77_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN77], [http://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN90], [http://people.sc.fsu.edu/~jburkardt/m_src/jacobi_eigenvalue/jacobi_eigenvalue.html MATLAB], [http://people.sc.fsu.edu/~jburkardt/py_src/jacobi_eigenvalue/jacobi_eigenvalue.html Python].
Данная библиотека распространяется по лицензии [http://people.sc.fsu.edu/~jburkardt/txt/gnu_lgpl.txt GNU LESSER GENERAL PUBLIC LICENSE].

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

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

<references \>

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

2016-11-21T18:40:01Z

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

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

Авторы описания: [[Участник: Galkina|А.С.Галкина]] (входные и выходные данные, математическое описание алгоритма и др.), [[Участник: Игорь|И.А.Плахов]] (ресурс параллелизма алгоритма,последовательная сложность алгоритма и др.) Вклад авторов считать равноценным.

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

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

Метод Якоби — итерационный алгоритм для вычисления собственных значений и собственных векторов вещественной симметричной матрицы. Карл Густав Якоб Якоби, в честь которого назван этот метод, предложил его в 1846 году, хотя использоваться он начал только в 1950-х годах с появлением компьютеров.
Суть алгоритма заключается в том, чтобы по заданной симметрической матрице <math>A = A_0</math> построить последовательность ортогонально подобных матриц <math>A_1,A_2,\dotsc,A_m</math>, сходящуюся к диагональной матрице, на диагонали которой стоят собственные значения. Для построения этой последовательности применяется специально подобранная матрица поворота <math>J_i</math>, такая что норма наддиагональной части <math>of\!f(A)=\sqrt{\sum\limits_{1 \le j < k \le n} a_{jk}^2}</math> уменьшается при каждом повороте матрицы <math>A</math>. Вычисление останавливается, когда угол поворота становится близок к нулю, либо когда максимальный внедиагональный элемент становится меньше заранее выбранного порогового значения.

=== Математическое описание алгоритма ===
Исходные данные: симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>).

Матрица <math>A_{i+1}</math> получается из <math>A_i</math> по формуле <math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math>J_i</math> — ортогональная матрица, называемая ''вращением Якоби''.
При подходящем выборе <math>J_i</math> матрица <math>A_m</math> для больших m будет близка к диагональной матрице <math>\Lambda</math>.

Матрица <math>J_i</math> выбирается так, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}</math> <ref name="VVVVVV">Деммель Дж. Вычислительная линейная алгебра. - М.: МИР, 2001 - С. 244-248</ref>.



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

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

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>. Тогда матрица <math>A_{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)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Можно выбрать <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>. Отсюда получим равенство

: <math> \frac{a_{jj}^{(i)} - a_{kk}^{(i)}}{2 a_{jk}^{(i)}} = \frac{c^2 - s^2}{2sc} = \frac{\cos (2\theta)}{\sin (2\theta)} = \operatorname{ctg}(2\theta) \equiv \tau </math>.

Если <math> a_{jj}^{(i)} = a_{kk}^{(i)}</math>, то <math>\theta = \frac{\pi}{4}</math>.

Положим <math>t = \frac{s}{c} = \operatorname{tg}(\theta)</math> и заметим, что <math>t^2 - 2t\tau + 1 = 0</math>. Решая квадратное уравнение, находим <math>t = \frac{\operatorname{sign}(\tau)}{|\tau| + \sqrt{1+\tau^2}}, c = \frac{1}{\sqrt{1+t^2}}, s = tc</math>.

Выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

=== Вычислительное ядро алгоритма ===
Рассматривая отдельную итерацию, можно считать, что вычислительное ядро составляют множественные вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>   в процессе применения матрицы поворота <math>J_i</math> к матрице <math>A</math>:
: <math>\begin{align}
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k,
\end{align}</math>

каждое из которых повторяется по <math> (n-2) </math> раза, а также вычисление элементов <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>

=== Макроструктура алгоритма ===
Основную часть метода составляет процедура применения вращения к матрице <math>A</math>, которая в дальнейшем будет обозначена как '''''Jakobi-Rotation<math>(A,j,k)</math>'''''.

Эту процедуру, в свою очередь, можно разделить на две логические части:
# Определение угла поворота <math>\theta</math> по элементам матрицы <math>a_{jj}</math>, <math>a_{kk}</math> и <math>a_{jk}</math>;
# Поворот матрицы <math>A</math> (изменяются лишь строки и столбцы, соответствующие индексам <math>j</math> и  <math>k</math>).

=== Схема реализации последовательного алгоритма ===
Алгоритм можно описать следующим образом <ref name="VVVVVV" />:

repeat
выбрать пару индексов j,k
обратиться к процедуре '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
пока <math>A</math> не достаточно близка к диагональной матрице

Существует несколько способов выбора пары <math>j,k</math>. Наиболее простой и быстрый способ — построчный циклический обход внедиагональных элементов матрицы <math>A</math>:

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

Процедура '''''Jakobi-Rotation<math>(A,j,k)</math>''''' — это следующий алгоритм:
if <math>|a_{jk}|</math> не слишком мал
if <math>a_{jj}==a_{kk}</math>
<math>\theta=\frac{\Pi}{4}</math>
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\,t
\end{align}</math>
end if
<math>A = R^T(j,k,\theta)\cdot A\cdot R(j,k,\theta), \qquad J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta </math>
end if

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

Для осуществления одной итерации метода Якоби для матрицы размера <math>(n\times n)</math> требуется выполнить:

Для вычислительного ядра —
* <math> 4n+4 </math> умножений,
* <math> 2n+2 </math> сложений.

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

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

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

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

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

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

'''Первой''' группе вершин (J) соответствует вычисление значений c и s.

'''Второй''' группе вершин (А) соответствует вычисление значений элементов <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>.

'''Третьей''' группе вершин (B) соответствует вычисление значений элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>.



[[File:Информационный_граф_метода_якоби.png|none|thumb|2000px|Рисунок 1. Граф одной итерации алгоритма без отображения входных и выходных данных.]]

[[File:ГрафJ.png|none|thumb|2000px|Рисунок 2. Внутренний граф вершин J с входными параметрами <math>x = a_{jj}^{(i)}, y = a_{kk}^{(i)}, z = a_{jk}^{(i)}</math>.]]

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

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

После этого выполняется ярус, отвечающий за применение поворота к матрице <math>A</math> с параллельным выполнением <math>2(n-2)</math> операций вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math> , а также 2 операций вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>. Наибольшее количество операций содержится в вычислении последних двух элементов (по 6 умножений и 3 сложения).

Суммарное количество итераций зависит от входных данных и заданного значения погрешности. Один "цикл" (полный проход по внедиагональным элементам) осуществляется за <math>N = \frac{n(n-1)}{2}</math> итераций. Асимптотически метод сходится квадратично <ref>Wilkinson J. H. The Algebraic Eigenvalue Problem // Oxford University Press, UK, 1965, P. 270</ref>. Как правило, для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов <ref name="VVVVVV" />.

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

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

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

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

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

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

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

Метод Якоби является самым медленным из имеющихся алгоритмов вычисления собственных значений симметричной матрицы. Тем не менее, он способен вычислять малые собственные числа и отвечающие им собственные векторы с гораздо большей точностью, чем другие методы <ref name="VVVVVV" />. Кроме того, он не предполагает первоначального приведения матрицы к трехдиагональной форме.

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

Вычислительная мощность алгоритма линейна.

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

Дуги информационного графа, исходящие из вершин, соответствующих вычислениям значений <math>c</math> и <math>s</math>, образуют пучки рассылок линейной мощности.

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Исследование масштабируемости проводилось на суперкомпьютере "Ломоносов" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского Государственного Университета имени М.В. Ломоносова]. Алгоритм реализован на языке C++ с использованием средств MPI. Компиляция производилась с помощью команды mpicxx с использованием компилятора Intel с OpenMPI и библиотеки MKL. Были подключены следующие модули: openmpi/1.5.5-icc, intel/13.1.0, mkl/4.0.2.146.

Значения изменяемых параметров запуска реализации алгоритма:
* число процессов: 2, 4, 8, 16, 32, 64;
* число элементов в матрице: 900, 3600, 8100, 14400, 22500, 32400, 44100, 57600, 72900, 90000.

На следующих рисунках приведены графики времени выполнения и производительности выбранной реализации алгоритма в зависимости от изменяемых параметров запуска

[[File:jacobi_time.jpg|thumb|center|1500px|Рисунок 3. Изменение времени выполнения в зависимости от числа процессов и размера входной матрицы]]
[[File:jacobi_perform.jpg|thumb|center|1500px|Рисунок 4. Изменение производительности в зависимости от числа процессов и размера входной матрицы]]

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

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

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

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

Существует библиотека JACOBI_EIGENVALUE, реализующая последовательный вариант метода Якоби на языках программирования [http://people.sc.fsu.edu/~jburkardt/c_src/jacobi_eigenvalue/jacobi_eigenvalue.html С], [http://people.sc.fsu.edu/~jburkardt/cpp_src/jacobi_eigenvalue/jacobi_eigenvalue.html С++], [http://people.sc.fsu.edu/~jburkardt/f77_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN77], [http://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN90], [http://people.sc.fsu.edu/~jburkardt/m_src/jacobi_eigenvalue/jacobi_eigenvalue.html MATLAB], [http://people.sc.fsu.edu/~jburkardt/py_src/jacobi_eigenvalue/jacobi_eigenvalue.html Python].
Данная библиотека распространяется по лицензии [http://people.sc.fsu.edu/~jburkardt/txt/gnu_lgpl.txt GNU LESSER GENERAL PUBLIC LICENSE].

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

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

<references \>

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

2016-11-18T18:44:43Z

Игорь:

{{assignment}}

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

Авторы описания: [[Участник: Galkina|А.С.Галкина]] (входные и выходные данные, математическое описание алгоритма и др.), [[Участник: Игорь|И.А.Плахов]] (ресурс параллелизма алгоритма,последовательная сложность алгоритма и др.) Вклад авторов считать равноценным.

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

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

Метод Якоби — итерационный алгоритм для вычисления собственных значений и собственных векторов вещественной симметричной матрицы. Карл Густав Якоб Якоби, в честь которого назван этот метод, предложил его в 1846 году, хотя использоваться он начал только в 1950-х годах с появлением компьютеров.
Суть алгоритма заключается в том, чтобы по заданной симметрической матрице <math>A = A_0</math> построить последовательность ортогонально подобных матриц <math>A_1,A_2,\dotsc,A_m</math>, сходящуюся к диагональной матрице, на диагонали которой стоят собственные значения. Для построения этой последовательности применяется специально подобранная матрица поворота <math>J_i</math>, такая что норма наддиагональной части <math>of\!f(A)=\sqrt{\sum\limits_{1 \le j < k \le n} a_{jk}^2}</math> уменьшается при каждом повороте матрицы <math>A</math>. Вычисление останавливается, когда угол поворота становится близок к нулю, либо когда максимальный внедиагональный элемент становится меньше заранее выбранного порогового значения.

=== Математическое описание алгоритма ===
Исходные данные: симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>).

Матрица <math>A_{i+1}</math> получается из <math>A_i</math> по формуле <math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math>J_i</math> — ортогональная матрица, называемая ''вращением Якоби''.
При подходящем выборе <math>J_i</math> матрица <math>A_m</math> для больших m будет близка к диагональной матрице <math>\Lambda</math>.

Матрица <math>J_i</math> выбирается так, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}</math> <ref name="VVVVVV">Деммель Дж. Вычислительная линейная алгебра. - М.: МИР, 2001 - С. 244-248</ref>.



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

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

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>. Тогда матрица <math>A_{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)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Можно выбрать <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>. Отсюда получим равенство

: <math> \frac{a_{jj}^{(i)} - a_{kk}^{(i)}}{2 a_{jk}^{(i)}} = \frac{c^2 - s^2}{2sc} = \frac{\cos (2\theta)}{\sin (2\theta)} = \operatorname{ctg}(2\theta) \equiv \tau </math>.

Если <math> a_{jj}^{(i)} = a_{kk}^{(i)}</math>, то <math>\theta = \frac{\pi}{4}</math>.

Положим <math>t = \frac{s}{c} = \operatorname{tg}(\theta)</math> и заметим, что <math>t^2 - 2t\tau + 1 = 0</math>. Решая квадратное уравнение, находим <math>t = \frac{\operatorname{sign}(\tau)}{|\tau| + \sqrt{1+\tau^2}}, c = \frac{1}{\sqrt{1+t^2}}, s = tc</math>.

Выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

=== Вычислительное ядро алгоритма ===
Рассматривая отдельную итерацию, можно считать, что вычислительное ядро составляют множественные вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>   в процессе применения матрицы поворота <math>J_i</math> к матрице <math>A</math>:
: <math>\begin{align}
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k,
\end{align}</math>

каждое из которых повторяется по <math> (n-2) </math> раза, а также вычисление элементов <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>

=== Макроструктура алгоритма ===
Основную часть метода составляет процедура применения вращения к матрице <math>A</math>, которая в дальнейшем будет обозначена как '''''Jakobi-Rotation<math>(A,j,k)</math>'''''.

Эту процедуру, в свою очередь, можно разделить на две логические части:
# Определение угла поворота <math>\theta</math> по элементам матрицы <math>a_{jj}</math>, <math>a_{kk}</math> и <math>a_{jk}</math>;
# Поворот матрицы <math>A</math> (изменяются лишь строки и столбцы, соответствующие индексам <math>j</math> и  <math>k</math>).

=== Схема реализации последовательного алгоритма ===
Алгоритм можно описать следующим образом <ref name="VVVVVV" />:

repeat
выбрать пару индексов j,k
обратиться к процедуре '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
пока <math>A</math> не достаточно близка к диагональной матрице

Существует несколько способов выбора пары <math>j,k</math>. Наиболее простой и быстрый способ — построчный циклический обход внедиагональных элементов матрицы <math>A</math>:

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

Процедура '''''Jakobi-Rotation<math>(A,j,k)</math>''''' — это следующий алгоритм:
if <math>|a_{jk}|</math> не слишком мал
if <math>a_{jj}==a_{kk}</math>
<math>\theta=\frac{\Pi}{4}</math>
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\,t
\end{align}</math>
end if
<math>A = R^T(j,k,\theta)\cdot A\cdot R(j,k,\theta), \qquad J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta </math>
end if

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

Для осуществления одной итерации метода Якоби для матрицы размера <math>(n\times n)</math> требуется выполнить:

Для вычислительного ядра —
* <math> 4n+4 </math> умножений,
* <math> 2n+2 </math> сложений.

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

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

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

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

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

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

'''Первой''' группе вершин (J) соответствует вычисление значений c и s.

'''Второй''' группе вершин (А) соответствует вычисление значений элементов <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>.

'''Третьей''' группе вершин (B) соответствует вычисление значений элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>.



[[File:Информационный_граф_метода_якоби.png|none|thumb|2000px|Рисунок 1. Граф одной итерации алгоритма без отображения входных и выходных данных.]]

[[File:ГрафJ.png|none|thumb|2000px|Рисунок 2. Внутренний граф вершин J с входными параметрами <math>x = a_{jj}^{(i)}, y = a_{kk}^{(i)}, z = a_{jk}^{(i)}</math>.]]

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

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

После этого выполняется ярус, отвечающий за применение поворота к матрице <math>A</math> с параллельным выполнением <math>2(n-2)</math> операций вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math> , а также 2 операций вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>. Наибольшее количество операций содержится в вычислении последних двух элементов (по 6 умножений и 3 сложения).

Суммарное количество итераций зависит от входных данных и заданного значения погрешности. Один "цикл" (полный проход по внедиагональным элементам) осуществляется за <math>N = \frac{n(n-1)}{2}</math> итераций. Асимптотически метод сходится квадратично <ref>Wilkinson J. H. The Algebraic Eigenvalue Problem // Oxford University Press, UK, 1965, P. 270</ref>. Как правило, для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов <ref name="VVVVVV" />.

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

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

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

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

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

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

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

Метод Якоби является самым медленным из имеющихся алгоритмов вычисления собственных значений симметричной матрицы. Тем не менее, он способен вычислять малые собственные числа и отвечающие им собственные векторы с гораздо большей точностью, чем другие методы <ref name="VVVVVV" />. Кроме того, он не предполагает первоначального приведения матрицы к трехдиагональной форме.

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

Вычислительная мощность алгоритма линейна.

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

Дуги информационного графа, исходящие из вершин, соответствующих вычислениям значений <math>c</math> и <math>s</math>, образуют пучки рассылок линейной мощности.

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Исследование масштабируемости проводилось на суперкомпьютере "Ломоносов" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского Государственного Университета имени М.В. Ломоносова]. Алгоритм реализован на языке C++ с использованием средств MPI.

Значения изменяемых параметров запуска реализации алгоритма:
* число процессов: 2, 4, 8, 16, 32, 64;
* число элементов в матрице: 900, 3600, 8100, 14400, 22500, 32400, 44100, 57600, 72900, 90000.

На следующих рисунках приведены графики времени выполнения и производительности выбранной реализации алгоритма в зависимости от изменяемых параметров запуска

[[File:jacobi_time.jpg|thumb|center|720px|Рисунок 3. Изменение времени выполнения в зависимости от числа процессов и размера входной матрицы]]
[[File:jacobi_perform.jpg|thumb|center|720px|Рисунок 4. Изменение производительности в зависимости от числа процессов и размера входной матрицы]]

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

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

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

Существует библиотека JACOBI_EIGENVALUE, реализующая последовательный вариант метода Якоби на языках программирования [http://people.sc.fsu.edu/~jburkardt/c_src/jacobi_eigenvalue/jacobi_eigenvalue.html С], [http://people.sc.fsu.edu/~jburkardt/cpp_src/jacobi_eigenvalue/jacobi_eigenvalue.html С++], [http://people.sc.fsu.edu/~jburkardt/f77_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN77], [http://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN90], [http://people.sc.fsu.edu/~jburkardt/m_src/jacobi_eigenvalue/jacobi_eigenvalue.html MATLAB], [http://people.sc.fsu.edu/~jburkardt/py_src/jacobi_eigenvalue/jacobi_eigenvalue.html Python].
Данная библиотека распространяется по лицензии [http://people.sc.fsu.edu/~jburkardt/txt/gnu_lgpl.txt GNU LESSER GENERAL PUBLIC LICENSE].

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

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

<references \>

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

2016-11-18T16:22:57Z

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

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

Авторы описания: [[Участник: Galkina|А.С.Галкина]] (входные и выходные данные, математическое описание алгоритма и др.), [[Участник: Игорь|И.А.Плахов]] (ресурс параллелизма алгоритма,последовательная сложность алгоритма и др.) Вклад авторов считать равноценным.

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

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

Метод Якоби — итерационный алгоритм для вычисления собственных значений и собственных векторов вещественной симметричной матрицы. Карл Густав Якоб Якоби, в честь которого назван этот метод, предложил его в 1846 году, хотя использоваться он начал только в 1950-х годах с появлением компьютеров.
Суть алгоритма заключается в том, чтобы по заданной симметрической матрице <math>A = A_0</math> построить последовательность ортогонально подобных матриц <math>A_1,A_2,\dotsc,A_m</math>, сходящуюся к диагональной матрице, на диагонали которой стоят собственные значения. Для построения этой последовательности применяется специально подобранная матрица поворота <math>J_i</math>, такая что норма наддиагональной части <math>of\!f(A)=\sqrt{\sum\limits_{1 \le j < k \le n} a_{jk}^2}</math> уменьшается при каждом повороте матрицы <math>A</math>. Вычисление останавливается, когда угол поворота становится близок к нулю, либо когда максимальный внедиагональный элемент становится меньше заранее выбранного порогового значения.

=== Математическое описание алгоритма ===
Исходные данные: симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>).

Матрица <math>A_{i+1}</math> получается из <math>A_i</math> по формуле <math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math>J_i</math> — ортогональная матрица, называемая ''вращением Якоби''.
При подходящем выборе <math>J_i</math> матрица <math>A_m</math> для больших m будет близка к диагональной матрице <math>\Lambda</math>.

Матрица <math>J_i</math> выбирается так, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}</math> <ref name="VVVVVV">Деммель Дж. Вычислительная линейная алгебра. - М.: МИР, 2001 - С. 244-248</ref>.



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

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

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>. Тогда матрица <math>A_{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)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Можно выбрать <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>. Отсюда получим равенство

: <math> \frac{a_{jj}^{(i)} - a_{kk}^{(i)}}{2 a_{jk}^{(i)}} = \frac{c^2 - s^2}{2sc} = \frac{\cos (2\theta)}{\sin (2\theta)} = \operatorname{ctg}(2\theta) \equiv \tau </math>.

Если <math> a_{jj}^{(i)} = a_{kk}^{(i)}</math>, то <math>\theta = \frac{\pi}{4}</math>.

Положим <math>t = \frac{s}{c} = \operatorname{tg}(\theta)</math> и заметим, что <math>t^2 - 2t\tau + 1 = 0</math>. Решая квадратное уравнение, находим <math>t = \frac{\operatorname{sign}(\tau)}{|\tau| + \sqrt{1+\tau^2}}, c = \frac{1}{\sqrt{1+t^2}}, s = tc</math>.

Выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

=== Вычислительное ядро алгоритма ===
Рассматривая отдельную итерацию, можно считать, что вычислительное ядро составляют множественные вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>   в процессе применения матрицы поворота <math>J_i</math> к матрице <math>A</math>:
: <math>\begin{align}
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k,
\end{align}</math>

каждое из которых повторяется по <math> (n-2) </math> раза, а также вычисление элементов <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>

=== Макроструктура алгоритма ===
Основную часть метода составляет процедура применения вращения к матрице <math>A</math>, которая в дальнейшем будет обозначена как '''''Jakobi-Rotation<math>(A,j,k)</math>'''''.

Эту процедуру, в свою очередь, можно разделить на две логические части:
# Определение угла поворота <math>\theta</math> по элементам матрицы <math>a_{jj}</math>, <math>a_{kk}</math> и <math>a_{jk}</math>;
# Поворот матрицы <math>A</math> (изменяются лишь строки и столбцы, соответствующие индексам <math>j</math> и  <math>k</math>).

=== Схема реализации последовательного алгоритма ===
Алгоритм можно описать следующим образом <ref name="VVVVVV" />:

repeat
выбрать пару индексов j,k
обратиться к процедуре '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
пока <math>A</math> не достаточно близка к диагональной матрице

Существует несколько способов выбора пары <math>j,k</math>. Наиболее простой и быстрый способ — построчный циклический обход внедиагональных элементов матрицы <math>A</math>:

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

Процедура '''''Jakobi-Rotation<math>(A,j,k)</math>''''' — это следующий алгоритм:
if <math>|a_{jk}|</math> не слишком мал
if <math>a_{jj}==a_{kk}</math>
<math>\theta=\frac{\Pi}{4}</math>
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\,t
\end{align}</math>
end if
<math>A = R^T(j,k,\theta)\cdot A\cdot R(j,k,\theta), \qquad J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta </math>
end if

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

Для осуществления одной итерации метода Якоби для матрицы размера <math>(n\times n)</math> требуется выполнить:

Для вычислительного ядра —
* <math> 4n+4 </math> умножений,
* <math> 2n+2 </math> сложений.

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

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

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

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

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

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

'''Первой''' группе вершин (J) соответствует вычисление значений c и s.

'''Второй''' группе вершин (А) соответствует вычисление значений элементов <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>.

'''Третьей''' группе вершин (B) соответствует вычисление значений элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>.



[[File:Информационный_граф_метода_якоби.png|none|thumb|2000px|Рисунок 1. Граф одной итерации алгоритма без отображения входных и выходных данных.]]

[[File:ГрафJ.png|none|thumb|2000px|Рисунок 2. Внутренний граф вершин J с входными параметрами <math>x = a_{jj}^{(i)}, y = a_{kk}^{(i)}, z = a_{jk}^{(i)}</math>.]]

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

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

После этого выполняется ярус, отвечающий за применение поворота к матрице <math>A</math> с параллельным выполнением <math>2(n-2)</math> операций вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math> , а также 2 операций вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>. Наибольшее количество операций содержится в вычислении последних двух элементов (по 6 умножений и 3 сложения).

Суммарное количество итераций зависит от входных данных и заданного значения погрешности. Один "цикл" (полный проход по внедиагональным элементам) осуществляется за <math>N = \frac{n(n-1)}{2}</math> итераций. Асимптотически метод сходится квадратично <ref>Wilkinson J. H. The Algebraic Eigenvalue Problem // Oxford University Press, UK, 1965, P. 270</ref>. Как правило, для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов <ref name="VVVVVV" />.

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

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

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

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

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

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

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

Метод Якоби является самым медленным из имеющихся алгоритмов вычисления собственных значений симметричной матрицы. Тем не менее, он способен вычислять малые собственные числа и отвечающие им собственные векторы с гораздо большей точностью, чем другие методы <ref name="VVVVVV" />. Кроме того, он не предполагает первоначального приведения матрицы к трехдиагональной форме.

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

Вычислительная мощность алгоритма линейна.

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

Дуги информационного графа, исходящие из вершин, соответствующих вычислениям значений <math>c</math> и <math>s</math>, образуют пучки рассылок линейной мощности.

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Исследование масштабируемости проводилось на суперкомпьютере "Ломоносов" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского Государственного Университета имени М.В. Ломоносова]. Алгоритм реализован на языке C++ с использованием средств MPI.

Значения изменяемых параметров запуска реализации алгоритма:
* число процессов: 2, 4, 8, 16, 32, 64;
* число элементов в матрице: 900, 3600, 8100, 14400, 22500, 32400, 44100, 57600, 72900, 90000.

На следующих рисунках приведены графики времени выполнения и производительности выбранной реализации алгоритма в зависимости от изменяемых параметров запуска

[[File:jacobi_time.jpg|thumb|center|720px|Рисунок 3. Изменение времени выполнения в зависимости от числа процессов и размера входной матрицы]]
[[File:jacobi_perform.jpg|thumb|center|720px|Рисунок 4. Изменение производительности в зависимости от числа процессов и размера входной матрицы]]

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

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

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

Существует библиотека JACOBI_EIGENVALUE, реализующая последовательный вариант метода Якоби на языках программирования [http://people.sc.fsu.edu/~jburkardt/c_src/jacobi_eigenvalue/jacobi_eigenvalue.html С], [http://people.sc.fsu.edu/~jburkardt/cpp_src/jacobi_eigenvalue/jacobi_eigenvalue.html С++], [http://people.sc.fsu.edu/~jburkardt/f77_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN77], [http://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN90], [http://people.sc.fsu.edu/~jburkardt/m_src/jacobi_eigenvalue/jacobi_eigenvalue.html MATLAB], [http://people.sc.fsu.edu/~jburkardt/py_src/jacobi_eigenvalue/jacobi_eigenvalue.html Python].
Данная библиотека распространяется по лицензии [http://people.sc.fsu.edu/~jburkardt/txt/gnu_lgpl.txt GNU LESSER GENERAL PUBLIC LICENSE].

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

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

<references \>

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

2016-11-11T18:26:34Z

Игорь:

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

Авторы описания: [[Участник: Galkina|А.С.Галкина]] (входные и выходные данные, математическое описание алгоритма и др.), [[Участник: Игорь|И.А.Плахов]] (ресурс параллелизма алгоритма,последовательная сложность алгоритма и др.) Вклад авторов считать равноценным.

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

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

Метод Якоби — итерационный алгоритм для вычисления собственных значений и собственных векторов вещественной симметричной матрицы. Карл Густав Якоб Якоби, в честь которого назван этот метод, предложил его в 1846 году, хотя использоваться он начал только в 1950-х годах с появлением компьютеров.
Суть алгоритма заключается в том, чтобы по заданной симметрической матрице <math>A = A_0</math> построить последовательность ортогонально подобных матриц <math>A_1,A_2,\dotsc,A_m</math>, сходящуюся к диагональной матрице, на диагонали которой стоят собственные значения. Для построения этой последовательности применяется специально подобранная матрица поворота <math>J_i</math>, такая что норма наддиагональной части <math>of\!f(A)=\sqrt{\sum\limits_{1 \le j < k \le n} a_{jk}^2}</math> уменьшается при каждом повороте матрицы <math>A</math>. Вычисление останавливается, когда угол поворота становится близок к нулю, либо когда максимальный внедиагональный элемент становится меньше заранее выбранного порогового значения.

=== Математическое описание алгоритма ===
Исходные данные: симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>).

Матрица <math>A_{i+1}</math> получается из <math>A_i</math> по формуле <math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math>J_i</math> — ортогональная матрица, называемая ''вращением Якоби''.
При подходящем выборе <math>J_i</math> матрица <math>A_m</math> для больших m будет близка к диагональной матрице <math>\Lambda</math>.

Матрица <math>J_i</math> выбирается так, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}</math> <ref name="VVVVVV">Деммель Дж. Вычислительная линейная алгебра. - М.: МИР, 2001 - С. 244-248</ref>.



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

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

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>. Тогда матрица <math>A_{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)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Можно выбрать <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>. Отсюда получим равенство

: <math> \frac{a_{jj}^{(i)} - a_{kk}^{(i)}}{2 a_{jk}^{(i)}} = \frac{c^2 - s^2}{2sc} = \frac{\cos (2\theta)}{\sin (2\theta)} = \operatorname{ctg}(2\theta) \equiv \tau </math>.

Если <math> a_{jj}^{(i)} = a_{kk}^{(i)}</math>, то <math>\theta = \frac{\pi}{4}</math>.

Положим <math>t = \frac{s}{c} = \operatorname{tg}(\theta)</math> и заметим, что <math>t^2 - 2t\tau + 1 = 0</math>. Решая квадратное уравнение, находим <math>t = \frac{\operatorname{sign}(\tau)}{|\tau| + \sqrt{1+\tau^2}}, c = \frac{1}{\sqrt{1+t^2}}, s = tc</math>.

Выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

=== Вычислительное ядро алгоритма ===
Рассматривая отдельную итерацию, можно считать, что вычислительное ядро составляют множественные вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>   в процессе применения матрицы поворота <math>J_i</math> к матрице <math>A</math>:
: <math>\begin{align}
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k,
\end{align}</math>

каждое из которых повторяется по <math> (n-2) </math> раза, а также вычисление элементов <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>

=== Макроструктура алгоритма ===
Основную часть метода составляет процедура применения вращения к матрице <math>A</math>, которая в дальнейшем будет обозначена как '''''Jakobi-Rotation<math>(A,j,k)</math>'''''.

Эту процедуру, в свою очередь, можно разделить на две логические части:
# Определение угла поворота <math>\theta</math> по элементам матрицы <math>a_{jj}</math>, <math>a_{kk}</math> и <math>a_{jk}</math>;
# Поворот матрицы <math>A</math> (изменяются лишь строки и столбцы, соответствующие индексам <math>j</math> и  <math>k</math>).

=== Схема реализации последовательного алгоритма ===
Алгоритм можно описать следующим образом <ref name="VVVVVV" />:

repeat
выбрать пару индексов j,k
обратиться к процедуре '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
пока <math>A</math> не достаточно близка к диагональной матрице

Существует несколько способов выбора пары <math>j,k</math>. Наиболее простой и быстрый способ — построчный циклический обход внедиагональных элементов матрицы <math>A</math>:

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

Процедура '''''Jakobi-Rotation<math>(A,j,k)</math>''''' — это следующий алгоритм:
if <math>|a_{jk}|</math> не слишком мал
if <math>a_{jj}==a_{kk}</math>
<math>\theta=\frac{\Pi}{4}</math>
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\,t
\end{align}</math>
end if
<math>A = R^T(j,k,\theta)\cdot A\cdot R(j,k,\theta), \qquad J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta </math>
end if

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

Для осуществления одной итерации метода Якоби для матрицы размера <math>(n\times n)</math> требуется выполнить:

Для вычислительного ядра —
* <math> 4n+4 </math> умножений,
* <math> 2n+2 </math> сложений.

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

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

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

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

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

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

'''Первой''' группе вершин (J) соответствует вычисление значений c и s.

'''Второй''' группе вершин (А) соответствует вычисление значений элементов <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>.

'''Третьей''' группе вершин (B) соответствует вычисление значений элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>.



[[File:Информационный_граф_метода_якоби.png|none|thumb|2000px|Рисунок 1. Граф одной итерации алгоритма без отображения входных и выходных данных.]]

[[File:ГрафJ.png|none|thumb|2000px|Рисунок 2. Внутренний граф вершин J с входными параметрами <math>x = a_{jj}^{(i)}, y = a_{kk}^{(i)}, z = a_{jk}^{(i)}</math>.]]

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

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

После этого выполняется ярус, отвечающий за применение поворота к матрице <math>A</math> с параллельным выполнением <math>2(n-2)</math> операций вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math> , а также 2 операций вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>. Наибольшее количество операций содержится в вычислении последних двух элементов (по 6 умножений и 3 сложения).

Суммарное количество итераций зависит от входных данных и заданного значения погрешности. Один "цикл" (полный проход по внедиагональным элементам) осуществляется за <math>N = \frac{n(n-1)}{2}</math> итераций. Асимптотически метод сходится квадратично <ref>Wilkinson J. H. The Algebraic Eigenvalue Problem // Oxford University Press, UK, 1965, P. 270</ref>. Как правило, для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов <ref name="VVVVVV" />.

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

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

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

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

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

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

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

Метод Якоби является самым медленным из имеющихся алгоритмов вычисления собственных значений симметричной матрицы. Тем не менее, он способен вычислять малые собственные числа и отвечающие им собственные векторы с гораздо большей точностью, чем другие методы <ref name="VVVVVV" />. Кроме того, он не предполагает первоначального приведения матрицы к трехдиагональной форме.

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

Вычислительная мощность алгоритма линейна.

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

Дуги информационного графа, исходящие из вершин, соответствующих вычислениям значений <math>c</math> и <math>s</math>, образуют пучки рассылок линейной мощности.

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

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

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

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

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

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

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

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

Существует библиотека JACOBI_EIGENVALUE, реализующая последовательный вариант метода Якоби на языках программирования [http://people.sc.fsu.edu/~jburkardt/c_src/jacobi_eigenvalue/jacobi_eigenvalue.html С], [http://people.sc.fsu.edu/~jburkardt/cpp_src/jacobi_eigenvalue/jacobi_eigenvalue.html С++], [http://people.sc.fsu.edu/~jburkardt/f77_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN77], [http://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN90], [http://people.sc.fsu.edu/~jburkardt/m_src/jacobi_eigenvalue/jacobi_eigenvalue.html MATLAB], [http://people.sc.fsu.edu/~jburkardt/py_src/jacobi_eigenvalue/jacobi_eigenvalue.html Python].
Данная библиотека распространяется по лицензии [http://people.sc.fsu.edu/~jburkardt/txt/gnu_lgpl.txt GNU LESSER GENERAL PUBLIC LICENSE].

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

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

<references \>

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

2016-11-11T17:05:04Z

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

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

Авторы описания: [[Участник: Galkina|А.С.Галкина]] (входные и выходные данные, математическое описание алгоритма и др.), [[Участник: Игорь|И.А.Плахов]] (ресурс параллелизма алгоритма,последовательная сложность алгоритма и др.) Вклад авторов считать равноценным.

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

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

Метод Якоби — итерационный алгоритм для вычисления собственных значений и собственных векторов вещественной симметричной матрицы. Карл Густав Якоб Якоби, в честь которого назван этот метод, предложил его в 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>Golub, G.H. (2000). «Eigenvalue computation in the 20th century». Journal of Computational and Applied Mathematics 123 (1-2): 35–65. DOI:[https://dx.doi.org/10.1016%2FS0377-0427%2800%2900413-1 10.1016/S0377-0427(00)00413-1].</ref>.
Суть алгоритма заключается в том, чтобы по заданной симметрической матрице <math>A = A_0</math> построить последовательность ортогонально подобных матриц <math>A_1,A_2,\dotsc,A_m</math>, сходящуюся к диагональной матрице, на диагонали которой стоят собственные значения. Для построения этой последовательности применяется специально подобранная матрица поворота <math>J_i</math>, такая что норма наддиагональной части <math>of\!f(A)=\sqrt{\sum\limits_{1 \le j < k \le n} a_{jk}^2}</math> уменьшается при каждом повороте матрицы <math>A</math>. Вычисление останавливается, когда угол поворота становится близок к нулю, либо когда максимальный внедиагональный элемент становится меньше заранее выбранного порогового значения.

=== Математическое описание алгоритма ===
Исходные данные: симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>).

Матрица <math>A_{i+1}</math> получается из <math>A_i</math> по формуле <math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math>J_i</math> — ортогональная матрица, называемая ''вращением Якоби''.
При подходящем выборе <math>J_i</math> матрица <math>A_m</math> для больших m будет близка к диагональной матрице <math>\Lambda</math>.

Матрица <math>J_i</math> выбирается так, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}</math> <ref name="VVVVVV">Деммель Дж. Вычислительная линейная алгебра. - М.: МИР, 2001 - С. 244-248</ref>.



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

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

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>. Тогда матрица <math>A_{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)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Можно выбрать <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>. Отсюда получим равенство

: <math> \frac{a_{jj}^{(i)} - a_{kk}^{(i)}}{2 a_{jk}^{(i)}} = \frac{c^2 - s^2}{2sc} = \frac{\cos 2\theta}{\sin 2\theta} = \operatorname{tg}(2\theta) \equiv \tau </math>.

Положим <math>t = \frac{s}{c} = \operatorname{ctg}(\theta)</math> и заметим, что <math>t^2 - 2t\tau + 1 = 0</math>. Решая квадратное уравнение, находим <math>t = \frac{\operatorname{sign}(\tau)}{|\tau| + \sqrt{1+\tau^2}}, c = \frac{1}{\sqrt{1+t^2}}, s = tc</math>.

Выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

=== Вычислительное ядро алгоритма ===
Рассматривая отдельную итерацию, можно считать, что вычислительное ядро составляют множественные вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>   в процессе применения матрицы поворота <math>J_i</math> к матрице <math>A</math>:
: <math>\begin{align}
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k,
\end{align}</math>

каждое из которых повторяется по <math> (n-2) </math> раза, а также вычисление элементов <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>

=== Макроструктура алгоритма ===
Основную часть метода составляет процедура применения вращения к матрице <math>A</math>, которая в дальнейшем будет обозначена как '''''Jakobi-Rotation<math>(A,j,k)</math>'''''.

Эту процедуру, в свою очередь, можно разделить на две логические части:
# Определение угла поворота <math>\theta</math> по элементам матрицы <math>a_{jj}</math>, <math>a_{kk}</math> и <math>a_{jk}</math>;
# Поворот матрицы <math>A</math> (изменяются лишь строки и столбцы, соответствующие индексам <math>j</math> и  <math>k</math>).

=== Схема реализации последовательного алгоритма ===
Алгоритм можно описать следующим образом <ref name="VVVVVV" />:

repeat
выбрать пару индексов j,k
обратиться к процедуре '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
пока <math>A</math> не достаточно близка к диагональной матрице

Существует несколько способов выбора пары <math>j,k</math>. Наиболее простой и быстрый способ — построчный циклический обход внедиагональных элементов матрицы <math>A</math>:

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

Процедура '''''Jakobi-Rotation<math>(A,j,k)</math>''''' — это следующий алгоритм:
if <math>|a_{jk}|</math> не слишком мал
if <math>a_{jj}==a_{kk}</math>
<math>\theta=\frac{\Pi}{4}</math>
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\,t
\end{align}</math>
end if
<math>A = R^T(j,k,\theta)\cdot A\cdot R(j,k,\theta), \qquad J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta </math>
end if

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

Для осуществления одной итерации метода Якоби для матрицы размера <math>(n\times n)</math> требуется выполнить:

Для вычислительного ядра —
* <math> 4n+4 </math> умножений,
* <math> 2n+2 </math> сложений.

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

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

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

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

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

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

'''Первой''' группе вершин (J) соответствует вычисление значений c и s.

'''Второй''' группе вершин (А) соответствует вычисление значений элементов <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>.

'''Третьей''' группе вершин (B) соответствует вычисление значений элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>.



[[File:Информационный_граф_метода_якоби.png|none|thumb|2000px|Рисунок 1. Граф одной итерации алгоритма без отображения входных и выходных данных.]]

[[File:ГрафJ.png|none|thumb|2000px|Рисунок 2. Внутренний граф вершин J с входными параметрами <math>x = a_{jj}^{(i)}, y = a_{kk}^{(i)}, z = a_{jk}^{(i)}</math>.]]

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

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

После этого выполняется ярус, отвечающий за применение поворота к матрице <math>A</math> с параллельным выполнением <math>2(n-2)</math> операций вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math> , а также 2 операций вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>. Наибольшее количество операций содержится в вычислении последних двух элементов (по 6 умножений и 3 сложения).

Суммарное количество итераций зависит от входных данных и заданного значения погрешности. Один "цикл" (полный проход по внедиагональным элементам) осуществляется за <math>N = \frac{n(n-1)}{2}</math> итераций. Асимптотически метод сходится квадратично<ref>J. H. Wilkinson. The Algebraic Eigenvalue Problem. Oxford University Press, UK, 1965. (стр 270)</ref>. Как правило, для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов <ref name="VVVVVV" />.

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

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

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

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

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

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

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

Метод Якоби является самым медленным из имеющихся алгоритмов вычисления собственных значений симметричной матрицы. Тем не менее, он способен вычислять малые собственные числа и отвечающие им собственные векторы с гораздо большей точностью, чем другие методы <ref name="VVVVVV" />. Кроме того, он не предполагает первоначального приведения матрицы к трехдиагональной форме.

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

Вычислительная мощность алгоритма линейна.

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

Дуги информационного графа, исходящие из вершин, соответствующих вычислениям значений <math>c</math> и <math>s</math>, образуют пучки рассылок линейной мощности.

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

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

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

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

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

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

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

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

Существует библиотека JACOBI_EIGENVALUE, реализующая последовательный вариант метода Якоби на языках программирования [http://people.sc.fsu.edu/~jburkardt/c_src/jacobi_eigenvalue/jacobi_eigenvalue.html С], [http://people.sc.fsu.edu/~jburkardt/cpp_src/jacobi_eigenvalue/jacobi_eigenvalue.html С++], [http://people.sc.fsu.edu/~jburkardt/f77_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN77], [http://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN90], [http://people.sc.fsu.edu/~jburkardt/m_src/jacobi_eigenvalue/jacobi_eigenvalue.html MATLAB], [http://people.sc.fsu.edu/~jburkardt/py_src/jacobi_eigenvalue/jacobi_eigenvalue.html Python].
Данная библиотека распространяется по лицензии [http://people.sc.fsu.edu/~jburkardt/txt/gnu_lgpl.txt GNU LESSER GENERAL PUBLIC LICENSE].

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

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

<references \>

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

2016-10-25T20:06:17Z

Игорь: /* Свойства алгоритма */

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

Авторы описания: [[Участник: Galkina|А.С.Галкина]] (входные и выходные данные, математическое описание алгоритма и др.), [[Участник: Игорь|И.А.Плахов]] (ресурс параллелизма алгоритма,последовательная сложность алгоритма и др.) Вклад авторов считать равноценным.

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

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

Метод Якоби — итерационный алгоритм для вычисления собственных значений и собственных векторов вещественной симметричной матрицы. Карл Густав Якоб Якоби, в честь которого назван этот метод, предложил его в 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>Golub, G.H. (2000). «Eigenvalue computation in the 20th century». Journal of Computational and Applied Mathematics 123 (1-2): 35–65. DOI:[https://dx.doi.org/10.1016%2FS0377-0427%2800%2900413-1 10.1016/S0377-0427(00)00413-1].</ref>.
Суть алгоритма заключается в том, чтобы по заданной симметрической матрице <math>A = A_0</math> построить последовательность ортогонально подобных матриц <math>A_1,A_2,\dotsc,A_m</math>, сходящуюся к диагональной матрице, на диагонали которой стоят собственные значения. Для построения этой последовательности применяется специально подобранная матрица поворота <math>J_i</math>, такая что норма наддиагональной части <math>of\!f(A)=\sqrt{\sum\limits_{1 \le j < k \le n} a_{jk}^2}</math> уменьшается при каждом повороте матрицы <math>A</math>. Вычисление останавливается, когда угол поворота становится близок к нулю, либо когда максимальный внедиагональный элемент становится меньше заранее выбранного порогового значения.

=== Математическое описание алгоритма ===
Исходные данные: симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>).

Матрица <math>A_{i+1}</math> получается из <math>A_i</math> по формуле <math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math>J_i</math> — ортогональная матрица, называемая ''вращением Якоби''.
При подходящем выборе <math>J_i</math> матрица <math>A_m</math> для больших m будет близка к диагональной матрице <math>\Lambda</math>.

Матрица <math>J_i</math> выбирается так, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}</math><ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>.



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

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

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>. Тогда матрица <math>A_{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)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Можно выбрать <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>. Отсюда получим равенство

: <math> \frac{a_{jj}^{(i)} - a_{kk}^{(i)}}{2 a_{jk}^{(i)}} = \frac{c^2 - s^2}{2sc} = \frac{\cos 2\theta}{\sin 2\theta} = \operatorname{tg}(2\theta) \equiv \tau </math>.

Положим <math>t = \frac{s}{c} = \operatorname{ctg}(\theta)</math> и заметим, что <math>t^2 - 2t\tau + 1 = 0</math>. Решая квадратное уравнение, находим <math>t = \frac{\operatorname{sign}(\tau)}{|\tau| + \sqrt{1+\tau^2}}, c = \frac{1}{\sqrt{1+t^2}}, s = tc</math>.

Выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

=== Вычислительное ядро алгоритма ===
Рассматривая отдельную итерацию, можно считать, что вычислительное ядро составляют множественные вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>   в процессе применения матрицы поворота <math>J_i</math> к матрице <math>A</math>:
: <math>\begin{align}
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k,
\end{align}</math>

каждое из которых повторяется по <math> (n-2) </math> раза, а также вычисление элементов <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>

=== Макроструктура алгоритма ===
Основную часть метода составляет процедура применения вращения к матрице <math>A</math>, которая в дальнейшем будет обозначена как '''''Jakobi-Rotation<math>(A,j,k)</math>'''''.

Эту процедуру, в свою очередь, можно разделить на две логические части:
# Определение угла поворота <math>\theta</math> по элементам матрицы <math>a_{jj}</math>, <math>a_{kk}</math> и <math>a_{jk}</math>;
# Поворот матрицы <math>A</math> (изменяются лишь строки и столбцы, соответствующие индексам <math>j</math> и  <math>k</math>).

=== Схема реализации последовательного алгоритма ===
Алгоритм можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246-248)</ref>:

repeat
выбрать пару индексов j,k
обратиться к процедуре '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
пока <math>A</math> не достаточно близка к диагональной матрице

Существует несколько способов выбора пары <math>j,k</math>. Наиболее простой и быстрый способ — построчный циклический обход внедиагональных элементов матрицы <math>A</math>:

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

Процедура '''''Jakobi-Rotation<math>(A,j,k)</math>''''' — это следующий алгоритм:
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\,t \\
A &= R^T(j,k,\theta)\cdot A\cdot R(j,k,\theta), \qquad J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}</math>
end if

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

Для осуществления одной итерации метода Якоби для матрицы размера <math>(n\times n)</math> требуется выполнить:

Для вычислительного ядра —
* <math> 4n+4 </math> умножений,
* <math> 2n+2 </math> сложений.

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

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

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

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

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

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

'''Первой''' группе вершин (J) соответствует вычисление значений c и s.

'''Второй''' группе вершин (А) соответствует вычисление значений элементов <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>.

'''Третьей''' группе вершин (B) соответствует вычисление значений элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>.



[[File:Информационный_граф_метода_якоби.png|none|thumb|2000px|Рисунок 1. Граф одной итерации алгоритма без отображения входных и выходных данных.]]

[[File:ГрафJ.png|none|thumb|2000px|Рисунок 2. Внутренний граф вершин J с входными параметрами <math>x = a_{jj}^{(i)}, y = a_{kk}^{(i)}, z = a_{jk}^{(i)}</math>.]]

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

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

После этого выполняется ярус, отвечающий за применение поворота к матрице <math>A</math> с параллельным выполнением <math>2(n-2)</math> операций вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math> , а также 2 операций вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>. Наибольшее количество операций содержится в вычислении последних двух элементов (по 6 умножений и 3 сложения).

Суммарное количество итераций зависит от входных данных и заданного значения погрешности. Один "цикл" (полный проход по внедиагональным элементам) осуществляется за <math>N = \frac{n(n-1)}{2}</math> итераций. Асимптотически метод сходится квадратично<ref>J. H. Wilkinson. The Algebraic Eigenvalue Problem. Oxford University Press, UK, 1965. (стр 270)</ref>. Как правило, для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 248)</ref>.

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

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

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

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

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

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

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

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

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

Вычислительная мощность алгоритма линейна.

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

Дуги информационного графа, исходящие из вершин, соответствующих вычислениям значений <math>c</math> и <math>s</math>, образуют пучки рассылок линейной мощности.

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

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

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

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

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

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

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

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

Существует библиотека JACOBI_EIGENVALUE, реализующая последовательный вариант метода Якоби на языках программирования [http://people.sc.fsu.edu/~jburkardt/c_src/jacobi_eigenvalue/jacobi_eigenvalue.html С], [http://people.sc.fsu.edu/~jburkardt/cpp_src/jacobi_eigenvalue/jacobi_eigenvalue.html С++], [http://people.sc.fsu.edu/~jburkardt/f77_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN77], [http://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN90], [http://people.sc.fsu.edu/~jburkardt/m_src/jacobi_eigenvalue/jacobi_eigenvalue.html MATLAB], [http://people.sc.fsu.edu/~jburkardt/py_src/jacobi_eigenvalue/jacobi_eigenvalue.html Python].
Данная библиотека распространяется по лицензии [http://people.sc.fsu.edu/~jburkardt/txt/gnu_lgpl.txt GNU LESSER GENERAL PUBLIC LICENSE].

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

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

<references \>

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

2016-10-25T17:10:46Z

Игорь:

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

Авторы описания: [[Участник: Galkina|А.С.Галкина]] (входные и выходные данные, математическое описание алгоритма и др.), [[Участник: Игорь|И.А.Плахов]] (ресурс параллелизма алгоритма,последовательная сложность алгоритма и др.) Вклад авторов считать равноценным.

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

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

Метод Якоби — итерационный алгоритм для вычисления собственных значений и собственных векторов вещественной симметричной матрицы. Карл Густав Якоб Якоби, в честь которого назван этот метод, предложил его в 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>Golub, G.H. (2000). «Eigenvalue computation in the 20th century». Journal of Computational and Applied Mathematics 123 (1-2): 35–65. DOI:[https://dx.doi.org/10.1016%2FS0377-0427%2800%2900413-1 10.1016/S0377-0427(00)00413-1].</ref>.
Суть алгоритма заключается в том, чтобы по заданной симметрической матрице <math>A = A_0</math> построить последовательность ортогонально подобных матриц <math>A_1,A_2,\dotsc,A_m</math>, сходящуюся к диагональной матрице, на диагонали которой стоят собственные значения. Для построения этой последовательности применяется специально подобранная матрица поворота <math>J_i</math>, такая что норма наддиагональной части <math>of\!f(A)=\sqrt{\sum\limits_{1 \le j < k \le n} a_{jk}^2}</math> уменьшается при каждом повороте матрицы <math>A</math>. Вычисление останавливается, когда угол поворота становится близок к нулю, либо когда максимальный внедиагональный элемент становится меньше заранее выбранного порогового значения.

=== Математическое описание алгоритма ===
Исходные данные: симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>).

Матрица <math>A_{i+1}</math> получается из <math>A_i</math> по формуле <math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math>J_i</math> — ортогональная матрица, называемая ''вращением Якоби''.
При подходящем выборе <math>J_i</math> матрица <math>A_m</math> для больших m будет близка к диагональной матрице <math>\Lambda</math>.

Матрица <math>J_i</math> выбирается так, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}</math><ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>.



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

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

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>. Тогда матрица <math>A_{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)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Можно выбрать <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>. Отсюда получим равенство

: <math> \frac{a_{jj}^{(i)} - a_{kk}^{(i)}}{2 a_{jk}^{(i)}} = \frac{c^2 - s^2}{2sc} = \frac{\cos 2\theta}{\sin 2\theta} = \operatorname{tg}(2\theta) \equiv \tau </math>.

Положим <math>t = \frac{s}{c} = \operatorname{ctg}(\theta)</math> и заметим, что <math>t^2 - 2t\tau + 1 = 0</math>. Решая квадратное уравнение, находим <math>t = \frac{\operatorname{sign}(\tau)}{|\tau| + \sqrt{1+\tau^2}}, c = \frac{1}{\sqrt{1+t^2}}, s = tc</math>.

Выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

=== Вычислительное ядро алгоритма ===
Рассматривая отдельную итерацию, можно считать, что вычислительное ядро составляют множественные вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>   в процессе применения матрицы поворота <math>J_i</math> к матрице <math>A</math>:
: <math>\begin{align}
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k,
\end{align}</math>

каждое из которых повторяется по <math> (n-2) </math> раза, а также вычисление элементов <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>

=== Макроструктура алгоритма ===
Основную часть метода составляет процедура применения вращения к матрице <math>A</math>, которая в дальнейшем будет обозначена как '''''Jakobi-Rotation<math>(A,j,k)</math>'''''.

Эту процедуру, в свою очередь, можно разделить на две логические части:
# Определение угла поворота <math>\theta</math> по элементам матрицы <math>a_{jj}</math>, <math>a_{kk}</math> и <math>a_{jk}</math>;
# Поворот матрицы <math>A</math> (изменяются лишь строки и столбцы, соответствующие индексам <math>j</math> и  <math>k</math>).

=== Схема реализации последовательного алгоритма ===
Алгоритм можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246-248)</ref>:

repeat
выбрать пару индексов j,k
обратиться к процедуре '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
пока <math>A</math> не достаточно близка к диагональной матрице

Существует несколько способов выбора пары <math>j,k</math>. Наиболее простой и быстрый способ — построчный циклический обход внедиагональных элементов матрицы <math>A</math>:

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

Процедура '''''Jakobi-Rotation<math>(A,j,k)</math>''''' — это следующий алгоритм:
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\,t \\
A &= R^T(j,k,\theta)\cdot A\cdot R(j,k,\theta), \qquad J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}</math>
end if

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

Для осуществления одной итерации метода Якоби для матрицы размера <math>(n\times n)</math> требуется выполнить:

Для вычислительного ядра —
* <math> 4n+4 </math> умножений,
* <math> 2n+2 </math> сложений.

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

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

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

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

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

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

'''Первой''' группе вершин (J) соответствует вычисление значений c и s.

'''Второй''' группе вершин (А) соответствует вычисление значений элементов <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>.

'''Третьей''' группе вершин (B) соответствует вычисление значений элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>.



[[File:Информационный_граф_метода_якоби.png|none|thumb|2000px|Рисунок 1. Граф одной итерации алгоритма без отображения входных и выходных данных.]]

[[File:ГрафJ.png|none|thumb|2000px|Рисунок 2. Внутренний граф вершин J с входными параметрами <math>x = a_{jj}^{(i)}, y = a_{kk}^{(i)}, z = a_{jk}^{(i)}</math>.]]

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

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

После этого выполняется ярус, отвечающий за применение поворота к матрице <math>A</math> с параллельным выполнением <math>2(n-2)</math> операций вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math> , а также 2 операций вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>. Наибольшее количество операций содержится в вычислении последних двух элементов (по 6 умножений и 3 сложения).

Суммарное количество итераций зависит от входных данных и заданного значения погрешности. Один "цикл" (полный проход по внедиагональным элементам) осуществляется за <math>N = \frac{n(n-1)}{2}</math> итераций. Асимптотически метод сходится квадратично<ref>J. H. Wilkinson. The Algebraic Eigenvalue Problem. Oxford University Press, UK, 1965. (стр 270)</ref>. Как правило, для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 248)</ref>.

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

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

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

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

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

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

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

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

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

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

Дуги информационного графа, исходящие из вершин, соответствующих вычислениям значений <math>c</math> и <math>s</math>, образуют пучки рассылок линейной мощности.

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

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

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

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

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

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

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

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

Существует библиотека JACOBI_EIGENVALUE, реализующая последовательный вариант метода Якоби на языках программирования [http://people.sc.fsu.edu/~jburkardt/c_src/jacobi_eigenvalue/jacobi_eigenvalue.html С], [http://people.sc.fsu.edu/~jburkardt/cpp_src/jacobi_eigenvalue/jacobi_eigenvalue.html С++], [http://people.sc.fsu.edu/~jburkardt/f77_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN77], [http://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN90], [http://people.sc.fsu.edu/~jburkardt/m_src/jacobi_eigenvalue/jacobi_eigenvalue.html MATLAB], [http://people.sc.fsu.edu/~jburkardt/py_src/jacobi_eigenvalue/jacobi_eigenvalue.html Python].
Данная библиотека распространяется по лицензии [http://people.sc.fsu.edu/~jburkardt/txt/gnu_lgpl.txt GNU LESSER GENERAL PUBLIC LICENSE].

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

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

<references \>

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

2016-10-25T17:03:42Z

Игорь:

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

Авторы описания: [[Участник: Galkina|А.С.Галкина]] (входные и выходные данные, математическое описание алгоритма), [[Участник: Игорь|И.А.Плахов]] (ресурс параллелизма алгоритма,последовательная сложность алгоритма). Вклад авторов считать равноценным.

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

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

Метод Якоби — итерационный алгоритм для вычисления собственных значений и собственных векторов вещественной симметричной матрицы. Карл Густав Якоб Якоби, в честь которого назван этот метод, предложил его в 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>Golub, G.H. (2000). «Eigenvalue computation in the 20th century». Journal of Computational and Applied Mathematics 123 (1-2): 35–65. DOI:[https://dx.doi.org/10.1016%2FS0377-0427%2800%2900413-1 10.1016/S0377-0427(00)00413-1].</ref>.
Суть алгоритма заключается в том, чтобы по заданной симметрической матрице <math>A = A_0</math> построить последовательность ортогонально подобных матриц <math>A_1,A_2,\dotsc,A_m</math>, сходящуюся к диагональной матрице, на диагонали которой стоят собственные значения. Для построения этой последовательности применяется специально подобранная матрица поворота <math>J_i</math>, такая что норма наддиагональной части <math>of\!f(A)=\sqrt{\sum\limits_{1 \le j < k \le n} a_{jk}^2}</math> уменьшается при каждом повороте матрицы <math>A</math>. Вычисление останавливается, когда угол поворота становится близок к нулю, либо когда максимальный внедиагональный элемент становится меньше заранее выбранного порогового значения.

=== Математическое описание алгоритма ===
Исходные данные: симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>).

Матрица <math>A_{i+1}</math> получается из <math>A_i</math> по формуле <math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math>J_i</math> — ортогональная матрица, называемая ''вращением Якоби''.
При подходящем выборе <math>J_i</math> матрица <math>A_m</math> для больших m будет близка к диагональной матрице <math>\Lambda</math>.

Матрица <math>J_i</math> выбирается так, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}</math><ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>.



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

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

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>. Тогда матрица <math>A_{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)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Можно выбрать <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>. Отсюда получим равенство

: <math> \frac{a_{jj}^{(i)} - a_{kk}^{(i)}}{2 a_{jk}^{(i)}} = \frac{c^2 - s^2}{2sc} = \frac{\cos 2\theta}{\sin 2\theta} = \operatorname{tg}(2\theta) \equiv \tau </math>.

Положим <math>t = \frac{s}{c} = \operatorname{ctg}(\theta)</math> и заметим, что <math>t^2 - 2t\tau + 1 = 0</math>. Решая квадратное уравнение, находим <math>t = \frac{\operatorname{sign}(\tau)}{|\tau| + \sqrt{1+\tau^2}}, c = \frac{1}{\sqrt{1+t^2}}, s = tc</math>.

Выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

=== Вычислительное ядро алгоритма ===
Рассматривая отдельную итерацию, можно считать, что вычислительное ядро составляют множественные вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>   в процессе применения матрицы поворота <math>J_i</math> к матрице <math>A</math>:
: <math>\begin{align}
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k,
\end{align}</math>

каждое из которых повторяется по <math> (n-2) </math> раза, а также вычисление элементов <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>

=== Макроструктура алгоритма ===
Основную часть метода составляет процедура применения вращения к матрице <math>A</math>, которая в дальнейшем будет обозначена как '''''Jakobi-Rotation<math>(A,j,k)</math>'''''.

Эту процедуру, в свою очередь, можно разделить на две логические части:
# Определение угла поворота <math>\theta</math> по элементам матрицы <math>a_{jj}</math>, <math>a_{kk}</math> и <math>a_{jk}</math>;
# Поворот матрицы <math>A</math> (изменяются лишь строки и столбцы, соответствующие индексам <math>j</math> и  <math>k</math>).

=== Схема реализации последовательного алгоритма ===
Алгоритм можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246-248)</ref>:

repeat
выбрать пару индексов j,k
обратиться к процедуре '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
пока <math>A</math> не достаточно близка к диагональной матрице

Существует несколько способов выбора пары <math>j,k</math>. Наиболее простой и быстрый способ — построчный циклический обход внедиагональных элементов матрицы <math>A</math>:

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

Процедура '''''Jakobi-Rotation<math>(A,j,k)</math>''''' — это следующий алгоритм:
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\,t \\
A &= R^T(j,k,\theta)\cdot A\cdot R(j,k,\theta), \qquad J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}</math>
end if

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

Для осуществления одной итерации метода Якоби для матрицы размера <math>(n\times n)</math> требуется выполнить:

Для вычислительного ядра —
* <math> 4n+4 </math> умножений,
* <math> 2n+2 </math> сложений.

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

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

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

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

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

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

'''Первой''' группе вершин (J) соответствует вычисление значений c и s.

'''Второй''' группе вершин (А) соответствует вычисление значений элементов <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>.

'''Третьей''' группе вершин (B) соответствует вычисление значений элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>.



[[File:Информационный_граф_метода_якоби.png|none|thumb|2000px|Рисунок 1. Граф одной итерации алгоритма без отображения входных и выходных данных.]]

[[File:ГрафJ.png|none|thumb|2000px|Рисунок 2. Внутренний граф вершин J с входными параметрами <math>x = a_{jj}^{(i)}, y = a_{kk}^{(i)}, z = a_{jk}^{(i)}</math>.]]

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

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

После этого выполняется ярус, отвечающий за применение поворота к матрице <math>A</math> с параллельным выполнением <math>2(n-2)</math> операций вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math> , а также 2 операций вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>. Наибольшее количество операций содержится в вычислении последних двух элементов (по 6 умножений и 3 сложения).

Суммарное количество итераций зависит от входных данных и заданного значения погрешности. Один "цикл" (полный проход по внедиагональным элементам) осуществляется за <math>N = \frac{n(n-1)}{2}</math> итераций. Асимптотически метод сходится квадратично<ref>J. H. Wilkinson. The Algebraic Eigenvalue Problem. Oxford University Press, UK, 1965. (стр 270)</ref>. Как правило, для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 248)</ref>.

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

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

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

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

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

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

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

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

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

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

Дуги информационного графа, исходящие из вершин, соответствующих вычислениям значений <math>c</math> и <math>s</math>, образуют пучки рассылок линейной мощности.

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

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

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

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

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

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

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

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

Существует библиотека JACOBI_EIGENVALUE, реализующая последовательный вариант метода Якоби на языках программирования [http://people.sc.fsu.edu/~jburkardt/c_src/jacobi_eigenvalue/jacobi_eigenvalue.html С], [http://people.sc.fsu.edu/~jburkardt/cpp_src/jacobi_eigenvalue/jacobi_eigenvalue.html С++], [http://people.sc.fsu.edu/~jburkardt/f77_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN77], [http://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN90], [http://people.sc.fsu.edu/~jburkardt/m_src/jacobi_eigenvalue/jacobi_eigenvalue.html MATLAB], [http://people.sc.fsu.edu/~jburkardt/py_src/jacobi_eigenvalue/jacobi_eigenvalue.html Python].
Данная библиотека распространяется по лицензии [http://people.sc.fsu.edu/~jburkardt/txt/gnu_lgpl.txt GNU LESSER GENERAL PUBLIC LICENSE].

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

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

<references \>

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

2016-10-15T18:54:12Z

Игорь: /* Математическое описание алгоритма */

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

Авторы описания: [[Участник: Galkina|А.С.Галкина]], [[Участник: Игорь|И.А.Плахов]]

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

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

Метод Якоби — итерационный алгоритм для вычисления собственных значений и собственных векторов вещественной симметричной матрицы. Карл Густав Якоб Якоби, в честь которого назван этот метод, предложил его в 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>Golub, G.H. (2000). «Eigenvalue computation in the 20th century». Journal of Computational and Applied Mathematics 123 (1-2): 35–65. DOI:[https://dx.doi.org/10.1016%2FS0377-0427%2800%2900413-1 10.1016/S0377-0427(00)00413-1].</ref>.
Суть алгоритма заключается в том, чтобы по заданной симметрической матрице <math>A = A_0</math> построить последовательность ортогонально подобных матриц <math>A_1,A_2,\dotsc,A_m</math>, сходящуюся к диагональной матрице, на диагонали которой стоят собственные значения. Для построения этой последовательности применяется специально подобранная матрица поворота <math>J_i</math>, такая что норма наддиагональной части <math>of\!f(A)=\sqrt{\sum\limits_{1 \le j < k \le n} a_{jk}^2}</math> уменьшается при каждом повороте матрицы <math>A</math>. Вычисление останавливается, когда угол поворота становится близок к нулю, либо когда максимальный внедиагональный элемент становится меньше заранее выбранного порогового значения.

=== Математическое описание алгоритма ===
Исходные данные: симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>).

Матрица <math>A_{i+1}</math> получается из <math>A_i</math> по формуле <math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math>J_i</math> — ортогональная матрица, называемая ''вращением Якоби''.
При подходящем выборе <math>J_i</math> матрица <math>A_m</math> для больших m будет близка к диагональной матрице <math>\Lambda</math>.

Матрица <math>J_i</math> выбирается так, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}</math><ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>.



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

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

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>. Тогда матрица <math>A_{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)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Можно выбрать <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>. Отсюда получим равенство

: <math> \frac{a_{jj}^{(i)} - a_{kk}^{(i)}}{2 a_{jk}^{(i)}} = \frac{c^2 - s^2}{2sc} = \frac{\cos 2\theta}{\sin 2\theta} = \operatorname{tg}(2\theta) \equiv \tau </math>.

Положим <math>t = \frac{s}{c} = \operatorname{ctg}(\theta)</math> и заметим, что <math>t^2 - 2t\tau + 1 = 0</math>. Решая квадратное уравнение, находим <math>t = \frac{\operatorname{sign}(\tau)}{|\tau| + \sqrt{1+\tau^2}}, c = \frac{1}{\sqrt{1+t^2}}, s = tc</math>.

Выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

=== Вычислительное ядро алгоритма ===
Рассматривая отдельную итерацию, можно считать, что вычислительное ядро составляют множественные вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>   в процессе применения матрицы поворота <math>J_i</math> к матрице <math>A</math>:
: <math>\begin{align}
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k,
\end{align}</math>

каждое из которых повторяется по <math> (n-2) </math> раза, а также вычисление элементов <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>

=== Макроструктура алгоритма ===
Основную часть метода составляет процедура применения вращения к матрице <math>A</math>, которая в дальнейшем будет обозначена как '''''Jakobi-Rotation<math>(A,j,k)</math>'''''.

Эту процедуру, в свою очередь, можно разделить на две логические части:
# Определение угла поворота <math>\theta</math> по элементам матрицы <math>a_{jj}</math>, <math>a_{kk}</math> и <math>a_{jk}</math>;
# Поворот матрицы <math>A</math> (изменяются лишь строки и столбцы, соответствующие индексам <math>j</math> и  <math>k</math>).

=== Схема реализации последовательного алгоритма ===
Алгоритм можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246-248)</ref>:

repeat
выбрать пару индексов j,k
обратиться к процедуре '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
пока <math>A</math> не достаточно близка к диагональной матрице

Существует несколько способов выбора пары <math>j,k</math>. Наиболее простой и быстрый способ — построчный циклический обход внедиагональных элементов матрицы <math>A</math>:

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

Процедура '''''Jakobi-Rotation<math>(A,j,k)</math>''''' — это следующий алгоритм:
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\,t \\
A &= R^T(j,k,\theta)\cdot A\cdot R(j,k,\theta), \qquad J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}</math>
end if

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

Для осуществления одной итерации метода Якоби для матрицы размера <math>(n\times n)</math> требуется выполнить:

Для вычислительного ядра —
* <math> 4n+4 </math> умножений,
* <math> 2n+2 </math> сложений.

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

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

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

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

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

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

'''Первой''' группе вершин (J) соответствует вычисление значений c и s.

'''Второй''' группе вершин (А) соответствует вычисление значений элементов <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>.

'''Третьей''' группе вершин (B) соответствует вычисление значений элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>.



[[File:Информационный_граф_метода_якоби.png|none|thumb|2000px|Рисунок 1. Граф одной итерации алгоритма без отображения входных и выходных данных.]]

[[File:ГрафJ.png|none|thumb|2000px|Рисунок 2. Внутренний граф вершин J с входными параметрами <math>x = a_{jj}^{(i)}, y = a_{kk}^{(i)}, z = a_{jk}^{(i)}</math>.]]

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

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

После этого выполняется ярус, отвечающий за применение поворота к матрице <math>A</math> с параллельным выполнением <math>2(n-2)</math> операций вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math> , а также 2 операций вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>. Наибольшее количество операций содержится в вычислении последних двух элементов (по 6 умножений и 3 сложения).

Суммарное количество итераций зависит от входных данных и заданного значения погрешности. Один "цикл" (полный проход по внедиагональным элементам) осуществляется за <math>N = \frac{n(n-1)}{2}</math> итераций. Асимптотически метод сходится квадратично<ref>J. H. Wilkinson. The Algebraic Eigenvalue Problem. Oxford University Press, UK, 1965. (стр 270)</ref>. Как правило, для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 248)</ref>.

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

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

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

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

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

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

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

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

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

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

Дуги информационного графа, исходящие из вершин, соответствующих вычислениям значений <math>c</math> и <math>s</math>, образуют пучки рассылок линейной мощности.

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

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

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

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

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

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

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

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

Существует библиотека JACOBI_EIGENVALUE, реализующая последовательный вариант метода Якоби на языках программирования [http://people.sc.fsu.edu/~jburkardt/c_src/jacobi_eigenvalue/jacobi_eigenvalue.html С], [http://people.sc.fsu.edu/~jburkardt/cpp_src/jacobi_eigenvalue/jacobi_eigenvalue.html С++], [http://people.sc.fsu.edu/~jburkardt/f77_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN77], [http://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN90], [http://people.sc.fsu.edu/~jburkardt/m_src/jacobi_eigenvalue/jacobi_eigenvalue.html MATLAB], [http://people.sc.fsu.edu/~jburkardt/py_src/jacobi_eigenvalue/jacobi_eigenvalue.html Python].
Данная библиотека распространяется по лицензии [http://people.sc.fsu.edu/~jburkardt/txt/gnu_lgpl.txt GNU LESSER GENERAL PUBLIC LICENSE].

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

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

<references \>

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

2016-10-15T15:52:11Z

Игорь:

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

Авторы описания: [[Участник: Galkina|А.С.Галкина]], [[Участник: Игорь|И.А.Плахов]]

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

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

Метод Якоби — итерационный алгоритм для вычисления собственных значений и собственных векторов вещественной симметричной матрицы. Карл Густав Якоб Якоби, в честь которого назван этот метод, предложил его в 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>Golub, G.H. (2000). «Eigenvalue computation in the 20th century». Journal of Computational and Applied Mathematics 123 (1-2): 35–65. DOI:[https://dx.doi.org/10.1016%2FS0377-0427%2800%2900413-1 10.1016/S0377-0427(00)00413-1].</ref>.
Суть алгоритма заключается в том, чтобы по заданной симметрической матрице <math>A = A_0</math> построить последовательность ортогонально подобных матриц <math>A_1,A_2,\dotsc,A_m</math>, сходящуюся к диагональной матрице, на диагонали которой стоят собственные значения. Для построения этой последовательности применяется специально подобранная матрица поворота <math>J_i</math>, такая что норма наддиагональной части <math>of\!f(A)=\sqrt{\sum\limits_{1 \le j < k \le n} a_{jk}^2}</math> уменьшается при каждом повороте матрицы <math>A</math>. Вычисление останавливается, когда угол поворота становится близок к нулю, либо когда максимальный внедиагональный элемент становится меньше заранее выбранного порогового значения.

=== Математическое описание алгоритма ===
Исходные данные: симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>).

Матрица <math>A_{i+1}</math> получается из <math>A_i</math> по формуле <math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math>J_i</math> — ортогональная матрица, называемая ''вращением Якоби''.
При подходящем выборе <math>J_i</math> матрица <math>A_m</math> для больших m будет близка к диагональной матрице <math>\Lambda</math>.

Матрица <math>J_i</math> выбирается так, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}</math><ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>.



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

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

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>. Тогда матрица <math>A_{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)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Можно выбрать <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>. Отсюда получим равенство

: <math> \frac{a_{jj}^{(i)} - a_{kk}^{(i)}}{2 a_{jk}^{(i)}} = \frac{c^2 - s^2}{2sc} = \frac{\cos 2\theta}{\sin 2\theta} = \operatorname{tg}(2\theta) \equiv \tau </math>.

Положим <math>t = \frac{s}{c} = \operatorname{ctg}(\theta)</math> и заметим, что <math>t^2 - 2t\tau + 1 = 0</math>. Решая квадратное уравнение, находим <math>t = \frac{\operatorname{sign}(\tau)}{|\tau| + \sqrt{1+\tau^2}}, c = \frac{1}{\sqrt{1+t^2}}, s = tc</math>.

Выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

=== Вычислительное ядро алгоритма ===
Рассматривая отдельную итерацию, можно считать, что вычислительное ядро составляют множественные вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>   в процессе применения матрицы поворота <math>J_i</math> к матрице <math>A</math>:
: <math>\begin{align}
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k,
\end{align}</math>

каждое из которых повторяется по <math> (n-2) </math> раза, а также вычисление элементов <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>

=== Макроструктура алгоритма ===
Основную часть метода составляет процедура применения вращения к матрице <math>A</math>, которая в дальнейшем будет обозначена как '''''Jakobi-Rotation<math>(A,j,k)</math>'''''.

Эту процедуру, в свою очередь, можно разделить на две логические части:
# Определение угла поворота <math>\theta</math> по элементам матрицы <math>a_{jj}</math>, <math>a_{kk}</math> и <math>a_{jk}</math>;
# Поворот матрицы <math>A</math> (изменяются лишь строки и столбцы, соответствующие индексам <math>j</math> и  <math>k</math>).

=== Схема реализации последовательного алгоритма ===
Алгоритм можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246-248)</ref>:

repeat
выбрать пару индексов j,k
обратиться к процедуре '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
пока <math>A</math> не достаточно близка к диагональной матрице

Существует несколько способов выбора пары <math>j,k</math>. Наиболее простой и быстрый способ — построчный циклический обход внедиагональных элементов матрицы <math>A</math>:

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

Процедура '''''Jakobi-Rotation<math>(A,j,k)</math>''''' — это следующий алгоритм:
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\,t \\
A &= R^T(j,k,\theta)\cdot A\cdot R(j,k,\theta), \qquad J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}</math>
end if

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

Для осуществления одной итерации метода Якоби для матрицы размера <math>(n\times n)</math> требуется выполнить:

Для вычислительного ядра —
* <math> 4n+4 </math> умножений,
* <math> 2n+2 </math> сложений.

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

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

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

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

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

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

'''Первой''' группе вершин (J) соответствует вычисление значений c и s.

'''Второй''' группе вершин (А) соответствует вычисление значений элементов <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>.

'''Третьей''' группе вершин (B) соответствует вычисление значений элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>.



[[File:Информационный_граф_метода_якоби.png|none|thumb|2000px|Рисунок 1. Граф одной итерации алгоритма без отображения входных и выходных данных.]]

[[File:ГрафJ.png|none|thumb|2000px|Рисунок 2. Внутренний граф вершин J с входными параметрами <math>x = a_{jj}^{(i)}, y = a_{kk}^{(i)}, z = a_{jk}^{(i)}</math>.]]

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

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

После этого выполняется ярус, отвечающий за применение поворота к матрице <math>A</math> с параллельным выполнением <math>2(n-2)</math> операций вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math> , а также 2 операций вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>. Наибольшее количество операций содержится в вычислении последних двух элементов (по 6 умножений и 3 сложения).

Суммарное количество итераций зависит от входных данных и заданного значения погрешности. Один "цикл" (полный проход по внедиагональным элементам) осуществляется за <math>N = \frac{n(n-1)}{2}</math> итераций. Асимптотически метод сходится квадратично<ref>J. H. Wilkinson. The Algebraic Eigenvalue Problem. Oxford University Press, UK, 1965. (стр 270)</ref>. Как правило, для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 248)</ref>.

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

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

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

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

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

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

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

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

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

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

Дуги информационного графа, исходящие из вершин, соответствующих вычислениям значений <math>c</math> и <math>s</math>, образуют пучки рассылок линейной мощности.

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

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

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

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

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

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

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

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

Существует библиотека JACOBI_EIGENVALUE, реализующая последовательный вариант метода Якоби на языках программирования [http://people.sc.fsu.edu/~jburkardt/c_src/jacobi_eigenvalue/jacobi_eigenvalue.html С], [http://people.sc.fsu.edu/~jburkardt/cpp_src/jacobi_eigenvalue/jacobi_eigenvalue.html С++], [http://people.sc.fsu.edu/~jburkardt/f77_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN77], [http://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN90], [http://people.sc.fsu.edu/~jburkardt/m_src/jacobi_eigenvalue/jacobi_eigenvalue.html MATLAB], [http://people.sc.fsu.edu/~jburkardt/py_src/jacobi_eigenvalue/jacobi_eigenvalue.html Python].
Данная библиотека распространяется по лицензии [http://people.sc.fsu.edu/~jburkardt/txt/gnu_lgpl.txt GNU LESSER GENERAL PUBLIC LICENSE].

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

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

<references \>

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

2016-10-15T15:34:59Z

Игорь: Отмена правки 10251, сделанной участником Игорь (обс.)

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

Авторы описания: [[Участник: Galkina|А.С.Галкина]], [[Участник: Игорь|И.А.Плахов]]

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

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

Метод Якоби — итерационный алгоритм для вычисления собственных значений и собственных векторов вещественной симметричной матрицы. Карл Густав Якоб Якоби, в честь которого назван этот метод, предложил его в 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>Golub, G.H. (2000). «Eigenvalue computation in the 20th century». Journal of Computational and Applied Mathematics 123 (1-2): 35–65. DOI:[https://dx.doi.org/10.1016%2FS0377-0427%2800%2900413-1 10.1016/S0377-0427(00)00413-1].</ref>.
Суть алгоритма заключается в том, чтобы по заданной симметрической матрице <math>A = A_0</math> построить последовательность ортогонально подобных матриц <math>A_1,A_2,\dotsc,A_m</math>, сходящуюся к диагональной матрице, на диагонали которой стоят собственные значения. Для построения этой последовательности применяется специально подобранная матрица поворота <math>J_i</math>, такая что норма наддиагональной части <math>of\!f(A)=\sqrt{\sum\limits_{1 \le j < k \le n} a_{jk}^2}</math> уменьшается при каждом повороте матрицы <math>A</math>. Вычисление останавливается, когда угол поворота становится близок к нулю, либо когда максимальный внедиагональный элемент становится меньше заранее выбранного порогового значения.

=== Математическое описание алгоритма ===
Исходные данные: симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>).

Матрица <math>A_{i+1}</math> получается из <math>A_i</math> по формуле <math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math>J_i</math> — ортогональная матрица, называемая ''вращением Якоби''.
При подходящем выборе <math>J_i</math> матрица <math>A_m</math> для больших m будет близка к диагональной матрице <math>\Lambda</math>.

Матрица <math>J_i</math> выбирается так, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}</math><ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>.



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

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

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>. Тогда матрица <math>A_{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)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Можно выбрать <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>. Отсюда получим равенство

: <math> \frac{a_{jj}^{(i)} - a_{kk}^{(i)}}{2 a_{jk}^{(i)}} = \frac{c^2 - s^2}{2sc} = \frac{\cos 2\theta}{\sin 2\theta} = \operatorname{tg}(2\theta) \equiv \tau </math>.

Положим <math>t = \frac{s}{c} = \operatorname{ctg}(\theta)</math> и заметим, что <math>t^2 - 2t\tau + 1 = 0</math>. Решая квадратное уравнение, находим <math>t = \frac{\operatorname{sign}(\tau)}{|\tau| + \sqrt{1+\tau^2}}, c = \frac{1}{\sqrt{1+t^2}}, s = tc</math>.

Выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

=== Вычислительное ядро алгоритма ===
Рассматривая отдельную итерацию, можно считать, что вычислительное ядро составляют множественные вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>   в процессе применения матрицы поворота <math>J_i</math> к матрице <math>A</math>:
: <math>\begin{align}
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k,
\end{align}</math>

каждое из которых повторяется по <math> (n-2) </math> раза, а также вычисление элементов <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>

=== Макроструктура алгоритма ===
Основную часть метода составляет процедура применения вращения к матрице <math>A</math>, которая в дальнейшем будет обозначена как '''''Jakobi-Rotation<math>(A,j,k)</math>'''''.

Эту процедуру, в свою очередь, можно разделить на две логические части:
# Определение угла поворота <math>\theta</math> по элементам матрицы <math>a_{jj}</math>, <math>a_{kk}</math> и <math>a_{jk}</math>;
# Поворот матрицы <math>A</math> (изменяются лишь строки и столбцы, соответствующие индексам <math>j</math> и  <math>k</math>).

=== Схема реализации последовательного алгоритма ===
Алгоритм можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246-248)</ref>:

repeat
выбрать пару индексов j,k
обратиться к процедуре '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
пока <math>A</math> не достаточно близка к диагональной матрице

Существует несколько способов выбора пары <math>j,k</math>. Наиболее простой и быстрый способ — построчный циклический обход внедиагональных элементов матрицы <math>A</math>:

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

Процедура '''''Jakobi-Rotation<math>(A,j,k)</math>''''' — это следующий алгоритм:
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\,t \\
A &= R^T(j,k,\theta)\cdot A\cdot R(j,k,\theta), \qquad J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}</math>
end if

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

Для осуществления одной итерации метода Якоби для матрицы размера <math>(n\times n)</math> требуется выполнить:

Для вычислительного ядра —
* <math> 4n+4 </math> умножений,
* <math> 2n+2 </math> сложений.

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

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

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

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

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

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

'''Первой''' группе вершин (J) соответствует вычисление значений c и s.

'''Второй''' группе вершин (А) соответствует вычисление значений элементов <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>.

'''Третьей''' группе вершин (B) соответствует вычисление значений элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>.

<center>
<div class="thumb">
<div class="thumbinner" style="width:{{#expr: 3 * (400 + 35) + 4 * (3 - 1) + 8}}px">
<gallery widths=400px heights=400px>
File:Информационный_граф_метода_якоби.png|Рисунок 1. Граф одной итерации алгоритма без отображения входных и выходных данных.
File:ГрафJ.png|Рисунок 2. Внутренний граф вершин J с входными параметрами <math>x = a_{jj}^{(i)}, y = a_{kk}^{(i)}, z = a_{jk}^{(i)}</math>.
</gallery>
</div>
</div>
</center>

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

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

После этого выполняется ярус, отвечающий за применение поворота к матрице <math>A</math> с параллельным выполнением <math>2(n-2)</math> операций вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math> , а также 2 операций вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>. Наибольшее количество операций содержится в вычислении последних двух элементов (по 6 умножений и 3 сложения).

Суммарное количество итераций зависит от входных данных и заданного значения погрешности. Один "цикл" (полный проход по внедиагональным элементам) осуществляется за <math>N = \frac{n(n-1)}{2}</math> итераций. Асимптотически метод сходится квадратично<ref>J. H. Wilkinson. The Algebraic Eigenvalue Problem. Oxford University Press, UK, 1965. (стр 270)</ref>. Как правило, для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 248)</ref>.

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

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

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

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

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

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

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

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

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

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

Дуги информационного графа, исходящие из вершин, соответствующих вычислениям значений <math>c</math> и <math>s</math>, образуют пучки рассылок линейной мощности.

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

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

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

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

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

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

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

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

Существует библиотека JACOBI_EIGENVALUE, реализующая последовательный вариант метода Якоби на языках программирования [http://people.sc.fsu.edu/~jburkardt/c_src/jacobi_eigenvalue/jacobi_eigenvalue.html С], [http://people.sc.fsu.edu/~jburkardt/cpp_src/jacobi_eigenvalue/jacobi_eigenvalue.html С++], [http://people.sc.fsu.edu/~jburkardt/f77_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN77], [http://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN90], [http://people.sc.fsu.edu/~jburkardt/m_src/jacobi_eigenvalue/jacobi_eigenvalue.html MATLAB], [http://people.sc.fsu.edu/~jburkardt/py_src/jacobi_eigenvalue/jacobi_eigenvalue.html Python].
Данная библиотека распространяется по лицензии [http://people.sc.fsu.edu/~jburkardt/txt/gnu_lgpl.txt GNU LESSER GENERAL PUBLIC LICENSE].

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

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

<references \>

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

2016-10-15T15:34:00Z

Игорь: /* Информационный граф */

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

Авторы описания: [[Участник: Galkina|А.С.Галкина]], [[Участник: Игорь|И.А.Плахов]]

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

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

Метод Якоби — итерационный алгоритм для вычисления собственных значений и собственных векторов вещественной симметричной матрицы. Карл Густав Якоб Якоби, в честь которого назван этот метод, предложил его в 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>Golub, G.H. (2000). «Eigenvalue computation in the 20th century». Journal of Computational and Applied Mathematics 123 (1-2): 35–65. DOI:[https://dx.doi.org/10.1016%2FS0377-0427%2800%2900413-1 10.1016/S0377-0427(00)00413-1].</ref>.
Суть алгоритма заключается в том, чтобы по заданной симметрической матрице <math>A = A_0</math> построить последовательность ортогонально подобных матриц <math>A_1,A_2,\dotsc,A_m</math>, сходящуюся к диагональной матрице, на диагонали которой стоят собственные значения. Для построения этой последовательности применяется специально подобранная матрица поворота <math>J_i</math>, такая что норма наддиагональной части <math>of\!f(A)=\sqrt{\sum\limits_{1 \le j < k \le n} a_{jk}^2}</math> уменьшается при каждом повороте матрицы <math>A</math>. Вычисление останавливается, когда угол поворота становится близок к нулю, либо когда максимальный внедиагональный элемент становится меньше заранее выбранного порогового значения.

=== Математическое описание алгоритма ===
Исходные данные: симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>).

Матрица <math>A_{i+1}</math> получается из <math>A_i</math> по формуле <math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math>J_i</math> — ортогональная матрица, называемая ''вращением Якоби''.
При подходящем выборе <math>J_i</math> матрица <math>A_m</math> для больших m будет близка к диагональной матрице <math>\Lambda</math>.

Матрица <math>J_i</math> выбирается так, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}</math><ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>.



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

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

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>. Тогда матрица <math>A_{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)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Можно выбрать <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>. Отсюда получим равенство

: <math> \frac{a_{jj}^{(i)} - a_{kk}^{(i)}}{2 a_{jk}^{(i)}} = \frac{c^2 - s^2}{2sc} = \frac{\cos 2\theta}{\sin 2\theta} = \operatorname{tg}(2\theta) \equiv \tau </math>.

Положим <math>t = \frac{s}{c} = \operatorname{ctg}(\theta)</math> и заметим, что <math>t^2 - 2t\tau + 1 = 0</math>. Решая квадратное уравнение, находим <math>t = \frac{\operatorname{sign}(\tau)}{|\tau| + \sqrt{1+\tau^2}}, c = \frac{1}{\sqrt{1+t^2}}, s = tc</math>.

Выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

=== Вычислительное ядро алгоритма ===
Рассматривая отдельную итерацию, можно считать, что вычислительное ядро составляют множественные вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>   в процессе применения матрицы поворота <math>J_i</math> к матрице <math>A</math>:
: <math>\begin{align}
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k,
\end{align}</math>

каждое из которых повторяется по <math> (n-2) </math> раза, а также вычисление элементов <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>

=== Макроструктура алгоритма ===
Основную часть метода составляет процедура применения вращения к матрице <math>A</math>, которая в дальнейшем будет обозначена как '''''Jakobi-Rotation<math>(A,j,k)</math>'''''.

Эту процедуру, в свою очередь, можно разделить на две логические части:
# Определение угла поворота <math>\theta</math> по элементам матрицы <math>a_{jj}</math>, <math>a_{kk}</math> и <math>a_{jk}</math>;
# Поворот матрицы <math>A</math> (изменяются лишь строки и столбцы, соответствующие индексам <math>j</math> и  <math>k</math>).

=== Схема реализации последовательного алгоритма ===
Алгоритм можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246-248)</ref>:

repeat
выбрать пару индексов j,k
обратиться к процедуре '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
пока <math>A</math> не достаточно близка к диагональной матрице

Существует несколько способов выбора пары <math>j,k</math>. Наиболее простой и быстрый способ — построчный циклический обход внедиагональных элементов матрицы <math>A</math>:

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

Процедура '''''Jakobi-Rotation<math>(A,j,k)</math>''''' — это следующий алгоритм:
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\,t \\
A &= R^T(j,k,\theta)\cdot A\cdot R(j,k,\theta), \qquad J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}</math>
end if

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

Для осуществления одной итерации метода Якоби для матрицы размера <math>(n\times n)</math> требуется выполнить:

Для вычислительного ядра —
* <math> 4n+4 </math> умножений,
* <math> 2n+2 </math> сложений.

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

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

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

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

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

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

'''Первой''' группе вершин (J) соответствует вычисление значений c и s.

'''Второй''' группе вершин (А) соответствует вычисление значений элементов <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>.

'''Третьей''' группе вершин (B) соответствует вычисление значений элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>.



[[File:Информационный_граф_метода_якоби.png|left|frame|Рисунок 1. Граф одной итерации алгоритма без отображения входных и выходных данных.]]

[[File:ГрафJ.png|left|frame|Рисунок 2. Внутренний граф вершин J с входными параметрами <math>x = a_{jj}^{(i)}, y = a_{kk}^{(i)}, z = a_{jk}^{(i)}</math>.]]

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

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

После этого выполняется ярус, отвечающий за применение поворота к матрице <math>A</math> с параллельным выполнением <math>2(n-2)</math> операций вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math> , а также 2 операций вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>. Наибольшее количество операций содержится в вычислении последних двух элементов (по 6 умножений и 3 сложения).

Суммарное количество итераций зависит от входных данных и заданного значения погрешности. Один "цикл" (полный проход по внедиагональным элементам) осуществляется за <math>N = \frac{n(n-1)}{2}</math> итераций. Асимптотически метод сходится квадратично<ref>J. H. Wilkinson. The Algebraic Eigenvalue Problem. Oxford University Press, UK, 1965. (стр 270)</ref>. Как правило, для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 248)</ref>.

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

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

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

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

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

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

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

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

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

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

Дуги информационного графа, исходящие из вершин, соответствующих вычислениям значений <math>c</math> и <math>s</math>, образуют пучки рассылок линейной мощности.

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

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

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

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

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

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

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

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

Существует библиотека JACOBI_EIGENVALUE, реализующая последовательный вариант метода Якоби на языках программирования [http://people.sc.fsu.edu/~jburkardt/c_src/jacobi_eigenvalue/jacobi_eigenvalue.html С], [http://people.sc.fsu.edu/~jburkardt/cpp_src/jacobi_eigenvalue/jacobi_eigenvalue.html С++], [http://people.sc.fsu.edu/~jburkardt/f77_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN77], [http://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN90], [http://people.sc.fsu.edu/~jburkardt/m_src/jacobi_eigenvalue/jacobi_eigenvalue.html MATLAB], [http://people.sc.fsu.edu/~jburkardt/py_src/jacobi_eigenvalue/jacobi_eigenvalue.html Python].
Данная библиотека распространяется по лицензии [http://people.sc.fsu.edu/~jburkardt/txt/gnu_lgpl.txt GNU LESSER GENERAL PUBLIC LICENSE].

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

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

<references \>

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

2016-10-15T12:41:19Z

Игорь: /* Ресурс параллелизма алгоритма */

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

Авторы описания: [[Участник: Galkina|А.С.Галкина]], [[Участник: Игорь|И.А.Плахов]]

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

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

Метод Якоби — итерационный алгоритм для вычисления собственных значений и собственных векторов вещественной симметричной матрицы. Карл Густав Якоб Якоби, в честь которого назван этот метод, предложил его в 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>Golub, G.H. (2000). «Eigenvalue computation in the 20th century». Journal of Computational and Applied Mathematics 123 (1-2): 35–65. DOI:[https://dx.doi.org/10.1016%2FS0377-0427%2800%2900413-1 10.1016/S0377-0427(00)00413-1].</ref>.
Суть алгоритма заключается в том, чтобы по заданной симметрической матрице <math>A = A_0</math> построить последовательность ортогонально подобных матриц <math>A_1,A_2,\dotsc,A_m</math>, сходящуюся к диагональной матрице, на диагонали которой стоят собственные значения. Для построения этой последовательности применяется специально подобранная матрица поворота <math>J_i</math>, такая что норма наддиагональной части <math>of\!f(A)=\sqrt{\sum\limits_{1 \le j < k \le n} a_{jk}^2}</math> уменьшается при каждом повороте матрицы <math>A</math>. Вычисление останавливается, когда угол поворота становится близок к нулю, либо когда максимальный внедиагональный элемент становится меньше заранее выбранного порогового значения.

=== Математическое описание алгоритма ===
Исходные данные: симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>).

Матрица <math>A_{i+1}</math> получается из <math>A_i</math> по формуле <math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math>J_i</math> — ортогональная матрица, называемая ''вращением Якоби''.
При подходящем выборе <math>J_i</math> матрица <math>A_m</math> для больших m будет близка к диагональной матрице <math>\Lambda</math>.

Матрица <math>J_i</math> выбирается так, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}</math><ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>.



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

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

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>. Тогда матрица <math>A_{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)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Можно выбрать <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>. Отсюда получим равенство

: <math> \frac{a_{jj}^{(i)} - a_{kk}^{(i)}}{2 a_{jk}^{(i)}} = \frac{c^2 - s^2}{2sc} = \frac{\cos 2\theta}{\sin 2\theta} = \operatorname{tg}(2\theta) \equiv \tau </math>.

Положим <math>t = \frac{s}{c} = \operatorname{ctg}(\theta)</math> и заметим, что <math>t^2 - 2t\tau + 1 = 0</math>. Решая квадратное уравнение, находим <math>t = \frac{\operatorname{sign}(\tau)}{|\tau| + \sqrt{1+\tau^2}}, c = \frac{1}{\sqrt{1+t^2}}, s = tc</math>.

Выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

=== Вычислительное ядро алгоритма ===
Рассматривая отдельную итерацию, можно считать, что вычислительное ядро составляют множественные вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>   в процессе применения матрицы поворота <math>J_i</math> к матрице <math>A</math>:
: <math>\begin{align}
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k,
\end{align}</math>

каждое из которых повторяется по <math> (n-2) </math> раза, а также вычисление элементов <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>

=== Макроструктура алгоритма ===
Основную часть метода составляет процедура применения вращения к матрице <math>A</math>, которая в дальнейшем будет обозначена как '''''Jakobi-Rotation<math>(A,j,k)</math>'''''.

Эту процедуру, в свою очередь, можно разделить на две логические части:
# Определение угла поворота <math>\theta</math> по элементам матрицы <math>a_{jj}</math>, <math>a_{kk}</math> и <math>a_{jk}</math>;
# Поворот матрицы <math>A</math> (изменяются лишь строки и столбцы, соответствующие индексам <math>j</math> и  <math>k</math>).

=== Схема реализации последовательного алгоритма ===
Алгоритм можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246-248)</ref>:

repeat
выбрать пару индексов j,k
обратиться к процедуре '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
пока <math>A</math> не достаточно близка к диагональной матрице

Существует несколько способов выбора пары <math>j,k</math>. Наиболее простой и быстрый способ — построчный циклический обход внедиагональных элементов матрицы <math>A</math>:

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

Процедура '''''Jakobi-Rotation<math>(A,j,k)</math>''''' — это следующий алгоритм:
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\,t \\
A &= R^T(j,k,\theta)\cdot A\cdot R(j,k,\theta), \qquad J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}</math>
end if

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

Для осуществления одной итерации метода Якоби для матрицы размера <math>(n\times n)</math> требуется выполнить:

Для вычислительного ядра —
* <math> 4n+4 </math> умножений,
* <math> 2n+2 </math> сложений.

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

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

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

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

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

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

'''Первой''' группе вершин (J) соответствует вычисление значений c и s.

'''Второй''' группе вершин (А) соответствует вычисление значений элементов <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>.

'''Третьей''' группе вершин (B) соответствует вычисление значений элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>.

<center>
<div class="thumb">
<div class="thumbinner" style="width:{{#expr: 3 * (400 + 35) + 4 * (3 - 1) + 8}}px">
<gallery widths=400px heights=400px>
File:Информационный_граф_метода_якоби.png|Рисунок 1. Граф одной итерации алгоритма без отображения входных и выходных данных.
File:ГрафJ.png|Рисунок 2. Внутренний граф вершин J с входными параметрами <math>x = a_{jj}^{(i)}, y = a_{kk}^{(i)}, z = a_{jk}^{(i)}</math>.
</gallery>
</div>
</div>
</center>

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

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

После этого выполняется ярус, отвечающий за применение поворота к матрице <math>A</math> с параллельным выполнением <math>2(n-2)</math> операций вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math> , а также 2 операций вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>. Наибольшее количество операций содержится в вычислении последних двух элементов (по 6 умножений и 3 сложения).

Суммарное количество итераций зависит от входных данных и заданного значения погрешности. Один "цикл" (полный проход по внедиагональным элементам) осуществляется за <math>N = \frac{n(n-1)}{2}</math> итераций. Асимптотически метод сходится квадратично<ref>J. H. Wilkinson. The Algebraic Eigenvalue Problem. Oxford University Press, UK, 1965. (стр 270)</ref>. Как правило, для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 248)</ref>.

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

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

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

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

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

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

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

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

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

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

Дуги информационного графа, исходящие из вершин, соответствующих вычислениям значений <math>c</math> и <math>s</math>, образуют пучки рассылок линейной мощности.

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

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

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

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

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

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

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

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

Существует библиотека JACOBI_EIGENVALUE, реализующая последовательный вариант метода Якоби на языках программирования [http://people.sc.fsu.edu/~jburkardt/c_src/jacobi_eigenvalue/jacobi_eigenvalue.html С], [http://people.sc.fsu.edu/~jburkardt/cpp_src/jacobi_eigenvalue/jacobi_eigenvalue.html С++], [http://people.sc.fsu.edu/~jburkardt/f77_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN77], [http://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN90], [http://people.sc.fsu.edu/~jburkardt/m_src/jacobi_eigenvalue/jacobi_eigenvalue.html MATLAB], [http://people.sc.fsu.edu/~jburkardt/py_src/jacobi_eigenvalue/jacobi_eigenvalue.html Python].
Данная библиотека распространяется по лицензии [http://people.sc.fsu.edu/~jburkardt/txt/gnu_lgpl.txt GNU LESSER GENERAL PUBLIC LICENSE].

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

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

<references \>

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

2016-10-15T10:21:02Z

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

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

Авторы описания: [[Участник: Galkina|А.С.Галкина]], [[Участник: Игорь|И.А.Плахов]]

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

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

Метод Якоби — итерационный алгоритм для вычисления собственных значений и собственных векторов вещественной симметричной матрицы. Карл Густав Якоб Якоби, в честь которого назван этот метод, предложил его в 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>Golub, G.H. (2000). «Eigenvalue computation in the 20th century». Journal of Computational and Applied Mathematics 123 (1-2): 35–65. DOI:[https://dx.doi.org/10.1016%2FS0377-0427%2800%2900413-1 10.1016/S0377-0427(00)00413-1].</ref>.
Суть алгоритма заключается в том, чтобы по заданной симметрической матрице <math>A = A_0</math> построить последовательность ортогонально подобных матриц <math>A_1,A_2,\dotsc,A_m</math>, сходящуюся к диагональной матрице, на диагонали которой стоят собственные значения. Для построения этой последовательности применяется специально подобранная матрица поворота <math>J_i</math>, такая что норма наддиагональной части <math>of\!f(A)=\sqrt{\sum\limits_{1 \le j < k \le n} a_{jk}^2}</math> уменьшается при каждом повороте матрицы <math>A</math>. Вычисление останавливается, когда угол поворота становится близок к нулю, либо когда максимальный внедиагональный элемент становится меньше заранее выбранного порогового значения.

=== Математическое описание алгоритма ===
Исходные данные: симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>).

Матрица <math>A_{i+1}</math> получается из <math>A_i</math> по формуле <math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math>J_i</math> — ортогональная матрица, называемая ''вращением Якоби''.
При подходящем выборе <math>J_i</math> матрица <math>A_m</math> для больших m будет близка к диагональной матрице <math>\Lambda</math>.

Матрица <math>J_i</math> выбирается так, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}</math><ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>.



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

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

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>. Тогда матрица <math>A_{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)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Можно выбрать <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>. Отсюда получим равенство

: <math> \frac{a_{jj}^{(i)} - a_{kk}^{(i)}}{2 a_{jk}^{(i)}} = \frac{c^2 - s^2}{2sc} = \frac{\cos 2\theta}{\sin 2\theta} = \operatorname{tg}(2\theta) \equiv \tau </math>.

Положим <math>t = \frac{s}{c} = \operatorname{ctg}(\theta)</math> и заметим, что <math>t^2 - 2t\tau + 1 = 0</math>. Решая квадратное уравнение, находим <math>t = \frac{\operatorname{sign}(\tau)}{|\tau| + \sqrt{1+\tau^2}}, c = \frac{1}{\sqrt{1+t^2}}, s = tc</math>.

Выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

=== Вычислительное ядро алгоритма ===
Рассматривая отдельную итерацию, можно считать, что вычислительное ядро составляют множественные вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>   в процессе применения матрицы поворота <math>J_i</math> к матрице <math>A</math>:
: <math>\begin{align}
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k,
\end{align}</math>

каждое из которых повторяется по <math> (n-2) </math> раза, а также вычисление элементов <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>

=== Макроструктура алгоритма ===
Основную часть метода составляет процедура применения вращения к матрице <math>A</math>, которая в дальнейшем будет обозначена как '''''Jakobi-Rotation<math>(A,j,k)</math>'''''.

Эту процедуру, в свою очередь, можно разделить на две логические части:
# Определение угла поворота <math>\theta</math> по элементам матрицы <math>a_{jj}</math>, <math>a_{kk}</math> и <math>a_{jk}</math>;
# Поворот матрицы <math>A</math> (изменяются лишь строки и столбцы, соответствующие индексам <math>j</math> и  <math>k</math>).

=== Схема реализации последовательного алгоритма ===
Алгоритм можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246-248)</ref>:

repeat
выбрать пару индексов j,k
обратиться к процедуре '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
пока <math>A</math> не достаточно близка к диагональной матрице

Существует несколько способов выбора пары <math>j,k</math>. Наиболее простой и быстрый способ — построчный циклический обход внедиагональных элементов матрицы <math>A</math>:

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

Процедура '''''Jakobi-Rotation<math>(A,j,k)</math>''''' — это следующий алгоритм:
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\,t \\
A &= R^T(j,k,\theta)\cdot A\cdot R(j,k,\theta), \qquad J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}</math>
end if

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

Для осуществления одной итерации метода Якоби для матрицы размера <math>(n\times n)</math> требуется выполнить:

Для вычислительного ядра —
* <math> 4n+4 </math> умножений,
* <math> 2n+2 </math> сложений.

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

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

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

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

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

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

'''Первой''' группе вершин (J) соответствует вычисление значений c и s.

'''Второй''' группе вершин (А) соответствует вычисление значений элементов <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>.

'''Третьей''' группе вершин (B) соответствует вычисление значений элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>.

<center>
<div class="thumb">
<div class="thumbinner" style="width:{{#expr: 3 * (400 + 35) + 4 * (3 - 1) + 8}}px">
<gallery widths=400px heights=400px>
File:Информационный_граф_метода_якоби.png|Рисунок 1. Граф одной итерации алгоритма без отображения входных и выходных данных.
File:ГрафJ.png|Рисунок 2. Внутренний граф вершин J с входными параметрами <math>x = a_{jj}^{(i)}, y = a_{kk}^{(i)}, z = a_{jk}^{(i)}</math>.
</gallery>
</div>
</div>
</center>

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

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

После этого выполняется ярус, отвечающий за применение поворота к матрице <math>A</math> с параллельным выполнением <math>2(n-2)</math> операций вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math> , а также 2 операций вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>. Наибольшее количество операций содержится в вычислении последних двух элементов (по 6 умножений и 3 сложения).

Суммарное количество итераций зависит от входных данных и заданного значения погрешности. Один "цикл" (полный проход по внедиагональным элементам) осуществляется за <math>N = \frac{n(n-1)}{2}</math> итераций. Асимптотически метод сходится квадратично<ref>J. H. Wilkinson. The Algebraic Eigenvalue Problem. Oxford University Press, UK, 1965. (стр 270)</ref>. Нередко для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 248)</ref>.

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

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

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

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

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

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

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

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

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

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

Дуги информационного графа, исходящие из вершин, соответствующих вычислениям значений <math>c</math> и <math>s</math>, образуют пучки рассылок линейной мощности.

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

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

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

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

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

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

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

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

Существует библиотека JACOBI_EIGENVALUE, реализующая последовательный вариант метода Якоби на языках программирования [http://people.sc.fsu.edu/~jburkardt/c_src/jacobi_eigenvalue/jacobi_eigenvalue.html С], [http://people.sc.fsu.edu/~jburkardt/cpp_src/jacobi_eigenvalue/jacobi_eigenvalue.html С++], [http://people.sc.fsu.edu/~jburkardt/f77_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN77], [http://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN90], [http://people.sc.fsu.edu/~jburkardt/m_src/jacobi_eigenvalue/jacobi_eigenvalue.html MATLAB], [http://people.sc.fsu.edu/~jburkardt/py_src/jacobi_eigenvalue/jacobi_eigenvalue.html Python].
Данная библиотека распространяется по лицензии [http://people.sc.fsu.edu/~jburkardt/txt/gnu_lgpl.txt GNU LESSER GENERAL PUBLIC LICENSE].

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

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

<references \>

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

2016-10-15T09:53:48Z

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

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

Авторы описания: [[Участник: Galkina|А.С.Галкина]], [[Участник: Игорь|И.А.Плахов]]

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

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

Метод Якоби — итерационный алгоритм для вычисления собственных значений и собственных векторов вещественной симметричной матрицы. Карл Густав Якоб Якоби, в честь которого назван этот метод, предложил его в 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>Golub, G.H. (2000). «Eigenvalue computation in the 20th century». Journal of Computational and Applied Mathematics 123 (1-2): 35–65. DOI:[https://dx.doi.org/10.1016%2FS0377-0427%2800%2900413-1 10.1016/S0377-0427(00)00413-1].</ref>.
Суть алгоритма заключается в том, чтобы по заданной симметрической матрице <math>A = A_0</math> построить последовательность ортогонально подобных матриц <math>A_1,A_2,\dotsc,A_m</math>, сходящуюся к диагональной матрице, на диагонали которой стоят собственные значения. Для построения этой последовательности применяется специально подобранная матрица поворота <math>J_i</math>, такая что норма наддиагональной части <math>of\!f(A)=\sqrt{\sum\limits_{1 \le j < k \le n} a_{jk}^2}</math> уменьшается при каждом повороте матрицы <math>A</math>. Вычисление останавливается, когда угол поворота становится близок к нулю, либо когда максимальный внедиагональный элемент становится меньше заранее выбранного порогового значения.

=== Математическое описание алгоритма ===
Исходные данные: симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>).

Матрица <math>A_{i+1}</math> получается из <math>A_i</math> по формуле <math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math>J_i</math> — ортогональная матрица, называемая ''вращением Якоби''.
При подходящем выборе <math>J_i</math> матрица <math>A_m</math> для больших m будет близка к диагональной матрице <math>\Lambda</math>.

Матрица <math>J_i</math> выбирается так, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}</math><ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>.



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

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

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>. Тогда матрица <math>A_{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)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Можно выбрать <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>. Отсюда получим равенство

: <math> \frac{a_{jj}^{(i)} - a_{kk}^{(i)}}{2 a_{jk}^{(i)}} = \frac{c^2 - s^2}{2sc} = \frac{\cos 2\theta}{\sin 2\theta} = \operatorname{tg}(2\theta) \equiv \tau </math>.

Положим <math>t = \frac{s}{c} = \operatorname{ctg}(\theta)</math> и заметим, что <math>t^2 - 2t\tau + 1 = 0</math>. Решая квадратное уравнение, находим <math>t = \frac{\operatorname{sign}(\tau)}{|\tau| + \sqrt{1+\tau^2}}, c = \frac{1}{\sqrt{1+t^2}}, s = tc</math>.

Выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

=== Вычислительное ядро алгоритма ===
Рассматривая отдельную итерацию, можно считать, что вычислительное ядро составляют множественные вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>   в процессе применения матрицы поворота <math>J_i</math> к матрице <math>A</math>:
: <math>\begin{align}
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k,
\end{align}</math>

каждое из которых повторяется по <math> (n-2) </math> раза, а также вычисление элементов <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>

=== Макроструктура алгоритма ===
Основную часть метода составляет процедура применения вращения к матрице <math>A</math>, которая в дальнейшем будет обозначена как '''''Jakobi-Rotation<math>(A,j,k)</math>'''''.

Эту процедуру, в свою очередь, можно разделить на две логические части:
# Определение угла поворота <math>\theta</math> по элементам матрицы <math>a_{jj}</math>, <math>a_{kk}</math> и <math>a_{jk}</math>;
# Поворот матрицы <math>A</math> (изменяются лишь строки и столбцы, соответствующие индексам <math>j</math> и  <math>k</math>).

=== Схема реализации последовательного алгоритма ===
Алгоритм можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246-248)</ref>:

repeat
выбрать пару индексов j,k
обратиться к процедуре '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
пока <math>A</math> не достаточно близка к диагональной матрице

Существует несколько способов выбора пары <math>j,k</math>. Наиболее простой и быстрый способ — построчный циклический обход внедиагональных элементов матрицы <math>A</math>:

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

Процедура '''''Jakobi-Rotation<math>(A,j,k)</math>''''' — это следующий алгоритм:
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\,t \\
A &= R^T(j,k,\theta)\cdot A\cdot R(j,k,\theta), \qquad J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}</math>
end if

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

Для осуществления одной итерации метода Якоби для матрицы размера <math>(n\times n)</math> требуется выполнить:

Для вычислительного ядра —
* <math> 4n+4 </math> умножений,
* <math> 2n+2 </math> сложений.

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

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

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

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

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

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

'''Первой''' группе вершин (J) соответствует вычисление значений c и s.

'''Второй''' группе вершин (А) соответствует вычисление значений элементов <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>.

'''Третьей''' группе вершин (B) соответствует вычисление значений элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>.

<center>
<div class="thumb">
<div class="thumbinner" style="width:{{#expr: 3 * (400 + 35) + 4 * (3 - 1) + 8}}px">
<gallery widths=400px heights=400px>
File:Информационный_граф_метода_якоби.png|Рисунок 1. Граф одной итерации алгоритма без отображения входных и выходных данных.
File:ГрафJ.png|Рисунок 2. Внутренний граф вершин J с входными параметрами <math>x = a_{jj}^{(i)}, y = a_{kk}^{(i)}, z = a_{jk}^{(i)}</math>.
</gallery>
</div>
</div>
</center>

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

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

После этого выполняется ярус, отвечающий за применение поворота к матрице <math>A</math> с параллельным выполнением <math>2(n-2)</math> операций вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math> , а также 2 операций вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>. Наибольшее количество операций содержится в вычислении последних двух элементов (по 6 умножений и 3 сложения).

Суммарное количество итераций зависит от входных данных и заданного значения погрешности. Один "цикл" (полный проход по внедиагональным элементам) осуществляется за <math>N = \frac{n(n-1)}{2}</math> итераций. Асимптотически метод сходится квадратично<ref>J. H. Wilkinson. The Algebraic Eigenvalue Problem. Oxford University Press, UK, 1965. (стр 270)</ref>. Нередко для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 248)</ref>.

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

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

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

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

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

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

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

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

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

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

Дуги информационного графа, исходящие из вершин, соответствующих вычислениям значений <math>c</math> и <math>s</math>, образуют пучки рассылок линейной мощности.

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

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

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

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

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

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

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

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

Существует библиотека JACOBI_EIGENVALUE, реализованная на языках программирования [http://people.sc.fsu.edu/~jburkardt/c_src/jacobi_eigenvalue/jacobi_eigenvalue.html С], [http://people.sc.fsu.edu/~jburkardt/cpp_src/jacobi_eigenvalue/jacobi_eigenvalue.html С++], [http://people.sc.fsu.edu/~jburkardt/f77_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN77], [http://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN90], [http://people.sc.fsu.edu/~jburkardt/m_src/jacobi_eigenvalue/jacobi_eigenvalue.html MATLAB], [http://people.sc.fsu.edu/~jburkardt/py_src/jacobi_eigenvalue/jacobi_eigenvalue.html Python],

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

<references \>

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

2016-10-14T21:08:37Z

Игорь:

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

Авторы описания: [[Участник: Galkina|А.С.Галкина]], [[Участник: Игорь|И.А.Плахов]]

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

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

Метод Якоби — итерационный алгоритм для вычисления собственных значений и собственных векторов вещественной симметричной матрицы. Карл Густав Якоб Якоби, в честь которого назван этот метод, предложил его в 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>Golub, G.H. (2000). «Eigenvalue computation in the 20th century». Journal of Computational and Applied Mathematics 123 (1-2): 35–65. DOI:[https://dx.doi.org/10.1016%2FS0377-0427%2800%2900413-1 10.1016/S0377-0427(00)00413-1].</ref>.
Суть алгоритма заключается в том, чтобы по заданной симметрической матрице <math>A = A_0</math> построить последовательность ортогонально подобных матриц <math>A_1,A_2,\dotsc,A_m</math>, сходящуюся к диагональной матрице, на диагонали которой стоят собственные значения. Для построения этой последовательности применяется специально подобранная матрица поворота <math>J_i</math>, такая что норма наддиагональной части <math>of\!f(A)=\sqrt{\sum\limits_{1 \le j < k \le n} a_{jk}^2}</math> уменьшается при каждом повороте матрицы <math>A</math>. Вычисление останавливается, когда угол поворота становится близок к нулю, либо когда максимальный внедиагональный элемент становится меньше заранее выбранного порогового значения.

=== Математическое описание алгоритма ===
Исходные данные: симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>).

Матрица <math>A_{i+1}</math> получается из <math>A_i</math> по формуле <math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math>J_i</math> — ортогональная матрица, называемая ''вращением Якоби''.
При подходящем выборе <math>J_i</math> матрица <math>A_m</math> для больших m будет близка к диагональной матрице <math>\Lambda</math>.

Матрица <math>J_i</math> выбирается так, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}</math><ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>.



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

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

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>. Тогда матрица <math>A_{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)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Можно выбрать <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>. Отсюда получим равенство

: <math> \frac{a_{jj}^{(i)} - a_{kk}^{(i)}}{2 a_{jk}^{(i)}} = \frac{c^2 - s^2}{2sc} = \frac{\cos 2\theta}{\sin 2\theta} = \operatorname{tg}(2\theta) \equiv \tau </math>.

Положим <math>t = \frac{s}{c} = \operatorname{ctg}(\theta)</math> и заметим, что <math>t^2 - 2t\tau + 1 = 0</math>. Решая квадратное уравнение, находим <math>t = \frac{\operatorname{sign}(\tau)}{|\tau| + \sqrt{1+\tau^2}}, c = \frac{1}{\sqrt{1+t^2}}, s = tc</math>.

Выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро составляют множественные вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>   в процессе применения матрицы поворота <math>J_i</math> к матрице <math>A</math>:
: <math>\begin{align}
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k,
\end{align}</math>

каждое из которых повторяется по <math> (n-2) </math> раза, а также вычисление элементов <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>

=== Макроструктура алгоритма ===
Основную часть метода составляет процедура применения вращения к матрице <math>A</math>, которая в дальнейшем будет обозначена как '''''Jakobi-Rotation<math>(A,j,k)</math>'''''.

Эту процедуру, в свою очередь, можно разделить на две логические части:
# Определение угла поворота <math>\theta</math> по элементам матрицы <math>a_{jj}</math>, <math>a_{kk}</math> и <math>a_{jk}</math>;
# Поворот матрицы <math>A</math> (изменяются лишь строки и столбцы, соответствующие индексам <math>j</math> и  <math>k</math>).

=== Схема реализации последовательного алгоритма ===
Алгоритм можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246-248)</ref>:

repeat
выбрать пару индексов j,k
обратиться к процедуре '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
пока <math>A</math> не достаточно близка к диагональной матрице

Существует несколько способов выбора пары <math>j,k</math>. Наиболее простой и быстрый способ — построчный циклический обход внедиагональных элементов матрицы <math>A</math>:

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

Процедура '''''Jakobi-Rotation<math>(A,j,k)</math>''''' — это следующий алгоритм:
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\,t \\
A &= R^T(j,k,\theta)\cdot A\cdot R(j,k,\theta), \qquad J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}</math>
end if

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

Для осуществления одной итерации метода Якоби для матрицы размера <math>(n\times n)</math> требуется выполнить:

Для вычислительного ядра —
* <math> 4n+4 </math> умножений,
* <math> 2n+2 </math> сложений.

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

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

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

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

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

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

'''Первой''' группе вершин (J) соответствует вычисление значений c и s.

'''Второй''' группе вершин (А) соответствует вычисление значений элементов <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>.

'''Третьей''' группе вершин (B) соответствует вычисление значений элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>.

<center>
<div class="thumb">
<div class="thumbinner" style="width:{{#expr: 3 * (400 + 35) + 4 * (3 - 1) + 8}}px">
<gallery widths=400px heights=400px>
File:Информационный_граф_метода_якоби.png|Рисунок 1. Граф одной итерации алгоритма без отображения входных и выходных данных.
File:ГрафJ.png|Рисунок 2. Внутренний граф вершин J с входными параметрами <math>x = a_{jj}^{(i)}, y = a_{kk}^{(i)}, z = a_{jk}^{(i)}</math>.
</gallery>
</div>
</div>
</center>

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

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

После этого выполняется ярус, отвечающий за применение поворота к матрице <math>A</math> с параллельным выполнением <math>2(n-2)</math> операций вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math> , а также 2 операций вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>. Наибольшее количество операций содержится в вычислении последних двух элементов (по 6 умножений и 3 сложения).

Суммарное количество итераций зависит от входных данных и заданного значения погрешности. Один "цикл" (полный проход по внедиагональным элементам) осуществляется за <math>N = \frac{n(n-1)}{2}</math> итераций. Асимптотически метод сходится квадратично<ref>J. H. Wilkinson. The Algebraic Eigenvalue Problem. Oxford University Press, UK, 1965. (стр 270)</ref>. Нередко для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 248)</ref>.

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

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

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

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

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

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

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

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

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

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

Дуги информационного графа, исходящие из вершин, соответствующих вычислениям значений <math>c</math> и <math>s</math>, образуют пучки рассылок линейной мощности.

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

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

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

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

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

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

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

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

Существует библиотека JACOBI_EIGENVALUE, реализованная на языках программирования [http://people.sc.fsu.edu/~jburkardt/c_src/jacobi_eigenvalue/jacobi_eigenvalue.html С], [http://people.sc.fsu.edu/~jburkardt/cpp_src/jacobi_eigenvalue/jacobi_eigenvalue.html С++], [http://people.sc.fsu.edu/~jburkardt/f77_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN77], [http://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN90], [http://people.sc.fsu.edu/~jburkardt/m_src/jacobi_eigenvalue/jacobi_eigenvalue.html MATLAB], [http://people.sc.fsu.edu/~jburkardt/py_src/jacobi_eigenvalue/jacobi_eigenvalue.html Python],

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

<references \>

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

2016-10-14T15:27:46Z

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

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

Авторы описания: [[Участник: Galkina|А.С.Галкина]], [[Участник: Игорь|И.А.Плахов]]

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

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

Метод Якоби — итерационный алгоритм для вычисления собственных значений и собственных векторов вещественной симметричной матрицы. Карл Густав Якоб Якоби, в честь которого назван этот метод, предложил его в 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>Golub, G.H. (2000). «Eigenvalue computation in the 20th century». Journal of Computational and Applied Mathematics 123 (1-2): 35–65. DOI:[https://dx.doi.org/10.1016%2FS0377-0427%2800%2900413-1 10.1016/S0377-0427(00)00413-1].</ref>.
Суть алгоритма заключается в том, чтобы по заданной симметрической матрице <math>A = A_0</math> построить последовательность ортогонально подобных матриц <math>A_1,A_2,\dotsc,A_m</math>, сходящуюся к диагональной матрице, на диагонали которой стоят собственные значения. Для построения этой последовательности применяется специально подобранная матрица поворота <math>J_i</math>, такая что норма наддиагональной части <math>of\!f(A)=\sqrt{\sum\limits_{1 \le j < k \le n} a_{jk}^2}</math> уменьшается при каждом повороте матрицы <math>A</math>. Вычисление останавливается, когда угол поворота становится близок к нулю, либо когда максимальный внедиагональный элемент становится меньше заранее выбранного порогового значения.

=== Математическое описание алгоритма ===
Исходные данные: симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>).

Матрица <math>A_{i+1}</math> получается из <math>A_i</math> по формуле <math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math>J_i</math> — ортогональная матрица, называемая ''вращением Якоби''.
При подходящем выборе <math>J_i</math> матрица <math>A_m</math> для больших m будет близка к диагональной матрице <math>\Lambda</math>.

Матрица <math>J_i</math> выбирается так, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}</math><ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>.



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

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

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>. Тогда матрица <math>A_{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)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Можно выбрать <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>. Отсюда получим равенство

: <math> \frac{a_{jj}^{(i)} - a_{kk}^{(i)}}{2 a_{jk}^{(i)}} = \frac{c^2 - s^2}{2sc} = \frac{\cos 2\theta}{\sin 2\theta} = \operatorname{tg}(2\theta) \equiv \tau </math>.

Положим <math>t = \frac{s}{c} = \operatorname{ctg}(\theta)</math> и заметим, что <math>t^2 - 2t\tau + 1 = 0</math>. Решая квадратное уравнение, находим <math>t = \frac{\operatorname{sign}(\tau)}{|\tau| + \sqrt{1+\tau^2}}, c = \frac{1}{\sqrt{1+t^2}}, s = tc</math>.

Выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро составляют множественные вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>   в процессе применения матрицы поворота <math>J_i</math> к матрице <math>A</math>:
: <math>\begin{align}
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k,
\end{align}</math>

каждое из которых повторяется по <math> (n-2) </math> раза, а также вычисление элементов <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>

=== Макроструктура алгоритма ===
Основную часть метода составляет процедура применения вращения к матрице <math>A</math>, которая в дальнейшем будет обозначена как '''''Jakobi-Rotation<math>(A,j,k)</math>'''''.

Эту процедуру, в свою очередь, можно разделить на две логические части:
# Определение угла поворота <math>\theta</math> по элементам матрицы <math>a_{jj}</math>, <math>a_{kk}</math> и <math>a_{jk}</math>;
# Поворот матрицы <math>A</math> (изменяются лишь строки и столбцы, соответствующие индексам <math>j</math> и  <math>k</math>).

=== Схема реализации последовательного алгоритма ===
Алгоритм можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246-248)</ref>:

repeat
выбрать пару индексов j,k
обратиться к процедуре '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
пока <math>A</math> не достаточно близка к диагональной матрице

Существует несколько способов выбора пары <math>j,k</math>. Наиболее простой и быстрый способ — построчный циклический обход внедиагональных элементов матрицы <math>A</math>:

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

Процедура '''''Jakobi-Rotation<math>(A,j,k)</math>''''' — это следующий алгоритм:
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\,t \\
A &= R^T(j,k,\theta)\cdot A\cdot R(j,k,\theta), \qquad J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}</math>
end if

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

Для осуществления одной итерации метода Якоби для матрицы размера <math>(n\times n)</math> требуется выполнить:

Для вычислительного ядра —
* <math> 4n+4 </math> умножений,
* <math> 2n+2 </math> сложений.

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

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

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

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

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

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

'''Первой''' группе вершин (J) соответствует вычисление значений c и s.

'''Второй''' группе вершин (А) соответствует вычисление значений элементов <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>.

'''Третьей''' группе вершин (B) соответствует вычисление значений элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>.

<center>
<div class="thumb">
<div class="thumbinner" style="width:{{#expr: 3 * (400 + 35) + 4 * (3 - 1) + 8}}px">
<gallery widths=400px heights=400px>
File:Информационный_граф_метода_якоби.png|Рисунок 1. Граф одной итерации алгоритма без отображения входных и выходных данных.
File:ГрафJ.png|Рисунок 2. Внутренний граф вершин J с входными параметрами <math>x = a_{jj}^{(i)}, y = a_{kk}^{(i)}, z = a_{jk}^{(i)}</math>.
</gallery>
</div>
</div>
</center>

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

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

После этого выполняется ярус, отвечающий за применение поворота к матрице <math>A</math> с параллельным выполнением <math>2(n-2)</math> операций вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math> , а также 2 операций вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>. Наибольшее количество операций содержится в вычислении последних двух элементов (по 6 умножений и 3 сложения).

Суммарное количество итераций зависит от входных данных и заданного значения погрешности. Один "цикл" (полный проход по внедиагональным элементам) осуществляется за <math>N = \frac{n(n-1)}{2}</math> итераций. Асимптотически метод сходится квадратично<ref>J. H. Wilkinson. The Algebraic Eigenvalue Problem. Oxford University Press, UK, 1965. (стр 270)</ref>. Нередко для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 248)</ref>.

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

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

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

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

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

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

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

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

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

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

Дуги информационного графа, исходящие из вершин, соответствующих вычислениям значений <math>c</math> и <math>s</math>, образуют пучки рассылок линейной мощности.

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

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

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

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

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

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

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

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

Существует библиотека JACOBI_EIGENVALUE, реализованная на языках программирования [http://people.sc.fsu.edu/~jburkardt/c_src/jacobi_eigenvalue/jacobi_eigenvalue.html С], [http://people.sc.fsu.edu/~jburkardt/cpp_src/jacobi_eigenvalue/jacobi_eigenvalue.html С++], [http://people.sc.fsu.edu/~jburkardt/f77_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN77], [http://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN90], [http://people.sc.fsu.edu/~jburkardt/m_src/jacobi_eigenvalue/jacobi_eigenvalue.html MATLAB], [http://people.sc.fsu.edu/~jburkardt/py_src/jacobi_eigenvalue/jacobi_eigenvalue.html Python],

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

<references \>

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

2016-10-14T15:18:00Z

Игорь: /* Макроструктура алгоритма */

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

Авторы описания: [[Участник: Galkina|А.С.Галкина]], [[Участник: Игорь|И.А.Плахов]]

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

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

Метод Якоби — итерационный алгоритм для вычисления собственных значений и собственных векторов вещественной симметричной матрицы. Карл Густав Якоб Якоби, в честь которого назван этот метод, предложил его в 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>Golub, G.H. (2000). «Eigenvalue computation in the 20th century». Journal of Computational and Applied Mathematics 123 (1-2): 35–65. DOI:[https://dx.doi.org/10.1016%2FS0377-0427%2800%2900413-1 10.1016/S0377-0427(00)00413-1].</ref>.
Суть алгоритма заключается в том, чтобы по заданной симметрической матрице <math>A = A_0</math> построить последовательность ортогонально подобных матриц <math>A_1,A_2,\dotsc,A_m</math>, сходящуюся к диагональной матрице, на диагонали которой стоят собственные значения. Для построения этой последовательности применяется специально подобранная матрица поворота <math>J_i</math>, такая что норма наддиагональной части <math>of\!f(A)=\sqrt{\sum\limits_{1 \le j < k \le n} a_{jk}^2}</math> уменьшается при каждом повороте матрицы <math>A</math>. Вычисление останавливается, когда угол поворота становится близок к нулю, либо когда максимальный внедиагональный элемент становится меньше заранее выбранного порогового значения.

=== Математическое описание алгоритма ===
Исходные данные: симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>).

Матрица <math>A_{i+1}</math> получается из <math>A_i</math> по формуле <math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math>J_i</math> — ортогональная матрица, называемая ''вращением Якоби''.
При подходящем выборе <math>J_i</math> матрица <math>A_m</math> для больших m будет близка к диагональной матрице <math>\Lambda</math>.

Матрица <math>J_i</math> выбирается так, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}</math><ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>.



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

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

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>. Тогда матрица <math>A_{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)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Можно выбрать <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>. Отсюда получим равенство

: <math> \frac{a_{jj}^{(i)} - a_{kk}^{(i)}}{2 a_{jk}^{(i)}} = \frac{c^2 - s^2}{2sc} = \frac{\cos 2\theta}{\sin 2\theta} = \operatorname{tg}(2\theta) \equiv \tau </math>.

Положим <math>t = \frac{s}{c} = \operatorname{ctg}(\theta)</math> и заметим, что <math>t^2 - 2t\tau + 1 = 0</math>. Решая квадратное уравнение, находим <math>t = \frac{\operatorname{sign}(\tau)}{|\tau| + \sqrt{1+\tau^2}}, c = \frac{1}{\sqrt{1+t^2}}, s = tc</math>.

Выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро составляют множественные вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>   в процессе применения матрицы поворота <math>J</math> к матрице <math>A</math>:
: <math>\begin{align}
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k,
\end{align}</math>

каждое из которых повторяется по <math> (n-2) </math> раза, а также вычисление элементов <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>

=== Макроструктура алгоритма ===
Основную часть метода составляет процедура применения вращения к матрице <math>A</math>, которая в дальнейшем будет обозначена как '''''Jakobi-Rotation<math>(A,j,k)</math>'''''.

Эту процедуру, в свою очередь, можно разделить на две логические части:
# Определение угла поворота <math>\theta</math> по элементам матрицы <math>a_{jj}</math>, <math>a_{kk}</math> и <math>a_{jk}</math>;
# Поворот матрицы <math>A</math> (изменяются лишь строки и столбцы, соответствующие индексам <math>j</math> и  <math>k</math>).

=== Схема реализации последовательного алгоритма ===
Алгоритм можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246-248)</ref>:

repeat
выбрать пару индексов j,k
обратиться к процедуре '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
пока <math>A</math> не достаточно близка к диагональной матрице

Существует несколько способов выбора пары <math>j,k</math>. Наиболее простой и быстрый способ — построчный циклический обход внедиагональных элементов матрицы <math>A</math>:

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

Процедура '''''Jakobi-Rotation<math>(A,j,k)</math>''''' — это следующий алгоритм:
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\,t \\
A &= R^T(j,k,\theta)\cdot A\cdot R(j,k,\theta), \qquad J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}</math>
end if

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

Для осуществления одной итерации метода Якоби для матрицы размера <math>(n\times n)</math> требуется выполнить:

Для вычислительного ядра —
* <math> 4n+4 </math> умножений,
* <math> 2n+2 </math> сложений.

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

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

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

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

=== Информационный граф ===

Граф алгоритма состоит из трёх групп вершин.

'''Первой''' группе вершин (J) соответствует вычисление значений c и s.

'''Второй''' группе вершин (А) соответствует вычисление значений элементов <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>.

'''Третьей''' группе вершин (B) соответствует вычисление значений элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>.

<center>
<div class="thumb">
<div class="thumbinner" style="width:{{#expr: 3 * (400 + 35) + 4 * (3 - 1) + 8}}px">
<gallery widths=400px heights=400px>
File:Информационный_граф_метода_якоби.png|Рисунок 1. Граф одной итерации алгоритма без отображения входных и выходных данных.
File:ГрафJ.png|Рисунок 2. Внутренний граф вершин J с входными параметрами <math>x = a_{jj}^{(i)}, y = a_{kk}^{(i)}, z = a_{jk}^{(i)}</math>.
</gallery>
</div>
</div>
</center>

=== Ресурс параллелизма алгоритма ===

Для выполнения одной итерации требуется последовательно выполнить следующие действия:
# вычислить <math>\tau</math> (2 операции сложения, 1 операция деления)
# вычислить <math>t</math> (1 операция сравнения, 1 операция взятия модуля, 2 операции сложения, 1 операция умножения, 1 операция деления, 1 операция извлечения квадратного корня)
# вычислить <math>c</math> (1 операция сложения, 1 операция умножения, 1 операция деления, 1 операция извлечения квадратного корня) и <math>s</math> (1 операция умножения)

После этого выполняется ярус, отвечающий за применение поворота к матрице <math>A</math> с параллельным выполнением <math>2(n-2)</math> операций вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math> , а также 2 операций вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>. Наибольшее количество операций содержится в вычислении последних двух элементов (по 6 умножений и 3 сложения).

Суммарное количество итераций зависит от входных данных и заданного значения погрешности. Один "цикл" (полный проход по внедиагональным элементам) осуществляется за <math>N = \frac{n(n-1)}{2}</math> итераций. Асимптотически метод сходится квадратично<ref>J. H. Wilkinson. The Algebraic Eigenvalue Problem. Oxford University Press, UK, 1965. (стр 270)</ref>. Нередко для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 248)</ref>.

Таким образом, при классификации по высоте ЯПФ метод Якоби относится к алгоритмам со сложностью <math>O(n^2)</math> , а при классификации по ширине ЯПФ — к алгоритмам со сложностью <math>O(n)</math>.

=== Входные и выходные данные алгоритма ===

'''Входные данные''': матрица <math>A</math> (элементы <math>a_{ij}</math>).
Дополнительные ограничения:
* <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы). В разных реализациях эта экономия хранения может быть выполнена разным образом.

'''Выходные данные''': вектор собственных значений <math>\Lambda</math> (элементы <math>\lambda_{ii}</math>).

'''Объём выходных данных''': <math> n </math>.

=== Свойства алгоритма ===

Метод Якоби является самым медленным из имеющихся алгоритмов вычисления собственных значений симметричной матрицы. Тем не менее, он способен вычислять малые собственные числа и отвечающие им собственные векторы с гораздо большей точностью, чем другие методы<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244)</ref>. Кроме того, он не предполагает первоначального приведения матрицы к трехдиагональной форме.

Соотношение последовательной и параллельной сложности в случае неограниченных ресурсов для метода Якоби является линейным, вычислительная мощность алгоритма также линейна.

Метод Якоби не детерминирован, так как является итерационным алгоритмом с выходом по точности: число итераций зависит от входных данных и порогового значения.

Дуги информационного графа, исходящие из вершин, соответствующих вычислениям значений <math>c</math> и <math>s</math>, образуют пучки рассылок линейной мощности.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

Существует библиотека JACOBI_EIGENVALUE, реализованная на языках программирования [http://people.sc.fsu.edu/~jburkardt/c_src/jacobi_eigenvalue/jacobi_eigenvalue.html С], [http://people.sc.fsu.edu/~jburkardt/cpp_src/jacobi_eigenvalue/jacobi_eigenvalue.html С++], [http://people.sc.fsu.edu/~jburkardt/f77_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN77], [http://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN90], [http://people.sc.fsu.edu/~jburkardt/m_src/jacobi_eigenvalue/jacobi_eigenvalue.html MATLAB], [http://people.sc.fsu.edu/~jburkardt/py_src/jacobi_eigenvalue/jacobi_eigenvalue.html Python],

== Литература ==

<references \>

Участник:Galkina/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-14T15:17:12Z

Игорь: /* Макроструктура алгоритма */

{{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>
}}

Авторы описания: [[Участник: Galkina|А.С.Галкина]], [[Участник: Игорь|И.А.Плахов]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Метод Якоби — итерационный алгоритм для вычисления собственных значений и собственных векторов вещественной симметричной матрицы. Карл Густав Якоб Якоби, в честь которого назван этот метод, предложил его в 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>Golub, G.H. (2000). «Eigenvalue computation in the 20th century». Journal of Computational and Applied Mathematics 123 (1-2): 35–65. DOI:[https://dx.doi.org/10.1016%2FS0377-0427%2800%2900413-1 10.1016/S0377-0427(00)00413-1].</ref>.
Суть алгоритма заключается в том, чтобы по заданной симметрической матрице <math>A = A_0</math> построить последовательность ортогонально подобных матриц <math>A_1,A_2,\dotsc,A_m</math>, сходящуюся к диагональной матрице, на диагонали которой стоят собственные значения. Для построения этой последовательности применяется специально подобранная матрица поворота <math>J_i</math>, такая что норма наддиагональной части <math>of\!f(A)=\sqrt{\sum\limits_{1 \le j < k \le n} a_{jk}^2}</math> уменьшается при каждом повороте матрицы <math>A</math>. Вычисление останавливается, когда угол поворота становится близок к нулю, либо когда максимальный внедиагональный элемент становится меньше заранее выбранного порогового значения.

=== Математическое описание алгоритма ===
Исходные данные: симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>).

Матрица <math>A_{i+1}</math> получается из <math>A_i</math> по формуле <math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math>J_i</math> — ортогональная матрица, называемая ''вращением Якоби''.
При подходящем выборе <math>J_i</math> матрица <math>A_m</math> для больших m будет близка к диагональной матрице <math>\Lambda</math>.

Матрица <math>J_i</math> выбирается так, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}</math><ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>.



                                                
<math>j</math>
                       
<math>k</math>

<math>
J_i =
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & -\sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>. Тогда матрица <math>A_{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)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Можно выбрать <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>. Отсюда получим равенство

: <math> \frac{a_{jj}^{(i)} - a_{kk}^{(i)}}{2 a_{jk}^{(i)}} = \frac{c^2 - s^2}{2sc} = \frac{\cos 2\theta}{\sin 2\theta} = \operatorname{tg}(2\theta) \equiv \tau </math>.

Положим <math>t = \frac{s}{c} = \operatorname{ctg}(\theta)</math> и заметим, что <math>t^2 - 2t\tau + 1 = 0</math>. Решая квадратное уравнение, находим <math>t = \frac{\operatorname{sign}(\tau)}{|\tau| + \sqrt{1+\tau^2}}, c = \frac{1}{\sqrt{1+t^2}}, s = tc</math>.

Выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро составляют множественные вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>   в процессе применения матрицы поворота <math>J</math> к матрице <math>A</math>:
: <math>\begin{align}
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k,
\end{align}</math>

каждое из которых повторяется по <math> (n-2) </math> раза, а также вычисление элементов <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>

=== Макроструктура алгоритма ===
Основную часть метода составляет процедура применения вращения к матрице <math>A</math>, которая в дальнейшем будет обозначена как '''''Jakobi-Rotation<math>(A,j,k)</math>'''''.

Эту процедуру, в свою очередь, можно разделить на две логические части:
# Определение угла поворота <math>\theta</math> по элементам матрицы <math>a_{jj}</math>, <math>a_{kk}</math> и <math>a_{jk}</math>;
# Применение вращения к матрице <math>A</math> (изменяются лишь строки и столбцы, соответствующие индексам <math>j</math> и  <math>k</math>).

=== Схема реализации последовательного алгоритма ===
Алгоритм можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246-248)</ref>:

repeat
выбрать пару индексов j,k
обратиться к процедуре '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
пока <math>A</math> не достаточно близка к диагональной матрице

Существует несколько способов выбора пары <math>j,k</math>. Наиболее простой и быстрый способ — построчный циклический обход внедиагональных элементов матрицы <math>A</math>:

repeat
for <math>j=1</math> to <math>n-1</math>
for <math>k=j+1</math> to <math>n</math>
выполнить процедуру '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
end for
end for
пока <math>A</math> не достаточно близка к диагональной матрице

Процедура '''''Jakobi-Rotation<math>(A,j,k)</math>''''' — это следующий алгоритм:
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\,t \\
A &= R^T(j,k,\theta)\cdot A\cdot R(j,k,\theta), \qquad J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}</math>
end if

=== Последовательная сложность алгоритма ===

Для осуществления одной итерации метода Якоби для матрицы размера <math>(n\times n)</math> требуется выполнить:

Для вычислительного ядра —
* <math> 4n+4 </math> умножений,
* <math> 2n+2 </math> сложений.

Для остальной части алгоритма —
* <math> 3 </math> умножения,
* <math> 3 </math> деления,
* <math> 5 </math> сложений (вычитаний),
* <math> 2 </math> извлечения квадратного корня.

Умножения и сложения (вычитания) составляют основную часть алгоритма.

Так как выбор индексов <math>j</math> и <math>k</math> осуществляется путем перебора внедиагональных элементов матрицы, для полного прохода потребуется <math>\frac{n(n-1)}{2}</math> итераций.

Таким образом, при классификации по последовательной сложности метод Якоби вычисления собственных значений симметричной матрицы относится к алгоритмам с кубической сложностью.

=== Информационный граф ===

Граф алгоритма состоит из трёх групп вершин.

'''Первой''' группе вершин (J) соответствует вычисление значений c и s.

'''Второй''' группе вершин (А) соответствует вычисление значений элементов <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>.

'''Третьей''' группе вершин (B) соответствует вычисление значений элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>.

<center>
<div class="thumb">
<div class="thumbinner" style="width:{{#expr: 3 * (400 + 35) + 4 * (3 - 1) + 8}}px">
<gallery widths=400px heights=400px>
File:Информационный_граф_метода_якоби.png|Рисунок 1. Граф одной итерации алгоритма без отображения входных и выходных данных.
File:ГрафJ.png|Рисунок 2. Внутренний граф вершин J с входными параметрами <math>x = a_{jj}^{(i)}, y = a_{kk}^{(i)}, z = a_{jk}^{(i)}</math>.
</gallery>
</div>
</div>
</center>

=== Ресурс параллелизма алгоритма ===

Для выполнения одной итерации требуется последовательно выполнить следующие действия:
# вычислить <math>\tau</math> (2 операции сложения, 1 операция деления)
# вычислить <math>t</math> (1 операция сравнения, 1 операция взятия модуля, 2 операции сложения, 1 операция умножения, 1 операция деления, 1 операция извлечения квадратного корня)
# вычислить <math>c</math> (1 операция сложения, 1 операция умножения, 1 операция деления, 1 операция извлечения квадратного корня) и <math>s</math> (1 операция умножения)

После этого выполняется ярус, отвечающий за применение поворота к матрице <math>A</math> с параллельным выполнением <math>2(n-2)</math> операций вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math> , а также 2 операций вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>. Наибольшее количество операций содержится в вычислении последних двух элементов (по 6 умножений и 3 сложения).

Суммарное количество итераций зависит от входных данных и заданного значения погрешности. Один "цикл" (полный проход по внедиагональным элементам) осуществляется за <math>N = \frac{n(n-1)}{2}</math> итераций. Асимптотически метод сходится квадратично<ref>J. H. Wilkinson. The Algebraic Eigenvalue Problem. Oxford University Press, UK, 1965. (стр 270)</ref>. Нередко для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 248)</ref>.

Таким образом, при классификации по высоте ЯПФ метод Якоби относится к алгоритмам со сложностью <math>O(n^2)</math> , а при классификации по ширине ЯПФ — к алгоритмам со сложностью <math>O(n)</math>.

=== Входные и выходные данные алгоритма ===

'''Входные данные''': матрица <math>A</math> (элементы <math>a_{ij}</math>).
Дополнительные ограничения:
* <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы). В разных реализациях эта экономия хранения может быть выполнена разным образом.

'''Выходные данные''': вектор собственных значений <math>\Lambda</math> (элементы <math>\lambda_{ii}</math>).

'''Объём выходных данных''': <math> n </math>.

=== Свойства алгоритма ===

Метод Якоби является самым медленным из имеющихся алгоритмов вычисления собственных значений симметричной матрицы. Тем не менее, он способен вычислять малые собственные числа и отвечающие им собственные векторы с гораздо большей точностью, чем другие методы<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244)</ref>. Кроме того, он не предполагает первоначального приведения матрицы к трехдиагональной форме.

Соотношение последовательной и параллельной сложности в случае неограниченных ресурсов для метода Якоби является линейным, вычислительная мощность алгоритма также линейна.

Метод Якоби не детерминирован, так как является итерационным алгоритмом с выходом по точности: число итераций зависит от входных данных и порогового значения.

Дуги информационного графа, исходящие из вершин, соответствующих вычислениям значений <math>c</math> и <math>s</math>, образуют пучки рассылок линейной мощности.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

Существует библиотека JACOBI_EIGENVALUE, реализованная на языках программирования [http://people.sc.fsu.edu/~jburkardt/c_src/jacobi_eigenvalue/jacobi_eigenvalue.html С], [http://people.sc.fsu.edu/~jburkardt/cpp_src/jacobi_eigenvalue/jacobi_eigenvalue.html С++], [http://people.sc.fsu.edu/~jburkardt/f77_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN77], [http://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN90], [http://people.sc.fsu.edu/~jburkardt/m_src/jacobi_eigenvalue/jacobi_eigenvalue.html MATLAB], [http://people.sc.fsu.edu/~jburkardt/py_src/jacobi_eigenvalue/jacobi_eigenvalue.html Python],

== Литература ==

<references \>

Участник:Galkina/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-14T15:16:49Z

Игорь: /* Макроструктура алгоритма */

{{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>
}}

Авторы описания: [[Участник: Galkina|А.С.Галкина]], [[Участник: Игорь|И.А.Плахов]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Метод Якоби — итерационный алгоритм для вычисления собственных значений и собственных векторов вещественной симметричной матрицы. Карл Густав Якоб Якоби, в честь которого назван этот метод, предложил его в 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>Golub, G.H. (2000). «Eigenvalue computation in the 20th century». Journal of Computational and Applied Mathematics 123 (1-2): 35–65. DOI:[https://dx.doi.org/10.1016%2FS0377-0427%2800%2900413-1 10.1016/S0377-0427(00)00413-1].</ref>.
Суть алгоритма заключается в том, чтобы по заданной симметрической матрице <math>A = A_0</math> построить последовательность ортогонально подобных матриц <math>A_1,A_2,\dotsc,A_m</math>, сходящуюся к диагональной матрице, на диагонали которой стоят собственные значения. Для построения этой последовательности применяется специально подобранная матрица поворота <math>J_i</math>, такая что норма наддиагональной части <math>of\!f(A)=\sqrt{\sum\limits_{1 \le j < k \le n} a_{jk}^2}</math> уменьшается при каждом повороте матрицы <math>A</math>. Вычисление останавливается, когда угол поворота становится близок к нулю, либо когда максимальный внедиагональный элемент становится меньше заранее выбранного порогового значения.

=== Математическое описание алгоритма ===
Исходные данные: симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>).

Матрица <math>A_{i+1}</math> получается из <math>A_i</math> по формуле <math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math>J_i</math> — ортогональная матрица, называемая ''вращением Якоби''.
При подходящем выборе <math>J_i</math> матрица <math>A_m</math> для больших m будет близка к диагональной матрице <math>\Lambda</math>.

Матрица <math>J_i</math> выбирается так, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}</math><ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>.



                                                
<math>j</math>
                       
<math>k</math>

<math>
J_i =
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & -\sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>. Тогда матрица <math>A_{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)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Можно выбрать <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>. Отсюда получим равенство

: <math> \frac{a_{jj}^{(i)} - a_{kk}^{(i)}}{2 a_{jk}^{(i)}} = \frac{c^2 - s^2}{2sc} = \frac{\cos 2\theta}{\sin 2\theta} = \operatorname{tg}(2\theta) \equiv \tau </math>.

Положим <math>t = \frac{s}{c} = \operatorname{ctg}(\theta)</math> и заметим, что <math>t^2 - 2t\tau + 1 = 0</math>. Решая квадратное уравнение, находим <math>t = \frac{\operatorname{sign}(\tau)}{|\tau| + \sqrt{1+\tau^2}}, c = \frac{1}{\sqrt{1+t^2}}, s = tc</math>.

Выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро составляют множественные вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>   в процессе применения матрицы поворота <math>J</math> к матрице <math>A</math>:
: <math>\begin{align}
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k,
\end{align}</math>

каждое из которых повторяется по <math> (n-2) </math> раза, а также вычисление элементов <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>

=== Макроструктура алгоритма ===
Основную часть метода составляет процедура применения вращения к матрице <math>A</math>, которая в дальнейшем будет обозначена как '''''Jakobi-Rotation<math>(A,j,k)</math>'''''

Эту процедуру, в свою очередь, можно разделить на две логические части:
# Определение угла поворота <math>\theta</math> по элементам матрицы <math>a_{jj}</math>, <math>a_{kk}</math> и <math>a_{jk}</math>;
# Применение вращения к матрице <math>A</math> (изменяются лишь строки и столбцы, соответствующие индексам <math>j</math> и  <math>k</math>).

=== Схема реализации последовательного алгоритма ===
Алгоритм можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246-248)</ref>:

repeat
выбрать пару индексов j,k
обратиться к процедуре '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
пока <math>A</math> не достаточно близка к диагональной матрице

Существует несколько способов выбора пары <math>j,k</math>. Наиболее простой и быстрый способ — построчный циклический обход внедиагональных элементов матрицы <math>A</math>:

repeat
for <math>j=1</math> to <math>n-1</math>
for <math>k=j+1</math> to <math>n</math>
выполнить процедуру '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
end for
end for
пока <math>A</math> не достаточно близка к диагональной матрице

Процедура '''''Jakobi-Rotation<math>(A,j,k)</math>''''' — это следующий алгоритм:
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\,t \\
A &= R^T(j,k,\theta)\cdot A\cdot R(j,k,\theta), \qquad J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}</math>
end if

=== Последовательная сложность алгоритма ===

Для осуществления одной итерации метода Якоби для матрицы размера <math>(n\times n)</math> требуется выполнить:

Для вычислительного ядра —
* <math> 4n+4 </math> умножений,
* <math> 2n+2 </math> сложений.

Для остальной части алгоритма —
* <math> 3 </math> умножения,
* <math> 3 </math> деления,
* <math> 5 </math> сложений (вычитаний),
* <math> 2 </math> извлечения квадратного корня.

Умножения и сложения (вычитания) составляют основную часть алгоритма.

Так как выбор индексов <math>j</math> и <math>k</math> осуществляется путем перебора внедиагональных элементов матрицы, для полного прохода потребуется <math>\frac{n(n-1)}{2}</math> итераций.

Таким образом, при классификации по последовательной сложности метод Якоби вычисления собственных значений симметричной матрицы относится к алгоритмам с кубической сложностью.

=== Информационный граф ===

Граф алгоритма состоит из трёх групп вершин.

'''Первой''' группе вершин (J) соответствует вычисление значений c и s.

'''Второй''' группе вершин (А) соответствует вычисление значений элементов <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>.

'''Третьей''' группе вершин (B) соответствует вычисление значений элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>.

<center>
<div class="thumb">
<div class="thumbinner" style="width:{{#expr: 3 * (400 + 35) + 4 * (3 - 1) + 8}}px">
<gallery widths=400px heights=400px>
File:Информационный_граф_метода_якоби.png|Рисунок 1. Граф одной итерации алгоритма без отображения входных и выходных данных.
File:ГрафJ.png|Рисунок 2. Внутренний граф вершин J с входными параметрами <math>x = a_{jj}^{(i)}, y = a_{kk}^{(i)}, z = a_{jk}^{(i)}</math>.
</gallery>
</div>
</div>
</center>

=== Ресурс параллелизма алгоритма ===

Для выполнения одной итерации требуется последовательно выполнить следующие действия:
# вычислить <math>\tau</math> (2 операции сложения, 1 операция деления)
# вычислить <math>t</math> (1 операция сравнения, 1 операция взятия модуля, 2 операции сложения, 1 операция умножения, 1 операция деления, 1 операция извлечения квадратного корня)
# вычислить <math>c</math> (1 операция сложения, 1 операция умножения, 1 операция деления, 1 операция извлечения квадратного корня) и <math>s</math> (1 операция умножения)

После этого выполняется ярус, отвечающий за применение поворота к матрице <math>A</math> с параллельным выполнением <math>2(n-2)</math> операций вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math> , а также 2 операций вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>. Наибольшее количество операций содержится в вычислении последних двух элементов (по 6 умножений и 3 сложения).

Суммарное количество итераций зависит от входных данных и заданного значения погрешности. Один "цикл" (полный проход по внедиагональным элементам) осуществляется за <math>N = \frac{n(n-1)}{2}</math> итераций. Асимптотически метод сходится квадратично<ref>J. H. Wilkinson. The Algebraic Eigenvalue Problem. Oxford University Press, UK, 1965. (стр 270)</ref>. Нередко для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 248)</ref>.

Таким образом, при классификации по высоте ЯПФ метод Якоби относится к алгоритмам со сложностью <math>O(n^2)</math> , а при классификации по ширине ЯПФ — к алгоритмам со сложностью <math>O(n)</math>.

=== Входные и выходные данные алгоритма ===

'''Входные данные''': матрица <math>A</math> (элементы <math>a_{ij}</math>).
Дополнительные ограничения:
* <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы). В разных реализациях эта экономия хранения может быть выполнена разным образом.

'''Выходные данные''': вектор собственных значений <math>\Lambda</math> (элементы <math>\lambda_{ii}</math>).

'''Объём выходных данных''': <math> n </math>.

=== Свойства алгоритма ===

Метод Якоби является самым медленным из имеющихся алгоритмов вычисления собственных значений симметричной матрицы. Тем не менее, он способен вычислять малые собственные числа и отвечающие им собственные векторы с гораздо большей точностью, чем другие методы<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244)</ref>. Кроме того, он не предполагает первоначального приведения матрицы к трехдиагональной форме.

Соотношение последовательной и параллельной сложности в случае неограниченных ресурсов для метода Якоби является линейным, вычислительная мощность алгоритма также линейна.

Метод Якоби не детерминирован, так как является итерационным алгоритмом с выходом по точности: число итераций зависит от входных данных и порогового значения.

Дуги информационного графа, исходящие из вершин, соответствующих вычислениям значений <math>c</math> и <math>s</math>, образуют пучки рассылок линейной мощности.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

Существует библиотека JACOBI_EIGENVALUE, реализованная на языках программирования [http://people.sc.fsu.edu/~jburkardt/c_src/jacobi_eigenvalue/jacobi_eigenvalue.html С], [http://people.sc.fsu.edu/~jburkardt/cpp_src/jacobi_eigenvalue/jacobi_eigenvalue.html С++], [http://people.sc.fsu.edu/~jburkardt/f77_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN77], [http://people.sc.fsu.edu/~jburkardt/f_src/jacobi_eigenvalue/jacobi_eigenvalue.html FORTRAN90], [http://people.sc.fsu.edu/~jburkardt/m_src/jacobi_eigenvalue/jacobi_eigenvalue.html MATLAB], [http://people.sc.fsu.edu/~jburkardt/py_src/jacobi_eigenvalue/jacobi_eigenvalue.html Python],

== Литература ==

<references \>

Участник:Galkina/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-14T13:38:51Z

Игорь: /* Свойства алгоритма */

{{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>
}}

Авторы описания: [[Участник: Galkina|А.С.Галкина]], [[Участник: Игорь|И.А.Плахов]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Метод Якоби — итерационный алгоритм для вычисления собственных значений и собственных векторов вещественной симметричной матрицы. Карл Густав Якоб Якоби, в честь которого назван этот метод, предложил его в 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>Golub, G.H. (2000). «Eigenvalue computation in the 20th century». Journal of Computational and Applied Mathematics 123 (1-2): 35–65. DOI:[https://dx.doi.org/10.1016%2FS0377-0427%2800%2900413-1 10.1016/S0377-0427(00)00413-1].</ref>.
Суть алгоритма заключается в том, чтобы по заданной симметрической матрице <math>A = A_0</math> построить последовательность ортогонально подобных матриц <math>A_1,A_2,\dotsc,A_m</math>, сходящуюся к диагональной матрице, на диагонали которой стоят собственные значения. Для построения этой последовательности применяется специально подобранная матрица поворота <math>J_i</math>, такая что норма наддиагональной части <math>of\!f(A)=\sqrt{\sum\limits_{1 \le j < k \le n} a_{jk}^2}</math> уменьшается при каждом повороте матрицы <math>A</math>. Вычисление останавливается, когда угол поворота становится близок к нулю, либо когда максимальный внедиагональный элемент становится меньше заранее выбранного порогового значения.

=== Математическое описание алгоритма ===
Исходные данные: симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>).

Матрица <math>A_{i+1}</math> получается из <math>A_i</math> по формуле <math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math>J_i</math> — ортогональная матрица, называемая ''вращением Якоби''.
При подходящем выборе <math>J_i</math> матрица <math>A_m</math> для больших m будет близка к диагональной матрице <math>\Lambda</math>.

Матрица <math>J_i</math> выбирается так, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}</math><ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>.



                                                
<math>j</math>
                       
<math>k</math>

<math>
J_i =
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & -\sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>. Тогда матрица <math>A_{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)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Можно выбрать <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>. Отсюда получим равенство

: <math> \frac{a_{jj}^{(i)} - a_{kk}^{(i)}}{2 a_{jk}^{(i)}} = \frac{c^2 - s^2}{2sc} = \frac{\cos 2\theta}{\sin 2\theta} = \operatorname{tg}(2\theta) \equiv \tau </math>.

Положим <math>t = \frac{s}{c} = \operatorname{ctg}(\theta)</math> и заметим, что <math>t^2 - 2t\tau + 1 = 0</math>. Решая квадратное уравнение, находим <math>t = \frac{\operatorname{sign}(\tau)}{|\tau| + \sqrt{1+\tau^2}}, c = \frac{1}{\sqrt{1+t^2}}, s = tc</math>.

Выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро составляют множественные вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>   в процессе применения матрицы поворота <math>J</math> к матрице <math>A</math>:
: <math>\begin{align}
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k,
\end{align}</math>

каждое из которых повторяется по <math> (n-2) </math> раза, а также вычисление элементов <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>

=== Макроструктура алгоритма ===
Основную часть метода составляет процедура применения вращения к матрице <math>A</math>, которая в дальнейшем будет обозначена как '''''Jakobi-Rotation<math>(A,j,k)</math>'''''

=== Схема реализации последовательного алгоритма ===
Алгоритм можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246-248)</ref>:

repeat
выбрать пару индексов j,k
обратиться к процедуре '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
пока <math>A</math> не достаточно близка к диагональной матрице

Существует несколько способов выбора пары <math>j,k</math>. Наиболее простой и быстрый способ — построчный циклический обход внедиагональных элементов матрицы <math>A</math>:

repeat
for <math>j=1</math> to <math>n-1</math>
for <math>k=j+1</math> to <math>n</math>
выполнить процедуру '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
end for
end for
пока <math>A</math> не достаточно близка к диагональной матрице

Процедура '''''Jakobi-Rotation<math>(A,j,k)</math>''''' — это следующий алгоритм:
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\,t \\
A &= R^T(j,k,\theta)\cdot A\cdot R(j,k,\theta), \qquad J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}</math>
end if

=== Последовательная сложность алгоритма ===

Для осуществления одной итерации метода Якоби для матрицы размера <math>(n\times n)</math> требуется выполнить:

Для вычислительного ядра —
* <math> 4n+4 </math> умножений,
* <math> 2n+2 </math> сложений.

Для остальной части алгоритма —
* <math> 3 </math> умножения,
* <math> 3 </math> деления,
* <math> 5 </math> сложений (вычитаний),
* <math> 2 </math> извлечения квадратного корня.

Умножения и сложения (вычитания) составляют основную часть алгоритма.

Так как выбор индексов <math>j</math> и <math>k</math> осуществляется путем перебора внедиагональных элементов матрицы, для полного прохода потребуется <math>\frac{n(n-1)}{2}</math> итераций.

Таким образом, при классификации по последовательной сложности метод Якоби вычисления собственных значений симметричной матрицы относится к алгоритмам с кубической сложностью.

=== Информационный граф ===

Граф алгоритма состоит из трёх групп вершин.

'''Первой''' группе вершин (J) соответствует вычисление значений c и s.

'''Второй''' группе вершин (А) соответствует вычисление значений элементов <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>.

'''Третьей''' группе вершин (B) соответствует вычисление значений элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>.

<center>
<div class="thumb">
<div class="thumbinner" style="width:{{#expr: 3 * (400 + 35) + 4 * (3 - 1) + 8}}px">
<gallery widths=400px heights=400px>
File:Информационный_граф_метода_якоби.png|Рисунок 1. Граф одной итерации алгоритма без отображения входных и выходных данных.
File:ГрафJ.png|Рисунок 2. Внутренний граф вершин J с входными параметрами <math>x = a_{jj}^{(i)}, y = a_{kk}^{(i)}, z = a_{jk}^{(i)}</math>.
</gallery>
</div>
</div>
</center>

=== Ресурс параллелизма алгоритма ===

Для выполнения одной итерации требуется последовательно выполнить следующие действия:
# вычислить <math>\tau</math> (2 операции сложения, 1 операция деления)
# вычислить <math>t</math> (1 операция сравнения, 1 операция взятия модуля, 2 операции сложения, 1 операция умножения, 1 операция деления, 1 операция извлечения квадратного корня)
# вычислить <math>c</math> (1 операция сложения, 1 операция умножения, 1 операция деления, 1 операция извлечения квадратного корня) и <math>s</math> (1 операция умножения)

После этого выполняется ярус, отвечающий за применение поворота к матрице <math>A</math> с параллельным выполнением <math>2(n-2)</math> операций вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math> , а также 2 операций вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>. Наибольшее количество операций содержится в вычислении последних двух элементов (по 6 умножений и 3 сложения).

Суммарное количество итераций зависит от входных данных и заданного значения погрешности. Один "цикл" (полный проход по внедиагональным элементам) осуществляется за <math>N = \frac{n(n-1)}{2}</math> итераций. Асимптотически метод сходится квадратично<ref>J. H. Wilkinson. The Algebraic Eigenvalue Problem. Oxford University Press, UK, 1965. (стр 270)</ref>. Нередко для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 248)</ref>.

Таким образом, при классификации по высоте ЯПФ метод Якоби относится к алгоритмам со сложностью <math>O(n^2)</math> , а при классификации по ширине ЯПФ — к алгоритмам со сложностью <math>O(n)</math>.

=== Входные и выходные данные алгоритма ===

'''Входные данные''': матрица <math>A</math> (элементы <math>a_{ij}</math>).
Дополнительные ограничения:
* <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы). В разных реализациях эта экономия хранения может быть выполнена разным образом.

'''Выходные данные''': вектор собственных значений <math>\Lambda</math> (элементы <math>\lambda_{ii}</math>).

'''Объём выходных данных''': <math> n </math>.

=== Свойства алгоритма ===

Метод Якоби является самым медленным из имеющихся алгоритмов вычисления собственных значений симметричной матрицы. Тем не менее, он способен вычислять малые собственные числа и отвечающие им собственные векторы с гораздо большей точностью, чем другие методы<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244)</ref>. Кроме того, он не предполагает первоначального приведения матрицы к трехдиагональной форме.

Соотношение последовательной и параллельной сложности в случае неограниченных ресурсов для метода Якоби является линейным, вычислительная мощность алгоритма также линейна.

Метод Якоби не детерминирован, так как является итерационным алгоритмом с выходом по точности: число итераций зависит от входных данных и порогового значения.

Дуги информационного графа, исходящие из вершин, соответствующих вычислениям значений <math>c</math> и <math>s</math>, образуют пучки рассылок линейной мощности.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

В [http://people.sc.fsu.edu/~jburkardt/cpp_src/cpp_src.html C++ Source Codes] имеется библиотека [http://people.sc.fsu.edu/~jburkardt/cpp_src/jacobi_eigenvalue/jacobi_eigenvalue.html JACOBI_EIGENVALUE].

== Литература ==

<references \>

Участник:Galkina/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-14T10:56:45Z

Игорь: /* Ресурс параллелизма алгоритма */

{{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>
}}

Авторы описания: [[Участник: Galkina|А.С.Галкина]], [[Участник: Игорь|И.А.Плахов]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Метод Якоби — итерационный алгоритм для вычисления собственных значений и собственных векторов вещественной симметричной матрицы. Карл Густав Якоб Якоби, в честь которого назван этот метод, предложил его в 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>Golub, G.H. (2000). «Eigenvalue computation in the 20th century». Journal of Computational and Applied Mathematics 123 (1-2): 35–65. DOI:[https://dx.doi.org/10.1016%2FS0377-0427%2800%2900413-1 10.1016/S0377-0427(00)00413-1].</ref>.
Суть алгоритма заключается в том, чтобы по заданной симметрической матрице <math>A = A_0</math> построить последовательность ортогонально подобных матриц <math>A_1,A_2,\dotsc,A_m</math>, сходящуюся к диагональной матрице, на диагонали которой стоят собственные значения. Для построения этой последовательности применяется специально подобранная матрица поворота <math>J_i</math>, такая что норма наддиагональной части <math>of\!f(A)=\sqrt{\sum\limits_{1 \le j < k \le n} a_{jk}^2}</math> уменьшается при каждом повороте матрицы <math>A</math>. Вычисление останавливается, когда угол поворота становится близок к нулю, либо когда максимальный внедиагональный элемент становится меньше заранее выбранного порогового значения.

=== Математическое описание алгоритма ===
Исходные данные: симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>).

Матрица <math>A_{i+1}</math> получается из <math>A_i</math> по формуле <math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math>J_i</math> — ортогональная матрица, называемая ''вращением Якоби''.
При подходящем выборе <math>J_i</math> матрица <math>A_m</math> для больших m будет близка к диагональной матрице <math>\Lambda</math>.

Матрица <math>J_i</math> выбирается так, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}</math><ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>.



                                                
<math>j</math>
                       
<math>k</math>

<math>
J_i =
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & -\sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>. Тогда матрица <math>A_{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)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Можно выбрать <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>. Отсюда получим равенство

: <math> \frac{a_{jj}^{(i)} - a_{kk}^{(i)}}{2 a_{jk}^{(i)}} = \frac{c^2 - s^2}{2sc} = \frac{\cos 2\theta}{\sin 2\theta} = \operatorname{tg}(2\theta) \equiv \tau </math>.

Положим <math>t = \frac{s}{c} = \operatorname{ctg}(\theta)</math> и заметим, что <math>t^2 - 2t\tau + 1 = 0</math>. Решая квадратное уравнение, находим <math>t = \frac{\operatorname{sign}(\tau)}{|\tau| + \sqrt{1+\tau^2}}, c = \frac{1}{\sqrt{1+t^2}}, s = tc</math>.

Выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро составляют множественные вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>   в процессе применения матрицы поворота <math>J</math> к матрице <math>A</math>:
: <math>\begin{align}
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k,
\end{align}</math>

каждое из которых повторяется по <math> (n-2) </math> раза, а также вычисление элементов <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>

=== Макроструктура алгоритма ===
Основную часть метода составляет процедура применения вращения к матрице <math>A</math>, которая в дальнейшем будет обозначена как '''''Jakobi-Rotation<math>(A,j,k)</math>'''''

=== Схема реализации последовательного алгоритма ===
Алгоритм можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246-248)</ref>:

repeat
выбрать пару индексов j,k
обратиться к процедуре '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
пока <math>A</math> не достаточно близка к диагональной матрице

Существует несколько способов выбора пары <math>j,k</math>. Наиболее простой и быстрый способ — построчный циклический обход внедиагональных элементов матрицы <math>A</math>:

repeat
for <math>j=1</math> to <math>n-1</math>
for <math>k=j+1</math> to <math>n</math>
выполнить процедуру '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
end for
end for
пока <math>A</math> не достаточно близка к диагональной матрице

Процедура '''''Jakobi-Rotation<math>(A,j,k)</math>''''' — это следующий алгоритм:
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\,t \\
A &= R^T(j,k,\theta)\cdot A\cdot R(j,k,\theta), \qquad J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}</math>
end if

=== Последовательная сложность алгоритма ===

Для осуществления одной итерации метода Якоби для матрицы размера <math>(n\times n)</math> требуется выполнить:

Для вычислительного ядра —
* <math> 4n+4 </math> умножений,
* <math> 2n+2 </math> сложений.

Для остальной части алгоритма —
* <math> 3 </math> умножения,
* <math> 3 </math> деления,
* <math> 5 </math> сложений (вычитаний),
* <math> 2 </math> извлечения квадратного корня.

Умножения и сложения (вычитания) составляют основную часть алгоритма.

Так как выбор индексов <math>j</math> и <math>k</math> осуществляется путем перебора внедиагональных элементов матрицы, для полного прохода потребуется <math>\frac{n(n-1)}{2}</math> итераций.

Таким образом, при классификации по последовательной сложности метод Якоби вычисления собственных значений симметричной матрицы относится к алгоритмам с кубической сложностью.

=== Информационный граф ===

Граф алгоритма состоит из трёх групп вершин.

'''Первой''' группе вершин (J) соответствует вычисление значений c и s.

'''Второй''' группе вершин (А) соответствует вычисление значений элементов <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>.

'''Третьей''' группе вершин (B) соответствует вычисление значений элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>.

<center>
<div class="thumb">
<div class="thumbinner" style="width:{{#expr: 3 * (400 + 35) + 4 * (3 - 1) + 8}}px">
<gallery widths=400px heights=400px>
File:Информационный_граф_метода_якоби.png|Рисунок 1. Граф одной итерации алгоритма без отображения входных и выходных данных.
File:ГрафJ.png|Рисунок 2. Внутренний граф вершин J с входными параметрами <math>x = a_{jj}^{(i)}, y = a_{kk}^{(i)}, z = a_{jk}^{(i)}</math>.
</gallery>
</div>
</div>
</center>

=== Ресурс параллелизма алгоритма ===

Для выполнения одной итерации требуется последовательно выполнить следующие действия:
# вычислить <math>\tau</math> (2 операции сложения, 1 операция деления)
# вычислить <math>t</math> (1 операция сравнения, 1 операция взятия модуля, 2 операции сложения, 1 операция умножения, 1 операция деления, 1 операция извлечения квадратного корня)
# вычислить <math>c</math> (1 операция сложения, 1 операция умножения, 1 операция деления, 1 операция извлечения квадратного корня) и <math>s</math> (1 операция умножения)

После этого выполняется ярус, отвечающий за применение поворота к матрице <math>A</math> с параллельным выполнением <math>2(n-2)</math> операций вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math> , а также 2 операций вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>. Наибольшее количество операций содержится в вычислении последних двух элементов (по 6 умножений и 3 сложения).

Суммарное количество итераций зависит от входных данных и заданного значения погрешности. Один "цикл" (полный проход по внедиагональным элементам) осуществляется за <math>N = \frac{n(n-1)}{2}</math> итераций. Асимптотически метод сходится квадратично<ref>J. H. Wilkinson. The Algebraic Eigenvalue Problem. Oxford University Press, UK, 1965. (стр 270)</ref>. Нередко для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 248)</ref>.

Таким образом, при классификации по высоте ЯПФ метод Якоби относится к алгоритмам со сложностью <math>O(n^2)</math> , а при классификации по ширине ЯПФ — к алгоритмам со сложностью <math>O(n)</math>.

=== Входные и выходные данные алгоритма ===

'''Входные данные''': матрица <math>A</math> (элементы <math>a_{ij}</math>).
Дополнительные ограничения:
* <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы). В разных реализациях эта экономия хранения может быть выполнена разным образом.

'''Выходные данные''': вектор собственных значений <math>\Lambda</math> (элементы <math>\lambda_{ii}</math>).

'''Объём выходных данных''': <math> n </math>.

=== Свойства алгоритма ===

Соотношение последовательной и параллельной сложности в случае неограниченных ресурсов для метода Якоби является линейным, вычислительная мощность алгоритма также линейна.

Метод Якоби не детерминирован, так как является итерационным алгоритмом с выходом по точности: число итераций зависит от входных данных и порогового значения.

Дуги информационного графа, исходящие из вершин, соответствующих вычислениям значений <math>c</math> и <math>s</math>, образуют пучки рассылок линейной мощности.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

== Литература ==

<references \>

Участник:Galkina/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-14T10:26:43Z

Игорь: /* Математическое описание алгоритма */

{{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>
}}

Авторы описания: [[Участник: Galkina|А.С.Галкина]], [[Участник: Игорь|И.А.Плахов]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Метод Якоби — итерационный алгоритм для вычисления собственных значений и собственных векторов вещественной симметричной матрицы. Карл Густав Якоб Якоби, в честь которого назван этот метод, предложил его в 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>Golub, G.H. (2000). «Eigenvalue computation in the 20th century». Journal of Computational and Applied Mathematics 123 (1-2): 35–65. DOI:[https://dx.doi.org/10.1016%2FS0377-0427%2800%2900413-1 10.1016/S0377-0427(00)00413-1].</ref>.
Суть алгоритма заключается в том, чтобы по заданной симметрической матрице <math>A = A_0</math> построить последовательность ортогонально подобных матриц <math>A_1,A_2,\dotsc,A_m</math>, сходящуюся к диагональной матрице, на диагонали которой стоят собственные значения. Для построения этой последовательности применяется специально подобранная матрица поворота <math>J_i</math>, такая что норма наддиагональной части <math>of\!f(A)=\sqrt{\sum\limits_{1 \le j < k \le n} a_{jk}^2}</math> уменьшается при каждом повороте матрицы <math>A</math>. Вычисление останавливается, когда угол поворота становится близок к нулю, либо когда максимальный внедиагональный элемент становится меньше заранее выбранного порогового значения.

=== Математическое описание алгоритма ===
Исходные данные: симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>).

Матрица <math>A_{i+1}</math> получается из <math>A_i</math> по формуле <math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math>J_i</math> — ортогональная матрица, называемая ''вращением Якоби''.
При подходящем выборе <math>J_i</math> матрица <math>A_m</math> для больших m будет близка к диагональной матрице <math>\Lambda</math>.

Матрица <math>J_i</math> выбирается так, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}</math><ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>.



                                                
<math>j</math>
                       
<math>k</math>

<math>
J_i =
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & -\sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>. Тогда матрица <math>A_{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)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Можно выбрать <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>. Отсюда получим равенство

: <math> \frac{a_{jj}^{(i)} - a_{kk}^{(i)}}{2 a_{jk}^{(i)}} = \frac{c^2 - s^2}{2sc} = \frac{\cos 2\theta}{\sin 2\theta} = \operatorname{tg}(2\theta) \equiv \tau </math>.

Положим <math>t = \frac{s}{c} = \operatorname{ctg}(\theta)</math> и заметим, что <math>t^2 - 2t\tau + 1 = 0</math>. Решая квадратное уравнение, находим <math>t = \frac{\operatorname{sign}(\tau)}{|\tau| + \sqrt{1+\tau^2}}, c = \frac{1}{\sqrt{1+t^2}}, s = tc</math>.

Выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро составляют множественные вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>   в процессе применения матрицы поворота <math>J</math> к матрице <math>A</math>:
: <math>\begin{align}
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k,
\end{align}</math>

каждое из которых повторяется по <math> (n-2) </math> раза, а также вычисление элементов <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>

=== Макроструктура алгоритма ===
Основную часть метода составляет процедура применения вращения к матрице <math>A</math>, которая в дальнейшем будет обозначена как '''''Jakobi-Rotation<math>(A,j,k)</math>'''''

=== Схема реализации последовательного алгоритма ===
Алгоритм можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246-248)</ref>:

repeat
выбрать пару индексов j,k
обратиться к процедуре '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
пока <math>A</math> не достаточно близка к диагональной матрице

Существует несколько способов выбора пары <math>j,k</math>. Наиболее простой и быстрый способ — построчный циклический обход внедиагональных элементов матрицы <math>A</math>:

repeat
for <math>j=1</math> to <math>n-1</math>
for <math>k=j+1</math> to <math>n</math>
выполнить процедуру '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
end for
end for
пока <math>A</math> не достаточно близка к диагональной матрице

Процедура '''''Jakobi-Rotation<math>(A,j,k)</math>''''' — это следующий алгоритм:
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\,t \\
A &= R^T(j,k,\theta)\cdot A\cdot R(j,k,\theta), \qquad J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}</math>
end if

=== Последовательная сложность алгоритма ===

Для осуществления одной итерации метода Якоби для матрицы размера <math>(n\times n)</math> требуется выполнить:

Для вычислительного ядра —
* <math> 4n+4 </math> умножений,
* <math> 2n+2 </math> сложений.

Для остальной части алгоритма —
* <math> 3 </math> умножения,
* <math> 3 </math> деления,
* <math> 5 </math> сложений (вычитаний),
* <math> 2 </math> извлечения квадратного корня.

Умножения и сложения (вычитания) составляют основную часть алгоритма.

Так как выбор индексов <math>j</math> и <math>k</math> осуществляется путем перебора внедиагональных элементов матрицы, для полного прохода потребуется <math>\frac{n(n-1)}{2}</math> итераций.

Таким образом, при классификации по последовательной сложности метод Якоби вычисления собственных значений симметричной матрицы относится к алгоритмам с кубической сложностью.

=== Информационный граф ===

Граф алгоритма состоит из трёх групп вершин.

'''Первой''' группе вершин (J) соответствует вычисление значений c и s.

'''Второй''' группе вершин (А) соответствует вычисление значений элементов <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>.

'''Третьей''' группе вершин (B) соответствует вычисление значений элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>.

<center>
<div class="thumb">
<div class="thumbinner" style="width:{{#expr: 3 * (400 + 35) + 4 * (3 - 1) + 8}}px">
<gallery widths=400px heights=400px>
File:Информационный_граф_метода_якоби.png|Рисунок 1. Граф одной итерации алгоритма без отображения входных и выходных данных.
File:ГрафJ.png|Рисунок 2. Внутренний граф вершин J с входными параметрами <math>x = a_{jj}^{(i)}, y = a_{kk}^{(i)}, z = a_{jk}^{(i)}</math>.
</gallery>
</div>
</div>
</center>

=== Ресурс параллелизма алгоритма ===

Для выполнения одной итерации требуется последовательно выполнить следующие действия:
# вычислить <math>\tau</math> (2 операции сложения, 1 операция деления)
# вычислить <math>t</math> (1 операция сравнения, 1 операция взятия модуля, 2 операции сложения, 1 операция умножения, 1 операция деления, 1 операция извлечения квадратного корня)
# вычислить <math>c</math> (1 операция сложения, 1 операция умножения, 1 операция деления, 1 операция извлечения квадратного корня) и <math>s</math> (1 операция умножения)

После этого выполняется ярус, отвечающий за применение поворота к матрице <math>A</math> с параллельным выполнением <math>2(n-2)</math> операций вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math> , а также 2 операций вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>. Наибольшее количество операций содержится в вычислении последних двух элементов (по 6 умножений и 3 сложения).

Количество итераций зависит от входных данных, однако асимптотически метод сходится квадратично<ref>J. H. Wilkinson. The Algebraic Eigenvalue Problem. Oxford University Press, UK, 1965. (стр 270)</ref>. Нередко для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 248)</ref>.

Таким образом, при классификации по высоте ЯПФ метод Якоби относится к алгоритмам со сложностью <math>O(n^2)</math> , а при классификации по ширине ЯПФ — к алгоритмам со сложностью <math>O(n)</math>.

=== Входные и выходные данные алгоритма ===

'''Входные данные''': матрица <math>A</math> (элементы <math>a_{ij}</math>).
Дополнительные ограничения:
* <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы). В разных реализациях эта экономия хранения может быть выполнена разным образом.

'''Выходные данные''': вектор собственных значений <math>\Lambda</math> (элементы <math>\lambda_{ii}</math>).

'''Объём выходных данных''': <math> n </math>.

=== Свойства алгоритма ===

Соотношение последовательной и параллельной сложности в случае неограниченных ресурсов для метода Якоби является линейным, вычислительная мощность алгоритма также линейна.

Метод Якоби не детерминирован, так как является итерационным алгоритмом с выходом по точности: число итераций зависит от входных данных и порогового значения.

Дуги информационного графа, исходящие из вершин, соответствующих вычислениям значений <math>c</math> и <math>s</math>, образуют пучки рассылок линейной мощности.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

== Литература ==

<references \>

Участник:Galkina/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-14T10:19:50Z

Игорь: /* Последовательная сложность алгоритма */

{{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>
}}

Авторы описания: [[Участник: Galkina|А.С.Галкина]], [[Участник: Игорь|И.А.Плахов]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Метод Якоби — итерационный алгоритм для вычисления собственных значений и собственных векторов вещественной симметричной матрицы. Карл Густав Якоб Якоби, в честь которого назван этот метод, предложил его в 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>Golub, G.H. (2000). «Eigenvalue computation in the 20th century». Journal of Computational and Applied Mathematics 123 (1-2): 35–65. DOI:[https://dx.doi.org/10.1016%2FS0377-0427%2800%2900413-1 10.1016/S0377-0427(00)00413-1].</ref>.
Суть алгоритма заключается в том, чтобы по заданной симметрической матрице <math>A = A_0</math> построить последовательность ортогонально подобных матриц <math>A_1,A_2,\dotsc,A_m</math>, сходящуюся к диагональной матрице, на диагонали которой стоят собственные значения. Для построения этой последовательности применяется специально подобранная матрица поворота <math>J_i</math>, такая что норма наддиагональной части <math>of\!f(A)=\sqrt{\sum\limits_{1 \le j < k \le n} a_{jk}^2}</math> уменьшается при каждом повороте матрицы <math>A</math>. Вычисление останавливается, когда угол поворота становится близок к нулю, либо когда максимальный внедиагональный элемент становится меньше заранее выбранного порогового значения.

=== Математическое описание алгоритма ===
Исходные данные: симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>).

Матрица <math>A_{i+1}</math> получается из <math>A_i</math> по формуле <math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math>J_i</math> — ортогональная матрица, называемая ''вращением Якоби''.
При подходящем выборе <math>J_i</math> матрица <math>A_m</math> для больших m будет близка к диагональной матрице <math>\Lambda</math>.

Матрица <math>J_i</math> выбирается так, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}</math><ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>.



                                                
<math>j</math>
                       
<math>k</math>

<math>
J_i = R(j,k,\theta) =
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & -\sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>. Тогда матрица <math>A_{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)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Можно выбрать <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>. Отсюда получим равенство

: <math> \frac{a_{jj}^{(i)} - a_{kk}^{(i)}}{2 a_{jk}^{(i)}} = \frac{c^2 - s^2}{2sc} = \frac{\cos 2\theta}{\sin 2\theta} = \operatorname{tg}(2\theta) \equiv \tau </math>.

Положим <math>t = \frac{s}{c} = \operatorname{ctg}(\theta)</math> и заметим, что <math>t^2 - 2t\tau + 1 = 0</math>. Решая квадратное уравнение, находим <math>t = \frac{\operatorname{sign}(\tau)}{|\tau| + \sqrt{1+\tau^2}}, c = \frac{1}{\sqrt{1+t^2}}, s = tc</math>.

Выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро составляют множественные вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>   в процессе применения матрицы поворота <math>J</math> к матрице <math>A</math>:
: <math>\begin{align}
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k,
\end{align}</math>

каждое из которых повторяется по <math> (n-2) </math> раза, а также вычисление элементов <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>

=== Макроструктура алгоритма ===
Основную часть метода составляет процедура применения вращения к матрице <math>A</math>, которая в дальнейшем будет обозначена как '''''Jakobi-Rotation<math>(A,j,k)</math>'''''

=== Схема реализации последовательного алгоритма ===
Алгоритм можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246-248)</ref>:

repeat
выбрать пару индексов j,k
обратиться к процедуре '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
пока <math>A</math> не достаточно близка к диагональной матрице

Существует несколько способов выбора пары <math>j,k</math>. Наиболее простой и быстрый способ — построчный циклический обход внедиагональных элементов матрицы <math>A</math>:

repeat
for <math>j=1</math> to <math>n-1</math>
for <math>k=j+1</math> to <math>n</math>
выполнить процедуру '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
end for
end for
пока <math>A</math> не достаточно близка к диагональной матрице

Процедура '''''Jakobi-Rotation<math>(A,j,k)</math>''''' — это следующий алгоритм:
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\,t \\
A &= R^T(j,k,\theta)\cdot A\cdot R(j,k,\theta), \qquad J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}</math>
end if

=== Последовательная сложность алгоритма ===

Для осуществления одной итерации метода Якоби для матрицы размера <math>(n\times n)</math> требуется выполнить:

Для вычислительного ядра —
* <math> 4n+4 </math> умножений,
* <math> 2n+2 </math> сложений.

Для остальной части алгоритма —
* <math> 3 </math> умножения,
* <math> 3 </math> деления,
* <math> 5 </math> сложений (вычитаний),
* <math> 2 </math> извлечения квадратного корня.

Умножения и сложения (вычитания) составляют основную часть алгоритма.

Так как выбор индексов <math>j</math> и <math>k</math> осуществляется путем перебора внедиагональных элементов матрицы, для полного прохода потребуется <math>\frac{n(n-1)}{2}</math> итераций.

Таким образом, при классификации по последовательной сложности метод Якоби вычисления собственных значений симметричной матрицы относится к алгоритмам с кубической сложностью.

=== Информационный граф ===

Граф алгоритма состоит из трёх групп вершин.

'''Первой''' группе вершин (J) соответствует вычисление значений c и s.

'''Второй''' группе вершин (А) соответствует вычисление значений элементов <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>.

'''Третьей''' группе вершин (B) соответствует вычисление значений элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>.

<center>
<div class="thumb">
<div class="thumbinner" style="width:{{#expr: 3 * (400 + 35) + 4 * (3 - 1) + 8}}px">
<gallery widths=400px heights=400px>
File:Информационный_граф_метода_якоби.png|Рисунок 1. Граф одной итерации алгоритма без отображения входных и выходных данных.
File:ГрафJ.png|Рисунок 2. Внутренний граф вершин J с входными параметрами <math>x = a_{jj}^{(i)}, y = a_{kk}^{(i)}, z = a_{jk}^{(i)}</math>.
</gallery>
</div>
</div>
</center>

=== Ресурс параллелизма алгоритма ===

Для выполнения одной итерации требуется последовательно выполнить следующие действия:
# вычислить <math>\tau</math> (2 операции сложения, 1 операция деления)
# вычислить <math>t</math> (1 операция сравнения, 1 операция взятия модуля, 2 операции сложения, 1 операция умножения, 1 операция деления, 1 операция извлечения квадратного корня)
# вычислить <math>c</math> (1 операция сложения, 1 операция умножения, 1 операция деления, 1 операция извлечения квадратного корня) и <math>s</math> (1 операция умножения)

После этого выполняется ярус, отвечающий за применение поворота к матрице <math>A</math> с параллельным выполнением <math>2(n-2)</math> операций вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math> , а также 2 операций вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>. Наибольшее количество операций содержится в вычислении последних двух элементов (по 6 умножений и 3 сложения).

Количество итераций зависит от входных данных, однако асимптотически метод сходится квадратично<ref>J. H. Wilkinson. The Algebraic Eigenvalue Problem. Oxford University Press, UK, 1965. (стр 270)</ref>. Нередко для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 248)</ref>.

Таким образом, при классификации по высоте ЯПФ метод Якоби относится к алгоритмам со сложностью <math>O(n^2)</math> , а при классификации по ширине ЯПФ — к алгоритмам со сложностью <math>O(n)</math>.

=== Входные и выходные данные алгоритма ===

'''Входные данные''': матрица <math>A</math> (элементы <math>a_{ij}</math>).
Дополнительные ограничения:
* <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы). В разных реализациях эта экономия хранения может быть выполнена разным образом.

'''Выходные данные''': вектор собственных значений <math>\Lambda</math> (элементы <math>\lambda_{ii}</math>).

'''Объём выходных данных''': <math> n </math>.

=== Свойства алгоритма ===

Соотношение последовательной и параллельной сложности в случае неограниченных ресурсов для метода Якоби является линейным, вычислительная мощность алгоритма также линейна.

Метод Якоби не детерминирован, так как является итерационным алгоритмом с выходом по точности: число итераций зависит от входных данных и порогового значения.

Дуги информационного графа, исходящие из вершин, соответствующих вычислениям значений <math>c</math> и <math>s</math>, образуют пучки рассылок линейной мощности.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

== Литература ==

<references \>

Участник:Galkina/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-14T10:15:16Z

Игорь: /* Последовательная сложность алгоритма */

{{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>
}}

Авторы описания: [[Участник: Galkina|А.С.Галкина]], [[Участник: Игорь|И.А.Плахов]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Метод Якоби — итерационный алгоритм для вычисления собственных значений и собственных векторов вещественной симметричной матрицы. Карл Густав Якоб Якоби, в честь которого назван этот метод, предложил его в 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>Golub, G.H. (2000). «Eigenvalue computation in the 20th century». Journal of Computational and Applied Mathematics 123 (1-2): 35–65. DOI:[https://dx.doi.org/10.1016%2FS0377-0427%2800%2900413-1 10.1016/S0377-0427(00)00413-1].</ref>.
Суть алгоритма заключается в том, чтобы по заданной симметрической матрице <math>A = A_0</math> построить последовательность ортогонально подобных матриц <math>A_1,A_2,\dotsc,A_m</math>, сходящуюся к диагональной матрице, на диагонали которой стоят собственные значения. Для построения этой последовательности применяется специально подобранная матрица поворота <math>J_i</math>, такая что норма наддиагональной части <math>of\!f(A)=\sqrt{\sum\limits_{1 \le j < k \le n} a_{jk}^2}</math> уменьшается при каждом повороте матрицы <math>A</math>. Вычисление останавливается, когда угол поворота становится близок к нулю, либо когда максимальный внедиагональный элемент становится меньше заранее выбранного порогового значения.

=== Математическое описание алгоритма ===
Исходные данные: симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>).

Матрица <math>A_{i+1}</math> получается из <math>A_i</math> по формуле <math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math>J_i</math> — ортогональная матрица, называемая ''вращением Якоби''.
При подходящем выборе <math>J_i</math> матрица <math>A_m</math> для больших m будет близка к диагональной матрице <math>\Lambda</math>.

Матрица <math>J_i</math> выбирается так, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}</math><ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>.



                                                
<math>j</math>
                       
<math>k</math>

<math>
J_i = R(j,k,\theta) =
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & -\sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>. Тогда матрица <math>A_{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)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Можно выбрать <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>. Отсюда получим равенство

: <math> \frac{a_{jj}^{(i)} - a_{kk}^{(i)}}{2 a_{jk}^{(i)}} = \frac{c^2 - s^2}{2sc} = \frac{\cos 2\theta}{\sin 2\theta} = \operatorname{tg}(2\theta) \equiv \tau </math>.

Положим <math>t = \frac{s}{c} = \operatorname{ctg}(\theta)</math> и заметим, что <math>t^2 - 2t\tau + 1 = 0</math>. Решая квадратное уравнение, находим <math>t = \frac{\operatorname{sign}(\tau)}{|\tau| + \sqrt{1+\tau^2}}, c = \frac{1}{\sqrt{1+t^2}}, s = tc</math>.

Выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро составляют множественные вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>   в процессе применения матрицы поворота <math>J</math> к матрице <math>A</math>:
: <math>\begin{align}
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k,
\end{align}</math>

каждое из которых повторяется по <math> (n-2) </math> раза, а также вычисление элементов <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>

=== Макроструктура алгоритма ===
Основную часть метода составляет процедура применения вращения к матрице <math>A</math>, которая в дальнейшем будет обозначена как '''''Jakobi-Rotation<math>(A,j,k)</math>'''''

=== Схема реализации последовательного алгоритма ===
Алгоритм можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246-248)</ref>:

repeat
выбрать пару индексов j,k
обратиться к процедуре '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
пока <math>A</math> не достаточно близка к диагональной матрице

Существует несколько способов выбора пары <math>j,k</math>. Наиболее простой и быстрый способ — построчный циклический обход внедиагональных элементов матрицы <math>A</math>:

repeat
for <math>j=1</math> to <math>n-1</math>
for <math>k=j+1</math> to <math>n</math>
выполнить процедуру '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
end for
end for
пока <math>A</math> не достаточно близка к диагональной матрице

Процедура '''''Jakobi-Rotation<math>(A,j,k)</math>''''' — это следующий алгоритм:
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\,t \\
A &= R^T(j,k,\theta)\cdot A\cdot R(j,k,\theta), \qquad J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}</math>
end if

=== Последовательная сложность алгоритма ===

Для осуществления одной итерации метода Якоби для матрицы размера <math>(n\,x\,n)</math> требуется выполнить:

Для вычислительного ядра —
* <math> 4n+4 </math> умножений,
* <math> 2n+2 </math> сложений.

Для остальной части алгоритма —
* <math> 3 </math> умножения,
* <math> 3 </math> деления,
* <math> 5 </math> сложений (вычитаний),
* <math> 2 </math> извлечения квадратного корня.

Умножения и сложения (вычитания) составляют основную часть алгоритма.

Так как выбор индексов <math>j</math> и <math>k</math> осуществляется путем перебора внедиагональных элементов матрицы, для полного прохода потребуется <math>\frac{n(n-1)}{2}</math> итераций.

Таким образом, при классификации по последовательной сложности метод Якоби вычисления собственных значений симметричной матрицы относится к алгоритмам с кубической сложностью.

=== Информационный граф ===

Граф алгоритма состоит из трёх групп вершин.

'''Первой''' группе вершин (J) соответствует вычисление значений c и s.

'''Второй''' группе вершин (А) соответствует вычисление значений элементов <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>.

'''Третьей''' группе вершин (B) соответствует вычисление значений элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>.

<center>
<div class="thumb">
<div class="thumbinner" style="width:{{#expr: 3 * (400 + 35) + 4 * (3 - 1) + 8}}px">
<gallery widths=400px heights=400px>
File:Информационный_граф_метода_якоби.png|Рисунок 1. Граф одной итерации алгоритма без отображения входных и выходных данных.
File:ГрафJ.png|Рисунок 2. Внутренний граф вершин J с входными параметрами <math>x = a_{jj}^{(i)}, y = a_{kk}^{(i)}, z = a_{jk}^{(i)}</math>.
</gallery>
</div>
</div>
</center>

=== Ресурс параллелизма алгоритма ===

Для выполнения одной итерации требуется последовательно выполнить следующие действия:
# вычислить <math>\tau</math> (2 операции сложения, 1 операция деления)
# вычислить <math>t</math> (1 операция сравнения, 1 операция взятия модуля, 2 операции сложения, 1 операция умножения, 1 операция деления, 1 операция извлечения квадратного корня)
# вычислить <math>c</math> (1 операция сложения, 1 операция умножения, 1 операция деления, 1 операция извлечения квадратного корня) и <math>s</math> (1 операция умножения)

После этого выполняется ярус, отвечающий за применение поворота к матрице <math>A</math> с параллельным выполнением <math>2(n-2)</math> операций вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math> , а также 2 операций вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>. Наибольшее количество операций содержится в вычислении последних двух элементов (по 6 умножений и 3 сложения).

Количество итераций зависит от входных данных, однако асимптотически метод сходится квадратично<ref>J. H. Wilkinson. The Algebraic Eigenvalue Problem. Oxford University Press, UK, 1965. (стр 270)</ref>. Нередко для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 248)</ref>.

Таким образом, при классификации по высоте ЯПФ метод Якоби относится к алгоритмам со сложностью <math>O(n^2)</math> , а при классификации по ширине ЯПФ — к алгоритмам со сложностью <math>O(n)</math>.

=== Входные и выходные данные алгоритма ===

'''Входные данные''': матрица <math>A</math> (элементы <math>a_{ij}</math>).
Дополнительные ограничения:
* <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы). В разных реализациях эта экономия хранения может быть выполнена разным образом.

'''Выходные данные''': вектор собственных значений <math>\Lambda</math> (элементы <math>\lambda_{ii}</math>).

'''Объём выходных данных''': <math> n </math>.

=== Свойства алгоритма ===

Соотношение последовательной и параллельной сложности в случае неограниченных ресурсов для метода Якоби является линейным, вычислительная мощность алгоритма также линейна.

Метод Якоби не детерминирован, так как является итерационным алгоритмом с выходом по точности: число итераций зависит от входных данных и порогового значения.

Дуги информационного графа, исходящие из вершин, соответствующих вычислениям значений <math>c</math> и <math>s</math>, образуют пучки рассылок линейной мощности.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

== Литература ==

<references \>

Участник:Galkina/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-14T09:55:08Z

Игорь: /* Ресурс параллелизма алгоритма */

{{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>
}}

Авторы описания: [[Участник: Galkina|А.С.Галкина]], [[Участник: Игорь|И.А.Плахов]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Метод Якоби — итерационный алгоритм для вычисления собственных значений и собственных векторов вещественной симметричной матрицы. Карл Густав Якоб Якоби, в честь которого назван этот метод, предложил его в 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>Golub, G.H. (2000). «Eigenvalue computation in the 20th century». Journal of Computational and Applied Mathematics 123 (1-2): 35–65. DOI:[https://dx.doi.org/10.1016%2FS0377-0427%2800%2900413-1 10.1016/S0377-0427(00)00413-1].</ref>.
Суть алгоритма заключается в том, чтобы по заданной симметрической матрице <math>A = A_0</math> построить последовательность ортогонально подобных матриц <math>A_1,A_2,\dotsc,A_m</math>, сходящуюся к диагональной матрице, на диагонали которой стоят собственные значения. Для построения этой последовательности применяется специально подобранная матрица поворота <math>J_i</math>, такая что норма наддиагональной части <math>of\!f(A)=\sqrt{\sum\limits_{1 \le j < k \le n} a_{jk}^2}</math> уменьшается при каждом повороте матрицы <math>A</math>. Вычисление останавливается, когда угол поворота становится близок к нулю, либо когда максимальный внедиагональный элемент становится меньше заранее выбранного порогового значения.

=== Математическое описание алгоритма ===
Исходные данные: симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>).

Матрица <math>A_{i+1}</math> получается из <math>A_i</math> по формуле <math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math>J_i</math> — ортогональная матрица, называемая ''вращением Якоби''.
При подходящем выборе <math>J_i</math> матрица <math>A_m</math> для больших m будет близка к диагональной матрице <math>\Lambda</math>.

Матрица <math>J_i</math> выбирается так, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}</math><ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>.



                                                
<math>j</math>
                       
<math>k</math>

<math>
J_i = R(j,k,\theta) =
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & -\sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>. Тогда матрица <math>A_{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)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Можно выбрать <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>. Отсюда получим равенство

: <math> \frac{a_{jj}^{(i)} - a_{kk}^{(i)}}{2 a_{jk}^{(i)}} = \frac{c^2 - s^2}{2sc} = \frac{\cos 2\theta}{\sin 2\theta} = \operatorname{tg}(2\theta) \equiv \tau </math>.

Положим <math>t = \frac{s}{c} = \operatorname{ctg}(\theta)</math> и заметим, что <math>t^2 - 2t\tau + 1 = 0</math>. Решая квадратное уравнение, находим <math>t = \frac{\operatorname{sign}(\tau)}{|\tau| + \sqrt{1+\tau^2}}, c = \frac{1}{\sqrt{1+t^2}}, s = tc</math>.

Выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро составляют множественные вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>   в процессе применения матрицы поворота <math>J</math> к матрице <math>A</math>:
: <math>\begin{align}
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k,
\end{align}</math>

каждое из которых повторяется по <math> (n-2) </math> раза, а также вычисление элементов <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>

=== Макроструктура алгоритма ===
Основную часть метода составляет процедура применения вращения к матрице <math>A</math>, которая в дальнейшем будет обозначена как '''''Jakobi-Rotation<math>(A,j,k)</math>'''''

=== Схема реализации последовательного алгоритма ===
Алгоритм можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246-248)</ref>:

repeat
выбрать пару индексов j,k
обратиться к процедуре '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
пока <math>A</math> не достаточно близка к диагональной матрице

Существует несколько способов выбора пары <math>j,k</math>. Наиболее простой и быстрый способ — построчный циклический обход внедиагональных элементов матрицы <math>A</math>:

repeat
for <math>j=1</math> to <math>n-1</math>
for <math>k=j+1</math> to <math>n</math>
выполнить процедуру '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
end for
end for
пока <math>A</math> не достаточно близка к диагональной матрице

Процедура '''''Jakobi-Rotation<math>(A,j,k)</math>''''' — это следующий алгоритм:
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\,t \\
A &= R^T(j,k,\theta)\cdot A\cdot R(j,k,\theta), \qquad J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}</math>
end if

=== Последовательная сложность алгоритма ===

Для вычисления собственных значений вещественной симметричной матрицы порядка n методом Якоби требуется:

Для вычислительного ядра —
* <math> 2\,n^2\,(n-1) </math> умножений,
* <math> \frac{n(n-1)(2n+1)}{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> операций извлечения квадратного корня.

Умножения и сложения (вычитания) составляют основную часть алгоритма.

Таким образом, при классификации по последовательной сложности метод Якоби вычисления собственных значений симметричной матрицы относится к алгоритмам с кубической сложностью.

=== Информационный граф ===

Граф алгоритма состоит из трёх групп вершин.

'''Первой''' группе вершин (J) соответствует вычисление значений c и s.

'''Второй''' группе вершин (А) соответствует вычисление значений элементов <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>.

'''Третьей''' группе вершин (B) соответствует вычисление значений элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>.

<center>
<div class="thumb">
<div class="thumbinner" style="width:{{#expr: 3 * (400 + 35) + 4 * (3 - 1) + 8}}px">
<gallery widths=400px heights=400px>
File:Информационный_граф_метода_якоби.png|Рисунок 1. Граф одной итерации алгоритма без отображения входных и выходных данных.
File:ГрафJ.png|Рисунок 2. Внутренний граф вершин J с входными параметрами <math>x = a_{jj}^{(i)}, y = a_{kk}^{(i)}, z = a_{jk}^{(i)}</math>.
</gallery>
</div>
</div>
</center>

=== Ресурс параллелизма алгоритма ===

Для выполнения одной итерации требуется последовательно выполнить следующие действия:
# вычислить <math>\tau</math> (2 операции сложения, 1 операция деления)
# вычислить <math>t</math> (1 операция сравнения, 1 операция взятия модуля, 2 операции сложения, 1 операция умножения, 1 операция деления, 1 операция извлечения квадратного корня)
# вычислить <math>c</math> (1 операция сложения, 1 операция умножения, 1 операция деления, 1 операция извлечения квадратного корня) и <math>s</math> (1 операция умножения)

После этого выполняется ярус, отвечающий за применение поворота к матрице <math>A</math> с параллельным выполнением <math>2(n-2)</math> операций вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math> , а также 2 операций вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>. Наибольшее количество операций содержится в вычислении последних двух элементов (по 6 умножений и 3 сложения).

Количество итераций зависит от входных данных, однако асимптотически метод сходится квадратично<ref>J. H. Wilkinson. The Algebraic Eigenvalue Problem. Oxford University Press, UK, 1965. (стр 270)</ref>. Нередко для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 248)</ref>.

Таким образом, при классификации по высоте ЯПФ метод Якоби относится к алгоритмам со сложностью <math>O(n^2)</math> , а при классификации по ширине ЯПФ — к алгоритмам со сложностью <math>O(n)</math>.

=== Входные и выходные данные алгоритма ===

'''Входные данные''': матрица <math>A</math> (элементы <math>a_{ij}</math>).
Дополнительные ограничения:
* <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы). В разных реализациях эта экономия хранения может быть выполнена разным образом.

'''Выходные данные''': вектор собственных значений <math>\Lambda</math> (элементы <math>\lambda_{ii}</math>).

'''Объём выходных данных''': <math> n </math>.

=== Свойства алгоритма ===

Соотношение последовательной и параллельной сложности в случае неограниченных ресурсов для метода Якоби является линейным, вычислительная мощность алгоритма также линейна.

Метод Якоби не детерминирован, так как является итерационным алгоритмом с выходом по точности: число итераций зависит от входных данных и порогового значения.

Дуги информационного графа, исходящие из вершин, соответствующих вычислениям значений <math>c</math> и <math>s</math>, образуют пучки рассылок линейной мощности.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

== Литература ==

<references \>

Участник:Galkina/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-13T14:59:24Z

Игорь: /* Свойства алгоритма */

Участник:Galkina/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-13T14:17:58Z

Игорь:

Участник:Galkina/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-13T13:54:00Z

Игорь:

Основные авторы описания: [[Участник: Galkina|А.С.Галкина]], [[Участник: Игорь|И.А.Плахов]]
{{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>
}}
== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Метод Якоби — итерационный алгоритм для вычисления собственных значений и собственных векторов вещественной симметричной матрицы. Карл Густав Якоб Якоби, в честь которого назван этот метод, предложил его в 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>Golub, G.H. (2000). «Eigenvalue computation in the 20th century». Journal of Computational and Applied Mathematics 123 (1-2): 35–65. DOI:[https://dx.doi.org/10.1016%2FS0377-0427%2800%2900413-1 10.1016/S0377-0427(00)00413-1].</ref>.
Суть алгоритма заключается в том, чтобы по заданной симметрической матрице <math>A = A_0</math> построить последовательность ортогонально подобных матриц <math>A_1,A_2,\dotsc,A_m</math>, сходящуюся к диагональной матрице, на диагонали которой стоят собственные значения. Для построения этой последовательности применяется специально подобранная матрица поворота <math>J_i</math>, такая что норма наддиагональной части <math>of\!f(A)=\sqrt{\sum\limits_{1 \le j < k \le n} a_{jk}^2}</math> уменьшается при каждом повороте матрицы <math>A</math>. Вычисление останавливается, когда угол поворота становится близок к нулю, либо когда максимальный внедиагональный элемент становится меньше заранее выбранного порогового значения.

=== Математическое описание алгоритма ===
Исходные данные: симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>).

Матрица <math>A_{i+1}</math> получается из <math>A_i</math> по формуле <math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math>J_i</math> — ортогональная матрица, называемая ''вращением Якоби''.
При подходящем выборе <math>J_i</math> матрица <math>A_m</math> для больших m будет близка к диагональной матрице <math>\Lambda</math>.

Матрица <math>J_i</math> выбирается так, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}</math><ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>.



                                                
<math>j</math>
                       
<math>k</math>

<math>
J_i =
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & -\sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>. Тогда матрица <math>A_{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)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Можно выбрать <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>. Отсюда получим равенство

: <math> \frac{a_{jj}^{(i)} - a_{kk}^{(i)}}{2 a_{jk}^{(i)}} = \frac{c^2 - s^2}{2sc} = \frac{\cos 2\theta}{\sin 2\theta} = \operatorname{tg}(2\theta) \equiv \tau </math>.

Положим <math>t = \frac{s}{c} = \operatorname{ctg}(\theta)</math> и заметим, что <math>t^2 - 2t\tau + 1 = 0</math>. Решая квадратное уравнение, находим <math>t = \frac{\operatorname{sign}(\tau)}{|\tau| + \sqrt{1+\tau^2}}, c = \frac{1}{\sqrt{1+t^2}}, s = tc</math>.

Выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро составляют множественные вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>   в процессе применения матрицы поворота <math>J</math> к матрице <math>A</math>:
: <math>\begin{align}
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k,
\end{align}</math>

каждое из которых повторяется по <math> (n-2) </math> раза, а также вычисление элементов <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>

=== Макроструктура алгоритма ===
Основную часть метода составляет процедура применения вращения к матрице <math>A</math>, которая в дальнейшем будет обозначена как '''''Jakobi-Rotation<math>(A,j,k)</math>'''''

=== Схема реализации последовательного алгоритма ===
Алгоритм можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246-248)</ref>:
repeat
for <math>j=1</math> to <math>n-1</math>
for <math>k=j+1</math> to <math>n</math>
выполнить процедуру '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
end for
end for
пока <math>A</math> не достаточно близка к диагональной матрице

Процедура '''''Jakobi-Rotation<math>(A,j,k)</math>''''' — это следующий алгоритм:
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\,t \\
A &= R^T(j,k,\theta)\cdot A\cdot R(j,k,\theta), \qquad J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}</math>
end if

=== Последовательная сложность алгоритма ===

Для вычисления собственных значений вещественной симметричной матрицы порядка n методом Якоби требуется:

Для вычислительного ядра —
* <math> 2\,n^2\,(n-1) </math> умножений,
* <math> \frac{n(n-1)(2n+1)}{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>\tau</math> (2 операции сложения, 1 операция деления)
# вычислить <math>t</math> (1 операция сравнения, 1 операция взятия модуля, 2 операции сложения, 1 операция умножения, 1 операция деления, 1 операция извлечения квадратного корня)
# вычислить <math>c</math> (1 операция сложения, 1 операция умножения, 1 операция деления, 1 операция извлечения квадратного корня) и <math>s</math> (1 операция умножения)

После этого выполняется ярус, отвечающий за применение поворота к матрице <math>A</math> с параллельным выполнением <math>2(n-2)</math> операций вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math> , а также 2 операций вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>. Наибольшее количество операций содержится в вычислении последних двух элементов (по 6 умножений и 3 сложения). ''Либо можно считать эти элементы совместно, тогда получится в сумме 8 умножений и 5 сложений, но не знаю, стоит ли этим заморачиваться''.

Количество итераций зависит от входных данных, однако асимптотиески метод сходится квадратично<ref>J. H. Wilkinson. The Algebraic Eigenvalue Problem. Oxford University Press, UK, 1965. (стр 270)</ref>. Нередко для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 248)</ref>.

Таким образом, при классификации по высоте ЯПФ метод Якоби относится к алгоритмам со сложностью <math>O(n^2)</math> , а при классификации по ширине ЯПФ — к алгоритмам со сложностью <math>O(n)</math>.

=== Входные и выходные данные алгоритма ===

'''Входные данные''': матрица <math>A</math> (элементы <math>a_{ij}</math>).
Дополнительные ограничения:
* <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы). В разных реализациях эта экономия хранения может быть выполнена разным образом.

'''Выходные данные''': вектор собственных значений <math>\Lambda</math> (элементы <math>\lambda_{ii}</math>).

'''Объём выходных данных''': <math> n </math>.

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Масштабируемость алгоритма и его реализации ===

=== Существующие реализации алгоритма ===

== Литература ==

<references \>

Участник:Galkina/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-13T12:28:12Z

Игорь: /* Ресурс параллелизма алгоритма */

Основные авторы описания: [[Участник: Galkina|А.С.Галкина]], [[Участник: Игорь|И.А.Плахов]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Метод Якоби — итерационный алгоритм для вычисления собственных значений и собственных векторов вещественной симметричной матрицы. Карл Густав Якоб Якоби, в честь которого назван этот метод, предложил его в 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>Golub, G.H. (2000). «Eigenvalue computation in the 20th century». Journal of Computational and Applied Mathematics 123 (1-2): 35–65. DOI:[https://dx.doi.org/10.1016%2FS0377-0427%2800%2900413-1 10.1016/S0377-0427(00)00413-1].</ref>.
Суть алгоритма заключается в том, чтобы по заданной симметрической матрице <math>A = A_0</math> построить последовательность ортогонально подобных матриц <math>A_1,A_2,...</math>. Эта последовательность сходится к диагональной матрице, на диагонали которой стоят собственные значения.

=== Математическое описание алгоритма ===
Исходные данные: симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>).

Матрица <math>A_{i+1}</math> получается из <math>A_i</math> по формуле <math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math>J_i</math> — ортогональная матрица, называемая ''вращением Якоби''.
При подходящем выборе <math>J_i</math> матрица <math>A_m</math> для больших m будет близка к диагональной матрице <math>\Lambda</math>.

Матрица <math>J_i</math> выбирается так, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}</math><ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>.



                                                
<math>j</math>
                       
<math>k</math>

<math>
J_i =
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & -\sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>. Тогда матрица <math>A_{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)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Можно выбрать <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>. Отсюда получим равенство

: <math> \frac{a_{jj}^{(i)} - a_{kk}^{(i)}}{2 a_{jk}^{(i)}} = \frac{c^2 - s^2}{2sc} = \frac{\cos 2\theta}{\sin 2\theta} = \operatorname{tg}(2\theta) \equiv \tau </math>.

Положим <math>t = \frac{s}{c} = \operatorname{ctg}(\theta)</math> и заметим, что <math>t^2 - 2t\tau + 1 = 0</math>. Решая квадратное уравнение, находим <math>t = \frac{\operatorname{sign}(\tau)}{|\tau| + \sqrt{1+\tau^2}}, c = \frac{1}{\sqrt{1+t^2}}, s = tc</math>.

Выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро составляют множественные вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>   в процессе применения матрицы поворота <math>J</math> к матрице <math>A</math>:
: <math>\begin{align}
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k,
\end{align}</math>

каждое из которых повторяется по <math> (n-2) </math> раза, а также вычисление элементов <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>

=== Макроструктура алгоритма ===
Основную часть метода составляет процедура применения вращения к матрице <math>A</math>, которая в дальнейшем будет обозначена как '''''Jakobi-Rotation<math>(A,j,k)</math>'''''

=== Схема реализации последовательного алгоритма ===
Алгоритм можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246-248)</ref>:
repeat
for <math>j=1</math> to <math>n-1</math>
for <math>k=j+1</math> to <math>n</math>
выполнить процедуру '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
end for
end for
пока <math>A</math> не достаточно близка к диагональной матрице

Процедура '''''Jakobi-Rotation<math>(A,j,k)</math>''''' — это следующий алгоритм:
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\,t \\
A &= R^T(j,k,\theta)\cdot A\cdot R(j,k,\theta), \qquad J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}</math>
end if

=== Последовательная сложность алгоритма ===

Для вычисления собственных значений вещественной симметричной матрицы порядка n методом Якоби требуется:

Для вычислительного ядра —
* <math> 2\,n^2\,(n-1) </math> умножений,
* <math> \frac{n(n-1)(2n+1)}{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>\tau</math> (2 операции сложения, 1 операция деления)
# вычислить <math>t</math> (1 операция сравнения, 1 операция взятия модуля, 2 операции сложения, 1 операция умножения, 1 операция деления, 1 операция извлечения квадратного корня)
# вычислить <math>c</math> (1 операция сложения, 1 операция умножения, 1 операция деления, 1 операция извлечения квадратного корня) и <math>s</math> (1 операция умножения)

После этого выполняется ярус, отвечающий за применение поворота к матрице <math>A</math> с параллельным выполнением <math>2(n-2)</math> операций вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math> , а также 2 операций вычисления элементов <math>a_{jj}^{(i+1)} </math>   и   <math>a_{kk}^{(i+1)} </math>. Наибольшее количество операций содержится в вычислении последних двух элементов (по 6 умножений и 3 сложения). ''Либо можно считать эти элементы совместно, тогда получится в сумме 8 умножений и 5 сложений, но не знаю, стоит ли этим заморачиваться''.

Количество итераций зависит от входных данных, однако асимптотиески метод сходится квадратично<ref>J. H. Wilkinson. The Algebraic Eigenvalue Problem. Oxford University Press, UK, 1965. (стр 270)</ref>. Нередко для сходимости метода Якоби требуется от 5 до 10 циклов, что хуже, чем у конкурирующих алгоритмов<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 248)</ref>.

Таким образом, при классификации по высоте ЯПФ метод Якоби относится к алгоритмам со сложностью <math>O(n^2)</math> , а при классификации по ширине ЯПФ — к алгоритмам со сложностью <math>O(n)</math>.

=== Входные и выходные данные алгоритма ===

'''Входные данные''': матрица <math>A</math> (элементы <math>a_{ij}</math>).
Дополнительные ограничения:
* <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы). В разных реализациях эта экономия хранения может быть выполнена разным образом.

'''Выходные данные''': вектор собственных значений <math>\Lambda</math> (элементы <math>\lambda_{ii}</math>).

'''Объём выходных данных''': <math> n </math>.

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Масштабируемость алгоритма и его реализации ===

=== Существующие реализации алгоритма ===

== Литература ==

<references \>

Участник:Galkina/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-12T17:29:20Z

Игорь: /* Последовательная сложность алгоритма */

Основные авторы описания: [[Участник: Galkina|А.С.Галкина]], [[Участник: Игорь|И.А.Плахов]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Метод Якоби — итерационный алгоритм для вычисления собственных значений и собственных векторов вещественной симметричной матрицы. Карл Густав Якоб Якоби, в честь которого назван этот метод, предложил его в 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>Golub, G.H. (2000). «Eigenvalue computation in the 20th century». Journal of Computational and Applied Mathematics 123 (1-2): 35–65. DOI:[https://dx.doi.org/10.1016%2FS0377-0427%2800%2900413-1 10.1016/S0377-0427(00)00413-1].</ref>.
Суть алгоритма заключается в том, чтобы по заданной симметрической матрице <math>A = A_0</math> построить последовательность ортогонально подобных матриц <math>A_1,A_2,...</math>. Эта последовательность сходится к диагональной матрице, на диагонали которой стоят собственные значения.

=== Математическое описание алгоритма ===
Исходные данные: симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>).

Матрица <math>A_{i+1}</math> получается из <math>A_i</math> по формуле <math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math>J_i</math> — ортогональная матрица, называемая ''вращением Якоби''.
При подходящем выборе <math>J_i</math> матрица <math>A_m</math> для больших m будет близка к диагональной матрице <math>\Lambda</math>.

Матрица <math>J_i</math> выбирается так, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}</math><ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>.



                                                
<math>j</math>
                       
<math>k</math>

<math>
J_i =
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & -\sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>. Тогда матрица <math>A_{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)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Можно выбрать <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>. Отсюда получим равенство

: <math> \frac{a_{jj}^{(i)} - a_{kk}^{(i)}}{2 a_{jk}^{(i)}} = \frac{c^2 - s^2}{2sc} = \frac{\cos 2\theta}{\sin 2\theta} = \operatorname{tg}(2\theta) \equiv \tau </math>.

Положим <math>t = \frac{s}{c} = \operatorname{ctg}(\theta)</math> и заметим, что <math>t^2 - 2t\tau + 1 = 0</math>. Решая квадратное уравнение, находим <math>t = \frac{\operatorname{sign}(\tau)}{|\tau| + \sqrt{1+\tau^2}}, c = \frac{1}{\sqrt{1+t^2}}, s = tc</math>.

Выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро составляют множественные вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>   в процессе применения матрицы поворота <math>J</math> к матрице <math>A</math>:
: <math>\begin{align}
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k,
\end{align}</math>

каждое из которых повторяется по <math> (n-2) </math> раза, а также вычисление элементов <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>

=== Макроструктура алгоритма ===
Основную часть метода составляет процедура применения вращения к матрице <math>A</math>, которая в дальнейшем будет обозначена как '''''Jakobi-Rotation<math>(A,j,k)</math>'''''

=== Схема реализации последовательного алгоритма ===
Алгоритм можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246-248)</ref>:
repeat
for <math>j=1</math> to <math>n-1</math>
for <math>k=j+1</math> to <math>n</math>
выполнить процедуру '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
end for
end for
пока <math>A</math> не достаточно близка к диагональной матрице

Процедура '''''Jakobi-Rotation<math>(A,j,k)</math>''''' — это следующий алгоритм:
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\,t \\
A &= R^T(j,k,\theta)\cdot A\cdot R(j,k,\theta), \qquad J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}</math>
end if

=== Последовательная сложность алгоритма ===

Для вычисления собственных значений вещественной симметричной матрицы порядка n методом Якоби требуется:

Для вычислительного ядра —
* <math> 2\,n^2\,(n-1) </math> умножений,
* <math> \frac{n(n-1)(2n+1)}{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</math> (элементы <math>a_{ij}</math>).
Дополнительные ограничения:
* <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы). В разных реализациях эта экономия хранения может быть выполнена разным образом.

'''Выходные данные''': диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ii}</math>).

'''Объём выходных данных''': <math> n </math> (достаточно хранить только диагональные элементы).

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Масштабируемость алгоритма и его реализации ===

=== Существующие реализации алгоритма ===

== Литература ==

<references \>

Участник:Galkina/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-12T17:14:31Z

Игорь: /* Вычислительное ядро алгоритма */

Основные авторы описания: [[Участник: Galkina|А.С.Галкина]], [[Участник: Игорь|И.А.Плахов]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Метод Якоби — итерационный алгоритм для вычисления собственных значений и собственных векторов вещественной симметричной матрицы. Карл Густав Якоб Якоби, в честь которого назван этот метод, предложил его в 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>Golub, G.H. (2000). «Eigenvalue computation in the 20th century». Journal of Computational and Applied Mathematics 123 (1-2): 35–65. DOI:[https://dx.doi.org/10.1016%2FS0377-0427%2800%2900413-1 10.1016/S0377-0427(00)00413-1].</ref>.
Суть алгоритма заключается в том, чтобы по заданной симметрической матрице <math>A = A_0</math> построить последовательность ортогонально подобных матриц <math>A_1,A_2,...</math>. Эта последовательность сходится к диагональной матрице, на диагонали которой стоят собственные значения.

=== Математическое описание алгоритма ===
Исходные данные: симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>).

Матрица <math>A_{i+1}</math> получается из <math>A_i</math> по формуле <math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math>J_i</math> — ортогональная матрица, называемая ''вращением Якоби''.
При подходящем выборе <math>J_i</math> матрица <math>A_m</math> для больших m будет близка к диагональной матрице <math>\Lambda</math>.

Матрица <math>J_i</math> выбирается так, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}</math><ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>.



                                                
<math>j</math>
                       
<math>k</math>

<math>
J_i =
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & -\sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>. Тогда матрица <math>A_{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)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Можно выбрать <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>. Для этого запишем равенство

: <math> \begin{bmatrix}
a_{jj}^{(i+1)} & a_{jk}^{(i+1)} \\
a_{kj}^{(i+1)} & a_{kk}^{(i+1)}
\end{bmatrix}
=
\begin{bmatrix}
\cos(\theta) & -\sin(\theta) \\
\sin(\theta) & \cos(\theta)
\end{bmatrix}^T
\begin{bmatrix}
a_{jj}^{(i)} & a_{jk}^{(i)} \\
a_{kj}^{(i)} & a_{kk}^{(i)}
\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_{jj}^{(i+1)} & a_{jk}^{(i+1)} \\
a_{kj}^{(i+1)} & a_{kk}^{(i+1)}
\end{bmatrix} </math>

Опуская индекс <math>(i)</math>, с учетом симметрии получим:

: <math>
\begin{bmatrix}
\lambda_1 & 0 \\
0 & \lambda_2
\end{bmatrix}
=
\begin{bmatrix}
a_{jj}c^2 + a_{kk}s^2 + 2sca_{jk} & sc(a_{kk}-a_{jj})+a_{jk}(c^2-s^2) \\
sc(a_{kk}-a_{jj})+a_{jk}(c^2-s^2) & a_{jj}s^2 + a_{kk}c^2 - 2sca_{jk}
\end{bmatrix}
</math>

Приравнивая внедиагональный элемент нулю, получаем

: <math> \frac{a_{jj}^{(i)} - a_{kk}^{(i)}}{2 a_{jk}^{(i)}} = \frac{c^2 - s^2}{2sc} = \frac{\cos 2\theta}{\sin 2\theta} = \operatorname{tg}(2\theta) \equiv \tau </math>.

Положим <math>t = \frac{s}{c} = \operatorname{ctg}(\theta)</math> и заметим, что <math>t^2 - 2t\tau + 1 = 0</math>. Решая квадратное уравнение, находим <math>t = \frac{\operatorname{sign}(\tau)}{|\tau| + \sqrt{1+\tau^2}}, c = \frac{1}{\sqrt{1+t^2}}, s = tc</math>.

Выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро составляют множественные вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>   в процессе применения матрицы поворота <math>J</math> к матрице <math>A</math>:
: <math>\begin{align}
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k,
\end{align}</math>

каждое из которых повторяется по <math> (n-2) </math> раза, а также вычисление элементов <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>

=== Макроструктура алгоритма ===
Основную часть метода составляет процедура применения вращения к матрице <math>A</math>, которая в дальнейшем будет обозначена как '''''Jakobi-Rotation<math>(A,j,k)</math>'''''

=== Схема реализации последовательного алгоритма ===
Алгоритм можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246-248)</ref>:
repeat
for <math>j=1</math> to <math>n-1</math>
for <math>k=j+1</math> to <math>n</math>
выполнить процедуру '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
end for
end for
пока <math>A</math> не достаточно близка к диагональной матрице

Процедура '''''Jakobi-Rotation<math>(A,j,k)</math>''''' — это следующий алгоритм:
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\,t \\
A &= R^T(j,k,\theta)\cdot A\cdot R(j,k,\theta), \qquad J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}</math>
end if

=== Последовательная сложность алгоритма ===

Для вычисления собственных значений вещественной симметричной матрицы порядка n методом Якоби требуется:

Для вычислительного ядра —
* <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</math> (элементы <math>a_{ij}</math>).
Дополнительные ограничения:
* <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы). В разных реализациях эта экономия хранения может быть выполнена разным образом.

'''Выходные данные''': диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ii}</math>).

'''Объём выходных данных''': <math> n </math> (достаточно хранить только диагональные элементы).

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Масштабируемость алгоритма и его реализации ===

=== Существующие реализации алгоритма ===

== Литература ==

<references \>

Участник:Galkina/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-12T16:55:25Z

Игорь:

Основные авторы описания: [[Участник: Galkina|А.С.Галкина]], [[Участник: Игорь|И.А.Плахов]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Метод Якоби — итерационный алгоритм для вычисления собственных значений и собственных векторов вещественной симметричной матрицы. Карл Густав Якоб Якоби, в честь которого назван этот метод, предложил его в 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>Golub, G.H. (2000). «Eigenvalue computation in the 20th century». Journal of Computational and Applied Mathematics 123 (1-2): 35–65. DOI:[https://dx.doi.org/10.1016%2FS0377-0427%2800%2900413-1 10.1016/S0377-0427(00)00413-1].</ref>.
Суть алгоритма заключается в том, чтобы по заданной симметрической матрице <math>A = A_0</math> построить последовательность ортогонально подобных матриц <math>A_1,A_2,...</math>. Эта последовательность сходится к диагональной матрице, на диагонали которой стоят собственные значения.

=== Математическое описание алгоритма ===
Исходные данные: симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>).

Матрица <math>A_{i+1}</math> получается из <math>A_i</math> по формуле <math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math>J_i</math> — ортогональная матрица, называемая ''вращением Якоби''.
При подходящем выборе <math>J_i</math> матрица <math>A_m</math> для больших m будет близка к диагональной матрице <math>\Lambda</math>.

Матрица <math>J_i</math> выбирается так, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}</math><ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>.



                                                
<math>j</math>
                       
<math>k</math>

<math>
J_i =
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & -\sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>. Тогда матрица <math>A_{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)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Можно выбрать <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>. Для этого запишем равенство

: <math> \begin{bmatrix}
a_{jj}^{(i+1)} & a_{jk}^{(i+1)} \\
a_{kj}^{(i+1)} & a_{kk}^{(i+1)}
\end{bmatrix}
=
\begin{bmatrix}
\cos(\theta) & -\sin(\theta) \\
\sin(\theta) & \cos(\theta)
\end{bmatrix}^T
\begin{bmatrix}
a_{jj}^{(i)} & a_{jk}^{(i)} \\
a_{kj}^{(i)} & a_{kk}^{(i)}
\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_{jj}^{(i+1)} & a_{jk}^{(i+1)} \\
a_{kj}^{(i+1)} & a_{kk}^{(i+1)}
\end{bmatrix} </math>

Опуская индекс <math>(i)</math>, с учетом симметрии получим:

: <math>
\begin{bmatrix}
\lambda_1 & 0 \\
0 & \lambda_2
\end{bmatrix}
=
\begin{bmatrix}
a_{jj}c^2 + a_{kk}s^2 + 2sca_{jk} & sc(a_{kk}-a_{jj})+a_{jk}(c^2-s^2) \\
sc(a_{kk}-a_{jj})+a_{jk}(c^2-s^2) & a_{jj}s^2 + a_{kk}c^2 - 2sca_{jk}
\end{bmatrix}
</math>

Приравнивая внедиагональный элемент нулю, получаем

: <math> \frac{a_{jj}^{(i)} - a_{kk}^{(i)}}{2 a_{jk}^{(i)}} = \frac{c^2 - s^2}{2sc} = \frac{\cos 2\theta}{\sin 2\theta} = \operatorname{tg}(2\theta) \equiv \tau </math>.

Положим <math>t = \frac{s}{c} = \operatorname{ctg}(\theta)</math> и заметим, что <math>t^2 - 2t\tau + 1 = 0</math>. Решая квадратное уравнение, находим <math>t = \frac{\operatorname{sign}(\tau)}{|\tau| + \sqrt{1+\tau^2}}, c = \frac{1}{\sqrt{1+t^2}}, s = tc</math>.

Выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро составляют множественные вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>,   <math>m \ne j,k</math>   в процессе применения матрицы поворота <math>J</math> к матрице <math>A</math>:
: <math>\begin{align}
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
\end{align}</math>

каждое из которых повторяется по <math> (n-2) </math> раза.

=== Макроструктура алгоритма ===
Основную часть метода составляет процедура применения вращения к матрице <math>A</math>, которая в дальнейшем будет обозначена как '''''Jakobi-Rotation<math>(A,j,k)</math>'''''

=== Схема реализации последовательного алгоритма ===
Алгоритм можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246-248)</ref>:
repeat
for <math>j=1</math> to <math>n-1</math>
for <math>k=j+1</math> to <math>n</math>
выполнить процедуру '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
end for
end for
пока <math>A</math> не достаточно близка к диагональной матрице

Процедура '''''Jakobi-Rotation<math>(A,j,k)</math>''''' — это следующий алгоритм:
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\,t \\
A &= R^T(j,k,\theta)\cdot A\cdot R(j,k,\theta), \qquad J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}</math>
end if

=== Последовательная сложность алгоритма ===

Для вычисления собственных значений вещественной симметричной матрицы порядка n методом Якоби требуется:

Для вычислительного ядра —
* <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</math> (элементы <math>a_{ij}</math>).
Дополнительные ограничения:
* <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы). В разных реализациях эта экономия хранения может быть выполнена разным образом.

'''Выходные данные''': диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ii}</math>).

'''Объём выходных данных''': <math> n </math> (достаточно хранить только диагональные элементы).

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Масштабируемость алгоритма и его реализации ===

=== Существующие реализации алгоритма ===

== Литература ==

<references \>

Участник:Galkina/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-12T16:46:05Z

Игорь:

Основные авторы описания: [[Участник: Galkina|А.С.Галкина]], [[Участник: Игорь|И.А.Плахов]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Метод Якоби — итерационный алгоритм для вычисления собственных значений и собственных векторов вещественной симметричной матрицы. Карл Густав Якоб Якоби, в честь которого назван этот метод, предложил его в 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>Golub, G.H. (2000). «Eigenvalue computation in the 20th century». Journal of Computational and Applied Mathematics 123 (1-2): 35–65. DOI:[https://dx.doi.org/10.1016%2FS0377-0427%2800%2900413-1 10.1016/S0377-0427(00)00413-1].</ref>.
Суть алгоритма заключается в том, чтобы по заданной симметрической матрице <math>A = A_0</math> построить последовательность ортогонально подобных матриц <math>A_1,A_2,...</math>. Эта последовательность сходится к диагональной матрице, на диагонали которой стоят собственные значения.

=== Математическое описание алгоритма ===
Исходные данные: симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>).

Матрица <math>A_{i+1}</math> получается из <math>A_i</math> по формуле <math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math>J_i</math> — ортогональная матрица, называемая ''вращением Якоби''.
При подходящем выборе <math>J_i</math> матрица <math>A_m</math> для больших m будет близка к диагональной матрице <math>\Lambda</math>.

Матрица <math>J_i</math> выбирается так, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}</math><ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>.



                                                
<math>j</math>
                       
<math>k</math>

<math>
J_i =
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & -\sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>. Тогда матрица <math>A_{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)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Можно выбрать <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>. Для этого запишем равенство

: <math> \begin{bmatrix}
a_{jj}^{(i+1)} & a_{jk}^{(i+1)} \\
a_{kj}^{(i+1)} & a_{kk}^{(i+1)}
\end{bmatrix}
=
\begin{bmatrix}
\cos(\theta) & -\sin(\theta) \\
\sin(\theta) & \cos(\theta)
\end{bmatrix}^T
\begin{bmatrix}
a_{jj}^{(i)} & a_{jk}^{(i)} \\
a_{kj}^{(i)} & a_{kk}^{(i)}
\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_{jj}^{(i+1)} & a_{jk}^{(i+1)} \\
a_{kj}^{(i+1)} & a_{kk}^{(i+1)}
\end{bmatrix} </math>

Опуская индекс <math>(i)</math>, с учетом симметрии получим:

: <math>
\begin{bmatrix}
\lambda_1 & 0 \\
0 & \lambda_2
\end{bmatrix}
=
\begin{bmatrix}
a_{jj}c^2 + a_{kk}s^2 + 2sca_{jk} & sc(a_{kk}-a_{jj})+a_{jk}(c^2-s^2) \\
sc(a_{kk}-a_{jj})+a_{jk}(c^2-s^2) & a_{jj}s^2 + a_{kk}c^2 - 2sca_{jk}
\end{bmatrix}
</math>

Приравнивая внедиагональный элемент нулю, получаем

: <math> \frac{a_{jj}^{(i)} - a_{kk}^{(i)}}{2 a_{jk}^{(i)}} = \frac{c^2 - s^2}{2sc} = \frac{\cos 2\theta}{\sin 2\theta} = \operatorname{tg}(2\theta) \equiv \tau </math>.

Положим <math>t = \frac{s}{c} = \operatorname{ctg}(\theta)</math> и заметим, что <math>t^2 - 2t\tau + 1 = 0</math>. Решая квадратное уравнение, находим <math>t = \frac{\operatorname{sign}(\tau)}{|\tau| + \sqrt{1+\tau^2}}, c = \frac{1}{\sqrt{1+t^2}}, s = tc</math>.

Выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро составляют множественные вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>   в процессе применения матрицы поворота <math>J</math> к матрице <math>A</math>:
: <math>\begin{align}
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
\end{align}</math>

каждое из которых повторяется по <math> (n-2) </math> раза.

=== Макроструктура алгоритма ===
Основную часть метода составляет процедура применения вращения к матрице <math>A</math>, которая в дальнейшем будет обозначена как '''''Jakobi-Rotation<math>(A,j,k)</math>'''''

=== Схема реализации последовательного алгоритма ===
Алгоритм можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246-248)</ref>:
repeat
for <math>j=1</math> to <math>n-1</math>
for <math>k=j+1</math> to <math>n</math>
выполнить процедуру '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
end for
end for
пока <math>A</math> не достаточно близка к диагональной матрице

Процедура '''''Jakobi-Rotation<math>(A,j,k)</math>''''' — это следующий алгоритм:
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\,t \\
A &= R^T(j,k,\theta)\cdot A\cdot R(j,k,\theta), \qquad J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}</math>
end if

=== Последовательная сложность алгоритма ===

Для вычисления собственных значений вещественной симметричной матрицы порядка n методом Якоби требуется:

Для вычислительного ядра —
* <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</math> (элементы <math>a_{ij}</math>).
Дополнительные ограничения:
* <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы). В разных реализациях эта экономия хранения может быть выполнена разным образом.

'''Выходные данные''': диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ii}</math>).

'''Объём выходных данных''': <math> n </math> (достаточно хранить только диагональные элементы).

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Масштабируемость алгоритма и его реализации ===

=== Существующие реализации алгоритма ===

== Литература ==

<references \>

Участник:Игорь

2016-10-12T16:45:04Z

Игорь: Новая страница: «Плахов Игорь Александрович, группа 614»

Плахов Игорь Александрович, группа 614

Участник:Galkina/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-10T20:42:41Z

Игорь:

Основные авторы описания: [[Участник: Galkina|А.С.Галкина]], [[Участник: Plahov|И.А.Плахов]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Метод Якоби — итерационный алгоритм для вычисления собственных значений и собственных векторов вещественной симметричной матрицы. Карл Густав Якоб Якоби, в честь которого назван этот метод, предложил его в 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>Golub, G.H. (2000). «Eigenvalue computation in the 20th century». Journal of Computational and Applied Mathematics 123 (1-2): 35–65. DOI:[https://dx.doi.org/10.1016%2FS0377-0427%2800%2900413-1 10.1016/S0377-0427(00)00413-1].</ref>.
Суть алгоритма заключается в том, чтобы по заданной симметрической матрице <math>A = A_0</math> построить последовательность ортогонально подобных матриц <math>A_1,A_2,...</math>. Эта последовательность сходится к диагональной матрице, на диагонали которой стоят собственные значения.

=== Математическое описание алгоритма ===
Исходные данные: симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>).

Матрица <math>A_{i+1}</math> получается из <math>A_i</math> по формуле <math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math>J_i</math> — ортогональная матрица, называемая ''вращением Якоби''.
При подходящем выборе <math>J_i</math> матрица <math>A_m</math> для больших m будет близка к диагональной матрице <math>\Lambda</math>.

Матрица <math>J_i</math> выбирается так, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}</math><ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 244-245)</ref>.



                                                
<math>j</math>
                       
<math>k</math>

<math>
J_i =
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & -\sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>. Тогда матрица <math>A_{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)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Можно выбрать <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>. Для этого запишем равенство

: <math> \begin{bmatrix}
a_{jj}^{(i+1)} & a_{jk}^{(i+1)} \\
a_{kj}^{(i+1)} & a_{kk}^{(i+1)}
\end{bmatrix}
=
\begin{bmatrix}
\cos(\theta) & -\sin(\theta) \\
\sin(\theta) & \cos(\theta)
\end{bmatrix}^T
\begin{bmatrix}
a_{jj}^{(i)} & a_{jk}^{(i)} \\
a_{kj}^{(i)} & a_{kk}^{(i)}
\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_{jj}^{(i+1)} & a_{jk}^{(i+1)} \\
a_{kj}^{(i+1)} & a_{kk}^{(i+1)}
\end{bmatrix} </math>

Опуская индекс <math>(i)</math>, с учетом симметрии получим:

: <math>
\begin{bmatrix}
\lambda_1 & 0 \\
0 & \lambda_2
\end{bmatrix}
=
\begin{bmatrix}
a_{jj}c^2 + a_{kk}s^2 + 2sca_{jk} & sc(a_{kk}-a_{jj})+a_{jk}(c^2-s^2) \\
sc(a_{kk}-a_{jj})+a_{jk}(c^2-s^2) & a_{jj}s^2 + a_{kk}c^2 - 2sca_{jk}
\end{bmatrix}
</math>

Приравнивая внедиагональный элемент нулю, получаем

: <math> \frac{a_{jj}^{(i)} - a_{kk}^{(i)}}{2 a_{jk}^{(i)}} = \frac{c^2 - s^2}{2sc} = \frac{\cos 2\theta}{\sin 2\theta} = \operatorname{tg}(2\theta) \equiv \tau </math>.

Положим <math>t = \frac{s}{c} = \operatorname{ctg}(\theta)</math> и заметим, что <math>t^2 - 2t\tau + 1 = 0</math>. Решая квадратное уравнение, находим <math>t = \frac{\operatorname{sign}(\tau)}{|\tau| + \sqrt{1+\tau^2}}, c = \frac{1}{\sqrt{1+t^2}}, s = tc</math>.

Выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро составляют множественные вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>   в процессе применения матрицы поворота <math>J</math> к матрице <math>A</math>:
: <math>\begin{align}
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
\end{align}</math>

каждое из которых повторяется по <math> (n-2) </math> раза.

=== Макроструктура алгоритма ===
Основную часть метода составляет процедура применения вращения к матрице <math>A</math>, которая в дальнейшем будет обозначена как '''''Jakobi-Rotation<math>(A,j,k)</math>'''''

=== Схема реализации последовательного алгоритма ===
Алгоритм можно описать следующим образом<ref>Дж. Деммель «Вычислительная линейная алгебра» (стр. 246-248)</ref>:
repeat
for <math>j=1</math> to <math>n-1</math>
for <math>k=j+1</math> to <math>n</math>
выполнить процедуру '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
end for
end for
пока <math>A</math> не достаточно близка к диагональной матрице

Процедура '''''Jakobi-Rotation<math>(A,j,k)</math>''''' — это следующий алгоритм:
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\,t \\
A &= R^T(j,k,\theta)\cdot A\cdot R(j,k,\theta), \qquad J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}</math>
end if

=== Последовательная сложность алгоритма ===

Для вычисления собственных значений вещественной симметричной матрицы порядка n методом Якоби требуется:

Для вычислительного ядра —
* <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</math> (элементы <math>a_{ij}</math>).
Дополнительные ограничения:
* <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы). В разных реализациях эта экономия хранения может быть выполнена разным образом.

'''Выходные данные''': диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ii}</math>).

'''Объём выходных данных''': <math> n </math> (достаточно хранить только диагональные элементы).

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Масштабируемость алгоритма и его реализации ===

=== Существующие реализации алгоритма ===

== Литература ==

<references \>

Участник:Galkina/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-10T20:15:58Z

Игорь:

Участник:Galkina/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-10T19:13:08Z

Игорь: /* Последовательная сложность алгоритма */

Основные авторы описания: [[Участник: Galkina|А.С.Галкина]], [[Участник: Plahov|И.А.Плахов]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Метод Якоби — итерационный алгоритм для вычисления собственных значений и собственных векторов вещественной симметричной матрицы. Карл Густав Якоб Якоби, в честь которого назван этот метод, предложил его в 1846 году, хотя использоваться он начал только в 1950-х годах с появлением компьютеров. Суть алгоритма заключается в том, чтобы по заданной симметрической матрице <math>A = A_0</math> построить последовательность ортогонально подобных матриц <math>A_1,A_2,...</math>. Эта последовательность сходится к диагональной матрице, на диагонали которой стоят собственные значения.

=== Математическое описание алгоритма ===
Исходные данные: симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>).

Матрица <math>A_{i+1}</math> получается из <math>A_i</math> по формуле <math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math>J_i</math> — ортогональная матрица, называемая ''вращением Якоби''.
При подходящем выборе <math>J_i</math> матрица <math>A_m</math> для больших m будет близка к диагональной матрице <math>\Lambda</math>.

Матрица <math>J_i</math> выбирается так, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}</math>.



                                                
<math>j</math>
                       
<math>k</math>

<math>
J_i =
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & -\sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>. Тогда матрица <math>A_{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)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Можно выбрать <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>. Для этого запишем равенство

: <math> \begin{bmatrix}
a_{jj}^{(i+1)} & a_{jk}^{(i+1)} \\
a_{kj}^{(i+1)} & a_{kk}^{(i+1)}
\end{bmatrix}
=
\begin{bmatrix}
\cos(\theta) & -\sin(\theta) \\
\sin(\theta) & \cos(\theta)
\end{bmatrix}^T
\begin{bmatrix}
a_{jj}^{(i)} & a_{jk}^{(i)} \\
a_{kj}^{(i)} & a_{kk}^{(i)}
\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_{jj}^{(i+1)} & a_{jk}^{(i+1)} \\
a_{kj}^{(i+1)} & a_{kk}^{(i+1)}
\end{bmatrix} </math>

Опуская индекс <math>(i)</math>, с учетом симметрии получим:

: <math>
\begin{bmatrix}
\lambda_1 & 0 \\
0 & \lambda_2
\end{bmatrix}
=
\begin{bmatrix}
a_{jj}c^2 + a_{kk}s^2 + 2sca_{jk} & sc(a_{kk}-a_{jj})+a_{jk}(c^2-s^2) \\
sc(a_{kk}-a_{jj})+a_{jk}(c^2-s^2) & a_{jj}s^2 + a_{kk}c^2 - 2sca_{jk}
\end{bmatrix}
</math>

Приравнивая внедиагональный элемент нулю, получаем

: <math> \frac{a_{jj}^{(i)} - a_{kk}^{(i)}}{2 a_{jk}^{(i)}} = \frac{c^2 - s^2}{2sc} = \frac{\cos 2\theta}{\sin 2\theta} = \operatorname{tg}(2\theta) \equiv \tau </math>.

Положим <math>t = \frac{s}{c} = \operatorname{ctg}(\theta)</math> и заметим, что <math>t^2 - 2t\tau + 1 = 0</math>. Решая квадратное уравнение, находим <math>t = \frac{\operatorname{sign}(\tau)}{|\tau| + \sqrt{1+\tau^2}}, c = \frac{1}{\sqrt{1+t^2}}, s = tc</math>.

Выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро составляют множественные вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>   в процессе применения матрицы поворота <math>J</math> к матрице <math>A</math>:
: <math>\begin{align}
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
\end{align}</math>

каждое из которых повторяется по <math> (n-2) </math> раза.

=== Макроструктура алгоритма ===
Основную часть метода составляет процедура применения вращения к матрице <math>A</math>, которая в дальнейшем будет обозначена как '''''Jakobi-Rotation<math>(A,j,k)</math>'''''

=== Схема реализации последовательного алгоритма ===
Алгоритм можно описать следующим образом:
repeat
for <math>j=1</math> to <math>n-1</math>
for <math>k=j+1</math> to <math>n</math>
выполнить процедуру '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
end for
end for
пока <math>A</math> не достаточно близка к диагональной матрице

Процедура '''''Jakobi-Rotation<math>(A,j,k)</math>''''' — это следующий алгоритм:
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\,t \\
A &= R^T(j,k,\theta)\cdot A\cdot R(j,k,\theta), \qquad J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}</math>
end if

=== Последовательная сложность алгоритма ===

Для вычисления собственных значений вещественной симметричной матрицы порядка n методом Якоби требуется:

Для вычислительного ядра —
* <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</math> (элементы <math>a_{ij}</math>).
Дополнительные ограничения:
* <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы). В разных реализациях эта экономия хранения может быть выполнена разным образом.

'''Выходные данные''': диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ii}</math>).

'''Объём выходных данных''': <math> n </math> (достаточно хранить только диагональные элементы).

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Масштабируемость алгоритма и его реализации ===

=== Существующие реализации алгоритма ===

== Литература ==

Участник:Galkina/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-10T19:12:31Z

Игорь:

Основные авторы описания: [[Участник: Galkina|А.С.Галкина]], [[Участник: Plahov|И.А.Плахов]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Метод Якоби — итерационный алгоритм для вычисления собственных значений и собственных векторов вещественной симметричной матрицы. Карл Густав Якоб Якоби, в честь которого назван этот метод, предложил его в 1846 году, хотя использоваться он начал только в 1950-х годах с появлением компьютеров. Суть алгоритма заключается в том, чтобы по заданной симметрической матрице <math>A = A_0</math> построить последовательность ортогонально подобных матриц <math>A_1,A_2,...</math>. Эта последовательность сходится к диагональной матрице, на диагонали которой стоят собственные значения.

=== Математическое описание алгоритма ===
Исходные данные: симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>).

Матрица <math>A_{i+1}</math> получается из <math>A_i</math> по формуле <math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math>J_i</math> — ортогональная матрица, называемая ''вращением Якоби''.
При подходящем выборе <math>J_i</math> матрица <math>A_m</math> для больших m будет близка к диагональной матрице <math>\Lambda</math>.

Матрица <math>J_i</math> выбирается так, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}</math>.



                                                
<math>j</math>
                       
<math>k</math>

<math>
J_i =
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & -\sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>. Тогда матрица <math>A_{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)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Можно выбрать <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>. Для этого запишем равенство

: <math> \begin{bmatrix}
a_{jj}^{(i+1)} & a_{jk}^{(i+1)} \\
a_{kj}^{(i+1)} & a_{kk}^{(i+1)}
\end{bmatrix}
=
\begin{bmatrix}
\cos(\theta) & -\sin(\theta) \\
\sin(\theta) & \cos(\theta)
\end{bmatrix}^T
\begin{bmatrix}
a_{jj}^{(i)} & a_{jk}^{(i)} \\
a_{kj}^{(i)} & a_{kk}^{(i)}
\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_{jj}^{(i+1)} & a_{jk}^{(i+1)} \\
a_{kj}^{(i+1)} & a_{kk}^{(i+1)}
\end{bmatrix} </math>

Опуская индекс <math>(i)</math>, с учетом симметрии получим:

: <math>
\begin{bmatrix}
\lambda_1 & 0 \\
0 & \lambda_2
\end{bmatrix}
=
\begin{bmatrix}
a_{jj}c^2 + a_{kk}s^2 + 2sca_{jk} & sc(a_{kk}-a_{jj})+a_{jk}(c^2-s^2) \\
sc(a_{kk}-a_{jj})+a_{jk}(c^2-s^2) & a_{jj}s^2 + a_{kk}c^2 - 2sca_{jk}
\end{bmatrix}
</math>

Приравнивая внедиагональный элемент нулю, получаем

: <math> \frac{a_{jj}^{(i)} - a_{kk}^{(i)}}{2 a_{jk}^{(i)}} = \frac{c^2 - s^2}{2sc} = \frac{\cos 2\theta}{\sin 2\theta} = \operatorname{tg}(2\theta) \equiv \tau </math>.

Положим <math>t = \frac{s}{c} = \operatorname{ctg}(\theta)</math> и заметим, что <math>t^2 - 2t\tau + 1 = 0</math>. Решая квадратное уравнение, находим <math>t = \frac{\operatorname{sign}(\tau)}{|\tau| + \sqrt{1+\tau^2}}, c = \frac{1}{\sqrt{1+t^2}}, s = tc</math>.

Выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро составляют множественные вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>   в процессе применения матрицы поворота <math>J</math> к матрице <math>A</math>:
: <math>\begin{align}
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
\end{align}</math>

каждое из которых повторяется по <math> (n-2) </math> раза.

=== Макроструктура алгоритма ===
Основную часть метода составляет процедура применения вращения к матрице <math>A</math>, которая в дальнейшем будет обозначена как '''''Jakobi-Rotation<math>(A,j,k)</math>'''''

=== Схема реализации последовательного алгоритма ===
Алгоритм можно описать следующим образом:
repeat
for <math>j=1</math> to <math>n-1</math>
for <math>k=j+1</math> to <math>n</math>
выполнить процедуру '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
end for
end for
пока <math>A</math> не достаточно близка к диагональной матрице

Процедура '''''Jakobi-Rotation<math>(A,j,k)</math>''''' — это следующий алгоритм:
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\,t \\
A &= R^T(j,k,\theta)\cdot A\cdot R(j,k,\theta), \qquad J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}</math>
end if

=== Последовательная сложность алгоритма ===

Для вычисления собственных значений вещественной симметричной матрицы порядка n методом Якоби требуется:

Для вычислительного ядра —
* <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</math> (элементы <math>a_{ij}</math>).
Дополнительные ограничения:
* <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы). В разных реализациях эта экономия хранения может быть выполнена разным образом.

'''Выходные данные''': диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ii}</math>).

'''Объём выходных данных''': <math> n </math> (достаточно хранить только диагональные элементы).

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Масштабируемость алгоритма и его реализации ===

=== Существующие реализации алгоритма ===

== Литература ==

Участник:Galkina/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-07T22:31:53Z

Игорь: /* Математическое описание алгоритма */

Основные авторы описания: [[Участник: Galkina|А.С.Галкина]], [[Участник: Plahov|И.А.Плахов]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Метод Якоби — итерационный алгоритм для вычисления собственных значений и собственных векторов вещественной симметричной матрицы. Карл Густав Якоб Якоби, в честь которого назван этот метод, предложил его в 1846 году, хотя использоваться он начал только в 1950-х годах с появлением компьютеров. Суть алгоритма заключается в том, чтобы по заданной симметрической матрице <math>A = A_0</math> построить последовательность ортогонально подобных матриц <math>A_1,A_2,...</math>. Эта последовательность сходится к диагональной матрице, на диагонали которой стоят собственные значения.

=== Математическое описание алгоритма ===
Исходные данные: симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>).

Матрица <math>A_{i+1}</math> получается из <math>A_i</math> по формуле <math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math>J_i</math> — ортогональная матрица, называемая ''вращением Якоби''.
При подходящем выборе <math>J_i</math> матрица <math>A_m</math> для больших m будет близка к диагональной матрице <math>\Lambda</math>.

Матрица <math>J_i</math> выбирается так, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}</math>.



                                                
<math>j</math>
                       
<math>k</math>

<math>
J_i =
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & -\sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>. Тогда матрица <math>A_{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)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Можно выбрать <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>. Для этого запишем равенство

: <math> \begin{bmatrix}
a_{jj}^{(i+1)} & a_{jk}^{(i+1)} \\
a_{kj}^{(i+1)} & a_{kk}^{(i+1)}
\end{bmatrix}
=
\begin{bmatrix}
\cos(\theta) & -\sin(\theta) \\
\sin(\theta) & \cos(\theta)
\end{bmatrix}^T
\begin{bmatrix}
a_{jj}^{(i)} & a_{jk}^{(i)} \\
a_{kj}^{(i)} & a_{kk}^{(i)}
\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_{jj}^{(i+1)} & a_{jk}^{(i+1)} \\
a_{kj}^{(i+1)} & a_{kk}^{(i+1)}
\end{bmatrix} </math>

Опуская индекс <math>(i)</math>, с учетом симметрии получим:

: <math>
\begin{bmatrix}
\lambda_1 & 0 \\
0 & \lambda_2
\end{bmatrix}
=
\begin{bmatrix}
a_{jj}c^2 + a_{kk}s^2 + 2sca_{jk} & sc(a_{kk}-a_{jj})+a_{jk}(c^2-s^2) \\
sc(a_{kk}-a_{jj})+a_{jk}(c^2-s^2) & a_{jj}s^2 + a_{kk}c^2 - 2sca_{jk}
\end{bmatrix}
</math>

Приравнивая внедиагональный элемент нулю, получаем

: <math> \frac{a_{jj}^{(i)} - a_{kk}^{(i)}}{2 a_{jk}^{(i)}} = \frac{c^2 - s^2}{2sc} = \frac{\cos 2\theta}{\sin 2\theta} = \operatorname{tg}(2\theta) \equiv \tau </math>.

Положим <math>t = \frac{s}{c} = \operatorname{ctg}(\theta)</math> и заметим, что <math>t^2 - 2t\tau + 1 = 0</math>. Решая квадратное уравнение, находим <math>t = \frac{\operatorname{sign}(\tau)}{|\tau| + \sqrt{1+\tau^2}}, c = \frac{1}{\sqrt{1+t^2}}, s = tc</math>.

Выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро составляют множественные вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>   в процессе применения матрицы поворота <math>J</math> к матрице <math>A</math>:
: <math>\begin{align}
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
\end{align}</math>

каждое из которых повторяется по <math> (n-2) </math> раза.

=== Макроструктура алгоритма ===
Основную часть метода составляет процедура применения вращения к матрице <math>A</math>, которая в дальнейшем будет обозначена как '''''Jakobi-Rotation<math>(A,j,k)</math>'''''

=== Схема реализации последовательного алгоритма ===
Алгоритм можно описать следующим образом:
repeat
for <math>j=1</math> to <math>n-1</math>
for <math>k=j+1</math> to <math>n</math>
выполнить процедуру '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
end for
end for
пока <math>A</math> не достаточно близка к диагональной матрице

Процедура '''''Jakobi-Rotation<math>(A,j,k)</math>''''' — это следующий алгоритм:
if <math>|a_{jk}|</math> не слишком мал
<math>\begin{align}
\tau &= (a_{jj}-a{kk})/(2\,a_{jk}) \\
t &= sign(\tau)/(|\tau|+\sqrt{1+\tau^2}) \\
c &= \frac{1}{\sqrt{1+t^2}} \\
s &= c\,t \\
A &= R^T(j,k,\theta)\,A\,R(j,k,\theta), \qquad J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}</math>
end if

=== Последовательная сложность алгоритма ===

=== Информационный граф ===

=== Ресурс параллелизма алгоритма ===

=== Входные и выходные данные алгоритма ===

'''Входные данные''': матрица <math>A</math> (элементы <math>a_{ij}</math>).
Дополнительные ограничения:
* <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы). В разных реализациях эта экономия хранения может быть выполнена разным образом.

'''Выходные данные''': диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ii}</math>).

'''Объём выходных данных''': <math> n </math> (достаточно хранить только диагональные элементы).

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Масштабируемость алгоритма и его реализации ===

=== Существующие реализации алгоритма ===

== Литература ==

Участник:Galkina/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-07T22:30:51Z

Игорь: /* Математическое описание алгоритма */

Основные авторы описания: [[Участник: Galkina|А.С.Галкина]], [[Участник: Plahov|И.А.Плахов]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Метод Якоби — итерационный алгоритм для вычисления собственных значений и собственных векторов вещественной симметричной матрицы. Карл Густав Якоб Якоби, в честь которого назван этот метод, предложил его в 1846 году, хотя использоваться он начал только в 1950-х годах с появлением компьютеров. Суть алгоритма заключается в том, чтобы по заданной симметрической матрице <math>A = A_0</math> построить последовательность ортогонально подобных матриц <math>A_1,A_2,...</math>. Эта последовательность сходится к диагональной матрице, на диагонали которой стоят собственные значения.

=== Математическое описание алгоритма ===
Исходные данные: симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>).

Матрица <math>A_{i+1}</math> получается из <math>A_i</math> по формуле <math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math>J_i</math> — ортогональная матрица, называемая ''вращением Якоби''.
При подходящем выборе <math>J_i</math> матрица <math>A_m</math> для больших m будет близка к диагональной матрице <math>\Lambda</math>.

Матрица <math>J_i</math> выбирается так, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}</math>.



                                                
<math>j</math>
                     
<math>k</math>

<math>
J_i =
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & -\sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>. Тогда матрица <math>A_{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)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Можно выбрать <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>. Для этого запишем равенство

: <math> \begin{bmatrix}
a_{jj}^{(i+1)} & a_{jk}^{(i+1)} \\
a_{kj}^{(i+1)} & a_{kk}^{(i+1)}
\end{bmatrix}
=
\begin{bmatrix}
\cos(\theta) & -\sin(\theta) \\
\sin(\theta) & \cos(\theta)
\end{bmatrix}^T
\begin{bmatrix}
a_{jj}^{(i)} & a_{jk}^{(i)} \\
a_{kj}^{(i)} & a_{kk}^{(i)}
\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_{jj}^{(i+1)} & a_{jk}^{(i+1)} \\
a_{kj}^{(i+1)} & a_{kk}^{(i+1)}
\end{bmatrix} </math>

Опуская индекс <math>(i)</math>, с учетом симметрии получим:

: <math>
\begin{bmatrix}
\lambda_1 & 0 \\
0 & \lambda_2
\end{bmatrix}
=
\begin{bmatrix}
a_{jj}c^2 + a_{kk}s^2 + 2sca_{jk} & sc(a_{kk}-a_{jj})+a_{jk}(c^2-s^2) \\
sc(a_{kk}-a_{jj})+a_{jk}(c^2-s^2) & a_{jj}s^2 + a_{kk}c^2 - 2sca_{jk}
\end{bmatrix}
</math>

Приравнивая внедиагональный элемент нулю, получаем

: <math> \frac{a_{jj}^{(i)} - a_{kk}^{(i)}}{2 a_{jk}^{(i)}} = \frac{c^2 - s^2}{2sc} = \frac{\cos 2\theta}{\sin 2\theta} = \operatorname{tg}(2\theta) \equiv \tau </math>.

Положим <math>t = \frac{s}{c} = \operatorname{ctg}(\theta)</math> и заметим, что <math>t^2 - 2t\tau + 1 = 0</math>. Решая квадратное уравнение, находим <math>t = \frac{\operatorname{sign}(\tau)}{|\tau| + \sqrt{1+\tau^2}}, c = \frac{1}{\sqrt{1+t^2}}, s = tc</math>.

Выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро составляют множественные вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>   в процессе применения матрицы поворота <math>J</math> к матрице <math>A</math>:
: <math>\begin{align}
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
\end{align}</math>

каждое из которых повторяется по <math> (n-2) </math> раза.

=== Макроструктура алгоритма ===
Основную часть метода составляет процедура применения вращения к матрице <math>A</math>, которая в дальнейшем будет обозначена как '''''Jakobi-Rotation<math>(A,j,k)</math>'''''

=== Схема реализации последовательного алгоритма ===
Алгоритм можно описать следующим образом:
repeat
for <math>j=1</math> to <math>n-1</math>
for <math>k=j+1</math> to <math>n</math>
выполнить процедуру '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
end for
end for
пока <math>A</math> не достаточно близка к диагональной матрице

Процедура '''''Jakobi-Rotation<math>(A,j,k)</math>''''' — это следующий алгоритм:
if <math>|a_{jk}|</math> не слишком мал
<math>\begin{align}
\tau &= (a_{jj}-a{kk})/(2\,a_{jk}) \\
t &= sign(\tau)/(|\tau|+\sqrt{1+\tau^2}) \\
c &= \frac{1}{\sqrt{1+t^2}} \\
s &= c\,t \\
A &= R^T(j,k,\theta)\,A\,R(j,k,\theta), \qquad J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}</math>
end if

=== Последовательная сложность алгоритма ===

=== Информационный граф ===

=== Ресурс параллелизма алгоритма ===

=== Входные и выходные данные алгоритма ===

'''Входные данные''': матрица <math>A</math> (элементы <math>a_{ij}</math>).
Дополнительные ограничения:
* <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы). В разных реализациях эта экономия хранения может быть выполнена разным образом.

'''Выходные данные''': диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ii}</math>).

'''Объём выходных данных''': <math> n </math> (достаточно хранить только диагональные элементы).

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Масштабируемость алгоритма и его реализации ===

=== Существующие реализации алгоритма ===

== Литература ==

Участник:Galkina/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-07T17:53:58Z

Игорь: /* Схема реализации последовательного алгоритма */

Основные авторы описания: [[Участник: Galkina|А.С.Галкина]], [[Участник: Plahov|И.А.Плахов]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Метод Якоби — итерационный алгоритм для вычисления собственных значений и собственных векторов вещественной симметричной матрицы. Карл Густав Якоб Якоби, в честь которого назван этот метод, предложил его в 1846 году, хотя использоваться он начал только в 1950-х годах с появлением компьютеров. Суть алгоритма заключается в том, чтобы по заданной симметрической матрице <math>A = A_0</math> построить последовательность ортогонально подобных матриц <math>A_1,A_2,...</math>. Эта последовательность сходится к диагональной матрице, на диагонали которой стоят собственные значения.

=== Математическое описание алгоритма ===
Исходные данные: симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>).

Матрица <math>A_{i+1}</math> получается из <math>A_i</math> по формуле <math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math>J_i</math> — ортогональная матрица, называемая ''вращением Якоби''.
При подходящем выборе <math>J_i</math> матрица <math>A_m</math> для больших m будет близка к диагональной матрице <math>\Lambda</math>.

Матрица <math>J_i</math> выбирается так, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}</math>.



                                                
<math>j</math>
                     
<math>k</math>

<math>
J_i =
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & \sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>. Тогда матрица <math>A_{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)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Можно выбрать <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>. Для этого запишем равенство

: <math> \begin{bmatrix}
a_{jj}^{(i+1)} & a_{jk}^{(i+1)} \\
a_{kj}^{(i+1)} & a_{kk}^{(i+1)}
\end{bmatrix}
=
\begin{bmatrix}
\cos(\theta) & -\sin(\theta) \\
\sin(\theta) & \cos(\theta)
\end{bmatrix}^T
\begin{bmatrix}
a_{jj}^{(i)} & a_{jk}^{(i)} \\
a_{kj}^{(i)} & a_{kk}^{(i)}
\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_{jj}^{(i+1)} & a_{jk}^{(i+1)} \\
a_{kj}^{(i+1)} & a_{kk}^{(i+1)}
\end{bmatrix} </math>

Опуская индекс <math>(i)</math>, с учетом симметрии получим:

: <math>
\begin{bmatrix}
\lambda_1 & 0 \\
0 & \lambda_2
\end{bmatrix}
=
\begin{bmatrix}
a_{jj}c^2 + a_{kk}s^2 + 2sca_{jk} & sc(a_{kk}-a_{jj})+a_{jk}(c^2-s^2) \\
sc(a_{kk}-a_{jj})+a_{jk}(c^2-s^2) & a_{jj}s^2 + a_{kk}c^2 - 2sca_{jk}
\end{bmatrix}
</math>

Приравнивая внедиагональный элемент нулю, получаем

: <math> \frac{a_{jj}^{(i)} - a_{kk}^{(i)}}{2 a_{jk}^{(i)}} = \frac{c^2 - s^2}{2sc} = \frac{\cos 2\theta}{\sin 2\theta} = \operatorname{tg}(2\theta) \equiv \tau </math>.

Положим <math>t = \frac{s}{c} = \operatorname{ctg}(\theta)</math> и заметим, что <math>t^2 - 2t\tau + 1 = 0</math>. Решая квадратное уравнение, находим <math>t = \frac{\operatorname{sign}(\tau)}{|\tau| + \sqrt{1+\tau^2}}, c = \frac{1}{\sqrt{1+t^2}}, s = tc</math>.

Выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро составляют множественные вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>   в процессе применения матрицы поворота <math>J</math> к матрице <math>A</math>:
: <math>\begin{align}
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
\end{align}</math>

каждое из которых повторяется по <math> (n-2) </math> раза.

=== Макроструктура алгоритма ===
Основную часть метода составляет процедура применения вращения к матрице <math>A</math>, которая в дальнейшем будет обозначена как '''''Jakobi-Rotation<math>(A,j,k)</math>'''''

=== Схема реализации последовательного алгоритма ===
Алгоритм можно описать следующим образом:
repeat
for <math>j=1</math> to <math>n-1</math>
for <math>k=j+1</math> to <math>n</math>
выполнить процедуру '''''Jakobi-Rotation<math>(A,j,k)</math>'''''
end for
end for
пока <math>A</math> не достаточно близка к диагональной матрице

Процедура '''''Jakobi-Rotation<math>(A,j,k)</math>''''' — это следующий алгоритм:
if <math>|a_{jk}|</math> не слишком мал
<math>\begin{align}
\tau &= (a_{jj}-a{kk})/(2\,a_{jk}) \\
t &= sign(\tau)/(|\tau|+\sqrt{1+\tau^2}) \\
c &= \frac{1}{\sqrt{1+t^2}} \\
s &= c\,t \\
A &= R^T(j,k,\theta)\,A\,R(j,k,\theta), \qquad J_i = R(j,k,\theta),\ c = \cos \theta,\ s = \sin \theta
\end{align}</math>
end if

=== Последовательная сложность алгоритма ===

=== Информационный граф ===

=== Ресурс параллелизма алгоритма ===

=== Входные и выходные данные алгоритма ===

'''Входные данные''': матрица <math>A</math> (элементы <math>a_{ij}</math>).
Дополнительные ограничения:
* <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы). В разных реализациях эта экономия хранения может быть выполнена разным образом.

'''Выходные данные''': диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ii}</math>).

'''Объём выходных данных''': <math> n </math> (достаточно хранить только диагональные элементы).

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Масштабируемость алгоритма и его реализации ===

=== Существующие реализации алгоритма ===

== Литература ==

Участник:Galkina/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-07T17:26:06Z

Игорь: /* Макроструктура алгоритма */

Основные авторы описания: [[Участник: Galkina|А.С.Галкина]], [[Участник: Plahov|И.А.Плахов]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Метод Якоби — итерационный алгоритм для вычисления собственных значений и собственных векторов вещественной симметричной матрицы. Карл Густав Якоб Якоби, в честь которого назван этот метод, предложил его в 1846 году, хотя использоваться он начал только в 1950-х годах с появлением компьютеров. Суть алгоритма заключается в том, чтобы по заданной симметрической матрице <math>A = A_0</math> построить последовательность ортогонально подобных матриц <math>A_1,A_2,...</math>. Эта последовательность сходится к диагональной матрице, на диагонали которой стоят собственные значения.

=== Математическое описание алгоритма ===
Исходные данные: симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>).

Матрица <math>A_{i+1}</math> получается из <math>A_i</math> по формуле <math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math>J_i</math> — ортогональная матрица, называемая ''вращением Якоби''.
При подходящем выборе <math>J_i</math> матрица <math>A_m</math> для больших m будет близка к диагональной матрице <math>\Lambda</math>.

Матрица <math>J_i</math> выбирается так, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}</math>.



                                                
<math>j</math>
                     
<math>k</math>

<math>
J_i =
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & \sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>. Тогда матрица <math>A_{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)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Можно выбрать <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>. Для этого запишем равенство

: <math> \begin{bmatrix}
a_{jj}^{(i+1)} & a_{jk}^{(i+1)} \\
a_{kj}^{(i+1)} & a_{kk}^{(i+1)}
\end{bmatrix}
=
\begin{bmatrix}
\cos(\theta) & -\sin(\theta) \\
\sin(\theta) & \cos(\theta)
\end{bmatrix}^T
\begin{bmatrix}
a_{jj}^{(i)} & a_{jk}^{(i)} \\
a_{kj}^{(i)} & a_{kk}^{(i)}
\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_{jj}^{(i+1)} & a_{jk}^{(i+1)} \\
a_{kj}^{(i+1)} & a_{kk}^{(i+1)}
\end{bmatrix} </math>

Опуская индекс <math>(i)</math>, с учетом симметрии получим:

: <math>
\begin{bmatrix}
\lambda_1 & 0 \\
0 & \lambda_2
\end{bmatrix}
=
\begin{bmatrix}
a_{jj}c^2 + a_{kk}s^2 + 2sca_{jk} & sc(a_{kk}-a_{jj})+a_{jk}(c^2-s^2) \\
sc(a_{kk}-a_{jj})+a_{jk}(c^2-s^2) & a_{jj}s^2 + a_{kk}c^2 - 2sca_{jk}
\end{bmatrix}
</math>

Приравнивая внедиагональный элемент нулю, получаем

: <math> \frac{a_{jj}^{(i)} - a_{kk}^{(i)}}{2 a_{jk}^{(i)}} = \frac{c^2 - s^2}{2sc} = \frac{\cos 2\theta}{\sin 2\theta} = \operatorname{tg}(2\theta) \equiv \tau </math>.

Положим <math>t = \frac{s}{c} = \operatorname{ctg}(\theta)</math> и заметим, что <math>t^2 - 2t\tau + 1 = 0</math>. Решая квадратное уравнение, находим <math>t = \frac{\operatorname{sign}(\tau)}{|\tau| + \sqrt{1+\tau^2}}, c = \frac{1}{\sqrt{1+t^2}}, s = tc</math>.

Выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро составляют множественные вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>   в процессе применения матрицы поворота <math>J</math> к матрице <math>A</math>:
: <math>\begin{align}
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
\end{align}</math>

каждое из которых повторяется по <math> (n-2) </math> раза.

=== Макроструктура алгоритма ===
Основную часть метода составляет процедура применения вращения к матрице <math>A</math>, которая в дальнейшем будет обозначена как '''''Jakobi-Rotation<math>(A,j,k)</math>'''''

=== Схема реализации последовательного алгоритма ===

=== Последовательная сложность алгоритма ===

=== Информационный граф ===

=== Ресурс параллелизма алгоритма ===

=== Входные и выходные данные алгоритма ===

'''Входные данные''': матрица <math>A</math> (элементы <math>a_{ij}</math>).
Дополнительные ограничения:
* <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы). В разных реализациях эта экономия хранения может быть выполнена разным образом.

'''Выходные данные''': диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ii}</math>).

'''Объём выходных данных''': <math> n </math> (достаточно хранить только диагональные элементы).

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Масштабируемость алгоритма и его реализации ===

=== Существующие реализации алгоритма ===

== Литература ==

Участник:Galkina/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-07T17:20:08Z

Игорь: /* Математическое описание алгоритма */

Основные авторы описания: [[Участник: Galkina|А.С.Галкина]], [[Участник: Plahov|И.А.Плахов]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Метод Якоби — итерационный алгоритм для вычисления собственных значений и собственных векторов вещественной симметричной матрицы. Карл Густав Якоб Якоби, в честь которого назван этот метод, предложил его в 1846 году, хотя использоваться он начал только в 1950-х годах с появлением компьютеров. Суть алгоритма заключается в том, чтобы по заданной симметрической матрице <math>A = A_0</math> построить последовательность ортогонально подобных матриц <math>A_1,A_2,...</math>. Эта последовательность сходится к диагональной матрице, на диагонали которой стоят собственные значения.

=== Математическое описание алгоритма ===
Исходные данные: симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>).

Матрица <math>A_{i+1}</math> получается из <math>A_i</math> по формуле <math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math>J_i</math> — ортогональная матрица, называемая ''вращением Якоби''.
При подходящем выборе <math>J_i</math> матрица <math>A_m</math> для больших m будет близка к диагональной матрице <math>\Lambda</math>.

Матрица <math>J_i</math> выбирается так, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}</math>.



                                                
<math>j</math>
                     
<math>k</math>

<math>
J_i =
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & \sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>. Тогда матрица <math>A_{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)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Можно выбрать <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>. Для этого запишем равенство

: <math> \begin{bmatrix}
a_{jj}^{(i+1)} & a_{jk}^{(i+1)} \\
a_{kj}^{(i+1)} & a_{kk}^{(i+1)}
\end{bmatrix}
=
\begin{bmatrix}
\cos(\theta) & -\sin(\theta) \\
\sin(\theta) & \cos(\theta)
\end{bmatrix}^T
\begin{bmatrix}
a_{jj}^{(i)} & a_{jk}^{(i)} \\
a_{kj}^{(i)} & a_{kk}^{(i)}
\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_{jj}^{(i+1)} & a_{jk}^{(i+1)} \\
a_{kj}^{(i+1)} & a_{kk}^{(i+1)}
\end{bmatrix} </math>

Опуская индекс <math>(i)</math>, с учетом симметрии получим:

: <math>
\begin{bmatrix}
\lambda_1 & 0 \\
0 & \lambda_2
\end{bmatrix}
=
\begin{bmatrix}
a_{jj}c^2 + a_{kk}s^2 + 2sca_{jk} & sc(a_{kk}-a_{jj})+a_{jk}(c^2-s^2) \\
sc(a_{kk}-a_{jj})+a_{jk}(c^2-s^2) & a_{jj}s^2 + a_{kk}c^2 - 2sca_{jk}
\end{bmatrix}
</math>

Приравнивая внедиагональный элемент нулю, получаем

: <math> \frac{a_{jj}^{(i)} - a_{kk}^{(i)}}{2 a_{jk}^{(i)}} = \frac{c^2 - s^2}{2sc} = \frac{\cos 2\theta}{\sin 2\theta} = \operatorname{tg}(2\theta) \equiv \tau </math>.

Положим <math>t = \frac{s}{c} = \operatorname{ctg}(\theta)</math> и заметим, что <math>t^2 - 2t\tau + 1 = 0</math>. Решая квадратное уравнение, находим <math>t = \frac{\operatorname{sign}(\tau)}{|\tau| + \sqrt{1+\tau^2}}, c = \frac{1}{\sqrt{1+t^2}}, s = tc</math>.

Выбор параметров <math>j</math> и <math>k</math> производится путем построчного циклического обхода внедиагональных элементов матрицы <math>A</math>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро составляют множественные вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>   в процессе применения матрицы поворота <math>J</math> к матрице <math>A</math>:
: <math>\begin{align}
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
\end{align}</math>

каждое из которых повторяется по <math> (n-2) </math> раза.

=== Макроструктура алгоритма ===

=== Схема реализации последовательного алгоритма ===

=== Последовательная сложность алгоритма ===

=== Информационный граф ===

=== Ресурс параллелизма алгоритма ===

=== Входные и выходные данные алгоритма ===

'''Входные данные''': матрица <math>A</math> (элементы <math>a_{ij}</math>).
Дополнительные ограничения:
* <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы). В разных реализациях эта экономия хранения может быть выполнена разным образом.

'''Выходные данные''': диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ii}</math>).

'''Объём выходных данных''': <math> n </math> (достаточно хранить только диагональные элементы).

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Масштабируемость алгоритма и его реализации ===

=== Существующие реализации алгоритма ===

== Литература ==

Участник:Galkina/Метод Якоби вычисления собственных значений симметричной матрицы

2016-10-07T17:08:00Z

Игорь: /* Вычислительное ядро алгоритма */

Основные авторы описания: [[Участник: Galkina|А.С.Галкина]], [[Участник: Plahov|И.А.Плахов]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Метод Якоби — итерационный алгоритм для вычисления собственных значений и собственных векторов вещественной симметричной матрицы. Карл Густав Якоб Якоби, в честь которого назван этот метод, предложил его в 1846 году, хотя использоваться он начал только в 1950-х годах с появлением компьютеров. Суть алгоритма заключается в том, чтобы по заданной симметрической матрице <math>A = A_0</math> построить последовательность ортогонально подобных матриц <math>A_1,A_2,...</math>. Эта последовательность сходится к диагональной матрице, на диагонали которой стоят собственные значения.

=== Математическое описание алгоритма ===
Исходные данные: симметрическая матрица <math>A</math> (элементы <math>a_{ij}</math>).

Вычисляемые данные: диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ij}</math>).

Матрица <math>A_{i+1}</math> получается из <math>A_i</math> по формуле <math>A_{i+1}={J_i}^TA_iJ_i</math>, где <math>J_i</math> — ортогональная матрица, называемая ''вращением Якоби''.
При подходящем выборе <math>J_i</math> матрица <math>A_m</math> для больших m будет близка к диагональной матрице <math>\Lambda</math>.

Матрица <math>J_i</math> выбирается так, чтобы сделать нулями пару внедиагональных элементов матрицы <math>A_{i+1}</math>.



                                                
<math>j</math>
                     
<math>k</math>

<math>
J_i =
\begin{matrix}
\\
\\
\\
j \\
\\
k \\
\\
\\
\\
\end{matrix}
</math>
<math>
\begin{bmatrix}
& 1 & & & & & & & & \\
& & 1 & & & & & & & \\
& & & \ddots & & & & & & \\
& & & & \cos(\theta) & & \sin(\theta) & & & \\
& & & & & \ddots & & & & \\
& & & & \sin(\theta) & & \cos(\theta) & & & \\
& & & & & & & \ddots & & \\
& & & & & & & & 1 & \\
& & & & & & & & & 1 \\
\end{bmatrix}
</math>

Обозначим <math>s = \sin \theta</math> и <math>c = \cos \theta</math>. Тогда матрица <math>A_{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)} \\
a_{jk}^{(i+1)} &= a_{kj}^{(i+1)} = (c^2 - s^2 ) \, a_{jk}^{(i)} + s c \, (a_{kk}^{(i)} - a_{jj}^{(i)} ) \\
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
a_{ml}^{(i+1)} &= a_{ml}^{(i)} &m,l \ne j,k
\end{align}</math>

Можно выбрать <math>\theta</math> так, чтобы <math>a_{jk}^{(i+1)} = 0</math> и <math>a_{kj}^{(i+1)} = 0</math>. Для этого запишем равенство

: <math> \begin{bmatrix}
a_{jj}^{(i+1)} & a_{jk}^{(i+1)} \\
a_{kj}^{(i+1)} & a_{kk}^{(i+1)}
\end{bmatrix}
=
\begin{bmatrix}
\cos(\theta) & -\sin(\theta) \\
\sin(\theta) & \cos(\theta)
\end{bmatrix}^T
\begin{bmatrix}
a_{jj}^{(i)} & a_{jk}^{(i)} \\
a_{kj}^{(i)} & a_{kk}^{(i)}
\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_{jj}^{(i+1)} & a_{jk}^{(i+1)} \\
a_{kj}^{(i+1)} & a_{kk}^{(i+1)}
\end{bmatrix} </math>

Опуская индекс <math>(i)</math>, с учетом симметрии получим:

: <math>
\begin{bmatrix}
\lambda_1 & 0 \\
0 & \lambda_2
\end{bmatrix}
=
\begin{bmatrix}
a_{jj}c^2 + a_{kk}s^2 + 2sca_{jk} & sc(a_{kk}-a_{jj})+a_{jk}(c^2-s^2) \\
sc(a_{kk}-a_{jj})+a_{jk}(c^2-s^2) & a_{jj}s^2 + a_{kk}c^2 - 2sca_{jk}
\end{bmatrix}
</math>

Приравнивая внедиагональный элемент нулю, получаем

: <math> \frac{a_{jj}^{(i)} - a_{kk}^{(i)}}{2 a_{jk}^{(i)}} = \frac{c^2 - s^2}{2sc} = \frac{\cos 2\theta}{\sin 2\theta} = \operatorname{tg}(2\theta) \equiv \tau </math>.

Положим <math>t = \frac{s}{c} = \operatorname{ctg}(\theta)</math> и заметим, что <math>t^2 - 2t\tau + 1 = 0</math>. Решая квадратное уравнение, находим <math>t = \frac{\operatorname{sign}(\tau)}{|\tau| + \sqrt{1+\tau^2}}, c = \frac{1}{\sqrt{1+t^2}}, s = tc</math>.

=== Вычислительное ядро алгоритма ===
Вычислительное ядро составляют множественные вычисления элементов матрицы <math>a_{jm}^{(i+1)} = a_{mj}^{(i+1)}</math>   и   <math>a_{km}^{(i+1)} = a_{mk}^{(i+1)}</math>   в процессе применения матрицы поворота <math>J</math> к матрице <math>A</math>:
: <math>\begin{align}
a_{jm}^{(i+1)} &= a_{mj}^{(i+1)} = c \, a_{jm}^{(i)} - s \, a_{km}^{(i)} & m \ne j,k \\
a_{km}^{(i+1)} &= a_{mk}^{(i+1)} = s \, a_{jm}^{(i)} + c \, a_{km}^{(i)} & m \ne j,k \\
\end{align}</math>

каждое из которых повторяется по <math> (n-2) </math> раза.

=== Макроструктура алгоритма ===

=== Схема реализации последовательного алгоритма ===

=== Последовательная сложность алгоритма ===

=== Информационный граф ===

=== Ресурс параллелизма алгоритма ===

=== Входные и выходные данные алгоритма ===

'''Входные данные''': матрица <math>A</math> (элементы <math>a_{ij}</math>).
Дополнительные ограничения:
* <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>.

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы). В разных реализациях эта экономия хранения может быть выполнена разным образом.

'''Выходные данные''': диагональная матрица <math>\Lambda</math> (элементы <math>\lambda_{ii}</math>).

'''Объём выходных данных''': <math> n </math> (достаточно хранить только диагональные элементы).

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Масштабируемость алгоритма и его реализации ===

=== Существующие реализации алгоритма ===

== Литература ==