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

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

2017-02-06T21:16:36Z

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

== Статья [[Учacтник:Malikovmt/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией]] ==

=== Замечания по тексту ===
* В разделе 1.4 должно быть не перечисление макроопераций, а нужно показать структуру алгоритма на макроуровне. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 17:41, 3 февраля 2017 (MSK)

Сделано

* Граф, приведённый в разделе 1.7, непонятен без пояснений, например, что означают разные типы стрелочек. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 17:41, 3 февраля 2017 (MSK)

Сделано

* В разделе 2.4 не приведены все параметры запуска теста - например, с какими опциями проводилась компиляция. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 17:41, 3 февраля 2017 (MSK)

Сделано

Учacтник:Malikovmt/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией

2017-02-06T21:16:02Z

Malikovmt:

{{Assignment}}

{{algorithm
| name = Алгоритм Ланцоша с полной переортогонализацией
| serial_complexity = <math>O(n^2k)</math>
| input_data = <math>\frac{n(n + 1)}{2}</math>
| output_data = <math>k(n + 1)</math>
}}

Авторы: [[Участник:Eroshkin|А.В.Ерошкин]] ([[#Масштабируемость алгоритма и его реализации|ссылкаКод]]), [[Участник:Malikovmt|М.М.Маликов]] ([[#Описание алгоритма|ссылка]])

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

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

'''Алгоритм Ланцоша''' - итерационный метод, используемый для вычисления части собственных значений и соответствующих им собственных векторов матрицы <math>A</math> размера <math>n*n</math>, изначально разработанный Корнелием Ланцошем. Преимуществами использования метода является относительно небольшое потребление памяти и вычислительных ресурсов, а также наличие параметра <math>k << n</math>, контролирующего количество итераций. Несмотря на то, что алгоритм является вычислительно эффективным, первоначально сформулированный метод был плохо применим из-за численной неустойчивости - метод хорошо работал на целочисленных значениях, однако в арифметике с плавающей точкой ошибки округления давали большую погрешность. В 1970 году Ojalvo и Newman показали, как сделать метод численно стабильным и применили его для расчета крупных инженерных сооружений, подверженных динамическим нагрузкам. Кроме того, они показали способ выбора начального приближения (с использованием ГПСЧ), а также эмпирический способ для выбора числа <math>k</math> (примерно в полтора раза больше искомого числа собственных векторов). В данный момент существует две основных модификации метода (с полной и выборочной переортогонализацией), а также большое количество модификаций, использующихся в различных технических областях. Алгоритм используется для больших <math>n</math>.

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

Первый этап алгоритма - использование метода Ланцоша для построения крыловского подпространства: <math> K_k(A,x) = span[x_1, Ax_1, A^2x_1, ..., A^{k-1}x_1] </math>. Входные данные алгоритма: квадратная симметричная матрица <math>A</math> размерности <math>n*n</math>, вектор начального приближения <math>b</math>, а так же число итераций <math>k</math>. Метод осуществляет поиск трехдиагональной симметричной матрицы <math>T_k=Q_k^TAQ_k</math>.

<math>T_k=\begin{bmatrix}
\alpha_1 & \beta_2 \\
\beta_2 & \alpha_2 & \beta_3 &\\
&. & . & .\\
&&\beta_{k-1} & \alpha_{k-1} & \beta_k\\
&&&\beta_k & \alpha_k
\end{bmatrix}</math>

Описание метода:

<math>
\begin{array}{l}
q_1 = b / \Vert b \Vert_2\\
j = \overline{1, k}:\\
\quad z_j = A q_j \\
\quad \alpha_j = q_j^T z_j \\
\quad z_j = z_j - \sum_{i=1}^j (z_j^T q_i) q_i\\
\quad z_j = z_j - \sum_{i=1}^j (z_j^T q_i) q_i\\
\quad \beta_j = \Vert z_j \Vert_2\\
\quad q_{j+1} = z_j / \Vert z_j \Vert_2 = z_j/\beta_j
\end{array}
</math>

Следующий шаг алгоритма - процедура Рэлея-Ритца. Она зкалючается в интерпретации собственных значений матрицы <math> T_k=Q_k^TAQ_k</math>.
Ее собственные значения приближают собственные значения исходной матрицы. Пусть ''Tk=V<math>\Lambda</math>VT'' - спектральное разложение матрицы ''Tk'', тогда столбцы матрицы ''QkV'' рассматриваются как приближения к соответствующим собственным векторам матрицы ''A'' и называются векторами Ритца. Числа и векторы Ритца являются оптимальными приближениями к собственным значениям и собственным векторам матрицы ''A''.

Поиск собственных значений матрицы ''T'' намного легче, чем для исходной матрицы, так как предполагается, что <math>k << n</math>, и матрица ''T'' - трехдиагональная.

Полная переортогонализация необходима для того, чтобы гарантировать, что каждый полученный вектор ''qj+1'' ортогонален уже имеющимся векторам ''q1..j''. Без этого процесса будут накапливаться существенные вычислительный ошибки.

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

Вычислительным ядро алгоритма состоит ииз двух основных частей:
* <math>Aq=( \sum\nolimits_{i=^n}a_{1i}q_i, \sum\nolimits_{i=2}^na_{2i}q_i, ..., \sum\nolimits_{i=1}^na_{ni}q_i)</math> - умножение симметричной матрицы <math>A</math> размерности <math>n*n</math> на вектор ''q'' размерности ''n''.

* <math>z=z-\sum\nolimits_{i=1}^{k}(z^Tq_i)q_i.</math> - процесс ортогонализации Грама-Шмидта.

=== Макроструктура алгоритма ===
Основные операции алгоритма:

1. Перемножение матрицы на вектор.
<math>b=Ax</math>.

2. Двойная ортогонализация методом Грмма-Шмидта.
<math>z=z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i,</math>
<math>z=z-\alpha_jq_j-\beta_{j}q_{j-1}.</math>

3. Вычисление обновленного базисного вектора.
<math>q_{i+1} = z/ \beta</math>.

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

В параграфе 1.2 приводится полная схема последовательного алгоритма.

Заполняем начальные значения алгоритма (''b'' - начальное преближение).

<math>
\begin{align}
& q_1=b/||b||,\\
& \beta_1=0,\\
&q_0=0, \\
\end{align}
</math>

Для всех <math>j=1..k</math>:

*1. Вычисляется ''j''-й диагональный элемент матрицы <math>T_k</math>: <math>z=Aq_j; \alpha_j=q_j^Tz;</math>

*2. Проводится полная переортогонализация Грамма-Шмидта: <math>z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i;</math>

*3. Вычисляются значения <math>\beta_{j+1}</math> матрицы <math>T_k</math>: <math>\beta_{j+1}=||z||;</math>

*4. Если <math>\beta_{j+1}=0</math>, то алгоритм завершается;

*5. Сохраняем значения для следующей итерации <math>q_{j+1}=z/\beta_{j+1}.</math>

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

*1. Основная часть операций в алгоритме Ланцоша производится во время умножения матрицы <math>A</math> размерности <math>n*n</math> на вектор <math>q</math> размерности <math>n</math> - вычислительная сложность: <math>n^2</math> умножений и <math>n^2-n</math> сложений. Остальные операции основного цикла производят меньше <math>n^2</math> операций сложения или умножения. Так как умножение матрицы на вектор производится <math>k</math> раз, то сложность этой части алгоритма - <math>O(kn^2)</math>
*2. Процесс ортогонализации Грама-Шмидта - вычислительная сложность: <math>k^2n+k(n+2)</math> умножений и <math>k^2n + k(n + 1) + 2</math> сложений. Производится в цикле <math>k</math> раз. Сложность - <math>O(nk^2)</math>
*3. Процесс разложения матрицы <math>T</math> размерности <math>k*k</math>. Сложность - <math>O(k^2)</math>

Так как число итераций много меньше размерности матрицы <math>A</math>, <math>k << n</math>, то общая сложность алгоритма сокращается до <math>O(kn^2)</math>.

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

[[Файл:Lanczos.png|center|300px|'''Рис. 1.''' Граф ''j''-й итерации.]]

Черные маленькие стрелочки - куда идут данные.

Большие стрелочки - обозначение прохода по массиву (изменение индекса)

В больших кружках преобразования (операции над данными или вычисления)

В маленьких кружках запись в переменную.

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

Алгоритм Ланцоша - итерационный, итерации должны выполняться в строгой последовательности, и нет возможности их параллелизовать. Внутри одной итерации алгоритма ресурсами параллелизма могут быть:
*1. умножение матрицы размерности <math>n * n</math> на вектор длины <math>n</math> требует последовательного выполнения <math>n</math> ярусов умножений и сложений;
*2. вычисление <math>\alpha_j</math> требует <math>n</math> ярусов сложений с 1 операцией умножения в каждом;
*3. переортагонализация требует вычисления <math>j</math> ярусов сложений с <math>n</math> операциями умножения в каждом, <math>n</math> ярусов сложений с <math>j</math> операциями умножения в каждом;
*4. вычисление нормы вектора длины <math>n</math> требует <math>n</math> ярусов сложений с <math>1</math> операцией умножения в каждом.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': <math>A\in\mathbb{R}^{n\times n}</math> - симметричная матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>. Объем данных: <math>\frac{n (n + 1)}{2}</math>.

'''Выходные данные''': <math>\Lambda</math> - вектор собственных значений матрицы и соответствующие им собственные вектора <math>v_i,i=1,\ldots, k </math>. Объем данных: <math> k(n+1) </math>.

=== Свойства алгоритма ===
* В классическом алгоритме Ланцоша возникает большая погрешность при округлении чисел с плавающей точкой. Выбранный вариант с полной переортогонализацией устраняет этот недостаток, однако является более ресурсоемким. На практике наиболее популярен вариант с частичной переортогонализацией.
* Вычислительная мощность алгоритма (отношение числа операций к суммарному объему данных) оценивается как <math>\approx 2k</math>.
* Преимуществом алгоритма является то, что он начинает поиск собственных значений матрицы начиная с максимального в абсолютном смысле значения.
* Нет необходимости хранения исходной матрицы на каждом вычислительном ядре, так как метод использует исходную матрицу только в операциях умножения матрицы на вектор, что позволяет эффективно использовать регулярность структуры матрицы.
* Существует модифицированный блочный вариант алгоритма, применяемый в случае кратных собственных значений.

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

=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Проверка масштабируемости алгоритма проходила на [//hpc.cmc.msu.ru/ IBM Blue Gene/P ВМК МГУ.]

Используемые компиляторы: intel/15.0.090 и OpenMPI/1.8.4-icc.

Для проведения расчетов и получения полноценной картины поведения алгоритма в зависимости от входных данных и числа процессоров, программа была запущена на следующих параметрах:
* размеры входной матрицы: [5000:30000] c шагом 5000;
* число процессоров: от 1, 2, 4 .. 64.

Сборка осуществлялась с параметрами:
*openmpi/1.5.5-icc
*intel/13.1.0

[[Файл:Lancos prof.jpg|центр|мини|800x800пкс|Рис. 2. Зависимость времени выполнения программы от входных данных]]

По графику видно, что время выполнения уменьшается с увеличением количества процессоров примерно до 16, дальше начинает медленно увеличиваться вплоть до 64 и далее. Это можно объяснить тем, что с увеличением количества вычислительных ядер растет количество передаваемых данных, и дальнейшее увеличение их числа только ухудшает положение.

[http://pastebin.com/sWQ9ihcW код программы]

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

The IETL Project http://www.comp-phys.org/software/ietl/ C++

NAG Library http://www.nag.com/content/nag-library C, C++, Fortran, C#, MATLAB, R

ARPACK https://people.sc.fsu.edu/~jburkardt/m_src/arpack/arpack.html MATLAB

GrapLab https://turi.com/products/create/open_source.html C++

LANSO/PLANSO http://web.cs.ucdavis.edu/~bai/ET/lanczos_methods/overview_PLANSO.html Fortran (уже распараллелена)

Julia Math https://github.com/JuliaMath/IterativeSolvers.jl Julia

SciPy https://scipy.org/ Python

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

Дж. Деммель «Вычислительная линейная алгебра» (стр. 391)

<references \>

#[[Категория:Законченные статьи]]
#[[Категория:Разложения матриц]]

Учacтник:Malikovmt/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией

2017-02-06T21:14:13Z

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

{{algorithm
| name = Алгоритм Ланцоша с полной переортогонализацией
| serial_complexity = <math>O(n^2k)</math>
| input_data = <math>\frac{n(n + 1)}{2}</math>
| output_data = <math>k(n + 1)</math>
}}

Авторы: [[Участник:Eroshkin|А.В.Ерошкин]] ([[#Масштабируемость алгоритма и его реализации|ссылкаКод]]), [[Участник:Malikovmt|М.М.Маликов]] ([[#Описание алгоритма|ссылка]])

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

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

'''Алгоритм Ланцоша''' - итерационный метод, используемый для вычисления части собственных значений и соответствующих им собственных векторов матрицы <math>A</math> размера <math>n*n</math>, изначально разработанный Корнелием Ланцошем. Преимуществами использования метода является относительно небольшое потребление памяти и вычислительных ресурсов, а также наличие параметра <math>k << n</math>, контролирующего количество итераций. Несмотря на то, что алгоритм является вычислительно эффективным, первоначально сформулированный метод был плохо применим из-за численной неустойчивости - метод хорошо работал на целочисленных значениях, однако в арифметике с плавающей точкой ошибки округления давали большую погрешность. В 1970 году Ojalvo и Newman показали, как сделать метод численно стабильным и применили его для расчета крупных инженерных сооружений, подверженных динамическим нагрузкам. Кроме того, они показали способ выбора начального приближения (с использованием ГПСЧ), а также эмпирический способ для выбора числа <math>k</math> (примерно в полтора раза больше искомого числа собственных векторов). В данный момент существует две основных модификации метода (с полной и выборочной переортогонализацией), а также большое количество модификаций, использующихся в различных технических областях. Алгоритм используется для больших <math>n</math>.

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

Первый этап алгоритма - использование метода Ланцоша для построения крыловского подпространства: <math> K_k(A,x) = span[x_1, Ax_1, A^2x_1, ..., A^{k-1}x_1] </math>. Входные данные алгоритма: квадратная симметричная матрица <math>A</math> размерности <math>n*n</math>, вектор начального приближения <math>b</math>, а так же число итераций <math>k</math>. Метод осуществляет поиск трехдиагональной симметричной матрицы <math>T_k=Q_k^TAQ_k</math>.

<math>T_k=\begin{bmatrix}
\alpha_1 & \beta_2 \\
\beta_2 & \alpha_2 & \beta_3 &\\
&. & . & .\\
&&\beta_{k-1} & \alpha_{k-1} & \beta_k\\
&&&\beta_k & \alpha_k
\end{bmatrix}</math>

Описание метода:

<math>
\begin{array}{l}
q_1 = b / \Vert b \Vert_2\\
j = \overline{1, k}:\\
\quad z_j = A q_j \\
\quad \alpha_j = q_j^T z_j \\
\quad z_j = z_j - \sum_{i=1}^j (z_j^T q_i) q_i\\
\quad z_j = z_j - \sum_{i=1}^j (z_j^T q_i) q_i\\
\quad \beta_j = \Vert z_j \Vert_2\\
\quad q_{j+1} = z_j / \Vert z_j \Vert_2 = z_j/\beta_j
\end{array}
</math>

Следующий шаг алгоритма - процедура Рэлея-Ритца. Она зкалючается в интерпретации собственных значений матрицы <math> T_k=Q_k^TAQ_k</math>.
Ее собственные значения приближают собственные значения исходной матрицы. Пусть ''Tk=V<math>\Lambda</math>VT'' - спектральное разложение матрицы ''Tk'', тогда столбцы матрицы ''QkV'' рассматриваются как приближения к соответствующим собственным векторам матрицы ''A'' и называются векторами Ритца. Числа и векторы Ритца являются оптимальными приближениями к собственным значениям и собственным векторам матрицы ''A''.

Поиск собственных значений матрицы ''T'' намного легче, чем для исходной матрицы, так как предполагается, что <math>k << n</math>, и матрица ''T'' - трехдиагональная.

Полная переортогонализация необходима для того, чтобы гарантировать, что каждый полученный вектор ''qj+1'' ортогонален уже имеющимся векторам ''q1..j''. Без этого процесса будут накапливаться существенные вычислительный ошибки.

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

Вычислительным ядро алгоритма состоит ииз двух основных частей:
* <math>Aq=( \sum\nolimits_{i=^n}a_{1i}q_i, \sum\nolimits_{i=2}^na_{2i}q_i, ..., \sum\nolimits_{i=1}^na_{ni}q_i)</math> - умножение симметричной матрицы <math>A</math> размерности <math>n*n</math> на вектор ''q'' размерности ''n''.

* <math>z=z-\sum\nolimits_{i=1}^{k}(z^Tq_i)q_i.</math> - процесс ортогонализации Грама-Шмидта.

=== Макроструктура алгоритма ===
Основные операции алгоритма:

1. Перемножение матрицы на вектор.
<math>b=Ax</math>.

2. Двойная ортогонализация методом Грмма-Шмидта.
<math>z=z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i,</math>
<math>z=z-\alpha_jq_j-\beta_{j}q_{j-1}.</math>

3. Вычисление обновленного базисного вектора.
<math>q_{i+1} = z/ \beta</math>.

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

В параграфе 1.2 приводится полная схема последовательного алгоритма.

Заполняем начальные значения алгоритма (''b'' - начальное преближение).

<math>
\begin{align}
& q_1=b/||b||,\\
& \beta_1=0,\\
&q_0=0, \\
\end{align}
</math>

Для всех <math>j=1..k</math>:

*1. Вычисляется ''j''-й диагональный элемент матрицы <math>T_k</math>: <math>z=Aq_j; \alpha_j=q_j^Tz;</math>

*2. Проводится полная переортогонализация Грамма-Шмидта: <math>z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i;</math>

*3. Вычисляются значения <math>\beta_{j+1}</math> матрицы <math>T_k</math>: <math>\beta_{j+1}=||z||;</math>

*4. Если <math>\beta_{j+1}=0</math>, то алгоритм завершается;

*5. Сохраняем значения для следующей итерации <math>q_{j+1}=z/\beta_{j+1}.</math>

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

*1. Основная часть операций в алгоритме Ланцоша производится во время умножения матрицы <math>A</math> размерности <math>n*n</math> на вектор <math>q</math> размерности <math>n</math> - вычислительная сложность: <math>n^2</math> умножений и <math>n^2-n</math> сложений. Остальные операции основного цикла производят меньше <math>n^2</math> операций сложения или умножения. Так как умножение матрицы на вектор производится <math>k</math> раз, то сложность этой части алгоритма - <math>O(kn^2)</math>
*2. Процесс ортогонализации Грама-Шмидта - вычислительная сложность: <math>k^2n+k(n+2)</math> умножений и <math>k^2n + k(n + 1) + 2</math> сложений. Производится в цикле <math>k</math> раз. Сложность - <math>O(nk^2)</math>
*3. Процесс разложения матрицы <math>T</math> размерности <math>k*k</math>. Сложность - <math>O(k^2)</math>

Так как число итераций много меньше размерности матрицы <math>A</math>, <math>k << n</math>, то общая сложность алгоритма сокращается до <math>O(kn^2)</math>.

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

[[Файл:Lanczos.png|center|300px|'''Рис. 1.''' Граф ''j''-й итерации.]]

Черные маленькие стрелочки - куда идут данные.

Большие стрелочки - обозначение прохода по массиву (изменение индекса)

В больших кружках преобразования (операции над данными или вычисления)

В маленьких кружках запись в переменную.

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

Алгоритм Ланцоша - итерационный, итерации должны выполняться в строгой последовательности, и нет возможности их параллелизовать. Внутри одной итерации алгоритма ресурсами параллелизма могут быть:
*1. умножение матрицы размерности <math>n * n</math> на вектор длины <math>n</math> требует последовательного выполнения <math>n</math> ярусов умножений и сложений;
*2. вычисление <math>\alpha_j</math> требует <math>n</math> ярусов сложений с 1 операцией умножения в каждом;
*3. переортагонализация требует вычисления <math>j</math> ярусов сложений с <math>n</math> операциями умножения в каждом, <math>n</math> ярусов сложений с <math>j</math> операциями умножения в каждом;
*4. вычисление нормы вектора длины <math>n</math> требует <math>n</math> ярусов сложений с <math>1</math> операцией умножения в каждом.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': <math>A\in\mathbb{R}^{n\times n}</math> - симметричная матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>. Объем данных: <math>\frac{n (n + 1)}{2}</math>.

'''Выходные данные''': <math>\Lambda</math> - вектор собственных значений матрицы и соответствующие им собственные вектора <math>v_i,i=1,\ldots, k </math>. Объем данных: <math> k(n+1) </math>.

=== Свойства алгоритма ===
* В классическом алгоритме Ланцоша возникает большая погрешность при округлении чисел с плавающей точкой. Выбранный вариант с полной переортогонализацией устраняет этот недостаток, однако является более ресурсоемким. На практике наиболее популярен вариант с частичной переортогонализацией.
* Вычислительная мощность алгоритма (отношение числа операций к суммарному объему данных) оценивается как <math>\approx 2k</math>.
* Преимуществом алгоритма является то, что он начинает поиск собственных значений матрицы начиная с максимального в абсолютном смысле значения.
* Нет необходимости хранения исходной матрицы на каждом вычислительном ядре, так как метод использует исходную матрицу только в операциях умножения матрицы на вектор, что позволяет эффективно использовать регулярность структуры матрицы.
* Существует модифицированный блочный вариант алгоритма, применяемый в случае кратных собственных значений.

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

=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Проверка масштабируемости алгоритма проходила на [//hpc.cmc.msu.ru/ IBM Blue Gene/P ВМК МГУ.]

Используемые компиляторы: intel/15.0.090 и OpenMPI/1.8.4-icc.

Для проведения расчетов и получения полноценной картины поведения алгоритма в зависимости от входных данных и числа процессоров, программа была запущена на следующих параметрах:
* размеры входной матрицы: [5000:30000] c шагом 5000;
* число процессоров: от 1, 2, 4 .. 64.

Сборка осуществлялась с параметрами:
*openmpi/1.5.5-icc
*intel/13.1.0

[[Файл:Lancos prof.jpg|центр|мини|800x800пкс|Рис. 2. Зависимость времени выполнения программы от входных данных]]

По графику видно, что время выполнения уменьшается с увеличением количества процессоров примерно до 16, дальше начинает медленно увеличиваться вплоть до 64 и далее. Это можно объяснить тем, что с увеличением количества вычислительных ядер растет количество передаваемых данных, и дальнейшее увеличение их числа только ухудшает положение.

[http://pastebin.com/sWQ9ihcW код программы]

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

The IETL Project http://www.comp-phys.org/software/ietl/ C++

NAG Library http://www.nag.com/content/nag-library C, C++, Fortran, C#, MATLAB, R

ARPACK https://people.sc.fsu.edu/~jburkardt/m_src/arpack/arpack.html MATLAB

GrapLab https://turi.com/products/create/open_source.html C++

LANSO/PLANSO http://web.cs.ucdavis.edu/~bai/ET/lanczos_methods/overview_PLANSO.html Fortran (уже распараллелена)

Julia Math https://github.com/JuliaMath/IterativeSolvers.jl Julia

SciPy https://scipy.org/ Python

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

Дж. Деммель «Вычислительная линейная алгебра» (стр. 391)

<references \>

#[[Категория:Законченные статьи]]
#[[Категория:Разложения матриц]]

Учacтник:Malikovmt/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией

2017-02-06T21:11:41Z

Malikovmt: /* Информационный граф */

{{algorithm
| name = Алгоритм Ланцоша с полной переортогонализацией
| serial_complexity = <math>O(n^2k)</math>
| input_data = <math>\frac{n(n + 1)}{2}</math>
| output_data = <math>k(n + 1)</math>
}}

Авторы: [[Участник:Eroshkin|А.В.Ерошкин]] ([[#Масштабируемость алгоритма и его реализации|ссылкаКод]]), [[Участник:Malikovmt|М.М.Маликов]] ([[#Описание алгоритма|ссылка]])

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

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

'''Алгоритм Ланцоша''' - итерационный метод, используемый для вычисления части собственных значений и соответствующих им собственных векторов матрицы <math>A</math> размера <math>n*n</math>, изначально разработанный Корнелием Ланцошем. Преимуществами использования метода является относительно небольшое потребление памяти и вычислительных ресурсов, а также наличие параметра <math>k << n</math>, контролирующего количество итераций. Несмотря на то, что алгоритм является вычислительно эффективным, первоначально сформулированный метод был плохо применим из-за численной неустойчивости - метод хорошо работал на целочисленных значениях, однако в арифметике с плавающей точкой ошибки округления давали большую погрешность. В 1970 году Ojalvo и Newman показали, как сделать метод численно стабильным и применили его для расчета крупных инженерных сооружений, подверженных динамическим нагрузкам. Кроме того, они показали способ выбора начального приближения (с использованием ГПСЧ), а также эмпирический способ для выбора числа <math>k</math> (примерно в полтора раза больше искомого числа собственных векторов). В данный момент существует две основных модификации метода (с полной и выборочной переортогонализацией), а также большое количество модификаций, использующихся в различных технических областях. Алгоритм используется для больших <math>n</math>.

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

Первый этап алгоритма - использование метода Ланцоша для построения крыловского подпространства: <math> K_k(A,x) = span[x_1, Ax_1, A^2x_1, ..., A^{k-1}x_1] </math>. Входные данные алгоритма: квадратная симметричная матрица <math>A</math> размерности <math>n*n</math>, вектор начального приближения <math>b</math>, а так же число итераций <math>k</math>. Метод осуществляет поиск трехдиагональной симметричной матрицы <math>T_k=Q_k^TAQ_k</math>.

<math>T_k=\begin{bmatrix}
\alpha_1 & \beta_2 \\
\beta_2 & \alpha_2 & \beta_3 &\\
&. & . & .\\
&&\beta_{k-1} & \alpha_{k-1} & \beta_k\\
&&&\beta_k & \alpha_k
\end{bmatrix}</math>

Описание метода:

<math>
\begin{array}{l}
q_1 = b / \Vert b \Vert_2\\
j = \overline{1, k}:\\
\quad z_j = A q_j \\
\quad \alpha_j = q_j^T z_j \\
\quad z_j = z_j - \sum_{i=1}^j (z_j^T q_i) q_i\\
\quad z_j = z_j - \sum_{i=1}^j (z_j^T q_i) q_i\\
\quad \beta_j = \Vert z_j \Vert_2\\
\quad q_{j+1} = z_j / \Vert z_j \Vert_2 = z_j/\beta_j
\end{array}
</math>

Следующий шаг алгоритма - процедура Рэлея-Ритца. Она зкалючается в интерпретации собственных значений матрицы <math> T_k=Q_k^TAQ_k</math>.
Ее собственные значения приближают собственные значения исходной матрицы. Пусть ''Tk=V<math>\Lambda</math>VT'' - спектральное разложение матрицы ''Tk'', тогда столбцы матрицы ''QkV'' рассматриваются как приближения к соответствующим собственным векторам матрицы ''A'' и называются векторами Ритца. Числа и векторы Ритца являются оптимальными приближениями к собственным значениям и собственным векторам матрицы ''A''.

Поиск собственных значений матрицы ''T'' намного легче, чем для исходной матрицы, так как предполагается, что <math>k << n</math>, и матрица ''T'' - трехдиагональная.

Полная переортогонализация необходима для того, чтобы гарантировать, что каждый полученный вектор ''qj+1'' ортогонален уже имеющимся векторам ''q1..j''. Без этого процесса будут накапливаться существенные вычислительный ошибки.

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

Вычислительным ядро алгоритма состоит ииз двух основных частей:
* <math>Aq=( \sum\nolimits_{i=^n}a_{1i}q_i, \sum\nolimits_{i=2}^na_{2i}q_i, ..., \sum\nolimits_{i=1}^na_{ni}q_i)</math> - умножение симметричной матрицы <math>A</math> размерности <math>n*n</math> на вектор ''q'' размерности ''n''.

* <math>z=z-\sum\nolimits_{i=1}^{k}(z^Tq_i)q_i.</math> - процесс ортогонализации Грама-Шмидта.

=== Макроструктура алгоритма ===
Основные операции алгоритма:

1. Перемножение матрицы на вектор.
<math>b=Ax</math>.

2. Двойная ортогонализация методом Грмма-Шмидта.
<math>z=z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i,</math>
<math>z=z-\alpha_jq_j-\beta_{j}q_{j-1}.</math>

3. Вычисление обновленного базисного вектора.
<math>q_{i+1} = z/ \beta</math>.

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

В параграфе 1.2 приводится полная схема последовательного алгоритма.

Заполняем начальные значения алгоритма (''b'' - начальное преближение).

<math>
\begin{align}
& q_1=b/||b||,\\
& \beta_1=0,\\
&q_0=0, \\
\end{align}
</math>

Для всех <math>j=1..k</math>:

*1. Вычисляется ''j''-й диагональный элемент матрицы <math>T_k</math>: <math>z=Aq_j; \alpha_j=q_j^Tz;</math>

*2. Проводится полная переортогонализация Грамма-Шмидта: <math>z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i;</math>

*3. Вычисляются значения <math>\beta_{j+1}</math> матрицы <math>T_k</math>: <math>\beta_{j+1}=||z||;</math>

*4. Если <math>\beta_{j+1}=0</math>, то алгоритм завершается;

*5. Сохраняем значения для следующей итерации <math>q_{j+1}=z/\beta_{j+1}.</math>

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

*1. Основная часть операций в алгоритме Ланцоша производится во время умножения матрицы <math>A</math> размерности <math>n*n</math> на вектор <math>q</math> размерности <math>n</math> - вычислительная сложность: <math>n^2</math> умножений и <math>n^2-n</math> сложений. Остальные операции основного цикла производят меньше <math>n^2</math> операций сложения или умножения. Так как умножение матрицы на вектор производится <math>k</math> раз, то сложность этой части алгоритма - <math>O(kn^2)</math>
*2. Процесс ортогонализации Грама-Шмидта - вычислительная сложность: <math>k^2n+k(n+2)</math> умножений и <math>k^2n + k(n + 1) + 2</math> сложений. Производится в цикле <math>k</math> раз. Сложность - <math>O(nk^2)</math>
*3. Процесс разложения матрицы <math>T</math> размерности <math>k*k</math>. Сложность - <math>O(k^2)</math>

Так как число итераций много меньше размерности матрицы <math>A</math>, <math>k << n</math>, то общая сложность алгоритма сокращается до <math>O(kn^2)</math>.

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

[[Файл:Lanczos.png|center|300px|'''Рис. 1.''' Граф ''j''-й итерации.]]

Черные маленькие стрелочки - куда идут данные.

Большие стрелочки - обозначение прохода по массиву (изменение индекса)

В больших кружках преобразования (операции над данными или вычисления)

В маленьких кружках запись в переменную.

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

Алгоритм Ланцоша - итерационный, итерации должны выполняться в строгой последовательности, и нет возможности их параллелизовать. Внутри одной итерации алгоритма ресурсами параллелизма могут быть:
*1. умножение матрицы размерности <math>n * n</math> на вектор длины <math>n</math> требует последовательного выполнения <math>n</math> ярусов умножений и сложений;
*2. вычисление <math>\alpha_j</math> требует <math>n</math> ярусов сложений с 1 операцией умножения в каждом;
*3. переортагонализация требует вычисления <math>j</math> ярусов сложений с <math>n</math> операциями умножения в каждом, <math>n</math> ярусов сложений с <math>j</math> операциями умножения в каждом;
*4. вычисление нормы вектора длины <math>n</math> требует <math>n</math> ярусов сложений с <math>1</math> операцией умножения в каждом.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': <math>A\in\mathbb{R}^{n\times n}</math> - симметричная матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>. Объем данных: <math>\frac{n (n + 1)}{2}</math>.

'''Выходные данные''': <math>\Lambda</math> - вектор собственных значений матрицы и соответствующие им собственные вектора <math>v_i,i=1,\ldots, k </math>. Объем данных: <math> k(n+1) </math>.

=== Свойства алгоритма ===
* В классическом алгоритме Ланцоша возникает большая погрешность при округлении чисел с плавающей точкой. Выбранный вариант с полной переортогонализацией устраняет этот недостаток, однако является более ресурсоемким. На практике наиболее популярен вариант с частичной переортогонализацией.
* Вычислительная мощность алгоритма (отношение числа операций к суммарному объему данных) оценивается как <math>\approx 2k</math>.
* Преимуществом алгоритма является то, что он начинает поиск собственных значений матрицы начиная с максимального в абсолютном смысле значения.
* Нет необходимости хранения исходной матрицы на каждом вычислительном ядре, так как метод использует исходную матрицу только в операциях умножения матрицы на вектор, что позволяет эффективно использовать регулярность структуры матрицы.
* Существует модифицированный блочный вариант алгоритма, применяемый в случае кратных собственных значений.

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

=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Проверка масштабируемости алгоритма проходила на [//hpc.cmc.msu.ru/ IBM Blue Gene/P ВМК МГУ.]

Используемые компиляторы: intel/15.0.090 и OpenMPI/1.8.4-icc.

Для проведения расчетов и получения полноценной картины поведения алгоритма в зависимости от входных данных и числа процессоров, программа была запущена на следующих параметрах:
* размеры входной матрицы: [5000:30000] c шагом 5000;
* число процессоров: от 1, 2, 4 .. 64.

[[Файл:Lancos prof.jpg|центр|мини|800x800пкс|Рис. 2. Зависимость времени выполнения программы от входных данных]]

По графику видно, что время выполнения уменьшается с увеличением количества процессоров примерно до 16, дальше начинает медленно увеличиваться вплоть до 64 и далее. Это можно объяснить тем, что с увеличением количества вычислительных ядер растет количество передаваемых данных, и дальнейшее увеличение их числа только ухудшает положение.

[http://pastebin.com/sWQ9ihcW код программы]

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

The IETL Project http://www.comp-phys.org/software/ietl/ C++

NAG Library http://www.nag.com/content/nag-library C, C++, Fortran, C#, MATLAB, R

ARPACK https://people.sc.fsu.edu/~jburkardt/m_src/arpack/arpack.html MATLAB

GrapLab https://turi.com/products/create/open_source.html C++

LANSO/PLANSO http://web.cs.ucdavis.edu/~bai/ET/lanczos_methods/overview_PLANSO.html Fortran (уже распараллелена)

Julia Math https://github.com/JuliaMath/IterativeSolvers.jl Julia

SciPy https://scipy.org/ Python

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

Дж. Деммель «Вычислительная линейная алгебра» (стр. 391)

<references \>

#[[Категория:Законченные статьи]]
#[[Категория:Разложения матриц]]

Учacтник:Malikovmt/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией

2017-02-06T21:03:57Z

Malikovmt: /* Макроструктура алгоритма */

{{algorithm
| name = Алгоритм Ланцоша с полной переортогонализацией
| serial_complexity = <math>O(n^2k)</math>
| input_data = <math>\frac{n(n + 1)}{2}</math>
| output_data = <math>k(n + 1)</math>
}}

Авторы: [[Участник:Eroshkin|А.В.Ерошкин]] ([[#Масштабируемость алгоритма и его реализации|ссылкаКод]]), [[Участник:Malikovmt|М.М.Маликов]] ([[#Описание алгоритма|ссылка]])

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

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

'''Алгоритм Ланцоша''' - итерационный метод, используемый для вычисления части собственных значений и соответствующих им собственных векторов матрицы <math>A</math> размера <math>n*n</math>, изначально разработанный Корнелием Ланцошем. Преимуществами использования метода является относительно небольшое потребление памяти и вычислительных ресурсов, а также наличие параметра <math>k << n</math>, контролирующего количество итераций. Несмотря на то, что алгоритм является вычислительно эффективным, первоначально сформулированный метод был плохо применим из-за численной неустойчивости - метод хорошо работал на целочисленных значениях, однако в арифметике с плавающей точкой ошибки округления давали большую погрешность. В 1970 году Ojalvo и Newman показали, как сделать метод численно стабильным и применили его для расчета крупных инженерных сооружений, подверженных динамическим нагрузкам. Кроме того, они показали способ выбора начального приближения (с использованием ГПСЧ), а также эмпирический способ для выбора числа <math>k</math> (примерно в полтора раза больше искомого числа собственных векторов). В данный момент существует две основных модификации метода (с полной и выборочной переортогонализацией), а также большое количество модификаций, использующихся в различных технических областях. Алгоритм используется для больших <math>n</math>.

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

Первый этап алгоритма - использование метода Ланцоша для построения крыловского подпространства: <math> K_k(A,x) = span[x_1, Ax_1, A^2x_1, ..., A^{k-1}x_1] </math>. Входные данные алгоритма: квадратная симметричная матрица <math>A</math> размерности <math>n*n</math>, вектор начального приближения <math>b</math>, а так же число итераций <math>k</math>. Метод осуществляет поиск трехдиагональной симметричной матрицы <math>T_k=Q_k^TAQ_k</math>.

<math>T_k=\begin{bmatrix}
\alpha_1 & \beta_2 \\
\beta_2 & \alpha_2 & \beta_3 &\\
&. & . & .\\
&&\beta_{k-1} & \alpha_{k-1} & \beta_k\\
&&&\beta_k & \alpha_k
\end{bmatrix}</math>

Описание метода:

<math>
\begin{array}{l}
q_1 = b / \Vert b \Vert_2\\
j = \overline{1, k}:\\
\quad z_j = A q_j \\
\quad \alpha_j = q_j^T z_j \\
\quad z_j = z_j - \sum_{i=1}^j (z_j^T q_i) q_i\\
\quad z_j = z_j - \sum_{i=1}^j (z_j^T q_i) q_i\\
\quad \beta_j = \Vert z_j \Vert_2\\
\quad q_{j+1} = z_j / \Vert z_j \Vert_2 = z_j/\beta_j
\end{array}
</math>

Следующий шаг алгоритма - процедура Рэлея-Ритца. Она зкалючается в интерпретации собственных значений матрицы <math> T_k=Q_k^TAQ_k</math>.
Ее собственные значения приближают собственные значения исходной матрицы. Пусть ''Tk=V<math>\Lambda</math>VT'' - спектральное разложение матрицы ''Tk'', тогда столбцы матрицы ''QkV'' рассматриваются как приближения к соответствующим собственным векторам матрицы ''A'' и называются векторами Ритца. Числа и векторы Ритца являются оптимальными приближениями к собственным значениям и собственным векторам матрицы ''A''.

Поиск собственных значений матрицы ''T'' намного легче, чем для исходной матрицы, так как предполагается, что <math>k << n</math>, и матрица ''T'' - трехдиагональная.

Полная переортогонализация необходима для того, чтобы гарантировать, что каждый полученный вектор ''qj+1'' ортогонален уже имеющимся векторам ''q1..j''. Без этого процесса будут накапливаться существенные вычислительный ошибки.

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

Вычислительным ядро алгоритма состоит ииз двух основных частей:
* <math>Aq=( \sum\nolimits_{i=^n}a_{1i}q_i, \sum\nolimits_{i=2}^na_{2i}q_i, ..., \sum\nolimits_{i=1}^na_{ni}q_i)</math> - умножение симметричной матрицы <math>A</math> размерности <math>n*n</math> на вектор ''q'' размерности ''n''.

* <math>z=z-\sum\nolimits_{i=1}^{k}(z^Tq_i)q_i.</math> - процесс ортогонализации Грама-Шмидта.

=== Макроструктура алгоритма ===
Основные операции алгоритма:

1. Перемножение матрицы на вектор.
<math>b=Ax</math>.

2. Двойная ортогонализация методом Грмма-Шмидта.
<math>z=z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i,</math>
<math>z=z-\alpha_jq_j-\beta_{j}q_{j-1}.</math>

3. Вычисление обновленного базисного вектора.
<math>q_{i+1} = z/ \beta</math>.

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

В параграфе 1.2 приводится полная схема последовательного алгоритма.

Заполняем начальные значения алгоритма (''b'' - начальное преближение).

<math>
\begin{align}
& q_1=b/||b||,\\
& \beta_1=0,\\
&q_0=0, \\
\end{align}
</math>

Для всех <math>j=1..k</math>:

*1. Вычисляется ''j''-й диагональный элемент матрицы <math>T_k</math>: <math>z=Aq_j; \alpha_j=q_j^Tz;</math>

*2. Проводится полная переортогонализация Грамма-Шмидта: <math>z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i;</math>

*3. Вычисляются значения <math>\beta_{j+1}</math> матрицы <math>T_k</math>: <math>\beta_{j+1}=||z||;</math>

*4. Если <math>\beta_{j+1}=0</math>, то алгоритм завершается;

*5. Сохраняем значения для следующей итерации <math>q_{j+1}=z/\beta_{j+1}.</math>

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

*1. Основная часть операций в алгоритме Ланцоша производится во время умножения матрицы <math>A</math> размерности <math>n*n</math> на вектор <math>q</math> размерности <math>n</math> - вычислительная сложность: <math>n^2</math> умножений и <math>n^2-n</math> сложений. Остальные операции основного цикла производят меньше <math>n^2</math> операций сложения или умножения. Так как умножение матрицы на вектор производится <math>k</math> раз, то сложность этой части алгоритма - <math>O(kn^2)</math>
*2. Процесс ортогонализации Грама-Шмидта - вычислительная сложность: <math>k^2n+k(n+2)</math> умножений и <math>k^2n + k(n + 1) + 2</math> сложений. Производится в цикле <math>k</math> раз. Сложность - <math>O(nk^2)</math>
*3. Процесс разложения матрицы <math>T</math> размерности <math>k*k</math>. Сложность - <math>O(k^2)</math>

Так как число итераций много меньше размерности матрицы <math>A</math>, <math>k << n</math>, то общая сложность алгоритма сокращается до <math>O(kn^2)</math>.

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

[[Файл:Lanczos.png|center|300px|'''Рис. 1.''' Граф ''j''-й итерации.]]

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

Алгоритм Ланцоша - итерационный, итерации должны выполняться в строгой последовательности, и нет возможности их параллелизовать. Внутри одной итерации алгоритма ресурсами параллелизма могут быть:
*1. умножение матрицы размерности <math>n * n</math> на вектор длины <math>n</math> требует последовательного выполнения <math>n</math> ярусов умножений и сложений;
*2. вычисление <math>\alpha_j</math> требует <math>n</math> ярусов сложений с 1 операцией умножения в каждом;
*3. переортагонализация требует вычисления <math>j</math> ярусов сложений с <math>n</math> операциями умножения в каждом, <math>n</math> ярусов сложений с <math>j</math> операциями умножения в каждом;
*4. вычисление нормы вектора длины <math>n</math> требует <math>n</math> ярусов сложений с <math>1</math> операцией умножения в каждом.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': <math>A\in\mathbb{R}^{n\times n}</math> - симметричная матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>. Объем данных: <math>\frac{n (n + 1)}{2}</math>.

'''Выходные данные''': <math>\Lambda</math> - вектор собственных значений матрицы и соответствующие им собственные вектора <math>v_i,i=1,\ldots, k </math>. Объем данных: <math> k(n+1) </math>.

=== Свойства алгоритма ===
* В классическом алгоритме Ланцоша возникает большая погрешность при округлении чисел с плавающей точкой. Выбранный вариант с полной переортогонализацией устраняет этот недостаток, однако является более ресурсоемким. На практике наиболее популярен вариант с частичной переортогонализацией.
* Вычислительная мощность алгоритма (отношение числа операций к суммарному объему данных) оценивается как <math>\approx 2k</math>.
* Преимуществом алгоритма является то, что он начинает поиск собственных значений матрицы начиная с максимального в абсолютном смысле значения.
* Нет необходимости хранения исходной матрицы на каждом вычислительном ядре, так как метод использует исходную матрицу только в операциях умножения матрицы на вектор, что позволяет эффективно использовать регулярность структуры матрицы.
* Существует модифицированный блочный вариант алгоритма, применяемый в случае кратных собственных значений.

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

=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Проверка масштабируемости алгоритма проходила на [//hpc.cmc.msu.ru/ IBM Blue Gene/P ВМК МГУ.]

Используемые компиляторы: intel/15.0.090 и OpenMPI/1.8.4-icc.

Для проведения расчетов и получения полноценной картины поведения алгоритма в зависимости от входных данных и числа процессоров, программа была запущена на следующих параметрах:
* размеры входной матрицы: [5000:30000] c шагом 5000;
* число процессоров: от 1, 2, 4 .. 64.

[[Файл:Lancos prof.jpg|центр|мини|800x800пкс|Рис. 2. Зависимость времени выполнения программы от входных данных]]

По графику видно, что время выполнения уменьшается с увеличением количества процессоров примерно до 16, дальше начинает медленно увеличиваться вплоть до 64 и далее. Это можно объяснить тем, что с увеличением количества вычислительных ядер растет количество передаваемых данных, и дальнейшее увеличение их числа только ухудшает положение.

[http://pastebin.com/sWQ9ihcW код программы]

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

The IETL Project http://www.comp-phys.org/software/ietl/ C++

NAG Library http://www.nag.com/content/nag-library C, C++, Fortran, C#, MATLAB, R

ARPACK https://people.sc.fsu.edu/~jburkardt/m_src/arpack/arpack.html MATLAB

GrapLab https://turi.com/products/create/open_source.html C++

LANSO/PLANSO http://web.cs.ucdavis.edu/~bai/ET/lanczos_methods/overview_PLANSO.html Fortran (уже распараллелена)

Julia Math https://github.com/JuliaMath/IterativeSolvers.jl Julia

SciPy https://scipy.org/ Python

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

Дж. Деммель «Вычислительная линейная алгебра» (стр. 391)

<references \>

#[[Категория:Законченные статьи]]
#[[Категория:Разложения матриц]]

Учacтник:Malikovmt/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией

2017-02-06T21:02:27Z

Malikovmt: /* Макроструктура алгоритма */

{{algorithm
| name = Алгоритм Ланцоша с полной переортогонализацией
| serial_complexity = <math>O(n^2k)</math>
| input_data = <math>\frac{n(n + 1)}{2}</math>
| output_data = <math>k(n + 1)</math>
}}

Авторы: [[Участник:Eroshkin|А.В.Ерошкин]] ([[#Масштабируемость алгоритма и его реализации|ссылкаКод]]), [[Участник:Malikovmt|М.М.Маликов]] ([[#Описание алгоритма|ссылка]])

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

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

'''Алгоритм Ланцоша''' - итерационный метод, используемый для вычисления части собственных значений и соответствующих им собственных векторов матрицы <math>A</math> размера <math>n*n</math>, изначально разработанный Корнелием Ланцошем. Преимуществами использования метода является относительно небольшое потребление памяти и вычислительных ресурсов, а также наличие параметра <math>k << n</math>, контролирующего количество итераций. Несмотря на то, что алгоритм является вычислительно эффективным, первоначально сформулированный метод был плохо применим из-за численной неустойчивости - метод хорошо работал на целочисленных значениях, однако в арифметике с плавающей точкой ошибки округления давали большую погрешность. В 1970 году Ojalvo и Newman показали, как сделать метод численно стабильным и применили его для расчета крупных инженерных сооружений, подверженных динамическим нагрузкам. Кроме того, они показали способ выбора начального приближения (с использованием ГПСЧ), а также эмпирический способ для выбора числа <math>k</math> (примерно в полтора раза больше искомого числа собственных векторов). В данный момент существует две основных модификации метода (с полной и выборочной переортогонализацией), а также большое количество модификаций, использующихся в различных технических областях. Алгоритм используется для больших <math>n</math>.

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

Первый этап алгоритма - использование метода Ланцоша для построения крыловского подпространства: <math> K_k(A,x) = span[x_1, Ax_1, A^2x_1, ..., A^{k-1}x_1] </math>. Входные данные алгоритма: квадратная симметричная матрица <math>A</math> размерности <math>n*n</math>, вектор начального приближения <math>b</math>, а так же число итераций <math>k</math>. Метод осуществляет поиск трехдиагональной симметричной матрицы <math>T_k=Q_k^TAQ_k</math>.

<math>T_k=\begin{bmatrix}
\alpha_1 & \beta_2 \\
\beta_2 & \alpha_2 & \beta_3 &\\
&. & . & .\\
&&\beta_{k-1} & \alpha_{k-1} & \beta_k\\
&&&\beta_k & \alpha_k
\end{bmatrix}</math>

Описание метода:

<math>
\begin{array}{l}
q_1 = b / \Vert b \Vert_2\\
j = \overline{1, k}:\\
\quad z_j = A q_j \\
\quad \alpha_j = q_j^T z_j \\
\quad z_j = z_j - \sum_{i=1}^j (z_j^T q_i) q_i\\
\quad z_j = z_j - \sum_{i=1}^j (z_j^T q_i) q_i\\
\quad \beta_j = \Vert z_j \Vert_2\\
\quad q_{j+1} = z_j / \Vert z_j \Vert_2 = z_j/\beta_j
\end{array}
</math>

Следующий шаг алгоритма - процедура Рэлея-Ритца. Она зкалючается в интерпретации собственных значений матрицы <math> T_k=Q_k^TAQ_k</math>.
Ее собственные значения приближают собственные значения исходной матрицы. Пусть ''Tk=V<math>\Lambda</math>VT'' - спектральное разложение матрицы ''Tk'', тогда столбцы матрицы ''QkV'' рассматриваются как приближения к соответствующим собственным векторам матрицы ''A'' и называются векторами Ритца. Числа и векторы Ритца являются оптимальными приближениями к собственным значениям и собственным векторам матрицы ''A''.

Поиск собственных значений матрицы ''T'' намного легче, чем для исходной матрицы, так как предполагается, что <math>k << n</math>, и матрица ''T'' - трехдиагональная.

Полная переортогонализация необходима для того, чтобы гарантировать, что каждый полученный вектор ''qj+1'' ортогонален уже имеющимся векторам ''q1..j''. Без этого процесса будут накапливаться существенные вычислительный ошибки.

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

Вычислительным ядро алгоритма состоит ииз двух основных частей:
* <math>Aq=( \sum\nolimits_{i=^n}a_{1i}q_i, \sum\nolimits_{i=2}^na_{2i}q_i, ..., \sum\nolimits_{i=1}^na_{ni}q_i)</math> - умножение симметричной матрицы <math>A</math> размерности <math>n*n</math> на вектор ''q'' размерности ''n''.

* <math>z=z-\sum\nolimits_{i=1}^{k}(z^Tq_i)q_i.</math> - процесс ортогонализации Грама-Шмидта.

=== Макроструктура алгоритма ===
Основные операции алгоритма:
1. Перемножение матрицы на вектор.
<math>b=Ax</math>.

2. Двойная ортогонализация методом Грмма-Шмидта.
<math>z=z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i,</math>
<math>z=z-\alpha_jq_j-\beta_{j}q_{j-1}.</math>

3. Вычисление обновленного базисного вектора.
<math>q_{i+1} = z/ \beta</math>.

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

В параграфе 1.2 приводится полная схема последовательного алгоритма.

Заполняем начальные значения алгоритма (''b'' - начальное преближение).

<math>
\begin{align}
& q_1=b/||b||,\\
& \beta_1=0,\\
&q_0=0, \\
\end{align}
</math>

Для всех <math>j=1..k</math>:

*1. Вычисляется ''j''-й диагональный элемент матрицы <math>T_k</math>: <math>z=Aq_j; \alpha_j=q_j^Tz;</math>

*2. Проводится полная переортогонализация Грамма-Шмидта: <math>z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i;</math>

*3. Вычисляются значения <math>\beta_{j+1}</math> матрицы <math>T_k</math>: <math>\beta_{j+1}=||z||;</math>

*4. Если <math>\beta_{j+1}=0</math>, то алгоритм завершается;

*5. Сохраняем значения для следующей итерации <math>q_{j+1}=z/\beta_{j+1}.</math>

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

*1. Основная часть операций в алгоритме Ланцоша производится во время умножения матрицы <math>A</math> размерности <math>n*n</math> на вектор <math>q</math> размерности <math>n</math> - вычислительная сложность: <math>n^2</math> умножений и <math>n^2-n</math> сложений. Остальные операции основного цикла производят меньше <math>n^2</math> операций сложения или умножения. Так как умножение матрицы на вектор производится <math>k</math> раз, то сложность этой части алгоритма - <math>O(kn^2)</math>
*2. Процесс ортогонализации Грама-Шмидта - вычислительная сложность: <math>k^2n+k(n+2)</math> умножений и <math>k^2n + k(n + 1) + 2</math> сложений. Производится в цикле <math>k</math> раз. Сложность - <math>O(nk^2)</math>
*3. Процесс разложения матрицы <math>T</math> размерности <math>k*k</math>. Сложность - <math>O(k^2)</math>

Так как число итераций много меньше размерности матрицы <math>A</math>, <math>k << n</math>, то общая сложность алгоритма сокращается до <math>O(kn^2)</math>.

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

[[Файл:Lanczos.png|center|300px|'''Рис. 1.''' Граф ''j''-й итерации.]]

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

Алгоритм Ланцоша - итерационный, итерации должны выполняться в строгой последовательности, и нет возможности их параллелизовать. Внутри одной итерации алгоритма ресурсами параллелизма могут быть:
*1. умножение матрицы размерности <math>n * n</math> на вектор длины <math>n</math> требует последовательного выполнения <math>n</math> ярусов умножений и сложений;
*2. вычисление <math>\alpha_j</math> требует <math>n</math> ярусов сложений с 1 операцией умножения в каждом;
*3. переортагонализация требует вычисления <math>j</math> ярусов сложений с <math>n</math> операциями умножения в каждом, <math>n</math> ярусов сложений с <math>j</math> операциями умножения в каждом;
*4. вычисление нормы вектора длины <math>n</math> требует <math>n</math> ярусов сложений с <math>1</math> операцией умножения в каждом.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': <math>A\in\mathbb{R}^{n\times n}</math> - симметричная матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>. Объем данных: <math>\frac{n (n + 1)}{2}</math>.

'''Выходные данные''': <math>\Lambda</math> - вектор собственных значений матрицы и соответствующие им собственные вектора <math>v_i,i=1,\ldots, k </math>. Объем данных: <math> k(n+1) </math>.

=== Свойства алгоритма ===
* В классическом алгоритме Ланцоша возникает большая погрешность при округлении чисел с плавающей точкой. Выбранный вариант с полной переортогонализацией устраняет этот недостаток, однако является более ресурсоемким. На практике наиболее популярен вариант с частичной переортогонализацией.
* Вычислительная мощность алгоритма (отношение числа операций к суммарному объему данных) оценивается как <math>\approx 2k</math>.
* Преимуществом алгоритма является то, что он начинает поиск собственных значений матрицы начиная с максимального в абсолютном смысле значения.
* Нет необходимости хранения исходной матрицы на каждом вычислительном ядре, так как метод использует исходную матрицу только в операциях умножения матрицы на вектор, что позволяет эффективно использовать регулярность структуры матрицы.
* Существует модифицированный блочный вариант алгоритма, применяемый в случае кратных собственных значений.

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

=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Проверка масштабируемости алгоритма проходила на [//hpc.cmc.msu.ru/ IBM Blue Gene/P ВМК МГУ.]

Используемые компиляторы: intel/15.0.090 и OpenMPI/1.8.4-icc.

Для проведения расчетов и получения полноценной картины поведения алгоритма в зависимости от входных данных и числа процессоров, программа была запущена на следующих параметрах:
* размеры входной матрицы: [5000:30000] c шагом 5000;
* число процессоров: от 1, 2, 4 .. 64.

[[Файл:Lancos prof.jpg|центр|мини|800x800пкс|Рис. 2. Зависимость времени выполнения программы от входных данных]]

По графику видно, что время выполнения уменьшается с увеличением количества процессоров примерно до 16, дальше начинает медленно увеличиваться вплоть до 64 и далее. Это можно объяснить тем, что с увеличением количества вычислительных ядер растет количество передаваемых данных, и дальнейшее увеличение их числа только ухудшает положение.

[http://pastebin.com/sWQ9ihcW код программы]

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

The IETL Project http://www.comp-phys.org/software/ietl/ C++

NAG Library http://www.nag.com/content/nag-library C, C++, Fortran, C#, MATLAB, R

ARPACK https://people.sc.fsu.edu/~jburkardt/m_src/arpack/arpack.html MATLAB

GrapLab https://turi.com/products/create/open_source.html C++

LANSO/PLANSO http://web.cs.ucdavis.edu/~bai/ET/lanczos_methods/overview_PLANSO.html Fortran (уже распараллелена)

Julia Math https://github.com/JuliaMath/IterativeSolvers.jl Julia

SciPy https://scipy.org/ Python

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

Дж. Деммель «Вычислительная линейная алгебра» (стр. 391)

<references \>

#[[Категория:Законченные статьи]]
#[[Категория:Разложения матриц]]

Учacтник:Malikovmt/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией

2017-02-01T22:08:31Z

Malikovmt:

{{algorithm
| name = Алгоритм Ланцоша с полной переортогонализацией
| serial_complexity = <math>O(n^2k)</math>
| input_data = <math>\frac{n(n + 1)}{2}</math>
| output_data = <math>k(n + 1)</math>
}}

{{Assignment}}

Авторы: [[Участник:Eroshkin|А.В.Ерошкин]] ([[#Масштабируемость алгоритма и его реализации|ссылкаКод]]), [[Участник:Malikovmt|М.М.Маликов]] ([[#Описание алгоритма|ссылка]])

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

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

'''Алгоритм Ланцоша''' - итерационный метод, используемый для вычисления части собственных значений и соответствующих им собственных векторов матрицы <math>A</math> размера <math>n*n</math>, изначально разработанный Корнелием Ланцошем. Преимуществами использования метода является относительно небольшое потребление памяти и вычислительных ресурсов, а также наличие параметра <math>k << n</math>, контролирующего количество итераций. Несмотря на то, что алгоритм является вычислительно эффективным, первоначально сформулированный метод был плохо применим из-за численной неустойчивости - метод хорошо работал на целочисленных значениях, однако в арифметике с плавающей точкой ошибки округления давали большую погрешность. В 1970 году Ojalvo и Newman показали, как сделать метод численно стабильным и применили его для расчета крупных инженерных сооружений, подверженных динамическим нагрузкам. Кроме того, они показали способ выбора начального приближения (с использованием ГПСЧ), а также эмпирический способ для выбора числа <math>k</math> (примерно в полтора раза больше искомого числа собственных векторов). В данный момент существует две основных модификации метода (с полной и выборочной переортогонализацией), а также большое количество модификаций, использующихся в различных технических областях. Алгоритм используется для больших <math>n</math>.

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

Первый этап алгоритма - использование метода Ланцоша для построения крыловского подпространства: <math> K_k(A,x) = span[x_1, Ax_1, A^2x_1, ..., A^{k-1}x_1] </math>. Входные данные алгоритма: квадратная симметричная матрица <math>A</math> размерности <math>n*n</math>, вектор начального приближения <math>b</math>, а так же число итераций <math>k</math>. Метод осуществляет поиск трехдиагональной симметричной матрицы <math>T_k=Q_k^TAQ_k</math>.

<math>T_k=\begin{bmatrix}
\alpha_1 & \beta_2 \\
\beta_2 & \alpha_2 & \beta_3 &\\
&. & . & .\\
&&\beta_{k-1} & \alpha_{k-1} & \beta_k\\
&&&\beta_k & \alpha_k
\end{bmatrix}</math>

Описание метода:

<math>
\begin{array}{l}
q_1 = b / \Vert b \Vert_2\\
j = \overline{1, k}:\\
\quad z_j = A q_j \\
\quad \alpha_j = q_j^T z_j \\
\quad z_j = z_j - \sum_{i=1}^j (z_j^T q_i) q_i\\
\quad z_j = z_j - \sum_{i=1}^j (z_j^T q_i) q_i\\
\quad \beta_j = \Vert z_j \Vert_2\\
\quad q_{j+1} = z_j / \Vert z_j \Vert_2 = z_j/\beta_j
\end{array}
</math>

Следующий шаг алгоритма - процедура Рэлея-Ритца. Она зкалючается в интерпретации собственных значений матрицы <math> T_k=Q_k^TAQ_k</math>.
Ее собственные значения приближают собственные значения исходной матрицы. Пусть ''Tk=V<math>\Lambda</math>VT'' - спектральное разложение матрицы ''Tk'', тогда столбцы матрицы ''QkV'' рассматриваются как приближения к соответствующим собственным векторам матрицы ''A'' и называются векторами Ритца. Числа и векторы Ритца являются оптимальными приближениями к собственным значениям и собственным векторам матрицы ''A''.

Поиск собственных значений матрицы ''T'' намного легче, чем для исходной матрицы, так как предполагается, что <math>k << n</math>, и матрица ''T'' - трехдиагональная.

Полная переортогонализация необходима для того, чтобы гарантировать, что каждый полученный вектор ''qj+1'' ортогонален уже имеющимся векторам ''q1..j''. Без этого процесса будут накапливаться существенные вычислительный ошибки.

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

Вычислительным ядро алгоритма состоит ииз двух основных частей:
* <math>Aq=( \sum\nolimits_{i=^n}a_{1i}q_i, \sum\nolimits_{i=2}^na_{2i}q_i, ..., \sum\nolimits_{i=1}^na_{ni}q_i)</math> - умножение симметричной матрицы <math>A</math> размерности <math>n*n</math> на вектор ''q'' размерности ''n''.

* <math>z=z-\sum\nolimits_{i=1}^{k}(z^Tq_i)q_i.</math> - процесс ортогонализации Грама-Шмидта.

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

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

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

В параграфе 1.2 приводится полная схема последовательного алгоритма.

Заполняем начальные значения алгоритма (''b'' - начальное преближение).

<math>
\begin{align}
& q_1=b/||b||,\\
& \beta_1=0,\\
&q_0=0, \\
\end{align}
</math>

Для всех <math>j=1..k</math>:

*1. Вычисляется ''j''-й диагональный элемент матрицы <math>T_k</math>: <math>z=Aq_j; \alpha_j=q_j^Tz;</math>

*2. Проводится полная переортогонализация Грамма-Шмидта: <math>z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i;</math>

*3. Вычисляются значения <math>\beta_{j+1}</math> матрицы <math>T_k</math>: <math>\beta_{j+1}=||z||;</math>

*4. Если <math>\beta_{j+1}=0</math>, то алгоритм завершается;

*5. Сохраняем значения для следующей итерации <math>q_{j+1}=z/\beta_{j+1}.</math>

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

*1. Основная часть операций в алгоритме Ланцоша производится во время умножения матрицы <math>A</math> размерности <math>n*n</math> на вектор <math>q</math> размерности <math>n</math> - вычислительная сложность: <math>n^2</math> умножений и <math>n^2-n</math> сложений. Остальные операции основного цикла производят меньше <math>n^2</math> операций сложения или умножения. Так как умножение матрицы на вектор производится <math>k</math> раз, то сложность этой части алгоритма - <math>O(kn^2)</math>
*2. Процесс ортогонализации Грама-Шмидта - вычислительная сложность: <math>k^2n+k(n+2)</math> умножений и <math>k^2n + k(n + 1) + 2</math> сложений. Производится в цикле <math>k</math> раз. Сложность - <math>O(nk^2)</math>
*3. Процесс разложения матрицы <math>T</math> размерности <math>k*k</math>. Сложность - <math>O(k^2)</math>

Так как число итераций много меньше размерности матрицы <math>A</math>, <math>k << n</math>, то общая сложность алгоритма сокращается до <math>O(kn^2)</math>.

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

[[Файл:Lanczos.png|center|300px|'''Рис. 1.''' Граф ''j''-й итерации.]]

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

Алгоритм Ланцоша - итерационный, итерации должны выполняться в строгой последовательности, и нет возможности их параллелизовать. Внутри одной итерации алгоритма ресурсами параллелизма могут быть:
*1. умножение матрицы размерности <math>n * n</math> на вектор длины <math>n</math> требует последовательного выполнения <math>n</math> ярусов умножений и сложений;
*2. вычисление <math>\alpha_j</math> требует <math>n</math> ярусов сложений с 1 операцией умножения в каждом;
*3. переортагонализация требует вычисления <math>j</math> ярусов сложений с <math>n</math> операциями умножения в каждом, <math>n</math> ярусов сложений с <math>j</math> операциями умножения в каждом;
*4. вычисление нормы вектора длины <math>n</math> требует <math>n</math> ярусов сложений с <math>1</math> операцией умножения в каждом.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': <math>A\in\mathbb{R}^{n\times n}</math> - симметричная матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>. Объем данных: <math>\frac{n (n + 1)}{2}</math>.

'''Выходные данные''': <math>\Lambda</math> - вектор собственных значений матрицы и соответствующие им собственные вектора <math>v_i,i=1,\ldots, k </math>. Объем данных: <math> k(n+1) </math>.

=== Свойства алгоритма ===
* В классическом алгоритме Ланцоша возникает большая погрешность при округлении чисел с плавающей точкой. Выбранный вариант с полной переортогонализацией устраняет этот недостаток, однако является более ресурсоемким. На практике наиболее популярен вариант с частичной переортогонализацией.
* Вычислительная мощность алгоритма (отношение числа операций к суммарному объему данных) оценивается как <math>\approx 2k</math>.
* Преимуществом алгоритма является то, что он начинает поиск собственных значений матрицы начиная с максимального в абсолютном смысле значения.
* Нет необходимости хранения исходной матрицы на каждом вычислительном ядре, так как метод использует исходную матрицу только в операциях умножения матрицы на вектор, что позволяет эффективно использовать регулярность структуры матрицы.
* Существует модифицированный блочный вариант алгоритма, применяемый в случае кратных собственных значений.

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

=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Проверка масштабируемости алгоритма проходила на [//hpc.cmc.msu.ru/ IBM Blue Gene/P ВМК МГУ.]

Используемые компиляторы: intel/15.0.090 и OpenMPI/1.8.4-icc.

Для проведения расчетов и получения полноценной картины поведения алгоритма в зависимости от входных данных и числа процессоров, программа была запущена на следующих параметрах:
* размеры входной матрицы: [5000:30000] c шагом 5000;
* число процессоров: от 1, 2, 4 .. 64.

[[Файл:Lancos prof.jpg|центр|мини|800x800пкс|Рис. 2. Зависимость времени выполнения программы от входных данных]]

По графику видно, что время выполнения уменьшается с увеличением количества процессоров примерно до 16, дальше начинает медленно увеличиваться вплоть до 64 и далее. Это можно объяснить тем, что с увеличением количества вычислительных ядер растет количество передаваемых данных, и дальнейшее увеличение их числа только ухудшает положение.

[http://pastebin.com/sWQ9ihcW код программы]

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

The IETL Project http://www.comp-phys.org/software/ietl/ C++

NAG Library http://www.nag.com/content/nag-library C, C++, Fortran, C#, MATLAB, R

ARPACK https://people.sc.fsu.edu/~jburkardt/m_src/arpack/arpack.html MATLAB

GrapLab https://turi.com/products/create/open_source.html C++

LANSO/PLANSO http://web.cs.ucdavis.edu/~bai/ET/lanczos_methods/overview_PLANSO.html Fortran (уже распараллелена)

Julia Math https://github.com/JuliaMath/IterativeSolvers.jl Julia

SciPy https://scipy.org/ Python

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

Дж. Деммель «Вычислительная линейная алгебра» (стр. 391)

<references \>

#[[Категория:Законченные статьи]]
#[[Категория:Разложения матриц]]

Учacтник:Malikovmt/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией

2017-02-01T22:02:20Z

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

{{algorithm
| name = Алгоритм Ланцоша с полной переортогонализацией
| serial_complexity = <math>O(n^2k)</math>
| input_data = <math>\frac{n(n + 1)}{2}</math>
| output_data = <math>k(n + 1)</math>
}}

Авторы: [[Участник:Eroshkin|А.В.Ерошкин]] ([[#Масштабируемость алгоритма и его реализации|ссылкаКод]]), [[Участник:Malikovmt|М.М.Маликов]] ([[#Описание алгоритма|ссылка]])

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

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

'''Алгоритм Ланцоша''' - итерационный метод, используемый для вычисления части собственных значений и соответствующих им собственных векторов матрицы <math>A</math> размера <math>n*n</math>, изначально разработанный Корнелием Ланцошем. Преимуществами использования метода является относительно небольшое потребление памяти и вычислительных ресурсов, а также наличие параметра <math>k << n</math>, контролирующего количество итераций. Несмотря на то, что алгоритм является вычислительно эффективным, первоначально сформулированный метод был плохо применим из-за численной неустойчивости - метод хорошо работал на целочисленных значениях, однако в арифметике с плавающей точкой ошибки округления давали большую погрешность. В 1970 году Ojalvo и Newman показали, как сделать метод численно стабильным и применили его для расчета крупных инженерных сооружений, подверженных динамическим нагрузкам. Кроме того, они показали способ выбора начального приближения (с использованием ГПСЧ), а также эмпирический способ для выбора числа <math>k</math> (примерно в полтора раза больше искомого числа собственных векторов). В данный момент существует две основных модификации метода (с полной и выборочной переортогонализацией), а также большое количество модификаций, использующихся в различных технических областях. Алгоритм используется для больших <math>n</math>.

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

Первый этап алгоритма - использование метода Ланцоша для построения крыловского подпространства: <math> K_k(A,x) = span[x_1, Ax_1, A^2x_1, ..., A^{k-1}x_1] </math>. Входные данные алгоритма: квадратная симметричная матрица <math>A</math> размерности <math>n*n</math>, вектор начального приближения <math>b</math>, а так же число итераций <math>k</math>. Метод осуществляет поиск трехдиагональной симметричной матрицы <math>T_k=Q_k^TAQ_k</math>.

<math>T_k=\begin{bmatrix}
\alpha_1 & \beta_2 \\
\beta_2 & \alpha_2 & \beta_3 &\\
&. & . & .\\
&&\beta_{k-1} & \alpha_{k-1} & \beta_k\\
&&&\beta_k & \alpha_k
\end{bmatrix}</math>

Описание метода:

<math>
\begin{array}{l}
q_1 = b / \Vert b \Vert_2\\
j = \overline{1, k}:\\
\quad z_j = A q_j \\
\quad \alpha_j = q_j^T z_j \\
\quad z_j = z_j - \sum_{i=1}^j (z_j^T q_i) q_i\\
\quad z_j = z_j - \sum_{i=1}^j (z_j^T q_i) q_i\\
\quad \beta_j = \Vert z_j \Vert_2\\
\quad q_{j+1} = z_j / \Vert z_j \Vert_2 = z_j/\beta_j
\end{array}
</math>

Следующий шаг алгоритма - процедура Рэлея-Ритца. Она зкалючается в интерпретации собственных значений матрицы <math> T_k=Q_k^TAQ_k</math>.
Ее собственные значения приближают собственные значения исходной матрицы. Пусть ''Tk=V<math>\Lambda</math>VT'' - спектральное разложение матрицы ''Tk'', тогда столбцы матрицы ''QkV'' рассматриваются как приближения к соответствующим собственным векторам матрицы ''A'' и называются векторами Ритца. Числа и векторы Ритца являются оптимальными приближениями к собственным значениям и собственным векторам матрицы ''A''.

Поиск собственных значений матрицы ''T'' намного легче, чем для исходной матрицы, так как предполагается, что <math>k << n</math>, и матрица ''T'' - трехдиагональная.

Полная переортогонализация необходима для того, чтобы гарантировать, что каждый полученный вектор ''qj+1'' ортогонален уже имеющимся векторам ''q1..j''. Без этого процесса будут накапливаться существенные вычислительный ошибки.

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

Вычислительным ядро алгоритма состоит ииз двух основных частей:
* <math>Aq=( \sum\nolimits_{i=^n}a_{1i}q_i, \sum\nolimits_{i=2}^na_{2i}q_i, ..., \sum\nolimits_{i=1}^na_{ni}q_i)</math> - умножение симметричной матрицы <math>A</math> размерности <math>n*n</math> на вектор ''q'' размерности ''n''.

* <math>z=z-\sum\nolimits_{i=1}^{k}(z^Tq_i)q_i.</math> - процесс ортогонализации Грама-Шмидта.

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

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

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

В параграфе 1.2 приводится полная схема последовательного алгоритма.

Заполняем начальные значения алгоритма (''b'' - начальное преближение).

<math>
\begin{align}
& q_1=b/||b||,\\
& \beta_1=0,\\
&q_0=0, \\
\end{align}
</math>

Для всех <math>j=1..k</math>:

*1. Вычисляется ''j''-й диагональный элемент матрицы <math>T_k</math>: <math>z=Aq_j; \alpha_j=q_j^Tz;</math>

*2. Проводится полная переортогонализация Грамма-Шмидта: <math>z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i;</math>

*3. Вычисляются значения <math>\beta_{j+1}</math> матрицы <math>T_k</math>: <math>\beta_{j+1}=||z||;</math>

*4. Если <math>\beta_{j+1}=0</math>, то алгоритм завершается;

*5. Сохраняем значения для следующей итерации <math>q_{j+1}=z/\beta_{j+1}.</math>

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

*1. Основная часть операций в алгоритме Ланцоша производится во время умножения матрицы <math>A</math> размерности <math>n*n</math> на вектор <math>q</math> размерности <math>n</math> - вычислительная сложность: <math>n^2</math> умножений и <math>n^2-n</math> сложений. Остальные операции основного цикла производят меньше <math>n^2</math> операций сложения или умножения. Так как умножение матрицы на вектор производится <math>k</math> раз, то сложность этой части алгоритма - <math>O(kn^2)</math>
*2. Процесс ортогонализации Грама-Шмидта - вычислительная сложность: <math>k^2n+k(n+2)</math> умножений и <math>k^2n + k(n + 1) + 2</math> сложений. Производится в цикле <math>k</math> раз. Сложность - <math>O(nk^2)</math>
*3. Процесс разложения матрицы <math>T</math> размерности <math>k*k</math>. Сложность - <math>O(k^2)</math>

Так как число итераций много меньше размерности матрицы <math>A</math>, <math>k << n</math>, то общая сложность алгоритма сокращается до <math>O(kn^2)</math>.

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

[[Файл:Lanczos.png|center|300px|'''Рис. 1.''' Граф ''j''-й итерации.]]

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

Алгоритм Ланцоша - итерационный, итерации должны выполняться в строгой последовательности, и нет возможности их параллелизовать. Внутри одной итерации алгоритма ресурсами параллелизма могут быть:
*1. умножение матрицы размерности <math>n * n</math> на вектор длины <math>n</math> требует последовательного выполнения <math>n</math> ярусов умножений и сложений;
*2. вычисление <math>\alpha_j</math> требует <math>n</math> ярусов сложений с 1 операцией умножения в каждом;
*3. переортагонализация требует вычисления <math>j</math> ярусов сложений с <math>n</math> операциями умножения в каждом, <math>n</math> ярусов сложений с <math>j</math> операциями умножения в каждом;
*4. вычисление нормы вектора длины <math>n</math> требует <math>n</math> ярусов сложений с <math>1</math> операцией умножения в каждом.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': <math>A\in\mathbb{R}^{n\times n}</math> - симметричная матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>. Объем данных: <math>\frac{n (n + 1)}{2}</math>.

'''Выходные данные''': <math>\Lambda</math> - вектор собственных значений матрицы и соответствующие им собственные вектора <math>v_i,i=1,\ldots, k </math>. Объем данных: <math> k(n+1) </math>.

=== Свойства алгоритма ===
* В классическом алгоритме Ланцоша возникает большая погрешность при округлении чисел с плавающей точкой. Выбранный вариант с полной переортогонализацией устраняет этот недостаток, однако является более ресурсоемким. На практике наиболее популярен вариант с частичной переортогонализацией.
* Вычислительная мощность алгоритма (отношение числа операций к суммарному объему данных) оценивается как <math>\approx 2k</math>.
* Преимуществом алгоритма является то, что он начинает поиск собственных значений матрицы начиная с максимального в абсолютном смысле значения.
* Нет необходимости хранения исходной матрицы на каждом вычислительном ядре, так как метод использует исходную матрицу только в операциях умножения матрицы на вектор, что позволяет эффективно использовать регулярность структуры матрицы.
* Существует модифицированный блочный вариант алгоритма, применяемый в случае кратных собственных значений.

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

=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Проверка масштабируемости алгоритма проходила на [//hpc.cmc.msu.ru/ IBM Blue Gene/P ВМК МГУ.]

Используемые компиляторы: intel/15.0.090 и OpenMPI/1.8.4-icc.

Для проведения расчетов и получения полноценной картины поведения алгоритма в зависимости от входных данных и числа процессоров, программа была запущена на следующих параметрах:
* размеры входной матрицы: [5000:30000] c шагом 5000;
* число процессоров: от 1, 2, 4 .. 64.

[[Файл:Lancos prof.jpg|центр|мини|800x800пкс|Рис. 2. Зависимость времени выполнения программы от входных данных]]

По графику видно, что время выполнения уменьшается с увеличением количества процессоров примерно до 16, дальше начинает медленно увеличиваться вплоть до 64 и далее. Это можно объяснить тем, что с увеличением количества вычислительных ядер растет количество передаваемых данных, и дальнейшее увеличение их числа только ухудшает положение.

[http://pastebin.com/sWQ9ihcW код программы]

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

The IETL Project http://www.comp-phys.org/software/ietl/ C++

NAG Library http://www.nag.com/content/nag-library C, C++, Fortran, C#, MATLAB, R

ARPACK https://people.sc.fsu.edu/~jburkardt/m_src/arpack/arpack.html MATLAB

GrapLab https://turi.com/products/create/open_source.html C++

LANSO/PLANSO http://web.cs.ucdavis.edu/~bai/ET/lanczos_methods/overview_PLANSO.html Fortran (уже распараллелена)

Julia Math https://github.com/JuliaMath/IterativeSolvers.jl Julia

SciPy https://scipy.org/ Python

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

Дж. Деммель «Вычислительная линейная алгебра» (стр. 391)

<references \>

#[[Категория:Законченные статьи]]
#[[Категория:Разложения матриц]]

Учacтник:Malikovmt/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией

2017-02-01T21:52:46Z

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

{{algorithm
| name = Алгоритм Ланцоша с полной переортогонализацией
| serial_complexity = <math>O(n^2k)</math>
| input_data = <math>\frac{n(n + 1)}{2}</math>
| output_data = <math>k(n + 1)</math>
}}

Авторы: [[Участник:Eroshkin|А.В.Ерошкин]] ([[#Масштабируемость алгоритма и его реализации|ссылкаКод]]), [[Участник:Malikovmt|М.М.Маликов]] ([[#Описание алгоритма|ссылка]])

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

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

'''Алгоритм Ланцоша''' - итерационный метод, используемый для вычисления части собственных значений и соответствующих им собственных векторов матрицы <math>A</math> размера <math>n*n</math>, изначально разработанный Корнелием Ланцошем. Преимуществами использования метода является относительно небольшое потребление памяти и вычислительных ресурсов, а также наличие параметра <math>k << n</math>, контролирующего количество итераций. Несмотря на то, что алгоритм является вычислительно эффективным, первоначально сформулированный метод был плохо применим из-за численной неустойчивости - метод хорошо работал на целочисленных значениях, однако в арифметике с плавающей точкой ошибки округления давали большую погрешность. В 1970 году Ojalvo и Newman показали, как сделать метод численно стабильным и применили его для расчета крупных инженерных сооружений, подверженных динамическим нагрузкам. Кроме того, они показали способ выбора начального приближения (с использованием ГПСЧ), а также эмпирический способ для выбора числа <math>k</math> (примерно в полтора раза больше искомого числа собственных векторов). В данный момент существует две основных модификации метода (с полной и выборочной переортогонализацией), а также большое количество модификаций, использующихся в различных технических областях. Алгоритм используется для больших <math>n</math>.

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

Первый этап алгоритма - использование метода Ланцоша для построения крыловского подпространства: <math> K_k(A,x) = span[x_1, Ax_1, A^2x_1, ..., A^{k-1}x_1] </math>. Входные данные алгоритма: квадратная симметричная матрица <math>A</math> размерности <math>n*n</math>, вектор начального приближения <math>b</math>, а так же число итераций <math>k</math>. Метод осуществляет поиск трехдиагональной симметричной матрицы <math>T_k=Q_k^TAQ_k</math>.

<math>T_k=\begin{bmatrix}
\alpha_1 & \beta_2 \\
\beta_2 & \alpha_2 & \beta_3 &\\
&. & . & .\\
&&\beta_{k-1} & \alpha_{k-1} & \beta_k\\
&&&\beta_k & \alpha_k
\end{bmatrix}</math>

Описание метода:

<math>
\begin{array}{l}
q_1 = b / \Vert b \Vert_2\\
j = \overline{1, k}:\\
\quad z_j = A q_j \\
\quad \alpha_j = q_j^T z_j \\
\quad z_j = z_j - \sum_{i=1}^j (z_j^T q_i) q_i\\
\quad z_j = z_j - \sum_{i=1}^j (z_j^T q_i) q_i\\
\quad \beta_j = \Vert z_j \Vert_2\\
\quad q_{j+1} = z_j / \Vert z_j \Vert_2 = z_j/\beta_j
\end{array}
</math>

Следующий шаг алгоритма - процедура Рэлея-Ритца. Она зкалючается в интерпретации собственных значений матрицы <math> T_k=Q_k^TAQ_k</math>.
Ее собственные значения приближают собственные значения исходной матрицы. Пусть ''Tk=V<math>\Lambda</math>VT'' - спектральное разложение матрицы ''Tk'', тогда столбцы матрицы ''QkV'' рассматриваются как приближения к соответствующим собственным векторам матрицы ''A'' и называются векторами Ритца. Числа и векторы Ритца являются оптимальными приближениями к собственным значениям и собственным векторам матрицы ''A''.

Поиск собственных значений матрицы ''T'' намного легче, чем для исходной матрицы, так как предполагается, что <math>k << n</math>, и матрица ''T'' - трехдиагональная.

Полная переортогонализация необходима для того, чтобы гарантировать, что каждый полученный вектор ''qj+1'' ортогонален уже имеющимся векторам ''q1..j''. Без этого процесса будут накапливаться существенные вычислительный ошибки.

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

Вычислительным ядро алгоритма состоит ииз двух основных частей:
* <math>Aq=( \sum\nolimits_{i=^n}a_{1i}q_i, \sum\nolimits_{i=2}^na_{2i}q_i, ..., \sum\nolimits_{i=1}^na_{ni}q_i)</math> - умножение симметричной матрицы <math>A</math> размерности <math>n*n</math> на вектор ''q'' размерности ''n''.

* <math>z=z-\sum\nolimits_{i=1}^{k}(z^Tq_i)q_i.</math> - процесс ортогонализации Грама-Шмидта.

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

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

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

В параграфе 1.2 приводится полная схема последовательного алгоритма.

Заполняем начальные значения алгоритма (''b'' - начальное преближение).

<math>
\begin{align}
& q_1=b/||b||,\\
& \beta_1=0,\\
&q_0=0, \\
\end{align}
</math>

Для всех <math>j=1..k</math>:

*1. Вычисляется ''j''-й диагональный элемент матрицы <math>T_k</math>: <math>z=Aq_j; \alpha_j=q_j^Tz;</math>

*2. Проводится полная переортогонализация Грамма-Шмидта: <math>z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i;</math>

*3. Вычисляются значения <math>\beta_{j+1}</math> матрицы <math>T_k</math>: <math>\beta_{j+1}=||z||;</math>

*4. Если <math>\beta_{j+1}=0</math>, то алгоритм завершается;

*5. Сохраняем значения для следующей итерации <math>q_{j+1}=z/\beta_{j+1}.</math>

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

*1. Основная часть операций в алгоритме Ланцоша производится во время умножения матрицы <math>A</math> размерности <math>n*n</math> на вектор <math>q</math> размерности <math>n</math> - вычислительная сложность: <math>n^2</math> умножений и <math>n^2-n</math> сложений. Остальные операции основного цикла производят меньше <math>n^2</math> операций сложения или умножения. Так как умножение матрицы на вектор производится <math>k</math> раз, то сложность этой части алгоритма - <math>O(kn^2)</math>
*2. Процесс ортогонализации Грама-Шмидта - вычислительная сложность: <math>k^2n+k(n+2)</math> умножений и <math>k^2n + k(n + 1) + 2</math> сложений. Производится в цикле <math>k</math> раз. Сложность - <math>O(nk^2)</math>
*3. Процесс разложения матрицы <math>T</math> размерности <math>k*k</math>. Сложность - <math>O(k^2)</math>

Так как число итераций много меньше размерности матрицы <math>A</math>, <math>k << n</math>, то общая сложность алгоритма сокращается до <math>O(kn^2)</math>.

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

[[Файл:Lanczos.png|center|300px|'''Рис. 1.''' Граф ''j''-й итерации.]]

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

Алгоритм Ланцоша - итерационный, итерации должны выполняться в строгой последовательности, и нет возможности их параллелизовать. Внутри одной итерации алгоритма ресурсами параллелизма могут быть:
*1. умножение матрицы размерности <math>n * n</math> на вектор длины <math>n</math> требует последовательного выполнения <math>n</math> ярусов умножений и сложений;
*2. вычисление <math>\alpha_j</math> требует <math>n</math> ярусов сложений с 1 операцией умножения в каждом;
*3. переортагонализация требует вычисления <math>j</math> ярусов сложений с <math>n</math> операциями умножения в каждом, <math>n</math> ярусов сложений с <math>j</math> операциями умножения в каждом;
*4. вычисление нормы вектора длины <math>n</math> требует <math>n</math> ярусов сложений с <math>1</math> операцией умножения в каждом.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': <math>A\in\mathbb{R}^{n\times n}</math> - симметричная матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>. Объем данных: <math>\frac{n (n + 1)}{2}</math>.

'''Выходные данные''': <math>\Lambda</math> - вектор собственных значений матрицы и соответствующие им собственные вектора <math>v_i,i=1,\ldots, k </math>. Объем данных: <math> k(n+1) </math>.

=== Свойства алгоритма ===
* В классическом алгоритме Ланцоша возникает большая погрешность при округлении чисел с плавающей точкой. Выбранный вариант с полной переортогонализацией устраняет этот недостаток, однако является более ресурсоемким. На практике наиболее популярен вариант с частичной переортогонализацией.
* Вычислительная мощность алгоритма (отношение числа операций к суммарному объему данных) оценивается как <math>\approx 2k</math>.
* Преимуществом алгоритма является то, что он начинает поиск собственных значений матрицы начиная с максимального в абсолютном смысле значения.
* Нет необходимости хранения исходной матрицы на каждом вычислительном ядре, так как метод использует исходную матрицу только в операциях умножения матрицы на вектор, что позволяет эффективно использовать регулярность структуры матрицы.
* Существует модифицированный блочный вариант алгоритма, применяемый в случае кратных собственных значений.

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

=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Проверка масштабируемости алгоритма проходила на [//hpc.cmc.msu.ru/ IBM Blue Gene/P ВМК МГУ.]

Используемые компиляторы: intel/15.0.090 и OpenMPI/1.8.4-icc.

Для проведения расчетов и получения полноценной картины поведения алгоритма в зависимости от входных данных и числа процессоров, программа была запущена на следующих параметрах:
* размеры входной матрицы: [5000:30000] c шагом 5000;
* число процессоров: от 1, 2, 4 .. 64.

[[Файл:Lancos prof.jpg|центр|мини|800x800пкс|Рис. 2. Зависимость времени выполнения программы от входных данных]]

По графику видно, что время выполнения уменьшается с увеличением количества процессоров примерно до 16, дальше начинает медленно увеличиваться вплоть до 64 и далее. Это можно объяснить тем, что с увеличением количества вычислительных ядер растет количество передаваемых данных, и дальнейшее увеличение их числа только ухудшает положение.

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

The IETL Project http://www.comp-phys.org/software/ietl/ C++

NAG Library http://www.nag.com/content/nag-library C, C++, Fortran, C#, MATLAB, R

ARPACK https://people.sc.fsu.edu/~jburkardt/m_src/arpack/arpack.html MATLAB

GrapLab https://turi.com/products/create/open_source.html C++

LANSO/PLANSO http://web.cs.ucdavis.edu/~bai/ET/lanczos_methods/overview_PLANSO.html Fortran (уже распараллелена)

Julia Math https://github.com/JuliaMath/IterativeSolvers.jl Julia

SciPy https://scipy.org/ Python

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

Дж. Деммель «Вычислительная линейная алгебра» (стр. 391)

<references \>

#[[Категория:Законченные статьи]]
#[[Категория:Разложения матриц]]

Учacтник:Malikovmt/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией

2017-02-01T21:52:06Z

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

{{algorithm
| name = Алгоритм Ланцоша с полной переортогонализацией
| serial_complexity = <math>O(n^2k)</math>
| input_data = <math>\frac{n(n + 1)}{2}</math>
| output_data = <math>k(n + 1)</math>
}}

Авторы: [[Участник:Eroshkin|А.В.Ерошкин]] ([[#Масштабируемость алгоритма и его реализации|ссылкаКод]]), [[Участник:Malikovmt|М.М.Маликов]] ([[#Описание алгоритма|ссылка]])

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

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

'''Алгоритм Ланцоша''' - итерационный метод, используемый для вычисления части собственных значений и соответствующих им собственных векторов матрицы <math>A</math> размера <math>n*n</math>, изначально разработанный Корнелием Ланцошем. Преимуществами использования метода является относительно небольшое потребление памяти и вычислительных ресурсов, а также наличие параметра <math>k << n</math>, контролирующего количество итераций. Несмотря на то, что алгоритм является вычислительно эффективным, первоначально сформулированный метод был плохо применим из-за численной неустойчивости - метод хорошо работал на целочисленных значениях, однако в арифметике с плавающей точкой ошибки округления давали большую погрешность. В 1970 году Ojalvo и Newman показали, как сделать метод численно стабильным и применили его для расчета крупных инженерных сооружений, подверженных динамическим нагрузкам. Кроме того, они показали способ выбора начального приближения (с использованием ГПСЧ), а также эмпирический способ для выбора числа <math>k</math> (примерно в полтора раза больше искомого числа собственных векторов). В данный момент существует две основных модификации метода (с полной и выборочной переортогонализацией), а также большое количество модификаций, использующихся в различных технических областях. Алгоритм используется для больших <math>n</math>.

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

Первый этап алгоритма - использование метода Ланцоша для построения крыловского подпространства: <math> K_k(A,x) = span[x_1, Ax_1, A^2x_1, ..., A^{k-1}x_1] </math>. Входные данные алгоритма: квадратная симметричная матрица <math>A</math> размерности <math>n*n</math>, вектор начального приближения <math>b</math>, а так же число итераций <math>k</math>. Метод осуществляет поиск трехдиагональной симметричной матрицы <math>T_k=Q_k^TAQ_k</math>.

<math>T_k=\begin{bmatrix}
\alpha_1 & \beta_2 \\
\beta_2 & \alpha_2 & \beta_3 &\\
&. & . & .\\
&&\beta_{k-1} & \alpha_{k-1} & \beta_k\\
&&&\beta_k & \alpha_k
\end{bmatrix}</math>

Описание метода:

<math>
\begin{array}{l}
q_1 = b / \Vert b \Vert_2\\
j = \overline{1, k}:\\
\quad z_j = A q_j \\
\quad \alpha_j = q_j^T z_j \\
\quad z_j = z_j - \sum_{i=1}^j (z_j^T q_i) q_i\\
\quad z_j = z_j - \sum_{i=1}^j (z_j^T q_i) q_i\\
\quad \beta_j = \Vert z_j \Vert_2\\
\quad q_{j+1} = z_j / \Vert z_j \Vert_2 = z_j/\beta_j
\end{array}
</math>

Следующий шаг алгоритма - процедура Рэлея-Ритца. Она зкалючается в интерпретации собственных значений матрицы <math> T_k=Q_k^TAQ_k</math>.
Ее собственные значения приближают собственные значения исходной матрицы. Пусть ''Tk=V<math>\Lambda</math>VT'' - спектральное разложение матрицы ''Tk'', тогда столбцы матрицы ''QkV'' рассматриваются как приближения к соответствующим собственным векторам матрицы ''A'' и называются векторами Ритца. Числа и векторы Ритца являются оптимальными приближениями к собственным значениям и собственным векторам матрицы ''A''.

Поиск собственных значений матрицы ''T'' намного легче, чем для исходной матрицы, так как предполагается, что <math>k << n</math>, и матрица ''T'' - трехдиагональная.

Полная переортогонализация необходима для того, чтобы гарантировать, что каждый полученный вектор ''qj+1'' ортогонален уже имеющимся векторам ''q1..j''. Без этого процесса будут накапливаться существенные вычислительный ошибки.

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

Вычислительным ядро алгоритма состоит ииз двух основных частей:
* <math>Aq=( \sum\nolimits_{i=^n}a_{1i}q_i, \sum\nolimits_{i=2}^na_{2i}q_i, ..., \sum\nolimits_{i=1}^na_{ni}q_i)</math> - умножение симметричной матрицы <math>A</math> размерности <math>n*n</math> на вектор ''q'' размерности ''n''.

* <math>z=z-\sum\nolimits_{i=1}^{k}(z^Tq_i)q_i.</math> - процесс ортогонализации Грама-Шмидта.

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

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

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

В параграфе 1.2 приводится полная схема последовательного алгоритма.

Заполняем начальные значения алгоритма (''b'' - начальное преближение).

<math>
\begin{align}
& q_1=b/||b||,\\
& \beta_1=0,\\
&q_0=0, \\
\end{align}
</math>

Для всех <math>j=1..k</math>:

*1. Вычисляется ''j''-й диагональный элемент матрицы <math>T_k</math>: <math>z=Aq_j; \alpha_j=q_j^Tz;</math>

*2. Проводится полная переортогонализация Грамма-Шмидта: <math>z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i;</math>

*3. Вычисляются значения <math>\beta_{j+1}</math> матрицы <math>T_k</math>: <math>\beta_{j+1}=||z||;</math>

*4. Если <math>\beta_{j+1}=0</math>, то алгоритм завершается;

*5. Сохраняем значения для следующей итерации <math>q_{j+1}=z/\beta_{j+1}.</math>

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

*1. Основная часть операций в алгоритме Ланцоша производится во время умножения матрицы <math>A</math> размерности <math>n*n</math> на вектор <math>q</math> размерности <math>n</math> - вычислительная сложность: <math>n^2</math> умножений и <math>n^2-n</math> сложений. Остальные операции основного цикла производят меньше <math>n^2</math> операций сложения или умножения. Так как умножение матрицы на вектор производится <math>k</math> раз, то сложность этой части алгоритма - <math>O(kn^2)</math>
*2. Процесс ортогонализации Грама-Шмидта - вычислительная сложность: <math>k^2n+k(n+2)</math> умножений и <math>k^2n + k(n + 1) + 2</math> сложений. Производится в цикле <math>k</math> раз. Сложность - <math>O(nk^2)</math>
*3. Процесс разложения матрицы <math>T</math> размерности <math>k*k</math>. Сложность - <math>O(k^2)</math>

Так как число итераций много меньше размерности матрицы <math>A</math>, <math>k << n</math>, то общая сложность алгоритма сокращается до <math>O(kn^2)</math>.

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

[[Файл:Lanczos.png|center|300px|'''Рис. 1.''' Граф ''j''-й итерации.]]

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

Алгоритм Ланцоша - итерационный, итерации должны выполняться в строгой последовательности, и нет возможности их параллелизовать. Внутри одной итерации алгоритма ресурсами параллелизма могут быть:
*1. умножение матрицы размерности <math>n * n</math> на вектор длины <math>n</math> требует последовательного выполнения <math>n</math> ярусов умножений и сложений;
*2. вычисление <math>\alpha_j</math> требует <math>n</math> ярусов сложений с 1 операцией умножения в каждом;
*3. переортагонализация требует вычисления <math>j</math> ярусов сложений с <math>n</math> операциями умножения в каждом, <math>n</math> ярусов сложений с <math>j</math> операциями умножения в каждом;
*4. вычисление нормы вектора длины <math>n</math> требует <math>n</math> ярусов сложений с <math>1</math> операцией умножения в каждом.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': <math>A\in\mathbb{R}^{n\times n}</math> - симметричная матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>. Объем данных: <math>\frac{n (n + 1)}{2}</math>.

'''Выходные данные''': <math>\Lambda</math> - вектор собственных значений матрицы и соответствующие им собственные вектора <math>v_i,i=1,\ldots, k </math>. Объем данных: <math> k(n+1) </math>.

=== Свойства алгоритма ===
* В классическом алгоритме Ланцоша возникает большая погрешность при округлении чисел с плавающей точкой. Выбранный вариант с полной переортогонализацией устраняет этот недостаток, однако является более ресурсоемким. На практике наиболее популярен вариант с частичной переортогонализацией.
* Вычислительная мощность алгоритма (отношение числа операций к суммарному объему данных) оценивается как <math>\approx 2k</math>.
* Преимуществом алгоритма является то, что он начинает поиск собственных значений матрицы начиная с максимального в абсолютном смысле значения.
* Нет необходимости хранения исходной матрицы на каждом вычислительном ядре, так как метод использует исходную матрицу только в операциях умножения матрицы на вектор, что позволяет эффективно использовать регулярность структуры матрицы.
* Существует модифицированный блочный вариант алгоритма, применяемый в случае кратных собственных значений.

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

=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Проверка масштабируемости алгоритма проходила на [//hpc.cmc.msu.ru/ IBM Blue Gene/P ВМК МГУ.]

Используемые компиляторы: intel/15.0.090 и OpenMPI/1.8.4-icc.

Для проведения расчетов и получения полноценной картины поведения алгоритма в зависимости от входных данных и числа процессоров, программа была запущена на следующих параметрах:
* размеры входной матрицы: [5000:30000] c шагом 5000;
* число процессоров: от 1, 2, 4 .. 64.

[[Файл:Lancos prof.jpg|центр||Рис. 2. Зависимость времени выполнения программы от входных данных]]

По графику видно, что время выполнения уменьшается с увеличением количества процессоров примерно до 16, дальше начинает медленно увеличиваться вплоть до 64 и далее. Это можно объяснить тем, что с увеличением количества вычислительных ядер растет количество передаваемых данных, и дальнейшее увеличение их числа только ухудшает положение.

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

The IETL Project http://www.comp-phys.org/software/ietl/ C++

NAG Library http://www.nag.com/content/nag-library C, C++, Fortran, C#, MATLAB, R

ARPACK https://people.sc.fsu.edu/~jburkardt/m_src/arpack/arpack.html MATLAB

GrapLab https://turi.com/products/create/open_source.html C++

LANSO/PLANSO http://web.cs.ucdavis.edu/~bai/ET/lanczos_methods/overview_PLANSO.html Fortran (уже распараллелена)

Julia Math https://github.com/JuliaMath/IterativeSolvers.jl Julia

SciPy https://scipy.org/ Python

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

Дж. Деммель «Вычислительная линейная алгебра» (стр. 391)

<references \>

#[[Категория:Законченные статьи]]
#[[Категория:Разложения матриц]]

Учacтник:Malikovmt/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией

2017-02-01T21:49:00Z

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

{{algorithm
| name = Алгоритм Ланцоша с полной переортогонализацией
| serial_complexity = <math>O(n^2k)</math>
| input_data = <math>\frac{n(n + 1)}{2}</math>
| output_data = <math>k(n + 1)</math>
}}

Авторы: [[Участник:Eroshkin|А.В.Ерошкин]] ([[#Масштабируемость алгоритма и его реализации|ссылкаКод]]), [[Участник:Malikovmt|М.М.Маликов]] ([[#Описание алгоритма|ссылка]])

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

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

'''Алгоритм Ланцоша''' - итерационный метод, используемый для вычисления части собственных значений и соответствующих им собственных векторов матрицы <math>A</math> размера <math>n*n</math>, изначально разработанный Корнелием Ланцошем. Преимуществами использования метода является относительно небольшое потребление памяти и вычислительных ресурсов, а также наличие параметра <math>k << n</math>, контролирующего количество итераций. Несмотря на то, что алгоритм является вычислительно эффективным, первоначально сформулированный метод был плохо применим из-за численной неустойчивости - метод хорошо работал на целочисленных значениях, однако в арифметике с плавающей точкой ошибки округления давали большую погрешность. В 1970 году Ojalvo и Newman показали, как сделать метод численно стабильным и применили его для расчета крупных инженерных сооружений, подверженных динамическим нагрузкам. Кроме того, они показали способ выбора начального приближения (с использованием ГПСЧ), а также эмпирический способ для выбора числа <math>k</math> (примерно в полтора раза больше искомого числа собственных векторов). В данный момент существует две основных модификации метода (с полной и выборочной переортогонализацией), а также большое количество модификаций, использующихся в различных технических областях. Алгоритм используется для больших <math>n</math>.

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

Первый этап алгоритма - использование метода Ланцоша для построения крыловского подпространства: <math> K_k(A,x) = span[x_1, Ax_1, A^2x_1, ..., A^{k-1}x_1] </math>. Входные данные алгоритма: квадратная симметричная матрица <math>A</math> размерности <math>n*n</math>, вектор начального приближения <math>b</math>, а так же число итераций <math>k</math>. Метод осуществляет поиск трехдиагональной симметричной матрицы <math>T_k=Q_k^TAQ_k</math>.

<math>T_k=\begin{bmatrix}
\alpha_1 & \beta_2 \\
\beta_2 & \alpha_2 & \beta_3 &\\
&. & . & .\\
&&\beta_{k-1} & \alpha_{k-1} & \beta_k\\
&&&\beta_k & \alpha_k
\end{bmatrix}</math>

Описание метода:

<math>
\begin{array}{l}
q_1 = b / \Vert b \Vert_2\\
j = \overline{1, k}:\\
\quad z_j = A q_j \\
\quad \alpha_j = q_j^T z_j \\
\quad z_j = z_j - \sum_{i=1}^j (z_j^T q_i) q_i\\
\quad z_j = z_j - \sum_{i=1}^j (z_j^T q_i) q_i\\
\quad \beta_j = \Vert z_j \Vert_2\\
\quad q_{j+1} = z_j / \Vert z_j \Vert_2 = z_j/\beta_j
\end{array}
</math>

Следующий шаг алгоритма - процедура Рэлея-Ритца. Она зкалючается в интерпретации собственных значений матрицы <math> T_k=Q_k^TAQ_k</math>.
Ее собственные значения приближают собственные значения исходной матрицы. Пусть ''Tk=V<math>\Lambda</math>VT'' - спектральное разложение матрицы ''Tk'', тогда столбцы матрицы ''QkV'' рассматриваются как приближения к соответствующим собственным векторам матрицы ''A'' и называются векторами Ритца. Числа и векторы Ритца являются оптимальными приближениями к собственным значениям и собственным векторам матрицы ''A''.

Поиск собственных значений матрицы ''T'' намного легче, чем для исходной матрицы, так как предполагается, что <math>k << n</math>, и матрица ''T'' - трехдиагональная.

Полная переортогонализация необходима для того, чтобы гарантировать, что каждый полученный вектор ''qj+1'' ортогонален уже имеющимся векторам ''q1..j''. Без этого процесса будут накапливаться существенные вычислительный ошибки.

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

Вычислительным ядро алгоритма состоит ииз двух основных частей:
* <math>Aq=( \sum\nolimits_{i=^n}a_{1i}q_i, \sum\nolimits_{i=2}^na_{2i}q_i, ..., \sum\nolimits_{i=1}^na_{ni}q_i)</math> - умножение симметричной матрицы <math>A</math> размерности <math>n*n</math> на вектор ''q'' размерности ''n''.

* <math>z=z-\sum\nolimits_{i=1}^{k}(z^Tq_i)q_i.</math> - процесс ортогонализации Грама-Шмидта.

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

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

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

В параграфе 1.2 приводится полная схема последовательного алгоритма.

Заполняем начальные значения алгоритма (''b'' - начальное преближение).

<math>
\begin{align}
& q_1=b/||b||,\\
& \beta_1=0,\\
&q_0=0, \\
\end{align}
</math>

Для всех <math>j=1..k</math>:

*1. Вычисляется ''j''-й диагональный элемент матрицы <math>T_k</math>: <math>z=Aq_j; \alpha_j=q_j^Tz;</math>

*2. Проводится полная переортогонализация Грамма-Шмидта: <math>z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i;</math>

*3. Вычисляются значения <math>\beta_{j+1}</math> матрицы <math>T_k</math>: <math>\beta_{j+1}=||z||;</math>

*4. Если <math>\beta_{j+1}=0</math>, то алгоритм завершается;

*5. Сохраняем значения для следующей итерации <math>q_{j+1}=z/\beta_{j+1}.</math>

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

*1. Основная часть операций в алгоритме Ланцоша производится во время умножения матрицы <math>A</math> размерности <math>n*n</math> на вектор <math>q</math> размерности <math>n</math> - вычислительная сложность: <math>n^2</math> умножений и <math>n^2-n</math> сложений. Остальные операции основного цикла производят меньше <math>n^2</math> операций сложения или умножения. Так как умножение матрицы на вектор производится <math>k</math> раз, то сложность этой части алгоритма - <math>O(kn^2)</math>
*2. Процесс ортогонализации Грама-Шмидта - вычислительная сложность: <math>k^2n+k(n+2)</math> умножений и <math>k^2n + k(n + 1) + 2</math> сложений. Производится в цикле <math>k</math> раз. Сложность - <math>O(nk^2)</math>
*3. Процесс разложения матрицы <math>T</math> размерности <math>k*k</math>. Сложность - <math>O(k^2)</math>

Так как число итераций много меньше размерности матрицы <math>A</math>, <math>k << n</math>, то общая сложность алгоритма сокращается до <math>O(kn^2)</math>.

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

[[Файл:Lanczos.png|center|300px|'''Рис. 1.''' Граф ''j''-й итерации.]]

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

Алгоритм Ланцоша - итерационный, итерации должны выполняться в строгой последовательности, и нет возможности их параллелизовать. Внутри одной итерации алгоритма ресурсами параллелизма могут быть:
*1. умножение матрицы размерности <math>n * n</math> на вектор длины <math>n</math> требует последовательного выполнения <math>n</math> ярусов умножений и сложений;
*2. вычисление <math>\alpha_j</math> требует <math>n</math> ярусов сложений с 1 операцией умножения в каждом;
*3. переортагонализация требует вычисления <math>j</math> ярусов сложений с <math>n</math> операциями умножения в каждом, <math>n</math> ярусов сложений с <math>j</math> операциями умножения в каждом;
*4. вычисление нормы вектора длины <math>n</math> требует <math>n</math> ярусов сложений с <math>1</math> операцией умножения в каждом.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': <math>A\in\mathbb{R}^{n\times n}</math> - симметричная матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>. Объем данных: <math>\frac{n (n + 1)}{2}</math>.

'''Выходные данные''': <math>\Lambda</math> - вектор собственных значений матрицы и соответствующие им собственные вектора <math>v_i,i=1,\ldots, k </math>. Объем данных: <math> k(n+1) </math>.

=== Свойства алгоритма ===
* В классическом алгоритме Ланцоша возникает большая погрешность при округлении чисел с плавающей точкой. Выбранный вариант с полной переортогонализацией устраняет этот недостаток, однако является более ресурсоемким. На практике наиболее популярен вариант с частичной переортогонализацией.
* Вычислительная мощность алгоритма (отношение числа операций к суммарному объему данных) оценивается как <math>\approx 2k</math>.
* Преимуществом алгоритма является то, что он начинает поиск собственных значений матрицы начиная с максимального в абсолютном смысле значения.
* Нет необходимости хранения исходной матрицы на каждом вычислительном ядре, так как метод использует исходную матрицу только в операциях умножения матрицы на вектор, что позволяет эффективно использовать регулярность структуры матрицы.
* Существует модифицированный блочный вариант алгоритма, применяемый в случае кратных собственных значений.

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

=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Проверка масштабируемости алгоритма проходила на [//hpc.cmc.msu.ru/ IBM Blue Gene/P ВМК МГУ.]

Используемые компиляторы: intel/15.0.090 и OpenMPI/1.8.4-icc.

Для проведения расчетов и получения полноценной картины поведения алгоритма в зависимости от входных данных и числа процессоров, программа была запущена на следующих параметрах:
* размеры входной матрицы: [5000:30000] c шагом 5000;
* число процессоров: от 1, 2, 4 .. 64.

[[Файл:Lancos_prof.png|центр||Рис. 2. Зависимость времени выполнения программы от входных данных]]

По графику видно, что время выполнения уменьшается с увеличением количества процессоров примерно до 16, дальше начинает медленно увеличиваться вплоть до 64 и далее. Это можно объяснить тем, что с увеличением количества вычислительных ядер растет количество передаваемых данных, и дальнейшее увеличение их числа только ухудшает положение.

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

The IETL Project http://www.comp-phys.org/software/ietl/ C++

NAG Library http://www.nag.com/content/nag-library C, C++, Fortran, C#, MATLAB, R

ARPACK https://people.sc.fsu.edu/~jburkardt/m_src/arpack/arpack.html MATLAB

GrapLab https://turi.com/products/create/open_source.html C++

LANSO/PLANSO http://web.cs.ucdavis.edu/~bai/ET/lanczos_methods/overview_PLANSO.html Fortran (уже распараллелена)

Julia Math https://github.com/JuliaMath/IterativeSolvers.jl Julia

SciPy https://scipy.org/ Python

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

Дж. Деммель «Вычислительная линейная алгебра» (стр. 391)

<references \>

#[[Категория:Законченные статьи]]
#[[Категория:Разложения матриц]]

Учacтник:Malikovmt/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией

2017-02-01T20:50:38Z

Malikovmt: /* Литература */

{{algorithm
| name = Алгоритм Ланцоша с полной переортогонализацией
| serial_complexity = <math>O(n^2k)</math>
| input_data = <math>\frac{n(n + 1)}{2}</math>
| output_data = <math>k(n + 1)</math>
}}

Авторы: [[Участник:Eroshkin|А.В.Ерошкин]] ([[#Масштабируемость алгоритма и его реализации|ссылкаКод]]), [[Участник:Malikovmt|М.М.Маликов]] ([[#Описание алгоритма|ссылка]])

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

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

'''Алгоритм Ланцоша''' - итерационный метод, используемый для вычисления части собственных значений и соответствующих им собственных векторов матрицы <math>A</math> размера <math>n*n</math>, изначально разработанный Корнелием Ланцошем. Преимуществами использования метода является относительно небольшое потребление памяти и вычислительных ресурсов, а также наличие параметра <math>k << n</math>, контролирующего количество итераций. Несмотря на то, что алгоритм является вычислительно эффективным, первоначально сформулированный метод был плохо применим из-за численной неустойчивости - метод хорошо работал на целочисленных значениях, однако в арифметике с плавающей точкой ошибки округления давали большую погрешность. В 1970 году Ojalvo и Newman показали, как сделать метод численно стабильным и применили его для расчета крупных инженерных сооружений, подверженных динамическим нагрузкам. Кроме того, они показали способ выбора начального приближения (с использованием ГПСЧ), а также эмпирический способ для выбора числа <math>k</math> (примерно в полтора раза больше искомого числа собственных векторов). В данный момент существует две основных модификации метода (с полной и выборочной переортогонализацией), а также большое количество модификаций, использующихся в различных технических областях. Алгоритм используется для больших <math>n</math>.

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

Первый этап алгоритма - использование метода Ланцоша для построения крыловского подпространства: <math> K_k(A,x) = span[x_1, Ax_1, A^2x_1, ..., A^{k-1}x_1] </math>. Входные данные алгоритма: квадратная симметричная матрица <math>A</math> размерности <math>n*n</math>, вектор начального приближения <math>b</math>, а так же число итераций <math>k</math>. Метод осуществляет поиск трехдиагональной симметричной матрицы <math>T_k=Q_k^TAQ_k</math>.

<math>T_k=\begin{bmatrix}
\alpha_1 & \beta_2 \\
\beta_2 & \alpha_2 & \beta_3 &\\
&. & . & .\\
&&\beta_{k-1} & \alpha_{k-1} & \beta_k\\
&&&\beta_k & \alpha_k
\end{bmatrix}</math>

Описание метода:

<math>
\begin{array}{l}
q_1 = b / \Vert b \Vert_2\\
j = \overline{1, k}:\\
\quad z_j = A q_j \\
\quad \alpha_j = q_j^T z_j \\
\quad z_j = z_j - \sum_{i=1}^j (z_j^T q_i) q_i\\
\quad z_j = z_j - \sum_{i=1}^j (z_j^T q_i) q_i\\
\quad \beta_j = \Vert z_j \Vert_2\\
\quad q_{j+1} = z_j / \Vert z_j \Vert_2 = z_j/\beta_j
\end{array}
</math>

Следующий шаг алгоритма - процедура Рэлея-Ритца. Она зкалючается в интерпретации собственных значений матрицы <math> T_k=Q_k^TAQ_k</math>.
Ее собственные значения приближают собственные значения исходной матрицы. Пусть ''Tk=V<math>\Lambda</math>VT'' - спектральное разложение матрицы ''Tk'', тогда столбцы матрицы ''QkV'' рассматриваются как приближения к соответствующим собственным векторам матрицы ''A'' и называются векторами Ритца. Числа и векторы Ритца являются оптимальными приближениями к собственным значениям и собственным векторам матрицы ''A''.

Поиск собственных значений матрицы ''T'' намного легче, чем для исходной матрицы, так как предполагается, что <math>k << n</math>, и матрица ''T'' - трехдиагональная.

Полная переортогонализация необходима для того, чтобы гарантировать, что каждый полученный вектор ''qj+1'' ортогонален уже имеющимся векторам ''q1..j''. Без этого процесса будут накапливаться существенные вычислительный ошибки.

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

Вычислительным ядро алгоритма состоит ииз двух основных частей:
* <math>Aq=( \sum\nolimits_{i=^n}a_{1i}q_i, \sum\nolimits_{i=2}^na_{2i}q_i, ..., \sum\nolimits_{i=1}^na_{ni}q_i)</math> - умножение симметричной матрицы <math>A</math> размерности <math>n*n</math> на вектор ''q'' размерности ''n''.

* <math>z=z-\sum\nolimits_{i=1}^{k}(z^Tq_i)q_i.</math> - процесс ортогонализации Грама-Шмидта.

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

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

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

В параграфе 1.2 приводится полная схема последовательного алгоритма.

Заполняем начальные значения алгоритма (''b'' - начальное преближение).

<math>
\begin{align}
& q_1=b/||b||,\\
& \beta_1=0,\\
&q_0=0, \\
\end{align}
</math>

Для всех <math>j=1..k</math>:

*1. Вычисляется ''j''-й диагональный элемент матрицы <math>T_k</math>: <math>z=Aq_j; \alpha_j=q_j^Tz;</math>

*2. Проводится полная переортогонализация Грамма-Шмидта: <math>z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i;</math>

*3. Вычисляются значения <math>\beta_{j+1}</math> матрицы <math>T_k</math>: <math>\beta_{j+1}=||z||;</math>

*4. Если <math>\beta_{j+1}=0</math>, то алгоритм завершается;

*5. Сохраняем значения для следующей итерации <math>q_{j+1}=z/\beta_{j+1}.</math>

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

*1. Основная часть операций в алгоритме Ланцоша производится во время умножения матрицы <math>A</math> размерности <math>n*n</math> на вектор <math>q</math> размерности <math>n</math> - вычислительная сложность: <math>n^2</math> умножений и <math>n^2-n</math> сложений. Остальные операции основного цикла производят меньше <math>n^2</math> операций сложения или умножения. Так как умножение матрицы на вектор производится <math>k</math> раз, то сложность этой части алгоритма - <math>O(kn^2)</math>
*2. Процесс ортогонализации Грама-Шмидта - вычислительная сложность: <math>k^2n+k(n+2)</math> умножений и <math>k^2n + k(n + 1) + 2</math> сложений. Производится в цикле <math>k</math> раз. Сложность - <math>O(nk^2)</math>
*3. Процесс разложения матрицы <math>T</math> размерности <math>k*k</math>. Сложность - <math>O(k^2)</math>

Так как число итераций много меньше размерности матрицы <math>A</math>, <math>k << n</math>, то общая сложность алгоритма сокращается до <math>O(kn^2)</math>.

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

[[Файл:Lanczos.png|center|300px|'''Рис. 1.''' Граф ''j''-й итерации.]]

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

Алгоритм Ланцоша - итерационный, итерации должны выполняться в строгой последовательности, и нет возможности их параллелизовать. Внутри одной итерации алгоритма ресурсами параллелизма могут быть:
*1. умножение матрицы размерности <math>n * n</math> на вектор длины <math>n</math> требует последовательного выполнения <math>n</math> ярусов умножений и сложений;
*2. вычисление <math>\alpha_j</math> требует <math>n</math> ярусов сложений с 1 операцией умножения в каждом;
*3. переортагонализация требует вычисления <math>j</math> ярусов сложений с <math>n</math> операциями умножения в каждом, <math>n</math> ярусов сложений с <math>j</math> операциями умножения в каждом;
*4. вычисление нормы вектора длины <math>n</math> требует <math>n</math> ярусов сложений с <math>1</math> операцией умножения в каждом.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': <math>A\in\mathbb{R}^{n\times n}</math> - симметричная матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>. Объем данных: <math>\frac{n (n + 1)}{2}</math>.

'''Выходные данные''': <math>\Lambda</math> - вектор собственных значений матрицы и соответствующие им собственные вектора <math>v_i,i=1,\ldots, k </math>. Объем данных: <math> k(n+1) </math>.

=== Свойства алгоритма ===
* В классическом алгоритме Ланцоша возникает большая погрешность при округлении чисел с плавающей точкой. Выбранный вариант с полной переортогонализацией устраняет этот недостаток, однако является более ресурсоемким. На практике наиболее популярен вариант с частичной переортогонализацией.
* Вычислительная мощность алгоритма (отношение числа операций к суммарному объему данных) оценивается как <math>\approx 2k</math>.
* Преимуществом алгоритма является то, что он начинает поиск собственных значений матрицы начиная с максимального в абсолютном смысле значения.
* Нет необходимости хранения исходной матрицы на каждом вычислительном ядре, так как метод использует исходную матрицу только в операциях умножения матрицы на вектор, что позволяет эффективно использовать регулярность структуры матрицы.
* Существует модифицированный блочный вариант алгоритма, применяемый в случае кратных собственных значений.

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

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

The IETL Project http://www.comp-phys.org/software/ietl/ C++

NAG Library http://www.nag.com/content/nag-library C, C++, Fortran, C#, MATLAB, R

ARPACK https://people.sc.fsu.edu/~jburkardt/m_src/arpack/arpack.html MATLAB

GrapLab https://turi.com/products/create/open_source.html C++

LANSO/PLANSO http://web.cs.ucdavis.edu/~bai/ET/lanczos_methods/overview_PLANSO.html Fortran (уже распараллелена)

Julia Math https://github.com/JuliaMath/IterativeSolvers.jl Julia

SciPy https://scipy.org/ Python

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

Дж. Деммель «Вычислительная линейная алгебра» (стр. 391)

<references \>

#[[Категория:Законченные статьи]]
#[[Категория:Разложения матриц]]

Учacтник:Malikovmt/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией

2017-02-01T20:48:33Z

Malikovmt: /* Литература */

{{algorithm
| name = Алгоритм Ланцоша с полной переортогонализацией
| serial_complexity = <math>O(n^2k)</math>
| input_data = <math>\frac{n(n + 1)}{2}</math>
| output_data = <math>k(n + 1)</math>
}}

Авторы: [[Участник:Eroshkin|А.В.Ерошкин]] ([[#Масштабируемость алгоритма и его реализации|ссылкаКод]]), [[Участник:Malikovmt|М.М.Маликов]] ([[#Описание алгоритма|ссылка]])

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

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

'''Алгоритм Ланцоша''' - итерационный метод, используемый для вычисления части собственных значений и соответствующих им собственных векторов матрицы <math>A</math> размера <math>n*n</math>, изначально разработанный Корнелием Ланцошем. Преимуществами использования метода является относительно небольшое потребление памяти и вычислительных ресурсов, а также наличие параметра <math>k << n</math>, контролирующего количество итераций. Несмотря на то, что алгоритм является вычислительно эффективным, первоначально сформулированный метод был плохо применим из-за численной неустойчивости - метод хорошо работал на целочисленных значениях, однако в арифметике с плавающей точкой ошибки округления давали большую погрешность. В 1970 году Ojalvo и Newman показали, как сделать метод численно стабильным и применили его для расчета крупных инженерных сооружений, подверженных динамическим нагрузкам. Кроме того, они показали способ выбора начального приближения (с использованием ГПСЧ), а также эмпирический способ для выбора числа <math>k</math> (примерно в полтора раза больше искомого числа собственных векторов). В данный момент существует две основных модификации метода (с полной и выборочной переортогонализацией), а также большое количество модификаций, использующихся в различных технических областях. Алгоритм используется для больших <math>n</math>.

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

Первый этап алгоритма - использование метода Ланцоша для построения крыловского подпространства: <math> K_k(A,x) = span[x_1, Ax_1, A^2x_1, ..., A^{k-1}x_1] </math>. Входные данные алгоритма: квадратная симметричная матрица <math>A</math> размерности <math>n*n</math>, вектор начального приближения <math>b</math>, а так же число итераций <math>k</math>. Метод осуществляет поиск трехдиагональной симметричной матрицы <math>T_k=Q_k^TAQ_k</math>.

<math>T_k=\begin{bmatrix}
\alpha_1 & \beta_2 \\
\beta_2 & \alpha_2 & \beta_3 &\\
&. & . & .\\
&&\beta_{k-1} & \alpha_{k-1} & \beta_k\\
&&&\beta_k & \alpha_k
\end{bmatrix}</math>

Описание метода:

<math>
\begin{array}{l}
q_1 = b / \Vert b \Vert_2\\
j = \overline{1, k}:\\
\quad z_j = A q_j \\
\quad \alpha_j = q_j^T z_j \\
\quad z_j = z_j - \sum_{i=1}^j (z_j^T q_i) q_i\\
\quad z_j = z_j - \sum_{i=1}^j (z_j^T q_i) q_i\\
\quad \beta_j = \Vert z_j \Vert_2\\
\quad q_{j+1} = z_j / \Vert z_j \Vert_2 = z_j/\beta_j
\end{array}
</math>

Следующий шаг алгоритма - процедура Рэлея-Ритца. Она зкалючается в интерпретации собственных значений матрицы <math> T_k=Q_k^TAQ_k</math>.
Ее собственные значения приближают собственные значения исходной матрицы. Пусть ''Tk=V<math>\Lambda</math>VT'' - спектральное разложение матрицы ''Tk'', тогда столбцы матрицы ''QkV'' рассматриваются как приближения к соответствующим собственным векторам матрицы ''A'' и называются векторами Ритца. Числа и векторы Ритца являются оптимальными приближениями к собственным значениям и собственным векторам матрицы ''A''.

Поиск собственных значений матрицы ''T'' намного легче, чем для исходной матрицы, так как предполагается, что <math>k << n</math>, и матрица ''T'' - трехдиагональная.

Полная переортогонализация необходима для того, чтобы гарантировать, что каждый полученный вектор ''qj+1'' ортогонален уже имеющимся векторам ''q1..j''. Без этого процесса будут накапливаться существенные вычислительный ошибки.

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

Вычислительным ядро алгоритма состоит ииз двух основных частей:
* <math>Aq=( \sum\nolimits_{i=^n}a_{1i}q_i, \sum\nolimits_{i=2}^na_{2i}q_i, ..., \sum\nolimits_{i=1}^na_{ni}q_i)</math> - умножение симметричной матрицы <math>A</math> размерности <math>n*n</math> на вектор ''q'' размерности ''n''.

* <math>z=z-\sum\nolimits_{i=1}^{k}(z^Tq_i)q_i.</math> - процесс ортогонализации Грама-Шмидта.

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

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

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

В параграфе 1.2 приводится полная схема последовательного алгоритма.

Заполняем начальные значения алгоритма (''b'' - начальное преближение).

<math>
\begin{align}
& q_1=b/||b||,\\
& \beta_1=0,\\
&q_0=0, \\
\end{align}
</math>

Для всех <math>j=1..k</math>:

*1. Вычисляется ''j''-й диагональный элемент матрицы <math>T_k</math>: <math>z=Aq_j; \alpha_j=q_j^Tz;</math>

*2. Проводится полная переортогонализация Грамма-Шмидта: <math>z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i;</math>

*3. Вычисляются значения <math>\beta_{j+1}</math> матрицы <math>T_k</math>: <math>\beta_{j+1}=||z||;</math>

*4. Если <math>\beta_{j+1}=0</math>, то алгоритм завершается;

*5. Сохраняем значения для следующей итерации <math>q_{j+1}=z/\beta_{j+1}.</math>

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

*1. Основная часть операций в алгоритме Ланцоша производится во время умножения матрицы <math>A</math> размерности <math>n*n</math> на вектор <math>q</math> размерности <math>n</math> - вычислительная сложность: <math>n^2</math> умножений и <math>n^2-n</math> сложений. Остальные операции основного цикла производят меньше <math>n^2</math> операций сложения или умножения. Так как умножение матрицы на вектор производится <math>k</math> раз, то сложность этой части алгоритма - <math>O(kn^2)</math>
*2. Процесс ортогонализации Грама-Шмидта - вычислительная сложность: <math>k^2n+k(n+2)</math> умножений и <math>k^2n + k(n + 1) + 2</math> сложений. Производится в цикле <math>k</math> раз. Сложность - <math>O(nk^2)</math>
*3. Процесс разложения матрицы <math>T</math> размерности <math>k*k</math>. Сложность - <math>O(k^2)</math>

Так как число итераций много меньше размерности матрицы <math>A</math>, <math>k << n</math>, то общая сложность алгоритма сокращается до <math>O(kn^2)</math>.

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

[[Файл:Lanczos.png|center|300px|'''Рис. 1.''' Граф ''j''-й итерации.]]

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

Алгоритм Ланцоша - итерационный, итерации должны выполняться в строгой последовательности, и нет возможности их параллелизовать. Внутри одной итерации алгоритма ресурсами параллелизма могут быть:
*1. умножение матрицы размерности <math>n * n</math> на вектор длины <math>n</math> требует последовательного выполнения <math>n</math> ярусов умножений и сложений;
*2. вычисление <math>\alpha_j</math> требует <math>n</math> ярусов сложений с 1 операцией умножения в каждом;
*3. переортагонализация требует вычисления <math>j</math> ярусов сложений с <math>n</math> операциями умножения в каждом, <math>n</math> ярусов сложений с <math>j</math> операциями умножения в каждом;
*4. вычисление нормы вектора длины <math>n</math> требует <math>n</math> ярусов сложений с <math>1</math> операцией умножения в каждом.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': <math>A\in\mathbb{R}^{n\times n}</math> - симметричная матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>. Объем данных: <math>\frac{n (n + 1)}{2}</math>.

'''Выходные данные''': <math>\Lambda</math> - вектор собственных значений матрицы и соответствующие им собственные вектора <math>v_i,i=1,\ldots, k </math>. Объем данных: <math> k(n+1) </math>.

=== Свойства алгоритма ===
* В классическом алгоритме Ланцоша возникает большая погрешность при округлении чисел с плавающей точкой. Выбранный вариант с полной переортогонализацией устраняет этот недостаток, однако является более ресурсоемким. На практике наиболее популярен вариант с частичной переортогонализацией.
* Вычислительная мощность алгоритма (отношение числа операций к суммарному объему данных) оценивается как <math>\approx 2k</math>.
* Преимуществом алгоритма является то, что он начинает поиск собственных значений матрицы начиная с максимального в абсолютном смысле значения.
* Нет необходимости хранения исходной матрицы на каждом вычислительном ядре, так как метод использует исходную матрицу только в операциях умножения матрицы на вектор, что позволяет эффективно использовать регулярность структуры матрицы.
* Существует модифицированный блочный вариант алгоритма, применяемый в случае кратных собственных значений.

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

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

The IETL Project http://www.comp-phys.org/software/ietl/ C++

NAG Library http://www.nag.com/content/nag-library C, C++, Fortran, C#, MATLAB, R

ARPACK https://people.sc.fsu.edu/~jburkardt/m_src/arpack/arpack.html MATLAB

GrapLab https://turi.com/products/create/open_source.html C++

LANSO/PLANSO http://web.cs.ucdavis.edu/~bai/ET/lanczos_methods/overview_PLANSO.html Fortran (уже распараллелена)

Julia Math https://github.com/JuliaMath/IterativeSolvers.jl Julia

SciPy https://scipy.org/ Python

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

<references \>

#[[Категория:Законченные статьи]]
#[[Категория:Разложения матриц]]

Учacтник:Malikovmt/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией

2017-02-01T20:44:56Z

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

{{algorithm
| name = Алгоритм Ланцоша с полной переортогонализацией
| serial_complexity = <math>O(n^2k)</math>
| input_data = <math>\frac{n(n + 1)}{2}</math>
| output_data = <math>k(n + 1)</math>
}}

Авторы: [[Участник:Eroshkin|А.В.Ерошкин]] ([[#Масштабируемость алгоритма и его реализации|ссылкаКод]]), [[Участник:Malikovmt|М.М.Маликов]] ([[#Описание алгоритма|ссылка]])

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

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

'''Алгоритм Ланцоша''' - итерационный метод, используемый для вычисления части собственных значений и соответствующих им собственных векторов матрицы <math>A</math> размера <math>n*n</math>, изначально разработанный Корнелием Ланцошем. Преимуществами использования метода является относительно небольшое потребление памяти и вычислительных ресурсов, а также наличие параметра <math>k << n</math>, контролирующего количество итераций. Несмотря на то, что алгоритм является вычислительно эффективным, первоначально сформулированный метод был плохо применим из-за численной неустойчивости - метод хорошо работал на целочисленных значениях, однако в арифметике с плавающей точкой ошибки округления давали большую погрешность. В 1970 году Ojalvo и Newman показали, как сделать метод численно стабильным и применили его для расчета крупных инженерных сооружений, подверженных динамическим нагрузкам. Кроме того, они показали способ выбора начального приближения (с использованием ГПСЧ), а также эмпирический способ для выбора числа <math>k</math> (примерно в полтора раза больше искомого числа собственных векторов). В данный момент существует две основных модификации метода (с полной и выборочной переортогонализацией), а также большое количество модификаций, использующихся в различных технических областях. Алгоритм используется для больших <math>n</math>.

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

Первый этап алгоритма - использование метода Ланцоша для построения крыловского подпространства: <math> K_k(A,x) = span[x_1, Ax_1, A^2x_1, ..., A^{k-1}x_1] </math>. Входные данные алгоритма: квадратная симметричная матрица <math>A</math> размерности <math>n*n</math>, вектор начального приближения <math>b</math>, а так же число итераций <math>k</math>. Метод осуществляет поиск трехдиагональной симметричной матрицы <math>T_k=Q_k^TAQ_k</math>.

<math>T_k=\begin{bmatrix}
\alpha_1 & \beta_2 \\
\beta_2 & \alpha_2 & \beta_3 &\\
&. & . & .\\
&&\beta_{k-1} & \alpha_{k-1} & \beta_k\\
&&&\beta_k & \alpha_k
\end{bmatrix}</math>

Описание метода:

<math>
\begin{array}{l}
q_1 = b / \Vert b \Vert_2\\
j = \overline{1, k}:\\
\quad z_j = A q_j \\
\quad \alpha_j = q_j^T z_j \\
\quad z_j = z_j - \sum_{i=1}^j (z_j^T q_i) q_i\\
\quad z_j = z_j - \sum_{i=1}^j (z_j^T q_i) q_i\\
\quad \beta_j = \Vert z_j \Vert_2\\
\quad q_{j+1} = z_j / \Vert z_j \Vert_2 = z_j/\beta_j
\end{array}
</math>

Следующий шаг алгоритма - процедура Рэлея-Ритца. Она зкалючается в интерпретации собственных значений матрицы <math> T_k=Q_k^TAQ_k</math>.
Ее собственные значения приближают собственные значения исходной матрицы. Пусть ''Tk=V<math>\Lambda</math>VT'' - спектральное разложение матрицы ''Tk'', тогда столбцы матрицы ''QkV'' рассматриваются как приближения к соответствующим собственным векторам матрицы ''A'' и называются векторами Ритца. Числа и векторы Ритца являются оптимальными приближениями к собственным значениям и собственным векторам матрицы ''A''.

Поиск собственных значений матрицы ''T'' намного легче, чем для исходной матрицы, так как предполагается, что <math>k << n</math>, и матрица ''T'' - трехдиагональная.

Полная переортогонализация необходима для того, чтобы гарантировать, что каждый полученный вектор ''qj+1'' ортогонален уже имеющимся векторам ''q1..j''. Без этого процесса будут накапливаться существенные вычислительный ошибки.

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

Вычислительным ядро алгоритма состоит ииз двух основных частей:
* <math>Aq=( \sum\nolimits_{i=^n}a_{1i}q_i, \sum\nolimits_{i=2}^na_{2i}q_i, ..., \sum\nolimits_{i=1}^na_{ni}q_i)</math> - умножение симметричной матрицы <math>A</math> размерности <math>n*n</math> на вектор ''q'' размерности ''n''.

* <math>z=z-\sum\nolimits_{i=1}^{k}(z^Tq_i)q_i.</math> - процесс ортогонализации Грама-Шмидта.

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

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

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

В параграфе 1.2 приводится полная схема последовательного алгоритма.

Заполняем начальные значения алгоритма (''b'' - начальное преближение).

<math>
\begin{align}
& q_1=b/||b||,\\
& \beta_1=0,\\
&q_0=0, \\
\end{align}
</math>

Для всех <math>j=1..k</math>:

*1. Вычисляется ''j''-й диагональный элемент матрицы <math>T_k</math>: <math>z=Aq_j; \alpha_j=q_j^Tz;</math>

*2. Проводится полная переортогонализация Грамма-Шмидта: <math>z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i;</math>

*3. Вычисляются значения <math>\beta_{j+1}</math> матрицы <math>T_k</math>: <math>\beta_{j+1}=||z||;</math>

*4. Если <math>\beta_{j+1}=0</math>, то алгоритм завершается;

*5. Сохраняем значения для следующей итерации <math>q_{j+1}=z/\beta_{j+1}.</math>

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

*1. Основная часть операций в алгоритме Ланцоша производится во время умножения матрицы <math>A</math> размерности <math>n*n</math> на вектор <math>q</math> размерности <math>n</math> - вычислительная сложность: <math>n^2</math> умножений и <math>n^2-n</math> сложений. Остальные операции основного цикла производят меньше <math>n^2</math> операций сложения или умножения. Так как умножение матрицы на вектор производится <math>k</math> раз, то сложность этой части алгоритма - <math>O(kn^2)</math>
*2. Процесс ортогонализации Грама-Шмидта - вычислительная сложность: <math>k^2n+k(n+2)</math> умножений и <math>k^2n + k(n + 1) + 2</math> сложений. Производится в цикле <math>k</math> раз. Сложность - <math>O(nk^2)</math>
*3. Процесс разложения матрицы <math>T</math> размерности <math>k*k</math>. Сложность - <math>O(k^2)</math>

Так как число итераций много меньше размерности матрицы <math>A</math>, <math>k << n</math>, то общая сложность алгоритма сокращается до <math>O(kn^2)</math>.

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

[[Файл:Lanczos.png|center|300px|'''Рис. 1.''' Граф ''j''-й итерации.]]

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

Алгоритм Ланцоша - итерационный, итерации должны выполняться в строгой последовательности, и нет возможности их параллелизовать. Внутри одной итерации алгоритма ресурсами параллелизма могут быть:
*1. умножение матрицы размерности <math>n * n</math> на вектор длины <math>n</math> требует последовательного выполнения <math>n</math> ярусов умножений и сложений;
*2. вычисление <math>\alpha_j</math> требует <math>n</math> ярусов сложений с 1 операцией умножения в каждом;
*3. переортагонализация требует вычисления <math>j</math> ярусов сложений с <math>n</math> операциями умножения в каждом, <math>n</math> ярусов сложений с <math>j</math> операциями умножения в каждом;
*4. вычисление нормы вектора длины <math>n</math> требует <math>n</math> ярусов сложений с <math>1</math> операцией умножения в каждом.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': <math>A\in\mathbb{R}^{n\times n}</math> - симметричная матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>. Объем данных: <math>\frac{n (n + 1)}{2}</math>.

'''Выходные данные''': <math>\Lambda</math> - вектор собственных значений матрицы и соответствующие им собственные вектора <math>v_i,i=1,\ldots, k </math>. Объем данных: <math> k(n+1) </math>.

=== Свойства алгоритма ===
* В классическом алгоритме Ланцоша возникает большая погрешность при округлении чисел с плавающей точкой. Выбранный вариант с полной переортогонализацией устраняет этот недостаток, однако является более ресурсоемким. На практике наиболее популярен вариант с частичной переортогонализацией.
* Вычислительная мощность алгоритма (отношение числа операций к суммарному объему данных) оценивается как <math>\approx 2k</math>.
* Преимуществом алгоритма является то, что он начинает поиск собственных значений матрицы начиная с максимального в абсолютном смысле значения.
* Нет необходимости хранения исходной матрицы на каждом вычислительном ядре, так как метод использует исходную матрицу только в операциях умножения матрицы на вектор, что позволяет эффективно использовать регулярность структуры матрицы.
* Существует модифицированный блочный вариант алгоритма, применяемый в случае кратных собственных значений.

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

<references \>

#[[Категория:Законченные статьи]]
#[[Категория:Разложения матриц]]

Учacтник:Malikovmt/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией

2017-02-01T20:25:01Z

Malikovmt: /* Входные и выходные данные алгоритма */

{{algorithm
| name = Алгоритм Ланцоша с полной переортогонализацией
| serial_complexity = <math>O(n^2k)</math>
| input_data = <math>\frac{n(n + 1)}{2}</math>
| output_data = <math>k(n + 1)</math>
}}

Авторы: [[Участник:Eroshkin|А.В.Ерошкин]] ([[#Масштабируемость алгоритма и его реализации|ссылкаКод]]), [[Участник:Malikovmt|М.М.Маликов]] ([[#Описание алгоритма|ссылка]])

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

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

'''Алгоритм Ланцоша''' - итерационный метод, используемый для вычисления части собственных значений и соответствующих им собственных векторов матрицы <math>A</math> размера <math>n*n</math>, изначально разработанный Корнелием Ланцошем. Преимуществами использования метода является относительно небольшое потребление памяти и вычислительных ресурсов, а также наличие параметра <math>k << n</math>, контролирующего количество итераций. Несмотря на то, что алгоритм является вычислительно эффективным, первоначально сформулированный метод был плохо применим из-за численной неустойчивости - метод хорошо работал на целочисленных значениях, однако в арифметике с плавающей точкой ошибки округления давали большую погрешность. В 1970 году Ojalvo и Newman показали, как сделать метод численно стабильным и применили его для расчета крупных инженерных сооружений, подверженных динамическим нагрузкам. Кроме того, они показали способ выбора начального приближения (с использованием ГПСЧ), а также эмпирический способ для выбора числа <math>k</math> (примерно в полтора раза больше искомого числа собственных векторов). В данный момент существует две основных модификации метода (с полной и выборочной переортогонализацией), а также большое количество модификаций, использующихся в различных технических областях. Алгоритм используется для больших <math>n</math>.

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

Первый этап алгоритма - использование метода Ланцоша для построения крыловского подпространства: <math> K_k(A,x) = span[x_1, Ax_1, A^2x_1, ..., A^{k-1}x_1] </math>. Входные данные алгоритма: квадратная симметричная матрица <math>A</math> размерности <math>n*n</math>, вектор начального приближения <math>b</math>, а так же число итераций <math>k</math>. Метод осуществляет поиск трехдиагональной симметричной матрицы <math>T_k=Q_k^TAQ_k</math>.

<math>T_k=\begin{bmatrix}
\alpha_1 & \beta_2 \\
\beta_2 & \alpha_2 & \beta_3 &\\
&. & . & .\\
&&\beta_{k-1} & \alpha_{k-1} & \beta_k\\
&&&\beta_k & \alpha_k
\end{bmatrix}</math>

Описание метода:

<math>
\begin{array}{l}
q_1 = b / \Vert b \Vert_2\\
j = \overline{1, k}:\\
\quad z_j = A q_j \\
\quad \alpha_j = q_j^T z_j \\
\quad z_j = z_j - \sum_{i=1}^j (z_j^T q_i) q_i\\
\quad z_j = z_j - \sum_{i=1}^j (z_j^T q_i) q_i\\
\quad \beta_j = \Vert z_j \Vert_2\\
\quad q_{j+1} = z_j / \Vert z_j \Vert_2 = z_j/\beta_j
\end{array}
</math>

Следующий шаг алгоритма - процедура Рэлея-Ритца. Она зкалючается в интерпретации собственных значений матрицы <math> T_k=Q_k^TAQ_k</math>.
Ее собственные значения приближают собственные значения исходной матрицы. Пусть ''Tk=V<math>\Lambda</math>VT'' - спектральное разложение матрицы ''Tk'', тогда столбцы матрицы ''QkV'' рассматриваются как приближения к соответствующим собственным векторам матрицы ''A'' и называются векторами Ритца. Числа и векторы Ритца являются оптимальными приближениями к собственным значениям и собственным векторам матрицы ''A''.

Поиск собственных значений матрицы ''T'' намного легче, чем для исходной матрицы, так как предполагается, что <math>k << n</math>, и матрица ''T'' - трехдиагональная.

Полная переортогонализация необходима для того, чтобы гарантировать, что каждый полученный вектор ''qj+1'' ортогонален уже имеющимся векторам ''q1..j''. Без этого процесса будут накапливаться существенные вычислительный ошибки.

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

Вычислительным ядро алгоритма состоит ииз двух основных частей:
* <math>Aq=( \sum\nolimits_{i=^n}a_{1i}q_i, \sum\nolimits_{i=2}^na_{2i}q_i, ..., \sum\nolimits_{i=1}^na_{ni}q_i)</math> - умножение симметричной матрицы <math>A</math> размерности <math>n*n</math> на вектор ''q'' размерности ''n''.

* <math>z=z-\sum\nolimits_{i=1}^{k}(z^Tq_i)q_i.</math> - процесс ортогонализации Грама-Шмидта.

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

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

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

В параграфе 1.2 приводится полная схема последовательного алгоритма.

Заполняем начальные значения алгоритма (''b'' - начальное преближение).

<math>
\begin{align}
& q_1=b/||b||,\\
& \beta_1=0,\\
&q_0=0, \\
\end{align}
</math>

Для всех <math>j=1..k</math>:

*1. Вычисляется ''j''-й диагональный элемент матрицы <math>T_k</math>: <math>z=Aq_j; \alpha_j=q_j^Tz;</math>

*2. Проводится полная переортогонализация Грамма-Шмидта: <math>z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i;</math>

*3. Вычисляются значения <math>\beta_{j+1}</math> матрицы <math>T_k</math>: <math>\beta_{j+1}=||z||;</math>

*4. Если <math>\beta_{j+1}=0</math>, то алгоритм завершается;

*5. Сохраняем значения для следующей итерации <math>q_{j+1}=z/\beta_{j+1}.</math>

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

*1. Основная часть операций в алгоритме Ланцоша производится во время умножения матрицы <math>A</math> размерности <math>n*n</math> на вектор <math>q</math> размерности <math>n</math> - вычислительная сложность: <math>n^2</math> умножений и <math>n^2-n</math> сложений. Остальные операции основного цикла производят меньше <math>n^2</math> операций сложения или умножения. Так как умножение матрицы на вектор производится <math>k</math> раз, то сложность этой части алгоритма - <math>O(kn^2)</math>
*2. Процесс ортогонализации Грама-Шмидта - вычислительная сложность: <math>k^2n+k(n+2)</math> умножений и <math>k^2n + k(n + 1) + 2</math> сложений. Производится в цикле <math>k</math> раз. Сложность - <math>O(nk^2)</math>
*3. Процесс разложения матрицы <math>T</math> размерности <math>k*k</math>. Сложность - <math>O(k^2)</math>

Так как число итераций много меньше размерности матрицы <math>A</math>, <math>k << n</math>, то общая сложность алгоритма сокращается до <math>O(kn^2)</math>.

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

[[Файл:Lanczos.png|center|300px|'''Рис. 1.''' Граф ''j''-й итерации.]]

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

Алгоритм Ланцоша - итерационный, итерации должны выполняться в строгой последовательности, и нет возможности их параллелизовать. Внутри одной итерации алгоритма ресурсами параллелизма могут быть:
*1. умножение матрицы размерности <math>n * n</math> на вектор длины <math>n</math> требует последовательного выполнения <math>n</math> ярусов умножений и сложений;
*2. вычисление <math>\alpha_j</math> требует <math>n</math> ярусов сложений с 1 операцией умножения в каждом;
*3. переортагонализация требует вычисления <math>j</math> ярусов сложений с <math>n</math> операциями умножения в каждом, <math>n</math> ярусов сложений с <math>j</math> операциями умножения в каждом;
*4. вычисление нормы вектора длины <math>n</math> требует <math>n</math> ярусов сложений с <math>1</math> операцией умножения в каждом.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': <math>A\in\mathbb{R}^{n\times n}</math> - симметричная матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>. Объем данных: <math>\frac{n (n + 1)}{2}</math>.

'''Выходные данные''': <math>\Lambda</math> - вектор собственных значений матрицы и соответствующие им собственные вектора <math>v_i,i=1,\ldots, k </math>. Объем данных: <math> k(n+1) </math>.

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

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

<references \>

#[[Категория:Законченные статьи]]
#[[Категория:Разложения матриц]]

Учacтник:Malikovmt/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией

2017-02-01T20:19:50Z

Malikovmt: /* Входные и выходные данные алгоритма */

{{algorithm
| name = Алгоритм Ланцоша с полной переортогонализацией
| serial_complexity = <math>O(n^2k)</math>
| input_data = <math>\frac{n(n + 1)}{2}</math>
| output_data = <math>k(n + 1)</math>
}}

Авторы: [[Участник:Eroshkin|А.В.Ерошкин]] ([[#Масштабируемость алгоритма и его реализации|ссылкаКод]]), [[Участник:Malikovmt|М.М.Маликов]] ([[#Описание алгоритма|ссылка]])

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

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

'''Алгоритм Ланцоша''' - итерационный метод, используемый для вычисления части собственных значений и соответствующих им собственных векторов матрицы <math>A</math> размера <math>n*n</math>, изначально разработанный Корнелием Ланцошем. Преимуществами использования метода является относительно небольшое потребление памяти и вычислительных ресурсов, а также наличие параметра <math>k << n</math>, контролирующего количество итераций. Несмотря на то, что алгоритм является вычислительно эффективным, первоначально сформулированный метод был плохо применим из-за численной неустойчивости - метод хорошо работал на целочисленных значениях, однако в арифметике с плавающей точкой ошибки округления давали большую погрешность. В 1970 году Ojalvo и Newman показали, как сделать метод численно стабильным и применили его для расчета крупных инженерных сооружений, подверженных динамическим нагрузкам. Кроме того, они показали способ выбора начального приближения (с использованием ГПСЧ), а также эмпирический способ для выбора числа <math>k</math> (примерно в полтора раза больше искомого числа собственных векторов). В данный момент существует две основных модификации метода (с полной и выборочной переортогонализацией), а также большое количество модификаций, использующихся в различных технических областях. Алгоритм используется для больших <math>n</math>.

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

Первый этап алгоритма - использование метода Ланцоша для построения крыловского подпространства: <math> K_k(A,x) = span[x_1, Ax_1, A^2x_1, ..., A^{k-1}x_1] </math>. Входные данные алгоритма: квадратная симметричная матрица <math>A</math> размерности <math>n*n</math>, вектор начального приближения <math>b</math>, а так же число итераций <math>k</math>. Метод осуществляет поиск трехдиагональной симметричной матрицы <math>T_k=Q_k^TAQ_k</math>.

<math>T_k=\begin{bmatrix}
\alpha_1 & \beta_2 \\
\beta_2 & \alpha_2 & \beta_3 &\\
&. & . & .\\
&&\beta_{k-1} & \alpha_{k-1} & \beta_k\\
&&&\beta_k & \alpha_k
\end{bmatrix}</math>

Описание метода:

<math>
\begin{array}{l}
q_1 = b / \Vert b \Vert_2\\
j = \overline{1, k}:\\
\quad z_j = A q_j \\
\quad \alpha_j = q_j^T z_j \\
\quad z_j = z_j - \sum_{i=1}^j (z_j^T q_i) q_i\\
\quad z_j = z_j - \sum_{i=1}^j (z_j^T q_i) q_i\\
\quad \beta_j = \Vert z_j \Vert_2\\
\quad q_{j+1} = z_j / \Vert z_j \Vert_2 = z_j/\beta_j
\end{array}
</math>

Следующий шаг алгоритма - процедура Рэлея-Ритца. Она зкалючается в интерпретации собственных значений матрицы <math> T_k=Q_k^TAQ_k</math>.
Ее собственные значения приближают собственные значения исходной матрицы. Пусть ''Tk=V<math>\Lambda</math>VT'' - спектральное разложение матрицы ''Tk'', тогда столбцы матрицы ''QkV'' рассматриваются как приближения к соответствующим собственным векторам матрицы ''A'' и называются векторами Ритца. Числа и векторы Ритца являются оптимальными приближениями к собственным значениям и собственным векторам матрицы ''A''.

Поиск собственных значений матрицы ''T'' намного легче, чем для исходной матрицы, так как предполагается, что <math>k << n</math>, и матрица ''T'' - трехдиагональная.

Полная переортогонализация необходима для того, чтобы гарантировать, что каждый полученный вектор ''qj+1'' ортогонален уже имеющимся векторам ''q1..j''. Без этого процесса будут накапливаться существенные вычислительный ошибки.

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

Вычислительным ядро алгоритма состоит ииз двух основных частей:
* <math>Aq=( \sum\nolimits_{i=^n}a_{1i}q_i, \sum\nolimits_{i=2}^na_{2i}q_i, ..., \sum\nolimits_{i=1}^na_{ni}q_i)</math> - умножение симметричной матрицы <math>A</math> размерности <math>n*n</math> на вектор ''q'' размерности ''n''.

* <math>z=z-\sum\nolimits_{i=1}^{k}(z^Tq_i)q_i.</math> - процесс ортогонализации Грама-Шмидта.

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

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

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

В параграфе 1.2 приводится полная схема последовательного алгоритма.

Заполняем начальные значения алгоритма (''b'' - начальное преближение).

<math>
\begin{align}
& q_1=b/||b||,\\
& \beta_1=0,\\
&q_0=0, \\
\end{align}
</math>

Для всех <math>j=1..k</math>:

*1. Вычисляется ''j''-й диагональный элемент матрицы <math>T_k</math>: <math>z=Aq_j; \alpha_j=q_j^Tz;</math>

*2. Проводится полная переортогонализация Грамма-Шмидта: <math>z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i;</math>

*3. Вычисляются значения <math>\beta_{j+1}</math> матрицы <math>T_k</math>: <math>\beta_{j+1}=||z||;</math>

*4. Если <math>\beta_{j+1}=0</math>, то алгоритм завершается;

*5. Сохраняем значения для следующей итерации <math>q_{j+1}=z/\beta_{j+1}.</math>

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

*1. Основная часть операций в алгоритме Ланцоша производится во время умножения матрицы <math>A</math> размерности <math>n*n</math> на вектор <math>q</math> размерности <math>n</math> - вычислительная сложность: <math>n^2</math> умножений и <math>n^2-n</math> сложений. Остальные операции основного цикла производят меньше <math>n^2</math> операций сложения или умножения. Так как умножение матрицы на вектор производится <math>k</math> раз, то сложность этой части алгоритма - <math>O(kn^2)</math>
*2. Процесс ортогонализации Грама-Шмидта - вычислительная сложность: <math>k^2n+k(n+2)</math> умножений и <math>k^2n + k(n + 1) + 2</math> сложений. Производится в цикле <math>k</math> раз. Сложность - <math>O(nk^2)</math>
*3. Процесс разложения матрицы <math>T</math> размерности <math>k*k</math>. Сложность - <math>O(k^2)</math>

Так как число итераций много меньше размерности матрицы <math>A</math>, <math>k << n</math>, то общая сложность алгоритма сокращается до <math>O(kn^2)</math>.

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

[[Файл:Lanczos.png|center|300px|'''Рис. 1.''' Граф ''j''-й итерации.]]

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

Алгоритм Ланцоша - итерационный, итерации должны выполняться в строгой последовательности, и нет возможности их параллелизовать. Внутри одной итерации алгоритма ресурсами параллелизма могут быть:
*1. умножение матрицы размерности <math>n * n</math> на вектор длины <math>n</math> требует последовательного выполнения <math>n</math> ярусов умножений и сложений;
*2. вычисление <math>\alpha_j</math> требует <math>n</math> ярусов сложений с 1 операцией умножения в каждом;
*3. переортагонализация требует вычисления <math>j</math> ярусов сложений с <math>n</math> операциями умножения в каждом, <math>n</math> ярусов сложений с <math>j</math> операциями умножения в каждом;
*4. вычисление нормы вектора длины <math>n</math> требует <math>n</math> ярусов сложений с <math>1</math> операцией умножения в каждом.

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

'''Объём входных данных''': <math>\frac{n (n + 1)}{2}</math>.

'''Выходные данные''':
*вектор приближенных собственных значений матрицы <math>\Lambda</math> (элементы <math>\lambda_{ii}</math>).
*приближения к собственным векторам ''<math>v_i,i=1,\ldots, m </math>.
'''Объём выходных данных''': <math> m(n+1) </math>.

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

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

<references \>

#[[Категория:Законченные статьи]]
#[[Категория:Разложения матриц]]

Учacтник:Malikovmt/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией

2017-02-01T20:17:23Z

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

Учacтник:Malikovmt/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией

2017-02-01T20:11:20Z

Malikovmt:

Учacтник:Malikovmt/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией

2017-02-01T19:32:57Z

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

{{algorithm
| name = Алгоритм Ланцоша с полной переортогонализацией
| serial_complexity = <math>O(n^2k)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>\frac{n(n + 1)}{2}</math>
| output_data = <math>k(n + 1)</math>
}}

Авторы: [[Участник:Eroshkin|А.В.Ерошкин]] ([[#Масштабируемость алгоритма и его реализации|ссылкаКод]]), [[Участник:Malikovmt|М.М.Маликов]] ([[#Описание алгоритма|ссылка]])

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

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

'''Алгоритм Ланцоша''' - итерационный метод, используемый для вычисления части собственных значений и соответствующих им собственных векторов матрицы <math>A</math> размера <math>n*n</math>, изначально разработанный Корнелием Ланцошем. Преимуществами использования метода является относительно небольшое потребление памяти и вычислительных ресурсов, а также наличие параметра <math>k << n</math>, контролирующего количество итераций. Несмотря на то, что алгоритм является вычислительно эффективным, первоначально сформулированный метод был плохо применим из-за численной неустойчивости - метод хорошо работал на целочисленных значениях, однако в арифметике с плавающей точкой ошибки округления давали большую погрешность. В 1970 году Ojalvo и Newman показали, как сделать метод численно стабильным и применили его для расчета крупных инженерных сооружений, подверженных динамическим нагрузкам. Кроме того, они показали способ выбора начального приближения (с использованием ГПСЧ), а также эмпирический способ для выбора числа <math>k</math> (примерно в полтора раза больше искомого числа собственных векторов). В данный момент существует две основных модификации метода (с полной и выборочной переортогонализацией), а также большое количество модификаций, использующихся в различных технических областях. Алгоритм используется для больших <math>n</math>.

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

Первый этап алгоритма - использование метода Ланцоша для построения крыловского подпространства: <math> K_k(A,x) = span[x_1, Ax_1, A^2x_1, ..., A^{k-1}x_1] </math>. Входные данные алгоритма: квадратная симметричная матрица <math>A</math> размерности <math>n*n</math>, вектор начального приближения <math>b</math>, а так же число итераций <math>k</math>. Метод осуществляет поиск трехдиагональной симметричной матрицы <math>T_k=Q_k^TAQ_k</math>.

<math>T_k=\begin{bmatrix}
\alpha_1 & \beta_2 \\
\beta_2 & \alpha_2 & \beta_3 &\\
&. & . & .\\
&&\beta_{k-1} & \alpha_{k-1} & \beta_k\\
&&&\beta_k & \alpha_k
\end{bmatrix}</math>

Описание метода:

<math>
\begin{array}{l}
q_1 = b / \Vert b \Vert_2\\
j = \overline{1, k}:\\
\quad z_j = A q_j \\
\quad \alpha_j = q_j^T z_j \\
\quad z_j = z_j - \sum_{i=1}^j (z_j^T q_i) q_i\\
\quad z_j = z_j - \sum_{i=1}^j (z_j^T q_i) q_i\\
\quad \beta_j = \Vert z_j \Vert_2\\
\quad q_{j+1} = z_j / \Vert z_j \Vert_2 = z_j/\beta_j
\end{array}
</math>

Следующий шаг алгоритма - процедура Рэлея-Ритца. Она зкалючается в интерпретации собственных значений матрицы <math> T_k=Q_k^TAQ_k</math>.
Ее собственные значения приближают собственные значения исходной матрицы. Пусть ''Tk=V<math>\Lambda</math>VT'' - спектральное разложение матрицы ''Tk'', тогда столбцы матрицы ''QkV'' рассматриваются как приближения к соответствующим собственным векторам матрицы ''A'' и называются векторами Ритца. Числа и векторы Ритца являются оптимальными приближениями к собственным значениям и собственным векторам матрицы ''A''.

Поиск собственных значений матрицы ''T'' намного легче, чем для исходной матрицы, так как предполагается, что <math>k << n</math>, и матрица ''T'' - трехдиагональная.

Полная переортогонализация необходима для того, чтобы гарантировать, что каждый полученный вектор ''qj+1'' ортогонален уже имеющимся векторам ''q1..j''. Без этого процесса будут накапливаться существенные вычислительный ошибки.

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

Вычислительным ядро алгоритма состоит ииз двух основных частей:
* <math>Aq=( \sum\nolimits_{i=^n}a_{1i}q_i, \sum\nolimits_{i=2}^na_{2i}q_i, ..., \sum\nolimits_{i=1}^na_{ni}q_i)</math> - умножение симметричной матрицы <math>A</math> размерности <math>n*n</math> на вектор ''q'' размерности ''n''.

* <math>z=z-\sum\nolimits_{i=1}^{k}(z^Tq_i)q_i.</math> - процесс ортогонализации Грама-Шмидта.

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

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

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

В параграфе 1.2 приводится полная схема последовательного алгоритма.

Заполняем начальные значения алгоритма (''b'' - начальное преближение).

<math>
\begin{align}
& q_1=b/||b||,\\
& \beta_1=0,\\
&q_0=0, \\
\end{align}
</math>

Для всех <math>j=1..k</math>:

*1. Вычисляется ''j''-й диагональный элемент матрицы <math>T_k</math>: <math>z=Aq_j; \alpha_j=q_j^Tz;</math>

*2. Проводится полная переортогонализация Грамма-Шмидта: <math>z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i;</math>

*3. Вычисляются значения <math>\beta_{j+1}</math> матрицы <math>T_k</math>: <math>\beta_{j+1}=||z||;</math>

*4. Если <math>\beta_{j+1}=0</math>, то алгоритм завершается;

*5. Сохраняем значения для следующей итерации <math>q_{j+1}=z/\beta_{j+1}.</math>

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

*1. Основная часть операций в алгоритме Ланцоша производится во время умножения матрицы <math>A</math> размерности <math>n*n</math> на вектор <math>q</math> размерности <math>n</math> - вычислительная сложность: <math>n^2</math> умножений и <math>n^2-n</math> сложений. Остальные операции основного цикла производят меньше <math>n^2</math> операций сложения или умножения. Так как умножение матрицы на вектор производится <math>k</math> раз, то сложность этой части алгоритма - <math>O(kn^2)</math>
*2. Процесс ортогонализации Грама-Шмидта - вычислительная сложность: <math>k^2n+k(n+2)</math> умножений и <math>k^2n + k(n + 1) + 2</math> сложений. Производится в цикле <math>k</math> раз. Сложность - <math>O(nk^2)</math>
*3. Процесс разложения матрицы <math>T</math> размерности <math>k*k</math>. Сложность - <math>O(k^2)</math>

Так как число итераций много меньше размерности матрицы <math>A</math>, <math>k << n</math>, то общая сложность алгоритма сокращается до <math>O(kn^2)</math>.

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

[[Файл:Lanczos.png|center|300px|'''Рис. 1.''' Граф ''j''-й итерации.]]

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

Алгоритм Ланцоша - итерационный, итерации должны выполняться в строгой последовательности, и нет возможности их параллелизовать. Внутри одной итерации алгоритма ресурсами параллелизма могут быть:
*1. процесс ортогонализации <math>j</math>-го вектора Ритца;
*2. умножение исходной матрицы на вектор;
*3. вычисление нормы вектора, их скалярного произведения и другие векторные операции.

Умножение матрицы размерности <math>n * n</math> на вектор длины <math>n</math> требует последовательного выполнения <math>n</math> ярусов умножений и сложений.

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

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

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

<references \>

#[[Категория:Законченные статьи]]
#[[Категория:Разложения матриц]]

Учacтник:Malikovmt/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией

2017-02-01T19:18:19Z

Malikovmt: /* Информационный граф */

{{algorithm
| name = Алгоритм Ланцоша с полной переортогонализацией
| serial_complexity = <math>O(n^2k)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>\frac{n(n + 1)}{2}</math>
| output_data = <math>k(n + 1)</math>
}}

Авторы: [[Участник:Eroshkin|А.В.Ерошкин]] ([[#Масштабируемость алгоритма и его реализации|ссылкаКод]]), [[Участник:Malikovmt|М.М.Маликов]] ([[#Описание алгоритма|ссылка]])

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

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

'''Алгоритм Ланцоша''' - итерационный метод, используемый для вычисления части собственных значений и соответствующих им собственных векторов матрицы <math>A</math> размера <math>n*n</math>, изначально разработанный Корнелием Ланцошем. Преимуществами использования метода является относительно небольшое потребление памяти и вычислительных ресурсов, а также наличие параметра <math>k << n</math>, контролирующего количество итераций. Несмотря на то, что алгоритм является вычислительно эффективным, первоначально сформулированный метод был плохо применим из-за численной неустойчивости - метод хорошо работал на целочисленных значениях, однако в арифметике с плавающей точкой ошибки округления давали большую погрешность. В 1970 году Ojalvo и Newman показали, как сделать метод численно стабильным и применили его для расчета крупных инженерных сооружений, подверженных динамическим нагрузкам. Кроме того, они показали способ выбора начального приближения (с использованием ГПСЧ), а также эмпирический способ для выбора числа <math>k</math> (примерно в полтора раза больше искомого числа собственных векторов). В данный момент существует две основных модификации метода (с полной и выборочной переортогонализацией), а также большое количество модификаций, использующихся в различных технических областях. Алгоритм используется для больших <math>n</math>.

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

Первый этап алгоритма - использование метода Ланцоша для построения крыловского подпространства: <math> K_k(A,x) = span[x_1, Ax_1, A^2x_1, ..., A^{k-1}x_1] </math>. Входные данные алгоритма: квадратная симметричная матрица <math>A</math> размерности <math>n*n</math>, вектор начального приближения <math>b</math>, а так же число итераций <math>k</math>. Метод осуществляет поиск трехдиагональной симметричной матрицы <math>T_k=Q_k^TAQ_k</math>.

<math>T_k=\begin{bmatrix}
\alpha_1 & \beta_2 \\
\beta_2 & \alpha_2 & \beta_3 &\\
&. & . & .\\
&&\beta_{k-1} & \alpha_{k-1} & \beta_k\\
&&&\beta_k & \alpha_k
\end{bmatrix}</math>

Описание метода:

<math>
\begin{array}{l}
q_1 = b / \Vert b \Vert_2\\
j = \overline{1, k}:\\
\quad z_j = A q_j \\
\quad \alpha_j = q_j^T z_j \\
\quad z_j = z_j - \sum_{i=1}^j (z_j^T q_i) q_i\\
\quad z_j = z_j - \sum_{i=1}^j (z_j^T q_i) q_i\\
\quad \beta_j = \Vert z_j \Vert_2\\
\quad q_{j+1} = z_j / \Vert z_j \Vert_2 = z_j/\beta_j
\end{array}
</math>

Следующий шаг алгоритма - процедура Рэлея-Ритца. Она зкалючается в интерпретации собственных значений матрицы <math> T_k=Q_k^TAQ_k</math>.
Ее собственные значения приближают собственные значения исходной матрицы. Пусть ''Tk=V<math>\Lambda</math>VT'' - спектральное разложение матрицы ''Tk'', тогда столбцы матрицы ''QkV'' рассматриваются как приближения к соответствующим собственным векторам матрицы ''A'' и называются векторами Ритца. Числа и векторы Ритца являются оптимальными приближениями к собственным значениям и собственным векторам матрицы ''A''.

Поиск собственных значений матрицы ''T'' намного легче, чем для исходной матрицы, так как предполагается, что <math>k << n</math>, и матрица ''T'' - трехдиагональная.

Полная переортогонализация необходима для того, чтобы гарантировать, что каждый полученный вектор ''qj+1'' ортогонален уже имеющимся векторам ''q1..j''. Без этого процесса будут накапливаться существенные вычислительный ошибки.

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

Вычислительным ядро алгоритма состоит ииз двух основных частей:
* <math>Aq=( \sum\nolimits_{i=^n}a_{1i}q_i, \sum\nolimits_{i=2}^na_{2i}q_i, ..., \sum\nolimits_{i=1}^na_{ni}q_i)</math> - умножение симметричной матрицы <math>A</math> размерности <math>n*n</math> на вектор ''q'' размерности ''n''.

* <math>z=z-\sum\nolimits_{i=1}^{k}(z^Tq_i)q_i.</math> - процесс ортогонализации Грама-Шмидта.

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

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

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

В параграфе 1.2 приводится полная схема последовательного алгоритма.

Заполняем начальные значения алгоритма (''b'' - начальное преближение).

<math>
\begin{align}
& q_1=b/||b||,\\
& \beta_1=0,\\
&q_0=0, \\
\end{align}
</math>

Для всех <math>j=1..k</math>:

*1. Вычисляется ''j''-й диагональный элемент матрицы <math>T_k</math>: <math>z=Aq_j; \alpha_j=q_j^Tz;</math>

*2. Проводится полная переортогонализация Грамма-Шмидта: <math>z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i;</math>

*3. Вычисляются значения <math>\beta_{j+1}</math> матрицы <math>T_k</math>: <math>\beta_{j+1}=||z||;</math>

*4. Если <math>\beta_{j+1}=0</math>, то алгоритм завершается;

*5. Сохраняем значения для следующей итерации <math>q_{j+1}=z/\beta_{j+1}.</math>

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

*1. Основная часть операций в алгоритме Ланцоша производится во время умножения матрицы <math>A</math> размерности <math>n*n</math> на вектор <math>q</math> размерности <math>n</math> - вычислительная сложность: <math>n^2</math> умножений и <math>n^2-n</math> сложений. Остальные операции основного цикла производят меньше <math>n^2</math> операций сложения или умножения. Так как умножение матрицы на вектор производится <math>k</math> раз, то сложность этой части алгоритма - <math>O(kn^2)</math>
*2. Процесс ортогонализации Грама-Шмидта - вычислительная сложность: <math>k^2n+k(n+2)</math> умножений и <math>k^2n + k(n + 1) + 2</math> сложений. Производится в цикле <math>k</math> раз. Сложность - <math>O(nk^2)</math>
*3. Процесс разложения матрицы <math>T</math> размерности <math>k*k</math>. Сложность - <math>O(k^2)</math>

Так как число итераций много меньше размерности матрицы <math>A</math>, <math>k << n</math>, то общая сложность алгоритма сокращается до <math>O(kn^2)</math>.

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

[[Файл:Lanczos.png|center|300px|'''Рис. 1.''' Граф ''j''-й итерации.]]

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

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

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

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

<references \>

#[[Категория:Законченные статьи]]
#[[Категория:Разложения матриц]]

Учacтник:Malikovmt/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией

2017-02-01T19:12:54Z

Malikovmt: /* Информационный граф */

{{algorithm
| name = Алгоритм Ланцоша с полной переортогонализацией
| serial_complexity = <math>O(n^2k)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>\frac{n(n + 1)}{2}</math>
| output_data = <math>k(n + 1)</math>
}}

Авторы: [[Участник:Eroshkin|А.В.Ерошкин]] ([[#Масштабируемость алгоритма и его реализации|ссылкаКод]]), [[Участник:Malikovmt|М.М.Маликов]] ([[#Описание алгоритма|ссылка]])

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

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

'''Алгоритм Ланцоша''' - итерационный метод, используемый для вычисления части собственных значений и соответствующих им собственных векторов матрицы <math>A</math> размера <math>n*n</math>, изначально разработанный Корнелием Ланцошем. Преимуществами использования метода является относительно небольшое потребление памяти и вычислительных ресурсов, а также наличие параметра <math>k << n</math>, контролирующего количество итераций. Несмотря на то, что алгоритм является вычислительно эффективным, первоначально сформулированный метод был плохо применим из-за численной неустойчивости - метод хорошо работал на целочисленных значениях, однако в арифметике с плавающей точкой ошибки округления давали большую погрешность. В 1970 году Ojalvo и Newman показали, как сделать метод численно стабильным и применили его для расчета крупных инженерных сооружений, подверженных динамическим нагрузкам. Кроме того, они показали способ выбора начального приближения (с использованием ГПСЧ), а также эмпирический способ для выбора числа <math>k</math> (примерно в полтора раза больше искомого числа собственных векторов). В данный момент существует две основных модификации метода (с полной и выборочной переортогонализацией), а также большое количество модификаций, использующихся в различных технических областях. Алгоритм используется для больших <math>n</math>.

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

Первый этап алгоритма - использование метода Ланцоша для построения крыловского подпространства: <math> K_k(A,x) = span[x_1, Ax_1, A^2x_1, ..., A^{k-1}x_1] </math>. Входные данные алгоритма: квадратная симметричная матрица <math>A</math> размерности <math>n*n</math>, вектор начального приближения <math>b</math>, а так же число итераций <math>k</math>. Метод осуществляет поиск трехдиагональной симметричной матрицы <math>T_k=Q_k^TAQ_k</math>.

<math>T_k=\begin{bmatrix}
\alpha_1 & \beta_2 \\
\beta_2 & \alpha_2 & \beta_3 &\\
&. & . & .\\
&&\beta_{k-1} & \alpha_{k-1} & \beta_k\\
&&&\beta_k & \alpha_k
\end{bmatrix}</math>

Описание метода:

<math>
\begin{array}{l}
q_1 = b / \Vert b \Vert_2\\
j = \overline{1, k}:\\
\quad z_j = A q_j \\
\quad \alpha_j = q_j^T z_j \\
\quad z_j = z_j - \sum_{i=1}^j (z_j^T q_i) q_i\\
\quad z_j = z_j - \sum_{i=1}^j (z_j^T q_i) q_i\\
\quad \beta_j = \Vert z_j \Vert_2\\
\quad q_{j+1} = z_j / \Vert z_j \Vert_2 = z_j/\beta_j
\end{array}
</math>

Следующий шаг алгоритма - процедура Рэлея-Ритца. Она зкалючается в интерпретации собственных значений матрицы <math> T_k=Q_k^TAQ_k</math>.
Ее собственные значения приближают собственные значения исходной матрицы. Пусть ''Tk=V<math>\Lambda</math>VT'' - спектральное разложение матрицы ''Tk'', тогда столбцы матрицы ''QkV'' рассматриваются как приближения к соответствующим собственным векторам матрицы ''A'' и называются векторами Ритца. Числа и векторы Ритца являются оптимальными приближениями к собственным значениям и собственным векторам матрицы ''A''.

Поиск собственных значений матрицы ''T'' намного легче, чем для исходной матрицы, так как предполагается, что <math>k << n</math>, и матрица ''T'' - трехдиагональная.

Полная переортогонализация необходима для того, чтобы гарантировать, что каждый полученный вектор ''qj+1'' ортогонален уже имеющимся векторам ''q1..j''. Без этого процесса будут накапливаться существенные вычислительный ошибки.

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

Вычислительным ядро алгоритма состоит ииз двух основных частей:
* <math>Aq=( \sum\nolimits_{i=^n}a_{1i}q_i, \sum\nolimits_{i=2}^na_{2i}q_i, ..., \sum\nolimits_{i=1}^na_{ni}q_i)</math> - умножение симметричной матрицы <math>A</math> размерности <math>n*n</math> на вектор ''q'' размерности ''n''.

* <math>z=z-\sum\nolimits_{i=1}^{k}(z^Tq_i)q_i.</math> - процесс ортогонализации Грама-Шмидта.

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

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

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

В параграфе 1.2 приводится полная схема последовательного алгоритма.

Заполняем начальные значения алгоритма (''b'' - начальное преближение).

<math>
\begin{align}
& q_1=b/||b||,\\
& \beta_1=0,\\
&q_0=0, \\
\end{align}
</math>

Для всех <math>j=1..k</math>:

*1. Вычисляется ''j''-й диагональный элемент матрицы <math>T_k</math>: <math>z=Aq_j; \alpha_j=q_j^Tz;</math>

*2. Проводится полная переортогонализация Грамма-Шмидта: <math>z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i;</math>

*3. Вычисляются значения <math>\beta_{j+1}</math> матрицы <math>T_k</math>: <math>\beta_{j+1}=||z||;</math>

*4. Если <math>\beta_{j+1}=0</math>, то алгоритм завершается;

*5. Сохраняем значения для следующей итерации <math>q_{j+1}=z/\beta_{j+1}.</math>

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

*1. Основная часть операций в алгоритме Ланцоша производится во время умножения матрицы <math>A</math> размерности <math>n*n</math> на вектор <math>q</math> размерности <math>n</math> - вычислительная сложность: <math>n^2</math> умножений и <math>n^2-n</math> сложений. Остальные операции основного цикла производят меньше <math>n^2</math> операций сложения или умножения. Так как умножение матрицы на вектор производится <math>k</math> раз, то сложность этой части алгоритма - <math>O(kn^2)</math>
*2. Процесс ортогонализации Грама-Шмидта - вычислительная сложность: <math>k^2n+k(n+2)</math> умножений и <math>k^2n + k(n + 1) + 2</math> сложений. Производится в цикле <math>k</math> раз. Сложность - <math>O(nk^2)</math>
*3. Процесс разложения матрицы <math>T</math> размерности <math>k*k</math>. Сложность - <math>O(k^2)</math>

Так как число итераций много меньше размерности матрицы <math>A</math>, <math>k << n</math>, то общая сложность алгоритма сокращается до <math>O(kn^2)</math>.

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

[[Файл:Lanczos.png|thumb|center|300px|'''Рисунок 2.''' Граф ''j''-й итерации.]]

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

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

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

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

<references \>

#[[Категория:Законченные статьи]]
#[[Категория:Разложения матриц]]

Учacтник:Malikovmt/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией

2017-02-01T18:42:01Z

Malikovmt: /* Математическое описание алгоритма */

{{algorithm
| name = Алгоритм Ланцоша с полной переортогонализацией
| serial_complexity = <math>O(n^2k)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>\frac{n(n + 1)}{2}</math>
| output_data = <math>k(n + 1)</math>
}}

Авторы: [[Участник:Eroshkin|А.В.Ерошкин]] ([[#Масштабируемость алгоритма и его реализации|ссылкаКод]]), [[Участник:Malikovmt|М.М.Маликов]] ([[#Описание алгоритма|ссылка]])

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

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

'''Алгоритм Ланцоша''' - итерационный метод, используемый для вычисления части собственных значений и соответствующих им собственных векторов матрицы <math>A</math> размера <math>n*n</math>, изначально разработанный Корнелием Ланцошем. Преимуществами использования метода является относительно небольшое потребление памяти и вычислительных ресурсов, а также наличие параметра <math>k << n</math>, контролирующего количество итераций. Несмотря на то, что алгоритм является вычислительно эффективным, первоначально сформулированный метод был плохо применим из-за численной неустойчивости - метод хорошо работал на целочисленных значениях, однако в арифметике с плавающей точкой ошибки округления давали большую погрешность. В 1970 году Ojalvo и Newman показали, как сделать метод численно стабильным и применили его для расчета крупных инженерных сооружений, подверженных динамическим нагрузкам. Кроме того, они показали способ выбора начального приближения (с использованием ГПСЧ), а также эмпирический способ для выбора числа <math>k</math> (примерно в полтора раза больше искомого числа собственных векторов). В данный момент существует две основных модификации метода (с полной и выборочной переортогонализацией), а также большое количество модификаций, использующихся в различных технических областях. Алгоритм используется для больших <math>n</math>.

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

Первый этап алгоритма - использование метода Ланцоша для построения крыловского подпространства: <math> K_k(A,x) = span[x_1, Ax_1, A^2x_1, ..., A^{k-1}x_1] </math>. Входные данные алгоритма: квадратная симметричная матрица <math>A</math> размерности <math>n*n</math>, вектор начального приближения <math>b</math>, а так же число итераций <math>k</math>. Метод осуществляет поиск трехдиагональной симметричной матрицы <math>T_k=Q_k^TAQ_k</math>.

<math>T_k=\begin{bmatrix}
\alpha_1 & \beta_2 \\
\beta_2 & \alpha_2 & \beta_3 &\\
&. & . & .\\
&&\beta_{k-1} & \alpha_{k-1} & \beta_k\\
&&&\beta_k & \alpha_k
\end{bmatrix}</math>

Описание метода:

<math>
\begin{array}{l}
q_1 = b / \Vert b \Vert_2\\
j = \overline{1, k}:\\
\quad z_j = A q_j \\
\quad \alpha_j = q_j^T z_j \\
\quad z_j = z_j - \sum_{i=1}^j (z_j^T q_i) q_i\\
\quad z_j = z_j - \sum_{i=1}^j (z_j^T q_i) q_i\\
\quad \beta_j = \Vert z_j \Vert_2\\
\quad q_{j+1} = z_j / \Vert z_j \Vert_2 = z_j/\beta_j
\end{array}
</math>

Следующий шаг алгоритма - процедура Рэлея-Ритца. Она зкалючается в интерпретации собственных значений матрицы <math> T_k=Q_k^TAQ_k</math>.
Ее собственные значения приближают собственные значения исходной матрицы. Пусть ''Tk=V<math>\Lambda</math>VT'' - спектральное разложение матрицы ''Tk'', тогда столбцы матрицы ''QkV'' рассматриваются как приближения к соответствующим собственным векторам матрицы ''A'' и называются векторами Ритца. Числа и векторы Ритца являются оптимальными приближениями к собственным значениям и собственным векторам матрицы ''A''.

Поиск собственных значений матрицы ''T'' намного легче, чем для исходной матрицы, так как предполагается, что <math>k << n</math>, и матрица ''T'' - трехдиагональная.

Полная переортогонализация необходима для того, чтобы гарантировать, что каждый полученный вектор ''qj+1'' ортогонален уже имеющимся векторам ''q1..j''. Без этого процесса будут накапливаться существенные вычислительный ошибки.

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

Вычислительным ядро алгоритма состоит ииз двух основных частей:
* <math>Aq=( \sum\nolimits_{i=^n}a_{1i}q_i, \sum\nolimits_{i=2}^na_{2i}q_i, ..., \sum\nolimits_{i=1}^na_{ni}q_i)</math> - умножение симметричной матрицы <math>A</math> размерности <math>n*n</math> на вектор ''q'' размерности ''n''.

* <math>z=z-\sum\nolimits_{i=1}^{k}(z^Tq_i)q_i.</math> - процесс ортогонализации Грама-Шмидта.

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

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

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

В параграфе 1.2 приводится полная схема последовательного алгоритма.

Заполняем начальные значения алгоритма (''b'' - начальное преближение).

<math>
\begin{align}
& q_1=b/||b||,\\
& \beta_1=0,\\
&q_0=0, \\
\end{align}
</math>

Для всех <math>j=1..k</math>:

*1. Вычисляется ''j''-й диагональный элемент матрицы <math>T_k</math>: <math>z=Aq_j; \alpha_j=q_j^Tz;</math>

*2. Проводится полная переортогонализация Грамма-Шмидта: <math>z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i;</math>

*3. Вычисляются значения <math>\beta_{j+1}</math> матрицы <math>T_k</math>: <math>\beta_{j+1}=||z||;</math>

*4. Если <math>\beta_{j+1}=0</math>, то алгоритм завершается;

*5. Сохраняем значения для следующей итерации <math>q_{j+1}=z/\beta_{j+1}.</math>

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

*1. Основная часть операций в алгоритме Ланцоша производится во время умножения матрицы <math>A</math> размерности <math>n*n</math> на вектор <math>q</math> размерности <math>n</math> - вычислительная сложность: <math>n^2</math> умножений и <math>n^2-n</math> сложений. Остальные операции основного цикла производят меньше <math>n^2</math> операций сложения или умножения. Так как умножение матрицы на вектор производится <math>k</math> раз, то сложность этой части алгоритма - <math>O(kn^2)</math>
*2. Процесс ортогонализации Грама-Шмидта - вычислительная сложность: <math>k^2n+k(n+2)</math> умножений и <math>k^2n + k(n + 1) + 2</math> сложений. Производится в цикле <math>k</math> раз. Сложность - <math>O(nk^2)</math>
*3. Процесс разложения матрицы <math>T</math> размерности <math>k*k</math>. Сложность - <math>O(k^2)</math>

Так как число итераций много меньше размерности матрицы <math>A</math>, <math>k << n</math>, то общая сложность алгоритма сокращается до <math>O(kn^2)</math>.

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

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

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

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

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

<references \>

#[[Категория:Законченные статьи]]
#[[Категория:Разложения матриц]]

Учacтник:Malikovmt/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией

2017-02-01T17:56:24Z

Malikovmt:

{{algorithm
| name = Алгоритм Ланцоша с полной переортогонализацией
| serial_complexity = <math>O(n^2k)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>\frac{n(n + 1)}{2}</math>
| output_data = <math>k(n + 1)</math>
}}

Авторы: [[Участник:Eroshkin|А.В.Ерошкин]] ([[#Масштабируемость алгоритма и его реализации|ссылкаКод]]), [[Участник:Malikovmt|М.М.Маликов]] ([[#Описание алгоритма|ссылка]])

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

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

'''Алгоритм Ланцоша''' - итерационный метод, используемый для вычисления части собственных значений и соответствующих им собственных векторов матрицы <math>A</math> размера <math>n*n</math>, изначально разработанный Корнелием Ланцошем. Преимуществами использования метода является относительно небольшое потребление памяти и вычислительных ресурсов, а также наличие параметра <math>k << n</math>, контролирующего количество итераций. Несмотря на то, что алгоритм является вычислительно эффективным, первоначально сформулированный метод был плохо применим из-за численной неустойчивости - метод хорошо работал на целочисленных значениях, однако в арифметике с плавающей точкой ошибки округления давали большую погрешность. В 1970 году Ojalvo и Newman показали, как сделать метод численно стабильным и применили его для расчета крупных инженерных сооружений, подверженных динамическим нагрузкам. Кроме того, они показали способ выбора начального приближения (с использованием ГПСЧ), а также эмпирический способ для выбора числа <math>k</math> (примерно в полтора раза больше искомого числа собственных векторов). В данный момент существует две основных модификации метода (с полной и выборочной переортогонализацией), а также большое количество модификаций, использующихся в различных технических областях. Алгоритм используется для больших <math>n</math>.

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

Первый этап алгоритма - использование метода Ланцоша для построения крыловского подпространства: <math> K_k(A,x) = span[x_1, Ax_1, A^2x_1, ..., A^{k-1}x_1] </math>. Входные данные алгоритма: квадратная симметричная матрица <math>A</math> размерности <math>n*n</math>, вектор начального приближения <math>b</math>, а так же число итераций <math>k</math>. Метод осуществляет поиск трехдиагональной симметричной матрицы <math>T_k=Q_k^TAQ_k</math>.

<math>T_k=\begin{bmatrix}
\alpha_1 & \beta_2 \\
\beta_2 & \alpha_2 & \beta_3 &\\
&. & . & .\\
&&\beta_{k-1} & \alpha_{k-1} & \beta_k\\
&&&\beta_k & \alpha_k
\end{bmatrix}</math>

Описание метода:

<math>
\begin{array}{l}
q_1 = b / \Vert b \Vert_2\\
j = \overline{1, k}:\\
\quad z_j = A q_j \\
\quad \alpha_j = q_j^T A q_j = q_j^T z_j \\
\quad z_j = z_j - \sum_{i=1}^j (z_j^T q_i) q_i\\
\quad z_j = z_j - \sum_{i=1}^j (z_j^T q_i) q_i\\
\quad \beta_j = \Vert z_j \Vert_2\\
\quad q_{j+1} = z_j / \Vert z_j \Vert_2 = z_j/\beta_j
\end{array}
</math>

Следующий шаг алгоритма - процедура Рэлея-Ритца. Она зкалючается в интерпретации собственных значений матрицы <math> T_k=Q_k^TAQ_k</math>.
Ее собственные значения приближают собственные значения исходной матрицы. Пусть ''Tk=V<math>\Lambda</math>VT'' - спектральное разложение матрицы ''Tk'', тогда столбцы матрицы ''QkV'' рассматриваются как приближения к соответствующим собственным векторам матрицы ''A'' и называются векторами Ритца. Числа и векторы Ритца являются оптимальными приближениями к собственным значениям и собственным векторам матрицы ''A''.

Поиск собственных значений матрицы ''T'' намного легче, чем для исходной матрицы, так как предполагается, что <math>k << n</math>, и матрица ''T'' - трехдиагональная.

Полная переортогонализация необходима для того, чтобы гарантировать, что каждый полученный вектор ''qj+1'' ортогонален уже имеющимся векторам ''q1..j''. Без этого процесса будут накапливаться существенные вычислительный ошибки.

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

Вычислительным ядро алгоритма состоит ииз двух основных частей:
* <math>Aq=( \sum\nolimits_{i=^n}a_{1i}q_i, \sum\nolimits_{i=2}^na_{2i}q_i, ..., \sum\nolimits_{i=1}^na_{ni}q_i)</math> - умножение симметричной матрицы <math>A</math> размерности <math>n*n</math> на вектор ''q'' размерности ''n''.

* <math>z=z-\sum\nolimits_{i=1}^{k}(z^Tq_i)q_i.</math> - процесс ортогонализации Грама-Шмидта.

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

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

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

В параграфе 1.2 приводится полная схема последовательного алгоритма.

Заполняем начальные значения алгоритма (''b'' - начальное преближение).

<math>
\begin{align}
& q_1=b/||b||,\\
& \beta_1=0,\\
&q_0=0, \\
\end{align}
</math>

Для всех <math>j=1..k</math>:

*1. Вычисляется ''j''-й диагональный элемент матрицы <math>T_k</math>: <math>z=Aq_j; \alpha_j=q_j^Tz;</math>

*2. Проводится полная переортогонализация Грамма-Шмидта: <math>z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i;</math>

*3. Вычисляются значения <math>\beta_{j+1}</math> матрицы <math>T_k</math>: <math>\beta_{j+1}=||z||;</math>

*4. Если <math>\beta_{j+1}=0</math>, то алгоритм завершается;

*5. Сохраняем значения для следующей итерации <math>q_{j+1}=z/\beta_{j+1}.</math>

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

*1. Основная часть операций в алгоритме Ланцоша производится во время умножения матрицы <math>A</math> размерности <math>n*n</math> на вектор <math>q</math> размерности <math>n</math> - вычислительная сложность: <math>n^2</math> умножений и <math>n^2-n</math> сложений. Остальные операции основного цикла производят меньше <math>n^2</math> операций сложения или умножения. Так как умножение матрицы на вектор производится <math>k</math> раз, то сложность этой части алгоритма - <math>O(kn^2)</math>
*2. Процесс ортогонализации Грама-Шмидта - вычислительная сложность: <math>k^2n+k(n+2)</math> умножений и <math>k^2n + k(n + 1) + 2</math> сложений. Производится в цикле <math>k</math> раз. Сложность - <math>O(nk^2)</math>
*3. Процесс разложения матрицы <math>T</math> размерности <math>k*k</math>. Сложность - <math>O(k^2)</math>

Так как число итераций много меньше размерности матрицы <math>A</math>, <math>k << n</math>, то общая сложность алгоритма сокращается до <math>O(kn^2)</math>.

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

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

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

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

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

<references \>

#[[Категория:Законченные статьи]]
#[[Категория:Разложения матриц]]

Учacтник:Malikovmt/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией

2017-02-01T17:52:24Z

Malikovmt: /* Математическое описание алгоритма */

{{algorithm
| name = Алгоритм Ланцоша с полной переортогонализацией
| serial_complexity = <math>O(n^2k)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>\frac{n(n + 1)}{2}</math>
| output_data = <math>k(n + 1)</math>
}}

Авторы: [[Участник:Eroshkin|А.В.Ерошкин]] ([[#Масштабируемость алгоритма и его реализации|ссылкаКод]]), [[Участник:Malikovmt|М.М.Маликов]] ([[#Описание алгоритма|ссылка]])

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

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

'''Алгоритм Ланцоша''' - итерационный метод, используемый для вычисления части собственных значений и соответствующих им собственных векторов матрицы <math>A</math> размера <math>n*n</math>, изначально разработанный Корнелием Ланцошем. Преимуществами использования метода является относительно небольшое потребление памяти и вычислительных ресурсов, а также наличие параметра <math>k << n</math>, контролирующего количество итераций. Несмотря на то, что алгоритм является вычислительно эффективным, первоначально сформулированный метод был плохо применим из-за численной неустойчивости - метод хорошо работал на целочисленных значениях, однако в арифметике с плавающей точкой ошибки округления давали большую погрешность. В 1970 году Ojalvo и Newman показали, как сделать метод численно стабильным и применили его для расчета крупных инженерных сооружений, подверженных динамическим нагрузкам. Кроме того, они показали способ выбора начального приближения (с использованием ГПСЧ), а также эмпирический способ для выбора числа <math>k</math> (примерно в полтора раза больше искомого числа собственных векторов). В данный момент существует две основных модификации метода (с полной и выборочной переортогонализацией), а также большое количество модификаций, использующихся в различных технических областях. Алгоритм используется для больших <math>n</math>.

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

Первый этап алгоритма - использование метода Ланцоша для построения крыловского подпространства: <math> K_k(A,x) = span[x_1, Ax_1, A^2x_1, ..., A^{k-1}x_1] </math>. Входные данные алгоритма: квадратная симметричная матрица <math>A</math> размерности <math>n*n</math>, вектор начального приближения <math>b</math>, а так же число итераций <math>k</math>. Метод осуществляет поиск трехдиагональной симметричной матрицы <math>T_k=Q_k^TAQ_k</math>.

<math>T_k=\begin{bmatrix}
\alpha_1 & \beta_2 \\
\beta_2 & \alpha_2 & \beta_3 &\\
&. & . & .\\
&&\beta_{k-1} & \alpha_{k-1} & \beta_k\\
&&&\beta_k & \alpha_k
\end{bmatrix}</math>

Описание метода:

<math>
\begin{array}{l}
q_1 = b / \Vert b \Vert_2\\
j = \overline{1, k}:\\
\quad z_j = A q_j \\
\quad \alpha_j = q_j^T A q_j = q_j^T z_j \\
\quad z_j = z_j - \sum_{i=1}^j (z_j^T q_i) q_i\\
\quad z_j = z_j - \sum_{i=1}^j (z_j^T q_i) q_i\\
\quad \beta_j = \Vert z_j \Vert_2\\
\quad q_{j+1} = z_j / \Vert z_j \Vert_2 = z_j/\beta_j
\end{array}
</math>

Следующий шаг алгоритма - процедура Рэлея-Ритца. Она зкалючается в интерпретации собственных значений матрицы <math> T_k=Q_k^TAQ_k</math>.
Ее собственные значения приближают собственные значения исходной матрицы. Пусть ''Tk=V<math>\Lambda</math>VT'' - спектральное разложение матрицы ''Tk'', тогда столбцы матрицы ''QkV'' рассматриваются как приближения к соответствующим собственным векторам матрицы ''A'' и называются векторами Ритца. Числа и векторы Ритца являются оптимальными приближениями к собственным значениям и собственным векторам матрицы ''A''.

Поиск собственных значений матрицы ''T'' намного легче, чем для исходной матрицы, так как предполагается, что <math>k << n</math>, и матрица ''T'' - трехдиагональная.

Полная переортогонализация необходима для того, чтобы гарантировать, что каждый полученный вектор ''qj+1'' ортогонален уже имеющимся векторам ''q1..j''. Без этого процесса будут накапливаться существенные вычислительный ошибки.

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

Вычислительным ядро алгоритма состоит ииз двух основных частей:
* <math>Aq=( \sum\nolimits_{i=^n}a_{1i}q_i, \sum\nolimits_{i=2}^na_{2i}q_i, ..., \sum\nolimits_{i=1}^na_{ni}q_i)</math> - умножение симметричной матрицы <math>A</math> размерности <math>n*n</math> на вектор ''q'' размерности ''n''.

* <math>z=z-\sum\nolimits_{i=1}^{k}(z^Tq_i)q_i.</math> - процесс ортогонализации Грама-Шмидта.

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

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

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

В параграфе 1.2 приводится полная схема последовательного алгоритма.

Заполняем начальные значения алгоритма (''b'' - начальное преближение).

<math>
\begin{align}
& q_1=b/||b||,\\
& \beta_1=0,\\
&q_0=0, \\
\end{align}
</math>

Для всех <math>j=1..k</math>:

*1. Вычисляется ''j''-й диагональный элемент матрицы <math>T_k</math>: <math>z=Aq_j; \alpha_j=q_j^Tz;</math>

*2. Проводится полная переортогонализация Грамма-Шмидта: <math>z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i;</math>

*3. Вычисляются значения <math>\beta_{j+1}</math> матрицы <math>T_k</math>: <math>\beta_{j+1}=||z||;</math>

*4. Если <math>\beta_{j+1}=0</math>, то алгоритм завершается;

*5. Сохраняем значения для следующей итерации <math>q_{j+1}=z/\beta_{j+1}.</math>

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

*1. Основная часть операций в алгоритме Ланцоша производится во время умножения матрицы <math>A</math> размерности <math>n*n</math> на вектор <math>q</math> размерности <math>n</math> - вычислительная сложность: <math>n^2</math> умножений и <math>n^2-n</math> сложений. Остальные операции основного цикла производят меньше <math>n^2</math> операций сложения или умножения. Так как умножение матрицы на вектор производится <math>k</math> раз, то сложность этой части алгоритма - <math>O(kn^2)</math>
*2. Процесс ортогонализации Грама-Шмидта - вычислительная сложность: <math>k^2n+k(n+2)</math> умножений и <math>k^2n + k(n + 1) + 2</math> сложений. Производится в цикле <math>k</math> раз. Сложность - <math>O(nk^2)</math>
*3. Процесс разложения матрицы <math>T</math> размерности <math>k*k</math>. Сложность - <math>O(k^2)</math>

Так как число итераций много меньше размерности матрицы <math>A</math>, <math>k << n</math>, то общая сложность алгоритма сокращается до <math>O(kn^2)</math>.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<references \>

#[[en:Cholesky decomposition]]

#[[Категория:Законченные статьи]]
#[[Категория:Разложения матриц]]

Учacтник:Malikovmt/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией

2017-02-01T17:44:32Z

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

{{algorithm
| name = Алгоритм Ланцоша с полной переортогонализацией
| serial_complexity = <math>O(n^2k)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>\frac{n(n + 1)}{2}</math>
| output_data = <math>k(n + 1)</math>
}}

Авторы: [[Участник:Eroshkin|А.В.Ерошкин]] ([[#Масштабируемость алгоритма и его реализации|ссылкаКод]]), [[Участник:Malikovmt|М.М.Маликов]] ([[#Описание алгоритма|ссылка]])

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

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

'''Алгоритм Ланцоша''' - итерационный метод, используемый для вычисления части собственных значений и соответствующих им собственных векторов матрицы <math>A</math> размера <math>n*n</math>, изначально разработанный Корнелием Ланцошем. Преимуществами использования метода является относительно небольшое потребление памяти и вычислительных ресурсов, а также наличие параметра <math>k << n</math>, контролирующего количество итераций. Несмотря на то, что алгоритм является вычислительно эффективным, первоначально сформулированный метод был плохо применим из-за численной неустойчивости - метод хорошо работал на целочисленных значениях, однако в арифметике с плавающей точкой ошибки округления давали большую погрешность. В 1970 году Ojalvo и Newman показали, как сделать метод численно стабильным и применили его для расчета крупных инженерных сооружений, подверженных динамическим нагрузкам. Кроме того, они показали способ выбора начального приближения (с использованием ГПСЧ), а также эмпирический способ для выбора числа <math>k</math> (примерно в полтора раза больше искомого числа собственных векторов). В данный момент существует две основных модификации метода (с полной и выборочной переортогонализацией), а также большое количество модификаций, использующихся в различных технических областях. Алгоритм используется для больших <math>n</math>.

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

Первый этап алгоритма - использование метода Ланцоша для построения крыловского подпространства: <math> K_k(A,x) = span[x_1, Ax_1, A^2x_1, ..., A^{k-1}x_1] </math>. Входные данные алгоритма: квадратная симметричная матрица <math>A</math> размерности <math>n*n</math>, вектор начального приближения <math>b</math>, а так же число итераций <math>k</math>. Метод осуществляет поиск трехдиагональной симметричной матрицы <math>T_k=Q_k^TAQ_k</math>.

<math>T_k=\begin{bmatrix}
\alpha_1 & \beta_2 \\
\beta_2 & \alpha_2 & \beta_3 &\\
&. & . & .\\
&&\beta_{k-1} & \alpha_{k-1} & \beta_k\\
&&&\beta_k & \alpha_k
\end{bmatrix}</math>

Описание метода:

<math>
\begin{array}{l}
q_1 = b / \Vert b \Vert_2\\
j = \overline{1, k}:\\
\quad z_j = A q_j \\
\quad \alpha_j = q_j^T A q_j = q_j^T z_j \\
\quad z_j = z_j - \sum_{i=1}^j (z_j^T q_i) q_i\\
\quad \beta_j = \Vert z_j \Vert_2\\
\quad q_{j+1} = z_j / \Vert z_j \Vert_2 = z_j/\beta_j
\end{array}
</math>

Следующий шаг алгоритма - процедура Рэлея-Ритца. Она зкалючается в интерпретации собственных значений матрицы <math> T_k=Q_k^TAQ_k</math>.
Ее собственные значения приближают собственные значения исходной матрицы. Пусть ''Tk=V<math>\Lambda</math>VT'' - спектральное разложение матрицы ''Tk'', тогда столбцы матрицы ''QkV'' рассматриваются как приближения к соответствующим собственным векторам матрицы ''A'' и называются векторами Ритца. Числа и векторы Ритца являются оптимальными приближениями к собственным значениям и собственным векторам матрицы ''A''.

Поиск собственных значений матрицы ''T'' намного легче, чем для исходной матрицы, так как предполагается, что <math>k << n</math>, и матрица ''T'' - трехдиагональная.

Полная переортогонализация необходима для того, чтобы гарантировать, что каждый полученный вектор ''qj+1'' ортогонален уже имеющимся векторам ''q1..j''. Без этого процесса будут накапливаться существенные вычислительный ошибки.

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

Вычислительным ядро алгоритма состоит ииз двух основных частей:
* <math>Aq=( \sum\nolimits_{i=^n}a_{1i}q_i, \sum\nolimits_{i=2}^na_{2i}q_i, ..., \sum\nolimits_{i=1}^na_{ni}q_i)</math> - умножение симметричной матрицы <math>A</math> размерности <math>n*n</math> на вектор ''q'' размерности ''n''.

* <math>z=z-\sum\nolimits_{i=1}^{k}(z^Tq_i)q_i.</math> - процесс ортогонализации Грама-Шмидта.

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

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

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

В параграфе 1.2 приводится полная схема последовательного алгоритма.

Заполняем начальные значения алгоритма (''b'' - начальное преближение).

<math>
\begin{align}
& q_1=b/||b||,\\
& \beta_1=0,\\
&q_0=0, \\
\end{align}
</math>

Для всех <math>j=1..k</math>:

*1. Вычисляется ''j''-й диагональный элемент матрицы <math>T_k</math>: <math>z=Aq_j; \alpha_j=q_j^Tz;</math>

*2. Проводится полная переортогонализация Грамма-Шмидта: <math>z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i;</math>

*3. Вычисляются значения <math>\beta_{j+1}</math> матрицы <math>T_k</math>: <math>\beta_{j+1}=||z||;</math>

*4. Если <math>\beta_{j+1}=0</math>, то алгоритм завершается;

*5. Сохраняем значения для следующей итерации <math>q_{j+1}=z/\beta_{j+1}.</math>

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

*1. Основная часть операций в алгоритме Ланцоша производится во время умножения матрицы <math>A</math> размерности <math>n*n</math> на вектор <math>q</math> размерности <math>n</math> - вычислительная сложность: <math>n^2</math> умножений и <math>n^2-n</math> сложений. Остальные операции основного цикла производят меньше <math>n^2</math> операций сложения или умножения. Так как умножение матрицы на вектор производится <math>k</math> раз, то сложность этой части алгоритма - <math>O(kn^2)</math>
*2. Процесс ортогонализации Грама-Шмидта - вычислительная сложность: <math>k^2n+k(n+2)</math> умножений и <math>k^2n + k(n + 1) + 2</math> сложений. Производится в цикле <math>k</math> раз. Сложность - <math>O(nk^2)</math>
*3. Процесс разложения матрицы <math>T</math> размерности <math>k*k</math>. Сложность - <math>O(k^2)</math>

Так как число итераций много меньше размерности матрицы <math>A</math>, <math>k << n</math>, то общая сложность алгоритма сокращается до <math>O(kn^2)</math>.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<references \>

#[[en:Cholesky decomposition]]

#[[Категория:Законченные статьи]]
#[[Категория:Разложения матриц]]

Учacтник:Malikovmt/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией

2017-02-01T17:31:10Z

Malikovmt: /* Математическое описание алгоритма */

{{algorithm
| name = Алгоритм Ланцоша с полной переортогонализацией
| serial_complexity = <math>O(n^2k)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>\frac{n(n + 1)}{2}</math>
| output_data = <math>k(n + 1)</math>
}}

Авторы: [[Участник:Eroshkin|А.В.Ерошкин]] ([[#Масштабируемость алгоритма и его реализации|ссылкаКод]]), [[Участник:Malikovmt|М.М.Маликов]] ([[#Описание алгоритма|ссылка]])

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

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

'''Алгоритм Ланцоша''' - итерационный метод, используемый для вычисления части собственных значений и соответствующих им собственных векторов матрицы <math>A</math> размера <math>n*n</math>, изначально разработанный Корнелием Ланцошем. Преимуществами использования метода является относительно небольшое потребление памяти и вычислительных ресурсов, а также наличие параметра <math>k << n</math>, контролирующего количество итераций. Несмотря на то, что алгоритм является вычислительно эффективным, первоначально сформулированный метод был плохо применим из-за численной неустойчивости - метод хорошо работал на целочисленных значениях, однако в арифметике с плавающей точкой ошибки округления давали большую погрешность. В 1970 году Ojalvo и Newman показали, как сделать метод численно стабильным и применили его для расчета крупных инженерных сооружений, подверженных динамическим нагрузкам. Кроме того, они показали способ выбора начального приближения (с использованием ГПСЧ), а также эмпирический способ для выбора числа <math>k</math> (примерно в полтора раза больше искомого числа собственных векторов). В данный момент существует две основных модификации метода (с полной и выборочной переортогонализацией), а также большое количество модификаций, использующихся в различных технических областях. Алгоритм используется для больших <math>n</math>.

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

Первый этап алгоритма - использование метода Ланцоша для построения крыловского подпространства: <math> K_k(A,x) = span[x_1, Ax_1, A^2x_1, ..., A^{k-1}x_1] </math>. Входные данные алгоритма: квадратная симметричная матрица <math>A</math> размерности <math>n*n</math>, вектор начального приближения <math>b</math>, а так же число итераций <math>k</math>. Метод осуществляет поиск трехдиагональной симметричной матрицы <math>T_k=Q_k^TAQ_k</math>.

<math>T_k=\begin{bmatrix}
\alpha_1 & \beta_2 \\
\beta_2 & \alpha_2 & \beta_3 &\\
&. & . & .\\
&&\beta_{k-1} & \alpha_{k-1} & \beta_k\\
&&&\beta_k & \alpha_k
\end{bmatrix}</math>

Описание метода:

<math>
\begin{array}{l}
q_1 = b / \Vert b \Vert_2\\
j = \overline{1, k}:\\
\quad z_j = A q_j \\
\quad \alpha_j = q_j^T A q_j = q_j^T z_j \\
\quad z_j = z_j - \sum_{i=1}^j (z_j^T q_i) q_i\\
\quad \beta_j = \Vert z_j \Vert_2\\
\quad q_{j+1} = z_j / \Vert z_j \Vert_2 = z_j/\beta_j
\end{array}
</math>

Следующий шаг алгоритма - процедура Рэлея-Ритца. Она зкалючается в интерпретации собственных значений матрицы <math> T_k=Q_k^TAQ_k</math>.
Ее собственные значения приближают собственные значения исходной матрицы. Пусть ''Tk=V<math>\Lambda</math>VT'' - спектральное разложение матрицы ''Tk'', тогда столбцы матрицы ''QkV'' рассматриваются как приближения к соответствующим собственным векторам матрицы ''A'' и называются векторами Ритца. Числа и векторы Ритца являются оптимальными приближениями к собственным значениям и собственным векторам матрицы ''A''.

Поиск собственных значений матрицы ''T'' намного легче, чем для исходной матрицы, так как предполагается, что <math>k << n</math>, и матрица ''T'' - трехдиагональная.

Полная переортогонализация необходима для того, чтобы гарантировать, что каждый полученный вектор ''qj+1'' ортогонален уже имеющимся векторам ''q1..j''. Без этого процесса будут накапливаться существенные вычислительный ошибки.

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

Вычислительным ядро алгоритма состоит ииз двух основных частей:
* <math>Aq=( \sum\nolimits_{i=^n}a_{1i}q_i, \sum\nolimits_{i=2}^na_{2i}q_i, ..., \sum\nolimits_{i=1}^na_{ni}q_i)</math> - умножение симметричной матрицы <math>A</math> размерности <math>n*n</math> на вектор ''q'' размерности ''n''.

* <math>z=z-\sum\nolimits_{i=1}^{k}(z^Tq_i)q_i.</math> - процесс ортогонализации Грама-Шмидта.

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

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

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

В параграфе 1.2 приводится полная схема последовательного алгоритма.

Заполняем начальные значения алгоритма (''b'' - начальное преближение).

<math>
\begin{align}
& q_1=b/||b||,\\
& \beta_1=0,\\
&q_0=0, \\
\end{align}
</math>

Для всех <math>j=1..k</math>:

*1. Вычисляется ''j''-й диагональный элемент матрицы <math>T_k</math>: <math>z=Aq_j; \alpha_j=q_j^Tz;</math>

*2. Проводится полная переортогонализация Грамма-Шмидта: <math>z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i;</math>

*3. Вычисляются значения <math>\beta_{j+1}</math> матрицы <math>T_k</math>: <math>\beta_{j+1}=||z||;</math>

*4. Если <math>\beta_{j+1}=0</math>, то алгоритм завершается;

*5. Сохраняем значения для следующей итерации <math>q_{j+1}=z/\beta_{j+1}.</math>

=== Последовательная сложность алгоритма ===
*1. умножение симметричной матрицы <math>A</math> размерности <math>n*n</math> на вектор ''q'' размерности ''n'' - вычислительная сложность: <math>n^2</math> умножений и <math>n^2-n</math> сложений
*2. процесс ортогонализации Грама-Шмидта - вычислительная сложность: <math>k^2n+k(n+2)</math> умножений и <math>k^2n + k(n + 1) + 2</math> сложений.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<references \>

#[[en:Cholesky decomposition]]

#[[Категория:Законченные статьи]]
#[[Категория:Разложения матриц]]

Учacтник:Malikovmt/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией

2017-02-01T17:06:10Z

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

{{algorithm
| name = Алгоритм Ланцоша с полной переортогонализацией
| serial_complexity = <math>O(n^2k)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>\frac{n(n + 1)}{2}</math>
| output_data = <math>k(n + 1)</math>
}}

Авторы: [[Участник:Eroshkin|А.В.Ерошкин]] ([[#Масштабируемость алгоритма и его реализации|ссылкаКод]]), [[Участник:Malikovmt|М.М.Маликов]] ([[#Описание алгоритма|ссылка]])

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

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

'''Алгоритм Ланцоша''' - итерационный метод, используемый для вычисления части собственных значений и соответствующих им собственных векторов матрицы <math>A</math> размера <math>n*n</math>, изначально разработанный Корнелием Ланцошем. Преимуществами использования метода является относительно небольшое потребление памяти и вычислительных ресурсов, а также наличие параметра <math>k << n</math>, контролирующего количество итераций. Несмотря на то, что алгоритм является вычислительно эффективным, первоначально сформулированный метод был плохо применим из-за численной неустойчивости - метод хорошо работал на целочисленных значениях, однако в арифметике с плавающей точкой ошибки округления давали большую погрешность. В 1970 году Ojalvo и Newman показали, как сделать метод численно стабильным и применили его для расчета крупных инженерных сооружений, подверженных динамическим нагрузкам. Кроме того, они показали способ выбора начального приближения (с использованием ГПСЧ), а также эмпирический способ для выбора числа <math>k</math> (примерно в полтора раза больше искомого числа собственных векторов). В данный момент существует две основных модификации метода (с полной и выборочной переортогонализацией), а также большое количество модификаций, использующихся в различных технических областях. Алгоритм используется для больших <math>n</math>.

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

Первый этап алгоритма - использование метода Ланцоша для построения крыловского подпространства: <math> K_k(A,x) = span[x_1, Ax_1, A^2x_1, ..., A^{k-1}x_1] </math>. Входные данные алгоритма: квадратная симметричная матрица <math>A</math> размерности <math>n*n</math>, вектор начального приближения <math>b</math>, а так же число итераций <math>k</math>. Метод осуществляет поиск трехдиагональной симметричной матрицы <math>T_k=Q_k^TAQ_k</math>.

<math>T_k=\begin{bmatrix}
\alpha_1 & \beta_2 \\
\beta_2 & \alpha_2 & \beta_3 &\\
&. & . & .\\
&&\beta_{k-1} & \alpha_{k-1} & \beta_k\\
&&&\beta_k & \alpha_k
\end{bmatrix}</math>

Описание метода:

<math>
\begin{array}{l}
q_1 = b / \Vert b \Vert_2\\
j = \overline{1, k}:\\
\quad z_j = A q_j \\
\quad \alpha_j = q_j^T A q_j = q_j^T z_j \\
\quad z_j = z_j - \sum_{i=1}^j (z_j'^T q_i) q_i\\
\quad \beta_j = \Vert z_j \Vert_2\\
\quad q_{j+1} = z_j / \Vert z_j'' \Vert_2 = z_j/\beta_j
\end{array}
</math>

Следующий шаг алгоритма - процедура Рэлея-Ритца. Она зкалючается в интерпретации собственных значений матрицы <math> T_k=Q_k^TAQ_k</math>.
Ее собственные значения приближают собственные значения исходной матрицы. Пусть ''Tk=V<math>\Lambda</math>VT'' - спектральное разложение матрицы ''Tk'', тогда столбцы матрицы ''QkV'' рассматриваются как приближения к соответствующим собственным векторам матрицы ''A'' и называются векторами Ритца. Числа и векторы Ритца являются оптимальными приближениями к собственным значениям и собственным векторам матрицы ''A''.

Поиск собственных значений матрицы ''T'' намного легче, чем для исходной матрицы, так как предполагается, что <math>k << n</math>, и матрица ''T'' - трехдиагональная.

Полная переортогонализация необходима для того, чтобы гарантировать, что каждый полученный вектор ''qj+1'' ортогонален уже имеющимся векторам ''q1..j''. Без этого процесса будут накапливаться существенные вычислительный ошибки.

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

Вычислительным ядро алгоритма состоит ииз двух основных частей:
* <math>Aq=( \sum\nolimits_{i=^n}a_{1i}q_i, \sum\nolimits_{i=2}^na_{2i}q_i, ..., \sum\nolimits_{i=1}^na_{ni}q_i)</math> - умножение симметричной матрицы <math>A</math> размерности <math>n*n</math> на вектор ''q'' размерности ''n''.

* <math>z=z-\sum\nolimits_{i=1}^{k}(z^Tq_i)q_i.</math> - процесс ортогонализации Грама-Шмидта.

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

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

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

В параграфе 1.2 приводится полная схема последовательного алгоритма.

Заполняем начальные значения алгоритма (''b'' - начальное преближение).

<math>
\begin{align}
& q_1=b/||b||,\\
& \beta_1=0,\\
&q_0=0, \\
\end{align}
</math>

Для всех <math>j=1..k</math>:

*1. Вычисляется ''j''-й диагональный элемент матрицы <math>T_k</math>: <math>z=Aq_j; \alpha_j=q_j^Tz;</math>

*2. Проводится полная переортогонализация Грамма-Шмидта: <math>z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i;</math>

*3. Вычисляются значения <math>\beta_{j+1}</math> матрицы <math>T_k</math>: <math>\beta_{j+1}=||z||;</math>

*4. Если <math>\beta_{j+1}=0</math>, то алгоритм завершается;

*5. Сохраняем значения для следующей итерации <math>q_{j+1}=z/\beta_{j+1}.</math>

=== Последовательная сложность алгоритма ===
*1. умножение симметричной матрицы <math>A</math> размерности <math>n*n</math> на вектор ''q'' размерности ''n'' - вычислительная сложность: <math>n^2</math> умножений и <math>n^2-n</math> сложений
*2. процесс ортогонализации Грама-Шмидта - вычислительная сложность: <math>k^2n+k(n+2)</math> умножений и <math>k^2n + k(n + 1) + 2</math> сложений.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<references \>

#[[en:Cholesky decomposition]]

#[[Категория:Законченные статьи]]
#[[Категория:Разложения матриц]]

Учacтник:Malikovmt/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией

2017-02-01T16:42:37Z

Malikovmt: /* Общее описание алгоритма */

{{algorithm
| name = Алгоритм Ланцоша с полной переортогонализацией
| serial_complexity = <math>O(n^2k)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>\frac{n(n + 1)}{2}</math>
| output_data = <math>k(n + 1)</math>
}}

Авторы: [[Участник:Eroshkin|А.В.Ерошкин]] ([[#Масштабируемость алгоритма и его реализации|ссылкаКод]]), [[Участник:Malikovmt|М.М.Маликов]] ([[#Описание алгоритма|ссылка]])

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

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

'''Алгоритм Ланцоша''' - итерационный метод, используемый для вычисления части собственных значений и соответствующих им собственных векторов матрицы <math>A</math> размера <math>n*n</math>, изначально разработанный Корнелием Ланцошем. Преимуществами использования метода является относительно небольшое потребление памяти и вычислительных ресурсов, а также наличие параметра <math>k << n</math>, контролирующего количество итераций. Несмотря на то, что алгоритм является вычислительно эффективным, первоначально сформулированный метод был плохо применим из-за численной неустойчивости - метод хорошо работал на целочисленных значениях, однако в арифметике с плавающей точкой ошибки округления давали большую погрешность. В 1970 году Ojalvo и Newman показали, как сделать метод численно стабильным и применили его для расчета крупных инженерных сооружений, подверженных динамическим нагрузкам. Кроме того, они показали способ выбора начального приближения (с использованием ГПСЧ), а также эмпирический способ для выбора числа <math>k</math> (примерно в полтора раза больше искомого числа собственных векторов). В данный момент существует две основных модификации метода (с полной и выборочной переортогонализацией), а также большое количество модификаций, использующихся в различных технических областях. Алгоритм используется для больших <math>n</math>.

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

Первый этап алгоритма - использование метода Ланцоша для построения крыловского подпространства: <math> K_k(A,x) = span[x_1, Ax_1, A^2x_1, ..., A^{k-1}x_1] </math>. Входные данные алгоритма: квадратная симметричная матрица <math>A</math> размерности <math>n*n</math>, вектор начального приближения <math>b</math>, а так же число итераций <math>k</math>. Метод осуществляет поиск трехдиагональной симметричной матрицы <math>T_k=Q_k^TAQ_k</math>.

<math>T_k=\begin{bmatrix}
\alpha_1 & \beta_2 \\
\beta_2 & \alpha_2 & \beta_3 &\\
&. & . & .\\
&&\beta_{k-1} & \alpha_{k-1} & \beta_k\\
&&&\beta_k & \alpha_k
\end{bmatrix}</math>

Описание метода:

<math>
\begin{array}{l}
q_1 = b / \Vert b \Vert_2\\
j = \overline{1, k}:\\
\quad z_j = A q_j \\
\quad \alpha_j = q_j^T A q_j = q_j^T z_j \\
\quad z_j = z_j - \sum_{i=1}^j (z_j'^T q_i) q_i\\
\quad \beta_j = \Vert z_j \Vert_2\\
\quad q_{j+1} = z_j / \Vert z_j'' \Vert_2 = z_j/\beta_j
\end{array}
</math>

Следующий шаг алгоритма - процедура Рэлея-Ритца. Она зкалючается в интерпретации собственных значений матрицы <math> T_k=Q_k^TAQ_k</math>.
Ее собственные значения приближают собственные значения исходной матрицы. Пусть ''Tk=V<math>\Lambda</math>VT'' - спектральное разложение матрицы ''Tk'', тогда столбцы матрицы ''QkV'' рассматриваются как приближения к соответствующим собственным векторам матрицы ''A'' и называются векторами Ритца. Числа и векторы Ритца являются оптимальными приближениями к собственным значениям и собственным векторам матрицы ''A''.

Поиск собственных значений матрицы ''T'' намного легче, чем для исходной матрицы, так как предполагается, что <math>k << n</math>, и матрица ''T'' - трехдиагональная.

Полная переортогонализация необходима для того, чтобы гарантировать, что каждый полученный вектор ''qj+1'' ортогонален уже имеющимся векторам ''q1..j''. Без этого процесса будут накапливаться существенные вычислительный ошибки.

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

Вычислительным ядро алгоритма состоит ииз двух основных частей:
* <math>Aq=( \sum\nolimits_{i=^n}a_{1i}q_i, \sum\nolimits_{i=2}^na_{2i}q_i, ..., \sum\nolimits_{i=1}^na_{ni}q_i)</math> - умножение симметричной матрицы <math>A</math> размерности <math>n*n</math> на вектор ''q'' размерности ''n''.

* <math>z=z-\sum\nolimits_{i=1}^{k}(z^Tq_i)q_i.</math> - процесс ортогонализации Грама-Шмидта.

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

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

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

=== Последовательная сложность алгоритма ===
*1. умножение симметричной матрицы <math>A</math> размерности <math>n*n</math> на вектор ''q'' размерности ''n'' - вычислительная сложность: <math>n^2</math> умножений и <math>n^2-n</math> сложений
*2. процесс ортогонализации Грама-Шмидта - вычислительная сложность: <math>k^2n+k(n+2)</math> умножений и <math>k^2n + k(n + 1) + 2</math> сложений.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<references \>

#[[en:Cholesky decomposition]]

#[[Категория:Законченные статьи]]
#[[Категория:Разложения матриц]]

Учacтник:Malikovmt/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией

2017-02-01T16:42:03Z

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

{{algorithm
| name = Алгоритм Ланцоша с полной переортогонализацией
| serial_complexity = <math>O(n^2k)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>\frac{n(n + 1)}{2}</math>
| output_data = <math>k(n + 1)</math>
}}

Авторы: [[Участник:Eroshkin|А.В.Ерошкин]] ([[#Масштабируемость алгоритма и его реализации|ссылкаКод]]), [[Участник:Malikovmt|М.М.Маликов]] ([[#Описание алгоритма|ссылка]])

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

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

'''Алгоритм Ланцоша''' - итерационный метод, используемый для вычисления части собственных значений и соответствующих им собственных векторов матрицы <math>A</math> размера <math>n*n</math>, изначально разработанный Корнелием Ланцошем. Преимуществами использования метода является относительно небольшое потребление памяти и вычислительных ресурсов, а также наличие параметра <math>k</math>, <math>k << n</math>, контролирующего количество итераций. Несмотря на то, что алгоритм является вычислительно эффективным, первоначально сформулированный метод был плохо применим из-за численной неустойчивости - метод хорошо работал на целочисленных значениях, однако в арифметике с плавающей точкой ошибки округления давали большую погрешность. В 1970 году Ojalvo и Newman показали, как сделать метод численно стабильным и применили его для расчета крупных инженерных сооружений, подверженных динамическим нагрузкам. Кроме того, они показали способ выбора начального приближения (с использованием ГПСЧ), а также эмпирический способ для выбора числа <math>k</math> (примерно в полтора раза больше искомого числа собственных векторов). В данный момент существует две основных модификации метода (с полной и выборочной переортогонализацией), а также большое количество модификаций, использующихся в различных технических областях. Алгоритм используется для больших <math>n</math>.

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

Первый этап алгоритма - использование метода Ланцоша для построения крыловского подпространства: <math> K_k(A,x) = span[x_1, Ax_1, A^2x_1, ..., A^{k-1}x_1] </math>. Входные данные алгоритма: квадратная симметричная матрица <math>A</math> размерности <math>n*n</math>, вектор начального приближения <math>b</math>, а так же число итераций <math>k</math>. Метод осуществляет поиск трехдиагональной симметричной матрицы <math>T_k=Q_k^TAQ_k</math>.

<math>T_k=\begin{bmatrix}
\alpha_1 & \beta_2 \\
\beta_2 & \alpha_2 & \beta_3 &\\
&. & . & .\\
&&\beta_{k-1} & \alpha_{k-1} & \beta_k\\
&&&\beta_k & \alpha_k
\end{bmatrix}</math>

Описание метода:

<math>
\begin{array}{l}
q_1 = b / \Vert b \Vert_2\\
j = \overline{1, k}:\\
\quad z_j = A q_j \\
\quad \alpha_j = q_j^T A q_j = q_j^T z_j \\
\quad z_j = z_j - \sum_{i=1}^j (z_j'^T q_i) q_i\\
\quad \beta_j = \Vert z_j \Vert_2\\
\quad q_{j+1} = z_j / \Vert z_j'' \Vert_2 = z_j/\beta_j
\end{array}
</math>

Следующий шаг алгоритма - процедура Рэлея-Ритца. Она зкалючается в интерпретации собственных значений матрицы <math> T_k=Q_k^TAQ_k</math>.
Ее собственные значения приближают собственные значения исходной матрицы. Пусть ''Tk=V<math>\Lambda</math>VT'' - спектральное разложение матрицы ''Tk'', тогда столбцы матрицы ''QkV'' рассматриваются как приближения к соответствующим собственным векторам матрицы ''A'' и называются векторами Ритца. Числа и векторы Ритца являются оптимальными приближениями к собственным значениям и собственным векторам матрицы ''A''.

Поиск собственных значений матрицы ''T'' намного легче, чем для исходной матрицы, так как предполагается, что <math>k << n</math>, и матрица ''T'' - трехдиагональная.

Полная переортогонализация необходима для того, чтобы гарантировать, что каждый полученный вектор ''qj+1'' ортогонален уже имеющимся векторам ''q1..j''. Без этого процесса будут накапливаться существенные вычислительный ошибки.

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

Вычислительным ядро алгоритма состоит ииз двух основных частей:
* <math>Aq=( \sum\nolimits_{i=^n}a_{1i}q_i, \sum\nolimits_{i=2}^na_{2i}q_i, ..., \sum\nolimits_{i=1}^na_{ni}q_i)</math> - умножение симметричной матрицы <math>A</math> размерности <math>n*n</math> на вектор ''q'' размерности ''n''.

* <math>z=z-\sum\nolimits_{i=1}^{k}(z^Tq_i)q_i.</math> - процесс ортогонализации Грама-Шмидта.

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

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

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

=== Последовательная сложность алгоритма ===
*1. умножение симметричной матрицы <math>A</math> размерности <math>n*n</math> на вектор ''q'' размерности ''n'' - вычислительная сложность: <math>n^2</math> умножений и <math>n^2-n</math> сложений
*2. процесс ортогонализации Грама-Шмидта - вычислительная сложность: <math>k^2n+k(n+2)</math> умножений и <math>k^2n + k(n + 1) + 2</math> сложений.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<references \>

#[[en:Cholesky decomposition]]

#[[Категория:Законченные статьи]]
#[[Категория:Разложения матриц]]

Учacтник:Malikovmt/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией

2017-02-01T16:41:33Z

Malikovmt:

{{algorithm
| name = Алгоритм Ланцоша с полной переортогонализацией
| serial_complexity = <math>O(n^2k)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>\frac{n(n + 1)}{2}</math>
| output_data = <math>k(n + 1)</math>
}}

Авторы: [[Участник:Eroshkin|А.В.Ерошкин]] ([[#Масштабируемость алгоритма и его реализации|ссылкаКод]]), [[Участник:Malikovmt|М.М.Маликов]] ([[#Описание алгоритма|ссылка]])

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

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

'''Алгоритм Ланцоша''' - итерационный метод, используемый для вычисления части собственных значений и соответствующих им собственных векторов матрицы <math>A</math> размера <math>n*n</math>, изначально разработанный Корнелием Ланцошем. Преимуществами использования метода является относительно небольшое потребление памяти и вычислительных ресурсов, а также наличие параметра <math>k</math>, <math>k << n</math>, контролирующего количество итераций. Несмотря на то, что алгоритм является вычислительно эффективным, первоначально сформулированный метод был плохо применим из-за численной неустойчивости - метод хорошо работал на целочисленных значениях, однако в арифметике с плавающей точкой ошибки округления давали большую погрешность. В 1970 году Ojalvo и Newman показали, как сделать метод численно стабильным и применили его для расчета крупных инженерных сооружений, подверженных динамическим нагрузкам. Кроме того, они показали способ выбора начального приближения (с использованием ГПСЧ), а также эмпирический способ для выбора числа <math>k</math> (примерно в полтора раза больше искомого числа собственных векторов). В данный момент существует две основных модификации метода (с полной и выборочной переортогонализацией), а также большое количество модификаций, использующихся в различных технических областях. Алгоритм используется для больших <math>n</math>.

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

Первый этап алгоритма - использование метода Ланцоша для построения крыловского подпространства: <math> K_k(A,x) = span[x_1, Ax_1, A^2x_1, ..., A^{k-1}x_1] </math>. Входные данные алгоритма: квадратная симметричная матрица <math>A</math> размерности <math>n*n</math>, вектор начального приближения <math>b</math>, а так же число итераций <math>k</math>. Метод осуществляет поиск трехдиагональной симметричной матрицы <math>T_k=Q_k^TAQ_k</math>.

<math>T_k=\begin{bmatrix}
\alpha_1 & \beta_2 \\
\beta_2 & \alpha_2 & \beta_3 &\\
&. & . & .\\
&&\beta_{k-1} & \alpha_{k-1} & \beta_k\\
&&&\beta_k & \alpha_k
\end{bmatrix}</math>

Описание метода:

<math>
\begin{array}{l}
q_1 = b / \Vert b \Vert_2\\
j = \overline{1, k}:\\
\quad z_j = A q_j \\
\quad \alpha_j = q_j^T A q_j = q_j^T z_j \\
\quad z_j = z_j - \sum_{i=1}^j (z_j'^T q_i) q_i\\
\quad \beta_j = \Vert z_j \Vert_2\\
\quad q_{j+1} = z_j / \Vert z_j'' \Vert_2 = z_j/\beta_j
\end{array}
</math>

Следующий шаг алгоритма - процедура Рэлея-Ритца. Она зкалючается в интерпретации собственных значений матрицы <math> T_k=Q_k^TAQ_k</math>.
Ее собственные значения приближают собственные значения исходной матрицы. Пусть ''Tk=V<math>\Lambda</math>VT'' - спектральное разложение матрицы ''Tk'', тогда столбцы матрицы ''QkV'' рассматриваются как приближения к соответствующим собственным векторам матрицы ''A'' и называются векторами Ритца. Числа и векторы Ритца являются оптимальными приближениями к собственным значениям и собственным векторам матрицы ''A''.

Поиск собственных значений матрицы ''T'' намного легче, чем для исходной матрицы, так как предполагается, что <math>k << n</math>, и матрица ''T'' - трехдиагональная.

Полная переортогонализация необходима для того, чтобы гарантировать, что каждый полученный вектор ''qj+1'' ортогонален уже имеющимся векторам ''q1..j''. Без этого процесса будут накапливаться существенные вычислительный ошибки.

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

Вычислительным ядро алгоритма состоит ииз двух основных частей:
*1. <math>Aq=( \sum\nolimits_{i=^n}a_{1i}q_i, \sum\nolimits_{i=2}^na_{2i}q_i, ..., \sum\nolimits_{i=1}^na_{ni}q_i)</math> - умножение симметричной матрицы <math>A</math> размерности <math>n*n</math> на вектор ''q'' размерности ''n''.

*2. <math>z=z-\sum\nolimits_{i=1}^{k}(z^Tq_i)q_i.</math> - процесс ортогонализации Грама-Шмидта.

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

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

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

=== Последовательная сложность алгоритма ===
*1. умножение симметричной матрицы <math>A</math> размерности <math>n*n</math> на вектор ''q'' размерности ''n'' - вычислительная сложность: <math>n^2</math> умножений и <math>n^2-n</math> сложений
*2. процесс ортогонализации Грама-Шмидта - вычислительная сложность: <math>k^2n+k(n+2)</math> умножений и <math>k^2n + k(n + 1) + 2</math> сложений.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<references \>

#[[en:Cholesky decomposition]]

#[[Категория:Законченные статьи]]
#[[Категория:Разложения матриц]]

Учacтник:Malikovmt/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией

2017-02-01T16:32:08Z

Malikovmt: /* Макроструктура алгоритма */

{{algorithm
| name = Алгоритм Ланцоша с полной переортогонализацией
| serial_complexity = <math>O(n^2k)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>\frac{n(n + 1)}{2}</math>
| output_data = <math>k(n + 1)</math>
}}

Авторы: [[Участник:Eroshkin|А.В.Ерошкин]] ([[#Масштабируемость алгоритма и его реализации|ссылкаКод]]), [[Участник:Malikovmt|М.М.Маликов]] ([[#Описание алгоритма|ссылка]])

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

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

'''Алгоритм Ланцоша''' - итерационный метод, используемый для вычисления части собственных значений и соответствующих им собственных векторов матрицы <math>A</math> размера <math>n*n</math>, изначально разработанный Корнелием Ланцошем. Преимуществами использования метода является относительно небольшое потребление памяти и вычислительных ресурсов, а также наличие параметра <math>k</math>, <math>k << n</math>, контролирующего количество итераций. Несмотря на то, что алгоритм является вычислительно эффективным, первоначально сформулированный метод был плохо применим из-за численной неустойчивости - метод хорошо работал на целочисленных значениях, однако в арифметике с плавающей точкой ошибки округления давали большую погрешность. В 1970 году Ojalvo и Newman показали, как сделать метод численно стабильным и применили его для расчета крупных инженерных сооружений, подверженных динамическим нагрузкам. Кроме того, они показали способ выбора начального приближения (с использованием ГПСЧ), а также эмпирический способ для выбора числа <math>k</math> (примерно в полтора раза больше искомого числа собственных векторов). В данный момент существует две основных модификации метода (с полной и выборочной переортогонализацией), а также большое количество модификаций, использующихся в различных технических областях. Алгоритм используется для больших <math>n</math>.

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

Первый этап алгоритма - использование метода Ланцоша для построения крыловского подпространства: <math> K_k(A,x) = span[x_1, Ax_1, A^2x_1, ..., A^{k-1}x_1] </math>. Входные данные алгоритма: квадратная симметричная матрица <math>A</math> размерности <math>n*n</math>, вектор начального приближения <math>b</math>, а так же число итераций <math>k</math>. Метод осуществляет поиск трехдиагональной симметричной матрицы <math>T_k=Q_k^TAQ_k</math>.

<math>T_k=\begin{bmatrix}
\alpha_1 & \beta_2 \\
\beta_2 & \alpha_2 & \beta_3 &\\
&. & . & .\\
&&\beta_{k-1} & \alpha_{k-1} & \beta_k\\
&&&\beta_k & \alpha_k
\end{bmatrix}</math>

Описание метода:

<math>
\begin{array}{l}
q_1 = b / \Vert b \Vert_2\\
j = \overline{1, k}:\\
\quad z_j = A q_j \\
\quad \alpha_j = q_j^T A q_j = q_j^T z_j \\
\quad z_j = z_j - \sum_{i=1}^j (z_j'^T q_i) q_i\\
\quad \beta_j = \Vert z_j \Vert_2\\
\quad q_{j+1} = z_j / \Vert z_j'' \Vert_2 = z_j/\beta_j
\end{array}
</math>

Следующий шаг алгоритма - процедура Рэлея-Ритца. Она зкалючается в интерпретации собственных значений матрицы <math> T_k=Q_k^TAQ_k</math>.
Ее собственные значения приближают собственные значения исходной матрицы. Пусть ''Tk=V<math>\Lambda</math>VT'' - спектральное разложение матрицы ''Tk'', тогда столбцы матрицы ''QkV'' рассматриваются как приближения к соответствующим собственным векторам матрицы ''A'' и называются векторами Ритца. Числа и векторы Ритца являются оптимальными приближениями к собственным значениям и собственным векторам матрицы ''A''.

Поиск собственных значений матрицы ''T'' намного легче, чем для исходной матрицы, так как предполагается, что <math>k << n</math>, и матрица ''T'' - трехдиагональная.

Полная переортогонализация необходима для того, чтобы гарантировать, что каждый полученный вектор ''qj+1'' ортогонален уже имеющимся векторам ''q1..j''. Без этого процесса будут накапливаться существенные вычислительный ошибки.

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

Вычислительным ядро алгоритма состоит ииз двух основных частей:
*1. <math>Aq=( \sum\nolimits_{i=^n}a_{1i}q_i, \sum\nolimits_{i=2}^na_{2i}q_i, ..., \sum\nolimits_{i=1}^na_{ni}q_i)</math> - умножение симметричной матрицы <math>A</math> размерности <math>n*n</math> на вектор ''q'' размерности ''n'' - вычислительная сложность: <math>n^2</math> умножений и <math>n^2-n</math> сложений

*2. <math>z=z-\sum\nolimits_{i=1}^{k}(z^Tq_i)q_i.</math> - процесс ортогонализации Грама-Шмидта - вычислительная сложность: <math>k^2n+k(n+2)</math> умножений и <math>k^2n + k(n + 1) + 2</math> сложений.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<references \>

#[[en:Cholesky decomposition]]

#[[Категория:Законченные статьи]]
#[[Категория:Разложения матриц]]

Учacтник:Malikovmt/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией

2017-02-01T16:23:25Z

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

{{algorithm
| name = Алгоритм Ланцоша с полной переортогонализацией
| serial_complexity = <math>O(n^2k)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>\frac{n(n + 1)}{2}</math>
| output_data = <math>k(n + 1)</math>
}}

Авторы: [[Участник:Eroshkin|А.В.Ерошкин]] ([[#Масштабируемость алгоритма и его реализации|ссылкаКод]]), [[Участник:Malikovmt|М.М.Маликов]] ([[#Описание алгоритма|ссылка]])

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

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

'''Алгоритм Ланцоша''' - итерационный метод, используемый для вычисления части собственных значений и соответствующих им собственных векторов матрицы <math>A</math> размера <math>n*n</math>, изначально разработанный Корнелием Ланцошем. Преимуществами использования метода является относительно небольшое потребление памяти и вычислительных ресурсов, а также наличие параметра <math>k</math>, <math>k << n</math>, контролирующего количество итераций. Несмотря на то, что алгоритм является вычислительно эффективным, первоначально сформулированный метод был плохо применим из-за численной неустойчивости - метод хорошо работал на целочисленных значениях, однако в арифметике с плавающей точкой ошибки округления давали большую погрешность. В 1970 году Ojalvo и Newman показали, как сделать метод численно стабильным и применили его для расчета крупных инженерных сооружений, подверженных динамическим нагрузкам. Кроме того, они показали способ выбора начального приближения (с использованием ГПСЧ), а также эмпирический способ для выбора числа <math>k</math> (примерно в полтора раза больше искомого числа собственных векторов). В данный момент существует две основных модификации метода (с полной и выборочной переортогонализацией), а также большое количество модификаций, использующихся в различных технических областях. Алгоритм используется для больших <math>n</math>.

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

Первый этап алгоритма - использование метода Ланцоша для построения крыловского подпространства: <math> K_k(A,x) = span[x_1, Ax_1, A^2x_1, ..., A^{k-1}x_1] </math>. Входные данные алгоритма: квадратная симметричная матрица <math>A</math> размерности <math>n*n</math>, вектор начального приближения <math>b</math>, а так же число итераций <math>k</math>. Метод осуществляет поиск трехдиагональной симметричной матрицы <math>T_k=Q_k^TAQ_k</math>.

<math>T_k=\begin{bmatrix}
\alpha_1 & \beta_2 \\
\beta_2 & \alpha_2 & \beta_3 &\\
&. & . & .\\
&&\beta_{k-1} & \alpha_{k-1} & \beta_k\\
&&&\beta_k & \alpha_k
\end{bmatrix}</math>

Описание метода:

<math>
\begin{array}{l}
q_1 = b / \Vert b \Vert_2\\
j = \overline{1, k}:\\
\quad z_j = A q_j \\
\quad \alpha_j = q_j^T A q_j = q_j^T z_j \\
\quad z_j = z_j - \sum_{i=1}^j (z_j'^T q_i) q_i\\
\quad \beta_j = \Vert z_j \Vert_2\\
\quad q_{j+1} = z_j / \Vert z_j'' \Vert_2 = z_j/\beta_j
\end{array}
</math>

Следующий шаг алгоритма - процедура Рэлея-Ритца. Она зкалючается в интерпретации собственных значений матрицы <math> T_k=Q_k^TAQ_k</math>.
Ее собственные значения приближают собственные значения исходной матрицы. Пусть ''Tk=V<math>\Lambda</math>VT'' - спектральное разложение матрицы ''Tk'', тогда столбцы матрицы ''QkV'' рассматриваются как приближения к соответствующим собственным векторам матрицы ''A'' и называются векторами Ритца. Числа и векторы Ритца являются оптимальными приближениями к собственным значениям и собственным векторам матрицы ''A''.

Поиск собственных значений матрицы ''T'' намного легче, чем для исходной матрицы, так как предполагается, что <math>k << n</math>, и матрица ''T'' - трехдиагональная.

Полная переортогонализация необходима для того, чтобы гарантировать, что каждый полученный вектор ''qj+1'' ортогонален уже имеющимся векторам ''q1..j''. Без этого процесса будут накапливаться существенные вычислительный ошибки.

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

Вычислительным ядро алгоритма состоит ииз двух основных частей:
*1. <math>Aq=( \sum\nolimits_{i=^n}a_{1i}q_i, \sum\nolimits_{i=2}^na_{2i}q_i, ..., \sum\nolimits_{i=1}^na_{ni}q_i)</math> - умножение симметричной матрицы <math>A</math> размерности <math>n*n</math> на вектор ''q'' размерности ''n'' - вычислительная сложность: <math>n^2</math> умножений и <math>n^2-n</math> сложений

*2. <math>z=z-\sum\nolimits_{i=1}^{k}(z^Tq_i)q_i.</math> - процесс ортогонализации Грама-Шмидта - вычислительная сложность: <math>k^2n+k(n+2)</math> умножений и <math>k^2n + k(n + 1) + 2</math> сложений.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<references \>

#[[en:Cholesky decomposition]]

#[[Категория:Законченные статьи]]
#[[Категория:Разложения матриц]]

Учacтник:Malikovmt/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией

2017-02-01T16:13:18Z

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

Учacтник:Malikovmt/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией

2017-02-01T16:02:04Z

Malikovmt: /* Математическое описание алгоритма */

{{algorithm
| name = Алгоритм Ланцоша с полной переортогонализацией
| serial_complexity = <math>O(n^2k)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>\frac{n(n + 1)}{2}</math>
| output_data = <math>k(n + 1)</math>
}}

Авторы: [[Участник:Eroshkin|А.В.Ерошкин]] ([[#Масштабируемость алгоритма и его реализации|ссылкаКод]]), [[Участник:Malikovmt|М.М.Маликов]] ([[#Описание алгоритма|ссылка]])

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

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

'''Алгоритм Ланцоша''' - итерационный метод, используемый для вычисления части собственных значений и соответствующих им собственных векторов матрицы <math>A</math> размера <math>n*n</math>, изначально разработанный Корнелием Ланцошем. Преимуществами использования метода является относительно небольшое потребление памяти и вычислительных ресурсов, а также наличие параметра <math>k</math>, <math>k << n</math>, контролирующего количество итераций. Несмотря на то, что алгоритм является вычислительно эффективным, первоначально сформулированный метод был плохо применим из-за численной неустойчивости - метод хорошо работал на целочисленных значениях, однако в арифметике с плавающей точкой ошибки округления давали большую погрешность. В 1970 году Ojalvo и Newman показали, как сделать метод численно стабильным и применили его для расчета крупных инженерных сооружений, подверженных динамическим нагрузкам. Кроме того, они показали способ выбора начального приближения (с использованием ГПСЧ), а также эмпирический способ для выбора числа <math>k</math> (примерно в полтора раза больше искомого числа собственных векторов). В данный момент существует две основных модификации метода (с полной и выборочной переортогонализацией), а также большое количество модификаций, использующихся в различных технических областях. Алгоритм используется для больших <math>n</math>.

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

Первый этап алгоритма - использование метода Ланцоша для построения крыловского подпространства: <math> K_k(A,x) = span[x_1, Ax_1, A^2x_1, ..., A^{k-1}x_1] </math>. Входные данные алгоритма: квадратная симметричная матрица <math>A</math> размерности <math>n*n</math>, вектор начального приближения <math>b</math>, а так же число итераций <math>k</math>. Метод осуществляет поиск трехдиагональной симметричной матрицы <math>T_k=Q_k^TAQ_k</math>.

<math>T_k=\begin{bmatrix}
\alpha_1 & \beta_2 \\
\beta_2 & \alpha_2 & \beta_3 &\\
&. & . & .\\
&&\beta_{k-1} & \alpha_{k-1} & \beta_k\\
&&&\beta_k & \alpha_k
\end{bmatrix}</math>

Описание метода:

<math>
\begin{array}{l}
q_1 = b / \Vert b \Vert_2\\
j = \overline{1, k}:\\
\quad z_j = A q_j \\
\quad \alpha_j = q_j^T A q_j = q_j^T z_j \\
\quad z_j = z_j - \sum_{i=1}^j (z_j'^T q_i) q_i\\
\quad \beta_j = \Vert z_j \Vert_2\\
\quad q_{j+1} = z_j / \Vert z_j'' \Vert_2 = z_j/\beta_j
\end{array}
</math>

Следующий шаг алгоритма - процедура Рэлея-Ритца. Она зкалючается в интерпретации собственных значений матрицы <math> T_k=Q_k^TAQ_k</math>.
Ее собственные значения приближают собственные значения исходной матрицы. Пусть ''Tk=V<math>\Lambda</math>VT'' - спектральное разложение матрицы ''Tk'', тогда столбцы матрицы ''QkV'' рассматриваются как приближения к соответствующим собственным векторам матрицы ''A'' и называются векторами Ритца. Числа и векторы Ритца являются оптимальными приближениями к собственным значениям и собственным векторам матрицы ''A''.

Поиск собственных значений матрицы ''T'' намного легче, чем для исходной матрицы, так как предполагается, что <math>k << n</math>, и матрица ''T'' - трехдиагональная.

Полная переортогонализация необходима для того, чтобы гарантировать, что каждый полученный вектор ''qj+1'' ортогонален уже имеющимся векторам ''q1..j''. Без этого процесса будут накапливаться существенные вычислительный ошибки.

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

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

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

<math>
\begin{align}
q_1 = & \frac{b}{\|b\|_2},\;\beta_0=0,\;q_0=0\\
for \; & j = 1 \; to \; k \\
& z = Aq_j\\
& \alpha_j = q^T_j z\\
& z=z-\alpha_jq_j-\beta_{j-1}q_{j-1}\\
& z = z - \sum^{j-1}_{i=1}\left(z^Tq_i\right)q_i,\;z = z - \sum^{j-1}_{i=1}\left(z^Tq_i\right)q_i \\
& \beta_j = \|z\|_2\\
& if \; \beta_j =0\; break\\
& q_{j+1} = \frac{z}{\beta_j}\\
end \; & for
\end{align}
</math>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<references \>

#[[en:Cholesky decomposition]]

#[[Категория:Законченные статьи]]
#[[Категория:Разложения матриц]]

Учacтник:Malikovmt/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией

2017-02-01T16:01:46Z

Malikovmt: /* Математическое описание алгоритма */

{{algorithm
| name = Алгоритм Ланцоша с полной переортогонализацией
| serial_complexity = <math>O(n^2k)</math>
| pf_height = <math>O(k)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>\frac{n(n + 1)}{2}</math>
| output_data = <math>k(n + 1)</math>
}}

Авторы: [[Участник:Eroshkin|А.В.Ерошкин]] ([[#Масштабируемость алгоритма и его реализации|ссылкаКод]]), [[Участник:Malikovmt|М.М.Маликов]] ([[#Описание алгоритма|ссылка]])

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

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

'''Алгоритм Ланцоша''' - итерационный метод, используемый для вычисления части собственных значений и соответствующих им собственных векторов матрицы <math>A</math> размера <math>n*n</math>, изначально разработанный Корнелием Ланцошем. Преимуществами использования метода является относительно небольшое потребление памяти и вычислительных ресурсов, а также наличие параметра <math>k</math>, <math>k << n</math>, контролирующего количество итераций. Несмотря на то, что алгоритм является вычислительно эффективным, первоначально сформулированный метод был плохо применим из-за численной неустойчивости - метод хорошо работал на целочисленных значениях, однако в арифметике с плавающей точкой ошибки округления давали большую погрешность. В 1970 году Ojalvo и Newman показали, как сделать метод численно стабильным и применили его для расчета крупных инженерных сооружений, подверженных динамическим нагрузкам. Кроме того, они показали способ выбора начального приближения (с использованием ГПСЧ), а также эмпирический способ для выбора числа <math>k</math> (примерно в полтора раза больше искомого числа собственных векторов). В данный момент существует две основных модификации метода (с полной и выборочной переортогонализацией), а также большое количество модификаций, использующихся в различных технических областях. Алгоритм используется для больших <math>n</math>.

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

Первый этап алгоритма - использование метода Ланцоша для построения крыловского подпространства: <math> K_k(A,x) = span[x_1, Ax_1, A^2x_1, ..., A^{k-1}x_1] </math>. Входные данные алгоритма: квадратная симметричная матрица <math>A</math> размерности <math>n*n</math>, вектор начального приближения <math>b</math>, а так же число итераций <math>k</math>. Метод осуществляет поиск трехдиагональной симметричной матрицы <math>T_k=Q_k^TAQ_k</math>.

<math>T_k=\begin{bmatrix}
\alpha_1 & \beta_2 \\
\beta_2 & \alpha_2 & \beta_3 &\\
&. & . & .\\
&&\beta_{k-1} & \alpha_{k-1} & \beta_k\\
&&&\beta_k & \alpha_k
\end{bmatrix}</math>

Описание метода:
<math>
\begin{array}{l}
q_1 = b / \Vert b \Vert_2\\
j = \overline{1, k}:\\
\quad z_j = A q_j \\
\quad \alpha_j = q_j^T A q_j = q_j^T z_j \\
\quad z_j = z_j - \sum_{i=1}^j (z_j'^T q_i) q_i\\
\quad \beta_j = \Vert z_j \Vert_2\\
\quad q_{j+1} = z_j / \Vert z_j'' \Vert_2 = z_j/\beta_j
\end{array}
</math>

Следующий шаг алгоритма - процедура Рэлея-Ритца. Она зкалючается в интерпретации собственных значений матрицы <math> T_k=Q_k^TAQ_k</math>.
Ее собственные значения приближают собственные значения исходной матрицы. Пусть ''Tk=V<math>\Lambda</math>VT'' - спектральное разложение матрицы ''Tk'', тогда столбцы матрицы ''QkV'' рассматриваются как приближения к соответствующим собственным векторам матрицы ''A'' и называются векторами Ритца. Числа и векторы Ритца являются оптимальными приближениями к собственным значениям и собственным векторам матрицы ''A''.

Поиск собственных значений матрицы ''T'' намного легче, чем для исходной матрицы, так как предполагается, что <math>k << n</math>, и матрица ''T'' - трехдиагональная.

Полная переортогонализация необходима для того, чтобы гарантировать, что каждый полученный вектор ''qj+1'' ортогонален уже имеющимся векторам ''q1..j''. Без этого процесса будут накапливаться существенные вычислительный ошибки.

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

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

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

<math>
\begin{align}
q_1 = & \frac{b}{\|b\|_2},\;\beta_0=0,\;q_0=0\\
for \; & j = 1 \; to \; k \\
& z = Aq_j\\
& \alpha_j = q^T_j z\\
& z=z-\alpha_jq_j-\beta_{j-1}q_{j-1}\\
& z = z - \sum^{j-1}_{i=1}\left(z^Tq_i\right)q_i,\;z = z - \sum^{j-1}_{i=1}\left(z^Tq_i\right)q_i \\
& \beta_j = \|z\|_2\\
& if \; \beta_j =0\; break\\
& q_{j+1} = \frac{z}{\beta_j}\\
end \; & for
\end{align}
</math>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<references \>

#[[en:Cholesky decomposition]]

#[[Категория:Законченные статьи]]
#[[Категория:Разложения матриц]]

Учacтник:Malikovmt/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией

2017-02-01T15:57:17Z

Malikovmt: /* Математическое описание алгоритма */

Учacтник:Malikovmt/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией

2017-02-01T15:55:28Z

Malikovmt:

Учacтник:Malikovmt/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией

2017-02-01T14:00:23Z

Malikovmt:

Учacтник:Malikovmt/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией

2017-02-01T13:54:09Z

Malikovmt:

{{algorithm
| name = Алгоритм Ланцоша с полной переортогонализацией
| serial_complexity = <math>O(n^2k + nk^2)</math>
| pf_height = <math>O(nk + k^2)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>n^2 + n</math>
| output_data = <math>2k - 1 + nk</math>
}}

Авторы: [[Участник:Eroshkin|А.В.Ерошкин]] ([[#Масштабируемость алгоритма и его реализации|ссылкаКод]]), [[Участник:Malikovmt|М.М.Маликов]] ([[#Описание алгоритма|ссылка]])

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

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

'''Алгоритм Ланцоша''' - итерационный метод, используемый для вычисления части собственных значений и соответствующих им собственных векторов матрицы <math>A</math> размера <math>n*n</math>, изначально разработанный Корнелием Ланцошем. Преимуществами использования метода является относительно небольшое потребление памяти и вычислительных ресурсов, а также наличие параметра <math>k</math>, контролирующего количество итераций. Несмотря на то, что алгоритм является вычислительно эффективным, первоначально сформулированный метод был плохо применим из-за численной неустойчивости - метод хорошо работал на целочисленных значениях, однако в арифметике с плавающей точкой ошибки округления давали большую погрешность. В 1970 году Ojalvo и Newman показали, как сделать метод численно стабильным и применили его для расчета крупных инженерных сооружений, подверженных динамическим нагрузкам. Кроме того, они показали способ выбора начального приближения (с использованием ГПСЧ), а также эмпирический способ для выбора числа <math>k</math> (примерно в полтора раза больше искомого числа собственных векторов). В данный момент существует две основных модификации метода (с полной и выборочной переортогонализацией), а также большое количество модификаций, использующихся в различных технических областях.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<references \>

#[[en:Cholesky decomposition]]

#[[Категория:Законченные статьи]]
#[[Категория:Разложения матриц]]

Учacтник:Malikovmt/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией

2017-02-01T13:32:13Z

Malikovmt: /* Общее описание алгоритма */

{{algorithm
| name = Алгоритм Ланцоша с полной переортогонализацией
| serial_complexity = <math>O(n^2k + nk^2)</math>
| pf_height = <math>O(nk + k^2)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>n^2 + n</math>
| output_data = <math>2k - 1 + nk</math>
}}

Авторы: [[Участник:Eroshkin|А.В.Ерошкин]] ([[#Масштабируемость алгоритма и его реализации|ссылкаКод]]), [[Участник:Malikovmt|М.М.Маликов]] ([[#Описание алгоритма|ссылка]])

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

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

'''Алгоритм Ланцоша''' - итерационный метод, используемый для вычисления части собственных значений и соответствующих им собственных векторов матрицы <math>A</math> размера <math>n*n</math>, изначально разработанный Корнелием Ланцошем. Преимуществами использования метода является относительно небольшое потребление памяти и вычислительных ресурсов, а также наличие параметра <math>m</math>, контролирующего количество итераций. Несмотря на то, что алгоритм является вычислительно эффективным, первоначально сформулированный метод был плохо применим из-за численной неустойчивости - метод хорошо работал на целочисленных значениях, однако в арифметике с плавающей точкой ошибки округления давали большую погрешность. В 1970 году Ojalvo и Newman показали, как сделать метод численно стабильным и применили его для расчета крупных инженерных сооружений, подверженных динамическим нагрузкам. Кроме того, они показали способ выбора начального приближения (с использованием ГПСЧ), а также эмпирический способ для выбора числа <math>m</math> (примерно в полтора раза больше искомого числа собственных векторов). В данный момент существует две основных модификации метода (с полной и выборочной переортогонализацией), а также большое количество модификаций, использующихся в различных технических областях.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<references \>

#[[en:Cholesky decomposition]]

#[[Категория:Законченные статьи]]
#[[Категория:Разложения матриц]]

Учacтник:Malikovmt/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией

2017-02-01T13:30:08Z

Malikovmt: /* Общее описание алгоритма */

{{algorithm
| name = Алгоритм Ланцоша с полной переортогонализацией
| serial_complexity = <math>O(n^2k + nk^2)</math>
| pf_height = <math>O(nk + k^2)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>n^2 + n</math>
| output_data = <math>2k - 1 + nk</math>
}}

Авторы: [[Участник:Eroshkin|А.В.Ерошкин]] ([[#Масштабируемость алгоритма и его реализации|ссылкаКод]]), [[Участник:Malikovmt|М.М.Маликов]] ([[#Описание алгоритма|ссылка]])

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

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

'''Алгоритм Ланцоша''' - итерационный метод, используемый для вычисления части собственных значений и соответствующих им собственных векторов матрицы <math>A</math> размера <math>n*n</math>, изначально разработанный Корнелием Ланцошем. Преимуществами использования метода является относительно небольшое потребление памяти и вычислительных ресурсов, а также наличие параметра <math>m</math>, контролирующего количество итераций. Несмотря на то, что алгоритм является вычислительно эффективным, первоначально сформулированный метод был плохо применим из-за численной неустойчивости - метод хорошо работал на целочисленных значениях, однако в арифметике с плавающей точкой ошибки округления давали большую погрешность. В 1970 году Ojalvo и Newman показали, как сделать метод численно стабильным и применили его для расчета крупных инженерных сооружений, подверженных динамическим нагрузкам. Кроме того, они показали способ выбора начального приближения (с использованием ГПСЧ), а также эмпирический способ для нахождения числа <math>m</math> (примерно в полтора раза больше искомого числа собственных векторов). В данный момент существует две основных модификации метода (с полной и выборочной переортогонализацией), а также большое количество модификаций, использующихся в различных технических областях.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<references \>

#[[en:Cholesky decomposition]]

#[[Категория:Законченные статьи]]
#[[Категория:Разложения матриц]]

Учacтник:Malikovmt/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией

2017-01-30T00:00:18Z

Malikovmt: /* Общее описание алгоритма */

{{algorithm
| name = Алгоритм Ланцоша с полной переортогонализацией
| serial_complexity = <math>O(n^2k + nk^2)</math>
| pf_height = <math>O(nk + k^2)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>n^2 + n</math>
| output_data = <math>2k - 1 + nk</math>
}}

Авторы: [[Участник:Eroshkin|А.В.Ерошкин]] ([[#Масштабируемость алгоритма и его реализации|ссылкаКод]]), [[Участник:Malikovmt|М.М.Маликов]] ([[#Описание алгоритма|ссылка]])

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

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

'''Алгоритм Ланцоша''' - итерационный метод, разработанный Корнелиусом Ланцошем, является адаптацией '''power methods''' для вычисления наиболее полезных собственных значений и собственных векторов n^{{th}} '''order linear system''' за ограниченное количество операций '''m''', где '''m''' много меньше '''n'''. Не смотря на то, что алгоритм является вычислительно эффективным, первоначально сформулированный метод не был полезным из-за его численной неустойчивости. В 1970 году '''Ojalvo''' и Ньюман показали как сделать метод численно стабильным и применили его для решения задачи очень крупных инженерных сооружений

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

==== Режим накопления ====

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<references \>

#[[en:Cholesky decomposition]]

#[[Категория:Законченные статьи]]
#[[Категория:Разложения матриц]]

Учacтник:Malikovmt/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией

2017-01-29T20:23:53Z

Malikovmt:

Учacтник:Malikovmt/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией

2017-01-29T20:23:22Z

Malikovmt: Новая страница: «{{algorithm | name = Алгоритм Ланцоша с полной переортогонализацией | serial_complexity = <math>O(n^2k + nk…»