https://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/api.php?action=feedcontributions&feedformat=atom&user=ChernyavskiyАлговики - Вклад [ru]2026-10-22T15:11:57ZВкладMediaWiki 1.43.5https://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%9A%D0%BB%D0%B0%D1%81%D1%81%D0%B8%D1%84%D0%B8%D0%BA%D0%B0%D1%86%D0%B8%D1%8F_%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC%D0%BE%D0%B2&diff=23958Классификация алгоритмов2017-11-15T12:10:16Z<p>Chernyavskiy: </p>
<hr />
<div># <div id="Векторные операции">'''Векторные операции'''</div><br />
## {{level|Суммирование сдваиванием}}<br />
### {{level|Нахождение суммы элементов массива сдваиванием}}<br />
### {{level|Нахождение частных сумм элементов массива сдваиванием}}<br />
## {{level|Равномерная норма вектора, вещественная версия, последовательно-параллельный вариант}}<br />
## {{level|Скалярное произведение векторов, вещественная версия, последовательно-параллельный вариант}}<br />
## {{level|Последовательно-параллельный метод суммирования}}<br />
# <div id="Матрично-векторные операции">'''Матрично-векторные операции'''</div><br />
## {{level|Умножение плотной матрицы на вектор}}<br />
### {{level|Умножение плотной неособенной матрицы на вектор (последовательный вещественный вариант)}}<br />
# <div id="Матричные операции">'''Матричные операции'''</div><br />
## {{level|Умножение плотных матриц}}<br />
### {{level|Перемножение плотных неособенных матриц (последовательный вещественный вариант)}}<br />
### {{level|Метод Штрассена}}<br />
# {{level|Разложения матриц}}<br />
## {{level|Треугольные разложения}}<br />
### {{level|Метод Гаусса (нахождение LU-разложения)}}<br />
#### {{level|LU-разложение методом Гаусса без перестановок}}<br />
##### {{level|LU-разложение методом Гаусса}}<br />
##### {{level|Компактная схема метода Гаусса и её модификации}}<br />
###### {{level|Компактная схема метода Гаусса для плотной матрицы}}<br />
###### {{level|Компактная схема метода Гаусса для трёхдиагональной матрицы и её модификации}}<br />
####### {{level|Компактная схема метода Гаусса для трёхдиагональной матрицы, последовательный вариант}}<br />
####### {{level|Алгоритм сдваивания Стоуна для LU-разложения трёхдиагональной матрицы}}<br />
####### {{level|Последовательно-параллельный алгоритм для LU-разложения трёхдиагональной матрицы}}<br />
#### {{level|LU-разложение методом Гаусса с перестановками}}<br />
##### {{level|LU-разложение методом Гаусса с выбором ведущего элемента по столбцу}}<br />
##### {{level|LU-разложение методом Гаусса с выбором ведущего элемента по строке}}<br />
##### {{level|LU-разложение методом Гаусса с выбором ведущего элемента по главной диагонали}}<br />
##### {{level|LU-разложение методом Гаусса с выбором ведущего элемента по всей матрице}}<br />
### {{level|Метод Холецкого (нахождение симметричного треугольного разложения)}}<br />
#### {{level|Разложение Холецкого (метод квадратного корня)}} базовый точечный вещественный вариант для плотной симметричной положительно-определённой матрицы<br />
### {{level|Известные треугольные разложения для матриц специального вида}}<br />
## {{level|Унитарно-треугольные разложения}}<br />
### {{level|QR-разложения плотных неособенных матриц}}<br />
#### {{level|Метод Гивенса (вращений) QR-разложения матрицы}}<br />
##### {{level|Метод Гивенса (вращений) QR-разложения квадратной матрицы (вещественный точечный вариант)}}<br />
#### {{level|Метод Хаусхолдера (отражений) QR-разложения матрицы}}<br />
##### {{level|Метод Хаусхолдера (отражений) QR-разложения квадратной матрицы, вещественный точечный вариант}}<br />
#### {{level|Метод ортогонализации}}<br />
##### {{level|Классический метод ортогонализации}}<br />
##### {{level|Метод ортогонализации с переортогонализацией}}<br />
#### {{level|Метод треугольного разложения матрицы Грама}}<br />
### {{level|Методы QR-разложения плотных хессенберговых матриц}}<br />
#### {{level|Метод Гивенса (вращений) QR-разложения хессенберговой матрицы (вещественный вариант)}}<br />
## {{level|Подобные разложения}}<br />
### {{level|Подобные разложения на унитарные и хессенберговы матрицы}}<br />
#### {{level|Метод Хаусхолдера (отражений) приведения матрицы к хессенберговой (почти треугольной) форме}}<br />
#### {{level|Метод Гивенса (вращений) приведения матрицы к хессенберговой (почти треугольной) форме}}<br />
### {{level|Симметричные разложения на унитарные и трёхдиагональные матрицы}}<br />
#### {{level|Метод Хаусхолдера (отражений) для приведения симметричных матриц к трёхдиагональному виду}}<br />
#### {{level|Метод Хаусхолдера (отражений) для приведения комплексных эрмитовых матриц к трёхдиагональному симметричному виду}}<br />
#### {{level|Метод Гивенса (вращений) приведения матрицы к трёхдиагональной форме}}<br />
### {{level|Спектральное разложение (нахождение собственных значений и векторов)}}<br />
## {{level|Разложения на унитарные и двухдиагональные матрицы}}<br />
### {{level|Метод Хаусхолдера (отражений) приведения матрицы к двухдиагональной форме}}<br />
### {{level|Метод Гивенса (вращений) приведения матрицы к двухдиагональной форме}}<br />
## {{level|Разложения на унитарные и диагональные матрицы}}<br />
### {{level|Сингулярное разложение (нахождение сингулярных значений и векторов)}}<br />
#### {{level|Методы нахождения сингулярных чисел двухдиагональных матриц}}<br />
##### {{level|Алгоритм dqds нахождения сингулярных чисел двухдиагональной матрицы}}<br />
###### {{level|Итерация алгоритма dqds}}<br />
# {{level|Решение систем линейных уравнений}}<br />
## {{level|Прямые методы решения СЛАУ}}<br />
### {{level|Linpack benchmark}}<br />
### {{level|Методы решения СЛАУ с матрицами специального вида}}<br />
#### {{level|Методы решения СЛАУ с треугольными матрицами}}<br />
##### {{level|Прямая подстановка (вещественный вариант)|Прямая подстановка}}<br />
##### {{level|Обратная подстановка (вещественный вариант)|Обратная подстановка}}<br />
##### {{level|Методы решения СЛАУ с двудиагональными матрицами}}<br />
###### {{level|Прямая и обратная подстановка в СЛАУ с двухдиагональной матрицей}}<br />
###### {{level|Метод сдваивания Стоуна для решения двудиагональных СЛАУ}}<br />
###### {{level|Последовательно-параллельный вариант обратной подстановки}}<br />
#### {{level|Методы решения СЛАУ с трёхдиагональными матрицами}}<br />
##### {{level|Методы, основанные на стандартном LU-разложении матрицы}}<br />
###### {{level|Прогонка}}<br />
####### {{level|Прогонка, точечный вариант}}<br />
####### {{level|Классическая монотонная прогонка, повторный вариант}}<br />
###### {{level|Метод сдваивания Стоуна}}<br />
####### {{level|Алгоритм сдваивания Стоуна для LU-разложения трёхдиагональной матрицы}}<br />
####### {{level|Метод сдваивания Стоуна для решения двудиагональных СЛАУ}}<br />
###### {{level|Последовательно-параллельный вариант решения трёхдиагональной СЛАУ с LU-разложением и обратными подстановками}}<br />
##### Другие методы<br />
###### {{level|Метод редукции}}<br />
####### {{level|Полный метод редукции}}<br />
####### {{level|Повторный метод редукции для новой правой части}}<br />
###### {{level|Встречная прогонка}}<br />
####### {{level|Встречная прогонка, точечный вариант}}<br />
####### {{level|Повторная встречная прогонка, точечный вариант}}<br />
###### {{level|Метод циклической редукции}}<br />
####### {{level|Полный метод циклической редукции}}<br />
####### {{level|Повторный метод циклической редукции для новой правой части}}<br />
###### {{level|Метод окаймления}}<br />
#### Методы решения СЛАУ с блочно-треугольными матрицами<br />
##### {{level|Блочная прямая подстановка (вещественный вариант)|Блочная прямая подстановка}}<br />
##### {{level|Блочная обратная подстановка (вещественный вариант)|Блочная обратная подстановка}}<br />
##### Методы решения СЛАУ с блочно-двухдиагональными матрицами<br />
###### {{level|Прямая и обратная подстановка в СЛАУ с блочно-двухдиагональной матрицей}}<br />
###### {{level|Метод сдваивания Стоуна для решения блочно-двухдиагональных СЛАУ}}<br />
###### {{level|Блочный последовательно-параллельный вариант обратной подстановки для решения блочно-двухдиагональных СЛАУ}}<br />
#### {{level|Методы решения СЛАУ с блочно-трёхдиагональными матрицами}}<br />
##### Методы, основанные на стандартном LU-разложении матрицы<br />
###### {{level|Блочная прогонка}}<br />
###### {{level|Блочный последовательно-параллельный вариант решения с LU-разложением и обратными подстановками}}<br />
##### Другие методы<br />
###### {{level|Встречная прогонка, блочный вариант}}<br />
###### {{level|Блочный метод циклической редукции}}<br />
###### {{level|Блочный метод окаймления}}<br />
### {{level|Решения СЛАУ с матрицами специального вида, имеющими известные обратные матрицы}}<br />
## Итерационные методы решения СЛАУ<br />
### {{level|High Performance Conjugate Gradient (HPCG) benchmark}}<br />
### {{level|Алгоритм_Качмажа}}<br />
# <div id="Решения спектральных задач">'''Решения спектральных задач'''</div><br />
## {{level|Спектральное разложение (нахождение собственных значений и векторов)}}<br />
### {{level|QR-алгоритм}}<br />
#### {{level|QR-алгоритм, используемый в SCALAPACK}}<br />
##### {{level|Метод Хаусхолдера (отражений) приведения матрицы к хессенберговой (почти треугольной) форме}}<br />
##### {{level|QR-алгоритм для хессенберговой матрицы, используемый в SCALAPACK}}<br />
#### {{level|QR-алгоритм для симметричных матриц, используемый в SCALAPACK}}<br />
##### {{level|Метод Хаусхолдера (отражений) для приведения симметричных матриц к трёхдиагональному виду}}<br />
##### {{level|QR-алгоритм для симметричных трёхдиагональных матриц, используемый в SCALAPACK}}<br />
#### {{level|QR-алгоритм для комплексных эрмитовых матриц, используемый в SCALAPACK}}<br />
##### {{level|Метод Хаусхолдера (отражений) для приведения комплексных эрмитовых матриц к трёхдиагональному симметричному виду}}<br />
##### {{level|QR-алгоритм для симметричных трёхдиагональных матриц, используемый в SCALAPACK}}<br />
### {{level|Метод Якоби (вращений) для решения спектральной задачи у симметричных матриц}}<br />
#### {{level|Классический метод Якоби (вращений) для симметричных матриц с выбором по всей матрице}}<br />
#### {{level|Метод Якоби (вращений) для симметричных матриц с циклическим исключением и барьерами}}<br />
### {{level|Метод Ланцоша}}<br />
#### {{level|Алгоритм Ланцоша для точной арифметики (без переортогонализации)}}<br />
## {{level|Частичная спектральная задача}}<br />
### {{level|Метод бисекций}}<br />
## {{level|Сингулярное разложение (нахождение сингулярных значений и векторов)}}<br />
### {{level|Метод Якоби (вращений) для нахождения сингулярных значений неособенных матриц}}<br />
### {{level|QR-алгоритм в приложении к сингулярному разложению}}<br />
# <div id="Тесты производительности компьютеров">'''Тесты производительности компьютеров'''</div><br />
## {{level|High Performance Conjugate Gradient (HPCG) benchmark}}<br />
## {{level|Linpack benchmark}}<br />
# {{level|Преобразование Фурье}}<br />
## {{level|Быстрое преобразование Фурье}}<br />
### {{level|Быстрое преобразование Фурье для степеней двойки}}<br />
# <div id="Алгебра многочленов">'''Алгебра многочленов'''</div><br />
## {{level|Схема Горнера, вещественная версия, последовательный вариант}}<br />
# <div id="Численные методы интегрирования">'''Численные методы интегрирования'''</div><br />
## {{level|Квадратурные формулы}}<br />
## {{level|Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)}}<br />
### [[Квадратурные_(кубатурные)_методы_численного_интегрирования_по_отрезку_(многомерному_кубу)#Метод прямоугольников|Метод прямоугольников]]<br />
### [[Квадратурные_(кубатурные)_методы_численного_интегрирования_по_отрезку_(многомерному_кубу)#Метод трапеций|Метод трапеций]]<br />
### [[Квадратурные_(кубатурные)_методы_численного_интегрирования_по_отрезку_(многомерному_кубу)#Метод парабол (метод Симпсона)|Метод парабол (метод Симпсона)]]<br />
### [[Квадратурные_(кубатурные)_методы_численного_интегрирования_по_отрезку_(многомерному_кубу)#Метод Гаусса|Метод Гаусса]]<br />
# <div id="Алгоритмы на графах">'''Алгоритмы на графах'''</div><br />
## Обход графа<br />
### {{level|Поиск в ширину (BFS)}}<br />
### {{level|Поиск в глубину (DFS)}}<br />
## {{level|Поиск кратчайшего пути от одной вершины (SSSP)}}<br />
### {{level|Поиск в ширину (BFS)}} (для невзвешенных графов)<br />
### {{level|Алгоритм Дейкстры}}<br />
### {{level|Алгоритм Беллмана-Форда}}<br />
### {{level|Алгоритм Δ-шагания}}<br />
## {{level|Поиск кратчайшего пути для всех пар вершин (APSP)}}<br />
### {{level|Алгоритм Джонсона}}<br />
### {{level|Алгоритм Флойда-Уоршелла}}<br />
## {{level|Поиск транзитивного замыкания орграфа}}<br />
### {{level|Алгоритм Пурдома}}<br />
## {{level|Определение диаметра графа}}<br />
## {{level|Построение минимального остовного дерева (MST)}}<br />
### {{level|Алгоритм Борувки}}<br />
### {{level|Алгоритм Крускала}}<br />
### {{level|Алгоритм Прима}}<br />
### {{level|Алгоритм GHS}}<br />
## {{level|Поиск изоморфных подграфов}}<br />
### {{level|Алгоритм Ульмана}}<br />
### {{level|Алгоритм VF2}}<br />
## {{level|Связность в графах}}<br />
### {{level|Алгоритм Шилоаха-Вишкина поиска компонент связности}}<br />
### {{level|Система непересекающихся множеств}}<br />
### {{level|Алгоритм Тарьяна поиска компонент сильной связности}}<br />
### {{level|Алгоритм DCSC поиска компонент сильной связности}}<br />
### {{level|Алгоритм Тарьяна поиска компонент двусвязности}}<br />
### {{level|Алгоритм Тарьяна-Вишкина поиска компонент двусвязности}}<br />
### {{level|Алгоритм Тарьяна поиска «мостов» в графе}}<br />
### {{level|Определение вершинной связности графа}}<br />
### {{level|Алгоритм Габова определения рёберной связности графа}}<br />
## {{level|Поиск максимального потока в транспортной сети}}<br />
### {{level|Алгоритм Форда-Фалкерсона}}<br />
### {{level|Алгоритм проталкивания предпотока}}<br />
## {{level|Поиск потока минимальной стоимости в транспортной сети}}<br />
## {{level|Задача о назначениях}}<br />
### {{level|Венгерский алгоритм}}<br />
### {{level|Алгоритм аукциона}}<br />
### {{level|Алгоритм Гопкрофта-Карпа}}<br />
## {{level|Вычисление betweenness centrality|Вычисление центральности вершин}}<br />
# <div id="Алгоритмы поиска">'''Алгоритмы поиска'''</div><br />
## {{level|Линейный поиск - находит элемент в любом списке|Линейный поиск}}, <math>O(n)</math><br />
## {{level|Двоичный поиск - находит элемент в отсортированном списке|Двоичный поиск}}, <math>O(log(n))</math><br />
# <div id="Алгоритмы сортировки">'''Алгоритмы сортировки'''</div><br />
## {{level|Сортировка с помощью двоичного дерева}}<br />
## {{level|Сортировка пузырьком}}<br />
## {{level|Сортировка слиянием (последовательный и параллельный варианты)}}<br />
# <div id="Вычислительная геометрия">'''Вычислительная геометрия'''</div><br />
## {{level|Поиск диаметра множества точек}}<br />
## {{level|Построение выпуклой оболочки набора точек}}<br />
## {{level|Триангуляция Делоне}}<br />
## {{level|Диаграмма Вороного}}<br />
## {{level|Принадлежность точки многоугольнику}}<br />
## {{level|Пересечения выпуклых многоугольников}} - трудоёмкость <math>O(n_1 + n_2)</math><br />
## {{level|Пересечение звёздных многоугольников}} - трудоёмкость <math>O(n_1 * n_2)</math><br />
# <div id="Компьютерная графика">'''Компьютерная графика'''</div><br />
## {{level|Алгоритмы построения отрезка - алгоритмы для аппроксимации отрезка на дискретной графической поверхности}}<br />
## {{level|Алгоритм определения видимых частей трёхмерной сцены}}<br />
## {{level|Трассировка лучей - рендеринг реалистичных изображений}}<br />
## {{level|Глобальное освещение - рассматривает прямое освещение и отражение от других объектов}}<br />
# <div id="Криптографические алгоритмы">'''Криптографические алгоритмы'''</div><br />
# <div id="Нейронные сети">'''Нейронные сети'''</div><br />
# <div id="Алгоритмы оптимизации">'''Алгоритмы оптимизации'''</div><br />
## {{level|Линейное программирование}}<br />
## {{level|Симплекс-метод}}<br />
## {{level|Метод ветвей и границ (последовательный и параллельный варианты)}}<br />
## {{level|Генетические алгоритмы}}<br />
## {{level|Муравьиные алгоритмы}}<br />
## {{level|Комбинированные алгоритмы}}<br />
## {{level|Нахождение экстремума функции}}<br />
# <div id="Алгоритмы теории игр">'''Алгоритмы теории игр'''</div><br />
# <div id="Алгоритмы моделирования квантовых систем">'''Алгоритмы моделирования квантовых систем'''</div><br />
## ''Алгоритмы моделирования квантовых вычислений''<br />
### {{level|Однокубитное преобразование вектора-состояния}}<br />
### {{level|Двухкубитное преобразование вектора-состояния}}<br />
### {{level|Моделирование квантового преобразования Фурье}}<br />
# <div id="Алгоритмы решения уравнений математической физики">'''Алгоритмы решения уравнений математической физики'''</div><br />
## {{level|Уравнение Пуассона, решение дискретным преобразованием Фурье}}<br />
# <div id="Другие алгоритмы">'''Другие алгоритмы'''</div><br />
<br />
[[en:Algorithm classification]]<br />
<br />
[[Категория:Алгоритмы|*]]</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9F%D0%B5%D0%B9%D0%BB%D0%B8_%D0%BF%D0%BE%D1%81%D1%82%D1%80%D0%BE%D0%B5%D0%BD%D0%B8%D1%8F_%D0%BC%D0%B0%D1%82%D1%80%D0%B8%D1%86%D1%8B_%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80%D0%B0&diff=22606Алгоритм Пейли построения матрицы Адамара2017-05-03T20:50:37Z<p>Chernyavskiy: /* Литература */</p>
<hr />
<div><br />
{{algorithm<br />
| name = Алгоритм Пейли построение матрицы Адамара<br />
| serial_complexity = <math>O(n^2)</math><br />
| pf_height = <math>O(1)</math><br />
| pf_width = <math>O(n^2)</math><br />
| input_data = <math>1</math><br />
| output_data = <math>n^2</math><br />
}}<br />
<br />
Основные авторы описания: [[Участник:Nikita|Иванов Н.В.]] (Разделы 1.1,1.7,1.9,1.10,2.4,2.7), [[Участник:Tsyganov Nikita|Цыганов Н.И.]] (Разделы 1.2,1.3,1.4,1.5,1.6,1.7,1.8,2.4), [[Участник:Chernyavskiy|А.Ю.Чернявский]] (проверка, редактирование), [[Участник:Sleo|С.Н.Леоненков]] (предварительня проверка), <br />
<br />
== Свойства и структура алгоритма ==<br />
<br />
<br />
=== Общее описание алгоритма ===<br />
<br />
Матрицы Адамара были введены в математический обиход в конце прошлого века и играют важную роль в алгебре и комбинаторике. Они находят широкое применение в теории кодирования (коды, исправляющие ошибки), теории планирования многофакторных экспериментов (блок-схемы) и других областях математики.<ref name="rt">http://cyberleninka.ru/article/n/matritsy-adamara-nechetnogo-poryadka.pdf</ref> Сравнительно недавно (в 1960 г.) было замечено, что эти матрицы могут быть использованы для построения кодов с большим кодовым расстоянием.<br />
<br />
'''''Матрицей Адамара порядка n''''' называется <math>n*n</math> матрица <math>H</math>, элементами которой являются +1 и −1 такая, что <math>H H^T = n E_n</math>, <br />
где <math>E_n</math> - единичная матрица размера n.<br />
<br />
Матрица Адамара обладает следующими ''свойствами'':<br />
* Различные строки матрицы ортогональны<br />
* Скалярное произведение любой строки саму на себя равно n<br />
* Умножение любой строки или столбца на -1 переводит H в другую матрицу Адамара<br />
* Если все элементы первой строки и первого столбца равны +1, то матрица Адамара называется нормализованной<br />
<br />
Ниже показаны примеры нормализованных матриц Адамара порядка 1,2 и 4, причем нормализованность матриц сохраняется при перестановке любых строк и столбцов, кроме первых:<br />
<br />
<math>H_1 = (1)</math><br />
<math>,<br />
H_2 =<br />
\begin{pmatrix}<br />
1 & 1\\<br />
1 & -1\end{pmatrix}<br />
</math>,<br />
<math>,<br />
H_4 =<br />
\begin{pmatrix}<br />
1 & 1 & 1 & 1\\<br />
1 & -1 & 1 & -1\\<br />
1 & 1 & -1 & -1\\<br />
1 & -1 & -1 & 1\end{pmatrix}<br />
</math><br />
<br />
<br />
Предполагается, что существуют матрицы Адамара порядка 1, 2 и всех порядков n, кратных 4, хотя это до сих пор еще не было доказано. Нет универсального алгоритма построения матрицы Адамара произвольного размера, но известно большое число методов для различных частных случаев, и наименьший порядок, для которого матрица Адамара еще не построена, равен 268 (на 1977 г.). <ref name="rt2">Мак-Вильямс Ф. Дж., Слоэн Н. Дж. А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — c. 52-57</ref> М<br />
<br />
В данном описании рассматривается метод Пейли, основанный на теоретико-числовых принципах и позволяющий строить матрицы Адамара порядка <math>n=p+1</math>, кратного 4, где p-простое число.<br />
<br />
=== Математическое описание алгоритма ===<br />
<br />
Для решения поставленной задачи будем использовать метод Пейли.<br />
Это построение дает матрицы Адамара любого порядка <math>n=p+1</math>, кратного 4, где p-простое число.<br />
<br />
'''Определение.''' Пусть p-простое число. Ненулевые квадраты чисел, приведенные по модулю p, называются квадратичными вычетами по модулю p или просто вычетами по модулю p. <br />
<br />
Чтобы найти все вычеты по модулю p, достаточно рассмотреть квадраты чисел от <math>1^2</math> до <math>(p-1)^2</math>. Но если учесть, что <math>(p-a)^2 </math> <math>mod </math> <math> p = (-a)^2 </math> <math> mod </math> <math> p = a^2 </math> <math>mod</math> <math> p</math>, то достаточно рассмотреть лишь числа <math>1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod </math> <math>p</math> .<br />
<br />
Функция <math>X(i)</math>, называемая символом Лежандра, определяется на целых числах следующим образом:<br />
* <math>X(i)=0</math>, если i кратно p;<br />
* <math>X(i)=1</math>, если остаток от деления i на p является квадратным вычетом по модулю p;<br />
* <math>X(i)=-1</math>, если остаток от деления i на p является невычетом.<br />
<br />
<br />
Теперь мы построим матрицу Джекобстола <math>Q=(q_{ij})</math>. Она представляет собой <math>(p*p)</math>-матрицу, строки и столбцы которой пронумерованы числами 0,1,..., p-1, а элементы <math>q_{ij}=X(j-i)</math>. <br />
<br />
Пусть теперь <math><br />
H =<br />
\begin{pmatrix}<br />
1 & 1\\<br />
1^T & Q-I\end{pmatrix}<br />
</math>.<br />
<br />
Все элементы главной диагонали этой матрицы, кроме элемента <math>h_{00}</math>, равны <math>X(0)-1=-1</math>. Нетрудно заметить, что данная матрица состоит только лишь из элементов 1 и -1.<br />
<br />
Доказано, что такая матрица <math>H</math> представляет собой нормализованную матрицу Адамара порядка p+1, которую называют матрицей типа Пейли.<ref name="rt3">http://tc.nsu.ru/uploads/codingtheory.pdf</ref><br />
<br />
Исходные данные алгоритма - это порядок генерируемой матрицы Адамара <math>n</math>, удовлетворяющее следующим свойствам: <br />
<br />
* <math>n>0</math>;<br />
<br />
* <math>n</math> делится на 4;<br />
<br />
* <math>n-1</math> - простое число.<br />
<br />
Вспомогательные данные: <br />
<br />
* Число <math>p=n-1</math>;<br />
* Вектор квадратичных вычетов (по модулю <math>p</math>) <math>R</math> (элементы <math>r_i</math>) размера <math>2p</math>. В этом векторе индексация идёт с нуля.<br />
<br />
Вычисляемые данные:<br />
<br />
* Матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>) размера <math>n \times n</math>. Индексация строчек и столбцов идёт с нуля. <br />
<br />
Алгоритм:<br />
:1. Строится вектор квадратичных вычетов <math>R</math>.<br />
:: Первые <math>p</math> элементов вектора <math>R</math> (<math>i=0,1,...,p-1</math>) определяются следующим образом:<br />
::: <math>r_i=1</math>, если <math>i \in \{1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod</math> <math> p\}</math>, <math>i=0,1,...,p-1</math>, то есть если <math>i</math> является квадратичным вычетом по модулю <math>p</math>;<br />
::: <math>r_i=-1</math>, иначе.<br />
::Вторые <math>p</math> элементов (<math>i=p,1,...,2p-1</math>) являются копией первых <math>p</math> элементов:<br />
:::<math>r_i=r_{i-p}, i=p,1,...,2p-1.</math><br />
:2. Строится матрица Адамара <math>H</math>.<br />
::Элементы матрицы Адамара <math>H</math> находятся следующим образом:<br />
::: <math>h_{0j}=1, j=0,1, ... ,n-1;</math><br />
::: <math>h_{i0}=1, i=1,2, ... ,n-1;</math><br />
::: <math>h_{ij}=r_{j-i+p}, i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math><br />
<br />
=== Вычислительное ядро алгоритма ===<br />
<br />
Вычислительное ядро алгоритма состоит из <math>(n-1) \times (n-1)</math> операций присваивания следующего вида:<br />
<br />
:<math>h_{ij}=r_{j-i+p},</math> <math> i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math><br />
<br />
=== Макроструктура алгоритма ===<br />
<br />
Как видно из математического описания, алгоритм основан на простейших операциях с числами, поэтому макроструктура алгоритма полностью соответствует его математическому описанию.<br />
<br />
=== Схема реализации последовательного алгоритма ===<br />
<br />
Приведем процедуру на языке С++, реализующую описанный алгоритм. На вход процедуре подается порядок матрицы <math>n</math> и ссылка на заполняемую матрицу <math>result</math>. Считаем, что <math>n</math> положительно, делится на <math>4</math>, <math>n-1</math> - простое число, а размер матрицы <math>result</math> равен <math>n \times n</math>.<br />
<br />
<source lang="C"><br />
void buildHadamardMatrix(int n, vector< vector<int> > & result)<br />
{<br />
// 1) matrix size changing<br />
result.resize(n);<br />
for (int i=0; i<n; i++) {<br />
result[i].resize(n);<br />
}<br />
<br />
// 2) residue array building<br />
int p=n-1;<br />
vector<int> residues;<br />
residues.resize(2*p);<br />
for (int i=0; i<p; i++) {<br />
residues[i] = -1;<br />
}<br />
for (int i=1; i<= (p-1)/2; i++) {<br />
residues[i*i % p] = 1;<br />
}<br />
for (int i=p; i<2*p; i++) {<br />
residues[i] = residues[i-p];<br />
}<br />
// 3) Paley matrix building<br />
// first line filling<br />
for (int j=0; j<n; j++) {<br />
result[0][j] = 1;<br />
}<br />
// first column filling<br />
for (int i=1; i<n; i++) {<br />
result[i][0] = 1;<br />
}<br />
// others<br />
for (int i=1; i<n; i++) {<br />
for (int j=1; j<n; j++) {<br />
result[i][j] = residues[j-i+p];<br />
}<br />
}<br />
}<br />
</source><br />
<br />
=== Последовательная сложность алгоритма ===<br />
<br />
Под сложностью будем понимать зависимость числа операций от задаваемого порядка матрицы <math>n</math>. <br />
<br />
Основными операциями алгоритма являются:<br />
<br />
* <math>\frac{n}{2}-2</math> операций умножения;<br />
* <math>\frac{n}{2}-2</math> операций взятия остатка;<br />
* <math>n^2+\frac{5}{2}n-3</math> операций присваивания.<br />
<br />
Из чего следует, что алгоритм имеет квадратичную последовательную сложность.<br />
<br />
=== Информационный граф ===<br />
<br />
Информационный граф алгоритма можно представить в виде четырёх последовательных блоков. Первый блок содержит <math>n-1</math> параллельных ветвей, второй блок - <math>\frac{n}{2}-1</math> параллельных ветвей, третий - <math>n-1</math> и четвёртый - <math>n^2</math>.<br />
<br />
[[Файл:i_graph2.png|600px|thumb|center]]<br />
<br />
Каждая вершина из <math>A_1-A_{n-1}</math>, <math>C_1-C_{n-1}</math>, <math>D_1-D_{n^2}</math> соответствует операции присваивания, каждая вершина из <math>B_1-B_{\frac{n}{2}-1}</math> соответствует трём последовательным операциям: умножения, взятия остатка по модулю и присваивания, а вершины, окрашенные серым, представляют собой промежуточные точки синхронизации.<br />
<br />
[[Файл:i_graph3.jpg|600px|thumb|center|Информационный граф для n=4.]]<br />
На рисунке приведен информационный граф алгоритма для случая n=4. Вершины графа соответствуют следующим строчкам кода:<br />
<br />
a. residues[i] = -1;<br />
<br />
b. residues[i*i%p] = 1;<br />
<br />
c. residues[i] = residues[i-p];<br />
<br />
d. result[0][j] = 1;<br />
<br />
e. result[i][0] = 1;<br />
<br />
f. result[i][j] = residues[i-j+p];<br />
<br />
=== Ресурс параллелизма алгоритма ===<br />
<br />
Как видно из информационного графа алгоритма, в параллельном варианте необходимо последовательно выполнить следующие блоки:<br />
<br />
* <math>n-1</math> операций присваивания;<br />
* <math>\frac{n}{2}-1</math> участков, состоящих из трёх операций: умножения, взятия остатка и присваивания;<br />
* <math>n-1</math> операций присваивания;<br />
* <math>n^2</math> операций присваивания.<br />
<br />
Из этого можно сделать вывод, что высота ярусно-параллельной формы информационного графа равняется 6 (присваивание, умножение, взятие остатка, присваивание, присваивание, присваивание). Ширина ярусно-параллельной формы равняется <math>n^2</math>, что означает, что при использовании <math>n^2</math> процессоров матрица Адамара будет строиться за 6 операций.<br />
<br />
=== Входные и выходные данные алгоритма ===<br />
<br />
'''Входные данные:''' число <math>n</math> - порядок матрицы Адамара <math>H_n</math>. Дополнительные ограничения на <math>n</math>:<br />
* <math>n</math> - натуральное;<br />
* <math>n</math> делится на 4;<br />
* <math>n-1</math> - простое.<br />
'''Объем входных данных:''' 1 (число <math>n</math>).<br />
<br />
'''Выходные данные:''' построенная матрица Адамара <math>H_n</math> (её элементы <math>h_{ij}</math>).<br />
<br />
'''Объем выходных данных:''' <math>n^2</math> (количество элементов матрицы Адамара размера <math>n*n</math>).<br />
<br />
=== Свойства алгоритма ===<br />
<br />
Соотношение последовательной и параллельной сложности в случае неограниченных ресурсов является квадратичным. <br />
<br />
Вычислительная мощность алгоритма является постоянной (<math>O(1)</math>). <br />
<br />
Алгоритм является полностью детерминированным. <br />
<br />
Для вершин <math>A_1-A_{n-1}</math>, <math>B_1-B_{\frac{n}{2}-1}</math>, <math>C_1-C_{n-1}</math> информационного графа степени исхода являются линейными, что означает, что при возможности на этапе реализации необходимо позаботиться об эффективном доступе к элементам массива "<math>residues</math>".<br />
<br />
== Программная реализация алгоритма ==<br />
<br />
=== Особенности реализации последовательного алгоритма ===<br />
<br />
=== Локальность данных и вычислений ===<br />
<br />
=== Возможные способы и особенности параллельной реализации алгоритма ===<br />
<br />
=== Масштабируемость алгоритма и его реализации ===<br />
<br />
<br />
Исследование масштабируемости параллельной реализации алгоритма построения матрицы Адамара проводилось на суперкомпьютере «Ломоносов». Для этого была исследована собственная реализация алгоритма с использованием средств MPI. В ходе исследования было произведено множество запусков программы с различными значениями параметра <math>n</math> (размер матрицы Адамара) и числом процессоров.<br />
<br />
Набор и границы значений изменяемых параметров запуска реализации алгоритма:<br />
*число процессоров (p): [2,64] с шагом 2;<br />
*размер матрицы: простые числа в диапазоне [4,10000].<br />
<br />
В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:<br />
*минимальная эффективность реализации 0.0000036% при n=4, p=2;<br />
*максимальная эффективность реализации 0.333426% при n=948, p=2.<br />
<br />
Ниже представлены графики времени работы, производительности и эффективности данной реализации алгоритма построения матрицы Адамара в зависимости от изменяемых параметров запуска.<br />
[[Файл:time_graph1.png|500px|thumb|center|Время работы параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]<br />
[[Файл:perform_graph1.png|500px|thumb|center|Изменение производительности параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]<br />
[[Файл:efficiency_graph1.png|500px|thumb|center|Эффективность работы параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]<br />
<br />
<br />
[https://github.com/snikersman/Hadamard Исследованная параллельная реализация на языке C++]<br />
<br />
Построим оценки масштабируемости, используя полученные результаты:<br />
*По размерности задачи. Увеличение размерности задачи приводит к увеличению производительности.<br />
*По числу процессоров. С ростом числа процессоров растет производительность, но при малых размерностях задачи этот рост незначителен. Это связано с дополнительными издержками по записи в участок памяти каждого процессора вспомогательного массива вычетов, а также с обменом информации между процессорами.<br />
*По двум направлениям. При увеличении как числа процессоров, так и размерности задачи, производительность увеличивается. Причем чем больше используется процессоров, тем сильнее увеличивается производительность при увеличении размерности.<br />
<br />
=== Динамические характеристики и эффективность реализации алгоритма ===<br />
<br />
=== Выводы для классов архитектур ===<br />
<br />
=== Существующие реализации алгоритма ===<br />
<br />
Алгоритм построения матрицы Адамара реализован в различных математических пакетах и библиотеках: <br />
* [https://www.mathworks.com/help/matlab/ref/hadamard.html?requestedDomain=www.mathworks.com MATLAB] (вносятся дополнительные ограничения, когда n, или n/12, или n/20 являются степенями по основанию 2)<br />
* [http://r-survey.r-forge.r-project.org/survey/html/hadamard.html R]<br />
* [https://reference.wolframcloud.com/cloudplatform/ref/HadamardMatrix.html Wolfram Mathematica]<br />
* [http://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.linalg.hadamard.html SciPy для Python]<br />
<br />
== Литература ==<br />
<br />
<br />
<br />
[[Категория:Статьи в работе]]</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA:Nikita/%D0%9F%D0%BE%D1%81%D1%82%D1%80%D0%BE%D0%B5%D0%BD%D0%B8%D0%B5_%D0%BC%D0%B0%D1%82%D1%80%D0%B8%D1%86%D1%8B_%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80%D0%B0&diff=22605Участник:Nikita/Построение матрицы Адамара2017-05-03T20:49:59Z<p>Chernyavskiy: /* Литература */</p>
<hr />
<div>{{Assignment|Sleo}}<br />
<br />
{{algorithm<br />
| name = Построение матрицы Адамара<br />
| serial_complexity = <math>O(n^2)</math><br />
| pf_height = <math>O(1)</math><br />
| pf_width = <math>O(n^2)</math><br />
| input_data = <math>1</math><br />
| output_data = <math>n^2</math><br />
}}<br />
<br />
Авторы статьи: [[Участник:Nikita|Иванов Н.В.]] (1.1,1.7,1.9,1.10,2.4,2.7), [[Участник:Tsyganov Nikita|Цыганов Н.И.]] (1.2,1.3,1.4,1.5,1.6,1.7,1.8,2.4).<br />
<br />
== Свойства и структура алгоритма ==<br />
<br />
<br />
=== Общее описание алгоритма ===<br />
<br />
Матрицы Адамара были введены в математический обиход в конце прошлого века и играют важную роль в алгебре и комбинаторике. Они находят широкое применение в теории кодирования (коды, исправляющие ошибки), теории планирования многофакторных экспериментов (блок-схемы) и других областях математики.<ref name="rt">http://cyberleninka.ru/article/n/matritsy-adamara-nechetnogo-poryadka.pdf</ref> Сравнительно недавно (в 1960 г.) было замечено, что эти матрицы могут быть использованы для построения кодов с большим кодовым расстоянием.<br />
<br />
'''''Матрицей Адамара порядка n''''' называется <math>n*n</math> матрица <math>H</math>, элементами которой являются +1 и −1 такая, что <math>H H^T = n E_n</math>, <br />
где <math>E_n</math> - единичная матрица размера n.<br />
<br />
Матрица Адамара обладает следующими ''свойствами'':<br />
* Различные строки матрицы ортогональны<br />
* Скалярное произведение любой строки саму на себя равно n<br />
* Умножение любой строки или столбца на -1 переводит H в другую матрицу Адамара<br />
* Если все элементы первой строки и первого столбца равны +1, то матрица Адамара называется нормализованной<br />
<br />
Ниже показаны примеры нормализованных матриц Адамара порядка 1,2 и 4, причем нормализованность матриц сохраняется при перестановке любых строк и столбцов, кроме первых:<br />
<br />
<math>H_1 = (1)</math><br />
<math>,<br />
H_2 =<br />
\begin{pmatrix}<br />
1 & 1\\<br />
1 & -1\end{pmatrix}<br />
</math>,<br />
<math>,<br />
H_4 =<br />
\begin{pmatrix}<br />
1 & 1 & 1 & 1\\<br />
1 & -1 & 1 & -1\\<br />
1 & 1 & -1 & -1\\<br />
1 & -1 & -1 & 1\end{pmatrix}<br />
</math><br />
<br />
<br />
Предполагается, что существуют матрицы Адамара порядка 1, 2 и всех порядков n, кратных 4, хотя это до сих пор еще не было доказано. Нет универсального алгоритма построения матрицы Адамара произвольного размера, но известно большое число методов для различных частных случаев, и наименьший порядок, для которого матрица Адамара еще не построена, равен 268 (на 1977 г.). <ref name="rt2">Мак-Вильямс Ф. Дж., Слоэн Н. Дж. А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — c. 52-57</ref> Мы приведем метод построения Пейли, который важен для теории кодирования. <br />
<br />
=== Математическое описание алгоритма ===<br />
<br />
Для решения поставленной задачи будем использовать метод Пейли.<br />
Это построение дает матрицы Адамара любого порядка <math>n=p+1</math>, кратного 4, где p-простое число.<br />
<br />
'''Определение.''' Пусть p-простое число. Ненулевые квадраты чисел, приведенные по модулю p, называются квадратичными вычетами по модулю p или просто вычетами по модулю p. <br />
<br />
Чтобы найти все вычеты по модулю p, достаточно рассмотреть квадраты чисел от <math>1^2</math> до <math>(p-1)^2</math>. Но если учесть, что <math>(p-a)^2 </math> <math>mod </math> <math> p = (-a)^2 </math> <math> mod </math> <math> p = a^2 </math> <math>mod</math> <math> p</math>, то достаточно рассмотреть лишь числа <math>1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod </math> <math>p</math> .<br />
<br />
Функция <math>X(i)</math>, называемая символом Лежандра, определяется на целых числах следующим образом:<br />
* <math>X(i)=0</math>, если i кратно p;<br />
* <math>X(i)=1</math>, если остаток от деления i на p является квадратным вычетом по модулю p;<br />
* <math>X(i)=-1</math>, если остаток от деления i на p является невычетом.<br />
<br />
<br />
Теперь мы построим матрицу Джекобстола <math>Q=(q_{ij})</math>. Она представляет собой <math>(p*p)</math>-матрицу, строки и столбцы которой пронумерованы числами 0,1,..., p-1, а элементы <math>q_{ij}=X(j-i)</math>. <br />
<br />
Пусть теперь <math><br />
H =<br />
\begin{pmatrix}<br />
1 & 1\\<br />
1^T & Q-I\end{pmatrix}<br />
</math>.<br />
<br />
Все элементы главной диагонали этой матрицы, кроме элемента <math>h_{00}</math>, равны <math>X(0)-1=-1</math>. Нетрудно заметить, что данная матрица состоит только лишь из элементов 1 и -1.<br />
<br />
Доказано, что такая матрица <math>H</math> представляет собой нормализованную матрицу Адамара порядка p+1, которую называют матрицей типа Пейли.<ref name="rt3">http://tc.nsu.ru/uploads/codingtheory.pdf</ref><br />
<br />
Исходные данные алгоритма - это порядок генерируемой матрицы Адамара <math>n</math>, удовлетворяющее следующим свойствам: <br />
<br />
* <math>n>0</math>;<br />
<br />
* <math>n</math> делится на 4;<br />
<br />
* <math>n-1</math> - простое число.<br />
<br />
Вспомогательные данные: <br />
<br />
* Число <math>p=n-1</math>;<br />
* Вектор квадратичных вычетов (по модулю <math>p</math>) <math>R</math> (элементы <math>r_i</math>) размера <math>2p</math>. В этом векторе индексация идёт с нуля.<br />
<br />
Вычисляемые данные:<br />
<br />
* Матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>) размера <math>n \times n</math>. Индексация строчек и столбцов идёт с нуля. <br />
<br />
Алгоритм:<br />
:1. Строится вектор квадратичных вычетов <math>R</math>.<br />
:: Первые <math>p</math> элементов вектора <math>R</math> (<math>i=0,1,...,p-1</math>) определяются следующим образом:<br />
::: <math>r_i=1</math>, если <math>i \in \{1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod</math> <math> p\}</math>, <math>i=0,1,...,p-1</math>, то есть если <math>i</math> является квадратичным вычетом по модулю <math>p</math>;<br />
::: <math>r_i=-1</math>, иначе.<br />
::Вторые <math>p</math> элементов (<math>i=p,1,...,2p-1</math>) являются копией первых <math>p</math> элементов:<br />
:::<math>r_i=r_{i-p}, i=p,1,...,2p-1.</math><br />
:2. Строится матрица Адамара <math>H</math>.<br />
::Элементы матрицы Адамара <math>H</math> находятся следующим образом:<br />
::: <math>h_{0j}=1, j=0,1, ... ,n-1;</math><br />
::: <math>h_{i0}=1, i=1,2, ... ,n-1;</math><br />
::: <math>h_{ij}=r_{j-i+p}, i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math><br />
<br />
=== Вычислительное ядро алгоритма ===<br />
<br />
Вычислительное ядро алгоритма состоит из <math>(n-1) \times (n-1)</math> операций присваивания следующего вида:<br />
<br />
:<math>h_{ij}=r_{j-i+p},</math> <math> i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math><br />
<br />
=== Макроструктура алгоритма ===<br />
<br />
Как видно из математического описания, алгоритм основан на простейших операциях с числами, поэтому макроструктура алгоритма полностью соответствует его математическому описанию.<br />
<br />
=== Схема реализации последовательного алгоритма ===<br />
<br />
Приведем процедуру на языке С++, реализующую описанный алгоритм. На вход процедуре подается порядок матрицы <math>n</math> и ссылка на заполняемую матрицу <math>result</math>. Считаем, что <math>n</math> положительно, делится на <math>4</math>, <math>n-1</math> - простое число, а размер матрицы <math>result</math> равен <math>n \times n</math>.<br />
<br />
<source lang="C"><br />
void buildHadamardMatrix(int n, vector< vector<int> > & result)<br />
{<br />
// 1) matrix size changing<br />
result.resize(n);<br />
for (int i=0; i<n; i++) {<br />
result[i].resize(n);<br />
}<br />
<br />
// 2) residue array building<br />
int p=n-1;<br />
vector<int> residues;<br />
residues.resize(2*p);<br />
for (int i=0; i<p; i++) {<br />
residues[i] = -1;<br />
}<br />
for (int i=1; i<= (p-1)/2; i++) {<br />
residues[i*i % p] = 1;<br />
}<br />
for (int i=p; i<2*p; i++) {<br />
residues[i] = residues[i-p];<br />
}<br />
// 3) Paley matrix building<br />
// first line filling<br />
for (int j=0; j<n; j++) {<br />
result[0][j] = 1;<br />
}<br />
// first column filling<br />
for (int i=1; i<n; i++) {<br />
result[i][0] = 1;<br />
}<br />
// others<br />
for (int i=1; i<n; i++) {<br />
for (int j=1; j<n; j++) {<br />
result[i][j] = residues[j-i+p];<br />
}<br />
}<br />
}<br />
</source><br />
<br />
=== Последовательная сложность алгоритма ===<br />
<br />
Под сложностью будем понимать зависимость числа операций от задаваемого порядка матрицы <math>n</math>. <br />
<br />
Основными операциями алгоритма являются:<br />
<br />
* <math>\frac{n}{2}-2</math> операций умножения;<br />
* <math>\frac{n}{2}-2</math> операций взятия остатка;<br />
* <math>n^2+\frac{5}{2}n-3</math> операций присваивания.<br />
<br />
Из чего следует, что алгоритм имеет квадратичную последовательную сложность.<br />
<br />
=== Информационный граф ===<br />
<br />
Информационный граф алгоритма можно представить в виде четырёх последовательных блоков. Первый блок содержит <math>n-1</math> параллельных ветвей, второй блок - <math>\frac{n}{2}-1</math> параллельных ветвей, третий - <math>n-1</math> и четвёртый - <math>n^2</math>.<br />
<br />
[[Файл:i_graph2.png|600px|thumb|center]]<br />
<br />
Каждая вершина из <math>A_1-A_{n-1}</math>, <math>C_1-C_{n-1}</math>, <math>D_1-D_{n^2}</math> соответствует операции присваивания, каждая вершина из <math>B_1-B_{\frac{n}{2}-1}</math> соответствует трём последовательным операциям: умножения, взятия остатка по модулю и присваивания, а вершины, окрашенные серым, представляют собой промежуточные точки синхронизации.<br />
<br />
[[Файл:i_graph3.jpg|600px|thumb|center|Информационный граф для n=4.]]<br />
На рисунке приведен информационный граф алгоритма для случая n=4. Вершины графа соответствуют следующим строчкам кода:<br />
<br />
a. residues[i] = -1;<br />
<br />
b. residues[i*i%p] = 1;<br />
<br />
c. residues[i] = residues[i-p];<br />
<br />
d. result[0][j] = 1;<br />
<br />
e. result[i][0] = 1;<br />
<br />
f. result[i][j] = residues[i-j+p];<br />
<br />
=== Ресурс параллелизма алгоритма ===<br />
<br />
Как видно из информационного графа алгоритма, в параллельном варианте необходимо последовательно выполнить следующие блоки:<br />
<br />
* <math>n-1</math> операций присваивания;<br />
* <math>\frac{n}{2}-1</math> участков, состоящих из трёх операций: умножения, взятия остатка и присваивания;<br />
* <math>n-1</math> операций присваивания;<br />
* <math>n^2</math> операций присваивания.<br />
<br />
Из этого можно сделать вывод, что высота ярусно-параллельной формы информационного графа равняется 6 (присваивание, умножение, взятие остатка, присваивание, присваивание, присваивание). Ширина ярусно-параллельной формы равняется <math>n^2</math>, что означает, что при использовании <math>n^2</math> процессоров матрица Адамара будет строиться за 6 операций.<br />
<br />
=== Входные и выходные данные алгоритма ===<br />
<br />
'''Входные данные:''' число <math>n</math> - порядок матрицы Адамара <math>H_n</math>. Дополнительные ограничения на <math>n</math>:<br />
* <math>n</math> - натуральное;<br />
* <math>n</math> делится на 4;<br />
* <math>n-1</math> - простое.<br />
'''Объем входных данных:''' 1 (число <math>n</math>).<br />
<br />
'''Выходные данные:''' построенная матрица Адамара <math>H_n</math> (её элементы <math>h_{ij}</math>).<br />
<br />
'''Объем выходных данных:''' <math>n^2</math> (количество элементов матрицы Адамара размера <math>n*n</math>).<br />
<br />
=== Свойства алгоритма ===<br />
<br />
Соотношение последовательной и параллельной сложности в случае неограниченных ресурсов является квадратичным. <br />
<br />
Вычислительная мощность алгоритма является постоянной (<math>O(1)</math>). <br />
<br />
Алгоритм является полностью детерминированным. <br />
<br />
Для вершин <math>A_1-A_{n-1}</math>, <math>B_1-B_{\frac{n}{2}-1}</math>, <math>C_1-C_{n-1}</math> информационного графа степени исхода являются линейными, что означает, что при возможности на этапе реализации необходимо позаботиться об эффективном доступе к элементам массива "<math>residues</math>".<br />
<br />
== Программная реализация алгоритма ==<br />
<br />
=== Особенности реализации последовательного алгоритма ===<br />
<br />
=== Локальность данных и вычислений ===<br />
<br />
=== Возможные способы и особенности параллельной реализации алгоритма ===<br />
<br />
=== Масштабируемость алгоритма и его реализации ===<br />
<br />
<br />
Исследование масштабируемости параллельной реализации алгоритма построения матрицы Адамара проводилось на суперкомпьютере «Ломоносов». Для этого была исследована собственная реализация алгоритма с использованием средств MPI. В ходе исследования было произведено множество запусков программы с различными значениями параметра <math>n</math> (размер матрицы Адамара) и числом процессоров.<br />
<br />
Набор и границы значений изменяемых параметров запуска реализации алгоритма:<br />
*число процессоров (p): [2,64] с шагом 2;<br />
*размер матрицы: простые числа в диапазоне [4,10000].<br />
<br />
В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:<br />
*минимальная эффективность реализации 0.0000036% при n=4, p=2;<br />
*максимальная эффективность реализации 0.333426% при n=948, p=2.<br />
<br />
Ниже представлены графики времени работы, производительности и эффективности данной реализации алгоритма построения матрицы Адамара в зависимости от изменяемых параметров запуска.<br />
[[Файл:time_graph1.png|500px|thumb|center|Время работы параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]<br />
[[Файл:perform_graph1.png|500px|thumb|center|Изменение производительности параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]<br />
[[Файл:efficiency_graph1.png|500px|thumb|center|Эффективность работы параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]<br />
<br />
<br />
[https://github.com/snikersman/Hadamard Исследованная параллельная реализация на языке C++]<br />
<br />
Построим оценки масштабируемости, используя полученные результаты:<br />
*По размерности задачи. Увеличение размерности задачи приводит к увеличению производительности.<br />
*По числу процессоров. С ростом числа процессоров растет производительность, но при малых размерностях задачи этот рост незначителен. Это связано с дополнительными издержками по записи в участок памяти каждого процессора вспомогательного массива вычетов, а также с обменом информации между процессорами.<br />
*По двум направлениям. При увеличении как числа процессоров, так и размерности задачи, производительность увеличивается. Причем чем больше используется процессоров, тем сильнее увеличивается производительность при увеличении размерности.<br />
<br />
=== Динамические характеристики и эффективность реализации алгоритма ===<br />
<br />
=== Выводы для классов архитектур ===<br />
<br />
=== Существующие реализации алгоритма ===<br />
<br />
Алгоритм построения матрицы Адамара реализован в различных математических пакетах и библиотеках: <br />
* [https://www.mathworks.com/help/matlab/ref/hadamard.html?requestedDomain=www.mathworks.com MATLAB] (вносятся дополнительные ограничения, когда n, или n/12, или n/20 являются степенями по основанию 2)<br />
* [http://r-survey.r-forge.r-project.org/survey/html/hadamard.html R]<br />
* [https://reference.wolframcloud.com/cloudplatform/ref/HadamardMatrix.html Wolfram Mathematica]<br />
* [http://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.linalg.hadamard.html SciPy для Python]<br />
<br />
== Литература ==</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA:Nikita/%D0%9F%D0%BE%D1%81%D1%82%D1%80%D0%BE%D0%B5%D0%BD%D0%B8%D0%B5_%D0%BC%D0%B0%D1%82%D1%80%D0%B8%D1%86%D1%8B_%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80%D0%B0&diff=22604Участник:Nikita/Построение матрицы Адамара2017-05-03T20:49:35Z<p>Chernyavskiy: /* Литература */</p>
<hr />
<div>{{Assignment|Sleo}}<br />
<br />
{{algorithm<br />
| name = Построение матрицы Адамара<br />
| serial_complexity = <math>O(n^2)</math><br />
| pf_height = <math>O(1)</math><br />
| pf_width = <math>O(n^2)</math><br />
| input_data = <math>1</math><br />
| output_data = <math>n^2</math><br />
}}<br />
<br />
Авторы статьи: [[Участник:Nikita|Иванов Н.В.]] (1.1,1.7,1.9,1.10,2.4,2.7), [[Участник:Tsyganov Nikita|Цыганов Н.И.]] (1.2,1.3,1.4,1.5,1.6,1.7,1.8,2.4).<br />
<br />
== Свойства и структура алгоритма ==<br />
<br />
<br />
=== Общее описание алгоритма ===<br />
<br />
Матрицы Адамара были введены в математический обиход в конце прошлого века и играют важную роль в алгебре и комбинаторике. Они находят широкое применение в теории кодирования (коды, исправляющие ошибки), теории планирования многофакторных экспериментов (блок-схемы) и других областях математики.<ref name="rt">http://cyberleninka.ru/article/n/matritsy-adamara-nechetnogo-poryadka.pdf</ref> Сравнительно недавно (в 1960 г.) было замечено, что эти матрицы могут быть использованы для построения кодов с большим кодовым расстоянием.<br />
<br />
'''''Матрицей Адамара порядка n''''' называется <math>n*n</math> матрица <math>H</math>, элементами которой являются +1 и −1 такая, что <math>H H^T = n E_n</math>, <br />
где <math>E_n</math> - единичная матрица размера n.<br />
<br />
Матрица Адамара обладает следующими ''свойствами'':<br />
* Различные строки матрицы ортогональны<br />
* Скалярное произведение любой строки саму на себя равно n<br />
* Умножение любой строки или столбца на -1 переводит H в другую матрицу Адамара<br />
* Если все элементы первой строки и первого столбца равны +1, то матрица Адамара называется нормализованной<br />
<br />
Ниже показаны примеры нормализованных матриц Адамара порядка 1,2 и 4, причем нормализованность матриц сохраняется при перестановке любых строк и столбцов, кроме первых:<br />
<br />
<math>H_1 = (1)</math><br />
<math>,<br />
H_2 =<br />
\begin{pmatrix}<br />
1 & 1\\<br />
1 & -1\end{pmatrix}<br />
</math>,<br />
<math>,<br />
H_4 =<br />
\begin{pmatrix}<br />
1 & 1 & 1 & 1\\<br />
1 & -1 & 1 & -1\\<br />
1 & 1 & -1 & -1\\<br />
1 & -1 & -1 & 1\end{pmatrix}<br />
</math><br />
<br />
<br />
Предполагается, что существуют матрицы Адамара порядка 1, 2 и всех порядков n, кратных 4, хотя это до сих пор еще не было доказано. Нет универсального алгоритма построения матрицы Адамара произвольного размера, но известно большое число методов для различных частных случаев, и наименьший порядок, для которого матрица Адамара еще не построена, равен 268 (на 1977 г.). <ref name="rt2">Мак-Вильямс Ф. Дж., Слоэн Н. Дж. А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — c. 52-57</ref> Мы приведем метод построения Пейли, который важен для теории кодирования. <br />
<br />
=== Математическое описание алгоритма ===<br />
<br />
Для решения поставленной задачи будем использовать метод Пейли.<br />
Это построение дает матрицы Адамара любого порядка <math>n=p+1</math>, кратного 4, где p-простое число.<br />
<br />
'''Определение.''' Пусть p-простое число. Ненулевые квадраты чисел, приведенные по модулю p, называются квадратичными вычетами по модулю p или просто вычетами по модулю p. <br />
<br />
Чтобы найти все вычеты по модулю p, достаточно рассмотреть квадраты чисел от <math>1^2</math> до <math>(p-1)^2</math>. Но если учесть, что <math>(p-a)^2 </math> <math>mod </math> <math> p = (-a)^2 </math> <math> mod </math> <math> p = a^2 </math> <math>mod</math> <math> p</math>, то достаточно рассмотреть лишь числа <math>1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod </math> <math>p</math> .<br />
<br />
Функция <math>X(i)</math>, называемая символом Лежандра, определяется на целых числах следующим образом:<br />
* <math>X(i)=0</math>, если i кратно p;<br />
* <math>X(i)=1</math>, если остаток от деления i на p является квадратным вычетом по модулю p;<br />
* <math>X(i)=-1</math>, если остаток от деления i на p является невычетом.<br />
<br />
<br />
Теперь мы построим матрицу Джекобстола <math>Q=(q_{ij})</math>. Она представляет собой <math>(p*p)</math>-матрицу, строки и столбцы которой пронумерованы числами 0,1,..., p-1, а элементы <math>q_{ij}=X(j-i)</math>. <br />
<br />
Пусть теперь <math><br />
H =<br />
\begin{pmatrix}<br />
1 & 1\\<br />
1^T & Q-I\end{pmatrix}<br />
</math>.<br />
<br />
Все элементы главной диагонали этой матрицы, кроме элемента <math>h_{00}</math>, равны <math>X(0)-1=-1</math>. Нетрудно заметить, что данная матрица состоит только лишь из элементов 1 и -1.<br />
<br />
Доказано, что такая матрица <math>H</math> представляет собой нормализованную матрицу Адамара порядка p+1, которую называют матрицей типа Пейли.<ref name="rt3">http://tc.nsu.ru/uploads/codingtheory.pdf</ref><br />
<br />
Исходные данные алгоритма - это порядок генерируемой матрицы Адамара <math>n</math>, удовлетворяющее следующим свойствам: <br />
<br />
* <math>n>0</math>;<br />
<br />
* <math>n</math> делится на 4;<br />
<br />
* <math>n-1</math> - простое число.<br />
<br />
Вспомогательные данные: <br />
<br />
* Число <math>p=n-1</math>;<br />
* Вектор квадратичных вычетов (по модулю <math>p</math>) <math>R</math> (элементы <math>r_i</math>) размера <math>2p</math>. В этом векторе индексация идёт с нуля.<br />
<br />
Вычисляемые данные:<br />
<br />
* Матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>) размера <math>n \times n</math>. Индексация строчек и столбцов идёт с нуля. <br />
<br />
Алгоритм:<br />
:1. Строится вектор квадратичных вычетов <math>R</math>.<br />
:: Первые <math>p</math> элементов вектора <math>R</math> (<math>i=0,1,...,p-1</math>) определяются следующим образом:<br />
::: <math>r_i=1</math>, если <math>i \in \{1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod</math> <math> p\}</math>, <math>i=0,1,...,p-1</math>, то есть если <math>i</math> является квадратичным вычетом по модулю <math>p</math>;<br />
::: <math>r_i=-1</math>, иначе.<br />
::Вторые <math>p</math> элементов (<math>i=p,1,...,2p-1</math>) являются копией первых <math>p</math> элементов:<br />
:::<math>r_i=r_{i-p}, i=p,1,...,2p-1.</math><br />
:2. Строится матрица Адамара <math>H</math>.<br />
::Элементы матрицы Адамара <math>H</math> находятся следующим образом:<br />
::: <math>h_{0j}=1, j=0,1, ... ,n-1;</math><br />
::: <math>h_{i0}=1, i=1,2, ... ,n-1;</math><br />
::: <math>h_{ij}=r_{j-i+p}, i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math><br />
<br />
=== Вычислительное ядро алгоритма ===<br />
<br />
Вычислительное ядро алгоритма состоит из <math>(n-1) \times (n-1)</math> операций присваивания следующего вида:<br />
<br />
:<math>h_{ij}=r_{j-i+p},</math> <math> i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math><br />
<br />
=== Макроструктура алгоритма ===<br />
<br />
Как видно из математического описания, алгоритм основан на простейших операциях с числами, поэтому макроструктура алгоритма полностью соответствует его математическому описанию.<br />
<br />
=== Схема реализации последовательного алгоритма ===<br />
<br />
Приведем процедуру на языке С++, реализующую описанный алгоритм. На вход процедуре подается порядок матрицы <math>n</math> и ссылка на заполняемую матрицу <math>result</math>. Считаем, что <math>n</math> положительно, делится на <math>4</math>, <math>n-1</math> - простое число, а размер матрицы <math>result</math> равен <math>n \times n</math>.<br />
<br />
<source lang="C"><br />
void buildHadamardMatrix(int n, vector< vector<int> > & result)<br />
{<br />
// 1) matrix size changing<br />
result.resize(n);<br />
for (int i=0; i<n; i++) {<br />
result[i].resize(n);<br />
}<br />
<br />
// 2) residue array building<br />
int p=n-1;<br />
vector<int> residues;<br />
residues.resize(2*p);<br />
for (int i=0; i<p; i++) {<br />
residues[i] = -1;<br />
}<br />
for (int i=1; i<= (p-1)/2; i++) {<br />
residues[i*i % p] = 1;<br />
}<br />
for (int i=p; i<2*p; i++) {<br />
residues[i] = residues[i-p];<br />
}<br />
// 3) Paley matrix building<br />
// first line filling<br />
for (int j=0; j<n; j++) {<br />
result[0][j] = 1;<br />
}<br />
// first column filling<br />
for (int i=1; i<n; i++) {<br />
result[i][0] = 1;<br />
}<br />
// others<br />
for (int i=1; i<n; i++) {<br />
for (int j=1; j<n; j++) {<br />
result[i][j] = residues[j-i+p];<br />
}<br />
}<br />
}<br />
</source><br />
<br />
=== Последовательная сложность алгоритма ===<br />
<br />
Под сложностью будем понимать зависимость числа операций от задаваемого порядка матрицы <math>n</math>. <br />
<br />
Основными операциями алгоритма являются:<br />
<br />
* <math>\frac{n}{2}-2</math> операций умножения;<br />
* <math>\frac{n}{2}-2</math> операций взятия остатка;<br />
* <math>n^2+\frac{5}{2}n-3</math> операций присваивания.<br />
<br />
Из чего следует, что алгоритм имеет квадратичную последовательную сложность.<br />
<br />
=== Информационный граф ===<br />
<br />
Информационный граф алгоритма можно представить в виде четырёх последовательных блоков. Первый блок содержит <math>n-1</math> параллельных ветвей, второй блок - <math>\frac{n}{2}-1</math> параллельных ветвей, третий - <math>n-1</math> и четвёртый - <math>n^2</math>.<br />
<br />
[[Файл:i_graph2.png|600px|thumb|center]]<br />
<br />
Каждая вершина из <math>A_1-A_{n-1}</math>, <math>C_1-C_{n-1}</math>, <math>D_1-D_{n^2}</math> соответствует операции присваивания, каждая вершина из <math>B_1-B_{\frac{n}{2}-1}</math> соответствует трём последовательным операциям: умножения, взятия остатка по модулю и присваивания, а вершины, окрашенные серым, представляют собой промежуточные точки синхронизации.<br />
<br />
[[Файл:i_graph3.jpg|600px|thumb|center|Информационный граф для n=4.]]<br />
На рисунке приведен информационный граф алгоритма для случая n=4. Вершины графа соответствуют следующим строчкам кода:<br />
<br />
a. residues[i] = -1;<br />
<br />
b. residues[i*i%p] = 1;<br />
<br />
c. residues[i] = residues[i-p];<br />
<br />
d. result[0][j] = 1;<br />
<br />
e. result[i][0] = 1;<br />
<br />
f. result[i][j] = residues[i-j+p];<br />
<br />
=== Ресурс параллелизма алгоритма ===<br />
<br />
Как видно из информационного графа алгоритма, в параллельном варианте необходимо последовательно выполнить следующие блоки:<br />
<br />
* <math>n-1</math> операций присваивания;<br />
* <math>\frac{n}{2}-1</math> участков, состоящих из трёх операций: умножения, взятия остатка и присваивания;<br />
* <math>n-1</math> операций присваивания;<br />
* <math>n^2</math> операций присваивания.<br />
<br />
Из этого можно сделать вывод, что высота ярусно-параллельной формы информационного графа равняется 6 (присваивание, умножение, взятие остатка, присваивание, присваивание, присваивание). Ширина ярусно-параллельной формы равняется <math>n^2</math>, что означает, что при использовании <math>n^2</math> процессоров матрица Адамара будет строиться за 6 операций.<br />
<br />
=== Входные и выходные данные алгоритма ===<br />
<br />
'''Входные данные:''' число <math>n</math> - порядок матрицы Адамара <math>H_n</math>. Дополнительные ограничения на <math>n</math>:<br />
* <math>n</math> - натуральное;<br />
* <math>n</math> делится на 4;<br />
* <math>n-1</math> - простое.<br />
'''Объем входных данных:''' 1 (число <math>n</math>).<br />
<br />
'''Выходные данные:''' построенная матрица Адамара <math>H_n</math> (её элементы <math>h_{ij}</math>).<br />
<br />
'''Объем выходных данных:''' <math>n^2</math> (количество элементов матрицы Адамара размера <math>n*n</math>).<br />
<br />
=== Свойства алгоритма ===<br />
<br />
Соотношение последовательной и параллельной сложности в случае неограниченных ресурсов является квадратичным. <br />
<br />
Вычислительная мощность алгоритма является постоянной (<math>O(1)</math>). <br />
<br />
Алгоритм является полностью детерминированным. <br />
<br />
Для вершин <math>A_1-A_{n-1}</math>, <math>B_1-B_{\frac{n}{2}-1}</math>, <math>C_1-C_{n-1}</math> информационного графа степени исхода являются линейными, что означает, что при возможности на этапе реализации необходимо позаботиться об эффективном доступе к элементам массива "<math>residues</math>".<br />
<br />
== Программная реализация алгоритма ==<br />
<br />
=== Особенности реализации последовательного алгоритма ===<br />
<br />
=== Локальность данных и вычислений ===<br />
<br />
=== Возможные способы и особенности параллельной реализации алгоритма ===<br />
<br />
=== Масштабируемость алгоритма и его реализации ===<br />
<br />
<br />
Исследование масштабируемости параллельной реализации алгоритма построения матрицы Адамара проводилось на суперкомпьютере «Ломоносов». Для этого была исследована собственная реализация алгоритма с использованием средств MPI. В ходе исследования было произведено множество запусков программы с различными значениями параметра <math>n</math> (размер матрицы Адамара) и числом процессоров.<br />
<br />
Набор и границы значений изменяемых параметров запуска реализации алгоритма:<br />
*число процессоров (p): [2,64] с шагом 2;<br />
*размер матрицы: простые числа в диапазоне [4,10000].<br />
<br />
В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:<br />
*минимальная эффективность реализации 0.0000036% при n=4, p=2;<br />
*максимальная эффективность реализации 0.333426% при n=948, p=2.<br />
<br />
Ниже представлены графики времени работы, производительности и эффективности данной реализации алгоритма построения матрицы Адамара в зависимости от изменяемых параметров запуска.<br />
[[Файл:time_graph1.png|500px|thumb|center|Время работы параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]<br />
[[Файл:perform_graph1.png|500px|thumb|center|Изменение производительности параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]<br />
[[Файл:efficiency_graph1.png|500px|thumb|center|Эффективность работы параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]<br />
<br />
<br />
[https://github.com/snikersman/Hadamard Исследованная параллельная реализация на языке C++]<br />
<br />
Построим оценки масштабируемости, используя полученные результаты:<br />
*По размерности задачи. Увеличение размерности задачи приводит к увеличению производительности.<br />
*По числу процессоров. С ростом числа процессоров растет производительность, но при малых размерностях задачи этот рост незначителен. Это связано с дополнительными издержками по записи в участок памяти каждого процессора вспомогательного массива вычетов, а также с обменом информации между процессорами.<br />
*По двум направлениям. При увеличении как числа процессоров, так и размерности задачи, производительность увеличивается. Причем чем больше используется процессоров, тем сильнее увеличивается производительность при увеличении размерности.<br />
<br />
=== Динамические характеристики и эффективность реализации алгоритма ===<br />
<br />
=== Выводы для классов архитектур ===<br />
<br />
=== Существующие реализации алгоритма ===<br />
<br />
Алгоритм построения матрицы Адамара реализован в различных математических пакетах и библиотеках: <br />
* [https://www.mathworks.com/help/matlab/ref/hadamard.html?requestedDomain=www.mathworks.com MATLAB] (вносятся дополнительные ограничения, когда n, или n/12, или n/20 являются степенями по основанию 2)<br />
* [http://r-survey.r-forge.r-project.org/survey/html/hadamard.html R]<br />
* [https://reference.wolframcloud.com/cloudplatform/ref/HadamardMatrix.html Wolfram Mathematica]<br />
* [http://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.linalg.hadamard.html SciPy для Python]<br />
<br />
== Литература ==<br />
<br />
<br />
[[Категория:Статьи в работе]]</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%BF%D0%BE%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D0%BD%D0%BE%D0%B3%D0%BE_%D0%BF%D0%BE%D1%81%D1%82%D1%80%D0%BE%D0%B5%D0%BD%D0%B8%D1%8F_%D0%BC%D0%B0%D1%82%D1%80%D0%B8%D1%86%D1%8B_%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80%D0%B0_%D1%80%D0%B0%D0%B7%D0%BC%D0%B5%D1%80%D0%BD%D0%BE%D1%81%D1%82%D0%B8_%D1%81%D1%82%D0%B5%D0%BF%D0%B5%D0%BD%D0%B8_2&diff=22603Алгоритм поэлементного построения матрицы Адамара размерности степени 22017-05-03T20:49:04Z<p>Chernyavskiy: </p>
<hr />
<div>Основные авторы описания: [[U:Бугаков Юрий|Ю.Бугаков]], Е. Кужамалиев, [[Участник:Chernyavskiy|А.Ю.Чернявский]] (редактирование), С.Н. Леоненков (предварительная проверка)<br />
<br />
{{algorithm<br />
| name = Построение матрицы Адамара<br />
| serial_complexity = <math>O( \left[ \frac{n}{4}\right]\,2^{2n})</math><br />
| pf_height = <math>O(1)</math><br />
| pf_width = <math>O(2^{2n})</math><br />
| input_data = <math>1</math><br />
| output_data = <math>2^{2n}</math><br />
}}<br />
<br />
== Свойства и структура алгоритма ==<br />
<br />
=== Общее описание алгоритма ===<br />
<br />
Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.<br />
<br />
Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие<br />
<br />
:<math> H_m\,H_m^T = m\,E_m </math><br />
<br />
Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны <ref>Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.</ref>. Также, можно увидеть из определения, что m четно и<br />
:<math><br />
H_{2m} =<br />
\begin{pmatrix}<br />
H_{m} & H_{m}\\<br />
H_{m} & -H_{m}\end{pmatrix}<br />
</math><br />
<br />
С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).<br />
<br />
Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 <ref>Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2</ref><ref name="kunz"> Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]</ref><ref name="wiki">Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).</ref>). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара следующим образом:<br />
<br />
<br />
<br />
'''Матрица Адамара ''H''<sub>''n''</sub> - это матрица размера 2<sup>''n''</sup>&nbsp;&times;&nbsp;2<sup>''n''</sup>, для которой справедливо равенство'''<br />
<br />
:<math>H_n = H_{1} \otimes H_{n-1}</math>,<br />
<br />
:<math>\begin{align}<br />
H_1 = \frac{1}{\sqrt2}<br />
&\begin{pmatrix}\begin{array}{rr}<br />
1 & 1\\<br />
1 & -1<br />
\end{array}\end{pmatrix}<br />
\end{align}</math>,<br />
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''<br />
<br />
Представим некоторые частные примеры матриц Адамара:<br />
<br />
:<math><br />
H_0 = +1,<br />
</math><br />
<br />
:<math><br />
H_1 = \frac{1}{\sqrt2}<br />
\begin{pmatrix}\begin{array}{rr}<br />
1 & 1\\<br />
1 & -1<br />
\end{array}\end{pmatrix}<br />
</math>,<br />
<br />
:<math><br />
H_2 = \frac{1}{2}<br />
\begin{pmatrix}\begin{array}{rrrr}<br />
1 & 1 & 1 & 1\\<br />
1 & -1 & 1 & -1\\<br />
1 & 1 & -1 & -1\\<br />
1 & -1 & -1 & 1<br />
\end{array}\end{pmatrix}<br />
</math>,<br />
<br />
:<math><br />
H_3 = \frac{1}{2^{\frac{3}{2}}}<br />
\begin{pmatrix}\begin{array}{rrrrrrrr}<br />
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\<br />
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\<br />
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\<br />
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\<br />
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\<br />
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\<br />
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\<br />
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\<br />
\end{array}\end{pmatrix}<br />
</math>.<br />
<br />
=== Математическое описание алгоритма ===<br />
<br />
Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> можно вычислить поэлементно<ref name="kunz"/><ref name="wiki"/>:<br />
<br />
:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,<br />
<br />
где ''k''<sub>''j''</sub> и ''l''<sub>''j''</sub> коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):<br />
<br />
: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math><br />
<br />
и<br />
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.<br />
<br />
Помимо этой формулы чаще всего используется заполнение по определению. В связи с трудностями распараллеливания и постоянного выделения памяти при каждом шаге рекурсивного вызова этого метода, был выбран предыдущий способ вычисления.<br />
<br />
=== Вычислительное ядро алгоритма ===<br />
<br />
Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.<br />
<br />
=== Макроструктура алгоритма ===<br />
<br />
Основную часть метода составляют вычисления значений степени -1 для каждого элемента:<br />
<br />
: <math>\sum_{j=0}^n k_j l_j</math>.<br />
<br />
Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.<br />
<br />
=== Схема реализации последовательного алгоритма ===<br />
<br />
Последовательность исполнения метода следующая:<br />
<br />
1. Побитовое умножение <math>k\&l</math>; <br />
<br />
2. Вычисление количества единиц двоичной записи;<br />
<br />
3. Определение знака элемента по степени.<br />
<br />
=== Последовательная сложность алгоритма ===<br />
<br />
Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.<br />
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма <math> T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}. </math><br />
<br />
=== Информационный граф ===<br />
<br />
На рисунке ниже изображен информационный граф <ref>Воеводин В.В.. Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.</ref> алгоритма.<br />
<br />
*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;<br />
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;<br />
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный. <br />
<br />
[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]<br />
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]<br />
<br />
=== Ресурс параллелизма алгоритма ===<br />
<br />
Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:<br />
* <math>N^2</math> вычислений побитового умножения,<br />
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,<br />
* <math>N^2</math> для определения знака значения элемента.<br />
<br />
Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.<br />
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна <math>O(2^{2n})</math>.<br />
<br />
=== Входные и выходные данные алгоритма ===<br />
<br />
'''Входные данные''': натуральное число <math> n \in \N </math> - размерность матрицы Адамара <math>H_n</math>.<br />
<br />
'''Объём входных данных''': 1 (натуральное число <math> n </math>).<br />
<br />
'''Выходные данные''': матрица Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> (элементы <math>h_{ij}</math>).<br />
<br />
'''Объём выходных данных''': <math>2^{2n}</math>, где <math> n </math> - размерность матрицы Адамара. Стоит заметить, что в силу симметричности или самого определения матрицы Адамара, достаточно хранить не все элементы матрицы, а только их часть.<br />
<br />
=== Свойства алгоритма ===<br />
<br />
* Соотношение последовательной и параллельной сложности:<br />
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом: <math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.<br />
<br />
Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.<br />
<br />
Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.<br />
:<math>\frac{T(n)}{T(n,P)}=P</math>.<br />
То есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;<br />
<br />
* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных: <br />
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right)</math>;<br />
<br />
* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размера 2<sup>''n''</sup>&nbsp;&times;&nbsp;2<sup>''n''</sup>);<br />
<br />
* Степень исхода вершины информационного графа равна 1;<br />
<br />
* Алгоритм построения матрицы Адамара является ''сбалансированным''. Так как количество вершин на разных процессорах одинаково, то алгоритм является сбалансированным по числу операций на каждом процессоре.<br />
<br />
=ЧАСТЬ Программная реализация алгоритма =<br />
<br />
== Особенности реализации последовательного алгоритма ==<br />
<br />
В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:<br />
<br />
<source lang="C"><br />
void adamar(int** H, int n) // N = 2^n - размерность матрицы<br />
{ <br />
int i,j,N;<br />
float h;<br />
h = pow(1/2,n/2); // h - нормализующий множитель<br />
N = pow(2,n);<br />
<br />
for(i=0;i<N;++i) <br />
{<br />
for(j=0;j<N;++j)<br />
{<br />
ij = i & j;<br />
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij<br />
if(l%2==0) H[i][j] = h;<br />
else H[i][j] = -h;<br />
}<br />
}<br />
}<br />
</source><br />
<br />
Также существует рекурсивная реализация метода построения матрицы Адамара<br />
<br />
<source lang="C"><br />
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель<br />
{<br />
if(n==1) H[i][j] = h;<br />
else<br />
{<br />
adamar(H, N/2, i, j, h);<br />
adamar(H, N/2, i, N/2+j, h);<br />
adamar(H, N/2, N/2+i, j, h);<br />
adamar(H, N/2, N/2+i, N/2+j, -h);<br />
}<br />
}<br />
</source><br />
<br />
Или эквивалентный безрекурсивный вариант:<br />
<br />
<source lang="C"><br />
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы<br />
{ <br />
int i,j,N;<br />
float h;<br />
h = pow(1/2,n/2);<br />
N = pow(2,n);<br />
k=2;<br />
H[0][0] = h;<br />
<br />
while(k<=N)<br />
{<br />
for (i=0; i<k; ++i)<br />
{<br />
for (j=0; j<k; ++j)<br />
{<br />
if (i<k/2 && j<k/2)<br />
{<br />
}<br />
else<br />
{<br />
if(i>=k/2 && j>=k/2)<br />
{<br />
H[i][j] = -(H[i-k/2][j-k/2]);<br />
}<br />
else<br />
{<br />
if (i>j)<br />
{<br />
H[i][j] = H[i-k/2][j];<br />
}<br />
else<br />
{<br />
H[i][j] = H[i][j-k/2];<br />
}<br />
}<br />
}<br />
}<br />
}<br />
<br />
k=k*2;<br />
}<br />
}<br />
</source><br />
<br />
Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у распараллелинной adamar_not_recursion (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).<br />
<br />
== Локальность данных и вычислений ==<br />
<br />
== Возможные способы и особенности параллельной реализации алгоритма ==<br />
<br />
== Масштабируемость алгоритма и его реализации ==<br />
Исследование проводилось на суперкомпьютере "Blue Gene".<br />
<br />
Набор и границы значений изменяемых параметров запуска реализации алгоритма: <br />
<br />
* число процессоров [1, 2, 4, 8,..., 1024] ;<br />
* размер матрицы [2, 4, 8,..., 2048].<br />
<br />
В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:<br />
<br />
* минимальная эффективность реализации 0.0121%;<br />
* максимальная эффективность реализации 3.3003%.<br />
<br />
На следующих рисунках приведены графики производительности и эффективности выбранной реализации построение матрицы Адамара в зависимости от изменяемых параметров запуска.<br />
<br />
[[file:Prois1.jpg|thumb|center|700px|Рис.5 Изменение производительности в зависимости от числа процессоров и размера матрицы.]]<br />
[[file:Effec1.jpg|thumb|center|700px|Рис.5 Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]<br />
<br />
Построим оценки масштабируемости выбранной реализации:<br />
* При увеличении числа процессов производительность на рассмотренной области изменений параметров запуска увеличивается практически линейно. В следствии этого эффективность реализации, как видно по графику, перестает изменяться при увеличении числа процессоров и равна примерно 1,7%.<br />
* При увеличении размера матрицы производительность на рассмотренной области изменений параметров запуска увеличивается логарифмически. Это связанно с тем, что количество операций зависит от количества единиц после бинарного произведения. Поэтому наиболее влияет порядок степени <math>n</math> размера матрицы <math>N=2^{n}</math>. При увеличении размера матрицы эффективность также увеличивается, но скорость возрастания уменьшается.<br />
По двум направлениям: При рассмотрении увеличения как вычислительной сложности, так и числа процессов на всей рассмотренной области значений эффективность увеличивается, однако скорость увеличения эффективности небольшая.<br />
<br />
== Динамические характеристики и эффективность реализации алгоритма ==<br />
<br />
== Выводы для классов архитектур ==<br />
<br />
== Существующие реализации алгоритма ==<br />
<br />
Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:<br />
<br />
# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];<br />
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];<br />
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];<br />
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave].<br />
<br />
Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах: <br />
# [https://ru.wikipedia.org/wiki/Maple MAPLE];<br />
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH].<br />
<br />
= Литература =<br />
<br />
<br />
<br />
[[Категория:Статьи в работе]]</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%BF%D0%BE%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D0%BD%D0%BE%D0%B3%D0%BE_%D0%BF%D0%BE%D1%81%D1%82%D1%80%D0%BE%D0%B5%D0%BD%D0%B8%D1%8F_%D0%BC%D0%B0%D1%82%D1%80%D0%B8%D1%86%D1%8B_%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80%D0%B0_%D1%80%D0%B0%D0%B7%D0%BC%D0%B5%D1%80%D0%BD%D0%BE%D1%81%D1%82%D0%B8_%D1%81%D1%82%D0%B5%D0%BF%D0%B5%D0%BD%D0%B8_2&diff=22602Алгоритм поэлементного построения матрицы Адамара размерности степени 22017-05-03T20:47:53Z<p>Chernyavskiy: /* Литература */</p>
<hr />
<div>Основные авторы описания: [[U:Бугаков Юрий|Ю.Бугаков]], Е. Кужамалиев, [[Участник:Chernyavskiy|А.Ю.Чернявский]] (редактирование), С.Н. Леоненков (предварительная проверка)<br />
<br />
{{algorithm<br />
| name = Построение матрицы Адамара<br />
| serial_complexity = <math>O( \left[ \frac{n}{4}\right]\,2^{2n})</math><br />
| pf_height = <math>O(1)</math><br />
| pf_width = <math>O(2^{2n})</math><br />
| input_data = <math>1</math><br />
| output_data = <math>2^{2n}</math><br />
}}<br />
<br />
== Свойства и структура алгоритма ==<br />
<br />
=== Общее описание алгоритма ===<br />
<br />
Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.<br />
<br />
Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие<br />
<br />
:<math> H_m\,H_m^T = m\,E_m </math><br />
<br />
Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны <ref>Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.</ref>. Также, можно увидеть из определения, что m четно и<br />
:<math><br />
H_{2m} =<br />
\begin{pmatrix}<br />
H_{m} & H_{m}\\<br />
H_{m} & -H_{m}\end{pmatrix}<br />
</math><br />
<br />
С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).<br />
<br />
Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 <ref>Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2</ref><ref name="kunz"> Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]</ref><ref name="wiki">Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).</ref>). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара следующим образом:<br />
<br />
<br />
<br />
'''Матрица Адамара ''H''<sub>''n''</sub> - это матрица размера 2<sup>''n''</sup>&nbsp;&times;&nbsp;2<sup>''n''</sup>, для которой справедливо равенство'''<br />
<br />
:<math>H_n = H_{1} \otimes H_{n-1}</math>,<br />
<br />
:<math>\begin{align}<br />
H_1 = \frac{1}{\sqrt2}<br />
&\begin{pmatrix}\begin{array}{rr}<br />
1 & 1\\<br />
1 & -1<br />
\end{array}\end{pmatrix}<br />
\end{align}</math>,<br />
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''<br />
<br />
Представим некоторые частные примеры матриц Адамара:<br />
<br />
:<math><br />
H_0 = +1,<br />
</math><br />
<br />
:<math><br />
H_1 = \frac{1}{\sqrt2}<br />
\begin{pmatrix}\begin{array}{rr}<br />
1 & 1\\<br />
1 & -1<br />
\end{array}\end{pmatrix}<br />
</math>,<br />
<br />
:<math><br />
H_2 = \frac{1}{2}<br />
\begin{pmatrix}\begin{array}{rrrr}<br />
1 & 1 & 1 & 1\\<br />
1 & -1 & 1 & -1\\<br />
1 & 1 & -1 & -1\\<br />
1 & -1 & -1 & 1<br />
\end{array}\end{pmatrix}<br />
</math>,<br />
<br />
:<math><br />
H_3 = \frac{1}{2^{\frac{3}{2}}}<br />
\begin{pmatrix}\begin{array}{rrrrrrrr}<br />
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\<br />
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\<br />
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\<br />
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\<br />
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\<br />
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\<br />
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\<br />
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\<br />
\end{array}\end{pmatrix}<br />
</math>.<br />
<br />
=== Математическое описание алгоритма ===<br />
<br />
Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> можно вычислить поэлементно<ref name="kunz"/><ref name="wiki"/>:<br />
<br />
:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,<br />
<br />
где ''k''<sub>''j''</sub> и ''l''<sub>''j''</sub> коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):<br />
<br />
: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math><br />
<br />
и<br />
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.<br />
<br />
Помимо этой формулы чаще всего используется заполнение по определению. В связи с трудностями распараллеливания и постоянного выделения памяти при каждом шаге рекурсивного вызова этого метода, был выбран предыдущий способ вычисления.<br />
<br />
=== Вычислительное ядро алгоритма ===<br />
<br />
Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.<br />
<br />
=== Макроструктура алгоритма ===<br />
<br />
Основную часть метода составляют вычисления значений степени -1 для каждого элемента:<br />
<br />
: <math>\sum_{j=0}^n k_j l_j</math>.<br />
<br />
Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.<br />
<br />
=== Схема реализации последовательного алгоритма ===<br />
<br />
Последовательность исполнения метода следующая:<br />
<br />
1. Побитовое умножение <math>k\&l</math>; <br />
<br />
2. Вычисление количества единиц двоичной записи;<br />
<br />
3. Определение знака элемента по степени.<br />
<br />
=== Последовательная сложность алгоритма ===<br />
<br />
Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.<br />
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма <math> T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}. </math><br />
<br />
=== Информационный граф ===<br />
<br />
На рисунке ниже изображен информационный граф <ref>Воеводин В.В.. Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.</ref> алгоритма.<br />
<br />
*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;<br />
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;<br />
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный. <br />
<br />
[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]<br />
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]<br />
<br />
=== Ресурс параллелизма алгоритма ===<br />
<br />
Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:<br />
* <math>N^2</math> вычислений побитового умножения,<br />
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,<br />
* <math>N^2</math> для определения знака значения элемента.<br />
<br />
Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.<br />
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна <math>O(2^{2n})</math>.<br />
<br />
=== Входные и выходные данные алгоритма ===<br />
<br />
'''Входные данные''': натуральное число <math> n \in \N </math> - размерность матрицы Адамара <math>H_n</math>.<br />
<br />
'''Объём входных данных''': 1 (натуральное число <math> n </math>).<br />
<br />
'''Выходные данные''': матрица Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> (элементы <math>h_{ij}</math>).<br />
<br />
'''Объём выходных данных''': <math>2^{2n}</math>, где <math> n </math> - размерность матрицы Адамара. Стоит заметить, что в силу симметричности или самого определения матрицы Адамара, достаточно хранить не все элементы матрицы, а только их часть.<br />
<br />
=== Свойства алгоритма ===<br />
<br />
* Соотношение последовательной и параллельной сложности:<br />
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом: <math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.<br />
<br />
Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.<br />
<br />
Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.<br />
:<math>\frac{T(n)}{T(n,P)}=P</math>.<br />
То есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;<br />
<br />
* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных: <br />
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right)</math>;<br />
<br />
* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размера 2<sup>''n''</sup>&nbsp;&times;&nbsp;2<sup>''n''</sup>);<br />
<br />
* Степень исхода вершины информационного графа равна 1;<br />
<br />
* Алгоритм построения матрицы Адамара является ''сбалансированным''. Так как количество вершин на разных процессорах одинаково, то алгоритм является сбалансированным по числу операций на каждом процессоре.<br />
<br />
=ЧАСТЬ Программная реализация алгоритма =<br />
<br />
== Особенности реализации последовательного алгоритма ==<br />
<br />
В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:<br />
<br />
<source lang="C"><br />
void adamar(int** H, int n) // N = 2^n - размерность матрицы<br />
{ <br />
int i,j,N;<br />
float h;<br />
h = pow(1/2,n/2); // h - нормализующий множитель<br />
N = pow(2,n);<br />
<br />
for(i=0;i<N;++i) <br />
{<br />
for(j=0;j<N;++j)<br />
{<br />
ij = i & j;<br />
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij<br />
if(l%2==0) H[i][j] = h;<br />
else H[i][j] = -h;<br />
}<br />
}<br />
}<br />
</source><br />
<br />
Также существует рекурсивная реализация метода построения матрицы Адамара<br />
<br />
<source lang="C"><br />
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель<br />
{<br />
if(n==1) H[i][j] = h;<br />
else<br />
{<br />
adamar(H, N/2, i, j, h);<br />
adamar(H, N/2, i, N/2+j, h);<br />
adamar(H, N/2, N/2+i, j, h);<br />
adamar(H, N/2, N/2+i, N/2+j, -h);<br />
}<br />
}<br />
</source><br />
<br />
Или эквивалентный безрекурсивный вариант:<br />
<br />
<source lang="C"><br />
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы<br />
{ <br />
int i,j,N;<br />
float h;<br />
h = pow(1/2,n/2);<br />
N = pow(2,n);<br />
k=2;<br />
H[0][0] = h;<br />
<br />
while(k<=N)<br />
{<br />
for (i=0; i<k; ++i)<br />
{<br />
for (j=0; j<k; ++j)<br />
{<br />
if (i<k/2 && j<k/2)<br />
{<br />
}<br />
else<br />
{<br />
if(i>=k/2 && j>=k/2)<br />
{<br />
H[i][j] = -(H[i-k/2][j-k/2]);<br />
}<br />
else<br />
{<br />
if (i>j)<br />
{<br />
H[i][j] = H[i-k/2][j];<br />
}<br />
else<br />
{<br />
H[i][j] = H[i][j-k/2];<br />
}<br />
}<br />
}<br />
}<br />
}<br />
<br />
k=k*2;<br />
}<br />
}<br />
</source><br />
<br />
Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у распараллелинной adamar_not_recursion (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).<br />
<br />
== Локальность данных и вычислений ==<br />
<br />
== Возможные способы и особенности параллельной реализации алгоритма ==<br />
<br />
== Масштабируемость алгоритма и его реализации ==<br />
Исследование проводилось на суперкомпьютере "Blue Gene".<br />
<br />
Набор и границы значений изменяемых параметров запуска реализации алгоритма: <br />
<br />
* число процессоров [1, 2, 4, 8,..., 1024] ;<br />
* размер матрицы [2, 4, 8,..., 2048].<br />
<br />
В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:<br />
<br />
* минимальная эффективность реализации 0.0121%;<br />
* максимальная эффективность реализации 3.3003%.<br />
<br />
На следующих рисунках приведены графики производительности и эффективности выбранной реализации построение матрицы Адамара в зависимости от изменяемых параметров запуска.<br />
<br />
[[file:Prois1.jpg|thumb|center|700px|Рис.5 Изменение производительности в зависимости от числа процессоров и размера матрицы.]]<br />
[[file:Effec1.jpg|thumb|center|700px|Рис.5 Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]<br />
<br />
Построим оценки масштабируемости выбранной реализации:<br />
* При увеличении числа процессов производительность на рассмотренной области изменений параметров запуска увеличивается практически линейно. В следствии этого эффективность реализации, как видно по графику, перестает изменяться при увеличении числа процессоров и равна примерно 1,7%.<br />
* При увеличении размера матрицы производительность на рассмотренной области изменений параметров запуска увеличивается логарифмически. Это связанно с тем, что количество операций зависит от количества единиц после бинарного произведения. Поэтому наиболее влияет порядок степени <math>n</math> размера матрицы <math>N=2^{n}</math>. При увеличении размера матрицы эффективность также увеличивается, но скорость возрастания уменьшается.<br />
По двум направлениям: При рассмотрении увеличения как вычислительной сложности, так и числа процессов на всей рассмотренной области значений эффективность увеличивается, однако скорость увеличения эффективности небольшая.<br />
<br />
== Динамические характеристики и эффективность реализации алгоритма ==<br />
<br />
== Выводы для классов архитектур ==<br />
<br />
== Существующие реализации алгоритма ==<br />
<br />
Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:<br />
<br />
# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];<br />
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];<br />
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];<br />
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave].<br />
<br />
Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах: <br />
# [https://ru.wikipedia.org/wiki/Maple MAPLE];<br />
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH].<br />
<br />
= Литература =</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%BF%D0%BE%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D0%BD%D0%BE%D0%B3%D0%BE_%D0%BF%D0%BE%D1%81%D1%82%D1%80%D0%BE%D0%B5%D0%BD%D0%B8%D1%8F_%D0%BC%D0%B0%D1%82%D1%80%D0%B8%D1%86%D1%8B_%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80%D0%B0_%D1%80%D0%B0%D0%B7%D0%BC%D0%B5%D1%80%D0%BD%D0%BE%D1%81%D1%82%D0%B8_%D1%81%D1%82%D0%B5%D0%BF%D0%B5%D0%BD%D0%B8_2&diff=22601Алгоритм поэлементного построения матрицы Адамара размерности степени 22017-05-03T20:47:32Z<p>Chernyavskiy: /* Информационный граф */</p>
<hr />
<div>Основные авторы описания: [[U:Бугаков Юрий|Ю.Бугаков]], Е. Кужамалиев, [[Участник:Chernyavskiy|А.Ю.Чернявский]] (редактирование), С.Н. Леоненков (предварительная проверка)<br />
<br />
{{algorithm<br />
| name = Построение матрицы Адамара<br />
| serial_complexity = <math>O( \left[ \frac{n}{4}\right]\,2^{2n})</math><br />
| pf_height = <math>O(1)</math><br />
| pf_width = <math>O(2^{2n})</math><br />
| input_data = <math>1</math><br />
| output_data = <math>2^{2n}</math><br />
}}<br />
<br />
== Свойства и структура алгоритма ==<br />
<br />
=== Общее описание алгоритма ===<br />
<br />
Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.<br />
<br />
Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие<br />
<br />
:<math> H_m\,H_m^T = m\,E_m </math><br />
<br />
Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны <ref>Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.</ref>. Также, можно увидеть из определения, что m четно и<br />
:<math><br />
H_{2m} =<br />
\begin{pmatrix}<br />
H_{m} & H_{m}\\<br />
H_{m} & -H_{m}\end{pmatrix}<br />
</math><br />
<br />
С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).<br />
<br />
Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 <ref>Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2</ref><ref name="kunz"> Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]</ref><ref name="wiki">Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).</ref>). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара следующим образом:<br />
<br />
<br />
<br />
'''Матрица Адамара ''H''<sub>''n''</sub> - это матрица размера 2<sup>''n''</sup>&nbsp;&times;&nbsp;2<sup>''n''</sup>, для которой справедливо равенство'''<br />
<br />
:<math>H_n = H_{1} \otimes H_{n-1}</math>,<br />
<br />
:<math>\begin{align}<br />
H_1 = \frac{1}{\sqrt2}<br />
&\begin{pmatrix}\begin{array}{rr}<br />
1 & 1\\<br />
1 & -1<br />
\end{array}\end{pmatrix}<br />
\end{align}</math>,<br />
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''<br />
<br />
Представим некоторые частные примеры матриц Адамара:<br />
<br />
:<math><br />
H_0 = +1,<br />
</math><br />
<br />
:<math><br />
H_1 = \frac{1}{\sqrt2}<br />
\begin{pmatrix}\begin{array}{rr}<br />
1 & 1\\<br />
1 & -1<br />
\end{array}\end{pmatrix}<br />
</math>,<br />
<br />
:<math><br />
H_2 = \frac{1}{2}<br />
\begin{pmatrix}\begin{array}{rrrr}<br />
1 & 1 & 1 & 1\\<br />
1 & -1 & 1 & -1\\<br />
1 & 1 & -1 & -1\\<br />
1 & -1 & -1 & 1<br />
\end{array}\end{pmatrix}<br />
</math>,<br />
<br />
:<math><br />
H_3 = \frac{1}{2^{\frac{3}{2}}}<br />
\begin{pmatrix}\begin{array}{rrrrrrrr}<br />
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\<br />
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\<br />
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\<br />
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\<br />
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\<br />
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\<br />
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\<br />
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\<br />
\end{array}\end{pmatrix}<br />
</math>.<br />
<br />
=== Математическое описание алгоритма ===<br />
<br />
Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> можно вычислить поэлементно<ref name="kunz"/><ref name="wiki"/>:<br />
<br />
:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,<br />
<br />
где ''k''<sub>''j''</sub> и ''l''<sub>''j''</sub> коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):<br />
<br />
: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math><br />
<br />
и<br />
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.<br />
<br />
Помимо этой формулы чаще всего используется заполнение по определению. В связи с трудностями распараллеливания и постоянного выделения памяти при каждом шаге рекурсивного вызова этого метода, был выбран предыдущий способ вычисления.<br />
<br />
=== Вычислительное ядро алгоритма ===<br />
<br />
Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.<br />
<br />
=== Макроструктура алгоритма ===<br />
<br />
Основную часть метода составляют вычисления значений степени -1 для каждого элемента:<br />
<br />
: <math>\sum_{j=0}^n k_j l_j</math>.<br />
<br />
Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.<br />
<br />
=== Схема реализации последовательного алгоритма ===<br />
<br />
Последовательность исполнения метода следующая:<br />
<br />
1. Побитовое умножение <math>k\&l</math>; <br />
<br />
2. Вычисление количества единиц двоичной записи;<br />
<br />
3. Определение знака элемента по степени.<br />
<br />
=== Последовательная сложность алгоритма ===<br />
<br />
Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.<br />
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма <math> T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}. </math><br />
<br />
=== Информационный граф ===<br />
<br />
На рисунке ниже изображен информационный граф <ref>Воеводин В.В.. Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.</ref> алгоритма.<br />
<br />
*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;<br />
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;<br />
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный. <br />
<br />
[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]<br />
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]<br />
<br />
=== Ресурс параллелизма алгоритма ===<br />
<br />
Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:<br />
* <math>N^2</math> вычислений побитового умножения,<br />
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,<br />
* <math>N^2</math> для определения знака значения элемента.<br />
<br />
Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.<br />
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна <math>O(2^{2n})</math>.<br />
<br />
=== Входные и выходные данные алгоритма ===<br />
<br />
'''Входные данные''': натуральное число <math> n \in \N </math> - размерность матрицы Адамара <math>H_n</math>.<br />
<br />
'''Объём входных данных''': 1 (натуральное число <math> n </math>).<br />
<br />
'''Выходные данные''': матрица Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> (элементы <math>h_{ij}</math>).<br />
<br />
'''Объём выходных данных''': <math>2^{2n}</math>, где <math> n </math> - размерность матрицы Адамара. Стоит заметить, что в силу симметричности или самого определения матрицы Адамара, достаточно хранить не все элементы матрицы, а только их часть.<br />
<br />
=== Свойства алгоритма ===<br />
<br />
* Соотношение последовательной и параллельной сложности:<br />
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом: <math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.<br />
<br />
Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.<br />
<br />
Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.<br />
:<math>\frac{T(n)}{T(n,P)}=P</math>.<br />
То есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;<br />
<br />
* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных: <br />
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right)</math>;<br />
<br />
* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размера 2<sup>''n''</sup>&nbsp;&times;&nbsp;2<sup>''n''</sup>);<br />
<br />
* Степень исхода вершины информационного графа равна 1;<br />
<br />
* Алгоритм построения матрицы Адамара является ''сбалансированным''. Так как количество вершин на разных процессорах одинаково, то алгоритм является сбалансированным по числу операций на каждом процессоре.<br />
<br />
=ЧАСТЬ Программная реализация алгоритма =<br />
<br />
== Особенности реализации последовательного алгоритма ==<br />
<br />
В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:<br />
<br />
<source lang="C"><br />
void adamar(int** H, int n) // N = 2^n - размерность матрицы<br />
{ <br />
int i,j,N;<br />
float h;<br />
h = pow(1/2,n/2); // h - нормализующий множитель<br />
N = pow(2,n);<br />
<br />
for(i=0;i<N;++i) <br />
{<br />
for(j=0;j<N;++j)<br />
{<br />
ij = i & j;<br />
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij<br />
if(l%2==0) H[i][j] = h;<br />
else H[i][j] = -h;<br />
}<br />
}<br />
}<br />
</source><br />
<br />
Также существует рекурсивная реализация метода построения матрицы Адамара<br />
<br />
<source lang="C"><br />
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель<br />
{<br />
if(n==1) H[i][j] = h;<br />
else<br />
{<br />
adamar(H, N/2, i, j, h);<br />
adamar(H, N/2, i, N/2+j, h);<br />
adamar(H, N/2, N/2+i, j, h);<br />
adamar(H, N/2, N/2+i, N/2+j, -h);<br />
}<br />
}<br />
</source><br />
<br />
Или эквивалентный безрекурсивный вариант:<br />
<br />
<source lang="C"><br />
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы<br />
{ <br />
int i,j,N;<br />
float h;<br />
h = pow(1/2,n/2);<br />
N = pow(2,n);<br />
k=2;<br />
H[0][0] = h;<br />
<br />
while(k<=N)<br />
{<br />
for (i=0; i<k; ++i)<br />
{<br />
for (j=0; j<k; ++j)<br />
{<br />
if (i<k/2 && j<k/2)<br />
{<br />
}<br />
else<br />
{<br />
if(i>=k/2 && j>=k/2)<br />
{<br />
H[i][j] = -(H[i-k/2][j-k/2]);<br />
}<br />
else<br />
{<br />
if (i>j)<br />
{<br />
H[i][j] = H[i-k/2][j];<br />
}<br />
else<br />
{<br />
H[i][j] = H[i][j-k/2];<br />
}<br />
}<br />
}<br />
}<br />
}<br />
<br />
k=k*2;<br />
}<br />
}<br />
</source><br />
<br />
Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у распараллелинной adamar_not_recursion (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).<br />
<br />
== Локальность данных и вычислений ==<br />
<br />
== Возможные способы и особенности параллельной реализации алгоритма ==<br />
<br />
== Масштабируемость алгоритма и его реализации ==<br />
Исследование проводилось на суперкомпьютере "Blue Gene".<br />
<br />
Набор и границы значений изменяемых параметров запуска реализации алгоритма: <br />
<br />
* число процессоров [1, 2, 4, 8,..., 1024] ;<br />
* размер матрицы [2, 4, 8,..., 2048].<br />
<br />
В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:<br />
<br />
* минимальная эффективность реализации 0.0121%;<br />
* максимальная эффективность реализации 3.3003%.<br />
<br />
На следующих рисунках приведены графики производительности и эффективности выбранной реализации построение матрицы Адамара в зависимости от изменяемых параметров запуска.<br />
<br />
[[file:Prois1.jpg|thumb|center|700px|Рис.5 Изменение производительности в зависимости от числа процессоров и размера матрицы.]]<br />
[[file:Effec1.jpg|thumb|center|700px|Рис.5 Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]<br />
<br />
Построим оценки масштабируемости выбранной реализации:<br />
* При увеличении числа процессов производительность на рассмотренной области изменений параметров запуска увеличивается практически линейно. В следствии этого эффективность реализации, как видно по графику, перестает изменяться при увеличении числа процессоров и равна примерно 1,7%.<br />
* При увеличении размера матрицы производительность на рассмотренной области изменений параметров запуска увеличивается логарифмически. Это связанно с тем, что количество операций зависит от количества единиц после бинарного произведения. Поэтому наиболее влияет порядок степени <math>n</math> размера матрицы <math>N=2^{n}</math>. При увеличении размера матрицы эффективность также увеличивается, но скорость возрастания уменьшается.<br />
По двум направлениям: При рассмотрении увеличения как вычислительной сложности, так и числа процессов на всей рассмотренной области значений эффективность увеличивается, однако скорость увеличения эффективности небольшая.<br />
<br />
== Динамические характеристики и эффективность реализации алгоритма ==<br />
<br />
== Выводы для классов архитектур ==<br />
<br />
== Существующие реализации алгоритма ==<br />
<br />
Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:<br />
<br />
# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];<br />
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];<br />
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];<br />
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave].<br />
<br />
Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах: <br />
# [https://ru.wikipedia.org/wiki/Maple MAPLE];<br />
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH].<br />
<br />
= Литература =<br />
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.<br />
<br />
[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2<br />
<br />
[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]<br />
<br />
[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).<br />
<br />
[5] Воеводин В.В.. Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.<br />
<br />
[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%BF%D0%BE%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D0%BD%D0%BE%D0%B3%D0%BE_%D0%BF%D0%BE%D1%81%D1%82%D1%80%D0%BE%D0%B5%D0%BD%D0%B8%D1%8F_%D0%BC%D0%B0%D1%82%D1%80%D0%B8%D1%86%D1%8B_%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80%D0%B0_%D1%80%D0%B0%D0%B7%D0%BC%D0%B5%D1%80%D0%BD%D0%BE%D1%81%D1%82%D0%B8_%D1%81%D1%82%D0%B5%D0%BF%D0%B5%D0%BD%D0%B8_2&diff=22600Алгоритм поэлементного построения матрицы Адамара размерности степени 22017-05-03T20:45:10Z<p>Chernyavskiy: Новая страница: «Основные авторы описания: Ю.Бугаков, Е. Кужамалиев, Участник:Chernyavskiy|А.Ю.…»</p>
<hr />
<div>Основные авторы описания: [[U:Бугаков Юрий|Ю.Бугаков]], Е. Кужамалиев, [[Участник:Chernyavskiy|А.Ю.Чернявский]] (редактирование), С.Н. Леоненков (предварительная проверка)<br />
<br />
{{algorithm<br />
| name = Построение матрицы Адамара<br />
| serial_complexity = <math>O( \left[ \frac{n}{4}\right]\,2^{2n})</math><br />
| pf_height = <math>O(1)</math><br />
| pf_width = <math>O(2^{2n})</math><br />
| input_data = <math>1</math><br />
| output_data = <math>2^{2n}</math><br />
}}<br />
<br />
== Свойства и структура алгоритма ==<br />
<br />
=== Общее описание алгоритма ===<br />
<br />
Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.<br />
<br />
Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие<br />
<br />
:<math> H_m\,H_m^T = m\,E_m </math><br />
<br />
Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны <ref>Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.</ref>. Также, можно увидеть из определения, что m четно и<br />
:<math><br />
H_{2m} =<br />
\begin{pmatrix}<br />
H_{m} & H_{m}\\<br />
H_{m} & -H_{m}\end{pmatrix}<br />
</math><br />
<br />
С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).<br />
<br />
Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 <ref>Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2</ref><ref name="kunz"> Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]</ref><ref name="wiki">Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).</ref>). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара следующим образом:<br />
<br />
<br />
<br />
'''Матрица Адамара ''H''<sub>''n''</sub> - это матрица размера 2<sup>''n''</sup>&nbsp;&times;&nbsp;2<sup>''n''</sup>, для которой справедливо равенство'''<br />
<br />
:<math>H_n = H_{1} \otimes H_{n-1}</math>,<br />
<br />
:<math>\begin{align}<br />
H_1 = \frac{1}{\sqrt2}<br />
&\begin{pmatrix}\begin{array}{rr}<br />
1 & 1\\<br />
1 & -1<br />
\end{array}\end{pmatrix}<br />
\end{align}</math>,<br />
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''<br />
<br />
Представим некоторые частные примеры матриц Адамара:<br />
<br />
:<math><br />
H_0 = +1,<br />
</math><br />
<br />
:<math><br />
H_1 = \frac{1}{\sqrt2}<br />
\begin{pmatrix}\begin{array}{rr}<br />
1 & 1\\<br />
1 & -1<br />
\end{array}\end{pmatrix}<br />
</math>,<br />
<br />
:<math><br />
H_2 = \frac{1}{2}<br />
\begin{pmatrix}\begin{array}{rrrr}<br />
1 & 1 & 1 & 1\\<br />
1 & -1 & 1 & -1\\<br />
1 & 1 & -1 & -1\\<br />
1 & -1 & -1 & 1<br />
\end{array}\end{pmatrix}<br />
</math>,<br />
<br />
:<math><br />
H_3 = \frac{1}{2^{\frac{3}{2}}}<br />
\begin{pmatrix}\begin{array}{rrrrrrrr}<br />
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\<br />
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\<br />
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\<br />
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\<br />
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\<br />
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\<br />
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\<br />
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\<br />
\end{array}\end{pmatrix}<br />
</math>.<br />
<br />
=== Математическое описание алгоритма ===<br />
<br />
Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> можно вычислить поэлементно<ref name="kunz"/><ref name="wiki"/>:<br />
<br />
:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,<br />
<br />
где ''k''<sub>''j''</sub> и ''l''<sub>''j''</sub> коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):<br />
<br />
: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math><br />
<br />
и<br />
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.<br />
<br />
Помимо этой формулы чаще всего используется заполнение по определению. В связи с трудностями распараллеливания и постоянного выделения памяти при каждом шаге рекурсивного вызова этого метода, был выбран предыдущий способ вычисления.<br />
<br />
=== Вычислительное ядро алгоритма ===<br />
<br />
Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.<br />
<br />
=== Макроструктура алгоритма ===<br />
<br />
Основную часть метода составляют вычисления значений степени -1 для каждого элемента:<br />
<br />
: <math>\sum_{j=0}^n k_j l_j</math>.<br />
<br />
Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.<br />
<br />
=== Схема реализации последовательного алгоритма ===<br />
<br />
Последовательность исполнения метода следующая:<br />
<br />
1. Побитовое умножение <math>k\&l</math>; <br />
<br />
2. Вычисление количества единиц двоичной записи;<br />
<br />
3. Определение знака элемента по степени.<br />
<br />
=== Последовательная сложность алгоритма ===<br />
<br />
Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.<br />
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма <math> T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}. </math><br />
<br />
=== Информационный граф ===<br />
<br />
На рисунке ниже изображен информационный граф алгоритма.<br />
<br />
*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;<br />
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;<br />
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный. <br />
<br />
[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]<br />
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]<br />
<br />
=== Ресурс параллелизма алгоритма ===<br />
<br />
Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:<br />
* <math>N^2</math> вычислений побитового умножения,<br />
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,<br />
* <math>N^2</math> для определения знака значения элемента.<br />
<br />
Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.<br />
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна <math>O(2^{2n})</math>.<br />
<br />
=== Входные и выходные данные алгоритма ===<br />
<br />
'''Входные данные''': натуральное число <math> n \in \N </math> - размерность матрицы Адамара <math>H_n</math>.<br />
<br />
'''Объём входных данных''': 1 (натуральное число <math> n </math>).<br />
<br />
'''Выходные данные''': матрица Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> (элементы <math>h_{ij}</math>).<br />
<br />
'''Объём выходных данных''': <math>2^{2n}</math>, где <math> n </math> - размерность матрицы Адамара. Стоит заметить, что в силу симметричности или самого определения матрицы Адамара, достаточно хранить не все элементы матрицы, а только их часть.<br />
<br />
=== Свойства алгоритма ===<br />
<br />
* Соотношение последовательной и параллельной сложности:<br />
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом: <math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.<br />
<br />
Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.<br />
<br />
Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.<br />
:<math>\frac{T(n)}{T(n,P)}=P</math>.<br />
То есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;<br />
<br />
* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных: <br />
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right)</math>;<br />
<br />
* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размера 2<sup>''n''</sup>&nbsp;&times;&nbsp;2<sup>''n''</sup>);<br />
<br />
* Степень исхода вершины информационного графа равна 1;<br />
<br />
* Алгоритм построения матрицы Адамара является ''сбалансированным''. Так как количество вершин на разных процессорах одинаково, то алгоритм является сбалансированным по числу операций на каждом процессоре.<br />
<br />
=ЧАСТЬ Программная реализация алгоритма =<br />
<br />
== Особенности реализации последовательного алгоритма ==<br />
<br />
В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:<br />
<br />
<source lang="C"><br />
void adamar(int** H, int n) // N = 2^n - размерность матрицы<br />
{ <br />
int i,j,N;<br />
float h;<br />
h = pow(1/2,n/2); // h - нормализующий множитель<br />
N = pow(2,n);<br />
<br />
for(i=0;i<N;++i) <br />
{<br />
for(j=0;j<N;++j)<br />
{<br />
ij = i & j;<br />
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij<br />
if(l%2==0) H[i][j] = h;<br />
else H[i][j] = -h;<br />
}<br />
}<br />
}<br />
</source><br />
<br />
Также существует рекурсивная реализация метода построения матрицы Адамара<br />
<br />
<source lang="C"><br />
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель<br />
{<br />
if(n==1) H[i][j] = h;<br />
else<br />
{<br />
adamar(H, N/2, i, j, h);<br />
adamar(H, N/2, i, N/2+j, h);<br />
adamar(H, N/2, N/2+i, j, h);<br />
adamar(H, N/2, N/2+i, N/2+j, -h);<br />
}<br />
}<br />
</source><br />
<br />
Или эквивалентный безрекурсивный вариант:<br />
<br />
<source lang="C"><br />
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы<br />
{ <br />
int i,j,N;<br />
float h;<br />
h = pow(1/2,n/2);<br />
N = pow(2,n);<br />
k=2;<br />
H[0][0] = h;<br />
<br />
while(k<=N)<br />
{<br />
for (i=0; i<k; ++i)<br />
{<br />
for (j=0; j<k; ++j)<br />
{<br />
if (i<k/2 && j<k/2)<br />
{<br />
}<br />
else<br />
{<br />
if(i>=k/2 && j>=k/2)<br />
{<br />
H[i][j] = -(H[i-k/2][j-k/2]);<br />
}<br />
else<br />
{<br />
if (i>j)<br />
{<br />
H[i][j] = H[i-k/2][j];<br />
}<br />
else<br />
{<br />
H[i][j] = H[i][j-k/2];<br />
}<br />
}<br />
}<br />
}<br />
}<br />
<br />
k=k*2;<br />
}<br />
}<br />
</source><br />
<br />
Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у распараллелинной adamar_not_recursion (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).<br />
<br />
== Локальность данных и вычислений ==<br />
<br />
== Возможные способы и особенности параллельной реализации алгоритма ==<br />
<br />
== Масштабируемость алгоритма и его реализации ==<br />
Исследование проводилось на суперкомпьютере "Blue Gene".<br />
<br />
Набор и границы значений изменяемых параметров запуска реализации алгоритма: <br />
<br />
* число процессоров [1, 2, 4, 8,..., 1024] ;<br />
* размер матрицы [2, 4, 8,..., 2048].<br />
<br />
В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:<br />
<br />
* минимальная эффективность реализации 0.0121%;<br />
* максимальная эффективность реализации 3.3003%.<br />
<br />
На следующих рисунках приведены графики производительности и эффективности выбранной реализации построение матрицы Адамара в зависимости от изменяемых параметров запуска.<br />
<br />
[[file:Prois1.jpg|thumb|center|700px|Рис.5 Изменение производительности в зависимости от числа процессоров и размера матрицы.]]<br />
[[file:Effec1.jpg|thumb|center|700px|Рис.5 Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]<br />
<br />
Построим оценки масштабируемости выбранной реализации:<br />
* При увеличении числа процессов производительность на рассмотренной области изменений параметров запуска увеличивается практически линейно. В следствии этого эффективность реализации, как видно по графику, перестает изменяться при увеличении числа процессоров и равна примерно 1,7%.<br />
* При увеличении размера матрицы производительность на рассмотренной области изменений параметров запуска увеличивается логарифмически. Это связанно с тем, что количество операций зависит от количества единиц после бинарного произведения. Поэтому наиболее влияет порядок степени <math>n</math> размера матрицы <math>N=2^{n}</math>. При увеличении размера матрицы эффективность также увеличивается, но скорость возрастания уменьшается.<br />
По двум направлениям: При рассмотрении увеличения как вычислительной сложности, так и числа процессов на всей рассмотренной области значений эффективность увеличивается, однако скорость увеличения эффективности небольшая.<br />
<br />
== Динамические характеристики и эффективность реализации алгоритма ==<br />
<br />
== Выводы для классов архитектур ==<br />
<br />
== Существующие реализации алгоритма ==<br />
<br />
Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:<br />
<br />
# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];<br />
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];<br />
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];<br />
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave].<br />
<br />
Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах: <br />
# [https://ru.wikipedia.org/wiki/Maple MAPLE];<br />
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH].<br />
<br />
= Литература =<br />
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.<br />
<br />
[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2<br />
<br />
[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]<br />
<br />
[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).<br />
<br />
[5] Воеводин В.В.. Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.<br />
<br />
[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9F%D0%B5%D0%B9%D0%BB%D0%B8_%D0%BF%D0%BE%D1%81%D1%82%D1%80%D0%BE%D0%B5%D0%BD%D0%B8%D1%8F_%D0%BC%D0%B0%D1%82%D1%80%D0%B8%D1%86%D1%8B_%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80%D0%B0&diff=22599Алгоритм Пейли построения матрицы Адамара2017-05-03T18:59:28Z<p>Chernyavskiy: /* Свойства и структура алгоритма */</p>
<hr />
<div><br />
{{algorithm<br />
| name = Алгоритм Пейли построение матрицы Адамара<br />
| serial_complexity = <math>O(n^2)</math><br />
| pf_height = <math>O(1)</math><br />
| pf_width = <math>O(n^2)</math><br />
| input_data = <math>1</math><br />
| output_data = <math>n^2</math><br />
}}<br />
<br />
Основные авторы описания: [[Участник:Nikita|Иванов Н.В.]] (Разделы 1.1,1.7,1.9,1.10,2.4,2.7), [[Участник:Tsyganov Nikita|Цыганов Н.И.]] (Разделы 1.2,1.3,1.4,1.5,1.6,1.7,1.8,2.4), [[Участник:Chernyavskiy|А.Ю.Чернявский]] (проверка, редактирование), [[Участник:Sleo|С.Н.Леоненков]] (предварительня проверка), <br />
<br />
== Свойства и структура алгоритма ==<br />
<br />
<br />
=== Общее описание алгоритма ===<br />
<br />
Матрицы Адамара были введены в математический обиход в конце прошлого века и играют важную роль в алгебре и комбинаторике. Они находят широкое применение в теории кодирования (коды, исправляющие ошибки), теории планирования многофакторных экспериментов (блок-схемы) и других областях математики.<ref name="rt">http://cyberleninka.ru/article/n/matritsy-adamara-nechetnogo-poryadka.pdf</ref> Сравнительно недавно (в 1960 г.) было замечено, что эти матрицы могут быть использованы для построения кодов с большим кодовым расстоянием.<br />
<br />
'''''Матрицей Адамара порядка n''''' называется <math>n*n</math> матрица <math>H</math>, элементами которой являются +1 и −1 такая, что <math>H H^T = n E_n</math>, <br />
где <math>E_n</math> - единичная матрица размера n.<br />
<br />
Матрица Адамара обладает следующими ''свойствами'':<br />
* Различные строки матрицы ортогональны<br />
* Скалярное произведение любой строки саму на себя равно n<br />
* Умножение любой строки или столбца на -1 переводит H в другую матрицу Адамара<br />
* Если все элементы первой строки и первого столбца равны +1, то матрица Адамара называется нормализованной<br />
<br />
Ниже показаны примеры нормализованных матриц Адамара порядка 1,2 и 4, причем нормализованность матриц сохраняется при перестановке любых строк и столбцов, кроме первых:<br />
<br />
<math>H_1 = (1)</math><br />
<math>,<br />
H_2 =<br />
\begin{pmatrix}<br />
1 & 1\\<br />
1 & -1\end{pmatrix}<br />
</math>,<br />
<math>,<br />
H_4 =<br />
\begin{pmatrix}<br />
1 & 1 & 1 & 1\\<br />
1 & -1 & 1 & -1\\<br />
1 & 1 & -1 & -1\\<br />
1 & -1 & -1 & 1\end{pmatrix}<br />
</math><br />
<br />
<br />
Предполагается, что существуют матрицы Адамара порядка 1, 2 и всех порядков n, кратных 4, хотя это до сих пор еще не было доказано. Нет универсального алгоритма построения матрицы Адамара произвольного размера, но известно большое число методов для различных частных случаев, и наименьший порядок, для которого матрица Адамара еще не построена, равен 268 (на 1977 г.). <ref name="rt2">Мак-Вильямс Ф. Дж., Слоэн Н. Дж. А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — c. 52-57</ref> М<br />
<br />
В данном описании рассматривается метод Пейли, основанный на теоретико-числовых принципах и позволяющий строить матрицы Адамара порядка <math>n=p+1</math>, кратного 4, где p-простое число.<br />
<br />
=== Математическое описание алгоритма ===<br />
<br />
Для решения поставленной задачи будем использовать метод Пейли.<br />
Это построение дает матрицы Адамара любого порядка <math>n=p+1</math>, кратного 4, где p-простое число.<br />
<br />
'''Определение.''' Пусть p-простое число. Ненулевые квадраты чисел, приведенные по модулю p, называются квадратичными вычетами по модулю p или просто вычетами по модулю p. <br />
<br />
Чтобы найти все вычеты по модулю p, достаточно рассмотреть квадраты чисел от <math>1^2</math> до <math>(p-1)^2</math>. Но если учесть, что <math>(p-a)^2 </math> <math>mod </math> <math> p = (-a)^2 </math> <math> mod </math> <math> p = a^2 </math> <math>mod</math> <math> p</math>, то достаточно рассмотреть лишь числа <math>1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod </math> <math>p</math> .<br />
<br />
Функция <math>X(i)</math>, называемая символом Лежандра, определяется на целых числах следующим образом:<br />
* <math>X(i)=0</math>, если i кратно p;<br />
* <math>X(i)=1</math>, если остаток от деления i на p является квадратным вычетом по модулю p;<br />
* <math>X(i)=-1</math>, если остаток от деления i на p является невычетом.<br />
<br />
<br />
Теперь мы построим матрицу Джекобстола <math>Q=(q_{ij})</math>. Она представляет собой <math>(p*p)</math>-матрицу, строки и столбцы которой пронумерованы числами 0,1,..., p-1, а элементы <math>q_{ij}=X(j-i)</math>. <br />
<br />
Пусть теперь <math><br />
H =<br />
\begin{pmatrix}<br />
1 & 1\\<br />
1^T & Q-I\end{pmatrix}<br />
</math>.<br />
<br />
Все элементы главной диагонали этой матрицы, кроме элемента <math>h_{00}</math>, равны <math>X(0)-1=-1</math>. Нетрудно заметить, что данная матрица состоит только лишь из элементов 1 и -1.<br />
<br />
Доказано, что такая матрица <math>H</math> представляет собой нормализованную матрицу Адамара порядка p+1, которую называют матрицей типа Пейли.<ref name="rt3">http://tc.nsu.ru/uploads/codingtheory.pdf</ref><br />
<br />
Исходные данные алгоритма - это порядок генерируемой матрицы Адамара <math>n</math>, удовлетворяющее следующим свойствам: <br />
<br />
* <math>n>0</math>;<br />
<br />
* <math>n</math> делится на 4;<br />
<br />
* <math>n-1</math> - простое число.<br />
<br />
Вспомогательные данные: <br />
<br />
* Число <math>p=n-1</math>;<br />
* Вектор квадратичных вычетов (по модулю <math>p</math>) <math>R</math> (элементы <math>r_i</math>) размера <math>2p</math>. В этом векторе индексация идёт с нуля.<br />
<br />
Вычисляемые данные:<br />
<br />
* Матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>) размера <math>n \times n</math>. Индексация строчек и столбцов идёт с нуля. <br />
<br />
Алгоритм:<br />
:1. Строится вектор квадратичных вычетов <math>R</math>.<br />
:: Первые <math>p</math> элементов вектора <math>R</math> (<math>i=0,1,...,p-1</math>) определяются следующим образом:<br />
::: <math>r_i=1</math>, если <math>i \in \{1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod</math> <math> p\}</math>, <math>i=0,1,...,p-1</math>, то есть если <math>i</math> является квадратичным вычетом по модулю <math>p</math>;<br />
::: <math>r_i=-1</math>, иначе.<br />
::Вторые <math>p</math> элементов (<math>i=p,1,...,2p-1</math>) являются копией первых <math>p</math> элементов:<br />
:::<math>r_i=r_{i-p}, i=p,1,...,2p-1.</math><br />
:2. Строится матрица Адамара <math>H</math>.<br />
::Элементы матрицы Адамара <math>H</math> находятся следующим образом:<br />
::: <math>h_{0j}=1, j=0,1, ... ,n-1;</math><br />
::: <math>h_{i0}=1, i=1,2, ... ,n-1;</math><br />
::: <math>h_{ij}=r_{j-i+p}, i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math><br />
<br />
=== Вычислительное ядро алгоритма ===<br />
<br />
Вычислительное ядро алгоритма состоит из <math>(n-1) \times (n-1)</math> операций присваивания следующего вида:<br />
<br />
:<math>h_{ij}=r_{j-i+p},</math> <math> i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math><br />
<br />
=== Макроструктура алгоритма ===<br />
<br />
Как видно из математического описания, алгоритм основан на простейших операциях с числами, поэтому макроструктура алгоритма полностью соответствует его математическому описанию.<br />
<br />
=== Схема реализации последовательного алгоритма ===<br />
<br />
Приведем процедуру на языке С++, реализующую описанный алгоритм. На вход процедуре подается порядок матрицы <math>n</math> и ссылка на заполняемую матрицу <math>result</math>. Считаем, что <math>n</math> положительно, делится на <math>4</math>, <math>n-1</math> - простое число, а размер матрицы <math>result</math> равен <math>n \times n</math>.<br />
<br />
<source lang="C"><br />
void buildHadamardMatrix(int n, vector< vector<int> > & result)<br />
{<br />
// 1) matrix size changing<br />
result.resize(n);<br />
for (int i=0; i<n; i++) {<br />
result[i].resize(n);<br />
}<br />
<br />
// 2) residue array building<br />
int p=n-1;<br />
vector<int> residues;<br />
residues.resize(2*p);<br />
for (int i=0; i<p; i++) {<br />
residues[i] = -1;<br />
}<br />
for (int i=1; i<= (p-1)/2; i++) {<br />
residues[i*i % p] = 1;<br />
}<br />
for (int i=p; i<2*p; i++) {<br />
residues[i] = residues[i-p];<br />
}<br />
// 3) Paley matrix building<br />
// first line filling<br />
for (int j=0; j<n; j++) {<br />
result[0][j] = 1;<br />
}<br />
// first column filling<br />
for (int i=1; i<n; i++) {<br />
result[i][0] = 1;<br />
}<br />
// others<br />
for (int i=1; i<n; i++) {<br />
for (int j=1; j<n; j++) {<br />
result[i][j] = residues[j-i+p];<br />
}<br />
}<br />
}<br />
</source><br />
<br />
=== Последовательная сложность алгоритма ===<br />
<br />
Под сложностью будем понимать зависимость числа операций от задаваемого порядка матрицы <math>n</math>. <br />
<br />
Основными операциями алгоритма являются:<br />
<br />
* <math>\frac{n}{2}-2</math> операций умножения;<br />
* <math>\frac{n}{2}-2</math> операций взятия остатка;<br />
* <math>n^2+\frac{5}{2}n-3</math> операций присваивания.<br />
<br />
Из чего следует, что алгоритм имеет квадратичную последовательную сложность.<br />
<br />
=== Информационный граф ===<br />
<br />
Информационный граф алгоритма можно представить в виде четырёх последовательных блоков. Первый блок содержит <math>n-1</math> параллельных ветвей, второй блок - <math>\frac{n}{2}-1</math> параллельных ветвей, третий - <math>n-1</math> и четвёртый - <math>n^2</math>.<br />
<br />
[[Файл:i_graph2.png|600px|thumb|center]]<br />
<br />
Каждая вершина из <math>A_1-A_{n-1}</math>, <math>C_1-C_{n-1}</math>, <math>D_1-D_{n^2}</math> соответствует операции присваивания, каждая вершина из <math>B_1-B_{\frac{n}{2}-1}</math> соответствует трём последовательным операциям: умножения, взятия остатка по модулю и присваивания, а вершины, окрашенные серым, представляют собой промежуточные точки синхронизации.<br />
<br />
[[Файл:i_graph3.jpg|600px|thumb|center|Информационный граф для n=4.]]<br />
На рисунке приведен информационный граф алгоритма для случая n=4. Вершины графа соответствуют следующим строчкам кода:<br />
<br />
a. residues[i] = -1;<br />
<br />
b. residues[i*i%p] = 1;<br />
<br />
c. residues[i] = residues[i-p];<br />
<br />
d. result[0][j] = 1;<br />
<br />
e. result[i][0] = 1;<br />
<br />
f. result[i][j] = residues[i-j+p];<br />
<br />
=== Ресурс параллелизма алгоритма ===<br />
<br />
Как видно из информационного графа алгоритма, в параллельном варианте необходимо последовательно выполнить следующие блоки:<br />
<br />
* <math>n-1</math> операций присваивания;<br />
* <math>\frac{n}{2}-1</math> участков, состоящих из трёх операций: умножения, взятия остатка и присваивания;<br />
* <math>n-1</math> операций присваивания;<br />
* <math>n^2</math> операций присваивания.<br />
<br />
Из этого можно сделать вывод, что высота ярусно-параллельной формы информационного графа равняется 6 (присваивание, умножение, взятие остатка, присваивание, присваивание, присваивание). Ширина ярусно-параллельной формы равняется <math>n^2</math>, что означает, что при использовании <math>n^2</math> процессоров матрица Адамара будет строиться за 6 операций.<br />
<br />
=== Входные и выходные данные алгоритма ===<br />
<br />
'''Входные данные:''' число <math>n</math> - порядок матрицы Адамара <math>H_n</math>. Дополнительные ограничения на <math>n</math>:<br />
* <math>n</math> - натуральное;<br />
* <math>n</math> делится на 4;<br />
* <math>n-1</math> - простое.<br />
'''Объем входных данных:''' 1 (число <math>n</math>).<br />
<br />
'''Выходные данные:''' построенная матрица Адамара <math>H_n</math> (её элементы <math>h_{ij}</math>).<br />
<br />
'''Объем выходных данных:''' <math>n^2</math> (количество элементов матрицы Адамара размера <math>n*n</math>).<br />
<br />
=== Свойства алгоритма ===<br />
<br />
Соотношение последовательной и параллельной сложности в случае неограниченных ресурсов является квадратичным. <br />
<br />
Вычислительная мощность алгоритма является постоянной (<math>O(1)</math>). <br />
<br />
Алгоритм является полностью детерминированным. <br />
<br />
Для вершин <math>A_1-A_{n-1}</math>, <math>B_1-B_{\frac{n}{2}-1}</math>, <math>C_1-C_{n-1}</math> информационного графа степени исхода являются линейными, что означает, что при возможности на этапе реализации необходимо позаботиться об эффективном доступе к элементам массива "<math>residues</math>".<br />
<br />
== Программная реализация алгоритма ==<br />
<br />
=== Особенности реализации последовательного алгоритма ===<br />
<br />
=== Локальность данных и вычислений ===<br />
<br />
=== Возможные способы и особенности параллельной реализации алгоритма ===<br />
<br />
=== Масштабируемость алгоритма и его реализации ===<br />
<br />
<br />
Исследование масштабируемости параллельной реализации алгоритма построения матрицы Адамара проводилось на суперкомпьютере «Ломоносов». Для этого была исследована собственная реализация алгоритма с использованием средств MPI. В ходе исследования было произведено множество запусков программы с различными значениями параметра <math>n</math> (размер матрицы Адамара) и числом процессоров.<br />
<br />
Набор и границы значений изменяемых параметров запуска реализации алгоритма:<br />
*число процессоров (p): [2,64] с шагом 2;<br />
*размер матрицы: простые числа в диапазоне [4,10000].<br />
<br />
В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:<br />
*минимальная эффективность реализации 0.0000036% при n=4, p=2;<br />
*максимальная эффективность реализации 0.333426% при n=948, p=2.<br />
<br />
Ниже представлены графики времени работы, производительности и эффективности данной реализации алгоритма построения матрицы Адамара в зависимости от изменяемых параметров запуска.<br />
[[Файл:time_graph1.png|500px|thumb|center|Время работы параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]<br />
[[Файл:perform_graph1.png|500px|thumb|center|Изменение производительности параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]<br />
[[Файл:efficiency_graph1.png|500px|thumb|center|Эффективность работы параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]<br />
<br />
<br />
[https://github.com/snikersman/Hadamard Исследованная параллельная реализация на языке C++]<br />
<br />
Построим оценки масштабируемости, используя полученные результаты:<br />
*По размерности задачи. Увеличение размерности задачи приводит к увеличению производительности.<br />
*По числу процессоров. С ростом числа процессоров растет производительность, но при малых размерностях задачи этот рост незначителен. Это связано с дополнительными издержками по записи в участок памяти каждого процессора вспомогательного массива вычетов, а также с обменом информации между процессорами.<br />
*По двум направлениям. При увеличении как числа процессоров, так и размерности задачи, производительность увеличивается. Причем чем больше используется процессоров, тем сильнее увеличивается производительность при увеличении размерности.<br />
<br />
=== Динамические характеристики и эффективность реализации алгоритма ===<br />
<br />
=== Выводы для классов архитектур ===<br />
<br />
=== Существующие реализации алгоритма ===<br />
<br />
Алгоритм построения матрицы Адамара реализован в различных математических пакетах и библиотеках: <br />
* [https://www.mathworks.com/help/matlab/ref/hadamard.html?requestedDomain=www.mathworks.com MATLAB] (вносятся дополнительные ограничения, когда n, или n/12, или n/20 являются степенями по основанию 2)<br />
* [http://r-survey.r-forge.r-project.org/survey/html/hadamard.html R]<br />
* [https://reference.wolframcloud.com/cloudplatform/ref/HadamardMatrix.html Wolfram Mathematica]<br />
* [http://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.linalg.hadamard.html SciPy для Python]<br />
<br />
== Литература ==</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9F%D0%B5%D0%B9%D0%BB%D0%B8_%D0%BF%D0%BE%D1%81%D1%82%D1%80%D0%BE%D0%B5%D0%BD%D0%B8%D1%8F_%D0%BC%D0%B0%D1%82%D1%80%D0%B8%D1%86%D1%8B_%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80%D0%B0&diff=22598Алгоритм Пейли построения матрицы Адамара2017-05-03T18:58:19Z<p>Chernyavskiy: /* Общее описание алгоритма */</p>
<hr />
<div><br />
{{algorithm<br />
| name = Алгоритм Пейли построение матрицы Адамара<br />
| serial_complexity = <math>O(n^2)</math><br />
| pf_height = <math>O(1)</math><br />
| pf_width = <math>O(n^2)</math><br />
| input_data = <math>1</math><br />
| output_data = <math>n^2</math><br />
}}<br />
<br />
Основные авторы описания: [[Участник:Nikita|Иванов Н.В.]] (Разделы 1.1,1.7,1.9,1.10,2.4,2.7), [[Участник:Tsyganov Nikita|Цыганов Н.И.]] (Разделы 1.2,1.3,1.4,1.5,1.6,1.7,1.8,2.4), [[Участник:Chernyavskiy|А.Ю.Чернявский]] (проверка, редактирование), [[Участник:Sleo|С.Н.Леоненков]] (предварительня проверка), <br />
<br />
== Свойства и структура алгоритма ==<br />
<br />
<br />
=== Общее описание алгоритма ===<br />
<br />
Матрицы Адамара были введены в математический обиход в конце прошлого века и играют важную роль в алгебре и комбинаторике. Они находят широкое применение в теории кодирования (коды, исправляющие ошибки), теории планирования многофакторных экспериментов (блок-схемы) и других областях математики.<ref name="rt">http://cyberleninka.ru/article/n/matritsy-adamara-nechetnogo-poryadka.pdf</ref> Сравнительно недавно (в 1960 г.) было замечено, что эти матрицы могут быть использованы для построения кодов с большим кодовым расстоянием.<br />
<br />
'''''Матрицей Адамара порядка n''''' называется <math>n*n</math> матрица <math>H</math>, элементами которой являются +1 и −1 такая, что <math>H H^T = n E_n</math>, <br />
где <math>E_n</math> - единичная матрица размера n.<br />
<br />
Матрица Адамара обладает следующими ''свойствами'':<br />
* Различные строки матрицы ортогональны<br />
* Скалярное произведение любой строки саму на себя равно n<br />
* Умножение любой строки или столбца на -1 переводит H в другую матрицу Адамара<br />
* Если все элементы первой строки и первого столбца равны +1, то матрица Адамара называется нормализованной<br />
<br />
Ниже показаны примеры нормализованных матриц Адамара порядка 1,2 и 4, причем нормализованность матриц сохраняется при перестановке любых строк и столбцов, кроме первых:<br />
<br />
<math>H_1 = (1)</math><br />
<math>,<br />
H_2 =<br />
\begin{pmatrix}<br />
1 & 1\\<br />
1 & -1\end{pmatrix}<br />
</math>,<br />
<math>,<br />
H_4 =<br />
\begin{pmatrix}<br />
1 & 1 & 1 & 1\\<br />
1 & -1 & 1 & -1\\<br />
1 & 1 & -1 & -1\\<br />
1 & -1 & -1 & 1\end{pmatrix}<br />
</math><br />
<br />
<br />
Предполагается, что существуют матрицы Адамара порядка 1, 2 и всех порядков n, кратных 4, хотя это до сих пор еще не было доказано. Нет универсального алгоритма построения матрицы Адамара произвольного размера, но известно большое число методов для различных частных случаев, и наименьший порядок, для которого матрица Адамара еще не построена, равен 268 (на 1977 г.). <ref name="rt2">Мак-Вильямс Ф. Дж., Слоэн Н. Дж. А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — c. 52-57</ref> М<br />
<br />
В данном описании рассматривается метод Пейли,<br />
<br />
=== Математическое описание алгоритма ===<br />
<br />
Для решения поставленной задачи будем использовать метод Пейли.<br />
Это построение дает матрицы Адамара любого порядка <math>n=p+1</math>, кратного 4, где p-простое число.<br />
<br />
'''Определение.''' Пусть p-простое число. Ненулевые квадраты чисел, приведенные по модулю p, называются квадратичными вычетами по модулю p или просто вычетами по модулю p. <br />
<br />
Чтобы найти все вычеты по модулю p, достаточно рассмотреть квадраты чисел от <math>1^2</math> до <math>(p-1)^2</math>. Но если учесть, что <math>(p-a)^2 </math> <math>mod </math> <math> p = (-a)^2 </math> <math> mod </math> <math> p = a^2 </math> <math>mod</math> <math> p</math>, то достаточно рассмотреть лишь числа <math>1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod </math> <math>p</math> .<br />
<br />
Функция <math>X(i)</math>, называемая символом Лежандра, определяется на целых числах следующим образом:<br />
* <math>X(i)=0</math>, если i кратно p;<br />
* <math>X(i)=1</math>, если остаток от деления i на p является квадратным вычетом по модулю p;<br />
* <math>X(i)=-1</math>, если остаток от деления i на p является невычетом.<br />
<br />
<br />
Теперь мы построим матрицу Джекобстола <math>Q=(q_{ij})</math>. Она представляет собой <math>(p*p)</math>-матрицу, строки и столбцы которой пронумерованы числами 0,1,..., p-1, а элементы <math>q_{ij}=X(j-i)</math>. <br />
<br />
Пусть теперь <math><br />
H =<br />
\begin{pmatrix}<br />
1 & 1\\<br />
1^T & Q-I\end{pmatrix}<br />
</math>.<br />
<br />
Все элементы главной диагонали этой матрицы, кроме элемента <math>h_{00}</math>, равны <math>X(0)-1=-1</math>. Нетрудно заметить, что данная матрица состоит только лишь из элементов 1 и -1.<br />
<br />
Доказано, что такая матрица <math>H</math> представляет собой нормализованную матрицу Адамара порядка p+1, которую называют матрицей типа Пейли.<ref name="rt3">http://tc.nsu.ru/uploads/codingtheory.pdf</ref><br />
<br />
Исходные данные алгоритма - это порядок генерируемой матрицы Адамара <math>n</math>, удовлетворяющее следующим свойствам: <br />
<br />
* <math>n>0</math>;<br />
<br />
* <math>n</math> делится на 4;<br />
<br />
* <math>n-1</math> - простое число.<br />
<br />
Вспомогательные данные: <br />
<br />
* Число <math>p=n-1</math>;<br />
* Вектор квадратичных вычетов (по модулю <math>p</math>) <math>R</math> (элементы <math>r_i</math>) размера <math>2p</math>. В этом векторе индексация идёт с нуля.<br />
<br />
Вычисляемые данные:<br />
<br />
* Матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>) размера <math>n \times n</math>. Индексация строчек и столбцов идёт с нуля. <br />
<br />
Алгоритм:<br />
:1. Строится вектор квадратичных вычетов <math>R</math>.<br />
:: Первые <math>p</math> элементов вектора <math>R</math> (<math>i=0,1,...,p-1</math>) определяются следующим образом:<br />
::: <math>r_i=1</math>, если <math>i \in \{1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod</math> <math> p\}</math>, <math>i=0,1,...,p-1</math>, то есть если <math>i</math> является квадратичным вычетом по модулю <math>p</math>;<br />
::: <math>r_i=-1</math>, иначе.<br />
::Вторые <math>p</math> элементов (<math>i=p,1,...,2p-1</math>) являются копией первых <math>p</math> элементов:<br />
:::<math>r_i=r_{i-p}, i=p,1,...,2p-1.</math><br />
:2. Строится матрица Адамара <math>H</math>.<br />
::Элементы матрицы Адамара <math>H</math> находятся следующим образом:<br />
::: <math>h_{0j}=1, j=0,1, ... ,n-1;</math><br />
::: <math>h_{i0}=1, i=1,2, ... ,n-1;</math><br />
::: <math>h_{ij}=r_{j-i+p}, i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math><br />
<br />
=== Вычислительное ядро алгоритма ===<br />
<br />
Вычислительное ядро алгоритма состоит из <math>(n-1) \times (n-1)</math> операций присваивания следующего вида:<br />
<br />
:<math>h_{ij}=r_{j-i+p},</math> <math> i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math><br />
<br />
=== Макроструктура алгоритма ===<br />
<br />
Как видно из математического описания, алгоритм основан на простейших операциях с числами, поэтому макроструктура алгоритма полностью соответствует его математическому описанию.<br />
<br />
=== Схема реализации последовательного алгоритма ===<br />
<br />
Приведем процедуру на языке С++, реализующую описанный алгоритм. На вход процедуре подается порядок матрицы <math>n</math> и ссылка на заполняемую матрицу <math>result</math>. Считаем, что <math>n</math> положительно, делится на <math>4</math>, <math>n-1</math> - простое число, а размер матрицы <math>result</math> равен <math>n \times n</math>.<br />
<br />
<source lang="C"><br />
void buildHadamardMatrix(int n, vector< vector<int> > & result)<br />
{<br />
// 1) matrix size changing<br />
result.resize(n);<br />
for (int i=0; i<n; i++) {<br />
result[i].resize(n);<br />
}<br />
<br />
// 2) residue array building<br />
int p=n-1;<br />
vector<int> residues;<br />
residues.resize(2*p);<br />
for (int i=0; i<p; i++) {<br />
residues[i] = -1;<br />
}<br />
for (int i=1; i<= (p-1)/2; i++) {<br />
residues[i*i % p] = 1;<br />
}<br />
for (int i=p; i<2*p; i++) {<br />
residues[i] = residues[i-p];<br />
}<br />
// 3) Paley matrix building<br />
// first line filling<br />
for (int j=0; j<n; j++) {<br />
result[0][j] = 1;<br />
}<br />
// first column filling<br />
for (int i=1; i<n; i++) {<br />
result[i][0] = 1;<br />
}<br />
// others<br />
for (int i=1; i<n; i++) {<br />
for (int j=1; j<n; j++) {<br />
result[i][j] = residues[j-i+p];<br />
}<br />
}<br />
}<br />
</source><br />
<br />
=== Последовательная сложность алгоритма ===<br />
<br />
Под сложностью будем понимать зависимость числа операций от задаваемого порядка матрицы <math>n</math>. <br />
<br />
Основными операциями алгоритма являются:<br />
<br />
* <math>\frac{n}{2}-2</math> операций умножения;<br />
* <math>\frac{n}{2}-2</math> операций взятия остатка;<br />
* <math>n^2+\frac{5}{2}n-3</math> операций присваивания.<br />
<br />
Из чего следует, что алгоритм имеет квадратичную последовательную сложность.<br />
<br />
=== Информационный граф ===<br />
<br />
Информационный граф алгоритма можно представить в виде четырёх последовательных блоков. Первый блок содержит <math>n-1</math> параллельных ветвей, второй блок - <math>\frac{n}{2}-1</math> параллельных ветвей, третий - <math>n-1</math> и четвёртый - <math>n^2</math>.<br />
<br />
[[Файл:i_graph2.png|600px|thumb|center]]<br />
<br />
Каждая вершина из <math>A_1-A_{n-1}</math>, <math>C_1-C_{n-1}</math>, <math>D_1-D_{n^2}</math> соответствует операции присваивания, каждая вершина из <math>B_1-B_{\frac{n}{2}-1}</math> соответствует трём последовательным операциям: умножения, взятия остатка по модулю и присваивания, а вершины, окрашенные серым, представляют собой промежуточные точки синхронизации.<br />
<br />
[[Файл:i_graph3.jpg|600px|thumb|center|Информационный граф для n=4.]]<br />
На рисунке приведен информационный граф алгоритма для случая n=4. Вершины графа соответствуют следующим строчкам кода:<br />
<br />
a. residues[i] = -1;<br />
<br />
b. residues[i*i%p] = 1;<br />
<br />
c. residues[i] = residues[i-p];<br />
<br />
d. result[0][j] = 1;<br />
<br />
e. result[i][0] = 1;<br />
<br />
f. result[i][j] = residues[i-j+p];<br />
<br />
=== Ресурс параллелизма алгоритма ===<br />
<br />
Как видно из информационного графа алгоритма, в параллельном варианте необходимо последовательно выполнить следующие блоки:<br />
<br />
* <math>n-1</math> операций присваивания;<br />
* <math>\frac{n}{2}-1</math> участков, состоящих из трёх операций: умножения, взятия остатка и присваивания;<br />
* <math>n-1</math> операций присваивания;<br />
* <math>n^2</math> операций присваивания.<br />
<br />
Из этого можно сделать вывод, что высота ярусно-параллельной формы информационного графа равняется 6 (присваивание, умножение, взятие остатка, присваивание, присваивание, присваивание). Ширина ярусно-параллельной формы равняется <math>n^2</math>, что означает, что при использовании <math>n^2</math> процессоров матрица Адамара будет строиться за 6 операций.<br />
<br />
=== Входные и выходные данные алгоритма ===<br />
<br />
'''Входные данные:''' число <math>n</math> - порядок матрицы Адамара <math>H_n</math>. Дополнительные ограничения на <math>n</math>:<br />
* <math>n</math> - натуральное;<br />
* <math>n</math> делится на 4;<br />
* <math>n-1</math> - простое.<br />
'''Объем входных данных:''' 1 (число <math>n</math>).<br />
<br />
'''Выходные данные:''' построенная матрица Адамара <math>H_n</math> (её элементы <math>h_{ij}</math>).<br />
<br />
'''Объем выходных данных:''' <math>n^2</math> (количество элементов матрицы Адамара размера <math>n*n</math>).<br />
<br />
=== Свойства алгоритма ===<br />
<br />
Соотношение последовательной и параллельной сложности в случае неограниченных ресурсов является квадратичным. <br />
<br />
Вычислительная мощность алгоритма является постоянной (<math>O(1)</math>). <br />
<br />
Алгоритм является полностью детерминированным. <br />
<br />
Для вершин <math>A_1-A_{n-1}</math>, <math>B_1-B_{\frac{n}{2}-1}</math>, <math>C_1-C_{n-1}</math> информационного графа степени исхода являются линейными, что означает, что при возможности на этапе реализации необходимо позаботиться об эффективном доступе к элементам массива "<math>residues</math>".<br />
<br />
== Программная реализация алгоритма ==<br />
<br />
=== Особенности реализации последовательного алгоритма ===<br />
<br />
=== Локальность данных и вычислений ===<br />
<br />
=== Возможные способы и особенности параллельной реализации алгоритма ===<br />
<br />
=== Масштабируемость алгоритма и его реализации ===<br />
<br />
<br />
Исследование масштабируемости параллельной реализации алгоритма построения матрицы Адамара проводилось на суперкомпьютере «Ломоносов». Для этого была исследована собственная реализация алгоритма с использованием средств MPI. В ходе исследования было произведено множество запусков программы с различными значениями параметра <math>n</math> (размер матрицы Адамара) и числом процессоров.<br />
<br />
Набор и границы значений изменяемых параметров запуска реализации алгоритма:<br />
*число процессоров (p): [2,64] с шагом 2;<br />
*размер матрицы: простые числа в диапазоне [4,10000].<br />
<br />
В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:<br />
*минимальная эффективность реализации 0.0000036% при n=4, p=2;<br />
*максимальная эффективность реализации 0.333426% при n=948, p=2.<br />
<br />
Ниже представлены графики времени работы, производительности и эффективности данной реализации алгоритма построения матрицы Адамара в зависимости от изменяемых параметров запуска.<br />
[[Файл:time_graph1.png|500px|thumb|center|Время работы параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]<br />
[[Файл:perform_graph1.png|500px|thumb|center|Изменение производительности параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]<br />
[[Файл:efficiency_graph1.png|500px|thumb|center|Эффективность работы параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]<br />
<br />
<br />
[https://github.com/snikersman/Hadamard Исследованная параллельная реализация на языке C++]<br />
<br />
Построим оценки масштабируемости, используя полученные результаты:<br />
*По размерности задачи. Увеличение размерности задачи приводит к увеличению производительности.<br />
*По числу процессоров. С ростом числа процессоров растет производительность, но при малых размерностях задачи этот рост незначителен. Это связано с дополнительными издержками по записи в участок памяти каждого процессора вспомогательного массива вычетов, а также с обменом информации между процессорами.<br />
*По двум направлениям. При увеличении как числа процессоров, так и размерности задачи, производительность увеличивается. Причем чем больше используется процессоров, тем сильнее увеличивается производительность при увеличении размерности.<br />
<br />
=== Динамические характеристики и эффективность реализации алгоритма ===<br />
<br />
=== Выводы для классов архитектур ===<br />
<br />
=== Существующие реализации алгоритма ===<br />
<br />
Алгоритм построения матрицы Адамара реализован в различных математических пакетах и библиотеках: <br />
* [https://www.mathworks.com/help/matlab/ref/hadamard.html?requestedDomain=www.mathworks.com MATLAB] (вносятся дополнительные ограничения, когда n, или n/12, или n/20 являются степенями по основанию 2)<br />
* [http://r-survey.r-forge.r-project.org/survey/html/hadamard.html R]<br />
* [https://reference.wolframcloud.com/cloudplatform/ref/HadamardMatrix.html Wolfram Mathematica]<br />
* [http://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.linalg.hadamard.html SciPy для Python]<br />
<br />
== Литература ==</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9F%D0%B5%D0%B9%D0%BB%D0%B8_%D0%BF%D0%BE%D1%81%D1%82%D1%80%D0%BE%D0%B5%D0%BD%D0%B8%D1%8F_%D0%BC%D0%B0%D1%82%D1%80%D0%B8%D1%86%D1%8B_%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80%D0%B0&diff=22597Алгоритм Пейли построения матрицы Адамара2017-05-03T18:42:42Z<p>Chernyavskiy: Новая страница: « {{algorithm | name = Алгоритм Пейли построение матрицы Адамара | serial_complexity = <math>O(n^2)</math> | pf_h…»</p>
<hr />
<div><br />
{{algorithm<br />
| name = Алгоритм Пейли построение матрицы Адамара<br />
| serial_complexity = <math>O(n^2)</math><br />
| pf_height = <math>O(1)</math><br />
| pf_width = <math>O(n^2)</math><br />
| input_data = <math>1</math><br />
| output_data = <math>n^2</math><br />
}}<br />
<br />
Основные авторы описания: [[Участник:Nikita|Иванов Н.В.]] (Разделы 1.1,1.7,1.9,1.10,2.4,2.7), [[Участник:Tsyganov Nikita|Цыганов Н.И.]] (Разделы 1.2,1.3,1.4,1.5,1.6,1.7,1.8,2.4), [[Участник:Chernyavskiy|А.Ю.Чернявский]] (проверка, редактирование), [[Участник:Sleo|С.Н.Леоненков]] (предварительня проверка), <br />
<br />
== Свойства и структура алгоритма ==<br />
<br />
<br />
=== Общее описание алгоритма ===<br />
<br />
Матрицы Адамара были введены в математический обиход в конце прошлого века и играют важную роль в алгебре и комбинаторике. Они находят широкое применение в теории кодирования (коды, исправляющие ошибки), теории планирования многофакторных экспериментов (блок-схемы) и других областях математики.<ref name="rt">http://cyberleninka.ru/article/n/matritsy-adamara-nechetnogo-poryadka.pdf</ref> Сравнительно недавно (в 1960 г.) было замечено, что эти матрицы могут быть использованы для построения кодов с большим кодовым расстоянием.<br />
<br />
'''''Матрицей Адамара порядка n''''' называется <math>n*n</math> матрица <math>H</math>, элементами которой являются +1 и −1 такая, что <math>H H^T = n E_n</math>, <br />
где <math>E_n</math> - единичная матрица размера n.<br />
<br />
Матрица Адамара обладает следующими ''свойствами'':<br />
* Различные строки матрицы ортогональны<br />
* Скалярное произведение любой строки саму на себя равно n<br />
* Умножение любой строки или столбца на -1 переводит H в другую матрицу Адамара<br />
* Если все элементы первой строки и первого столбца равны +1, то матрица Адамара называется нормализованной<br />
<br />
Ниже показаны примеры нормализованных матриц Адамара порядка 1,2 и 4, причем нормализованность матриц сохраняется при перестановке любых строк и столбцов, кроме первых:<br />
<br />
<math>H_1 = (1)</math><br />
<math>,<br />
H_2 =<br />
\begin{pmatrix}<br />
1 & 1\\<br />
1 & -1\end{pmatrix}<br />
</math>,<br />
<math>,<br />
H_4 =<br />
\begin{pmatrix}<br />
1 & 1 & 1 & 1\\<br />
1 & -1 & 1 & -1\\<br />
1 & 1 & -1 & -1\\<br />
1 & -1 & -1 & 1\end{pmatrix}<br />
</math><br />
<br />
<br />
Предполагается, что существуют матрицы Адамара порядка 1, 2 и всех порядков n, кратных 4, хотя это до сих пор еще не было доказано. Нет универсального алгоритма построения матрицы Адамара произвольного размера, но известно большое число методов для различных частных случаев, и наименьший порядок, для которого матрица Адамара еще не построена, равен 268 (на 1977 г.). <ref name="rt2">Мак-Вильямс Ф. Дж., Слоэн Н. Дж. А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — c. 52-57</ref> Мы приведем метод построения Пейли, который важен для теории кодирования. <br />
<br />
=== Математическое описание алгоритма ===<br />
<br />
Для решения поставленной задачи будем использовать метод Пейли.<br />
Это построение дает матрицы Адамара любого порядка <math>n=p+1</math>, кратного 4, где p-простое число.<br />
<br />
'''Определение.''' Пусть p-простое число. Ненулевые квадраты чисел, приведенные по модулю p, называются квадратичными вычетами по модулю p или просто вычетами по модулю p. <br />
<br />
Чтобы найти все вычеты по модулю p, достаточно рассмотреть квадраты чисел от <math>1^2</math> до <math>(p-1)^2</math>. Но если учесть, что <math>(p-a)^2 </math> <math>mod </math> <math> p = (-a)^2 </math> <math> mod </math> <math> p = a^2 </math> <math>mod</math> <math> p</math>, то достаточно рассмотреть лишь числа <math>1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod </math> <math>p</math> .<br />
<br />
Функция <math>X(i)</math>, называемая символом Лежандра, определяется на целых числах следующим образом:<br />
* <math>X(i)=0</math>, если i кратно p;<br />
* <math>X(i)=1</math>, если остаток от деления i на p является квадратным вычетом по модулю p;<br />
* <math>X(i)=-1</math>, если остаток от деления i на p является невычетом.<br />
<br />
<br />
Теперь мы построим матрицу Джекобстола <math>Q=(q_{ij})</math>. Она представляет собой <math>(p*p)</math>-матрицу, строки и столбцы которой пронумерованы числами 0,1,..., p-1, а элементы <math>q_{ij}=X(j-i)</math>. <br />
<br />
Пусть теперь <math><br />
H =<br />
\begin{pmatrix}<br />
1 & 1\\<br />
1^T & Q-I\end{pmatrix}<br />
</math>.<br />
<br />
Все элементы главной диагонали этой матрицы, кроме элемента <math>h_{00}</math>, равны <math>X(0)-1=-1</math>. Нетрудно заметить, что данная матрица состоит только лишь из элементов 1 и -1.<br />
<br />
Доказано, что такая матрица <math>H</math> представляет собой нормализованную матрицу Адамара порядка p+1, которую называют матрицей типа Пейли.<ref name="rt3">http://tc.nsu.ru/uploads/codingtheory.pdf</ref><br />
<br />
Исходные данные алгоритма - это порядок генерируемой матрицы Адамара <math>n</math>, удовлетворяющее следующим свойствам: <br />
<br />
* <math>n>0</math>;<br />
<br />
* <math>n</math> делится на 4;<br />
<br />
* <math>n-1</math> - простое число.<br />
<br />
Вспомогательные данные: <br />
<br />
* Число <math>p=n-1</math>;<br />
* Вектор квадратичных вычетов (по модулю <math>p</math>) <math>R</math> (элементы <math>r_i</math>) размера <math>2p</math>. В этом векторе индексация идёт с нуля.<br />
<br />
Вычисляемые данные:<br />
<br />
* Матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>) размера <math>n \times n</math>. Индексация строчек и столбцов идёт с нуля. <br />
<br />
Алгоритм:<br />
:1. Строится вектор квадратичных вычетов <math>R</math>.<br />
:: Первые <math>p</math> элементов вектора <math>R</math> (<math>i=0,1,...,p-1</math>) определяются следующим образом:<br />
::: <math>r_i=1</math>, если <math>i \in \{1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod</math> <math> p\}</math>, <math>i=0,1,...,p-1</math>, то есть если <math>i</math> является квадратичным вычетом по модулю <math>p</math>;<br />
::: <math>r_i=-1</math>, иначе.<br />
::Вторые <math>p</math> элементов (<math>i=p,1,...,2p-1</math>) являются копией первых <math>p</math> элементов:<br />
:::<math>r_i=r_{i-p}, i=p,1,...,2p-1.</math><br />
:2. Строится матрица Адамара <math>H</math>.<br />
::Элементы матрицы Адамара <math>H</math> находятся следующим образом:<br />
::: <math>h_{0j}=1, j=0,1, ... ,n-1;</math><br />
::: <math>h_{i0}=1, i=1,2, ... ,n-1;</math><br />
::: <math>h_{ij}=r_{j-i+p}, i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math><br />
<br />
=== Вычислительное ядро алгоритма ===<br />
<br />
Вычислительное ядро алгоритма состоит из <math>(n-1) \times (n-1)</math> операций присваивания следующего вида:<br />
<br />
:<math>h_{ij}=r_{j-i+p},</math> <math> i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math><br />
<br />
=== Макроструктура алгоритма ===<br />
<br />
Как видно из математического описания, алгоритм основан на простейших операциях с числами, поэтому макроструктура алгоритма полностью соответствует его математическому описанию.<br />
<br />
=== Схема реализации последовательного алгоритма ===<br />
<br />
Приведем процедуру на языке С++, реализующую описанный алгоритм. На вход процедуре подается порядок матрицы <math>n</math> и ссылка на заполняемую матрицу <math>result</math>. Считаем, что <math>n</math> положительно, делится на <math>4</math>, <math>n-1</math> - простое число, а размер матрицы <math>result</math> равен <math>n \times n</math>.<br />
<br />
<source lang="C"><br />
void buildHadamardMatrix(int n, vector< vector<int> > & result)<br />
{<br />
// 1) matrix size changing<br />
result.resize(n);<br />
for (int i=0; i<n; i++) {<br />
result[i].resize(n);<br />
}<br />
<br />
// 2) residue array building<br />
int p=n-1;<br />
vector<int> residues;<br />
residues.resize(2*p);<br />
for (int i=0; i<p; i++) {<br />
residues[i] = -1;<br />
}<br />
for (int i=1; i<= (p-1)/2; i++) {<br />
residues[i*i % p] = 1;<br />
}<br />
for (int i=p; i<2*p; i++) {<br />
residues[i] = residues[i-p];<br />
}<br />
// 3) Paley matrix building<br />
// first line filling<br />
for (int j=0; j<n; j++) {<br />
result[0][j] = 1;<br />
}<br />
// first column filling<br />
for (int i=1; i<n; i++) {<br />
result[i][0] = 1;<br />
}<br />
// others<br />
for (int i=1; i<n; i++) {<br />
for (int j=1; j<n; j++) {<br />
result[i][j] = residues[j-i+p];<br />
}<br />
}<br />
}<br />
</source><br />
<br />
=== Последовательная сложность алгоритма ===<br />
<br />
Под сложностью будем понимать зависимость числа операций от задаваемого порядка матрицы <math>n</math>. <br />
<br />
Основными операциями алгоритма являются:<br />
<br />
* <math>\frac{n}{2}-2</math> операций умножения;<br />
* <math>\frac{n}{2}-2</math> операций взятия остатка;<br />
* <math>n^2+\frac{5}{2}n-3</math> операций присваивания.<br />
<br />
Из чего следует, что алгоритм имеет квадратичную последовательную сложность.<br />
<br />
=== Информационный граф ===<br />
<br />
Информационный граф алгоритма можно представить в виде четырёх последовательных блоков. Первый блок содержит <math>n-1</math> параллельных ветвей, второй блок - <math>\frac{n}{2}-1</math> параллельных ветвей, третий - <math>n-1</math> и четвёртый - <math>n^2</math>.<br />
<br />
[[Файл:i_graph2.png|600px|thumb|center]]<br />
<br />
Каждая вершина из <math>A_1-A_{n-1}</math>, <math>C_1-C_{n-1}</math>, <math>D_1-D_{n^2}</math> соответствует операции присваивания, каждая вершина из <math>B_1-B_{\frac{n}{2}-1}</math> соответствует трём последовательным операциям: умножения, взятия остатка по модулю и присваивания, а вершины, окрашенные серым, представляют собой промежуточные точки синхронизации.<br />
<br />
[[Файл:i_graph3.jpg|600px|thumb|center|Информационный граф для n=4.]]<br />
На рисунке приведен информационный граф алгоритма для случая n=4. Вершины графа соответствуют следующим строчкам кода:<br />
<br />
a. residues[i] = -1;<br />
<br />
b. residues[i*i%p] = 1;<br />
<br />
c. residues[i] = residues[i-p];<br />
<br />
d. result[0][j] = 1;<br />
<br />
e. result[i][0] = 1;<br />
<br />
f. result[i][j] = residues[i-j+p];<br />
<br />
=== Ресурс параллелизма алгоритма ===<br />
<br />
Как видно из информационного графа алгоритма, в параллельном варианте необходимо последовательно выполнить следующие блоки:<br />
<br />
* <math>n-1</math> операций присваивания;<br />
* <math>\frac{n}{2}-1</math> участков, состоящих из трёх операций: умножения, взятия остатка и присваивания;<br />
* <math>n-1</math> операций присваивания;<br />
* <math>n^2</math> операций присваивания.<br />
<br />
Из этого можно сделать вывод, что высота ярусно-параллельной формы информационного графа равняется 6 (присваивание, умножение, взятие остатка, присваивание, присваивание, присваивание). Ширина ярусно-параллельной формы равняется <math>n^2</math>, что означает, что при использовании <math>n^2</math> процессоров матрица Адамара будет строиться за 6 операций.<br />
<br />
=== Входные и выходные данные алгоритма ===<br />
<br />
'''Входные данные:''' число <math>n</math> - порядок матрицы Адамара <math>H_n</math>. Дополнительные ограничения на <math>n</math>:<br />
* <math>n</math> - натуральное;<br />
* <math>n</math> делится на 4;<br />
* <math>n-1</math> - простое.<br />
'''Объем входных данных:''' 1 (число <math>n</math>).<br />
<br />
'''Выходные данные:''' построенная матрица Адамара <math>H_n</math> (её элементы <math>h_{ij}</math>).<br />
<br />
'''Объем выходных данных:''' <math>n^2</math> (количество элементов матрицы Адамара размера <math>n*n</math>).<br />
<br />
=== Свойства алгоритма ===<br />
<br />
Соотношение последовательной и параллельной сложности в случае неограниченных ресурсов является квадратичным. <br />
<br />
Вычислительная мощность алгоритма является постоянной (<math>O(1)</math>). <br />
<br />
Алгоритм является полностью детерминированным. <br />
<br />
Для вершин <math>A_1-A_{n-1}</math>, <math>B_1-B_{\frac{n}{2}-1}</math>, <math>C_1-C_{n-1}</math> информационного графа степени исхода являются линейными, что означает, что при возможности на этапе реализации необходимо позаботиться об эффективном доступе к элементам массива "<math>residues</math>".<br />
<br />
== Программная реализация алгоритма ==<br />
<br />
=== Особенности реализации последовательного алгоритма ===<br />
<br />
=== Локальность данных и вычислений ===<br />
<br />
=== Возможные способы и особенности параллельной реализации алгоритма ===<br />
<br />
=== Масштабируемость алгоритма и его реализации ===<br />
<br />
<br />
Исследование масштабируемости параллельной реализации алгоритма построения матрицы Адамара проводилось на суперкомпьютере «Ломоносов». Для этого была исследована собственная реализация алгоритма с использованием средств MPI. В ходе исследования было произведено множество запусков программы с различными значениями параметра <math>n</math> (размер матрицы Адамара) и числом процессоров.<br />
<br />
Набор и границы значений изменяемых параметров запуска реализации алгоритма:<br />
*число процессоров (p): [2,64] с шагом 2;<br />
*размер матрицы: простые числа в диапазоне [4,10000].<br />
<br />
В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:<br />
*минимальная эффективность реализации 0.0000036% при n=4, p=2;<br />
*максимальная эффективность реализации 0.333426% при n=948, p=2.<br />
<br />
Ниже представлены графики времени работы, производительности и эффективности данной реализации алгоритма построения матрицы Адамара в зависимости от изменяемых параметров запуска.<br />
[[Файл:time_graph1.png|500px|thumb|center|Время работы параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]<br />
[[Файл:perform_graph1.png|500px|thumb|center|Изменение производительности параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]<br />
[[Файл:efficiency_graph1.png|500px|thumb|center|Эффективность работы параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]<br />
<br />
<br />
[https://github.com/snikersman/Hadamard Исследованная параллельная реализация на языке C++]<br />
<br />
Построим оценки масштабируемости, используя полученные результаты:<br />
*По размерности задачи. Увеличение размерности задачи приводит к увеличению производительности.<br />
*По числу процессоров. С ростом числа процессоров растет производительность, но при малых размерностях задачи этот рост незначителен. Это связано с дополнительными издержками по записи в участок памяти каждого процессора вспомогательного массива вычетов, а также с обменом информации между процессорами.<br />
*По двум направлениям. При увеличении как числа процессоров, так и размерности задачи, производительность увеличивается. Причем чем больше используется процессоров, тем сильнее увеличивается производительность при увеличении размерности.<br />
<br />
=== Динамические характеристики и эффективность реализации алгоритма ===<br />
<br />
=== Выводы для классов архитектур ===<br />
<br />
=== Существующие реализации алгоритма ===<br />
<br />
Алгоритм построения матрицы Адамара реализован в различных математических пакетах и библиотеках: <br />
* [https://www.mathworks.com/help/matlab/ref/hadamard.html?requestedDomain=www.mathworks.com MATLAB] (вносятся дополнительные ограничения, когда n, или n/12, или n/20 являются степенями по основанию 2)<br />
* [http://r-survey.r-forge.r-project.org/survey/html/hadamard.html R]<br />
* [https://reference.wolframcloud.com/cloudplatform/ref/HadamardMatrix.html Wolfram Mathematica]<br />
* [http://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.linalg.hadamard.html SciPy для Python]<br />
<br />
== Литература ==</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9B%D0%B0%D0%BD%D1%86%D0%BE%D1%88%D0%B0_%D0%B4%D0%BB%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B8_%D1%81_%D0%BF%D0%BB%D0%B0%D0%B2%D0%B0%D1%8E%D1%89%D0%B5%D0%B9_%D1%82%D0%BE%D1%87%D0%BA%D0%BE%D0%B9_%D1%81_%D0%BF%D0%BE%D0%BB%D0%BD%D0%BE%D0%B9_%D0%BF%D0%B5%D1%80%D0%B5%D0%BE%D1%80%D1%82%D0%BE%D0%B3%D0%BE%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D0%B5%D0%B9&diff=22596Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией2017-05-03T13:40:33Z<p>Chernyavskiy: /* Литература */</p>
<hr />
<div>Основные авторы описания: [[Участник:Sagak|С.А.Айвазян]], [[Участник:Kozlov_Vladimir|В.Козлов]] (Часть 1), [[Участник:Chernyavskiy|А.Ю.Чернявский]] (компоновка и редактирование), [[Участник:ASA|А.С.Антонов]] (предварительная проверка).<br />
<br />
<br />
<br />
== Свойства и структура алгоритма ==<br />
===Общее описание алгоритма===<br />
Алгоритм Ланцоша <ref>Деммель Дж. Вычислительная линейна алгебра. Теория и приложения. -М.: Мир, 2001. - 430 c.</ref> <ref>Вербицкий В.В., Реут В.В. Введение в численные методы алгебры, 2015.</ref> – итерационный метод , созданный Корнелиусом Ланцошем, для нахождения собственных значений и собственных векторов симметричной матрицы. Суть алгоритма в том, что он сводит частичную проблему собственных значений симметричной вещественной матрицы к полной проблеме собственных значений для симметричной трехдиагональной матрицы меньшей размерности. Алгоритм применяется к матрицам большой размерности, к которым не применимы никакие прямые методы. <br />
<br />
Алгоритм Ланцоша относится к методам аппроксимаций, которые применяют широко распространенную в математике процедуру Релея-Ритца к матричным вычислениям, посредством чего сводят исходную задачу к задаче гораздо меньшего размера, решив которую, получаем приближенные собственные значения и собственные векторы исходной задачи. Метод основан на применении процедуры Релея-Ритца к последовательности вложенных подпространств Крылова.<br />
Важной особенностью подпространства Крылова является трехдиагонольность ортогональной проекции на него исходной матрицы, что способствует тому, что процедура <br />
Релея-Ритца прорабатывает очень эффективно. Главными особенностями поведения алгоритмов метода Ланцоша являются потеря ортогональности векторов базиса и быстрая сходимость в области наибольших по значению собственных значений. Наиболее популярными средствами борьбы с потерей ортогональности векторов Ланцоша являются различные варианты переортогонализации: частичная, полная и выборочная.<br />
<br />
Симметричность исходной матрицы позволяет хранить и вычислять чуть больше половины её элементов, что почти вдвое экономит как необходимые для вычислений объёмы памяти, так и количество операций. Также алгоритм позволяет использовать так называемый режим накопления, обусловленный тем, что значительную часть вычислений составляют вычисления скалярных произведений.<br />
<br />
Преимущество алгоритма заключается в том, что он дает приближение за конечное число шагов. Метод Ланцоша выигрывает в конкуренции таким прямым методам, как метод прямых или обратных итераций, <math>QR</math> и <math>QL</math> преобразования, методы вращений (вращения Якоби), которые потеряли значение как самостоятельные методы поиска собственных<br />
значений матриц большого размера. Также нужно заметить, что метод Ланцоша практически всегда эффективнее других методов аппроксимаций.<br />
<br />
=== Математическое описание алгоритма ===<br />
<br />
<br />
'''Алгоритм Ланцоша''' — это итерационный алгоритм поиска <math>k</math> приближённых собственных значений симметричной вещественной матрицы <math>A</math> размера <math>n \times n</math>. Алгоритм применяется, когда матрица <math>A</math> слишком велика, чтобы к ней можно было применять точные прямые методы вычисления собственных значений. Алгоритм комбинирует '''метод Рэлея — Ритца''' поиска приближённых собственных значений и '''метод Ланцоша''' построения крыловского подпространства.<br />
<br />
Метод Рэлея — Ритца является методом поиска <math>k</math> приближённых собственных значений симметричной вещественной матрицы <math>A</math> размера <math>n \times n</math>. Если <math>Q = [Q_k, Q_u]</math> — ортонормированная матрица размера <math>n \times n</math>, <math>Q_k</math> имеет размер <math>n \times k</math>, <math>Q_u</math> имеет размер <math>n \times n - k</math>, то можно записать равенство<br />
<br />
<math>T = Q^T A Q = [Q_k, Q_u]^T A [Q_k, Q_u] = <br />
\left[ \begin{array}{cc}<br />
Q_k^T A Q_k & Q_k^T A Q_u\\<br />
Q_u^T A Q_k & Q_u^T A Q_u<br />
\end{array} \right]<br />
= \left[ \begin{array}{cc}<br />
T_{k} & T_{ku}^T\\<br />
T_{ku} & T_{u}<br />
\end{array} \right].</math><br />
<br />
Метод Рэлея — Ритца заключается в том, что собственные значения матрицы <math>T_k = Q_k^T A Q_k</math> объявляются приближёнными собственными значениями матрицы <math>A</math>. Такое приближение является в некотором смысле «наилучшим»: можно показать, что если <math>T_k = V \Lambda V^{-1}</math> — спектральное разложение <math>T_k</math>, то пара <math>(Q_k V, \Lambda)</math> минимизирует функционал <math>L(P_k, D) = \Vert A P_k - P_k D \Vert_2</math>, причём <math>L(Q_k V, \Lambda) = \Vert T_{ku} \Vert_2</math>, то есть <math>A \approx (Q_k V) \Lambda (Q_k V)^{-1}</math>. Из этого также видно, что метод Рэлея — Ритца позволяет получать приближения для собственных векторов матрицы <math>A</math>. Более того, можно показать, что собственные значения <math>T</math> отличаются от некоторых собственных значений <math>A</math> не более чем на <math>\Vert T_{ku} \Vert_2</math>. <br />
<br />
Метод Ланцоша — это метод построения матрицы <math>Q</math>, при использовании которого, во-первых, матрица <math>T</math> оказывается симметричной трёхдиагональной, во-вторых, столбцы <math>Q</math> и <math>T</math> вычисляются последовательно. Трёхдиагональность <math>T</math> приводит к следующим явлениям:<br />
# матрица <math>T_k</math> является трёхдиагональной матрицей меньшей размерности, а для трёхдиагональных матриц существуют высокоэффективные методы поиска собственных значений;<br />
# матрица <math>T_{ku}</math> имеет только один ненулевой (возможно) элемент — правый верхний, а значит, для оценки погрешности полученных собственных значений достаточно знать только этот элемент.<br />
<br />
В теории в методе Ланцоша для вычисления каждого следующего столбца <math>q_{j + 1}</math> матрицы <math>Q</math> достаточно знать только <math>q_{j - 1}</math> и <math>q_{j}</math> в силу трёхдиагональности матрицы <math>T</math>. На практике из-за ошибок округления, если не предпринимать специальных мер, набор векторов <math>q_{1}, \dots, q_{k}</math> перестаёт быть ортогональным. Для борьбы с этим явлением на каждом шаге метода Ланцоша приходится выполнять так называемую переортогонализацию — повторно запускать процесс ортогонализации Грама — Шмидта.<br />
<br />
Перейдем к описанию самого алгоритма.<br />
<br />
Исходные данные: симметричная вещественная матрица <math>A</math> — матрица, для которой будут вычисляться собственные значения, вектор <math>b</math> — начальное приближение для метода Ланцоша.<br />
<br />
Выходные данные: трёхдиагональная симметричная вещественная матрица <math>T_k = \left[ \begin{array}{cccc}<br />
\alpha_1 & \beta_1 & & \\<br />
\beta_1 & \ddots & \ddots & \\<br />
& \ddots & \ddots & \beta_{k - 1}\\<br />
& & \beta_{k - 1} & \alpha_k<br />
\end{array} \right]</math>, ортонормированный набор векторов <math>q_1, \dots, q_k</math>: <math>T_k = [q_1, \dots, q_k]^T A [q_1, \dots, q_k]</math>.<br />
<br />
Формулы метода:<br />
<br />
<math><br />
\begin{array}{l}<br />
q_1 = b / \Vert b \Vert_2\\<br />
j = \overline{1, k}:\\<br />
\quad z_j = A q_j \\<br />
\quad \alpha_j = q_j^T A q_j = q_j^T z_j \\<br />
\quad z_j' = z_j - \sum_{i=1}^j (z_j^T q_i) q_i \\<br />
\quad z_j'' = z_j' - \sum_{i=1}^j (z_j'^T q_i) q_i\\<br />
\quad \beta_j = \Vert z_j'' \Vert_2\\<br />
\quad q_{j+1} = z_j'' / \Vert z_j'' \Vert_2 = z_j''/\beta_j<br />
\end{array}<br />
</math> <br />
<br />
Собственные значения и собственные векторы матрицы <math>T_k</math> ищутся любым прямым алгоритмом.<br />
<br />
Вычисление <math>z_j', z_j''</math> — это полная переортогонализация <math>z_j</math> методом Грама — Шмидта. Двойной запуск практически гарантирует, что <math>z_j''</math> будет ортогонален <math>q_1, \dots, q_j</math>. Заметим, что <math>\sum_{i=1}^j (z^T q_i) q_i = Q_j Q_j^T z</math>, где <math>Q_j = [q_1, \dots, q_j]</math>, поэтому переортогонализацию можно переписать в виде <math>z'_j = z_j - Q_j Q_j^T z_j, z_j'' = z_j' - Q_j Q_j^T z_j'</math>.<br />
<br />
Если <math>\beta_j = 0</math> для какого-либо <math>j < k</math>, то <math>\Vert T_{ju}\Vert_2 = 0</math>, а значит, собственные значения <math>T_j</math> в точности совпадают с каким-то собственными значениями <math>A</math>. В этом случае дальнейшие вычисления прекращаются и либо используется полученная <math>T_j</math> размерности меньшей, чем <math>k</math>, либо процедура запускается заново с другим начальным вектором <math>b</math>.<br />
<br />
=== Вычислительное ядро алгоритма ===<br />
У алгоритма построения матрицы <math>T_k</math> в том виде, как он описан выше, можно выделить два ядра:<br />
# умножение матрицы <math>A</math> на вектор <math>q_j</math>: <math>z_j = A q_j</math> (<math>O(n^2)</math> умножений вещественных чисел);<br />
# переортогонализация: <math>z'_j = z_j - Q_j Q_j^T z_j,\; z_j'' = z_j' - Q_j Q_j^T z_j'</math> (<math>O(nk^2)</math> умножений вещественных чисел).<br />
<br />
<br />
=== Макроструктура алгоритма ===<br />
На макроуровне выделяем 3 основные операции:<br />
<br />
1. Умножение исходной матрицы <math>A</math> на очередной вектор базиса <math>q_p</math>.<br />
<br />
<math><br />
z=Aq_p. <br />
</math><br />
<br />
2. Повторное проведения процесса Грамма-Шмидта для ортогонализации посчитанного вектора <math>z</math> со всеми построенными ранее векторами базиса.<br />
<br />
<math><br />
z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i, </math> <br />
<br />
<math>z=z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i. </math> <br />
<br />
3.Непосредственное вычисление нового базисного вектора <math>q_{j+1}</math> и элементов <math><br />
\alpha_j<br />
</math>, <math> \beta_{j+1}<br />
</math> трехдиагональной матрицы.<br />
<br />
<math><br />
\alpha_j=q_j^Tz,<br />
</math><br />
<br />
<math>z=z-\alpha_jq_j-\beta_{j}q_{j-1}, </math><br />
<br />
<math>\beta_{j+1}=||z||,<br />
</math><br />
<br />
<math>q_{j+1}=z/\beta_{j+1}.</math><br />
<br />
=== Схема реализации последовательного алгоритма ===<br />
Последовательность исполнения метода следующая:<br />
<br />
Сначала заполняем начальные значения. <br />
<br />
<math><br />
\begin{align}<br />
& q_1=b/||b||,\\<br />
& \beta_1=0,\\<br />
&q_0=0, \\<br />
\end{align}<br />
</math><br />
<br />
где <math>b</math>-произвольный вектор.<br />
<br />
Далее выполняется основная процедура, которая строит ортонормированный базис подпространства Крылова для симметричной матрицы и трехдиагональную матрицу размерности <math>k</math>.<br />
<br />
Для всех <math>j</math> от <math>1</math> до <math>k</math> по нарастанию выполняются<br />
<br />
<math><br />
1.z=Aq_j, <br />
</math><br />
<br />
Вычисляем элемент, который будет находится на позиции <math>t_{j,j}</math> конечной матрицы <math>T_k</math>,<br />
<br />
<math><br />
2.\alpha_j=q_j^Tz,<br />
</math><br />
<br />
Чтобы гарантировать ортогональность базиса на каждой итерации цикла два раза проводим полную переортогонализацию, использую процесс Грамма-Шмидта,<br />
<br />
<math><br />
3.z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i, </math> <br />
<br />
<math>4.z=z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i, </math> <br />
<br />
После ортогонализации процедура продолжается следующим образом. <br />
<br />
<math>5.z=z-\alpha_jq_j-\beta_{j}q_{j-1}, </math><br />
<br />
Вычисляем элемент, который будет находится на позиции <math>t_{j,j+1}</math> и <math>t_{j+1,j}</math>,<br />
<br />
<math>6.\beta_{j+1}=||z||,<br />
</math><br />
<br />
Если <math>\beta_{j+1}=0</math>, то алгоритм завершается.<br />
<br />
<math>7.q_{j+1}=z/\beta_{j+1}.</math><br />
<br />
В конце каждой итерации получаем очередной вектор <math>q_{j+1}</math> базиса с единичной нормой, который ортогонален всем предыдущим векторам базиса,<br />
<br />
и элементы <math>\alpha_j</math>, <math>\beta_{j+1}</math> трехдиагональной матрицы размерности <math>k</math> .<br />
<br />
<br />
=== Последовательная сложность алгоритма ===<br />
На <math>j</math>-ой итерации алгоритм выполняет<br />
* <math>n^2 + n + 4nj + n + n = n^2 + 3n + 4nj</math> умножений и делений;<br />
* <math>n(n - 1) + (n - 1) + (4n - 2)j + (n - 1) = n^2 + (n - 2) + (4n - 2)j</math> сложений и вычитаний;<br />
* одно извлечение квадратного корня.<br />
<br />
Всего за <math>k</math> итераций алгоритм выполняет<br />
* <math>(n + 3)nk + 2nk(k + 1)</math> умножений и делений;<br />
* <math>(n^2 + n - 2)k + (2n - 1)k(k + 1)</math> сложений и вычитаний.<br />
<br />
Таким образом, алгоритм имеет последовательную сложность <math>O(n^2k + nk^2)</math>.<br />
<br />
=== Информационный граф===<br />
<br />
Представим информационные графы разных уровней алгоритма.<br />
<br />
====Информационный граф на уровне макроопераций с входными и выходными данными====<br />
<br />
[[Файл:Lanczoc-full-orth-macro.png|thumb|1000px|center|alt=Информационный граф алгоритма Ланцоша на уровне отдельных итераций|Рисунок 1. Информационный граф алгоритма Ланцоша на уровне итераций с входными и выходными данными. In — входные данные (матрица <math>A</math> и вектор <math>b</math>), Out — выходные данные (<math>\alpha_j, \beta_j</math> и <math>q_j</math>), nrm — вычисление еклидовой нормы вектора, / — деление вектора на число, Iter — итерации алгоритма.]]<br />
<br />
<br />
====Информационный граф на уровне одной итерации с входными и выходными данными====<br />
<br />
<br />
[[Файл:Lanczoc-full-orth-iter.png|thumb|1000px|center|alt=Информационный граф алгоритма Ланцоша на уровне отдельных итераций|Рисунок 2. Информационный граф итерации алгоритма Ланцоша на уровне макроопераций (первые три итерации). In — входные данные (матрица <math>A</math>), Out — выходные данные (<math>\alpha_j, \beta_j</math> и <math>q_j</math>), dprod — скалярное произведение векторов, mprod — произведение матрицы на вектор, - — разность векторов, nrm — вычисление еклидовой нормы вектора, / — деление вектора на число.]]<br />
<br />
====Общий информационный граф алгроитма====<br />
<br />
<br />
[[Файл:photo.jpg|thumb|center|alt=Общий информационный граф алгроитма Ланцоша|Рисунок 3. Общий информационный граф алгроитма алгоритма Ланцоша.]]<br />
<br />
<br />
* Вершина черного цвета соответствует операции <math>Aq_j,</math>.<br />
* Вершина красного цвета соответствует операции скалярного произведения <math>q_j^Tz</math>.<br />
* Вершина сиреневого цвета соответствует операции <math>z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i</math>.<br />
* Вершина желтого цвета соответствует операции <math>z-\alpha_jq_j-\beta_{j-1}q_{j-1}</math>.<br />
* Вершина синего цвета соответствует операции <math>||z||</math>.<br />
* Вершина зеленого цвета соответствует операции <math>z/\beta_j</math>.<br />
<br />
=== Ресурс параллелизма алгоритма ===<br />
Для реализации <math>j</math>-ой итерации алгоритма нужно выполнить следующие ярусы:<br />
# <math>n</math> ярусов сложений с <math>n</math> операциями умножения в каждом (вычисление <math>z</math>);<br />
# <math>n</math> ярусов сложений с <math>1</math> операцией умножения в каждом (вычисление <math>\alpha_j</math>);<br />
# <math>j</math> ярусов сложений с <math>n</math> операциями умножения в каждом, <math>n</math> ярусов сложений с <math>j</math> операциями умножения в каждом, <math>1</math> ярус вычитаний размера <math>n</math> (первая переортогонализация);<br />
# <math>j</math> ярусов сложений с <math>n</math> операциями умножения в каждом, <math>n</math> ярусов сложений с <math>j</math> операциями умножения в каждом, <math>1</math> ярус вычитаний размера <math>n</math> (вторая переортогонализация);<br />
# <math>n</math> ярусов сложений с <math>1</math> операцией умножения в каждом (вычисление <math>\beta_j</math>);<br />
# <math>1</math> ярус делений размера <math>n</math> (вычисление <math>q_{j + 1}</math>).<br />
<br />
Итого ширина ЯПФ одной итерации составляет <math>O(n)</math>, высота — <math>4n + 2j + 3</math>. Ширина ЯПФ всего алгоритма составляет <math>O(n)</math>, высота — <math>O(nk + k^2)</math>.<br />
<br />
<br />
=== Входные и выходные данные алгоритма ===<br />
'''Входные данные''': плотная матрица <math>A</math> (элементы <math>a_{ij}</math>),произвольный вектор ненулевой <math>b</math>, количество итераций <math>k</math>.<br />
<br />
Дополнительные ограничения:<br />
* <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>..<br />
'''Объём входных данных''': <math>\frac{n (n + 3)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы).<br />
<br />
'''Выходные данные''': трехдиагональная симметрическая матрица <math>T</math> (элементы <math>_{ij}</math>), либо два вектора <math>a</math> и <math>b</math> размерности <math>k</math>.<br />
<br />
'''Объём выходных данных''': <math>2k</math> (в силу трехдиагональности симметричности достаточно хранить только ненулевые элементы). В разных реализациях эта экономия хранения может быть выполнена разным образом.<br />
<br />
<br />
=== Свойства алгоритма ===<br />
Сам по себе алгоритм Ланшоца не является устойчивым, так как из-за округлений ортогональность построенных векторов подпространства Крылова быстро теряется, вплоть до того, что некоторые из них становятся линейно зависимыми, что влечет к отсутствию приближения собственных векторов и собственных значений исходной матрицы. Однако, рассмотренный вариант с полной ортогонализацией как раз-таки делает алгоритм устойчивым.<br />
<br />
Количество операций умножения и количество операций сложения имеют один и тот же порядок, но они явно преобладают над операцией взятия корня. Также сбалансированы между собой арифметические операции и операции обращений в память. Алгоритм обрабатывает матрицу и вектора и считает множество скалярных произведений, следовательно обеспечивается хорошая сбалансированность операций между параллельными ветвями алгоритма. <br />
Соотношение последовательной и параллельной сложности <math>O(n)</math>.<br />
<br />
При этом вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных равняется <math>O(k)</math>. Алгоритм недетерминированный, так как если в какой-то итерации <math>b_j=0</math>, то алгоритм останавливается. Также на недетерминированность может повлиять изменение порядка выполнения ассоциативных операций, в частности при вычислении скалярного произведения. <br />
<br />
"Длинных" дуг в информационном графе нет, запись данных происходит предсказуемо(на каждом шаге заполняются следующие элементы выходных векторов), следовательно нет никаких потенциальных сложностей с размещением данных в иерархии памяти компьютера на этапе выполнения программы.<br />
<br />
<br />
== Программная реализация алгоритма ==<br />
<br />
<br />
=== Особенности реализации последовательного алгоритма ===<br />
=== Локальность данных и вычислений ===<br />
=== Возможные способы и особенности параллельной реализации алгоритма ===<br />
=== Масштабируемость алгоритма и его реализации ===<br />
Первое исследование масштабируемости проводилось на 1U сервере со следующими характеристиками:<br />
* 2 x Intel® Xeon® Processor E5-2697 v2;<br />
* 128GB RAM;<br />
Набор изменяемых параметров запуска реализации алгоритма и границы значений параметров алгоритма:<br />
*Число процессоров <math>1,2,4,8,16,32,48</math><br />
*Размерность матрицы <math>[1000:16000]</math><br />
*Количество итераций <math>10</math><br />
Использовался компилятор g++ версии 5.4.0 с параметрами запуска: <br />
*-fopenmp <br />
*-std=c++11<br />
Реализация алгоритма написана с использованием стандарта OpenMP.<br />
[[Файл:just2.png|thumb|center|1024px|Рисунок 4. Зависимость производительности от числа процессов и размера входной матрицы]]<br />
[http://pastebin.com/iurnjf8f Используемая параллельная реализация алгоритма на языке C++]<br />
<br />
Как видно из графика, размер задачи не оказывает существенного влияния на производительность. С увеличением количества процессоров производительность сначала возрастает, затем медленно убывает. Высокая производительность достигается при работе 20-30 процессоров, при дальнейшем увеличении числа процессоров накладные расходы на организацию параллельного вычисления ведут к уменьшению производительности.<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
Следующее исследование масштабируемости реализации алгоритма проводилось с использованием стандарта MPI на суперкомпьютере "Ломоносов" суперкомпьютерного комплекса Московского университета.<br />
<br />
Набор изменяемых параметров запуска реализации алгоритма и границы значений параметров алгоритма:<br />
*Число процессоров <math>1,2,4,8,16,32,64,96,128</math><br />
*Размерность матрицы <math> 1000:15000,1700,21000,25000,30000</math><br />
*Количество итераций <math>500</math><br />
Сборка осуществлялась с параметрами: <br />
*openmpi/1.5.5-icc<br />
*intel/13.1.0<br />
[[Файл:just5.png|thumb|center|1024px|Рисунок 4. Зависимость производительности от числа процессов и размера входной матрицы]]<br />
[[Файл:just6.png|thumb|center|1024px|Рисунок 4. Зависимость времени выполнения от числа процессов и размера входной матрицы]]<br />
[http://pastebin.com/5id6w9is Используемая параллельная реализация алгоритма на языке C++]<br />
<br />
При увеличении числа процессов производительность возрастает на всей рассмотренной области изменений параметров запуска. Увеличение размера задачи так же повышает производительность в рассматриваемой области, как и при увеличении количества процессоров, но при размерах задачи больше 25000 наблюдается медленный спад. Это снижение производительности объясняется тем, что при увеличении размера задачи существенно возрастают объемы передаваемых данных между процессами.<br />
<br />
=== Динамические характеристики и эффективность реализации алгоритма ===<br />
=== Выводы для классов архитектур ===<br />
<br />
=== Существующие реализации алгоритма ===<br />
NAG Library имеет множество процедур для решения система алгебраических уравнений и нахождения собственных значений, которые используют алгоритм Ланцоша.<br />
<br />
http://www.nag.com/content/nag-library C, C++, Fortran, C#, MATLAB, R.<br />
<br />
MATLAB содержит реализацию алгоритма в пакете Gaussian Belief Propagation Matlab Package.<br />
<br />
http://www.cs.cmu.edu/~bickson/gabp/.<br />
<br />
GraphLab имеет библиотеку, в которой есть огромное количество параллельных реализаций алгоритма Ланцоша <br />
<br />
https://turi.com/products/create/open_source.html C++.<br />
<br />
В LANSO/PLANSO есть параллельная версия алгоритма<br />
<br />
http://web.cs.ucdavis.edu/~bai/ET/lanczos_methods/overview_PLANSO.html Fortran.<br />
<br />
== Литература ==<br />
<br />
<references \><br />
<br />
<br />
[[Категория:Статьи в работе]]</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%C2%AB%D1%80%D0%B0%D0%B7%D0%B4%D0%B5%D0%BB%D1%8F%D0%B9_%D0%B8_%D0%B2%D0%BB%D0%B0%D1%81%D1%82%D0%B2%D1%83%D0%B9%C2%BB_%D0%B2%D1%8B%D1%87%D0%B8%D1%81%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F_%D1%81%D0%BE%D0%B1%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D1%8B%D1%85_%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B9_%D0%B8_%D0%B2%D0%B5%D0%BA%D1%82%D0%BE%D1%80%D0%BE%D0%B2_%D1%81%D0%B8%D0%BC%D0%BC%D0%B5%D1%82%D1%80%D0%B8%D1%87%D0%BD%D0%BE%D0%B9_%D1%82%D1%80%D0%B5%D1%85%D0%B4%D0%B8%D0%B0%D0%B3%D0%BE%D0%BD%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B9_%D0%BC%D0%B0%D1%82%D1%80%D0%B8%D1%86%D1%8B&diff=22595Метод «разделяй и властвуй» вычисления собственных значений и векторов симметричной трехдиагональной матрицы2017-05-03T13:40:11Z<p>Chernyavskiy: </p>
<hr />
<div>Основные авторы описания: [[Участник:Роман_Землянский|Р.Землянский]] (Разделы <br />
[[#Общее описание алгоритма|1.1]], [[#Математическое описание алгоритма|1.2]], [[#Последовательная сложность алгоритма|1.6]], [[#Ресурс параллелизма алгоритма|1.8]], [[#Входные и выходные данные алгоритма|1.9]], [[#Свойства алгоритма|1.10]]), В.Завольсков (Разделы [[#Вычислительное ядро алгоритма|1.3]], [[#Макроструктура алгоритма|1.4]], [[#Схема реализации последовательного алгоритма|1.5]], [[#Информационный граф|1.7]], [[#Существующие реализации алгоритма|2.7]]), [[Участник:IgorS]] (предварительная проверка), [[Участник:Chernyavskiy|А.Ю. Чернявский]] (проверка, редактирование).<br />
<br />
<br />
{{algorithm<br />
| name = Метод "Разделяй и властвуй" вычисления собственных значений и векторов трёхдиагональной матрицы<br />
| serial_complexity = <math> c\frac{4}{3}n^{3} </math><br />
| parallel_complexity = <math> O(n^{2.3}) </math><br />
<br />
крайне редко: <math> O(n^{2}) </math> <br />
| pf_width = <br />
| input_data = <math> 2n + 1 </math><br />
| output_data = <math> n(n + 1) </math><br />
}}<br />
<br />
<br />
= Свойства и структура алгоритмов =<br />
== Общее описание алгоритма ==<br />
'''Метод разделяй и властвуй вычисления собственных значений и векторов трёхдиагональной матрицы''' - это наиболее быстрый из существующих методов, если нужны все собственные значения и собственные векторы трехдиагональной матрицы, начиная с порядка n, примерно равного 26. (Точное значение этого порогового порядка зависит от компьютера.) Его численно устойчивая реализация весьма не тривиальна. В самом деле, хотя впервые метод был предложен еще в 1981 г., "правильный" способ его реализации был найден лишь в 1992 г. Этот способ воплощен LAPACK-программами ssyevd (для плотных матриц) и sstevd (для трехдиагональных матриц). В них стратегия "разделяй-и-влавствуй" используется для матриц порядка, большего чем 25. Для матриц меньшего порядка (или если нужны только собственные значения) происходит автоматический переход к QR-итерации.<br />
<br />
== Математическое описание алгоритма ==<br />
Пусть <br />
<br />
:<math><br />
T = \begin{bmatrix}<br />
a_{1} & b_{1}&&&&& \\<br />
b_{1} & \ddots & \ddots \\<br />
& \ddots & a_{m-1} & b_{m-1} \\<br />
&& b_{m-1} & a_{m} & b_{m} \\<br />
&&& b_{m} & a_{m+1} & b_{m+1} \\<br />
&&&& b_{m+1} & \ddots \\<br />
&&&&&& \ddots & b_{n-1} \\<br />
&&&&&& b_{n-1} & a_{n} \\<br />
\end{bmatrix}<br />
= \begin{bmatrix}<br />
a_{1} & b_{1} &&&&& \\<br />
b_{1} & \ddots & \ddots \\<br />
& \ddots & a_{m-1} & b_{m-1} \\<br />
&& b_{m-1} & a_{m} - b_{m} \\<br />
&&&& a_{m+1} - b_{m} & b_{m+1} \\<br />
&&&& b_{m+1} & \ddots \\<br />
&&&&&& \ddots & b_{n-1} \\<br />
&&&&&& b_{n-1} & a_{n} \\<br />
\end{bmatrix} +<br />
</math><br />
<br />
<math><br />
+ \begin{bmatrix}<br />
&&&&& \\<br />
&&b_{m} & b_{m} \\<br />
&&b_{m} & b_{m} \\<br />
&&&&& \\<br />
\end{bmatrix}<br />
<br />
= \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m} * \begin{bmatrix} 0 \\ \vdots \\ 0 \\ 1 \\ 1 \\ 0 \\ \vdots \\ 0 \end{bmatrix} \begin{bmatrix} 0 , \ldots , 0 , 1 , 1 , 0 \ldots , 0 \end{bmatrix} <br />
<br />
\equiv \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T}<br />
</math><br />
<br />
Предположим, что нам известны спектральные разложения матриц <math>T_{1}</math> и <math> T_{2} </math>: <br />
<math> T_{i} = Q_{i} \Lambda_{i} Q_{i}^{T} </math>. В действительности, они будут рекурсивно вычисляться тем же самым алгоритмом. Установим связь между собственными значениями матрицы Т и собственными значениями матриц<br />
<math>T_{1}</math> и <math>T_{2}</math>. Имеем:<br />
<br />
<math> <br />
T = \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T} <br />
= \begin{bmatrix} Q_{1} \Lambda_{1} Q_{1}^{T} & 0 \\ 0 & Q_{2} \Lambda_{2} Q_{2}^{T}\end{bmatrix} + b_{m}vv^{T} <br />
= \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}(\begin{bmatrix} \Lambda_{1} & \\ & \Lambda_{2}\end{bmatrix} + b_{m}uu^{T})\begin{bmatrix} Q_{1}^{T} & 0 \\ 0 & Q_{2}^{T}\end{bmatrix}<br />
</math>,<br />
<br />
где <br />
<br />
<math><br />
u = \begin{bmatrix} Q_{1}^{T} & 0 \\ 0 & Q_{2}^{T}\end{bmatrix}v<br />
</math><br />
<br />
так как <math>v = \begin{bmatrix} 0 , \ldots , 0 , 1 , 1 , 0 \ldots , 0 \end{bmatrix}^T</math>, получим матрицу, состоящую из последнего столбца матрицы <math> Q_{1}^{T}</math> и первого столбца матрицы <math> Q_{2}^{T}</math>.<br />
<br />
Следовательно, <math>T</math> имеет те же собственные значения, что и подобная ей матрица <math>D + \rho uu^{T}</math>, <br />
где <math>D = \begin{bmatrix} \Lambda_{1} & 0 \\ 0 & \Lambda_{2}\end{bmatrix}</math> - диагональная матрица, <br />
<math>\rho = b_{m}</math> - число, а <math>u</math> - вектор. <br />
<br />
Будем предполагать, не ограничивая общности, что диагональные элементы <math>d_{1}, \ldots, d_{n}</math> матрицы <math>D</math> упорядочены по убыванию: <math>d_{n} <= \ldots <=d_{1}</math>.<br />
<br />
Чтобы найти собственные значения матрицы <math>D + \rho uu^{T}</math>, вычислим её характеристический многочлен, считая пока матрицу <math>D - \lambda I</math> невырожденной.<br />
Тогда<br />
<br />
<math>det(D + \rho uu^{T} - \lambda I) = det((D - \lambda I)(I + \rho (D- \lambda I)^{-1} uu^{T}))</math>.<br />
<br />
Поскольку <math>D - \lambda I</math> невырожденна, <math>det(I + \rho (D - \lambda I)^{-1}uu^{T}) = 0</math> тогда и только тогда, когда <math>\lambda</math> - собственное значение. Заметим, что матрица <math>I + \rho (D - \lambda I)^{-1}uu^{T}</math> получается из единичной добавлением матрицы ранга 1. Определитель такой матрицы легко вычислить.<br />
<br />
'''Лемма 1.''' Справедливо равенство <math>det(I + xy^{T}) = 1 + y^{T}x</math>, где <math>x</math> и <math>y</math> - векторы.<br />
<br />
Таким образом,<br />
<br />
<math>det(I + \rho (D - \lambda I)^{-1}uu^{T}) = 1 + \rho u^{T}(D - \lambda I)^{-1}u</math> <math> = 1 + \rho \sum_{i=1, n} \frac{u_{i}^{2}} {d_{i}-\lambda} \equiv f(\lambda)</math> , <br />
<br />
т.е. собственные значения матрицы <math>T</math> есть корни так называемого векового уравнения <math>f(\lambda) = 0</math>. Если все числа <math>d_{i}</math> различны и все <math>u_{i} <> 0</math> (случай общего положения), то <math>f(\lambda)</math> имеет график типа показанного на рис.1(где <math>n = 4</math> и <math>\rho > 0</math>).<br />
<br />
[[File:Graphics.PNG|thumb|center|800px|Рис. 1. График функции <math> f(\lambda) = 1 + \frac{0.5}{1 - \lambda} + \frac{0.5}{2 - \lambda} + \frac{0.5}{3 - \lambda} + \frac{0.5}{4 - \lambda}</math>]]<br />
<br />
Можно видеть, что прямая <math>y = 1</math> является горизонтальной асимптотой для этого графика, а прямые <math>\lambda = d_{i}</math> есть вертикальные асимптоты. Поскольку <math>f^{'}(\lambda) = \rho \sum_{i=1, n} \frac{u_{i}^{2}} {(d_{i}-\lambda)^{2}}> 0 </math>, функция возрастает всюду, кроме точек <math>\lambda = d_{i}</math>. Поэтому корни функции разделяются числами <math>d_{i}</math> и ещё один корень находится справа от точки <math>d_{1}</math> (на рис. 1 <math>d_{1} = 4</math>). (При <math>\rho<0</math> функция <math>f(\lambda)</math> всюду убывает и соответствующий корень находится слева от точки <math>d_{n}</math>). Для функции <math>f(\lambda)</math>, монотонной и гладкой на каждом из интервалов <math>(d_{i+1},d_{i})</math>, можно найти вариант метода Ньютона, который быстро и монотонно сходится к каждому из корней, если начальная точка взята в <math>(d_{i+1},d_{i})</math>. Нам достаточно знать, что на практике метод сходится к каждому собственному значению за ограниченное число шагов. Поскольку вычисление <math>f(\lambda)</math> и <math>f^{'}(\lambda)</math> стоит <math>O(n)</math> флопов, для вычисления одного собственного значения достаточно <math>O(n)</math>, а для вычисления всех <math>n</math> собственных значений матрицы <math>D + \rho uu^{T}</math> требуется <math>O(n^{2})</math> флопов.<br />
Для собственных векторов матрицы <math>D + \rho uu^{T}</math> мы легко можем получить явные выражения.<br />
<br />
'''Лемма 2.''' Если <math>\alpha</math> - собственное значение матрицы <math>D + \rho uu^{T}</math>, то соответствующий вектор равен <math>(D - \alpha I)^{-1}u</math>. Поскольку матрица <math>D - \alpha I</math> диагональная, для вычисления такого вектора достаточно <math>O(n)</math> флопов.<br />
<br />
Доказательство.<br />
<br />
<math>(D + \rho uu^{T})[(D - \alpha I)^{-1}u] = (D - \alpha I + \alpha I + \rho uu^{T})(D - \alpha I)^{-1}u</math><br />
<br />
<math>=u + \alpha (D - \alpha I)^{-1}u + u[\rho u^{T}(D - \alpha I)^{-1}u] </math><br />
<br />
<math>=u + \alpha(D - \alpha I)^{-1}u - u</math> <br />
<br />
поскольку <math> \rho u^{T}(D - \alpha I)^{-1}u + 1 = f(\alpha) = 0 </math><br />
<br />
<math>=\alpha [(D - \alpha I)^{-1}u]</math>, что и требовалось.<br />
<br />
<br />
Для вычисления по этой простой формуле всех <math>n</math> собственных векторов требуется <math>O(n^{2})</math> флопов. К сожалению, формула не обеспечивает численной устойчивости, так как для двух очень близких значений <math>\alpha_{i}</math> может давать неортогональные приближенные собственные векторы <math>u_{i}</math>. Потребовалось целое десятилетие для того, чтобы найти устойчивую альтернативу исходному описанию алгоритма. Снова детали будут обсуждаться позднее в данном разделе. <br />
<br />
Алгоритм является рекурсивным.<br />
<br />
=== Дефляция ===<br />
<br />
До сих пор полагалось, что все <math>d_{i}</math> различны и все <math>u_{i}</math> отличны от нуля. Если это не так, вековое уравнение <math>f(\lambda)=0</math> имеет <math>k</math> вертикальных асимптот, где <math>k<n</math>, а потому <math>k</math> корней. Однако оказывается, что остальные <math>n - k</math> собственных значений могут быть определены без каких-либо усилий: если <math>d_{i}=d_{i+1}</math> или <math>u_{i}=0</math>, то легко показать, что <math>d_{i}</math> является собственным значением и для матрицы <math>D + \rho uu^{T}</math>. В такой ситуации мы говорим о ''дефляции''. На практике выбирается некоторое пороговое значение и дефляция для числа <math>d_{i}</math> регистрируется, если в смысле этого порога <math>d_{i}</math> достаточно близко к <math>d_{i+1}</math> либо <math>u_{i}</math> достаточно мало.<br />
<br />
Основной выигрыш от использования дефляции состоит не в том, что убыстряется решение векового уравнения - этот этап в любом случае стоит лишь <math>O(n^{2})</math> операций. Выигрыш заключается в ускорении матричного умножения на последнем шаге алгоритма. Действительно, если <math>u_{i}=0</math>, то соответствующий собственный вектор есть i-й столбец <math>e_{i}</math> единичной матрицы. Это означает, что <math>e_{i}</math> является i-м столбцом в матрице <math>Q_{'}</math>, поэтому при формировании матрицы <math>Q</math> посредством левого умножения <math>Q_{1}</math> на <math>Q_{2}</math> вычисление i-го столбца не требует никаких затрат. Аналогичное упрощение имеет место в случае <math>d_{i} = d_{i+1}</math>. При дефляции многих собственных значений устраняется большая часть работы, связанной с матричным умножением.<br />
<br />
=== Решение векового уравнения ===<br />
<br />
Подробно стоит поговорить о решении векового уравнения, которое является одной из основных частей алгоритма.<br />
<br />
Предположим, что некоторое <math>u_{i}</math>, хотя и мало, все же недостаточно мало для того, чтобы была зарегистрирована дефляция. В этом случае применение метода Ньютона к решению векового уравнения встречается с затруднениями. Вспомним, что пересчет приближённого решения <math>u_{j}</math> уравнения <math>f(\lambda) = 0</math> в методе Ньютона основан на следующих положениях:<br />
<br />
1. Вблизи точки <math>\lambda = \lambda_{j}</math> функция <math>f(\lambda)</math> аппроксимируется линейной функцией <math>l(\lambda)</math>; график есть прямая линия, касающаяся графика функции <math>f(\lambda)</math> при <math>\lambda = \lambda_{j}</math>.<br />
<br />
2. В качестве <math>\lambda_{j+1}</math> берётся нуль этого линейного приближения, т.е. <math>l(\lambda_{j+1})=0</math>.<br />
<br />
Функция, показанная на рис.1, не доставляет видимых трудностей методу Ньютона, поскольку вблизи каждого своего нуля <math>f(\lambda)</math> достаточно хорошо аппроксимируется линейными функциями. Однако рассмотрим график функции на рис.2. Она получена из функции на рис. 1 заменой значения .5 для <math>u_{i}^{2}</math> на .001. Это новое значение недостаточно мало для того, чтобы вызвать дефляцию. График функции в левой части рис.2 визуально не отличим от её вертикальных и горизонтальных асимптот, поэтому в правой части укрупненно воспроизведён фрагмент графика, прилегающий к вертикальной асимптоте <math>\lambda = 2</math>. Видно, что график слишком быстро "выполняет поворот" и для большей части значений <math>\lambda</math> почти горизонтален. Поэтому, применяя метод Ньютона почти к любому начальному приближению <math>\lambda_{0}</math>, мы получаем линейное приближение <math>l(\lambda)</math> с почти горизонтальным графиком и малым положительным угловым коэффициентом. В результате <math>\lambda_{1}</math> является отрицательным числом, огромным по абсолютной величине, которое совершенно бесполезно в качестве приближения к истинному корню.<br />
<br />
[[File:GraphNewton.png|thumb|center|800px|Рис. 2. График функции <math> f(\lambda) = 1 + \frac{10^{-3}}{1 - \lambda} + \frac{10^{-3}}{2 - \lambda} + \frac{10^{-3}}{3 - \lambda} + \frac{10^{-3}}{4 - \lambda}</math>]]<br />
<br />
Чтобы найти выход из этого положения, можно модифицировать метод Ньютона следующим образом: раз <math>f(\lambda)</math> нельзя хорошо приблизить линейной функцией <math>l(\lambda)</math>, попробуем взять в качестве приближения какую-нибудь другую простую функцию <math>h(\lambda)</math>. Нет ничего особого именно в прямых линиях: для метода Ньютона вместо <math>l(\lambda)</math> можно взять любое приближение <math>h(\lambda)</math>, значения и нули которого легко вычисляются. Функция <math>f(\lambda)</math> имеет полюсы в точках <math>d_{i}</math> и <math>d_{i+1}</math>, которые определяют её поведение в соответствующих окрестностях. Поэтому при поиске корня в интервале <math>(d_{i+1}, d_{i})</math> естественно выбрать функцию <math>h(\lambda)</math>, также имеющую эти полюсы, т.е. функцию вида<br />
<math>h(\lambda)= \frac{c_{1}}{d_{i}-\lambda} + \frac{c_{2}}{d_{i+1}-\lambda} + c_{3}</math><br />
<br />
Константы <math>c_{1},c_{2}</math> и <math>c_{3}</math> обеспечивающие, что <math>h(\lambda)</math> есть приближение к <math>f(\lambda)</math>, можно выбрать несколькими способами. Отметим, что если <math>c_{1},c_{2}</math> и <math>c_{3}</math> уже известны, то уравнение <math>h(\lambda)=0</math> легко решается относительно <math>\lambda</math>, поскольку сводится к эквивалентному квадратному уравнению<br />
<math>c_{1}(d_{i+1}-\lambda)+c_{2}(d_{i}-\lambda)+c_{3}(d_{i}-\lambda)(d_{i+1}-\lambda)=0</math><br />
<br />
Пусть <math>\lambda_{j}</math> - приближённое значение корня. определим <math>c_{1},c_{2}</math> и <math>c_{3}</math> так, чтобы<br />
<math>\frac{c_{1}}{d_{i}-\lambda} + \frac{c_{2}}{d_{i+1}-\lambda} + c_{3} = h(\lambda) \approx f(\lambda) = 1 + \rho \sum_{k=1, n} \frac{u_{k}^{2}} {d_{k}-\lambda} </math><br />
<br />
для <math>\lambda</math> в окрестности <math>\lambda_{j}</math>. Заметим, что<br />
<br />
<math>f(\lambda) = 1 + \rho \sum_{k=1, i} \frac{u_{k}^{2}} {d_{k}-\lambda} + \rho \sum_{k=i+1, n} \frac{u_{k}^{2}} {d_{k}-\lambda} \equiv 1 + \psi_{1}(\lambda) + \psi_{2}(\lambda)</math>.<br />
<br />
Если <math>\lambda \in (d_{i+1},d_{i})</math>, то <math>\psi_{1}(\lambda)</math> есть сумма положительных слагаемых, а <math>\psi_{2}(\lambda)</math> - сумма отрицательных. Поэтому и <math>\psi_{1}(\lambda)</math>, и <math>\psi_{2}(\lambda)</math> могут быть вычислены с высокой точностью; однако при их сложении вполне вероятно взаимное уничтожение верных разрядов и потеря относительной точности в сумме. Возьмем числа <math>c_{1}</math> и <math>\hat{c_{1}}</math>, такие, что функция <br />
<br />
<math>h_{1}(\lambda) \equiv \hat{c_{1}} + \frac{c_{1}}{d_{i}-\lambda}</math> удовлетворяет условиям <math>h_{1}(\lambda_{j}) = \psi_{1}(\lambda_{j})</math> и <math>h_{1}^{'}(\lambda_{j})=\psi_{1}^{'}(\lambda_{j})</math> (1)<br />
<br />
Это означает, что гипербола, являющаяся графиком функции <math>h_{1}(\lambda)</math>, касается графика функции <math>\psi_{i}(\lambda)</math> при <math>\lambda = \lambda_{j}</math>. Два условия в (1) - это обычные условия метода Ньютона, за исключением того, что вместо прямой в качестве приближения используется гипербола. Легко проверить, что <math>c_{1}=\psi_{1}^{'}(\lambda_{j})(d_{i} - \lambda_{j})^{2}</math> и <math>\hat{c_{1}}=\psi_{1}(\lambda_{j}) - \psi_{1}^{'}(\lambda_{j})(d_{i} - \lambda_{j})</math><br />
<br />
Подобным же образом выбираем <math>c_{2}</math> и <math>\hat{c_{2}}</math> так, чтобы функция <br />
<br />
<math>h_{2}(\lambda) \equiv \hat{c_{2}} + \frac{c_{2}}{d_{i+1}-\lambda}</math><br />
<br />
Удовлетворяла условиям<br />
<br />
<math>h_{2}(\lambda_{j}) = \psi_{2}(\lambda_{j})</math> и <math>h_{2}^{'}(\lambda_{j})=\psi_{2}^{'}(\lambda_{j})</math> (2)<br />
<br />
Наконец, полагаем<br />
<br />
<math>h(\lambda) = 1 + h_{1}(\lambda) + h_{2}(\lambda) = (1 + \hat{c_{1}} + \hat{c_{2}} + \frac{c_{1}}{d_{i}-\lambda} + \frac{c_{2}}{d_{i+1}-\lambda} </math><br />
<br />
<math>\equiv c_{3} + \frac{c_{1}}{d_{i}-\lambda} + \frac{c_{2}}{d_{i+1}-\lambda}</math>.<br />
<br />
== Вычислительное ядро алгоритма ==<br />
Вычислительным ядром последовательной схемы решения является вычисление матрицы <math>Q</math> собственных векторов путём умножения матрицы <math>Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}</math> на матрицу <math>Q^{'}</math> Данная операция имеет сложность <math>cn^{3}</math> о чём и говорится в разделе [[#Последовательная сложность алгоритма]] .<br />
Ей предшествует вычисление собственных значений и векторов матрицы <math> D + \rho uu^{T}</math><br />
<br />
== Макроструктура алгоритма ==<br />
Ниже описана структура алгоритма, в которой есть блок умножения матриц для вычисления собственных векторов, являющийся вычислительным ядром алгоритма. В соответствующем разделе ([[#Вычислительное ядро алгоритма]]) мы упоминали о том, что данному блоку предшествует вычисление собственных значений, которое производится [https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D0%9D%D1%8C%D1%8E%D1%82%D0%BE%D0%BD%D0%B0 методом Ньютона].<br />
<br />
[[File:DivideAndConquerTree.png|thumb|center|left|800px|Рис. 3. Дерево алгоритма "Разделяй и властвуй"]]<br />
<br />
[[File:InfoGraph.jpg|thumb|center|1200px|Рис. 4. Детальное описание одного блока алгоритма]]<br />
<br />
== Схема реализации последовательного алгоритма ==<br />
''Вычисление собственных значений и собственных векторов симметричной трехдиагональной матрицы посредством стратегии "разделяй и властвуй"'':<br />
<br />
<br />
''proc dc_eig''<math>(T,Q,\Lambda)...</math> по входной матрице <math>T</math> вычисляются выходные матрицы <math>Q</math> и <math>\Lambda</math>, такие, что <math>T = Q\Lambda Q^{T}</math><br />
<br />
'''Если <math>T</math> - матрица размера <math>1</math> x <math>1</math>'''<br />
<br />
1. Присвоить выходным параметрам значения <math> Q = 1, \Lambda = T</math><br />
<br />
'''Иначе'''<br />
<br />
1. Представить <math>T</math> в виде <math> T = \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T} </math><br />
<br />
2. ''call dc_eig''<math>(T_{1},Q_{1},\Lambda_{1})</math><br />
<br />
3. ''call dc_eig''<math>(T_{2},Q_{2},\Lambda_{2})</math><br />
<br />
4. Построить <math>D+\rho uu^{T}</math> по <math> \Lambda_{1},\Lambda_{2}, Q_{1}, Q_{2}</math><br />
<br />
5. Найти матрицу собственных значений <math>\Lambda</math><br />
<br />
6. Найти матрицу собственных векторов <math>Q^{'}</math> для матрицы <math>D+\rho uu^{T}</math><br />
<br />
7. Построить матрицу собственных векторов <math>Q</math> для матрицы <math>T</math> : <math> Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}* Q^{'} </math><br />
<br />
8. Присвоить выходным параметрам значения <math>Q</math> и <math>\Lambda</math><br />
<br />
'''endif'''<br />
<br />
== Последовательная сложность алгоритма ==<br />
Проанализируем сложность алгоритма. Пусть <math>t(n)</math> - число флопов при обработке матрицы размера <math> n x n</math> процедурой ''dc_eig''. Тогда <br />
<br />
<math> t(n) = 2t(n/2) </math> два рекурсивных обращения к ''dc_eig''<math>(T_{i},Q_{i},\Lambda_{i})</math><br />
<br />
<math> +O(n^{2})</math> вычисление собственных значений матрицы <math>D+\rho uu^{T}</math><br />
<br />
<math> +O(n^{2})</math> вычисление собственных векторов матрицы <math>D+\rho uu^{T}</math><br />
<br />
<math> +c*n^{3}</math> вычисление матрицы <math>Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}*Q^{'}</math><br />
<br />
<br />
Если <math> Q_{1}, Q_{2}</math> и <math>Q^{'}</math> рассматриваются как плотные матрицы и используется стандартный алгоритм матричного умножения, то константа <math> c </math> в последней строке равна 1. Таким образом, именно это умножение составляет наиболее трудоёмкую часть алгоритма в целом. Игнорируя члены порядка <math>n^{2}</math>, получаем <math>t(n) = 2t(n/2) + cn^{3}</math>. Решая это разностное уравнение, находим <math> t \approx c\frac{4}{3}n^{3} </math><br />
<br />
На практике константа <math>c</math> обычно гораздо меньше 1, потому что матрица <math>Q^{'}</math> весьма разрежена вследствие явления, называемого дефляцией.<br />
<br />
== Информационный граф ==<br />
В данном разделе на рисунке 5 представлен информационный граф алгоритма.<br />
<br />
[[File:InfoGraphSC.jpg|thumb|center|left|1200px|Рис. 5. Информационный граф алгоритма "Разделяй и властвуй" - шаг <b>Divide</b>]]<br />
<br />
Операции: <br />
<br />
<math>D</math> - операция Divide разделения матрицы <math> T </math> на матрицы <math>T_{1}</math> и <math>T_{2}</math><br />
<br />
Индексы - размерность <br />
<br />
<math>S_{k}</math> - операция Conquer сбора матрицы <math> D </math><br />
<br />
<math> L_{k} </math> - операция поиска собственных значений <br />
<br />
<math> S^{'} </math> - операция поиска собственных векторов матрицы <math> Q^{'} </math><br />
<br />
<math> S </math> - операция поиска собственных векторов матрицы <math> Q </math><br />
<br />
== Ресурс параллелизма алгоритма ==<br />
Рассмотрев информационный граф алгоритма, можно заметить, что в структуре имеется два параллельных блока - вызов рекурсивных функций ''dc_eig'' для вычисления собственных значений и векторов матриц <math>T_{1}</math> и <math>T_{2}</math> - это единственная часть алгоритма, в которой мы прибегаем к параллелизму. <br />
<br />
Рекурсивное разделение матрицы ведёт к иерархии вычислительных подблоков с графом зависимости данных, который выглядит, как двоичное дерево. Данная структура является естественным путем разделения вычислений между процессорами.<br />
<br />
В вершине дерева все процессы взаимодействуют. В каждой ветви дерева вычисление делится на два вычислительных подблока, внутри каждого из которых процессы параллельно взаимодействуют. В листьях деревьев каждый процесс занимается вычислением независимо.<br />
<br />
В случае реализации без параллелизма, функции ''dc_eig'' отрабатывают последовательно - сначала со входными параметрами <math>T_{1}, Q_{1}, \Lambda_{1}</math>, затем - <math>T_{2}, Q_{2}, \Lambda_{2}</math>.<br />
<br />
Таким образом, благодаря параллелизму высота алгоритма параллельного составляет <math>log_{2}(n)</math>, когда как при последовательной реализации высота алгоритма равна сумме геометрической прогрессии <math>1+2+4+8+...+2^{n-1} = 2^{n} - 1</math>, что значительно сокращает число итераций алгоритма.<br />
<br />
== Входные и выходные данные алгоритма ==<br />
'''Входные данные:''' <br />
<br />
На вход алгоритму подаётся трёхдиагональная симметричная матрица:<br />
<br />
<math><br />
L = \begin{bmatrix}<br />
a_{1} & b_{1}&&&&& \\<br />
b_{1} & \ddots & \ddots \\<br />
& \ddots & a_{m-1} & b_{m-1} \\<br />
&& b_{m-1} & a_{m} & b_{m} \\<br />
&&& b_{m} & a_{m+1} & b_{m+1} \\<br />
&&&& b_{m+1} & \ddots \\<br />
&&&&&& \ddots & b_{n-1} \\<br />
&&&&&& b_{n-1} & a_{n} \\<br />
\end{bmatrix}<br />
</math><br />
<br />
'''Объем входных данных:''' <br />
<br />
<math>2n + 1</math> - в силу симметрии, хранить следует только диагональные, поддиагональые и наддиагональные элементы.<br />
<br />
'''Выходные данные:'''<br />
<br />
На выходе мы получаем вектор собственных значений длины <math> n </math> и <math> n </math> собственных векторов длины <math> n </math> , соответствующих собственным значениям исходной матрицы.<br />
<br />
'''Объем выходных данных:'''<br />
<br />
<math> n + n^{2} = n(n + 1) </math><br />
<br />
== Свойства алгоритма ==<br />
Описанный в данной статье алгоритм является самым быстрым алгоритмом, среди существующих: QR / Бисекция и обратная итерация / Разделяй и властвуй.<br />
<br />
Последовательная сложность алгоритма (не принимая во внимание дефляцию) удовлетворяет рекурсивному соотношению: <br />
<br />
<math>t(n) = n^3 +2t(\frac{n}{2})</math><br />
<br />
Решение которого имеет вид:<br />
<br />
<math> t = c\frac{4}{3}n^{3} </math><br />
<br />
На практике же, параллельная сложность алгоритма в силу использования дефляции, позволяющей получить выигрыш в количестве операций, который заключается в ускорении матричного умножения на последнем шаге алгоритма (см. [[#Дефляция]]), имеет следующий вид: <math> O(n^{2.3})</math> или в самых редких случаях <math> O(n^{2}) </math> (см. [3] стр. 8).<br />
<br />
Особенности алгоритма:<br />
<br />
1. Использование дефляции ([[#Дефляция]])<br />
<br />
2. Использование адаптированного метода Ньютона ([[#Макроструктура алгоритма]])<br />
<br />
= Программная реализация алгоритма =<br />
Вторая часть описания алгоритмов в рамках AlgoWiki рассматривает все составные части процесса их реализации. Рассматривается как последовательная реализация алгоритма, так и параллельная. Описывается взаимосвязь свойств программ, реализующих алгоритм, и особенностей архитектуры компьютера, на которой они выполняются. Исследуется работа с памятью, локальность данных и вычислений, описывается масштабируемость и эффективность параллельных программ, производительность компьютеров, достигаемая на данной программе. Обсуждаются особенности реализации для разных классов архитектур компьютеров, приводятся ссылки на реализации в существующих библиотеках.<br />
<br />
<br />
== Особенности реализации последовательного алгоритма ==<br />
<br />
== Локальность данных и вычислений ==<br />
<br />
== Возможные способы и особенности параллельной реализации алгоритма ==<br />
== Масштабируемость алгоритма и его реализации ==<br />
Исследование проводилось на суперкомпьютере "Ломоносов" Суперкомпьютерного комплекса Московского университета.<br />
<br />
Набор и границы значений изменяемых параметров запуска реализации алгоритма: <br />
<br />
* число процессоров [1 : 8] (1,2,3,4,8);<br />
* размер матрицы [4 : 8192].<br />
<br />
Для исследования масштабируемости алгоритм был реализован на библиотеке OpenMP 1.5.5 для языка C++(компилятор g++) на cуперкомпьютере Ломоносов на узле compiler. Для данного узла максимально возможное число потоков - 8. В ходе оценки масштабируемости, программа была запущена в 1, 2, 4, 8 потока. <br />
Параметры компиляции и запуска: <br />
<br />
ssh compiler <br />
module add slurm<br />
module add openmpi/1.5.5-icc<br />
g++ _scratch/test.c++ -fopenmp -std=c++0x -o test <br />
sbatch -p test -n1 run ./test<br />
<br />
Для управления количеством потоков использовалась операция OpenMP omp_set_num_threads();<br />
<br />
[[File:ResultsDiagram.jpg|thumb|center|left|800px|Рис. 6. График времени работы программы в зависимости от числа процессов и размера задачи]]<br />
<br />
Масштабируемость рассматриваемой реализации алгоритма '''"Разделяй и властвуй"''':<br />
<br />
* При увеличении числа процессов общая эффективность программы увеличивается, т.к. время чтения и подготовки исходной матрицы остаётся неизменным, а время работы алгоритма уменьшается, однако рост незначительный.<br />
* При увеличении размерности матрицы общая эффективность программы постепенно уменьшается, т.к. время чтения и подготовки исходных данных растёт быстрее, чем время работы исследуемого алгоритма.<br />
* При одновременном увеличении как числа процессов, так и размерности матрицы общая эффективность программы уменьшается.<br />
<br />
Код исследуемой реализации представлен здесь [http://pastebin.com/QpfYZGkK pastebin.com]<br />
<br />
== Динамические характеристики и эффективность реализации алгоритма ==<br />
<br />
== Выводы для классов архитектур ==<br />
<br />
== Существующие реализации алгоритма ==<br />
Описываемый метод реализован в пакете LAPACK, описание которого можно найти в [http://www.netlib.org/lapack/lawnspdf/lawn132.pdf этой статье] на страницах 7, 19 и 20, которая указана в списке литературы.<br />
<br />
= Литература =<br />
[1] Дж. Деммель, «Вычислительная линейная алгебра» //С. 230-235<br />
<br />
[2] [http://www.netlib.org/utk/people/JackDongarra/PAPERS/104_1999_a-parallel-divide-and-conquer-algorithm.pdf Francoise Tisseury, Jack Dongarra, A Parallel Divide and Conquer Algorithm for the Symmetric Eigenvalue Problem on Distributed Memory Architectures]<br />
<br />
[3] [http://www.netlib.org/lapack/lawnspdf/lawn132.pdf Francoise Tisseury, Jack Dongarra, Parallelizing the Divide and Conquer Algorithm for the Symmetric Tridiagonal Eigenvalue Problem on Distributed Memory Architectures]<br />
<br />
[4] [https://en.wikipedia.org/wiki/Divide-and-conquer_eigenvalue_algorithm Алгоритм "Разделяй и властвуй" - Wikipedia]<br />
<br />
[5] [http://www.cscamm.umd.edu/tadmor/pub/linear-stability/Gill_Tadmor_SISC90.pdf Doron Grill and Eitan Tadmor AN <math>O(N2)</math> METHOD FOR COMPUTING THE EIGENSYSTEM OF <math>N</math>x<math>N</math> SYMMETRIC TRIDIAGONAL MATRICES BY THE DIVIDE AND CONQUER APPROACH]<br />
<br />
<br />
<br />
[[Категория:Статьи в работе]]</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9B%D0%B0%D0%BD%D1%86%D0%BE%D1%88%D0%B0_%D0%B4%D0%BB%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B8_%D1%81_%D0%BF%D0%BB%D0%B0%D0%B2%D0%B0%D1%8E%D1%89%D0%B5%D0%B9_%D1%82%D0%BE%D1%87%D0%BA%D0%BE%D0%B9_%D1%81_%D0%BF%D0%BE%D0%BB%D0%BD%D0%BE%D0%B9_%D0%BF%D0%B5%D1%80%D0%B5%D0%BE%D1%80%D1%82%D0%BE%D0%B3%D0%BE%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D0%B5%D0%B9&diff=22594Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией2017-05-03T13:39:09Z<p>Chernyavskiy: /* Существующие реализации алгоритма */</p>
<hr />
<div>Основные авторы описания: [[Участник:Sagak|С.А.Айвазян]], [[Участник:Kozlov_Vladimir|В.Козлов]] (Часть 1), [[Участник:Chernyavskiy|А.Ю.Чернявский]] (компоновка и редактирование), [[Участник:ASA|А.С.Антонов]] (предварительная проверка).<br />
<br />
<br />
<br />
== Свойства и структура алгоритма ==<br />
===Общее описание алгоритма===<br />
Алгоритм Ланцоша <ref>Деммель Дж. Вычислительная линейна алгебра. Теория и приложения. -М.: Мир, 2001. - 430 c.</ref> <ref>Вербицкий В.В., Реут В.В. Введение в численные методы алгебры, 2015.</ref> – итерационный метод , созданный Корнелиусом Ланцошем, для нахождения собственных значений и собственных векторов симметричной матрицы. Суть алгоритма в том, что он сводит частичную проблему собственных значений симметричной вещественной матрицы к полной проблеме собственных значений для симметричной трехдиагональной матрицы меньшей размерности. Алгоритм применяется к матрицам большой размерности, к которым не применимы никакие прямые методы. <br />
<br />
Алгоритм Ланцоша относится к методам аппроксимаций, которые применяют широко распространенную в математике процедуру Релея-Ритца к матричным вычислениям, посредством чего сводят исходную задачу к задаче гораздо меньшего размера, решив которую, получаем приближенные собственные значения и собственные векторы исходной задачи. Метод основан на применении процедуры Релея-Ритца к последовательности вложенных подпространств Крылова.<br />
Важной особенностью подпространства Крылова является трехдиагонольность ортогональной проекции на него исходной матрицы, что способствует тому, что процедура <br />
Релея-Ритца прорабатывает очень эффективно. Главными особенностями поведения алгоритмов метода Ланцоша являются потеря ортогональности векторов базиса и быстрая сходимость в области наибольших по значению собственных значений. Наиболее популярными средствами борьбы с потерей ортогональности векторов Ланцоша являются различные варианты переортогонализации: частичная, полная и выборочная.<br />
<br />
Симметричность исходной матрицы позволяет хранить и вычислять чуть больше половины её элементов, что почти вдвое экономит как необходимые для вычислений объёмы памяти, так и количество операций. Также алгоритм позволяет использовать так называемый режим накопления, обусловленный тем, что значительную часть вычислений составляют вычисления скалярных произведений.<br />
<br />
Преимущество алгоритма заключается в том, что он дает приближение за конечное число шагов. Метод Ланцоша выигрывает в конкуренции таким прямым методам, как метод прямых или обратных итераций, <math>QR</math> и <math>QL</math> преобразования, методы вращений (вращения Якоби), которые потеряли значение как самостоятельные методы поиска собственных<br />
значений матриц большого размера. Также нужно заметить, что метод Ланцоша практически всегда эффективнее других методов аппроксимаций.<br />
<br />
=== Математическое описание алгоритма ===<br />
<br />
<br />
'''Алгоритм Ланцоша''' — это итерационный алгоритм поиска <math>k</math> приближённых собственных значений симметричной вещественной матрицы <math>A</math> размера <math>n \times n</math>. Алгоритм применяется, когда матрица <math>A</math> слишком велика, чтобы к ней можно было применять точные прямые методы вычисления собственных значений. Алгоритм комбинирует '''метод Рэлея — Ритца''' поиска приближённых собственных значений и '''метод Ланцоша''' построения крыловского подпространства.<br />
<br />
Метод Рэлея — Ритца является методом поиска <math>k</math> приближённых собственных значений симметричной вещественной матрицы <math>A</math> размера <math>n \times n</math>. Если <math>Q = [Q_k, Q_u]</math> — ортонормированная матрица размера <math>n \times n</math>, <math>Q_k</math> имеет размер <math>n \times k</math>, <math>Q_u</math> имеет размер <math>n \times n - k</math>, то можно записать равенство<br />
<br />
<math>T = Q^T A Q = [Q_k, Q_u]^T A [Q_k, Q_u] = <br />
\left[ \begin{array}{cc}<br />
Q_k^T A Q_k & Q_k^T A Q_u\\<br />
Q_u^T A Q_k & Q_u^T A Q_u<br />
\end{array} \right]<br />
= \left[ \begin{array}{cc}<br />
T_{k} & T_{ku}^T\\<br />
T_{ku} & T_{u}<br />
\end{array} \right].</math><br />
<br />
Метод Рэлея — Ритца заключается в том, что собственные значения матрицы <math>T_k = Q_k^T A Q_k</math> объявляются приближёнными собственными значениями матрицы <math>A</math>. Такое приближение является в некотором смысле «наилучшим»: можно показать, что если <math>T_k = V \Lambda V^{-1}</math> — спектральное разложение <math>T_k</math>, то пара <math>(Q_k V, \Lambda)</math> минимизирует функционал <math>L(P_k, D) = \Vert A P_k - P_k D \Vert_2</math>, причём <math>L(Q_k V, \Lambda) = \Vert T_{ku} \Vert_2</math>, то есть <math>A \approx (Q_k V) \Lambda (Q_k V)^{-1}</math>. Из этого также видно, что метод Рэлея — Ритца позволяет получать приближения для собственных векторов матрицы <math>A</math>. Более того, можно показать, что собственные значения <math>T</math> отличаются от некоторых собственных значений <math>A</math> не более чем на <math>\Vert T_{ku} \Vert_2</math>. <br />
<br />
Метод Ланцоша — это метод построения матрицы <math>Q</math>, при использовании которого, во-первых, матрица <math>T</math> оказывается симметричной трёхдиагональной, во-вторых, столбцы <math>Q</math> и <math>T</math> вычисляются последовательно. Трёхдиагональность <math>T</math> приводит к следующим явлениям:<br />
# матрица <math>T_k</math> является трёхдиагональной матрицей меньшей размерности, а для трёхдиагональных матриц существуют высокоэффективные методы поиска собственных значений;<br />
# матрица <math>T_{ku}</math> имеет только один ненулевой (возможно) элемент — правый верхний, а значит, для оценки погрешности полученных собственных значений достаточно знать только этот элемент.<br />
<br />
В теории в методе Ланцоша для вычисления каждого следующего столбца <math>q_{j + 1}</math> матрицы <math>Q</math> достаточно знать только <math>q_{j - 1}</math> и <math>q_{j}</math> в силу трёхдиагональности матрицы <math>T</math>. На практике из-за ошибок округления, если не предпринимать специальных мер, набор векторов <math>q_{1}, \dots, q_{k}</math> перестаёт быть ортогональным. Для борьбы с этим явлением на каждом шаге метода Ланцоша приходится выполнять так называемую переортогонализацию — повторно запускать процесс ортогонализации Грама — Шмидта.<br />
<br />
Перейдем к описанию самого алгоритма.<br />
<br />
Исходные данные: симметричная вещественная матрица <math>A</math> — матрица, для которой будут вычисляться собственные значения, вектор <math>b</math> — начальное приближение для метода Ланцоша.<br />
<br />
Выходные данные: трёхдиагональная симметричная вещественная матрица <math>T_k = \left[ \begin{array}{cccc}<br />
\alpha_1 & \beta_1 & & \\<br />
\beta_1 & \ddots & \ddots & \\<br />
& \ddots & \ddots & \beta_{k - 1}\\<br />
& & \beta_{k - 1} & \alpha_k<br />
\end{array} \right]</math>, ортонормированный набор векторов <math>q_1, \dots, q_k</math>: <math>T_k = [q_1, \dots, q_k]^T A [q_1, \dots, q_k]</math>.<br />
<br />
Формулы метода:<br />
<br />
<math><br />
\begin{array}{l}<br />
q_1 = b / \Vert b \Vert_2\\<br />
j = \overline{1, k}:\\<br />
\quad z_j = A q_j \\<br />
\quad \alpha_j = q_j^T A q_j = q_j^T z_j \\<br />
\quad z_j' = z_j - \sum_{i=1}^j (z_j^T q_i) q_i \\<br />
\quad z_j'' = z_j' - \sum_{i=1}^j (z_j'^T q_i) q_i\\<br />
\quad \beta_j = \Vert z_j'' \Vert_2\\<br />
\quad q_{j+1} = z_j'' / \Vert z_j'' \Vert_2 = z_j''/\beta_j<br />
\end{array}<br />
</math> <br />
<br />
Собственные значения и собственные векторы матрицы <math>T_k</math> ищутся любым прямым алгоритмом.<br />
<br />
Вычисление <math>z_j', z_j''</math> — это полная переортогонализация <math>z_j</math> методом Грама — Шмидта. Двойной запуск практически гарантирует, что <math>z_j''</math> будет ортогонален <math>q_1, \dots, q_j</math>. Заметим, что <math>\sum_{i=1}^j (z^T q_i) q_i = Q_j Q_j^T z</math>, где <math>Q_j = [q_1, \dots, q_j]</math>, поэтому переортогонализацию можно переписать в виде <math>z'_j = z_j - Q_j Q_j^T z_j, z_j'' = z_j' - Q_j Q_j^T z_j'</math>.<br />
<br />
Если <math>\beta_j = 0</math> для какого-либо <math>j < k</math>, то <math>\Vert T_{ju}\Vert_2 = 0</math>, а значит, собственные значения <math>T_j</math> в точности совпадают с каким-то собственными значениями <math>A</math>. В этом случае дальнейшие вычисления прекращаются и либо используется полученная <math>T_j</math> размерности меньшей, чем <math>k</math>, либо процедура запускается заново с другим начальным вектором <math>b</math>.<br />
<br />
=== Вычислительное ядро алгоритма ===<br />
У алгоритма построения матрицы <math>T_k</math> в том виде, как он описан выше, можно выделить два ядра:<br />
# умножение матрицы <math>A</math> на вектор <math>q_j</math>: <math>z_j = A q_j</math> (<math>O(n^2)</math> умножений вещественных чисел);<br />
# переортогонализация: <math>z'_j = z_j - Q_j Q_j^T z_j,\; z_j'' = z_j' - Q_j Q_j^T z_j'</math> (<math>O(nk^2)</math> умножений вещественных чисел).<br />
<br />
<br />
=== Макроструктура алгоритма ===<br />
На макроуровне выделяем 3 основные операции:<br />
<br />
1. Умножение исходной матрицы <math>A</math> на очередной вектор базиса <math>q_p</math>.<br />
<br />
<math><br />
z=Aq_p. <br />
</math><br />
<br />
2. Повторное проведения процесса Грамма-Шмидта для ортогонализации посчитанного вектора <math>z</math> со всеми построенными ранее векторами базиса.<br />
<br />
<math><br />
z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i, </math> <br />
<br />
<math>z=z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i. </math> <br />
<br />
3.Непосредственное вычисление нового базисного вектора <math>q_{j+1}</math> и элементов <math><br />
\alpha_j<br />
</math>, <math> \beta_{j+1}<br />
</math> трехдиагональной матрицы.<br />
<br />
<math><br />
\alpha_j=q_j^Tz,<br />
</math><br />
<br />
<math>z=z-\alpha_jq_j-\beta_{j}q_{j-1}, </math><br />
<br />
<math>\beta_{j+1}=||z||,<br />
</math><br />
<br />
<math>q_{j+1}=z/\beta_{j+1}.</math><br />
<br />
=== Схема реализации последовательного алгоритма ===<br />
Последовательность исполнения метода следующая:<br />
<br />
Сначала заполняем начальные значения. <br />
<br />
<math><br />
\begin{align}<br />
& q_1=b/||b||,\\<br />
& \beta_1=0,\\<br />
&q_0=0, \\<br />
\end{align}<br />
</math><br />
<br />
где <math>b</math>-произвольный вектор.<br />
<br />
Далее выполняется основная процедура, которая строит ортонормированный базис подпространства Крылова для симметричной матрицы и трехдиагональную матрицу размерности <math>k</math>.<br />
<br />
Для всех <math>j</math> от <math>1</math> до <math>k</math> по нарастанию выполняются<br />
<br />
<math><br />
1.z=Aq_j, <br />
</math><br />
<br />
Вычисляем элемент, который будет находится на позиции <math>t_{j,j}</math> конечной матрицы <math>T_k</math>,<br />
<br />
<math><br />
2.\alpha_j=q_j^Tz,<br />
</math><br />
<br />
Чтобы гарантировать ортогональность базиса на каждой итерации цикла два раза проводим полную переортогонализацию, использую процесс Грамма-Шмидта,<br />
<br />
<math><br />
3.z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i, </math> <br />
<br />
<math>4.z=z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i, </math> <br />
<br />
После ортогонализации процедура продолжается следующим образом. <br />
<br />
<math>5.z=z-\alpha_jq_j-\beta_{j}q_{j-1}, </math><br />
<br />
Вычисляем элемент, который будет находится на позиции <math>t_{j,j+1}</math> и <math>t_{j+1,j}</math>,<br />
<br />
<math>6.\beta_{j+1}=||z||,<br />
</math><br />
<br />
Если <math>\beta_{j+1}=0</math>, то алгоритм завершается.<br />
<br />
<math>7.q_{j+1}=z/\beta_{j+1}.</math><br />
<br />
В конце каждой итерации получаем очередной вектор <math>q_{j+1}</math> базиса с единичной нормой, который ортогонален всем предыдущим векторам базиса,<br />
<br />
и элементы <math>\alpha_j</math>, <math>\beta_{j+1}</math> трехдиагональной матрицы размерности <math>k</math> .<br />
<br />
<br />
=== Последовательная сложность алгоритма ===<br />
На <math>j</math>-ой итерации алгоритм выполняет<br />
* <math>n^2 + n + 4nj + n + n = n^2 + 3n + 4nj</math> умножений и делений;<br />
* <math>n(n - 1) + (n - 1) + (4n - 2)j + (n - 1) = n^2 + (n - 2) + (4n - 2)j</math> сложений и вычитаний;<br />
* одно извлечение квадратного корня.<br />
<br />
Всего за <math>k</math> итераций алгоритм выполняет<br />
* <math>(n + 3)nk + 2nk(k + 1)</math> умножений и делений;<br />
* <math>(n^2 + n - 2)k + (2n - 1)k(k + 1)</math> сложений и вычитаний.<br />
<br />
Таким образом, алгоритм имеет последовательную сложность <math>O(n^2k + nk^2)</math>.<br />
<br />
=== Информационный граф===<br />
<br />
Представим информационные графы разных уровней алгоритма.<br />
<br />
====Информационный граф на уровне макроопераций с входными и выходными данными====<br />
<br />
[[Файл:Lanczoc-full-orth-macro.png|thumb|1000px|center|alt=Информационный граф алгоритма Ланцоша на уровне отдельных итераций|Рисунок 1. Информационный граф алгоритма Ланцоша на уровне итераций с входными и выходными данными. In — входные данные (матрица <math>A</math> и вектор <math>b</math>), Out — выходные данные (<math>\alpha_j, \beta_j</math> и <math>q_j</math>), nrm — вычисление еклидовой нормы вектора, / — деление вектора на число, Iter — итерации алгоритма.]]<br />
<br />
<br />
====Информационный граф на уровне одной итерации с входными и выходными данными====<br />
<br />
<br />
[[Файл:Lanczoc-full-orth-iter.png|thumb|1000px|center|alt=Информационный граф алгоритма Ланцоша на уровне отдельных итераций|Рисунок 2. Информационный граф итерации алгоритма Ланцоша на уровне макроопераций (первые три итерации). In — входные данные (матрица <math>A</math>), Out — выходные данные (<math>\alpha_j, \beta_j</math> и <math>q_j</math>), dprod — скалярное произведение векторов, mprod — произведение матрицы на вектор, - — разность векторов, nrm — вычисление еклидовой нормы вектора, / — деление вектора на число.]]<br />
<br />
====Общий информационный граф алгроитма====<br />
<br />
<br />
[[Файл:photo.jpg|thumb|center|alt=Общий информационный граф алгроитма Ланцоша|Рисунок 3. Общий информационный граф алгроитма алгоритма Ланцоша.]]<br />
<br />
<br />
* Вершина черного цвета соответствует операции <math>Aq_j,</math>.<br />
* Вершина красного цвета соответствует операции скалярного произведения <math>q_j^Tz</math>.<br />
* Вершина сиреневого цвета соответствует операции <math>z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i</math>.<br />
* Вершина желтого цвета соответствует операции <math>z-\alpha_jq_j-\beta_{j-1}q_{j-1}</math>.<br />
* Вершина синего цвета соответствует операции <math>||z||</math>.<br />
* Вершина зеленого цвета соответствует операции <math>z/\beta_j</math>.<br />
<br />
=== Ресурс параллелизма алгоритма ===<br />
Для реализации <math>j</math>-ой итерации алгоритма нужно выполнить следующие ярусы:<br />
# <math>n</math> ярусов сложений с <math>n</math> операциями умножения в каждом (вычисление <math>z</math>);<br />
# <math>n</math> ярусов сложений с <math>1</math> операцией умножения в каждом (вычисление <math>\alpha_j</math>);<br />
# <math>j</math> ярусов сложений с <math>n</math> операциями умножения в каждом, <math>n</math> ярусов сложений с <math>j</math> операциями умножения в каждом, <math>1</math> ярус вычитаний размера <math>n</math> (первая переортогонализация);<br />
# <math>j</math> ярусов сложений с <math>n</math> операциями умножения в каждом, <math>n</math> ярусов сложений с <math>j</math> операциями умножения в каждом, <math>1</math> ярус вычитаний размера <math>n</math> (вторая переортогонализация);<br />
# <math>n</math> ярусов сложений с <math>1</math> операцией умножения в каждом (вычисление <math>\beta_j</math>);<br />
# <math>1</math> ярус делений размера <math>n</math> (вычисление <math>q_{j + 1}</math>).<br />
<br />
Итого ширина ЯПФ одной итерации составляет <math>O(n)</math>, высота — <math>4n + 2j + 3</math>. Ширина ЯПФ всего алгоритма составляет <math>O(n)</math>, высота — <math>O(nk + k^2)</math>.<br />
<br />
<br />
=== Входные и выходные данные алгоритма ===<br />
'''Входные данные''': плотная матрица <math>A</math> (элементы <math>a_{ij}</math>),произвольный вектор ненулевой <math>b</math>, количество итераций <math>k</math>.<br />
<br />
Дополнительные ограничения:<br />
* <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>..<br />
'''Объём входных данных''': <math>\frac{n (n + 3)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы).<br />
<br />
'''Выходные данные''': трехдиагональная симметрическая матрица <math>T</math> (элементы <math>_{ij}</math>), либо два вектора <math>a</math> и <math>b</math> размерности <math>k</math>.<br />
<br />
'''Объём выходных данных''': <math>2k</math> (в силу трехдиагональности симметричности достаточно хранить только ненулевые элементы). В разных реализациях эта экономия хранения может быть выполнена разным образом.<br />
<br />
<br />
=== Свойства алгоритма ===<br />
Сам по себе алгоритм Ланшоца не является устойчивым, так как из-за округлений ортогональность построенных векторов подпространства Крылова быстро теряется, вплоть до того, что некоторые из них становятся линейно зависимыми, что влечет к отсутствию приближения собственных векторов и собственных значений исходной матрицы. Однако, рассмотренный вариант с полной ортогонализацией как раз-таки делает алгоритм устойчивым.<br />
<br />
Количество операций умножения и количество операций сложения имеют один и тот же порядок, но они явно преобладают над операцией взятия корня. Также сбалансированы между собой арифметические операции и операции обращений в память. Алгоритм обрабатывает матрицу и вектора и считает множество скалярных произведений, следовательно обеспечивается хорошая сбалансированность операций между параллельными ветвями алгоритма. <br />
Соотношение последовательной и параллельной сложности <math>O(n)</math>.<br />
<br />
При этом вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных равняется <math>O(k)</math>. Алгоритм недетерминированный, так как если в какой-то итерации <math>b_j=0</math>, то алгоритм останавливается. Также на недетерминированность может повлиять изменение порядка выполнения ассоциативных операций, в частности при вычислении скалярного произведения. <br />
<br />
"Длинных" дуг в информационном графе нет, запись данных происходит предсказуемо(на каждом шаге заполняются следующие элементы выходных векторов), следовательно нет никаких потенциальных сложностей с размещением данных в иерархии памяти компьютера на этапе выполнения программы.<br />
<br />
<br />
== Программная реализация алгоритма ==<br />
<br />
<br />
=== Особенности реализации последовательного алгоритма ===<br />
=== Локальность данных и вычислений ===<br />
=== Возможные способы и особенности параллельной реализации алгоритма ===<br />
=== Масштабируемость алгоритма и его реализации ===<br />
Первое исследование масштабируемости проводилось на 1U сервере со следующими характеристиками:<br />
* 2 x Intel® Xeon® Processor E5-2697 v2;<br />
* 128GB RAM;<br />
Набор изменяемых параметров запуска реализации алгоритма и границы значений параметров алгоритма:<br />
*Число процессоров <math>1,2,4,8,16,32,48</math><br />
*Размерность матрицы <math>[1000:16000]</math><br />
*Количество итераций <math>10</math><br />
Использовался компилятор g++ версии 5.4.0 с параметрами запуска: <br />
*-fopenmp <br />
*-std=c++11<br />
Реализация алгоритма написана с использованием стандарта OpenMP.<br />
[[Файл:just2.png|thumb|center|1024px|Рисунок 4. Зависимость производительности от числа процессов и размера входной матрицы]]<br />
[http://pastebin.com/iurnjf8f Используемая параллельная реализация алгоритма на языке C++]<br />
<br />
Как видно из графика, размер задачи не оказывает существенного влияния на производительность. С увеличением количества процессоров производительность сначала возрастает, затем медленно убывает. Высокая производительность достигается при работе 20-30 процессоров, при дальнейшем увеличении числа процессоров накладные расходы на организацию параллельного вычисления ведут к уменьшению производительности.<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
Следующее исследование масштабируемости реализации алгоритма проводилось с использованием стандарта MPI на суперкомпьютере "Ломоносов" суперкомпьютерного комплекса Московского университета.<br />
<br />
Набор изменяемых параметров запуска реализации алгоритма и границы значений параметров алгоритма:<br />
*Число процессоров <math>1,2,4,8,16,32,64,96,128</math><br />
*Размерность матрицы <math> 1000:15000,1700,21000,25000,30000</math><br />
*Количество итераций <math>500</math><br />
Сборка осуществлялась с параметрами: <br />
*openmpi/1.5.5-icc<br />
*intel/13.1.0<br />
[[Файл:just5.png|thumb|center|1024px|Рисунок 4. Зависимость производительности от числа процессов и размера входной матрицы]]<br />
[[Файл:just6.png|thumb|center|1024px|Рисунок 4. Зависимость времени выполнения от числа процессов и размера входной матрицы]]<br />
[http://pastebin.com/5id6w9is Используемая параллельная реализация алгоритма на языке C++]<br />
<br />
При увеличении числа процессов производительность возрастает на всей рассмотренной области изменений параметров запуска. Увеличение размера задачи так же повышает производительность в рассматриваемой области, как и при увеличении количества процессоров, но при размерах задачи больше 25000 наблюдается медленный спад. Это снижение производительности объясняется тем, что при увеличении размера задачи существенно возрастают объемы передаваемых данных между процессами.<br />
<br />
=== Динамические характеристики и эффективность реализации алгоритма ===<br />
=== Выводы для классов архитектур ===<br />
<br />
=== Существующие реализации алгоритма ===<br />
NAG Library имеет множество процедур для решения система алгебраических уравнений и нахождения собственных значений, которые используют алгоритм Ланцоша.<br />
<br />
http://www.nag.com/content/nag-library C, C++, Fortran, C#, MATLAB, R.<br />
<br />
MATLAB содержит реализацию алгоритма в пакете Gaussian Belief Propagation Matlab Package.<br />
<br />
http://www.cs.cmu.edu/~bickson/gabp/.<br />
<br />
GraphLab имеет библиотеку, в которой есть огромное количество параллельных реализаций алгоритма Ланцоша <br />
<br />
https://turi.com/products/create/open_source.html C++.<br />
<br />
В LANSO/PLANSO есть параллельная версия алгоритма<br />
<br />
http://web.cs.ucdavis.edu/~bai/ET/lanczos_methods/overview_PLANSO.html Fortran.<br />
<br />
== Литература ==<br />
<br />
<references \></div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9B%D0%B0%D0%BD%D1%86%D0%BE%D1%88%D0%B0_%D0%B4%D0%BB%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B8_%D1%81_%D0%BF%D0%BB%D0%B0%D0%B2%D0%B0%D1%8E%D1%89%D0%B5%D0%B9_%D1%82%D0%BE%D1%87%D0%BA%D0%BE%D0%B9_%D1%81_%D0%BF%D0%BE%D0%BB%D0%BD%D0%BE%D0%B9_%D0%BF%D0%B5%D1%80%D0%B5%D0%BE%D1%80%D1%82%D0%BE%D0%B3%D0%BE%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D0%B5%D0%B9&diff=22593Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией2017-05-03T13:38:24Z<p>Chernyavskiy: /* Общее описание алгоритма */</p>
<hr />
<div>Основные авторы описания: [[Участник:Sagak|С.А.Айвазян]], [[Участник:Kozlov_Vladimir|В.Козлов]] (Часть 1), [[Участник:Chernyavskiy|А.Ю.Чернявский]] (компоновка и редактирование), [[Участник:ASA|А.С.Антонов]] (предварительная проверка).<br />
<br />
<br />
<br />
== Свойства и структура алгоритма ==<br />
===Общее описание алгоритма===<br />
Алгоритм Ланцоша <ref>Деммель Дж. Вычислительная линейна алгебра. Теория и приложения. -М.: Мир, 2001. - 430 c.</ref> <ref>Вербицкий В.В., Реут В.В. Введение в численные методы алгебры, 2015.</ref> – итерационный метод , созданный Корнелиусом Ланцошем, для нахождения собственных значений и собственных векторов симметричной матрицы. Суть алгоритма в том, что он сводит частичную проблему собственных значений симметричной вещественной матрицы к полной проблеме собственных значений для симметричной трехдиагональной матрицы меньшей размерности. Алгоритм применяется к матрицам большой размерности, к которым не применимы никакие прямые методы. <br />
<br />
Алгоритм Ланцоша относится к методам аппроксимаций, которые применяют широко распространенную в математике процедуру Релея-Ритца к матричным вычислениям, посредством чего сводят исходную задачу к задаче гораздо меньшего размера, решив которую, получаем приближенные собственные значения и собственные векторы исходной задачи. Метод основан на применении процедуры Релея-Ритца к последовательности вложенных подпространств Крылова.<br />
Важной особенностью подпространства Крылова является трехдиагонольность ортогональной проекции на него исходной матрицы, что способствует тому, что процедура <br />
Релея-Ритца прорабатывает очень эффективно. Главными особенностями поведения алгоритмов метода Ланцоша являются потеря ортогональности векторов базиса и быстрая сходимость в области наибольших по значению собственных значений. Наиболее популярными средствами борьбы с потерей ортогональности векторов Ланцоша являются различные варианты переортогонализации: частичная, полная и выборочная.<br />
<br />
Симметричность исходной матрицы позволяет хранить и вычислять чуть больше половины её элементов, что почти вдвое экономит как необходимые для вычислений объёмы памяти, так и количество операций. Также алгоритм позволяет использовать так называемый режим накопления, обусловленный тем, что значительную часть вычислений составляют вычисления скалярных произведений.<br />
<br />
Преимущество алгоритма заключается в том, что он дает приближение за конечное число шагов. Метод Ланцоша выигрывает в конкуренции таким прямым методам, как метод прямых или обратных итераций, <math>QR</math> и <math>QL</math> преобразования, методы вращений (вращения Якоби), которые потеряли значение как самостоятельные методы поиска собственных<br />
значений матриц большого размера. Также нужно заметить, что метод Ланцоша практически всегда эффективнее других методов аппроксимаций.<br />
<br />
=== Математическое описание алгоритма ===<br />
<br />
<br />
'''Алгоритм Ланцоша''' — это итерационный алгоритм поиска <math>k</math> приближённых собственных значений симметричной вещественной матрицы <math>A</math> размера <math>n \times n</math>. Алгоритм применяется, когда матрица <math>A</math> слишком велика, чтобы к ней можно было применять точные прямые методы вычисления собственных значений. Алгоритм комбинирует '''метод Рэлея — Ритца''' поиска приближённых собственных значений и '''метод Ланцоша''' построения крыловского подпространства.<br />
<br />
Метод Рэлея — Ритца является методом поиска <math>k</math> приближённых собственных значений симметричной вещественной матрицы <math>A</math> размера <math>n \times n</math>. Если <math>Q = [Q_k, Q_u]</math> — ортонормированная матрица размера <math>n \times n</math>, <math>Q_k</math> имеет размер <math>n \times k</math>, <math>Q_u</math> имеет размер <math>n \times n - k</math>, то можно записать равенство<br />
<br />
<math>T = Q^T A Q = [Q_k, Q_u]^T A [Q_k, Q_u] = <br />
\left[ \begin{array}{cc}<br />
Q_k^T A Q_k & Q_k^T A Q_u\\<br />
Q_u^T A Q_k & Q_u^T A Q_u<br />
\end{array} \right]<br />
= \left[ \begin{array}{cc}<br />
T_{k} & T_{ku}^T\\<br />
T_{ku} & T_{u}<br />
\end{array} \right].</math><br />
<br />
Метод Рэлея — Ритца заключается в том, что собственные значения матрицы <math>T_k = Q_k^T A Q_k</math> объявляются приближёнными собственными значениями матрицы <math>A</math>. Такое приближение является в некотором смысле «наилучшим»: можно показать, что если <math>T_k = V \Lambda V^{-1}</math> — спектральное разложение <math>T_k</math>, то пара <math>(Q_k V, \Lambda)</math> минимизирует функционал <math>L(P_k, D) = \Vert A P_k - P_k D \Vert_2</math>, причём <math>L(Q_k V, \Lambda) = \Vert T_{ku} \Vert_2</math>, то есть <math>A \approx (Q_k V) \Lambda (Q_k V)^{-1}</math>. Из этого также видно, что метод Рэлея — Ритца позволяет получать приближения для собственных векторов матрицы <math>A</math>. Более того, можно показать, что собственные значения <math>T</math> отличаются от некоторых собственных значений <math>A</math> не более чем на <math>\Vert T_{ku} \Vert_2</math>. <br />
<br />
Метод Ланцоша — это метод построения матрицы <math>Q</math>, при использовании которого, во-первых, матрица <math>T</math> оказывается симметричной трёхдиагональной, во-вторых, столбцы <math>Q</math> и <math>T</math> вычисляются последовательно. Трёхдиагональность <math>T</math> приводит к следующим явлениям:<br />
# матрица <math>T_k</math> является трёхдиагональной матрицей меньшей размерности, а для трёхдиагональных матриц существуют высокоэффективные методы поиска собственных значений;<br />
# матрица <math>T_{ku}</math> имеет только один ненулевой (возможно) элемент — правый верхний, а значит, для оценки погрешности полученных собственных значений достаточно знать только этот элемент.<br />
<br />
В теории в методе Ланцоша для вычисления каждого следующего столбца <math>q_{j + 1}</math> матрицы <math>Q</math> достаточно знать только <math>q_{j - 1}</math> и <math>q_{j}</math> в силу трёхдиагональности матрицы <math>T</math>. На практике из-за ошибок округления, если не предпринимать специальных мер, набор векторов <math>q_{1}, \dots, q_{k}</math> перестаёт быть ортогональным. Для борьбы с этим явлением на каждом шаге метода Ланцоша приходится выполнять так называемую переортогонализацию — повторно запускать процесс ортогонализации Грама — Шмидта.<br />
<br />
Перейдем к описанию самого алгоритма.<br />
<br />
Исходные данные: симметричная вещественная матрица <math>A</math> — матрица, для которой будут вычисляться собственные значения, вектор <math>b</math> — начальное приближение для метода Ланцоша.<br />
<br />
Выходные данные: трёхдиагональная симметричная вещественная матрица <math>T_k = \left[ \begin{array}{cccc}<br />
\alpha_1 & \beta_1 & & \\<br />
\beta_1 & \ddots & \ddots & \\<br />
& \ddots & \ddots & \beta_{k - 1}\\<br />
& & \beta_{k - 1} & \alpha_k<br />
\end{array} \right]</math>, ортонормированный набор векторов <math>q_1, \dots, q_k</math>: <math>T_k = [q_1, \dots, q_k]^T A [q_1, \dots, q_k]</math>.<br />
<br />
Формулы метода:<br />
<br />
<math><br />
\begin{array}{l}<br />
q_1 = b / \Vert b \Vert_2\\<br />
j = \overline{1, k}:\\<br />
\quad z_j = A q_j \\<br />
\quad \alpha_j = q_j^T A q_j = q_j^T z_j \\<br />
\quad z_j' = z_j - \sum_{i=1}^j (z_j^T q_i) q_i \\<br />
\quad z_j'' = z_j' - \sum_{i=1}^j (z_j'^T q_i) q_i\\<br />
\quad \beta_j = \Vert z_j'' \Vert_2\\<br />
\quad q_{j+1} = z_j'' / \Vert z_j'' \Vert_2 = z_j''/\beta_j<br />
\end{array}<br />
</math> <br />
<br />
Собственные значения и собственные векторы матрицы <math>T_k</math> ищутся любым прямым алгоритмом.<br />
<br />
Вычисление <math>z_j', z_j''</math> — это полная переортогонализация <math>z_j</math> методом Грама — Шмидта. Двойной запуск практически гарантирует, что <math>z_j''</math> будет ортогонален <math>q_1, \dots, q_j</math>. Заметим, что <math>\sum_{i=1}^j (z^T q_i) q_i = Q_j Q_j^T z</math>, где <math>Q_j = [q_1, \dots, q_j]</math>, поэтому переортогонализацию можно переписать в виде <math>z'_j = z_j - Q_j Q_j^T z_j, z_j'' = z_j' - Q_j Q_j^T z_j'</math>.<br />
<br />
Если <math>\beta_j = 0</math> для какого-либо <math>j < k</math>, то <math>\Vert T_{ju}\Vert_2 = 0</math>, а значит, собственные значения <math>T_j</math> в точности совпадают с каким-то собственными значениями <math>A</math>. В этом случае дальнейшие вычисления прекращаются и либо используется полученная <math>T_j</math> размерности меньшей, чем <math>k</math>, либо процедура запускается заново с другим начальным вектором <math>b</math>.<br />
<br />
=== Вычислительное ядро алгоритма ===<br />
У алгоритма построения матрицы <math>T_k</math> в том виде, как он описан выше, можно выделить два ядра:<br />
# умножение матрицы <math>A</math> на вектор <math>q_j</math>: <math>z_j = A q_j</math> (<math>O(n^2)</math> умножений вещественных чисел);<br />
# переортогонализация: <math>z'_j = z_j - Q_j Q_j^T z_j,\; z_j'' = z_j' - Q_j Q_j^T z_j'</math> (<math>O(nk^2)</math> умножений вещественных чисел).<br />
<br />
<br />
=== Макроструктура алгоритма ===<br />
На макроуровне выделяем 3 основные операции:<br />
<br />
1. Умножение исходной матрицы <math>A</math> на очередной вектор базиса <math>q_p</math>.<br />
<br />
<math><br />
z=Aq_p. <br />
</math><br />
<br />
2. Повторное проведения процесса Грамма-Шмидта для ортогонализации посчитанного вектора <math>z</math> со всеми построенными ранее векторами базиса.<br />
<br />
<math><br />
z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i, </math> <br />
<br />
<math>z=z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i. </math> <br />
<br />
3.Непосредственное вычисление нового базисного вектора <math>q_{j+1}</math> и элементов <math><br />
\alpha_j<br />
</math>, <math> \beta_{j+1}<br />
</math> трехдиагональной матрицы.<br />
<br />
<math><br />
\alpha_j=q_j^Tz,<br />
</math><br />
<br />
<math>z=z-\alpha_jq_j-\beta_{j}q_{j-1}, </math><br />
<br />
<math>\beta_{j+1}=||z||,<br />
</math><br />
<br />
<math>q_{j+1}=z/\beta_{j+1}.</math><br />
<br />
=== Схема реализации последовательного алгоритма ===<br />
Последовательность исполнения метода следующая:<br />
<br />
Сначала заполняем начальные значения. <br />
<br />
<math><br />
\begin{align}<br />
& q_1=b/||b||,\\<br />
& \beta_1=0,\\<br />
&q_0=0, \\<br />
\end{align}<br />
</math><br />
<br />
где <math>b</math>-произвольный вектор.<br />
<br />
Далее выполняется основная процедура, которая строит ортонормированный базис подпространства Крылова для симметричной матрицы и трехдиагональную матрицу размерности <math>k</math>.<br />
<br />
Для всех <math>j</math> от <math>1</math> до <math>k</math> по нарастанию выполняются<br />
<br />
<math><br />
1.z=Aq_j, <br />
</math><br />
<br />
Вычисляем элемент, который будет находится на позиции <math>t_{j,j}</math> конечной матрицы <math>T_k</math>,<br />
<br />
<math><br />
2.\alpha_j=q_j^Tz,<br />
</math><br />
<br />
Чтобы гарантировать ортогональность базиса на каждой итерации цикла два раза проводим полную переортогонализацию, использую процесс Грамма-Шмидта,<br />
<br />
<math><br />
3.z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i, </math> <br />
<br />
<math>4.z=z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i, </math> <br />
<br />
После ортогонализации процедура продолжается следующим образом. <br />
<br />
<math>5.z=z-\alpha_jq_j-\beta_{j}q_{j-1}, </math><br />
<br />
Вычисляем элемент, который будет находится на позиции <math>t_{j,j+1}</math> и <math>t_{j+1,j}</math>,<br />
<br />
<math>6.\beta_{j+1}=||z||,<br />
</math><br />
<br />
Если <math>\beta_{j+1}=0</math>, то алгоритм завершается.<br />
<br />
<math>7.q_{j+1}=z/\beta_{j+1}.</math><br />
<br />
В конце каждой итерации получаем очередной вектор <math>q_{j+1}</math> базиса с единичной нормой, который ортогонален всем предыдущим векторам базиса,<br />
<br />
и элементы <math>\alpha_j</math>, <math>\beta_{j+1}</math> трехдиагональной матрицы размерности <math>k</math> .<br />
<br />
<br />
=== Последовательная сложность алгоритма ===<br />
На <math>j</math>-ой итерации алгоритм выполняет<br />
* <math>n^2 + n + 4nj + n + n = n^2 + 3n + 4nj</math> умножений и делений;<br />
* <math>n(n - 1) + (n - 1) + (4n - 2)j + (n - 1) = n^2 + (n - 2) + (4n - 2)j</math> сложений и вычитаний;<br />
* одно извлечение квадратного корня.<br />
<br />
Всего за <math>k</math> итераций алгоритм выполняет<br />
* <math>(n + 3)nk + 2nk(k + 1)</math> умножений и делений;<br />
* <math>(n^2 + n - 2)k + (2n - 1)k(k + 1)</math> сложений и вычитаний.<br />
<br />
Таким образом, алгоритм имеет последовательную сложность <math>O(n^2k + nk^2)</math>.<br />
<br />
=== Информационный граф===<br />
<br />
Представим информационные графы разных уровней алгоритма.<br />
<br />
====Информационный граф на уровне макроопераций с входными и выходными данными====<br />
<br />
[[Файл:Lanczoc-full-orth-macro.png|thumb|1000px|center|alt=Информационный граф алгоритма Ланцоша на уровне отдельных итераций|Рисунок 1. Информационный граф алгоритма Ланцоша на уровне итераций с входными и выходными данными. In — входные данные (матрица <math>A</math> и вектор <math>b</math>), Out — выходные данные (<math>\alpha_j, \beta_j</math> и <math>q_j</math>), nrm — вычисление еклидовой нормы вектора, / — деление вектора на число, Iter — итерации алгоритма.]]<br />
<br />
<br />
====Информационный граф на уровне одной итерации с входными и выходными данными====<br />
<br />
<br />
[[Файл:Lanczoc-full-orth-iter.png|thumb|1000px|center|alt=Информационный граф алгоритма Ланцоша на уровне отдельных итераций|Рисунок 2. Информационный граф итерации алгоритма Ланцоша на уровне макроопераций (первые три итерации). In — входные данные (матрица <math>A</math>), Out — выходные данные (<math>\alpha_j, \beta_j</math> и <math>q_j</math>), dprod — скалярное произведение векторов, mprod — произведение матрицы на вектор, - — разность векторов, nrm — вычисление еклидовой нормы вектора, / — деление вектора на число.]]<br />
<br />
====Общий информационный граф алгроитма====<br />
<br />
<br />
[[Файл:photo.jpg|thumb|center|alt=Общий информационный граф алгроитма Ланцоша|Рисунок 3. Общий информационный граф алгроитма алгоритма Ланцоша.]]<br />
<br />
<br />
* Вершина черного цвета соответствует операции <math>Aq_j,</math>.<br />
* Вершина красного цвета соответствует операции скалярного произведения <math>q_j^Tz</math>.<br />
* Вершина сиреневого цвета соответствует операции <math>z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i</math>.<br />
* Вершина желтого цвета соответствует операции <math>z-\alpha_jq_j-\beta_{j-1}q_{j-1}</math>.<br />
* Вершина синего цвета соответствует операции <math>||z||</math>.<br />
* Вершина зеленого цвета соответствует операции <math>z/\beta_j</math>.<br />
<br />
=== Ресурс параллелизма алгоритма ===<br />
Для реализации <math>j</math>-ой итерации алгоритма нужно выполнить следующие ярусы:<br />
# <math>n</math> ярусов сложений с <math>n</math> операциями умножения в каждом (вычисление <math>z</math>);<br />
# <math>n</math> ярусов сложений с <math>1</math> операцией умножения в каждом (вычисление <math>\alpha_j</math>);<br />
# <math>j</math> ярусов сложений с <math>n</math> операциями умножения в каждом, <math>n</math> ярусов сложений с <math>j</math> операциями умножения в каждом, <math>1</math> ярус вычитаний размера <math>n</math> (первая переортогонализация);<br />
# <math>j</math> ярусов сложений с <math>n</math> операциями умножения в каждом, <math>n</math> ярусов сложений с <math>j</math> операциями умножения в каждом, <math>1</math> ярус вычитаний размера <math>n</math> (вторая переортогонализация);<br />
# <math>n</math> ярусов сложений с <math>1</math> операцией умножения в каждом (вычисление <math>\beta_j</math>);<br />
# <math>1</math> ярус делений размера <math>n</math> (вычисление <math>q_{j + 1}</math>).<br />
<br />
Итого ширина ЯПФ одной итерации составляет <math>O(n)</math>, высота — <math>4n + 2j + 3</math>. Ширина ЯПФ всего алгоритма составляет <math>O(n)</math>, высота — <math>O(nk + k^2)</math>.<br />
<br />
<br />
=== Входные и выходные данные алгоритма ===<br />
'''Входные данные''': плотная матрица <math>A</math> (элементы <math>a_{ij}</math>),произвольный вектор ненулевой <math>b</math>, количество итераций <math>k</math>.<br />
<br />
Дополнительные ограничения:<br />
* <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>..<br />
'''Объём входных данных''': <math>\frac{n (n + 3)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы).<br />
<br />
'''Выходные данные''': трехдиагональная симметрическая матрица <math>T</math> (элементы <math>_{ij}</math>), либо два вектора <math>a</math> и <math>b</math> размерности <math>k</math>.<br />
<br />
'''Объём выходных данных''': <math>2k</math> (в силу трехдиагональности симметричности достаточно хранить только ненулевые элементы). В разных реализациях эта экономия хранения может быть выполнена разным образом.<br />
<br />
<br />
=== Свойства алгоритма ===<br />
Сам по себе алгоритм Ланшоца не является устойчивым, так как из-за округлений ортогональность построенных векторов подпространства Крылова быстро теряется, вплоть до того, что некоторые из них становятся линейно зависимыми, что влечет к отсутствию приближения собственных векторов и собственных значений исходной матрицы. Однако, рассмотренный вариант с полной ортогонализацией как раз-таки делает алгоритм устойчивым.<br />
<br />
Количество операций умножения и количество операций сложения имеют один и тот же порядок, но они явно преобладают над операцией взятия корня. Также сбалансированы между собой арифметические операции и операции обращений в память. Алгоритм обрабатывает матрицу и вектора и считает множество скалярных произведений, следовательно обеспечивается хорошая сбалансированность операций между параллельными ветвями алгоритма. <br />
Соотношение последовательной и параллельной сложности <math>O(n)</math>.<br />
<br />
При этом вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных равняется <math>O(k)</math>. Алгоритм недетерминированный, так как если в какой-то итерации <math>b_j=0</math>, то алгоритм останавливается. Также на недетерминированность может повлиять изменение порядка выполнения ассоциативных операций, в частности при вычислении скалярного произведения. <br />
<br />
"Длинных" дуг в информационном графе нет, запись данных происходит предсказуемо(на каждом шаге заполняются следующие элементы выходных векторов), следовательно нет никаких потенциальных сложностей с размещением данных в иерархии памяти компьютера на этапе выполнения программы.<br />
<br />
<br />
== Программная реализация алгоритма ==<br />
<br />
<br />
=== Особенности реализации последовательного алгоритма ===<br />
=== Локальность данных и вычислений ===<br />
=== Возможные способы и особенности параллельной реализации алгоритма ===<br />
=== Масштабируемость алгоритма и его реализации ===<br />
Первое исследование масштабируемости проводилось на 1U сервере со следующими характеристиками:<br />
* 2 x Intel® Xeon® Processor E5-2697 v2;<br />
* 128GB RAM;<br />
Набор изменяемых параметров запуска реализации алгоритма и границы значений параметров алгоритма:<br />
*Число процессоров <math>1,2,4,8,16,32,48</math><br />
*Размерность матрицы <math>[1000:16000]</math><br />
*Количество итераций <math>10</math><br />
Использовался компилятор g++ версии 5.4.0 с параметрами запуска: <br />
*-fopenmp <br />
*-std=c++11<br />
Реализация алгоритма написана с использованием стандарта OpenMP.<br />
[[Файл:just2.png|thumb|center|1024px|Рисунок 4. Зависимость производительности от числа процессов и размера входной матрицы]]<br />
[http://pastebin.com/iurnjf8f Используемая параллельная реализация алгоритма на языке C++]<br />
<br />
Как видно из графика, размер задачи не оказывает существенного влияния на производительность. С увеличением количества процессоров производительность сначала возрастает, затем медленно убывает. Высокая производительность достигается при работе 20-30 процессоров, при дальнейшем увеличении числа процессоров накладные расходы на организацию параллельного вычисления ведут к уменьшению производительности.<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
Следующее исследование масштабируемости реализации алгоритма проводилось с использованием стандарта MPI на суперкомпьютере "Ломоносов" суперкомпьютерного комплекса Московского университета.<br />
<br />
Набор изменяемых параметров запуска реализации алгоритма и границы значений параметров алгоритма:<br />
*Число процессоров <math>1,2,4,8,16,32,64,96,128</math><br />
*Размерность матрицы <math> 1000:15000,1700,21000,25000,30000</math><br />
*Количество итераций <math>500</math><br />
Сборка осуществлялась с параметрами: <br />
*openmpi/1.5.5-icc<br />
*intel/13.1.0<br />
[[Файл:just5.png|thumb|center|1024px|Рисунок 4. Зависимость производительности от числа процессов и размера входной матрицы]]<br />
[[Файл:just6.png|thumb|center|1024px|Рисунок 4. Зависимость времени выполнения от числа процессов и размера входной матрицы]]<br />
[http://pastebin.com/5id6w9is Используемая параллельная реализация алгоритма на языке C++]<br />
<br />
При увеличении числа процессов производительность возрастает на всей рассмотренной области изменений параметров запуска. Увеличение размера задачи так же повышает производительность в рассматриваемой области, как и при увеличении количества процессоров, но при размерах задачи больше 25000 наблюдается медленный спад. Это снижение производительности объясняется тем, что при увеличении размера задачи существенно возрастают объемы передаваемых данных между процессами.<br />
<br />
=== Динамические характеристики и эффективность реализации алгоритма ===<br />
=== Выводы для классов архитектур ===<br />
<br />
=== Существующие реализации алгоритма ===<br />
NAG Library имеет множество процедур для решения система алгебраических уравнений и нахождения собственных значений, которые используют алгоритм Ланцоша.<br />
<br />
http://www.nag.com/content/nag-library C, C++, Fortran, C#, MATLAB, R.<br />
<br />
MATLAB содержит реализацию алгоритма в пакете Gaussian Belief Propagation Matlab Package.<br />
<br />
http://www.cs.cmu.edu/~bickson/gabp/.<br />
<br />
GraphLab имеет библиотеку, в которой есть огромное количество параллельных реализаций алгоритма Ланцоша <br />
<br />
https://turi.com/products/create/open_source.html C++.<br />
<br />
В LANSO/PLANSO есть параллельная версия алгоритма<br />
<br />
http://web.cs.ucdavis.edu/~bai/ET/lanczos_methods/overview_PLANSO.html Fortran.</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9B%D0%B0%D0%BD%D1%86%D0%BE%D1%88%D0%B0_%D0%B4%D0%BB%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B8_%D1%81_%D0%BF%D0%BB%D0%B0%D0%B2%D0%B0%D1%8E%D1%89%D0%B5%D0%B9_%D1%82%D0%BE%D1%87%D0%BA%D0%BE%D0%B9_%D1%81_%D0%BF%D0%BE%D0%BB%D0%BD%D0%BE%D0%B9_%D0%BF%D0%B5%D1%80%D0%B5%D0%BE%D1%80%D1%82%D0%BE%D0%B3%D0%BE%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D0%B5%D0%B9&diff=22592Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией2017-05-03T13:35:08Z<p>Chernyavskiy: /* Свойства алгоритма */</p>
<hr />
<div>Основные авторы описания: [[Участник:Sagak|С.А.Айвазян]], [[Участник:Kozlov_Vladimir|В.Козлов]] (Часть 1), [[Участник:Chernyavskiy|А.Ю.Чернявский]] (компоновка и редактирование), [[Участник:ASA|А.С.Антонов]] (предварительная проверка).<br />
<br />
<br />
<br />
== Свойства и структура алгоритма ==<br />
===Общее описание алгоритма===<br />
Алгоритм Ланцоша – итерационный метод , созданный Корнелиусом Ланцошем, для нахождения собственных значений и собственных векторов симметричной матрицы. Суть алгоритма в том, что он сводит частичную проблему собственных значений симметричной вещественной матрицы к полной проблеме собственных значений для симметричной трехдиагональной матрицы меньшей размерности. Алгоритм применяется к матрицам большой размерности, к которым не применимы никакие прямые методы. <br />
<br />
Алгоритм Ланцоша относится к методам аппроксимаций, которые применяют широко распространенную в математике процедуру Релея-Ритца к матричным вычислениям, посредством чего сводят исходную задачу к задаче гораздо меньшего размера, решив которую, получаем приближенные собственные значения и собственные векторы исходной задачи. Метод основан на применении процедуры Релея-Ритца к последовательности вложенных подпространств Крылова.<br />
Важной особенностью подпространства Крылова является трехдиагонольность ортогональной проекции на него исходной матрицы, что способствует тому, что процедура <br />
Релея-Ритца прорабатывает очень эффективно. Главными особенностями поведения алгоритмов метода Ланцоша являются потеря ортогональности векторов базиса и быстрая сходимость в области наибольших по значению собственных значений. Наиболее популярными средствами борьбы с потерей ортогональности векторов Ланцоша являются различные варианты переортогонализации: частичная, полная и выборочная.<br />
<br />
Симметричность исходной матрицы позволяет хранить и вычислять чуть больше половины её элементов, что почти вдвое экономит как необходимые для вычислений объёмы памяти, так и количество операций. Также алгоритм позволяет использовать так называемый режим накопления, обусловленный тем, что значительную часть вычислений составляют вычисления скалярных произведений.<br />
<br />
Преимущество алгоритма заключается в том, что он дает приближение за конечное число шагов. Метод Ланцоша выигрывает в конкуренции таким прямым методам, как метод прямых или обратных итераций, <math>QR</math> и <math>QL</math> преобразования, методы вращений (вращения Якоби), которые потеряли значение как самостоятельные методы поиска собственных<br />
значений матриц большого размера. Также нужно заметить, что метод Ланцоша практически всегда эффективнее других методов аппроксимаций.<br />
<br />
<br />
=== Математическое описание алгоритма ===<br />
<br />
<br />
'''Алгоритм Ланцоша''' — это итерационный алгоритм поиска <math>k</math> приближённых собственных значений симметричной вещественной матрицы <math>A</math> размера <math>n \times n</math>. Алгоритм применяется, когда матрица <math>A</math> слишком велика, чтобы к ней можно было применять точные прямые методы вычисления собственных значений. Алгоритм комбинирует '''метод Рэлея — Ритца''' поиска приближённых собственных значений и '''метод Ланцоша''' построения крыловского подпространства.<br />
<br />
Метод Рэлея — Ритца является методом поиска <math>k</math> приближённых собственных значений симметричной вещественной матрицы <math>A</math> размера <math>n \times n</math>. Если <math>Q = [Q_k, Q_u]</math> — ортонормированная матрица размера <math>n \times n</math>, <math>Q_k</math> имеет размер <math>n \times k</math>, <math>Q_u</math> имеет размер <math>n \times n - k</math>, то можно записать равенство<br />
<br />
<math>T = Q^T A Q = [Q_k, Q_u]^T A [Q_k, Q_u] = <br />
\left[ \begin{array}{cc}<br />
Q_k^T A Q_k & Q_k^T A Q_u\\<br />
Q_u^T A Q_k & Q_u^T A Q_u<br />
\end{array} \right]<br />
= \left[ \begin{array}{cc}<br />
T_{k} & T_{ku}^T\\<br />
T_{ku} & T_{u}<br />
\end{array} \right].</math><br />
<br />
Метод Рэлея — Ритца заключается в том, что собственные значения матрицы <math>T_k = Q_k^T A Q_k</math> объявляются приближёнными собственными значениями матрицы <math>A</math>. Такое приближение является в некотором смысле «наилучшим»: можно показать, что если <math>T_k = V \Lambda V^{-1}</math> — спектральное разложение <math>T_k</math>, то пара <math>(Q_k V, \Lambda)</math> минимизирует функционал <math>L(P_k, D) = \Vert A P_k - P_k D \Vert_2</math>, причём <math>L(Q_k V, \Lambda) = \Vert T_{ku} \Vert_2</math>, то есть <math>A \approx (Q_k V) \Lambda (Q_k V)^{-1}</math>. Из этого также видно, что метод Рэлея — Ритца позволяет получать приближения для собственных векторов матрицы <math>A</math>. Более того, можно показать, что собственные значения <math>T</math> отличаются от некоторых собственных значений <math>A</math> не более чем на <math>\Vert T_{ku} \Vert_2</math>. <br />
<br />
Метод Ланцоша — это метод построения матрицы <math>Q</math>, при использовании которого, во-первых, матрица <math>T</math> оказывается симметричной трёхдиагональной, во-вторых, столбцы <math>Q</math> и <math>T</math> вычисляются последовательно. Трёхдиагональность <math>T</math> приводит к следующим явлениям:<br />
# матрица <math>T_k</math> является трёхдиагональной матрицей меньшей размерности, а для трёхдиагональных матриц существуют высокоэффективные методы поиска собственных значений;<br />
# матрица <math>T_{ku}</math> имеет только один ненулевой (возможно) элемент — правый верхний, а значит, для оценки погрешности полученных собственных значений достаточно знать только этот элемент.<br />
<br />
В теории в методе Ланцоша для вычисления каждого следующего столбца <math>q_{j + 1}</math> матрицы <math>Q</math> достаточно знать только <math>q_{j - 1}</math> и <math>q_{j}</math> в силу трёхдиагональности матрицы <math>T</math>. На практике из-за ошибок округления, если не предпринимать специальных мер, набор векторов <math>q_{1}, \dots, q_{k}</math> перестаёт быть ортогональным. Для борьбы с этим явлением на каждом шаге метода Ланцоша приходится выполнять так называемую переортогонализацию — повторно запускать процесс ортогонализации Грама — Шмидта.<br />
<br />
Перейдем к описанию самого алгоритма.<br />
<br />
Исходные данные: симметричная вещественная матрица <math>A</math> — матрица, для которой будут вычисляться собственные значения, вектор <math>b</math> — начальное приближение для метода Ланцоша.<br />
<br />
Выходные данные: трёхдиагональная симметричная вещественная матрица <math>T_k = \left[ \begin{array}{cccc}<br />
\alpha_1 & \beta_1 & & \\<br />
\beta_1 & \ddots & \ddots & \\<br />
& \ddots & \ddots & \beta_{k - 1}\\<br />
& & \beta_{k - 1} & \alpha_k<br />
\end{array} \right]</math>, ортонормированный набор векторов <math>q_1, \dots, q_k</math>: <math>T_k = [q_1, \dots, q_k]^T A [q_1, \dots, q_k]</math>.<br />
<br />
Формулы метода:<br />
<br />
<math><br />
\begin{array}{l}<br />
q_1 = b / \Vert b \Vert_2\\<br />
j = \overline{1, k}:\\<br />
\quad z_j = A q_j \\<br />
\quad \alpha_j = q_j^T A q_j = q_j^T z_j \\<br />
\quad z_j' = z_j - \sum_{i=1}^j (z_j^T q_i) q_i \\<br />
\quad z_j'' = z_j' - \sum_{i=1}^j (z_j'^T q_i) q_i\\<br />
\quad \beta_j = \Vert z_j'' \Vert_2\\<br />
\quad q_{j+1} = z_j'' / \Vert z_j'' \Vert_2 = z_j''/\beta_j<br />
\end{array}<br />
</math> <br />
<br />
Собственные значения и собственные векторы матрицы <math>T_k</math> ищутся любым прямым алгоритмом.<br />
<br />
Вычисление <math>z_j', z_j''</math> — это полная переортогонализация <math>z_j</math> методом Грама — Шмидта. Двойной запуск практически гарантирует, что <math>z_j''</math> будет ортогонален <math>q_1, \dots, q_j</math>. Заметим, что <math>\sum_{i=1}^j (z^T q_i) q_i = Q_j Q_j^T z</math>, где <math>Q_j = [q_1, \dots, q_j]</math>, поэтому переортогонализацию можно переписать в виде <math>z'_j = z_j - Q_j Q_j^T z_j, z_j'' = z_j' - Q_j Q_j^T z_j'</math>.<br />
<br />
Если <math>\beta_j = 0</math> для какого-либо <math>j < k</math>, то <math>\Vert T_{ju}\Vert_2 = 0</math>, а значит, собственные значения <math>T_j</math> в точности совпадают с каким-то собственными значениями <math>A</math>. В этом случае дальнейшие вычисления прекращаются и либо используется полученная <math>T_j</math> размерности меньшей, чем <math>k</math>, либо процедура запускается заново с другим начальным вектором <math>b</math>.<br />
<br />
=== Вычислительное ядро алгоритма ===<br />
У алгоритма построения матрицы <math>T_k</math> в том виде, как он описан выше, можно выделить два ядра:<br />
# умножение матрицы <math>A</math> на вектор <math>q_j</math>: <math>z_j = A q_j</math> (<math>O(n^2)</math> умножений вещественных чисел);<br />
# переортогонализация: <math>z'_j = z_j - Q_j Q_j^T z_j,\; z_j'' = z_j' - Q_j Q_j^T z_j'</math> (<math>O(nk^2)</math> умножений вещественных чисел).<br />
<br />
<br />
=== Макроструктура алгоритма ===<br />
На макроуровне выделяем 3 основные операции:<br />
<br />
1. Умножение исходной матрицы <math>A</math> на очередной вектор базиса <math>q_p</math>.<br />
<br />
<math><br />
z=Aq_p. <br />
</math><br />
<br />
2. Повторное проведения процесса Грамма-Шмидта для ортогонализации посчитанного вектора <math>z</math> со всеми построенными ранее векторами базиса.<br />
<br />
<math><br />
z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i, </math> <br />
<br />
<math>z=z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i. </math> <br />
<br />
3.Непосредственное вычисление нового базисного вектора <math>q_{j+1}</math> и элементов <math><br />
\alpha_j<br />
</math>, <math> \beta_{j+1}<br />
</math> трехдиагональной матрицы.<br />
<br />
<math><br />
\alpha_j=q_j^Tz,<br />
</math><br />
<br />
<math>z=z-\alpha_jq_j-\beta_{j}q_{j-1}, </math><br />
<br />
<math>\beta_{j+1}=||z||,<br />
</math><br />
<br />
<math>q_{j+1}=z/\beta_{j+1}.</math><br />
<br />
=== Схема реализации последовательного алгоритма ===<br />
Последовательность исполнения метода следующая:<br />
<br />
Сначала заполняем начальные значения. <br />
<br />
<math><br />
\begin{align}<br />
& q_1=b/||b||,\\<br />
& \beta_1=0,\\<br />
&q_0=0, \\<br />
\end{align}<br />
</math><br />
<br />
где <math>b</math>-произвольный вектор.<br />
<br />
Далее выполняется основная процедура, которая строит ортонормированный базис подпространства Крылова для симметричной матрицы и трехдиагональную матрицу размерности <math>k</math>.<br />
<br />
Для всех <math>j</math> от <math>1</math> до <math>k</math> по нарастанию выполняются<br />
<br />
<math><br />
1.z=Aq_j, <br />
</math><br />
<br />
Вычисляем элемент, который будет находится на позиции <math>t_{j,j}</math> конечной матрицы <math>T_k</math>,<br />
<br />
<math><br />
2.\alpha_j=q_j^Tz,<br />
</math><br />
<br />
Чтобы гарантировать ортогональность базиса на каждой итерации цикла два раза проводим полную переортогонализацию, использую процесс Грамма-Шмидта,<br />
<br />
<math><br />
3.z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i, </math> <br />
<br />
<math>4.z=z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i, </math> <br />
<br />
После ортогонализации процедура продолжается следующим образом. <br />
<br />
<math>5.z=z-\alpha_jq_j-\beta_{j}q_{j-1}, </math><br />
<br />
Вычисляем элемент, который будет находится на позиции <math>t_{j,j+1}</math> и <math>t_{j+1,j}</math>,<br />
<br />
<math>6.\beta_{j+1}=||z||,<br />
</math><br />
<br />
Если <math>\beta_{j+1}=0</math>, то алгоритм завершается.<br />
<br />
<math>7.q_{j+1}=z/\beta_{j+1}.</math><br />
<br />
В конце каждой итерации получаем очередной вектор <math>q_{j+1}</math> базиса с единичной нормой, который ортогонален всем предыдущим векторам базиса,<br />
<br />
и элементы <math>\alpha_j</math>, <math>\beta_{j+1}</math> трехдиагональной матрицы размерности <math>k</math> .<br />
<br />
<br />
=== Последовательная сложность алгоритма ===<br />
На <math>j</math>-ой итерации алгоритм выполняет<br />
* <math>n^2 + n + 4nj + n + n = n^2 + 3n + 4nj</math> умножений и делений;<br />
* <math>n(n - 1) + (n - 1) + (4n - 2)j + (n - 1) = n^2 + (n - 2) + (4n - 2)j</math> сложений и вычитаний;<br />
* одно извлечение квадратного корня.<br />
<br />
Всего за <math>k</math> итераций алгоритм выполняет<br />
* <math>(n + 3)nk + 2nk(k + 1)</math> умножений и делений;<br />
* <math>(n^2 + n - 2)k + (2n - 1)k(k + 1)</math> сложений и вычитаний.<br />
<br />
Таким образом, алгоритм имеет последовательную сложность <math>O(n^2k + nk^2)</math>.<br />
<br />
=== Информационный граф===<br />
<br />
Представим информационные графы разных уровней алгоритма.<br />
<br />
====Информационный граф на уровне макроопераций с входными и выходными данными====<br />
<br />
[[Файл:Lanczoc-full-orth-macro.png|thumb|1000px|center|alt=Информационный граф алгоритма Ланцоша на уровне отдельных итераций|Рисунок 1. Информационный граф алгоритма Ланцоша на уровне итераций с входными и выходными данными. In — входные данные (матрица <math>A</math> и вектор <math>b</math>), Out — выходные данные (<math>\alpha_j, \beta_j</math> и <math>q_j</math>), nrm — вычисление еклидовой нормы вектора, / — деление вектора на число, Iter — итерации алгоритма.]]<br />
<br />
<br />
====Информационный граф на уровне одной итерации с входными и выходными данными====<br />
<br />
<br />
[[Файл:Lanczoc-full-orth-iter.png|thumb|1000px|center|alt=Информационный граф алгоритма Ланцоша на уровне отдельных итераций|Рисунок 2. Информационный граф итерации алгоритма Ланцоша на уровне макроопераций (первые три итерации). In — входные данные (матрица <math>A</math>), Out — выходные данные (<math>\alpha_j, \beta_j</math> и <math>q_j</math>), dprod — скалярное произведение векторов, mprod — произведение матрицы на вектор, - — разность векторов, nrm — вычисление еклидовой нормы вектора, / — деление вектора на число.]]<br />
<br />
====Общий информационный граф алгроитма====<br />
<br />
<br />
[[Файл:photo.jpg|thumb|center|alt=Общий информационный граф алгроитма Ланцоша|Рисунок 3. Общий информационный граф алгроитма алгоритма Ланцоша.]]<br />
<br />
<br />
* Вершина черного цвета соответствует операции <math>Aq_j,</math>.<br />
* Вершина красного цвета соответствует операции скалярного произведения <math>q_j^Tz</math>.<br />
* Вершина сиреневого цвета соответствует операции <math>z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i</math>.<br />
* Вершина желтого цвета соответствует операции <math>z-\alpha_jq_j-\beta_{j-1}q_{j-1}</math>.<br />
* Вершина синего цвета соответствует операции <math>||z||</math>.<br />
* Вершина зеленого цвета соответствует операции <math>z/\beta_j</math>.<br />
<br />
=== Ресурс параллелизма алгоритма ===<br />
Для реализации <math>j</math>-ой итерации алгоритма нужно выполнить следующие ярусы:<br />
# <math>n</math> ярусов сложений с <math>n</math> операциями умножения в каждом (вычисление <math>z</math>);<br />
# <math>n</math> ярусов сложений с <math>1</math> операцией умножения в каждом (вычисление <math>\alpha_j</math>);<br />
# <math>j</math> ярусов сложений с <math>n</math> операциями умножения в каждом, <math>n</math> ярусов сложений с <math>j</math> операциями умножения в каждом, <math>1</math> ярус вычитаний размера <math>n</math> (первая переортогонализация);<br />
# <math>j</math> ярусов сложений с <math>n</math> операциями умножения в каждом, <math>n</math> ярусов сложений с <math>j</math> операциями умножения в каждом, <math>1</math> ярус вычитаний размера <math>n</math> (вторая переортогонализация);<br />
# <math>n</math> ярусов сложений с <math>1</math> операцией умножения в каждом (вычисление <math>\beta_j</math>);<br />
# <math>1</math> ярус делений размера <math>n</math> (вычисление <math>q_{j + 1}</math>).<br />
<br />
Итого ширина ЯПФ одной итерации составляет <math>O(n)</math>, высота — <math>4n + 2j + 3</math>. Ширина ЯПФ всего алгоритма составляет <math>O(n)</math>, высота — <math>O(nk + k^2)</math>.<br />
<br />
<br />
=== Входные и выходные данные алгоритма ===<br />
'''Входные данные''': плотная матрица <math>A</math> (элементы <math>a_{ij}</math>),произвольный вектор ненулевой <math>b</math>, количество итераций <math>k</math>.<br />
<br />
Дополнительные ограничения:<br />
* <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>..<br />
'''Объём входных данных''': <math>\frac{n (n + 3)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы).<br />
<br />
'''Выходные данные''': трехдиагональная симметрическая матрица <math>T</math> (элементы <math>_{ij}</math>), либо два вектора <math>a</math> и <math>b</math> размерности <math>k</math>.<br />
<br />
'''Объём выходных данных''': <math>2k</math> (в силу трехдиагональности симметричности достаточно хранить только ненулевые элементы). В разных реализациях эта экономия хранения может быть выполнена разным образом.<br />
<br />
<br />
=== Свойства алгоритма ===<br />
Сам по себе алгоритм Ланшоца не является устойчивым, так как из-за округлений ортогональность построенных векторов подпространства Крылова быстро теряется, вплоть до того, что некоторые из них становятся линейно зависимыми, что влечет к отсутствию приближения собственных векторов и собственных значений исходной матрицы. Однако, рассмотренный вариант с полной ортогонализацией как раз-таки делает алгоритм устойчивым.<br />
<br />
Количество операций умножения и количество операций сложения имеют один и тот же порядок, но они явно преобладают над операцией взятия корня. Также сбалансированы между собой арифметические операции и операции обращений в память. Алгоритм обрабатывает матрицу и вектора и считает множество скалярных произведений, следовательно обеспечивается хорошая сбалансированность операций между параллельными ветвями алгоритма. <br />
Соотношение последовательной и параллельной сложности <math>O(n)</math>.<br />
<br />
При этом вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных равняется <math>O(k)</math>. Алгоритм недетерминированный, так как если в какой-то итерации <math>b_j=0</math>, то алгоритм останавливается. Также на недетерминированность может повлиять изменение порядка выполнения ассоциативных операций, в частности при вычислении скалярного произведения. <br />
<br />
"Длинных" дуг в информационном графе нет, запись данных происходит предсказуемо(на каждом шаге заполняются следующие элементы выходных векторов), следовательно нет никаких потенциальных сложностей с размещением данных в иерархии памяти компьютера на этапе выполнения программы.<br />
<br />
<br />
== Программная реализация алгоритма ==<br />
<br />
<br />
=== Особенности реализации последовательного алгоритма ===<br />
=== Локальность данных и вычислений ===<br />
=== Возможные способы и особенности параллельной реализации алгоритма ===<br />
=== Масштабируемость алгоритма и его реализации ===<br />
Первое исследование масштабируемости проводилось на 1U сервере со следующими характеристиками:<br />
* 2 x Intel® Xeon® Processor E5-2697 v2;<br />
* 128GB RAM;<br />
Набор изменяемых параметров запуска реализации алгоритма и границы значений параметров алгоритма:<br />
*Число процессоров <math>1,2,4,8,16,32,48</math><br />
*Размерность матрицы <math>[1000:16000]</math><br />
*Количество итераций <math>10</math><br />
Использовался компилятор g++ версии 5.4.0 с параметрами запуска: <br />
*-fopenmp <br />
*-std=c++11<br />
Реализация алгоритма написана с использованием стандарта OpenMP.<br />
[[Файл:just2.png|thumb|center|1024px|Рисунок 4. Зависимость производительности от числа процессов и размера входной матрицы]]<br />
[http://pastebin.com/iurnjf8f Используемая параллельная реализация алгоритма на языке C++]<br />
<br />
Как видно из графика, размер задачи не оказывает существенного влияния на производительность. С увеличением количества процессоров производительность сначала возрастает, затем медленно убывает. Высокая производительность достигается при работе 20-30 процессоров, при дальнейшем увеличении числа процессоров накладные расходы на организацию параллельного вычисления ведут к уменьшению производительности.<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
Следующее исследование масштабируемости реализации алгоритма проводилось с использованием стандарта MPI на суперкомпьютере "Ломоносов" суперкомпьютерного комплекса Московского университета.<br />
<br />
Набор изменяемых параметров запуска реализации алгоритма и границы значений параметров алгоритма:<br />
*Число процессоров <math>1,2,4,8,16,32,64,96,128</math><br />
*Размерность матрицы <math> 1000:15000,1700,21000,25000,30000</math><br />
*Количество итераций <math>500</math><br />
Сборка осуществлялась с параметрами: <br />
*openmpi/1.5.5-icc<br />
*intel/13.1.0<br />
[[Файл:just5.png|thumb|center|1024px|Рисунок 4. Зависимость производительности от числа процессов и размера входной матрицы]]<br />
[[Файл:just6.png|thumb|center|1024px|Рисунок 4. Зависимость времени выполнения от числа процессов и размера входной матрицы]]<br />
[http://pastebin.com/5id6w9is Используемая параллельная реализация алгоритма на языке C++]<br />
<br />
При увеличении числа процессов производительность возрастает на всей рассмотренной области изменений параметров запуска. Увеличение размера задачи так же повышает производительность в рассматриваемой области, как и при увеличении количества процессоров, но при размерах задачи больше 25000 наблюдается медленный спад. Это снижение производительности объясняется тем, что при увеличении размера задачи существенно возрастают объемы передаваемых данных между процессами.<br />
<br />
=== Динамические характеристики и эффективность реализации алгоритма ===<br />
=== Выводы для классов архитектур ===<br />
<br />
=== Существующие реализации алгоритма ===<br />
NAG Library имеет множество процедур для решения система алгебраических уравнений и нахождения собственных значений, которые используют алгоритм Ланцоша.<br />
<br />
http://www.nag.com/content/nag-library C, C++, Fortran, C#, MATLAB, R.<br />
<br />
MATLAB содержит реализацию алгоритма в пакете Gaussian Belief Propagation Matlab Package.<br />
<br />
http://www.cs.cmu.edu/~bickson/gabp/.<br />
<br />
GraphLab имеет библиотеку, в которой есть огромное количество параллельных реализаций алгоритма Ланцоша <br />
<br />
https://turi.com/products/create/open_source.html C++.<br />
<br />
В LANSO/PLANSO есть параллельная версия алгоритма<br />
<br />
http://web.cs.ucdavis.edu/~bai/ET/lanczos_methods/overview_PLANSO.html Fortran.</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9B%D0%B0%D0%BD%D1%86%D0%BE%D1%88%D0%B0_%D0%B4%D0%BB%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B8_%D1%81_%D0%BF%D0%BB%D0%B0%D0%B2%D0%B0%D1%8E%D1%89%D0%B5%D0%B9_%D1%82%D0%BE%D1%87%D0%BA%D0%BE%D0%B9_%D1%81_%D0%BF%D0%BE%D0%BB%D0%BD%D0%BE%D0%B9_%D0%BF%D0%B5%D1%80%D0%B5%D0%BE%D1%80%D1%82%D0%BE%D0%B3%D0%BE%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D0%B5%D0%B9&diff=22591Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией2017-05-03T13:33:55Z<p>Chernyavskiy: /* Входные и выходные данные алгоритма */</p>
<hr />
<div>Основные авторы описания: [[Участник:Sagak|С.А.Айвазян]], [[Участник:Kozlov_Vladimir|В.Козлов]] (Часть 1), [[Участник:Chernyavskiy|А.Ю.Чернявский]] (компоновка и редактирование), [[Участник:ASA|А.С.Антонов]] (предварительная проверка).<br />
<br />
<br />
<br />
== Свойства и структура алгоритма ==<br />
===Общее описание алгоритма===<br />
Алгоритм Ланцоша – итерационный метод , созданный Корнелиусом Ланцошем, для нахождения собственных значений и собственных векторов симметричной матрицы. Суть алгоритма в том, что он сводит частичную проблему собственных значений симметричной вещественной матрицы к полной проблеме собственных значений для симметричной трехдиагональной матрицы меньшей размерности. Алгоритм применяется к матрицам большой размерности, к которым не применимы никакие прямые методы. <br />
<br />
Алгоритм Ланцоша относится к методам аппроксимаций, которые применяют широко распространенную в математике процедуру Релея-Ритца к матричным вычислениям, посредством чего сводят исходную задачу к задаче гораздо меньшего размера, решив которую, получаем приближенные собственные значения и собственные векторы исходной задачи. Метод основан на применении процедуры Релея-Ритца к последовательности вложенных подпространств Крылова.<br />
Важной особенностью подпространства Крылова является трехдиагонольность ортогональной проекции на него исходной матрицы, что способствует тому, что процедура <br />
Релея-Ритца прорабатывает очень эффективно. Главными особенностями поведения алгоритмов метода Ланцоша являются потеря ортогональности векторов базиса и быстрая сходимость в области наибольших по значению собственных значений. Наиболее популярными средствами борьбы с потерей ортогональности векторов Ланцоша являются различные варианты переортогонализации: частичная, полная и выборочная.<br />
<br />
Симметричность исходной матрицы позволяет хранить и вычислять чуть больше половины её элементов, что почти вдвое экономит как необходимые для вычислений объёмы памяти, так и количество операций. Также алгоритм позволяет использовать так называемый режим накопления, обусловленный тем, что значительную часть вычислений составляют вычисления скалярных произведений.<br />
<br />
Преимущество алгоритма заключается в том, что он дает приближение за конечное число шагов. Метод Ланцоша выигрывает в конкуренции таким прямым методам, как метод прямых или обратных итераций, <math>QR</math> и <math>QL</math> преобразования, методы вращений (вращения Якоби), которые потеряли значение как самостоятельные методы поиска собственных<br />
значений матриц большого размера. Также нужно заметить, что метод Ланцоша практически всегда эффективнее других методов аппроксимаций.<br />
<br />
<br />
=== Математическое описание алгоритма ===<br />
<br />
<br />
'''Алгоритм Ланцоша''' — это итерационный алгоритм поиска <math>k</math> приближённых собственных значений симметричной вещественной матрицы <math>A</math> размера <math>n \times n</math>. Алгоритм применяется, когда матрица <math>A</math> слишком велика, чтобы к ней можно было применять точные прямые методы вычисления собственных значений. Алгоритм комбинирует '''метод Рэлея — Ритца''' поиска приближённых собственных значений и '''метод Ланцоша''' построения крыловского подпространства.<br />
<br />
Метод Рэлея — Ритца является методом поиска <math>k</math> приближённых собственных значений симметричной вещественной матрицы <math>A</math> размера <math>n \times n</math>. Если <math>Q = [Q_k, Q_u]</math> — ортонормированная матрица размера <math>n \times n</math>, <math>Q_k</math> имеет размер <math>n \times k</math>, <math>Q_u</math> имеет размер <math>n \times n - k</math>, то можно записать равенство<br />
<br />
<math>T = Q^T A Q = [Q_k, Q_u]^T A [Q_k, Q_u] = <br />
\left[ \begin{array}{cc}<br />
Q_k^T A Q_k & Q_k^T A Q_u\\<br />
Q_u^T A Q_k & Q_u^T A Q_u<br />
\end{array} \right]<br />
= \left[ \begin{array}{cc}<br />
T_{k} & T_{ku}^T\\<br />
T_{ku} & T_{u}<br />
\end{array} \right].</math><br />
<br />
Метод Рэлея — Ритца заключается в том, что собственные значения матрицы <math>T_k = Q_k^T A Q_k</math> объявляются приближёнными собственными значениями матрицы <math>A</math>. Такое приближение является в некотором смысле «наилучшим»: можно показать, что если <math>T_k = V \Lambda V^{-1}</math> — спектральное разложение <math>T_k</math>, то пара <math>(Q_k V, \Lambda)</math> минимизирует функционал <math>L(P_k, D) = \Vert A P_k - P_k D \Vert_2</math>, причём <math>L(Q_k V, \Lambda) = \Vert T_{ku} \Vert_2</math>, то есть <math>A \approx (Q_k V) \Lambda (Q_k V)^{-1}</math>. Из этого также видно, что метод Рэлея — Ритца позволяет получать приближения для собственных векторов матрицы <math>A</math>. Более того, можно показать, что собственные значения <math>T</math> отличаются от некоторых собственных значений <math>A</math> не более чем на <math>\Vert T_{ku} \Vert_2</math>. <br />
<br />
Метод Ланцоша — это метод построения матрицы <math>Q</math>, при использовании которого, во-первых, матрица <math>T</math> оказывается симметричной трёхдиагональной, во-вторых, столбцы <math>Q</math> и <math>T</math> вычисляются последовательно. Трёхдиагональность <math>T</math> приводит к следующим явлениям:<br />
# матрица <math>T_k</math> является трёхдиагональной матрицей меньшей размерности, а для трёхдиагональных матриц существуют высокоэффективные методы поиска собственных значений;<br />
# матрица <math>T_{ku}</math> имеет только один ненулевой (возможно) элемент — правый верхний, а значит, для оценки погрешности полученных собственных значений достаточно знать только этот элемент.<br />
<br />
В теории в методе Ланцоша для вычисления каждого следующего столбца <math>q_{j + 1}</math> матрицы <math>Q</math> достаточно знать только <math>q_{j - 1}</math> и <math>q_{j}</math> в силу трёхдиагональности матрицы <math>T</math>. На практике из-за ошибок округления, если не предпринимать специальных мер, набор векторов <math>q_{1}, \dots, q_{k}</math> перестаёт быть ортогональным. Для борьбы с этим явлением на каждом шаге метода Ланцоша приходится выполнять так называемую переортогонализацию — повторно запускать процесс ортогонализации Грама — Шмидта.<br />
<br />
Перейдем к описанию самого алгоритма.<br />
<br />
Исходные данные: симметричная вещественная матрица <math>A</math> — матрица, для которой будут вычисляться собственные значения, вектор <math>b</math> — начальное приближение для метода Ланцоша.<br />
<br />
Выходные данные: трёхдиагональная симметричная вещественная матрица <math>T_k = \left[ \begin{array}{cccc}<br />
\alpha_1 & \beta_1 & & \\<br />
\beta_1 & \ddots & \ddots & \\<br />
& \ddots & \ddots & \beta_{k - 1}\\<br />
& & \beta_{k - 1} & \alpha_k<br />
\end{array} \right]</math>, ортонормированный набор векторов <math>q_1, \dots, q_k</math>: <math>T_k = [q_1, \dots, q_k]^T A [q_1, \dots, q_k]</math>.<br />
<br />
Формулы метода:<br />
<br />
<math><br />
\begin{array}{l}<br />
q_1 = b / \Vert b \Vert_2\\<br />
j = \overline{1, k}:\\<br />
\quad z_j = A q_j \\<br />
\quad \alpha_j = q_j^T A q_j = q_j^T z_j \\<br />
\quad z_j' = z_j - \sum_{i=1}^j (z_j^T q_i) q_i \\<br />
\quad z_j'' = z_j' - \sum_{i=1}^j (z_j'^T q_i) q_i\\<br />
\quad \beta_j = \Vert z_j'' \Vert_2\\<br />
\quad q_{j+1} = z_j'' / \Vert z_j'' \Vert_2 = z_j''/\beta_j<br />
\end{array}<br />
</math> <br />
<br />
Собственные значения и собственные векторы матрицы <math>T_k</math> ищутся любым прямым алгоритмом.<br />
<br />
Вычисление <math>z_j', z_j''</math> — это полная переортогонализация <math>z_j</math> методом Грама — Шмидта. Двойной запуск практически гарантирует, что <math>z_j''</math> будет ортогонален <math>q_1, \dots, q_j</math>. Заметим, что <math>\sum_{i=1}^j (z^T q_i) q_i = Q_j Q_j^T z</math>, где <math>Q_j = [q_1, \dots, q_j]</math>, поэтому переортогонализацию можно переписать в виде <math>z'_j = z_j - Q_j Q_j^T z_j, z_j'' = z_j' - Q_j Q_j^T z_j'</math>.<br />
<br />
Если <math>\beta_j = 0</math> для какого-либо <math>j < k</math>, то <math>\Vert T_{ju}\Vert_2 = 0</math>, а значит, собственные значения <math>T_j</math> в точности совпадают с каким-то собственными значениями <math>A</math>. В этом случае дальнейшие вычисления прекращаются и либо используется полученная <math>T_j</math> размерности меньшей, чем <math>k</math>, либо процедура запускается заново с другим начальным вектором <math>b</math>.<br />
<br />
=== Вычислительное ядро алгоритма ===<br />
У алгоритма построения матрицы <math>T_k</math> в том виде, как он описан выше, можно выделить два ядра:<br />
# умножение матрицы <math>A</math> на вектор <math>q_j</math>: <math>z_j = A q_j</math> (<math>O(n^2)</math> умножений вещественных чисел);<br />
# переортогонализация: <math>z'_j = z_j - Q_j Q_j^T z_j,\; z_j'' = z_j' - Q_j Q_j^T z_j'</math> (<math>O(nk^2)</math> умножений вещественных чисел).<br />
<br />
<br />
=== Макроструктура алгоритма ===<br />
На макроуровне выделяем 3 основные операции:<br />
<br />
1. Умножение исходной матрицы <math>A</math> на очередной вектор базиса <math>q_p</math>.<br />
<br />
<math><br />
z=Aq_p. <br />
</math><br />
<br />
2. Повторное проведения процесса Грамма-Шмидта для ортогонализации посчитанного вектора <math>z</math> со всеми построенными ранее векторами базиса.<br />
<br />
<math><br />
z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i, </math> <br />
<br />
<math>z=z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i. </math> <br />
<br />
3.Непосредственное вычисление нового базисного вектора <math>q_{j+1}</math> и элементов <math><br />
\alpha_j<br />
</math>, <math> \beta_{j+1}<br />
</math> трехдиагональной матрицы.<br />
<br />
<math><br />
\alpha_j=q_j^Tz,<br />
</math><br />
<br />
<math>z=z-\alpha_jq_j-\beta_{j}q_{j-1}, </math><br />
<br />
<math>\beta_{j+1}=||z||,<br />
</math><br />
<br />
<math>q_{j+1}=z/\beta_{j+1}.</math><br />
<br />
=== Схема реализации последовательного алгоритма ===<br />
Последовательность исполнения метода следующая:<br />
<br />
Сначала заполняем начальные значения. <br />
<br />
<math><br />
\begin{align}<br />
& q_1=b/||b||,\\<br />
& \beta_1=0,\\<br />
&q_0=0, \\<br />
\end{align}<br />
</math><br />
<br />
где <math>b</math>-произвольный вектор.<br />
<br />
Далее выполняется основная процедура, которая строит ортонормированный базис подпространства Крылова для симметричной матрицы и трехдиагональную матрицу размерности <math>k</math>.<br />
<br />
Для всех <math>j</math> от <math>1</math> до <math>k</math> по нарастанию выполняются<br />
<br />
<math><br />
1.z=Aq_j, <br />
</math><br />
<br />
Вычисляем элемент, который будет находится на позиции <math>t_{j,j}</math> конечной матрицы <math>T_k</math>,<br />
<br />
<math><br />
2.\alpha_j=q_j^Tz,<br />
</math><br />
<br />
Чтобы гарантировать ортогональность базиса на каждой итерации цикла два раза проводим полную переортогонализацию, использую процесс Грамма-Шмидта,<br />
<br />
<math><br />
3.z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i, </math> <br />
<br />
<math>4.z=z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i, </math> <br />
<br />
После ортогонализации процедура продолжается следующим образом. <br />
<br />
<math>5.z=z-\alpha_jq_j-\beta_{j}q_{j-1}, </math><br />
<br />
Вычисляем элемент, который будет находится на позиции <math>t_{j,j+1}</math> и <math>t_{j+1,j}</math>,<br />
<br />
<math>6.\beta_{j+1}=||z||,<br />
</math><br />
<br />
Если <math>\beta_{j+1}=0</math>, то алгоритм завершается.<br />
<br />
<math>7.q_{j+1}=z/\beta_{j+1}.</math><br />
<br />
В конце каждой итерации получаем очередной вектор <math>q_{j+1}</math> базиса с единичной нормой, который ортогонален всем предыдущим векторам базиса,<br />
<br />
и элементы <math>\alpha_j</math>, <math>\beta_{j+1}</math> трехдиагональной матрицы размерности <math>k</math> .<br />
<br />
<br />
=== Последовательная сложность алгоритма ===<br />
На <math>j</math>-ой итерации алгоритм выполняет<br />
* <math>n^2 + n + 4nj + n + n = n^2 + 3n + 4nj</math> умножений и делений;<br />
* <math>n(n - 1) + (n - 1) + (4n - 2)j + (n - 1) = n^2 + (n - 2) + (4n - 2)j</math> сложений и вычитаний;<br />
* одно извлечение квадратного корня.<br />
<br />
Всего за <math>k</math> итераций алгоритм выполняет<br />
* <math>(n + 3)nk + 2nk(k + 1)</math> умножений и делений;<br />
* <math>(n^2 + n - 2)k + (2n - 1)k(k + 1)</math> сложений и вычитаний.<br />
<br />
Таким образом, алгоритм имеет последовательную сложность <math>O(n^2k + nk^2)</math>.<br />
<br />
=== Информационный граф===<br />
<br />
Представим информационные графы разных уровней алгоритма.<br />
<br />
====Информационный граф на уровне макроопераций с входными и выходными данными====<br />
<br />
[[Файл:Lanczoc-full-orth-macro.png|thumb|1000px|center|alt=Информационный граф алгоритма Ланцоша на уровне отдельных итераций|Рисунок 1. Информационный граф алгоритма Ланцоша на уровне итераций с входными и выходными данными. In — входные данные (матрица <math>A</math> и вектор <math>b</math>), Out — выходные данные (<math>\alpha_j, \beta_j</math> и <math>q_j</math>), nrm — вычисление еклидовой нормы вектора, / — деление вектора на число, Iter — итерации алгоритма.]]<br />
<br />
<br />
====Информационный граф на уровне одной итерации с входными и выходными данными====<br />
<br />
<br />
[[Файл:Lanczoc-full-orth-iter.png|thumb|1000px|center|alt=Информационный граф алгоритма Ланцоша на уровне отдельных итераций|Рисунок 2. Информационный граф итерации алгоритма Ланцоша на уровне макроопераций (первые три итерации). In — входные данные (матрица <math>A</math>), Out — выходные данные (<math>\alpha_j, \beta_j</math> и <math>q_j</math>), dprod — скалярное произведение векторов, mprod — произведение матрицы на вектор, - — разность векторов, nrm — вычисление еклидовой нормы вектора, / — деление вектора на число.]]<br />
<br />
====Общий информационный граф алгроитма====<br />
<br />
<br />
[[Файл:photo.jpg|thumb|center|alt=Общий информационный граф алгроитма Ланцоша|Рисунок 3. Общий информационный граф алгроитма алгоритма Ланцоша.]]<br />
<br />
<br />
* Вершина черного цвета соответствует операции <math>Aq_j,</math>.<br />
* Вершина красного цвета соответствует операции скалярного произведения <math>q_j^Tz</math>.<br />
* Вершина сиреневого цвета соответствует операции <math>z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i</math>.<br />
* Вершина желтого цвета соответствует операции <math>z-\alpha_jq_j-\beta_{j-1}q_{j-1}</math>.<br />
* Вершина синего цвета соответствует операции <math>||z||</math>.<br />
* Вершина зеленого цвета соответствует операции <math>z/\beta_j</math>.<br />
<br />
=== Ресурс параллелизма алгоритма ===<br />
Для реализации <math>j</math>-ой итерации алгоритма нужно выполнить следующие ярусы:<br />
# <math>n</math> ярусов сложений с <math>n</math> операциями умножения в каждом (вычисление <math>z</math>);<br />
# <math>n</math> ярусов сложений с <math>1</math> операцией умножения в каждом (вычисление <math>\alpha_j</math>);<br />
# <math>j</math> ярусов сложений с <math>n</math> операциями умножения в каждом, <math>n</math> ярусов сложений с <math>j</math> операциями умножения в каждом, <math>1</math> ярус вычитаний размера <math>n</math> (первая переортогонализация);<br />
# <math>j</math> ярусов сложений с <math>n</math> операциями умножения в каждом, <math>n</math> ярусов сложений с <math>j</math> операциями умножения в каждом, <math>1</math> ярус вычитаний размера <math>n</math> (вторая переортогонализация);<br />
# <math>n</math> ярусов сложений с <math>1</math> операцией умножения в каждом (вычисление <math>\beta_j</math>);<br />
# <math>1</math> ярус делений размера <math>n</math> (вычисление <math>q_{j + 1}</math>).<br />
<br />
Итого ширина ЯПФ одной итерации составляет <math>O(n)</math>, высота — <math>4n + 2j + 3</math>. Ширина ЯПФ всего алгоритма составляет <math>O(n)</math>, высота — <math>O(nk + k^2)</math>.<br />
<br />
<br />
=== Входные и выходные данные алгоритма ===<br />
'''Входные данные''': плотная матрица <math>A</math> (элементы <math>a_{ij}</math>),произвольный вектор ненулевой <math>b</math>, количество итераций <math>k</math>.<br />
<br />
Дополнительные ограничения:<br />
* <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>..<br />
'''Объём входных данных''': <math>\frac{n (n + 3)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы).<br />
<br />
'''Выходные данные''': трехдиагональная симметрическая матрица <math>T</math> (элементы <math>_{ij}</math>), либо два вектора <math>a</math> и <math>b</math> размерности <math>k</math>.<br />
<br />
'''Объём выходных данных''': <math>2k</math> (в силу трехдиагональности симметричности достаточно хранить только ненулевые элементы). В разных реализациях эта экономия хранения может быть выполнена разным образом.<br />
<br />
<br />
=== Свойства алгоритма ===<br />
Сам по себе алгоритм Ланшоца не является устойчивым, так как из-за округлений ортогональность построенных векторов подпространства Крылова быстро теряется, вплоть до того, что некоторые из них становятся линейно зависимыми, что влечет к отсутствию приближения собственных векторов и собственных значений исходной матрицы. Однако, рассмотренный вариант с полной ортогонализацией как раз-таки делает алгоритм устойчивым.<br />
<br />
Количество операций умножения и количество операций сложения имеют один и тот же порядок, но они явно преобладают над операцией взятия корня. Также сбалансированы между собой арифметические операции и операции обращений в память. Алгоритм обрабатывает матрицу и вектора и считает множество скалярных произведений, следовательно обеспечивается хорошая сбалансированность операций между параллельными ветвями алгоритма. <br />
Соотношение последовательной и параллельной сложности <math>O(n)</math>.<br />
<br />
При этом вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных равняется <math>O(k)</math>. Алгоритм недетерминированный, так как если в какой-то итерации <math>b_j=0</math>, то алгоритм останавливается. Также на недетерминированность может повлиять изменение порядка выполнения ассоциативных операций, в частности при вычислении скалярного произведения. <br />
<br />
"Длинных" дуг в информационном графе нет, запись данных происходит предсказуемо(на каждом шаге заполняются следующие элементы выходных векторов), следовательно нет никаких потенциальных сложностей с размещением данных в иерархии памяти компьютера на этапе выполнения программы.</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9B%D0%B0%D0%BD%D1%86%D0%BE%D1%88%D0%B0_%D0%B4%D0%BB%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B8_%D1%81_%D0%BF%D0%BB%D0%B0%D0%B2%D0%B0%D1%8E%D1%89%D0%B5%D0%B9_%D1%82%D0%BE%D1%87%D0%BA%D0%BE%D0%B9_%D1%81_%D0%BF%D0%BE%D0%BB%D0%BD%D0%BE%D0%B9_%D0%BF%D0%B5%D1%80%D0%B5%D0%BE%D1%80%D1%82%D0%BE%D0%B3%D0%BE%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D0%B5%D0%B9&diff=22590Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией2017-05-03T13:30:45Z<p>Chernyavskiy: /* Общий информационный граф алгроитма */</p>
<hr />
<div>Основные авторы описания: [[Участник:Sagak|С.А.Айвазян]], [[Участник:Kozlov_Vladimir|В.Козлов]] (Часть 1), [[Участник:Chernyavskiy|А.Ю.Чернявский]] (компоновка и редактирование), [[Участник:ASA|А.С.Антонов]] (предварительная проверка).<br />
<br />
<br />
<br />
== Свойства и структура алгоритма ==<br />
===Общее описание алгоритма===<br />
Алгоритм Ланцоша – итерационный метод , созданный Корнелиусом Ланцошем, для нахождения собственных значений и собственных векторов симметричной матрицы. Суть алгоритма в том, что он сводит частичную проблему собственных значений симметричной вещественной матрицы к полной проблеме собственных значений для симметричной трехдиагональной матрицы меньшей размерности. Алгоритм применяется к матрицам большой размерности, к которым не применимы никакие прямые методы. <br />
<br />
Алгоритм Ланцоша относится к методам аппроксимаций, которые применяют широко распространенную в математике процедуру Релея-Ритца к матричным вычислениям, посредством чего сводят исходную задачу к задаче гораздо меньшего размера, решив которую, получаем приближенные собственные значения и собственные векторы исходной задачи. Метод основан на применении процедуры Релея-Ритца к последовательности вложенных подпространств Крылова.<br />
Важной особенностью подпространства Крылова является трехдиагонольность ортогональной проекции на него исходной матрицы, что способствует тому, что процедура <br />
Релея-Ритца прорабатывает очень эффективно. Главными особенностями поведения алгоритмов метода Ланцоша являются потеря ортогональности векторов базиса и быстрая сходимость в области наибольших по значению собственных значений. Наиболее популярными средствами борьбы с потерей ортогональности векторов Ланцоша являются различные варианты переортогонализации: частичная, полная и выборочная.<br />
<br />
Симметричность исходной матрицы позволяет хранить и вычислять чуть больше половины её элементов, что почти вдвое экономит как необходимые для вычислений объёмы памяти, так и количество операций. Также алгоритм позволяет использовать так называемый режим накопления, обусловленный тем, что значительную часть вычислений составляют вычисления скалярных произведений.<br />
<br />
Преимущество алгоритма заключается в том, что он дает приближение за конечное число шагов. Метод Ланцоша выигрывает в конкуренции таким прямым методам, как метод прямых или обратных итераций, <math>QR</math> и <math>QL</math> преобразования, методы вращений (вращения Якоби), которые потеряли значение как самостоятельные методы поиска собственных<br />
значений матриц большого размера. Также нужно заметить, что метод Ланцоша практически всегда эффективнее других методов аппроксимаций.<br />
<br />
<br />
=== Математическое описание алгоритма ===<br />
<br />
<br />
'''Алгоритм Ланцоша''' — это итерационный алгоритм поиска <math>k</math> приближённых собственных значений симметричной вещественной матрицы <math>A</math> размера <math>n \times n</math>. Алгоритм применяется, когда матрица <math>A</math> слишком велика, чтобы к ней можно было применять точные прямые методы вычисления собственных значений. Алгоритм комбинирует '''метод Рэлея — Ритца''' поиска приближённых собственных значений и '''метод Ланцоша''' построения крыловского подпространства.<br />
<br />
Метод Рэлея — Ритца является методом поиска <math>k</math> приближённых собственных значений симметричной вещественной матрицы <math>A</math> размера <math>n \times n</math>. Если <math>Q = [Q_k, Q_u]</math> — ортонормированная матрица размера <math>n \times n</math>, <math>Q_k</math> имеет размер <math>n \times k</math>, <math>Q_u</math> имеет размер <math>n \times n - k</math>, то можно записать равенство<br />
<br />
<math>T = Q^T A Q = [Q_k, Q_u]^T A [Q_k, Q_u] = <br />
\left[ \begin{array}{cc}<br />
Q_k^T A Q_k & Q_k^T A Q_u\\<br />
Q_u^T A Q_k & Q_u^T A Q_u<br />
\end{array} \right]<br />
= \left[ \begin{array}{cc}<br />
T_{k} & T_{ku}^T\\<br />
T_{ku} & T_{u}<br />
\end{array} \right].</math><br />
<br />
Метод Рэлея — Ритца заключается в том, что собственные значения матрицы <math>T_k = Q_k^T A Q_k</math> объявляются приближёнными собственными значениями матрицы <math>A</math>. Такое приближение является в некотором смысле «наилучшим»: можно показать, что если <math>T_k = V \Lambda V^{-1}</math> — спектральное разложение <math>T_k</math>, то пара <math>(Q_k V, \Lambda)</math> минимизирует функционал <math>L(P_k, D) = \Vert A P_k - P_k D \Vert_2</math>, причём <math>L(Q_k V, \Lambda) = \Vert T_{ku} \Vert_2</math>, то есть <math>A \approx (Q_k V) \Lambda (Q_k V)^{-1}</math>. Из этого также видно, что метод Рэлея — Ритца позволяет получать приближения для собственных векторов матрицы <math>A</math>. Более того, можно показать, что собственные значения <math>T</math> отличаются от некоторых собственных значений <math>A</math> не более чем на <math>\Vert T_{ku} \Vert_2</math>. <br />
<br />
Метод Ланцоша — это метод построения матрицы <math>Q</math>, при использовании которого, во-первых, матрица <math>T</math> оказывается симметричной трёхдиагональной, во-вторых, столбцы <math>Q</math> и <math>T</math> вычисляются последовательно. Трёхдиагональность <math>T</math> приводит к следующим явлениям:<br />
# матрица <math>T_k</math> является трёхдиагональной матрицей меньшей размерности, а для трёхдиагональных матриц существуют высокоэффективные методы поиска собственных значений;<br />
# матрица <math>T_{ku}</math> имеет только один ненулевой (возможно) элемент — правый верхний, а значит, для оценки погрешности полученных собственных значений достаточно знать только этот элемент.<br />
<br />
В теории в методе Ланцоша для вычисления каждого следующего столбца <math>q_{j + 1}</math> матрицы <math>Q</math> достаточно знать только <math>q_{j - 1}</math> и <math>q_{j}</math> в силу трёхдиагональности матрицы <math>T</math>. На практике из-за ошибок округления, если не предпринимать специальных мер, набор векторов <math>q_{1}, \dots, q_{k}</math> перестаёт быть ортогональным. Для борьбы с этим явлением на каждом шаге метода Ланцоша приходится выполнять так называемую переортогонализацию — повторно запускать процесс ортогонализации Грама — Шмидта.<br />
<br />
Перейдем к описанию самого алгоритма.<br />
<br />
Исходные данные: симметричная вещественная матрица <math>A</math> — матрица, для которой будут вычисляться собственные значения, вектор <math>b</math> — начальное приближение для метода Ланцоша.<br />
<br />
Выходные данные: трёхдиагональная симметричная вещественная матрица <math>T_k = \left[ \begin{array}{cccc}<br />
\alpha_1 & \beta_1 & & \\<br />
\beta_1 & \ddots & \ddots & \\<br />
& \ddots & \ddots & \beta_{k - 1}\\<br />
& & \beta_{k - 1} & \alpha_k<br />
\end{array} \right]</math>, ортонормированный набор векторов <math>q_1, \dots, q_k</math>: <math>T_k = [q_1, \dots, q_k]^T A [q_1, \dots, q_k]</math>.<br />
<br />
Формулы метода:<br />
<br />
<math><br />
\begin{array}{l}<br />
q_1 = b / \Vert b \Vert_2\\<br />
j = \overline{1, k}:\\<br />
\quad z_j = A q_j \\<br />
\quad \alpha_j = q_j^T A q_j = q_j^T z_j \\<br />
\quad z_j' = z_j - \sum_{i=1}^j (z_j^T q_i) q_i \\<br />
\quad z_j'' = z_j' - \sum_{i=1}^j (z_j'^T q_i) q_i\\<br />
\quad \beta_j = \Vert z_j'' \Vert_2\\<br />
\quad q_{j+1} = z_j'' / \Vert z_j'' \Vert_2 = z_j''/\beta_j<br />
\end{array}<br />
</math> <br />
<br />
Собственные значения и собственные векторы матрицы <math>T_k</math> ищутся любым прямым алгоритмом.<br />
<br />
Вычисление <math>z_j', z_j''</math> — это полная переортогонализация <math>z_j</math> методом Грама — Шмидта. Двойной запуск практически гарантирует, что <math>z_j''</math> будет ортогонален <math>q_1, \dots, q_j</math>. Заметим, что <math>\sum_{i=1}^j (z^T q_i) q_i = Q_j Q_j^T z</math>, где <math>Q_j = [q_1, \dots, q_j]</math>, поэтому переортогонализацию можно переписать в виде <math>z'_j = z_j - Q_j Q_j^T z_j, z_j'' = z_j' - Q_j Q_j^T z_j'</math>.<br />
<br />
Если <math>\beta_j = 0</math> для какого-либо <math>j < k</math>, то <math>\Vert T_{ju}\Vert_2 = 0</math>, а значит, собственные значения <math>T_j</math> в точности совпадают с каким-то собственными значениями <math>A</math>. В этом случае дальнейшие вычисления прекращаются и либо используется полученная <math>T_j</math> размерности меньшей, чем <math>k</math>, либо процедура запускается заново с другим начальным вектором <math>b</math>.<br />
<br />
=== Вычислительное ядро алгоритма ===<br />
У алгоритма построения матрицы <math>T_k</math> в том виде, как он описан выше, можно выделить два ядра:<br />
# умножение матрицы <math>A</math> на вектор <math>q_j</math>: <math>z_j = A q_j</math> (<math>O(n^2)</math> умножений вещественных чисел);<br />
# переортогонализация: <math>z'_j = z_j - Q_j Q_j^T z_j,\; z_j'' = z_j' - Q_j Q_j^T z_j'</math> (<math>O(nk^2)</math> умножений вещественных чисел).<br />
<br />
<br />
=== Макроструктура алгоритма ===<br />
На макроуровне выделяем 3 основные операции:<br />
<br />
1. Умножение исходной матрицы <math>A</math> на очередной вектор базиса <math>q_p</math>.<br />
<br />
<math><br />
z=Aq_p. <br />
</math><br />
<br />
2. Повторное проведения процесса Грамма-Шмидта для ортогонализации посчитанного вектора <math>z</math> со всеми построенными ранее векторами базиса.<br />
<br />
<math><br />
z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i, </math> <br />
<br />
<math>z=z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i. </math> <br />
<br />
3.Непосредственное вычисление нового базисного вектора <math>q_{j+1}</math> и элементов <math><br />
\alpha_j<br />
</math>, <math> \beta_{j+1}<br />
</math> трехдиагональной матрицы.<br />
<br />
<math><br />
\alpha_j=q_j^Tz,<br />
</math><br />
<br />
<math>z=z-\alpha_jq_j-\beta_{j}q_{j-1}, </math><br />
<br />
<math>\beta_{j+1}=||z||,<br />
</math><br />
<br />
<math>q_{j+1}=z/\beta_{j+1}.</math><br />
<br />
=== Схема реализации последовательного алгоритма ===<br />
Последовательность исполнения метода следующая:<br />
<br />
Сначала заполняем начальные значения. <br />
<br />
<math><br />
\begin{align}<br />
& q_1=b/||b||,\\<br />
& \beta_1=0,\\<br />
&q_0=0, \\<br />
\end{align}<br />
</math><br />
<br />
где <math>b</math>-произвольный вектор.<br />
<br />
Далее выполняется основная процедура, которая строит ортонормированный базис подпространства Крылова для симметричной матрицы и трехдиагональную матрицу размерности <math>k</math>.<br />
<br />
Для всех <math>j</math> от <math>1</math> до <math>k</math> по нарастанию выполняются<br />
<br />
<math><br />
1.z=Aq_j, <br />
</math><br />
<br />
Вычисляем элемент, который будет находится на позиции <math>t_{j,j}</math> конечной матрицы <math>T_k</math>,<br />
<br />
<math><br />
2.\alpha_j=q_j^Tz,<br />
</math><br />
<br />
Чтобы гарантировать ортогональность базиса на каждой итерации цикла два раза проводим полную переортогонализацию, использую процесс Грамма-Шмидта,<br />
<br />
<math><br />
3.z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i, </math> <br />
<br />
<math>4.z=z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i, </math> <br />
<br />
После ортогонализации процедура продолжается следующим образом. <br />
<br />
<math>5.z=z-\alpha_jq_j-\beta_{j}q_{j-1}, </math><br />
<br />
Вычисляем элемент, который будет находится на позиции <math>t_{j,j+1}</math> и <math>t_{j+1,j}</math>,<br />
<br />
<math>6.\beta_{j+1}=||z||,<br />
</math><br />
<br />
Если <math>\beta_{j+1}=0</math>, то алгоритм завершается.<br />
<br />
<math>7.q_{j+1}=z/\beta_{j+1}.</math><br />
<br />
В конце каждой итерации получаем очередной вектор <math>q_{j+1}</math> базиса с единичной нормой, который ортогонален всем предыдущим векторам базиса,<br />
<br />
и элементы <math>\alpha_j</math>, <math>\beta_{j+1}</math> трехдиагональной матрицы размерности <math>k</math> .<br />
<br />
<br />
=== Последовательная сложность алгоритма ===<br />
На <math>j</math>-ой итерации алгоритм выполняет<br />
* <math>n^2 + n + 4nj + n + n = n^2 + 3n + 4nj</math> умножений и делений;<br />
* <math>n(n - 1) + (n - 1) + (4n - 2)j + (n - 1) = n^2 + (n - 2) + (4n - 2)j</math> сложений и вычитаний;<br />
* одно извлечение квадратного корня.<br />
<br />
Всего за <math>k</math> итераций алгоритм выполняет<br />
* <math>(n + 3)nk + 2nk(k + 1)</math> умножений и делений;<br />
* <math>(n^2 + n - 2)k + (2n - 1)k(k + 1)</math> сложений и вычитаний.<br />
<br />
Таким образом, алгоритм имеет последовательную сложность <math>O(n^2k + nk^2)</math>.<br />
<br />
=== Информационный граф===<br />
<br />
Представим информационные графы разных уровней алгоритма.<br />
<br />
====Информационный граф на уровне макроопераций с входными и выходными данными====<br />
<br />
[[Файл:Lanczoc-full-orth-macro.png|thumb|1000px|center|alt=Информационный граф алгоритма Ланцоша на уровне отдельных итераций|Рисунок 1. Информационный граф алгоритма Ланцоша на уровне итераций с входными и выходными данными. In — входные данные (матрица <math>A</math> и вектор <math>b</math>), Out — выходные данные (<math>\alpha_j, \beta_j</math> и <math>q_j</math>), nrm — вычисление еклидовой нормы вектора, / — деление вектора на число, Iter — итерации алгоритма.]]<br />
<br />
<br />
====Информационный граф на уровне одной итерации с входными и выходными данными====<br />
<br />
<br />
[[Файл:Lanczoc-full-orth-iter.png|thumb|1000px|center|alt=Информационный граф алгоритма Ланцоша на уровне отдельных итераций|Рисунок 2. Информационный граф итерации алгоритма Ланцоша на уровне макроопераций (первые три итерации). In — входные данные (матрица <math>A</math>), Out — выходные данные (<math>\alpha_j, \beta_j</math> и <math>q_j</math>), dprod — скалярное произведение векторов, mprod — произведение матрицы на вектор, - — разность векторов, nrm — вычисление еклидовой нормы вектора, / — деление вектора на число.]]<br />
<br />
====Общий информационный граф алгроитма====<br />
<br />
<br />
[[Файл:photo.jpg|thumb|center|alt=Общий информационный граф алгроитма Ланцоша|Рисунок 3. Общий информационный граф алгроитма алгоритма Ланцоша.]]<br />
<br />
<br />
* Вершина черного цвета соответствует операции <math>Aq_j,</math>.<br />
* Вершина красного цвета соответствует операции скалярного произведения <math>q_j^Tz</math>.<br />
* Вершина сиреневого цвета соответствует операции <math>z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i</math>.<br />
* Вершина желтого цвета соответствует операции <math>z-\alpha_jq_j-\beta_{j-1}q_{j-1}</math>.<br />
* Вершина синего цвета соответствует операции <math>||z||</math>.<br />
* Вершина зеленого цвета соответствует операции <math>z/\beta_j</math>.<br />
<br />
=== Ресурс параллелизма алгоритма ===<br />
Для реализации <math>j</math>-ой итерации алгоритма нужно выполнить следующие ярусы:<br />
# <math>n</math> ярусов сложений с <math>n</math> операциями умножения в каждом (вычисление <math>z</math>);<br />
# <math>n</math> ярусов сложений с <math>1</math> операцией умножения в каждом (вычисление <math>\alpha_j</math>);<br />
# <math>j</math> ярусов сложений с <math>n</math> операциями умножения в каждом, <math>n</math> ярусов сложений с <math>j</math> операциями умножения в каждом, <math>1</math> ярус вычитаний размера <math>n</math> (первая переортогонализация);<br />
# <math>j</math> ярусов сложений с <math>n</math> операциями умножения в каждом, <math>n</math> ярусов сложений с <math>j</math> операциями умножения в каждом, <math>1</math> ярус вычитаний размера <math>n</math> (вторая переортогонализация);<br />
# <math>n</math> ярусов сложений с <math>1</math> операцией умножения в каждом (вычисление <math>\beta_j</math>);<br />
# <math>1</math> ярус делений размера <math>n</math> (вычисление <math>q_{j + 1}</math>).<br />
<br />
Итого ширина ЯПФ одной итерации составляет <math>O(n)</math>, высота — <math>4n + 2j + 3</math>. Ширина ЯПФ всего алгоритма составляет <math>O(n)</math>, высота — <math>O(nk + k^2)</math>.<br />
<br />
<br />
=== Входные и выходные данные алгоритма ===<br />
'''Входные данные''': плотная матрица <math>A</math> (элементы <math>a_{ij}</math>),произвольный вектор ненулевой <math>b</math>, количество итераций <math>k</math>.<br />
<br />
Дополнительные ограничения:<br />
* <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>..<br />
'''Объём входных данных''': <math>\frac{n (n + 3)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы).<br />
<br />
'''Выходные данные''': трехдиагональная симметрическая матрица <math>T</math> (элементы <math>_{ij}</math>), либо два вектора <math>a</math> и <math>b</math> размерности <math>k</math>.<br />
<br />
'''Объём выходных данных''': <math>2k</math> (в силу трехдиагональности симметричности достаточно хранить только ненулевые элементы). В разных реализациях эта экономия хранения может быть выполнена разным образом.</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9B%D0%B0%D0%BD%D1%86%D0%BE%D1%88%D0%B0_%D0%B4%D0%BB%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B8_%D1%81_%D0%BF%D0%BB%D0%B0%D0%B2%D0%B0%D1%8E%D1%89%D0%B5%D0%B9_%D1%82%D0%BE%D1%87%D0%BA%D0%BE%D0%B9_%D1%81_%D0%BF%D0%BE%D0%BB%D0%BD%D0%BE%D0%B9_%D0%BF%D0%B5%D1%80%D0%B5%D0%BE%D1%80%D1%82%D0%BE%D0%B3%D0%BE%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D0%B5%D0%B9&diff=22589Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией2017-05-03T13:27:40Z<p>Chernyavskiy: /* Общий информационный граф алгроитма */</p>
<hr />
<div>Основные авторы описания: [[Участник:Sagak|С.А.Айвазян]], [[Участник:Kozlov_Vladimir|В.Козлов]] (Часть 1), [[Участник:Chernyavskiy|А.Ю.Чернявский]] (компоновка и редактирование), [[Участник:ASA|А.С.Антонов]] (предварительная проверка).<br />
<br />
<br />
<br />
== Свойства и структура алгоритма ==<br />
===Общее описание алгоритма===<br />
Алгоритм Ланцоша – итерационный метод , созданный Корнелиусом Ланцошем, для нахождения собственных значений и собственных векторов симметричной матрицы. Суть алгоритма в том, что он сводит частичную проблему собственных значений симметричной вещественной матрицы к полной проблеме собственных значений для симметричной трехдиагональной матрицы меньшей размерности. Алгоритм применяется к матрицам большой размерности, к которым не применимы никакие прямые методы. <br />
<br />
Алгоритм Ланцоша относится к методам аппроксимаций, которые применяют широко распространенную в математике процедуру Релея-Ритца к матричным вычислениям, посредством чего сводят исходную задачу к задаче гораздо меньшего размера, решив которую, получаем приближенные собственные значения и собственные векторы исходной задачи. Метод основан на применении процедуры Релея-Ритца к последовательности вложенных подпространств Крылова.<br />
Важной особенностью подпространства Крылова является трехдиагонольность ортогональной проекции на него исходной матрицы, что способствует тому, что процедура <br />
Релея-Ритца прорабатывает очень эффективно. Главными особенностями поведения алгоритмов метода Ланцоша являются потеря ортогональности векторов базиса и быстрая сходимость в области наибольших по значению собственных значений. Наиболее популярными средствами борьбы с потерей ортогональности векторов Ланцоша являются различные варианты переортогонализации: частичная, полная и выборочная.<br />
<br />
Симметричность исходной матрицы позволяет хранить и вычислять чуть больше половины её элементов, что почти вдвое экономит как необходимые для вычислений объёмы памяти, так и количество операций. Также алгоритм позволяет использовать так называемый режим накопления, обусловленный тем, что значительную часть вычислений составляют вычисления скалярных произведений.<br />
<br />
Преимущество алгоритма заключается в том, что он дает приближение за конечное число шагов. Метод Ланцоша выигрывает в конкуренции таким прямым методам, как метод прямых или обратных итераций, <math>QR</math> и <math>QL</math> преобразования, методы вращений (вращения Якоби), которые потеряли значение как самостоятельные методы поиска собственных<br />
значений матриц большого размера. Также нужно заметить, что метод Ланцоша практически всегда эффективнее других методов аппроксимаций.<br />
<br />
<br />
=== Математическое описание алгоритма ===<br />
<br />
<br />
'''Алгоритм Ланцоша''' — это итерационный алгоритм поиска <math>k</math> приближённых собственных значений симметричной вещественной матрицы <math>A</math> размера <math>n \times n</math>. Алгоритм применяется, когда матрица <math>A</math> слишком велика, чтобы к ней можно было применять точные прямые методы вычисления собственных значений. Алгоритм комбинирует '''метод Рэлея — Ритца''' поиска приближённых собственных значений и '''метод Ланцоша''' построения крыловского подпространства.<br />
<br />
Метод Рэлея — Ритца является методом поиска <math>k</math> приближённых собственных значений симметричной вещественной матрицы <math>A</math> размера <math>n \times n</math>. Если <math>Q = [Q_k, Q_u]</math> — ортонормированная матрица размера <math>n \times n</math>, <math>Q_k</math> имеет размер <math>n \times k</math>, <math>Q_u</math> имеет размер <math>n \times n - k</math>, то можно записать равенство<br />
<br />
<math>T = Q^T A Q = [Q_k, Q_u]^T A [Q_k, Q_u] = <br />
\left[ \begin{array}{cc}<br />
Q_k^T A Q_k & Q_k^T A Q_u\\<br />
Q_u^T A Q_k & Q_u^T A Q_u<br />
\end{array} \right]<br />
= \left[ \begin{array}{cc}<br />
T_{k} & T_{ku}^T\\<br />
T_{ku} & T_{u}<br />
\end{array} \right].</math><br />
<br />
Метод Рэлея — Ритца заключается в том, что собственные значения матрицы <math>T_k = Q_k^T A Q_k</math> объявляются приближёнными собственными значениями матрицы <math>A</math>. Такое приближение является в некотором смысле «наилучшим»: можно показать, что если <math>T_k = V \Lambda V^{-1}</math> — спектральное разложение <math>T_k</math>, то пара <math>(Q_k V, \Lambda)</math> минимизирует функционал <math>L(P_k, D) = \Vert A P_k - P_k D \Vert_2</math>, причём <math>L(Q_k V, \Lambda) = \Vert T_{ku} \Vert_2</math>, то есть <math>A \approx (Q_k V) \Lambda (Q_k V)^{-1}</math>. Из этого также видно, что метод Рэлея — Ритца позволяет получать приближения для собственных векторов матрицы <math>A</math>. Более того, можно показать, что собственные значения <math>T</math> отличаются от некоторых собственных значений <math>A</math> не более чем на <math>\Vert T_{ku} \Vert_2</math>. <br />
<br />
Метод Ланцоша — это метод построения матрицы <math>Q</math>, при использовании которого, во-первых, матрица <math>T</math> оказывается симметричной трёхдиагональной, во-вторых, столбцы <math>Q</math> и <math>T</math> вычисляются последовательно. Трёхдиагональность <math>T</math> приводит к следующим явлениям:<br />
# матрица <math>T_k</math> является трёхдиагональной матрицей меньшей размерности, а для трёхдиагональных матриц существуют высокоэффективные методы поиска собственных значений;<br />
# матрица <math>T_{ku}</math> имеет только один ненулевой (возможно) элемент — правый верхний, а значит, для оценки погрешности полученных собственных значений достаточно знать только этот элемент.<br />
<br />
В теории в методе Ланцоша для вычисления каждого следующего столбца <math>q_{j + 1}</math> матрицы <math>Q</math> достаточно знать только <math>q_{j - 1}</math> и <math>q_{j}</math> в силу трёхдиагональности матрицы <math>T</math>. На практике из-за ошибок округления, если не предпринимать специальных мер, набор векторов <math>q_{1}, \dots, q_{k}</math> перестаёт быть ортогональным. Для борьбы с этим явлением на каждом шаге метода Ланцоша приходится выполнять так называемую переортогонализацию — повторно запускать процесс ортогонализации Грама — Шмидта.<br />
<br />
Перейдем к описанию самого алгоритма.<br />
<br />
Исходные данные: симметричная вещественная матрица <math>A</math> — матрица, для которой будут вычисляться собственные значения, вектор <math>b</math> — начальное приближение для метода Ланцоша.<br />
<br />
Выходные данные: трёхдиагональная симметричная вещественная матрица <math>T_k = \left[ \begin{array}{cccc}<br />
\alpha_1 & \beta_1 & & \\<br />
\beta_1 & \ddots & \ddots & \\<br />
& \ddots & \ddots & \beta_{k - 1}\\<br />
& & \beta_{k - 1} & \alpha_k<br />
\end{array} \right]</math>, ортонормированный набор векторов <math>q_1, \dots, q_k</math>: <math>T_k = [q_1, \dots, q_k]^T A [q_1, \dots, q_k]</math>.<br />
<br />
Формулы метода:<br />
<br />
<math><br />
\begin{array}{l}<br />
q_1 = b / \Vert b \Vert_2\\<br />
j = \overline{1, k}:\\<br />
\quad z_j = A q_j \\<br />
\quad \alpha_j = q_j^T A q_j = q_j^T z_j \\<br />
\quad z_j' = z_j - \sum_{i=1}^j (z_j^T q_i) q_i \\<br />
\quad z_j'' = z_j' - \sum_{i=1}^j (z_j'^T q_i) q_i\\<br />
\quad \beta_j = \Vert z_j'' \Vert_2\\<br />
\quad q_{j+1} = z_j'' / \Vert z_j'' \Vert_2 = z_j''/\beta_j<br />
\end{array}<br />
</math> <br />
<br />
Собственные значения и собственные векторы матрицы <math>T_k</math> ищутся любым прямым алгоритмом.<br />
<br />
Вычисление <math>z_j', z_j''</math> — это полная переортогонализация <math>z_j</math> методом Грама — Шмидта. Двойной запуск практически гарантирует, что <math>z_j''</math> будет ортогонален <math>q_1, \dots, q_j</math>. Заметим, что <math>\sum_{i=1}^j (z^T q_i) q_i = Q_j Q_j^T z</math>, где <math>Q_j = [q_1, \dots, q_j]</math>, поэтому переортогонализацию можно переписать в виде <math>z'_j = z_j - Q_j Q_j^T z_j, z_j'' = z_j' - Q_j Q_j^T z_j'</math>.<br />
<br />
Если <math>\beta_j = 0</math> для какого-либо <math>j < k</math>, то <math>\Vert T_{ju}\Vert_2 = 0</math>, а значит, собственные значения <math>T_j</math> в точности совпадают с каким-то собственными значениями <math>A</math>. В этом случае дальнейшие вычисления прекращаются и либо используется полученная <math>T_j</math> размерности меньшей, чем <math>k</math>, либо процедура запускается заново с другим начальным вектором <math>b</math>.<br />
<br />
=== Вычислительное ядро алгоритма ===<br />
У алгоритма построения матрицы <math>T_k</math> в том виде, как он описан выше, можно выделить два ядра:<br />
# умножение матрицы <math>A</math> на вектор <math>q_j</math>: <math>z_j = A q_j</math> (<math>O(n^2)</math> умножений вещественных чисел);<br />
# переортогонализация: <math>z'_j = z_j - Q_j Q_j^T z_j,\; z_j'' = z_j' - Q_j Q_j^T z_j'</math> (<math>O(nk^2)</math> умножений вещественных чисел).<br />
<br />
<br />
=== Макроструктура алгоритма ===<br />
На макроуровне выделяем 3 основные операции:<br />
<br />
1. Умножение исходной матрицы <math>A</math> на очередной вектор базиса <math>q_p</math>.<br />
<br />
<math><br />
z=Aq_p. <br />
</math><br />
<br />
2. Повторное проведения процесса Грамма-Шмидта для ортогонализации посчитанного вектора <math>z</math> со всеми построенными ранее векторами базиса.<br />
<br />
<math><br />
z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i, </math> <br />
<br />
<math>z=z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i. </math> <br />
<br />
3.Непосредственное вычисление нового базисного вектора <math>q_{j+1}</math> и элементов <math><br />
\alpha_j<br />
</math>, <math> \beta_{j+1}<br />
</math> трехдиагональной матрицы.<br />
<br />
<math><br />
\alpha_j=q_j^Tz,<br />
</math><br />
<br />
<math>z=z-\alpha_jq_j-\beta_{j}q_{j-1}, </math><br />
<br />
<math>\beta_{j+1}=||z||,<br />
</math><br />
<br />
<math>q_{j+1}=z/\beta_{j+1}.</math><br />
<br />
=== Схема реализации последовательного алгоритма ===<br />
Последовательность исполнения метода следующая:<br />
<br />
Сначала заполняем начальные значения. <br />
<br />
<math><br />
\begin{align}<br />
& q_1=b/||b||,\\<br />
& \beta_1=0,\\<br />
&q_0=0, \\<br />
\end{align}<br />
</math><br />
<br />
где <math>b</math>-произвольный вектор.<br />
<br />
Далее выполняется основная процедура, которая строит ортонормированный базис подпространства Крылова для симметричной матрицы и трехдиагональную матрицу размерности <math>k</math>.<br />
<br />
Для всех <math>j</math> от <math>1</math> до <math>k</math> по нарастанию выполняются<br />
<br />
<math><br />
1.z=Aq_j, <br />
</math><br />
<br />
Вычисляем элемент, который будет находится на позиции <math>t_{j,j}</math> конечной матрицы <math>T_k</math>,<br />
<br />
<math><br />
2.\alpha_j=q_j^Tz,<br />
</math><br />
<br />
Чтобы гарантировать ортогональность базиса на каждой итерации цикла два раза проводим полную переортогонализацию, использую процесс Грамма-Шмидта,<br />
<br />
<math><br />
3.z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i, </math> <br />
<br />
<math>4.z=z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i, </math> <br />
<br />
После ортогонализации процедура продолжается следующим образом. <br />
<br />
<math>5.z=z-\alpha_jq_j-\beta_{j}q_{j-1}, </math><br />
<br />
Вычисляем элемент, который будет находится на позиции <math>t_{j,j+1}</math> и <math>t_{j+1,j}</math>,<br />
<br />
<math>6.\beta_{j+1}=||z||,<br />
</math><br />
<br />
Если <math>\beta_{j+1}=0</math>, то алгоритм завершается.<br />
<br />
<math>7.q_{j+1}=z/\beta_{j+1}.</math><br />
<br />
В конце каждой итерации получаем очередной вектор <math>q_{j+1}</math> базиса с единичной нормой, который ортогонален всем предыдущим векторам базиса,<br />
<br />
и элементы <math>\alpha_j</math>, <math>\beta_{j+1}</math> трехдиагональной матрицы размерности <math>k</math> .<br />
<br />
<br />
=== Последовательная сложность алгоритма ===<br />
На <math>j</math>-ой итерации алгоритм выполняет<br />
* <math>n^2 + n + 4nj + n + n = n^2 + 3n + 4nj</math> умножений и делений;<br />
* <math>n(n - 1) + (n - 1) + (4n - 2)j + (n - 1) = n^2 + (n - 2) + (4n - 2)j</math> сложений и вычитаний;<br />
* одно извлечение квадратного корня.<br />
<br />
Всего за <math>k</math> итераций алгоритм выполняет<br />
* <math>(n + 3)nk + 2nk(k + 1)</math> умножений и делений;<br />
* <math>(n^2 + n - 2)k + (2n - 1)k(k + 1)</math> сложений и вычитаний.<br />
<br />
Таким образом, алгоритм имеет последовательную сложность <math>O(n^2k + nk^2)</math>.<br />
<br />
=== Информационный граф===<br />
<br />
Представим информационные графы разных уровней алгоритма.<br />
<br />
====Информационный граф на уровне макроопераций с входными и выходными данными====<br />
<br />
[[Файл:Lanczoc-full-orth-macro.png|thumb|1000px|center|alt=Информационный граф алгоритма Ланцоша на уровне отдельных итераций|Рисунок 1. Информационный граф алгоритма Ланцоша на уровне итераций с входными и выходными данными. In — входные данные (матрица <math>A</math> и вектор <math>b</math>), Out — выходные данные (<math>\alpha_j, \beta_j</math> и <math>q_j</math>), nrm — вычисление еклидовой нормы вектора, / — деление вектора на число, Iter — итерации алгоритма.]]<br />
<br />
<br />
====Информационный граф на уровне одной итерации с входными и выходными данными====<br />
<br />
<br />
[[Файл:Lanczoc-full-orth-iter.png|thumb|1000px|center|alt=Информационный граф алгоритма Ланцоша на уровне отдельных итераций|Рисунок 2. Информационный граф итерации алгоритма Ланцоша на уровне макроопераций (первые три итерации). In — входные данные (матрица <math>A</math>), Out — выходные данные (<math>\alpha_j, \beta_j</math> и <math>q_j</math>), dprod — скалярное произведение векторов, mprod — произведение матрицы на вектор, - — разность векторов, nrm — вычисление еклидовой нормы вектора, / — деление вектора на число.]]<br />
<br />
====Общий информационный граф алгроитма====<br />
<br />
<br />
[[Файл:photo.jpg|thumb|left|alt=Общий информационный граф алгроитма Ланцоша|Рисунок 3. Общий информационный граф алгроитма алгоритма Ланцоша.]]<br />
<br />
* Вершина черного цвета соответствует операции <math>Aq_j,</math>.<br />
* Вершина красного цвета соответствует операции скалярного произведения <math>q_j^Tz</math>.<br />
* Вершина сиреневого цвета соответствует операции <math>z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i</math>.<br />
* Вершина желтого цвета соответствует операции <math>z-\alpha_jq_j-\beta_{j-1}q_{j-1}</math>.<br />
* Вершина синего цвета соответствует операции <math>||z||</math>.<br />
* Вершина зеленого цвета соответствует операции <math>z/\beta_j</math>.<br />
<br />
<br />
=== Ресурс параллелизма алгоритма ===<br />
Для реализации <math>j</math>-ой итерации алгоритма нужно выполнить следующие ярусы:<br />
# <math>n</math> ярусов сложений с <math>n</math> операциями умножения в каждом (вычисление <math>z</math>);<br />
# <math>n</math> ярусов сложений с <math>1</math> операцией умножения в каждом (вычисление <math>\alpha_j</math>);<br />
# <math>j</math> ярусов сложений с <math>n</math> операциями умножения в каждом, <math>n</math> ярусов сложений с <math>j</math> операциями умножения в каждом, <math>1</math> ярус вычитаний размера <math>n</math> (первая переортогонализация);<br />
# <math>j</math> ярусов сложений с <math>n</math> операциями умножения в каждом, <math>n</math> ярусов сложений с <math>j</math> операциями умножения в каждом, <math>1</math> ярус вычитаний размера <math>n</math> (вторая переортогонализация);<br />
# <math>n</math> ярусов сложений с <math>1</math> операцией умножения в каждом (вычисление <math>\beta_j</math>);<br />
# <math>1</math> ярус делений размера <math>n</math> (вычисление <math>q_{j + 1}</math>).<br />
<br />
Итого ширина ЯПФ одной итерации составляет <math>O(n)</math>, высота — <math>4n + 2j + 3</math>. Ширина ЯПФ всего алгоритма составляет <math>O(n)</math>, высота — <math>O(nk + k^2)</math>.<br />
<br />
<br />
=== Входные и выходные данные алгоритма ===<br />
'''Входные данные''': плотная матрица <math>A</math> (элементы <math>a_{ij}</math>),произвольный вектор ненулевой <math>b</math>, количество итераций <math>k</math>.<br />
<br />
Дополнительные ограничения:<br />
* <math>A</math> – симметрическая матрица, т. е. <math>a_{ij}= a_{ji}, i, j = 1, \ldots, n</math>..<br />
'''Объём входных данных''': <math>\frac{n (n + 3)}{2}</math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы).<br />
<br />
'''Выходные данные''': трехдиагональная симметрическая матрица <math>T</math> (элементы <math>_{ij}</math>), либо два вектора <math>a</math> и <math>b</math> размерности <math>k</math>.<br />
<br />
'''Объём выходных данных''': <math>2k</math> (в силу трехдиагональности симметричности достаточно хранить только ненулевые элементы). В разных реализациях эта экономия хранения может быть выполнена разным образом.</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9B%D0%B0%D0%BD%D1%86%D0%BE%D1%88%D0%B0_%D0%B4%D0%BB%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B8_%D1%81_%D0%BF%D0%BB%D0%B0%D0%B2%D0%B0%D1%8E%D1%89%D0%B5%D0%B9_%D1%82%D0%BE%D1%87%D0%BA%D0%BE%D0%B9_%D1%81_%D0%BF%D0%BE%D0%BB%D0%BD%D0%BE%D0%B9_%D0%BF%D0%B5%D1%80%D0%B5%D0%BE%D1%80%D1%82%D0%BE%D0%B3%D0%BE%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D0%B5%D0%B9&diff=22588Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией2017-05-03T13:21:20Z<p>Chernyavskiy: /* Информационный граф */</p>
<hr />
<div>Основные авторы описания: [[Участник:Sagak|С.А.Айвазян]], [[Участник:Kozlov_Vladimir|В.Козлов]] (Часть 1), [[Участник:Chernyavskiy|А.Ю.Чернявский]] (компоновка и редактирование), [[Участник:ASA|А.С.Антонов]] (предварительная проверка).<br />
<br />
<br />
<br />
== Свойства и структура алгоритма ==<br />
===Общее описание алгоритма===<br />
Алгоритм Ланцоша – итерационный метод , созданный Корнелиусом Ланцошем, для нахождения собственных значений и собственных векторов симметричной матрицы. Суть алгоритма в том, что он сводит частичную проблему собственных значений симметричной вещественной матрицы к полной проблеме собственных значений для симметричной трехдиагональной матрицы меньшей размерности. Алгоритм применяется к матрицам большой размерности, к которым не применимы никакие прямые методы. <br />
<br />
Алгоритм Ланцоша относится к методам аппроксимаций, которые применяют широко распространенную в математике процедуру Релея-Ритца к матричным вычислениям, посредством чего сводят исходную задачу к задаче гораздо меньшего размера, решив которую, получаем приближенные собственные значения и собственные векторы исходной задачи. Метод основан на применении процедуры Релея-Ритца к последовательности вложенных подпространств Крылова.<br />
Важной особенностью подпространства Крылова является трехдиагонольность ортогональной проекции на него исходной матрицы, что способствует тому, что процедура <br />
Релея-Ритца прорабатывает очень эффективно. Главными особенностями поведения алгоритмов метода Ланцоша являются потеря ортогональности векторов базиса и быстрая сходимость в области наибольших по значению собственных значений. Наиболее популярными средствами борьбы с потерей ортогональности векторов Ланцоша являются различные варианты переортогонализации: частичная, полная и выборочная.<br />
<br />
Симметричность исходной матрицы позволяет хранить и вычислять чуть больше половины её элементов, что почти вдвое экономит как необходимые для вычислений объёмы памяти, так и количество операций. Также алгоритм позволяет использовать так называемый режим накопления, обусловленный тем, что значительную часть вычислений составляют вычисления скалярных произведений.<br />
<br />
Преимущество алгоритма заключается в том, что он дает приближение за конечное число шагов. Метод Ланцоша выигрывает в конкуренции таким прямым методам, как метод прямых или обратных итераций, <math>QR</math> и <math>QL</math> преобразования, методы вращений (вращения Якоби), которые потеряли значение как самостоятельные методы поиска собственных<br />
значений матриц большого размера. Также нужно заметить, что метод Ланцоша практически всегда эффективнее других методов аппроксимаций.<br />
<br />
<br />
=== Математическое описание алгоритма ===<br />
<br />
<br />
'''Алгоритм Ланцоша''' — это итерационный алгоритм поиска <math>k</math> приближённых собственных значений симметричной вещественной матрицы <math>A</math> размера <math>n \times n</math>. Алгоритм применяется, когда матрица <math>A</math> слишком велика, чтобы к ней можно было применять точные прямые методы вычисления собственных значений. Алгоритм комбинирует '''метод Рэлея — Ритца''' поиска приближённых собственных значений и '''метод Ланцоша''' построения крыловского подпространства.<br />
<br />
Метод Рэлея — Ритца является методом поиска <math>k</math> приближённых собственных значений симметричной вещественной матрицы <math>A</math> размера <math>n \times n</math>. Если <math>Q = [Q_k, Q_u]</math> — ортонормированная матрица размера <math>n \times n</math>, <math>Q_k</math> имеет размер <math>n \times k</math>, <math>Q_u</math> имеет размер <math>n \times n - k</math>, то можно записать равенство<br />
<br />
<math>T = Q^T A Q = [Q_k, Q_u]^T A [Q_k, Q_u] = <br />
\left[ \begin{array}{cc}<br />
Q_k^T A Q_k & Q_k^T A Q_u\\<br />
Q_u^T A Q_k & Q_u^T A Q_u<br />
\end{array} \right]<br />
= \left[ \begin{array}{cc}<br />
T_{k} & T_{ku}^T\\<br />
T_{ku} & T_{u}<br />
\end{array} \right].</math><br />
<br />
Метод Рэлея — Ритца заключается в том, что собственные значения матрицы <math>T_k = Q_k^T A Q_k</math> объявляются приближёнными собственными значениями матрицы <math>A</math>. Такое приближение является в некотором смысле «наилучшим»: можно показать, что если <math>T_k = V \Lambda V^{-1}</math> — спектральное разложение <math>T_k</math>, то пара <math>(Q_k V, \Lambda)</math> минимизирует функционал <math>L(P_k, D) = \Vert A P_k - P_k D \Vert_2</math>, причём <math>L(Q_k V, \Lambda) = \Vert T_{ku} \Vert_2</math>, то есть <math>A \approx (Q_k V) \Lambda (Q_k V)^{-1}</math>. Из этого также видно, что метод Рэлея — Ритца позволяет получать приближения для собственных векторов матрицы <math>A</math>. Более того, можно показать, что собственные значения <math>T</math> отличаются от некоторых собственных значений <math>A</math> не более чем на <math>\Vert T_{ku} \Vert_2</math>. <br />
<br />
Метод Ланцоша — это метод построения матрицы <math>Q</math>, при использовании которого, во-первых, матрица <math>T</math> оказывается симметричной трёхдиагональной, во-вторых, столбцы <math>Q</math> и <math>T</math> вычисляются последовательно. Трёхдиагональность <math>T</math> приводит к следующим явлениям:<br />
# матрица <math>T_k</math> является трёхдиагональной матрицей меньшей размерности, а для трёхдиагональных матриц существуют высокоэффективные методы поиска собственных значений;<br />
# матрица <math>T_{ku}</math> имеет только один ненулевой (возможно) элемент — правый верхний, а значит, для оценки погрешности полученных собственных значений достаточно знать только этот элемент.<br />
<br />
В теории в методе Ланцоша для вычисления каждого следующего столбца <math>q_{j + 1}</math> матрицы <math>Q</math> достаточно знать только <math>q_{j - 1}</math> и <math>q_{j}</math> в силу трёхдиагональности матрицы <math>T</math>. На практике из-за ошибок округления, если не предпринимать специальных мер, набор векторов <math>q_{1}, \dots, q_{k}</math> перестаёт быть ортогональным. Для борьбы с этим явлением на каждом шаге метода Ланцоша приходится выполнять так называемую переортогонализацию — повторно запускать процесс ортогонализации Грама — Шмидта.<br />
<br />
Перейдем к описанию самого алгоритма.<br />
<br />
Исходные данные: симметричная вещественная матрица <math>A</math> — матрица, для которой будут вычисляться собственные значения, вектор <math>b</math> — начальное приближение для метода Ланцоша.<br />
<br />
Выходные данные: трёхдиагональная симметричная вещественная матрица <math>T_k = \left[ \begin{array}{cccc}<br />
\alpha_1 & \beta_1 & & \\<br />
\beta_1 & \ddots & \ddots & \\<br />
& \ddots & \ddots & \beta_{k - 1}\\<br />
& & \beta_{k - 1} & \alpha_k<br />
\end{array} \right]</math>, ортонормированный набор векторов <math>q_1, \dots, q_k</math>: <math>T_k = [q_1, \dots, q_k]^T A [q_1, \dots, q_k]</math>.<br />
<br />
Формулы метода:<br />
<br />
<math><br />
\begin{array}{l}<br />
q_1 = b / \Vert b \Vert_2\\<br />
j = \overline{1, k}:\\<br />
\quad z_j = A q_j \\<br />
\quad \alpha_j = q_j^T A q_j = q_j^T z_j \\<br />
\quad z_j' = z_j - \sum_{i=1}^j (z_j^T q_i) q_i \\<br />
\quad z_j'' = z_j' - \sum_{i=1}^j (z_j'^T q_i) q_i\\<br />
\quad \beta_j = \Vert z_j'' \Vert_2\\<br />
\quad q_{j+1} = z_j'' / \Vert z_j'' \Vert_2 = z_j''/\beta_j<br />
\end{array}<br />
</math> <br />
<br />
Собственные значения и собственные векторы матрицы <math>T_k</math> ищутся любым прямым алгоритмом.<br />
<br />
Вычисление <math>z_j', z_j''</math> — это полная переортогонализация <math>z_j</math> методом Грама — Шмидта. Двойной запуск практически гарантирует, что <math>z_j''</math> будет ортогонален <math>q_1, \dots, q_j</math>. Заметим, что <math>\sum_{i=1}^j (z^T q_i) q_i = Q_j Q_j^T z</math>, где <math>Q_j = [q_1, \dots, q_j]</math>, поэтому переортогонализацию можно переписать в виде <math>z'_j = z_j - Q_j Q_j^T z_j, z_j'' = z_j' - Q_j Q_j^T z_j'</math>.<br />
<br />
Если <math>\beta_j = 0</math> для какого-либо <math>j < k</math>, то <math>\Vert T_{ju}\Vert_2 = 0</math>, а значит, собственные значения <math>T_j</math> в точности совпадают с каким-то собственными значениями <math>A</math>. В этом случае дальнейшие вычисления прекращаются и либо используется полученная <math>T_j</math> размерности меньшей, чем <math>k</math>, либо процедура запускается заново с другим начальным вектором <math>b</math>.<br />
<br />
=== Вычислительное ядро алгоритма ===<br />
У алгоритма построения матрицы <math>T_k</math> в том виде, как он описан выше, можно выделить два ядра:<br />
# умножение матрицы <math>A</math> на вектор <math>q_j</math>: <math>z_j = A q_j</math> (<math>O(n^2)</math> умножений вещественных чисел);<br />
# переортогонализация: <math>z'_j = z_j - Q_j Q_j^T z_j,\; z_j'' = z_j' - Q_j Q_j^T z_j'</math> (<math>O(nk^2)</math> умножений вещественных чисел).<br />
<br />
<br />
=== Макроструктура алгоритма ===<br />
На макроуровне выделяем 3 основные операции:<br />
<br />
1. Умножение исходной матрицы <math>A</math> на очередной вектор базиса <math>q_p</math>.<br />
<br />
<math><br />
z=Aq_p. <br />
</math><br />
<br />
2. Повторное проведения процесса Грамма-Шмидта для ортогонализации посчитанного вектора <math>z</math> со всеми построенными ранее векторами базиса.<br />
<br />
<math><br />
z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i, </math> <br />
<br />
<math>z=z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i. </math> <br />
<br />
3.Непосредственное вычисление нового базисного вектора <math>q_{j+1}</math> и элементов <math><br />
\alpha_j<br />
</math>, <math> \beta_{j+1}<br />
</math> трехдиагональной матрицы.<br />
<br />
<math><br />
\alpha_j=q_j^Tz,<br />
</math><br />
<br />
<math>z=z-\alpha_jq_j-\beta_{j}q_{j-1}, </math><br />
<br />
<math>\beta_{j+1}=||z||,<br />
</math><br />
<br />
<math>q_{j+1}=z/\beta_{j+1}.</math><br />
<br />
=== Схема реализации последовательного алгоритма ===<br />
Последовательность исполнения метода следующая:<br />
<br />
Сначала заполняем начальные значения. <br />
<br />
<math><br />
\begin{align}<br />
& q_1=b/||b||,\\<br />
& \beta_1=0,\\<br />
&q_0=0, \\<br />
\end{align}<br />
</math><br />
<br />
где <math>b</math>-произвольный вектор.<br />
<br />
Далее выполняется основная процедура, которая строит ортонормированный базис подпространства Крылова для симметричной матрицы и трехдиагональную матрицу размерности <math>k</math>.<br />
<br />
Для всех <math>j</math> от <math>1</math> до <math>k</math> по нарастанию выполняются<br />
<br />
<math><br />
1.z=Aq_j, <br />
</math><br />
<br />
Вычисляем элемент, который будет находится на позиции <math>t_{j,j}</math> конечной матрицы <math>T_k</math>,<br />
<br />
<math><br />
2.\alpha_j=q_j^Tz,<br />
</math><br />
<br />
Чтобы гарантировать ортогональность базиса на каждой итерации цикла два раза проводим полную переортогонализацию, использую процесс Грамма-Шмидта,<br />
<br />
<math><br />
3.z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i, </math> <br />
<br />
<math>4.z=z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i, </math> <br />
<br />
После ортогонализации процедура продолжается следующим образом. <br />
<br />
<math>5.z=z-\alpha_jq_j-\beta_{j}q_{j-1}, </math><br />
<br />
Вычисляем элемент, который будет находится на позиции <math>t_{j,j+1}</math> и <math>t_{j+1,j}</math>,<br />
<br />
<math>6.\beta_{j+1}=||z||,<br />
</math><br />
<br />
Если <math>\beta_{j+1}=0</math>, то алгоритм завершается.<br />
<br />
<math>7.q_{j+1}=z/\beta_{j+1}.</math><br />
<br />
В конце каждой итерации получаем очередной вектор <math>q_{j+1}</math> базиса с единичной нормой, который ортогонален всем предыдущим векторам базиса,<br />
<br />
и элементы <math>\alpha_j</math>, <math>\beta_{j+1}</math> трехдиагональной матрицы размерности <math>k</math> .<br />
<br />
<br />
=== Последовательная сложность алгоритма ===<br />
На <math>j</math>-ой итерации алгоритм выполняет<br />
* <math>n^2 + n + 4nj + n + n = n^2 + 3n + 4nj</math> умножений и делений;<br />
* <math>n(n - 1) + (n - 1) + (4n - 2)j + (n - 1) = n^2 + (n - 2) + (4n - 2)j</math> сложений и вычитаний;<br />
* одно извлечение квадратного корня.<br />
<br />
Всего за <math>k</math> итераций алгоритм выполняет<br />
* <math>(n + 3)nk + 2nk(k + 1)</math> умножений и делений;<br />
* <math>(n^2 + n - 2)k + (2n - 1)k(k + 1)</math> сложений и вычитаний.<br />
<br />
Таким образом, алгоритм имеет последовательную сложность <math>O(n^2k + nk^2)</math>.<br />
<br />
=== Информационный граф===<br />
<br />
Представим информационные графы разных уровней алгоритма.<br />
<br />
====Информационный граф на уровне макроопераций с входными и выходными данными====<br />
<br />
[[Файл:Lanczoc-full-orth-macro.png|thumb|1000px|center|alt=Информационный граф алгоритма Ланцоша на уровне отдельных итераций|Рисунок 1. Информационный граф алгоритма Ланцоша на уровне итераций с входными и выходными данными. In — входные данные (матрица <math>A</math> и вектор <math>b</math>), Out — выходные данные (<math>\alpha_j, \beta_j</math> и <math>q_j</math>), nrm — вычисление еклидовой нормы вектора, / — деление вектора на число, Iter — итерации алгоритма.]]<br />
<br />
<br />
====Информационный граф на уровне одной итерации с входными и выходными данными====<br />
<br />
<br />
[[Файл:Lanczoc-full-orth-iter.png|thumb|1000px|center|alt=Информационный граф алгоритма Ланцоша на уровне отдельных итераций|Рисунок 2. Информационный граф итерации алгоритма Ланцоша на уровне макроопераций (первые три итерации). In — входные данные (матрица <math>A</math>), Out — выходные данные (<math>\alpha_j, \beta_j</math> и <math>q_j</math>), dprod — скалярное произведение векторов, mprod — произведение матрицы на вектор, - — разность векторов, nrm — вычисление еклидовой нормы вектора, / — деление вектора на число.]]<br />
<br />
====Общий информационный граф алгроитма====<br />
<br />
<br />
[[Файл:photo.jpg|thumb|left|alt=Общий информационный граф алгроитма Ланцоша|Рисунок 3. Общий информационный граф алгроитма алгоритма Ланцоша.]]<br />
<br />
* Вершина черного цвета соответствует операции <math>Aq_j,</math>.<br />
* Вершина красного цвета соответствует операции скалярного произведения <math>q_j^Tz</math>.<br />
* Вершина сиреневого цвета соответствует операции <math>z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i</math>.<br />
* Вершина желтого цвета соответствует операции <math>z-\alpha_jq_j-\beta_{j-1}q_{j-1}</math>.<br />
* Вершина синего цвета соответствует операции <math>||z||</math>.<br />
* Вершина зеленого цвета соответствует операции <math>z/\beta_j</math>.</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9B%D0%B0%D0%BD%D1%86%D0%BE%D1%88%D0%B0_%D0%B4%D0%BB%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B8_%D1%81_%D0%BF%D0%BB%D0%B0%D0%B2%D0%B0%D1%8E%D1%89%D0%B5%D0%B9_%D1%82%D0%BE%D1%87%D0%BA%D0%BE%D0%B9_%D1%81_%D0%BF%D0%BE%D0%BB%D0%BD%D0%BE%D0%B9_%D0%BF%D0%B5%D1%80%D0%B5%D0%BE%D1%80%D1%82%D0%BE%D0%B3%D0%BE%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D0%B5%D0%B9&diff=22587Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией2017-05-03T13:15:39Z<p>Chernyavskiy: /* =Общий информационный граф */</p>
<hr />
<div>Основные авторы описания: [[Участник:Sagak|С.А.Айвазян]], [[Участник:Kozlov_Vladimir|В.Козлов]] (Часть 1), [[Участник:Chernyavskiy|А.Ю.Чернявский]] (компоновка и редактирование), [[Участник:ASA|А.С.Антонов]] (предварительная проверка).<br />
<br />
<br />
<br />
== Свойства и структура алгоритма ==<br />
===Общее описание алгоритма===<br />
Алгоритм Ланцоша – итерационный метод , созданный Корнелиусом Ланцошем, для нахождения собственных значений и собственных векторов симметричной матрицы. Суть алгоритма в том, что он сводит частичную проблему собственных значений симметричной вещественной матрицы к полной проблеме собственных значений для симметричной трехдиагональной матрицы меньшей размерности. Алгоритм применяется к матрицам большой размерности, к которым не применимы никакие прямые методы. <br />
<br />
Алгоритм Ланцоша относится к методам аппроксимаций, которые применяют широко распространенную в математике процедуру Релея-Ритца к матричным вычислениям, посредством чего сводят исходную задачу к задаче гораздо меньшего размера, решив которую, получаем приближенные собственные значения и собственные векторы исходной задачи. Метод основан на применении процедуры Релея-Ритца к последовательности вложенных подпространств Крылова.<br />
Важной особенностью подпространства Крылова является трехдиагонольность ортогональной проекции на него исходной матрицы, что способствует тому, что процедура <br />
Релея-Ритца прорабатывает очень эффективно. Главными особенностями поведения алгоритмов метода Ланцоша являются потеря ортогональности векторов базиса и быстрая сходимость в области наибольших по значению собственных значений. Наиболее популярными средствами борьбы с потерей ортогональности векторов Ланцоша являются различные варианты переортогонализации: частичная, полная и выборочная.<br />
<br />
Симметричность исходной матрицы позволяет хранить и вычислять чуть больше половины её элементов, что почти вдвое экономит как необходимые для вычислений объёмы памяти, так и количество операций. Также алгоритм позволяет использовать так называемый режим накопления, обусловленный тем, что значительную часть вычислений составляют вычисления скалярных произведений.<br />
<br />
Преимущество алгоритма заключается в том, что он дает приближение за конечное число шагов. Метод Ланцоша выигрывает в конкуренции таким прямым методам, как метод прямых или обратных итераций, <math>QR</math> и <math>QL</math> преобразования, методы вращений (вращения Якоби), которые потеряли значение как самостоятельные методы поиска собственных<br />
значений матриц большого размера. Также нужно заметить, что метод Ланцоша практически всегда эффективнее других методов аппроксимаций.<br />
<br />
<br />
=== Математическое описание алгоритма ===<br />
<br />
<br />
'''Алгоритм Ланцоша''' — это итерационный алгоритм поиска <math>k</math> приближённых собственных значений симметричной вещественной матрицы <math>A</math> размера <math>n \times n</math>. Алгоритм применяется, когда матрица <math>A</math> слишком велика, чтобы к ней можно было применять точные прямые методы вычисления собственных значений. Алгоритм комбинирует '''метод Рэлея — Ритца''' поиска приближённых собственных значений и '''метод Ланцоша''' построения крыловского подпространства.<br />
<br />
Метод Рэлея — Ритца является методом поиска <math>k</math> приближённых собственных значений симметричной вещественной матрицы <math>A</math> размера <math>n \times n</math>. Если <math>Q = [Q_k, Q_u]</math> — ортонормированная матрица размера <math>n \times n</math>, <math>Q_k</math> имеет размер <math>n \times k</math>, <math>Q_u</math> имеет размер <math>n \times n - k</math>, то можно записать равенство<br />
<br />
<math>T = Q^T A Q = [Q_k, Q_u]^T A [Q_k, Q_u] = <br />
\left[ \begin{array}{cc}<br />
Q_k^T A Q_k & Q_k^T A Q_u\\<br />
Q_u^T A Q_k & Q_u^T A Q_u<br />
\end{array} \right]<br />
= \left[ \begin{array}{cc}<br />
T_{k} & T_{ku}^T\\<br />
T_{ku} & T_{u}<br />
\end{array} \right].</math><br />
<br />
Метод Рэлея — Ритца заключается в том, что собственные значения матрицы <math>T_k = Q_k^T A Q_k</math> объявляются приближёнными собственными значениями матрицы <math>A</math>. Такое приближение является в некотором смысле «наилучшим»: можно показать, что если <math>T_k = V \Lambda V^{-1}</math> — спектральное разложение <math>T_k</math>, то пара <math>(Q_k V, \Lambda)</math> минимизирует функционал <math>L(P_k, D) = \Vert A P_k - P_k D \Vert_2</math>, причём <math>L(Q_k V, \Lambda) = \Vert T_{ku} \Vert_2</math>, то есть <math>A \approx (Q_k V) \Lambda (Q_k V)^{-1}</math>. Из этого также видно, что метод Рэлея — Ритца позволяет получать приближения для собственных векторов матрицы <math>A</math>. Более того, можно показать, что собственные значения <math>T</math> отличаются от некоторых собственных значений <math>A</math> не более чем на <math>\Vert T_{ku} \Vert_2</math>. <br />
<br />
Метод Ланцоша — это метод построения матрицы <math>Q</math>, при использовании которого, во-первых, матрица <math>T</math> оказывается симметричной трёхдиагональной, во-вторых, столбцы <math>Q</math> и <math>T</math> вычисляются последовательно. Трёхдиагональность <math>T</math> приводит к следующим явлениям:<br />
# матрица <math>T_k</math> является трёхдиагональной матрицей меньшей размерности, а для трёхдиагональных матриц существуют высокоэффективные методы поиска собственных значений;<br />
# матрица <math>T_{ku}</math> имеет только один ненулевой (возможно) элемент — правый верхний, а значит, для оценки погрешности полученных собственных значений достаточно знать только этот элемент.<br />
<br />
В теории в методе Ланцоша для вычисления каждого следующего столбца <math>q_{j + 1}</math> матрицы <math>Q</math> достаточно знать только <math>q_{j - 1}</math> и <math>q_{j}</math> в силу трёхдиагональности матрицы <math>T</math>. На практике из-за ошибок округления, если не предпринимать специальных мер, набор векторов <math>q_{1}, \dots, q_{k}</math> перестаёт быть ортогональным. Для борьбы с этим явлением на каждом шаге метода Ланцоша приходится выполнять так называемую переортогонализацию — повторно запускать процесс ортогонализации Грама — Шмидта.<br />
<br />
Перейдем к описанию самого алгоритма.<br />
<br />
Исходные данные: симметричная вещественная матрица <math>A</math> — матрица, для которой будут вычисляться собственные значения, вектор <math>b</math> — начальное приближение для метода Ланцоша.<br />
<br />
Выходные данные: трёхдиагональная симметричная вещественная матрица <math>T_k = \left[ \begin{array}{cccc}<br />
\alpha_1 & \beta_1 & & \\<br />
\beta_1 & \ddots & \ddots & \\<br />
& \ddots & \ddots & \beta_{k - 1}\\<br />
& & \beta_{k - 1} & \alpha_k<br />
\end{array} \right]</math>, ортонормированный набор векторов <math>q_1, \dots, q_k</math>: <math>T_k = [q_1, \dots, q_k]^T A [q_1, \dots, q_k]</math>.<br />
<br />
Формулы метода:<br />
<br />
<math><br />
\begin{array}{l}<br />
q_1 = b / \Vert b \Vert_2\\<br />
j = \overline{1, k}:\\<br />
\quad z_j = A q_j \\<br />
\quad \alpha_j = q_j^T A q_j = q_j^T z_j \\<br />
\quad z_j' = z_j - \sum_{i=1}^j (z_j^T q_i) q_i \\<br />
\quad z_j'' = z_j' - \sum_{i=1}^j (z_j'^T q_i) q_i\\<br />
\quad \beta_j = \Vert z_j'' \Vert_2\\<br />
\quad q_{j+1} = z_j'' / \Vert z_j'' \Vert_2 = z_j''/\beta_j<br />
\end{array}<br />
</math> <br />
<br />
Собственные значения и собственные векторы матрицы <math>T_k</math> ищутся любым прямым алгоритмом.<br />
<br />
Вычисление <math>z_j', z_j''</math> — это полная переортогонализация <math>z_j</math> методом Грама — Шмидта. Двойной запуск практически гарантирует, что <math>z_j''</math> будет ортогонален <math>q_1, \dots, q_j</math>. Заметим, что <math>\sum_{i=1}^j (z^T q_i) q_i = Q_j Q_j^T z</math>, где <math>Q_j = [q_1, \dots, q_j]</math>, поэтому переортогонализацию можно переписать в виде <math>z'_j = z_j - Q_j Q_j^T z_j, z_j'' = z_j' - Q_j Q_j^T z_j'</math>.<br />
<br />
Если <math>\beta_j = 0</math> для какого-либо <math>j < k</math>, то <math>\Vert T_{ju}\Vert_2 = 0</math>, а значит, собственные значения <math>T_j</math> в точности совпадают с каким-то собственными значениями <math>A</math>. В этом случае дальнейшие вычисления прекращаются и либо используется полученная <math>T_j</math> размерности меньшей, чем <math>k</math>, либо процедура запускается заново с другим начальным вектором <math>b</math>.<br />
<br />
=== Вычислительное ядро алгоритма ===<br />
У алгоритма построения матрицы <math>T_k</math> в том виде, как он описан выше, можно выделить два ядра:<br />
# умножение матрицы <math>A</math> на вектор <math>q_j</math>: <math>z_j = A q_j</math> (<math>O(n^2)</math> умножений вещественных чисел);<br />
# переортогонализация: <math>z'_j = z_j - Q_j Q_j^T z_j,\; z_j'' = z_j' - Q_j Q_j^T z_j'</math> (<math>O(nk^2)</math> умножений вещественных чисел).<br />
<br />
<br />
=== Макроструктура алгоритма ===<br />
На макроуровне выделяем 3 основные операции:<br />
<br />
1. Умножение исходной матрицы <math>A</math> на очередной вектор базиса <math>q_p</math>.<br />
<br />
<math><br />
z=Aq_p. <br />
</math><br />
<br />
2. Повторное проведения процесса Грамма-Шмидта для ортогонализации посчитанного вектора <math>z</math> со всеми построенными ранее векторами базиса.<br />
<br />
<math><br />
z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i, </math> <br />
<br />
<math>z=z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i. </math> <br />
<br />
3.Непосредственное вычисление нового базисного вектора <math>q_{j+1}</math> и элементов <math><br />
\alpha_j<br />
</math>, <math> \beta_{j+1}<br />
</math> трехдиагональной матрицы.<br />
<br />
<math><br />
\alpha_j=q_j^Tz,<br />
</math><br />
<br />
<math>z=z-\alpha_jq_j-\beta_{j}q_{j-1}, </math><br />
<br />
<math>\beta_{j+1}=||z||,<br />
</math><br />
<br />
<math>q_{j+1}=z/\beta_{j+1}.</math><br />
<br />
=== Схема реализации последовательного алгоритма ===<br />
Последовательность исполнения метода следующая:<br />
<br />
Сначала заполняем начальные значения. <br />
<br />
<math><br />
\begin{align}<br />
& q_1=b/||b||,\\<br />
& \beta_1=0,\\<br />
&q_0=0, \\<br />
\end{align}<br />
</math><br />
<br />
где <math>b</math>-произвольный вектор.<br />
<br />
Далее выполняется основная процедура, которая строит ортонормированный базис подпространства Крылова для симметричной матрицы и трехдиагональную матрицу размерности <math>k</math>.<br />
<br />
Для всех <math>j</math> от <math>1</math> до <math>k</math> по нарастанию выполняются<br />
<br />
<math><br />
1.z=Aq_j, <br />
</math><br />
<br />
Вычисляем элемент, который будет находится на позиции <math>t_{j,j}</math> конечной матрицы <math>T_k</math>,<br />
<br />
<math><br />
2.\alpha_j=q_j^Tz,<br />
</math><br />
<br />
Чтобы гарантировать ортогональность базиса на каждой итерации цикла два раза проводим полную переортогонализацию, использую процесс Грамма-Шмидта,<br />
<br />
<math><br />
3.z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i, </math> <br />
<br />
<math>4.z=z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i, </math> <br />
<br />
После ортогонализации процедура продолжается следующим образом. <br />
<br />
<math>5.z=z-\alpha_jq_j-\beta_{j}q_{j-1}, </math><br />
<br />
Вычисляем элемент, который будет находится на позиции <math>t_{j,j+1}</math> и <math>t_{j+1,j}</math>,<br />
<br />
<math>6.\beta_{j+1}=||z||,<br />
</math><br />
<br />
Если <math>\beta_{j+1}=0</math>, то алгоритм завершается.<br />
<br />
<math>7.q_{j+1}=z/\beta_{j+1}.</math><br />
<br />
В конце каждой итерации получаем очередной вектор <math>q_{j+1}</math> базиса с единичной нормой, который ортогонален всем предыдущим векторам базиса,<br />
<br />
и элементы <math>\alpha_j</math>, <math>\beta_{j+1}</math> трехдиагональной матрицы размерности <math>k</math> .<br />
<br />
<br />
=== Последовательная сложность алгоритма ===<br />
На <math>j</math>-ой итерации алгоритм выполняет<br />
* <math>n^2 + n + 4nj + n + n = n^2 + 3n + 4nj</math> умножений и делений;<br />
* <math>n(n - 1) + (n - 1) + (4n - 2)j + (n - 1) = n^2 + (n - 2) + (4n - 2)j</math> сложений и вычитаний;<br />
* одно извлечение квадратного корня.<br />
<br />
Всего за <math>k</math> итераций алгоритм выполняет<br />
* <math>(n + 3)nk + 2nk(k + 1)</math> умножений и делений;<br />
* <math>(n^2 + n - 2)k + (2n - 1)k(k + 1)</math> сложений и вычитаний.<br />
<br />
Таким образом, алгоритм имеет последовательную сложность <math>O(n^2k + nk^2)</math>.<br />
<br />
=== Информационный граф===<br />
<br />
Представим информационные графы разных уровней алгоритма.<br />
<br />
====Информационный граф на уровне макроопераций с входными и выходными данными====<br />
<br />
[[Файл:Lanczoc-full-orth-macro.png|thumb|1000px|center|alt=Информационный граф алгоритма Ланцоша на уровне отдельных итераций|Рисунок 1. Информационный граф алгоритма Ланцоша на уровне итераций с входными и выходными данными. In — входные данные (матрица <math>A</math> и вектор <math>b</math>), Out — выходные данные (<math>\alpha_j, \beta_j</math> и <math>q_j</math>), nrm — вычисление еклидовой нормы вектора, / — деление вектора на число, Iter — итерации алгоритма.]]<br />
<br />
<br />
====Информационный граф на уровне одной итерации с входными и выходными данными====<br />
<br />
<br />
[[Файл:Lanczoc-full-orth-iter.png|thumb|1000px|center|alt=Информационный граф алгоритма Ланцоша на уровне отдельных итераций|Рисунок 2. Информационный граф итерации алгоритма Ланцоша на уровне макроопераций. In — входные данные (матрица <math>A</math>), Out — выходные данные (<math>\alpha_j, \beta_j</math> и <math>q_j</math>), dprod — скалярное произведение векторов, mprod — произведение матрицы на вектор, - — разность векторов, nrm — вычисление еклидовой нормы вектора, / — деление вектора на число.]]<br />
<br />
====Общий информационный граф алгроитма====<br />
[[Файл:photo.jpg]]Здесь показаны первые три итерации алгоритма, при больших итерациях граф строится аналогичным образом.<br />
* Вершина черного цвета соответствует операции <math>Aq_j,</math>.<br />
* Вершина красного цвета соответствует операции скалярного произведения <math>q_j^Tz</math>.<br />
* Вершина сиреневого цвета соответствует операции <math>z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i</math>.<br />
* Вершина желтого цвета соответствует операции <math>z-\alpha_jq_j-\beta_{j-1}q_{j-1}</math>.<br />
* Вершина синего цвета соответствует операции <math>||z||</math>.<br />
* Вершина зеленого цвета соответствует операции <math>z/\beta_j</math>.</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9B%D0%B0%D0%BD%D1%86%D0%BE%D1%88%D0%B0_%D0%B4%D0%BB%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B8_%D1%81_%D0%BF%D0%BB%D0%B0%D0%B2%D0%B0%D1%8E%D1%89%D0%B5%D0%B9_%D1%82%D0%BE%D1%87%D0%BA%D0%BE%D0%B9_%D1%81_%D0%BF%D0%BE%D0%BB%D0%BD%D0%BE%D0%B9_%D0%BF%D0%B5%D1%80%D0%B5%D0%BE%D1%80%D1%82%D0%BE%D0%B3%D0%BE%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D0%B5%D0%B9&diff=22586Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией2017-05-03T13:15:21Z<p>Chernyavskiy: /* =Информационный граф на уровне макроопераций с входными и выходными данными */</p>
<hr />
<div>Основные авторы описания: [[Участник:Sagak|С.А.Айвазян]], [[Участник:Kozlov_Vladimir|В.Козлов]] (Часть 1), [[Участник:Chernyavskiy|А.Ю.Чернявский]] (компоновка и редактирование), [[Участник:ASA|А.С.Антонов]] (предварительная проверка).<br />
<br />
<br />
<br />
== Свойства и структура алгоритма ==<br />
===Общее описание алгоритма===<br />
Алгоритм Ланцоша – итерационный метод , созданный Корнелиусом Ланцошем, для нахождения собственных значений и собственных векторов симметричной матрицы. Суть алгоритма в том, что он сводит частичную проблему собственных значений симметричной вещественной матрицы к полной проблеме собственных значений для симметричной трехдиагональной матрицы меньшей размерности. Алгоритм применяется к матрицам большой размерности, к которым не применимы никакие прямые методы. <br />
<br />
Алгоритм Ланцоша относится к методам аппроксимаций, которые применяют широко распространенную в математике процедуру Релея-Ритца к матричным вычислениям, посредством чего сводят исходную задачу к задаче гораздо меньшего размера, решив которую, получаем приближенные собственные значения и собственные векторы исходной задачи. Метод основан на применении процедуры Релея-Ритца к последовательности вложенных подпространств Крылова.<br />
Важной особенностью подпространства Крылова является трехдиагонольность ортогональной проекции на него исходной матрицы, что способствует тому, что процедура <br />
Релея-Ритца прорабатывает очень эффективно. Главными особенностями поведения алгоритмов метода Ланцоша являются потеря ортогональности векторов базиса и быстрая сходимость в области наибольших по значению собственных значений. Наиболее популярными средствами борьбы с потерей ортогональности векторов Ланцоша являются различные варианты переортогонализации: частичная, полная и выборочная.<br />
<br />
Симметричность исходной матрицы позволяет хранить и вычислять чуть больше половины её элементов, что почти вдвое экономит как необходимые для вычислений объёмы памяти, так и количество операций. Также алгоритм позволяет использовать так называемый режим накопления, обусловленный тем, что значительную часть вычислений составляют вычисления скалярных произведений.<br />
<br />
Преимущество алгоритма заключается в том, что он дает приближение за конечное число шагов. Метод Ланцоша выигрывает в конкуренции таким прямым методам, как метод прямых или обратных итераций, <math>QR</math> и <math>QL</math> преобразования, методы вращений (вращения Якоби), которые потеряли значение как самостоятельные методы поиска собственных<br />
значений матриц большого размера. Также нужно заметить, что метод Ланцоша практически всегда эффективнее других методов аппроксимаций.<br />
<br />
<br />
=== Математическое описание алгоритма ===<br />
<br />
<br />
'''Алгоритм Ланцоша''' — это итерационный алгоритм поиска <math>k</math> приближённых собственных значений симметричной вещественной матрицы <math>A</math> размера <math>n \times n</math>. Алгоритм применяется, когда матрица <math>A</math> слишком велика, чтобы к ней можно было применять точные прямые методы вычисления собственных значений. Алгоритм комбинирует '''метод Рэлея — Ритца''' поиска приближённых собственных значений и '''метод Ланцоша''' построения крыловского подпространства.<br />
<br />
Метод Рэлея — Ритца является методом поиска <math>k</math> приближённых собственных значений симметричной вещественной матрицы <math>A</math> размера <math>n \times n</math>. Если <math>Q = [Q_k, Q_u]</math> — ортонормированная матрица размера <math>n \times n</math>, <math>Q_k</math> имеет размер <math>n \times k</math>, <math>Q_u</math> имеет размер <math>n \times n - k</math>, то можно записать равенство<br />
<br />
<math>T = Q^T A Q = [Q_k, Q_u]^T A [Q_k, Q_u] = <br />
\left[ \begin{array}{cc}<br />
Q_k^T A Q_k & Q_k^T A Q_u\\<br />
Q_u^T A Q_k & Q_u^T A Q_u<br />
\end{array} \right]<br />
= \left[ \begin{array}{cc}<br />
T_{k} & T_{ku}^T\\<br />
T_{ku} & T_{u}<br />
\end{array} \right].</math><br />
<br />
Метод Рэлея — Ритца заключается в том, что собственные значения матрицы <math>T_k = Q_k^T A Q_k</math> объявляются приближёнными собственными значениями матрицы <math>A</math>. Такое приближение является в некотором смысле «наилучшим»: можно показать, что если <math>T_k = V \Lambda V^{-1}</math> — спектральное разложение <math>T_k</math>, то пара <math>(Q_k V, \Lambda)</math> минимизирует функционал <math>L(P_k, D) = \Vert A P_k - P_k D \Vert_2</math>, причём <math>L(Q_k V, \Lambda) = \Vert T_{ku} \Vert_2</math>, то есть <math>A \approx (Q_k V) \Lambda (Q_k V)^{-1}</math>. Из этого также видно, что метод Рэлея — Ритца позволяет получать приближения для собственных векторов матрицы <math>A</math>. Более того, можно показать, что собственные значения <math>T</math> отличаются от некоторых собственных значений <math>A</math> не более чем на <math>\Vert T_{ku} \Vert_2</math>. <br />
<br />
Метод Ланцоша — это метод построения матрицы <math>Q</math>, при использовании которого, во-первых, матрица <math>T</math> оказывается симметричной трёхдиагональной, во-вторых, столбцы <math>Q</math> и <math>T</math> вычисляются последовательно. Трёхдиагональность <math>T</math> приводит к следующим явлениям:<br />
# матрица <math>T_k</math> является трёхдиагональной матрицей меньшей размерности, а для трёхдиагональных матриц существуют высокоэффективные методы поиска собственных значений;<br />
# матрица <math>T_{ku}</math> имеет только один ненулевой (возможно) элемент — правый верхний, а значит, для оценки погрешности полученных собственных значений достаточно знать только этот элемент.<br />
<br />
В теории в методе Ланцоша для вычисления каждого следующего столбца <math>q_{j + 1}</math> матрицы <math>Q</math> достаточно знать только <math>q_{j - 1}</math> и <math>q_{j}</math> в силу трёхдиагональности матрицы <math>T</math>. На практике из-за ошибок округления, если не предпринимать специальных мер, набор векторов <math>q_{1}, \dots, q_{k}</math> перестаёт быть ортогональным. Для борьбы с этим явлением на каждом шаге метода Ланцоша приходится выполнять так называемую переортогонализацию — повторно запускать процесс ортогонализации Грама — Шмидта.<br />
<br />
Перейдем к описанию самого алгоритма.<br />
<br />
Исходные данные: симметричная вещественная матрица <math>A</math> — матрица, для которой будут вычисляться собственные значения, вектор <math>b</math> — начальное приближение для метода Ланцоша.<br />
<br />
Выходные данные: трёхдиагональная симметричная вещественная матрица <math>T_k = \left[ \begin{array}{cccc}<br />
\alpha_1 & \beta_1 & & \\<br />
\beta_1 & \ddots & \ddots & \\<br />
& \ddots & \ddots & \beta_{k - 1}\\<br />
& & \beta_{k - 1} & \alpha_k<br />
\end{array} \right]</math>, ортонормированный набор векторов <math>q_1, \dots, q_k</math>: <math>T_k = [q_1, \dots, q_k]^T A [q_1, \dots, q_k]</math>.<br />
<br />
Формулы метода:<br />
<br />
<math><br />
\begin{array}{l}<br />
q_1 = b / \Vert b \Vert_2\\<br />
j = \overline{1, k}:\\<br />
\quad z_j = A q_j \\<br />
\quad \alpha_j = q_j^T A q_j = q_j^T z_j \\<br />
\quad z_j' = z_j - \sum_{i=1}^j (z_j^T q_i) q_i \\<br />
\quad z_j'' = z_j' - \sum_{i=1}^j (z_j'^T q_i) q_i\\<br />
\quad \beta_j = \Vert z_j'' \Vert_2\\<br />
\quad q_{j+1} = z_j'' / \Vert z_j'' \Vert_2 = z_j''/\beta_j<br />
\end{array}<br />
</math> <br />
<br />
Собственные значения и собственные векторы матрицы <math>T_k</math> ищутся любым прямым алгоритмом.<br />
<br />
Вычисление <math>z_j', z_j''</math> — это полная переортогонализация <math>z_j</math> методом Грама — Шмидта. Двойной запуск практически гарантирует, что <math>z_j''</math> будет ортогонален <math>q_1, \dots, q_j</math>. Заметим, что <math>\sum_{i=1}^j (z^T q_i) q_i = Q_j Q_j^T z</math>, где <math>Q_j = [q_1, \dots, q_j]</math>, поэтому переортогонализацию можно переписать в виде <math>z'_j = z_j - Q_j Q_j^T z_j, z_j'' = z_j' - Q_j Q_j^T z_j'</math>.<br />
<br />
Если <math>\beta_j = 0</math> для какого-либо <math>j < k</math>, то <math>\Vert T_{ju}\Vert_2 = 0</math>, а значит, собственные значения <math>T_j</math> в точности совпадают с каким-то собственными значениями <math>A</math>. В этом случае дальнейшие вычисления прекращаются и либо используется полученная <math>T_j</math> размерности меньшей, чем <math>k</math>, либо процедура запускается заново с другим начальным вектором <math>b</math>.<br />
<br />
=== Вычислительное ядро алгоритма ===<br />
У алгоритма построения матрицы <math>T_k</math> в том виде, как он описан выше, можно выделить два ядра:<br />
# умножение матрицы <math>A</math> на вектор <math>q_j</math>: <math>z_j = A q_j</math> (<math>O(n^2)</math> умножений вещественных чисел);<br />
# переортогонализация: <math>z'_j = z_j - Q_j Q_j^T z_j,\; z_j'' = z_j' - Q_j Q_j^T z_j'</math> (<math>O(nk^2)</math> умножений вещественных чисел).<br />
<br />
<br />
=== Макроструктура алгоритма ===<br />
На макроуровне выделяем 3 основные операции:<br />
<br />
1. Умножение исходной матрицы <math>A</math> на очередной вектор базиса <math>q_p</math>.<br />
<br />
<math><br />
z=Aq_p. <br />
</math><br />
<br />
2. Повторное проведения процесса Грамма-Шмидта для ортогонализации посчитанного вектора <math>z</math> со всеми построенными ранее векторами базиса.<br />
<br />
<math><br />
z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i, </math> <br />
<br />
<math>z=z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i. </math> <br />
<br />
3.Непосредственное вычисление нового базисного вектора <math>q_{j+1}</math> и элементов <math><br />
\alpha_j<br />
</math>, <math> \beta_{j+1}<br />
</math> трехдиагональной матрицы.<br />
<br />
<math><br />
\alpha_j=q_j^Tz,<br />
</math><br />
<br />
<math>z=z-\alpha_jq_j-\beta_{j}q_{j-1}, </math><br />
<br />
<math>\beta_{j+1}=||z||,<br />
</math><br />
<br />
<math>q_{j+1}=z/\beta_{j+1}.</math><br />
<br />
=== Схема реализации последовательного алгоритма ===<br />
Последовательность исполнения метода следующая:<br />
<br />
Сначала заполняем начальные значения. <br />
<br />
<math><br />
\begin{align}<br />
& q_1=b/||b||,\\<br />
& \beta_1=0,\\<br />
&q_0=0, \\<br />
\end{align}<br />
</math><br />
<br />
где <math>b</math>-произвольный вектор.<br />
<br />
Далее выполняется основная процедура, которая строит ортонормированный базис подпространства Крылова для симметричной матрицы и трехдиагональную матрицу размерности <math>k</math>.<br />
<br />
Для всех <math>j</math> от <math>1</math> до <math>k</math> по нарастанию выполняются<br />
<br />
<math><br />
1.z=Aq_j, <br />
</math><br />
<br />
Вычисляем элемент, который будет находится на позиции <math>t_{j,j}</math> конечной матрицы <math>T_k</math>,<br />
<br />
<math><br />
2.\alpha_j=q_j^Tz,<br />
</math><br />
<br />
Чтобы гарантировать ортогональность базиса на каждой итерации цикла два раза проводим полную переортогонализацию, использую процесс Грамма-Шмидта,<br />
<br />
<math><br />
3.z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i, </math> <br />
<br />
<math>4.z=z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i, </math> <br />
<br />
После ортогонализации процедура продолжается следующим образом. <br />
<br />
<math>5.z=z-\alpha_jq_j-\beta_{j}q_{j-1}, </math><br />
<br />
Вычисляем элемент, который будет находится на позиции <math>t_{j,j+1}</math> и <math>t_{j+1,j}</math>,<br />
<br />
<math>6.\beta_{j+1}=||z||,<br />
</math><br />
<br />
Если <math>\beta_{j+1}=0</math>, то алгоритм завершается.<br />
<br />
<math>7.q_{j+1}=z/\beta_{j+1}.</math><br />
<br />
В конце каждой итерации получаем очередной вектор <math>q_{j+1}</math> базиса с единичной нормой, который ортогонален всем предыдущим векторам базиса,<br />
<br />
и элементы <math>\alpha_j</math>, <math>\beta_{j+1}</math> трехдиагональной матрицы размерности <math>k</math> .<br />
<br />
<br />
=== Последовательная сложность алгоритма ===<br />
На <math>j</math>-ой итерации алгоритм выполняет<br />
* <math>n^2 + n + 4nj + n + n = n^2 + 3n + 4nj</math> умножений и делений;<br />
* <math>n(n - 1) + (n - 1) + (4n - 2)j + (n - 1) = n^2 + (n - 2) + (4n - 2)j</math> сложений и вычитаний;<br />
* одно извлечение квадратного корня.<br />
<br />
Всего за <math>k</math> итераций алгоритм выполняет<br />
* <math>(n + 3)nk + 2nk(k + 1)</math> умножений и делений;<br />
* <math>(n^2 + n - 2)k + (2n - 1)k(k + 1)</math> сложений и вычитаний.<br />
<br />
Таким образом, алгоритм имеет последовательную сложность <math>O(n^2k + nk^2)</math>.<br />
<br />
=== Информационный граф===<br />
<br />
Представим информационные графы разных уровней алгоритма.<br />
<br />
====Информационный граф на уровне макроопераций с входными и выходными данными====<br />
<br />
[[Файл:Lanczoc-full-orth-macro.png|thumb|1000px|center|alt=Информационный граф алгоритма Ланцоша на уровне отдельных итераций|Рисунок 1. Информационный граф алгоритма Ланцоша на уровне итераций с входными и выходными данными. In — входные данные (матрица <math>A</math> и вектор <math>b</math>), Out — выходные данные (<math>\alpha_j, \beta_j</math> и <math>q_j</math>), nrm — вычисление еклидовой нормы вектора, / — деление вектора на число, Iter — итерации алгоритма.]]<br />
<br />
<br />
====Информационный граф на уровне одной итерации с входными и выходными данными====<br />
<br />
<br />
[[Файл:Lanczoc-full-orth-iter.png|thumb|1000px|center|alt=Информационный граф алгоритма Ланцоша на уровне отдельных итераций|Рисунок 2. Информационный граф итерации алгоритма Ланцоша на уровне макроопераций. In — входные данные (матрица <math>A</math>), Out — выходные данные (<math>\alpha_j, \beta_j</math> и <math>q_j</math>), dprod — скалярное произведение векторов, mprod — произведение матрицы на вектор, - — разность векторов, nrm — вычисление еклидовой нормы вектора, / — деление вектора на число.]]<br />
<br />
====Общий информационный граф===<br />
[[Файл:photo.jpg]]Здесь показаны первые три итерации алгоритма, при больших итерациях граф строится аналогичным образом.<br />
* Вершина черного цвета соответствует операции <math>Aq_j,</math>.<br />
* Вершина красного цвета соответствует операции скалярного произведения <math>q_j^Tz</math>.<br />
* Вершина сиреневого цвета соответствует операции <math>z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i</math>.<br />
* Вершина желтого цвета соответствует операции <math>z-\alpha_jq_j-\beta_{j-1}q_{j-1}</math>.<br />
* Вершина синего цвета соответствует операции <math>||z||</math>.<br />
* Вершина зеленого цвета соответствует операции <math>z/\beta_j</math>.</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9B%D0%B0%D0%BD%D1%86%D0%BE%D1%88%D0%B0_%D0%B4%D0%BB%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B8_%D1%81_%D0%BF%D0%BB%D0%B0%D0%B2%D0%B0%D1%8E%D1%89%D0%B5%D0%B9_%D1%82%D0%BE%D1%87%D0%BA%D0%BE%D0%B9_%D1%81_%D0%BF%D0%BE%D0%BB%D0%BD%D0%BE%D0%B9_%D0%BF%D0%B5%D1%80%D0%B5%D0%BE%D1%80%D1%82%D0%BE%D0%B3%D0%BE%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D0%B5%D0%B9&diff=22585Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией2017-05-03T13:14:43Z<p>Chernyavskiy: /* Свойства и структура алгоритма */</p>
<hr />
<div>Основные авторы описания: [[Участник:Sagak|С.А.Айвазян]], [[Участник:Kozlov_Vladimir|В.Козлов]] (Часть 1), [[Участник:Chernyavskiy|А.Ю.Чернявский]] (компоновка и редактирование), [[Участник:ASA|А.С.Антонов]] (предварительная проверка).<br />
<br />
<br />
<br />
== Свойства и структура алгоритма ==<br />
===Общее описание алгоритма===<br />
Алгоритм Ланцоша – итерационный метод , созданный Корнелиусом Ланцошем, для нахождения собственных значений и собственных векторов симметричной матрицы. Суть алгоритма в том, что он сводит частичную проблему собственных значений симметричной вещественной матрицы к полной проблеме собственных значений для симметричной трехдиагональной матрицы меньшей размерности. Алгоритм применяется к матрицам большой размерности, к которым не применимы никакие прямые методы. <br />
<br />
Алгоритм Ланцоша относится к методам аппроксимаций, которые применяют широко распространенную в математике процедуру Релея-Ритца к матричным вычислениям, посредством чего сводят исходную задачу к задаче гораздо меньшего размера, решив которую, получаем приближенные собственные значения и собственные векторы исходной задачи. Метод основан на применении процедуры Релея-Ритца к последовательности вложенных подпространств Крылова.<br />
Важной особенностью подпространства Крылова является трехдиагонольность ортогональной проекции на него исходной матрицы, что способствует тому, что процедура <br />
Релея-Ритца прорабатывает очень эффективно. Главными особенностями поведения алгоритмов метода Ланцоша являются потеря ортогональности векторов базиса и быстрая сходимость в области наибольших по значению собственных значений. Наиболее популярными средствами борьбы с потерей ортогональности векторов Ланцоша являются различные варианты переортогонализации: частичная, полная и выборочная.<br />
<br />
Симметричность исходной матрицы позволяет хранить и вычислять чуть больше половины её элементов, что почти вдвое экономит как необходимые для вычислений объёмы памяти, так и количество операций. Также алгоритм позволяет использовать так называемый режим накопления, обусловленный тем, что значительную часть вычислений составляют вычисления скалярных произведений.<br />
<br />
Преимущество алгоритма заключается в том, что он дает приближение за конечное число шагов. Метод Ланцоша выигрывает в конкуренции таким прямым методам, как метод прямых или обратных итераций, <math>QR</math> и <math>QL</math> преобразования, методы вращений (вращения Якоби), которые потеряли значение как самостоятельные методы поиска собственных<br />
значений матриц большого размера. Также нужно заметить, что метод Ланцоша практически всегда эффективнее других методов аппроксимаций.<br />
<br />
<br />
=== Математическое описание алгоритма ===<br />
<br />
<br />
'''Алгоритм Ланцоша''' — это итерационный алгоритм поиска <math>k</math> приближённых собственных значений симметричной вещественной матрицы <math>A</math> размера <math>n \times n</math>. Алгоритм применяется, когда матрица <math>A</math> слишком велика, чтобы к ней можно было применять точные прямые методы вычисления собственных значений. Алгоритм комбинирует '''метод Рэлея — Ритца''' поиска приближённых собственных значений и '''метод Ланцоша''' построения крыловского подпространства.<br />
<br />
Метод Рэлея — Ритца является методом поиска <math>k</math> приближённых собственных значений симметричной вещественной матрицы <math>A</math> размера <math>n \times n</math>. Если <math>Q = [Q_k, Q_u]</math> — ортонормированная матрица размера <math>n \times n</math>, <math>Q_k</math> имеет размер <math>n \times k</math>, <math>Q_u</math> имеет размер <math>n \times n - k</math>, то можно записать равенство<br />
<br />
<math>T = Q^T A Q = [Q_k, Q_u]^T A [Q_k, Q_u] = <br />
\left[ \begin{array}{cc}<br />
Q_k^T A Q_k & Q_k^T A Q_u\\<br />
Q_u^T A Q_k & Q_u^T A Q_u<br />
\end{array} \right]<br />
= \left[ \begin{array}{cc}<br />
T_{k} & T_{ku}^T\\<br />
T_{ku} & T_{u}<br />
\end{array} \right].</math><br />
<br />
Метод Рэлея — Ритца заключается в том, что собственные значения матрицы <math>T_k = Q_k^T A Q_k</math> объявляются приближёнными собственными значениями матрицы <math>A</math>. Такое приближение является в некотором смысле «наилучшим»: можно показать, что если <math>T_k = V \Lambda V^{-1}</math> — спектральное разложение <math>T_k</math>, то пара <math>(Q_k V, \Lambda)</math> минимизирует функционал <math>L(P_k, D) = \Vert A P_k - P_k D \Vert_2</math>, причём <math>L(Q_k V, \Lambda) = \Vert T_{ku} \Vert_2</math>, то есть <math>A \approx (Q_k V) \Lambda (Q_k V)^{-1}</math>. Из этого также видно, что метод Рэлея — Ритца позволяет получать приближения для собственных векторов матрицы <math>A</math>. Более того, можно показать, что собственные значения <math>T</math> отличаются от некоторых собственных значений <math>A</math> не более чем на <math>\Vert T_{ku} \Vert_2</math>. <br />
<br />
Метод Ланцоша — это метод построения матрицы <math>Q</math>, при использовании которого, во-первых, матрица <math>T</math> оказывается симметричной трёхдиагональной, во-вторых, столбцы <math>Q</math> и <math>T</math> вычисляются последовательно. Трёхдиагональность <math>T</math> приводит к следующим явлениям:<br />
# матрица <math>T_k</math> является трёхдиагональной матрицей меньшей размерности, а для трёхдиагональных матриц существуют высокоэффективные методы поиска собственных значений;<br />
# матрица <math>T_{ku}</math> имеет только один ненулевой (возможно) элемент — правый верхний, а значит, для оценки погрешности полученных собственных значений достаточно знать только этот элемент.<br />
<br />
В теории в методе Ланцоша для вычисления каждого следующего столбца <math>q_{j + 1}</math> матрицы <math>Q</math> достаточно знать только <math>q_{j - 1}</math> и <math>q_{j}</math> в силу трёхдиагональности матрицы <math>T</math>. На практике из-за ошибок округления, если не предпринимать специальных мер, набор векторов <math>q_{1}, \dots, q_{k}</math> перестаёт быть ортогональным. Для борьбы с этим явлением на каждом шаге метода Ланцоша приходится выполнять так называемую переортогонализацию — повторно запускать процесс ортогонализации Грама — Шмидта.<br />
<br />
Перейдем к описанию самого алгоритма.<br />
<br />
Исходные данные: симметричная вещественная матрица <math>A</math> — матрица, для которой будут вычисляться собственные значения, вектор <math>b</math> — начальное приближение для метода Ланцоша.<br />
<br />
Выходные данные: трёхдиагональная симметричная вещественная матрица <math>T_k = \left[ \begin{array}{cccc}<br />
\alpha_1 & \beta_1 & & \\<br />
\beta_1 & \ddots & \ddots & \\<br />
& \ddots & \ddots & \beta_{k - 1}\\<br />
& & \beta_{k - 1} & \alpha_k<br />
\end{array} \right]</math>, ортонормированный набор векторов <math>q_1, \dots, q_k</math>: <math>T_k = [q_1, \dots, q_k]^T A [q_1, \dots, q_k]</math>.<br />
<br />
Формулы метода:<br />
<br />
<math><br />
\begin{array}{l}<br />
q_1 = b / \Vert b \Vert_2\\<br />
j = \overline{1, k}:\\<br />
\quad z_j = A q_j \\<br />
\quad \alpha_j = q_j^T A q_j = q_j^T z_j \\<br />
\quad z_j' = z_j - \sum_{i=1}^j (z_j^T q_i) q_i \\<br />
\quad z_j'' = z_j' - \sum_{i=1}^j (z_j'^T q_i) q_i\\<br />
\quad \beta_j = \Vert z_j'' \Vert_2\\<br />
\quad q_{j+1} = z_j'' / \Vert z_j'' \Vert_2 = z_j''/\beta_j<br />
\end{array}<br />
</math> <br />
<br />
Собственные значения и собственные векторы матрицы <math>T_k</math> ищутся любым прямым алгоритмом.<br />
<br />
Вычисление <math>z_j', z_j''</math> — это полная переортогонализация <math>z_j</math> методом Грама — Шмидта. Двойной запуск практически гарантирует, что <math>z_j''</math> будет ортогонален <math>q_1, \dots, q_j</math>. Заметим, что <math>\sum_{i=1}^j (z^T q_i) q_i = Q_j Q_j^T z</math>, где <math>Q_j = [q_1, \dots, q_j]</math>, поэтому переортогонализацию можно переписать в виде <math>z'_j = z_j - Q_j Q_j^T z_j, z_j'' = z_j' - Q_j Q_j^T z_j'</math>.<br />
<br />
Если <math>\beta_j = 0</math> для какого-либо <math>j < k</math>, то <math>\Vert T_{ju}\Vert_2 = 0</math>, а значит, собственные значения <math>T_j</math> в точности совпадают с каким-то собственными значениями <math>A</math>. В этом случае дальнейшие вычисления прекращаются и либо используется полученная <math>T_j</math> размерности меньшей, чем <math>k</math>, либо процедура запускается заново с другим начальным вектором <math>b</math>.<br />
<br />
=== Вычислительное ядро алгоритма ===<br />
У алгоритма построения матрицы <math>T_k</math> в том виде, как он описан выше, можно выделить два ядра:<br />
# умножение матрицы <math>A</math> на вектор <math>q_j</math>: <math>z_j = A q_j</math> (<math>O(n^2)</math> умножений вещественных чисел);<br />
# переортогонализация: <math>z'_j = z_j - Q_j Q_j^T z_j,\; z_j'' = z_j' - Q_j Q_j^T z_j'</math> (<math>O(nk^2)</math> умножений вещественных чисел).<br />
<br />
<br />
=== Макроструктура алгоритма ===<br />
На макроуровне выделяем 3 основные операции:<br />
<br />
1. Умножение исходной матрицы <math>A</math> на очередной вектор базиса <math>q_p</math>.<br />
<br />
<math><br />
z=Aq_p. <br />
</math><br />
<br />
2. Повторное проведения процесса Грамма-Шмидта для ортогонализации посчитанного вектора <math>z</math> со всеми построенными ранее векторами базиса.<br />
<br />
<math><br />
z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i, </math> <br />
<br />
<math>z=z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i. </math> <br />
<br />
3.Непосредственное вычисление нового базисного вектора <math>q_{j+1}</math> и элементов <math><br />
\alpha_j<br />
</math>, <math> \beta_{j+1}<br />
</math> трехдиагональной матрицы.<br />
<br />
<math><br />
\alpha_j=q_j^Tz,<br />
</math><br />
<br />
<math>z=z-\alpha_jq_j-\beta_{j}q_{j-1}, </math><br />
<br />
<math>\beta_{j+1}=||z||,<br />
</math><br />
<br />
<math>q_{j+1}=z/\beta_{j+1}.</math><br />
<br />
=== Схема реализации последовательного алгоритма ===<br />
Последовательность исполнения метода следующая:<br />
<br />
Сначала заполняем начальные значения. <br />
<br />
<math><br />
\begin{align}<br />
& q_1=b/||b||,\\<br />
& \beta_1=0,\\<br />
&q_0=0, \\<br />
\end{align}<br />
</math><br />
<br />
где <math>b</math>-произвольный вектор.<br />
<br />
Далее выполняется основная процедура, которая строит ортонормированный базис подпространства Крылова для симметричной матрицы и трехдиагональную матрицу размерности <math>k</math>.<br />
<br />
Для всех <math>j</math> от <math>1</math> до <math>k</math> по нарастанию выполняются<br />
<br />
<math><br />
1.z=Aq_j, <br />
</math><br />
<br />
Вычисляем элемент, который будет находится на позиции <math>t_{j,j}</math> конечной матрицы <math>T_k</math>,<br />
<br />
<math><br />
2.\alpha_j=q_j^Tz,<br />
</math><br />
<br />
Чтобы гарантировать ортогональность базиса на каждой итерации цикла два раза проводим полную переортогонализацию, использую процесс Грамма-Шмидта,<br />
<br />
<math><br />
3.z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i, </math> <br />
<br />
<math>4.z=z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i, </math> <br />
<br />
После ортогонализации процедура продолжается следующим образом. <br />
<br />
<math>5.z=z-\alpha_jq_j-\beta_{j}q_{j-1}, </math><br />
<br />
Вычисляем элемент, который будет находится на позиции <math>t_{j,j+1}</math> и <math>t_{j+1,j}</math>,<br />
<br />
<math>6.\beta_{j+1}=||z||,<br />
</math><br />
<br />
Если <math>\beta_{j+1}=0</math>, то алгоритм завершается.<br />
<br />
<math>7.q_{j+1}=z/\beta_{j+1}.</math><br />
<br />
В конце каждой итерации получаем очередной вектор <math>q_{j+1}</math> базиса с единичной нормой, который ортогонален всем предыдущим векторам базиса,<br />
<br />
и элементы <math>\alpha_j</math>, <math>\beta_{j+1}</math> трехдиагональной матрицы размерности <math>k</math> .<br />
<br />
<br />
=== Последовательная сложность алгоритма ===<br />
На <math>j</math>-ой итерации алгоритм выполняет<br />
* <math>n^2 + n + 4nj + n + n = n^2 + 3n + 4nj</math> умножений и делений;<br />
* <math>n(n - 1) + (n - 1) + (4n - 2)j + (n - 1) = n^2 + (n - 2) + (4n - 2)j</math> сложений и вычитаний;<br />
* одно извлечение квадратного корня.<br />
<br />
Всего за <math>k</math> итераций алгоритм выполняет<br />
* <math>(n + 3)nk + 2nk(k + 1)</math> умножений и делений;<br />
* <math>(n^2 + n - 2)k + (2n - 1)k(k + 1)</math> сложений и вычитаний.<br />
<br />
Таким образом, алгоритм имеет последовательную сложность <math>O(n^2k + nk^2)</math>.<br />
<br />
=== Информационный граф===<br />
<br />
Представим информационные графы разных уровней алгоритма.<br />
<br />
====Информационный граф на уровне макроопераций с входными и выходными данными===<br />
<br />
[[Файл:Lanczoc-full-orth-macro.png|thumb|1000px|center|alt=Информационный граф алгоритма Ланцоша на уровне отдельных итераций|Рисунок 1. Информационный граф алгоритма Ланцоша на уровне итераций с входными и выходными данными. In — входные данные (матрица <math>A</math> и вектор <math>b</math>), Out — выходные данные (<math>\alpha_j, \beta_j</math> и <math>q_j</math>), nrm — вычисление еклидовой нормы вектора, / — деление вектора на число, Iter — итерации алгоритма.]]<br />
<br />
<br />
====Информационный граф на уровне одной итерации с входными и выходными данными====<br />
<br />
<br />
[[Файл:Lanczoc-full-orth-iter.png|thumb|1000px|center|alt=Информационный граф алгоритма Ланцоша на уровне отдельных итераций|Рисунок 2. Информационный граф итерации алгоритма Ланцоша на уровне макроопераций. In — входные данные (матрица <math>A</math>), Out — выходные данные (<math>\alpha_j, \beta_j</math> и <math>q_j</math>), dprod — скалярное произведение векторов, mprod — произведение матрицы на вектор, - — разность векторов, nrm — вычисление еклидовой нормы вектора, / — деление вектора на число.]]<br />
<br />
<br />
====Общий информационный граф===<br />
[[Файл:photo.jpg]]Здесь показаны первые три итерации алгоритма, при больших итерациях граф строится аналогичным образом.<br />
* Вершина черного цвета соответствует операции <math>Aq_j,</math>.<br />
* Вершина красного цвета соответствует операции скалярного произведения <math>q_j^Tz</math>.<br />
* Вершина сиреневого цвета соответствует операции <math>z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i</math>.<br />
* Вершина желтого цвета соответствует операции <math>z-\alpha_jq_j-\beta_{j-1}q_{j-1}</math>.<br />
* Вершина синего цвета соответствует операции <math>||z||</math>.<br />
* Вершина зеленого цвета соответствует операции <math>z/\beta_j</math>.</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9B%D0%B0%D0%BD%D1%86%D0%BE%D1%88%D0%B0_%D0%B4%D0%BB%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B8_%D1%81_%D0%BF%D0%BB%D0%B0%D0%B2%D0%B0%D1%8E%D1%89%D0%B5%D0%B9_%D1%82%D0%BE%D1%87%D0%BA%D0%BE%D0%B9_%D1%81_%D0%BF%D0%BE%D0%BB%D0%BD%D0%BE%D0%B9_%D0%BF%D0%B5%D1%80%D0%B5%D0%BE%D1%80%D1%82%D0%BE%D0%B3%D0%BE%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D0%B5%D0%B9&diff=22584Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией2017-05-03T13:06:22Z<p>Chernyavskiy: /* Свойства и структура алгоритма */</p>
<hr />
<div>Основные авторы описания: [[Участник:Sagak|С.А.Айвазян]], [[Участник:Kozlov_Vladimir|В.Козлов]] (Часть 1), [[Участник:Chernyavskiy|А.Ю.Чернявский]] (компоновка и редактирование), [[Участник:ASA|А.С.Антонов]] (предварительная проверка).<br />
<br />
<br />
<br />
== Свойства и структура алгоритма ==<br />
===Общее описание алгоритма===<br />
Алгоритм Ланцоша – итерационный метод , созданный Корнелиусом Ланцошем, для нахождения собственных значений и собственных векторов симметричной матрицы. Суть алгоритма в том, что он сводит частичную проблему собственных значений симметричной вещественной матрицы к полной проблеме собственных значений для симметричной трехдиагональной матрицы меньшей размерности. Алгоритм применяется к матрицам большой размерности, к которым не применимы никакие прямые методы. <br />
<br />
Алгоритм Ланцоша относится к методам аппроксимаций, которые применяют широко распространенную в математике процедуру Релея-Ритца к матричным вычислениям, посредством чего сводят исходную задачу к задаче гораздо меньшего размера, решив которую, получаем приближенные собственные значения и собственные векторы исходной задачи. Метод основан на применении процедуры Релея-Ритца к последовательности вложенных подпространств Крылова.<br />
Важной особенностью подпространства Крылова является трехдиагонольность ортогональной проекции на него исходной матрицы, что способствует тому, что процедура <br />
Релея-Ритца прорабатывает очень эффективно. Главными особенностями поведения алгоритмов метода Ланцоша являются потеря ортогональности векторов базиса и быстрая сходимость в области наибольших по значению собственных значений. Наиболее популярными средствами борьбы с потерей ортогональности векторов Ланцоша являются различные варианты переортогонализации: частичная, полная и выборочная.<br />
<br />
Симметричность исходной матрицы позволяет хранить и вычислять чуть больше половины её элементов, что почти вдвое экономит как необходимые для вычислений объёмы памяти, так и количество операций. Также алгоритм позволяет использовать так называемый режим накопления, обусловленный тем, что значительную часть вычислений составляют вычисления скалярных произведений.<br />
<br />
Преимущество алгоритма заключается в том, что он дает приближение за конечное число шагов. Метод Ланцоша выигрывает в конкуренции таким прямым методам, как метод прямых или обратных итераций, <math>QR</math> и <math>QL</math> преобразования, методы вращений (вращения Якоби), которые потеряли значение как самостоятельные методы поиска собственных<br />
значений матриц большого размера. Также нужно заметить, что метод Ланцоша практически всегда эффективнее других методов аппроксимаций.<br />
<br />
<br />
=== Математическое описание алгоритма ===<br />
<br />
<br />
'''Алгоритм Ланцоша''' — это итерационный алгоритм поиска <math>k</math> приближённых собственных значений симметричной вещественной матрицы <math>A</math> размера <math>n \times n</math>. Алгоритм применяется, когда матрица <math>A</math> слишком велика, чтобы к ней можно было применять точные прямые методы вычисления собственных значений. Алгоритм комбинирует '''метод Рэлея — Ритца''' поиска приближённых собственных значений и '''метод Ланцоша''' построения крыловского подпространства.<br />
<br />
Метод Рэлея — Ритца является методом поиска <math>k</math> приближённых собственных значений симметричной вещественной матрицы <math>A</math> размера <math>n \times n</math>. Если <math>Q = [Q_k, Q_u]</math> — ортонормированная матрица размера <math>n \times n</math>, <math>Q_k</math> имеет размер <math>n \times k</math>, <math>Q_u</math> имеет размер <math>n \times n - k</math>, то можно записать равенство<br />
<br />
<math>T = Q^T A Q = [Q_k, Q_u]^T A [Q_k, Q_u] = <br />
\left[ \begin{array}{cc}<br />
Q_k^T A Q_k & Q_k^T A Q_u\\<br />
Q_u^T A Q_k & Q_u^T A Q_u<br />
\end{array} \right]<br />
= \left[ \begin{array}{cc}<br />
T_{k} & T_{ku}^T\\<br />
T_{ku} & T_{u}<br />
\end{array} \right].</math><br />
<br />
Метод Рэлея — Ритца заключается в том, что собственные значения матрицы <math>T_k = Q_k^T A Q_k</math> объявляются приближёнными собственными значениями матрицы <math>A</math>. Такое приближение является в некотором смысле «наилучшим»: можно показать, что если <math>T_k = V \Lambda V^{-1}</math> — спектральное разложение <math>T_k</math>, то пара <math>(Q_k V, \Lambda)</math> минимизирует функционал <math>L(P_k, D) = \Vert A P_k - P_k D \Vert_2</math>, причём <math>L(Q_k V, \Lambda) = \Vert T_{ku} \Vert_2</math>, то есть <math>A \approx (Q_k V) \Lambda (Q_k V)^{-1}</math>. Из этого также видно, что метод Рэлея — Ритца позволяет получать приближения для собственных векторов матрицы <math>A</math>. Более того, можно показать, что собственные значения <math>T</math> отличаются от некоторых собственных значений <math>A</math> не более чем на <math>\Vert T_{ku} \Vert_2</math>. <br />
<br />
Метод Ланцоша — это метод построения матрицы <math>Q</math>, при использовании которого, во-первых, матрица <math>T</math> оказывается симметричной трёхдиагональной, во-вторых, столбцы <math>Q</math> и <math>T</math> вычисляются последовательно. Трёхдиагональность <math>T</math> приводит к следующим явлениям:<br />
# матрица <math>T_k</math> является трёхдиагональной матрицей меньшей размерности, а для трёхдиагональных матриц существуют высокоэффективные методы поиска собственных значений;<br />
# матрица <math>T_{ku}</math> имеет только один ненулевой (возможно) элемент — правый верхний, а значит, для оценки погрешности полученных собственных значений достаточно знать только этот элемент.<br />
<br />
В теории в методе Ланцоша для вычисления каждого следующего столбца <math>q_{j + 1}</math> матрицы <math>Q</math> достаточно знать только <math>q_{j - 1}</math> и <math>q_{j}</math> в силу трёхдиагональности матрицы <math>T</math>. На практике из-за ошибок округления, если не предпринимать специальных мер, набор векторов <math>q_{1}, \dots, q_{k}</math> перестаёт быть ортогональным. Для борьбы с этим явлением на каждом шаге метода Ланцоша приходится выполнять так называемую переортогонализацию — повторно запускать процесс ортогонализации Грама — Шмидта.<br />
<br />
Перейдем к описанию самого алгоритма.<br />
<br />
Исходные данные: симметричная вещественная матрица <math>A</math> — матрица, для которой будут вычисляться собственные значения, вектор <math>b</math> — начальное приближение для метода Ланцоша.<br />
<br />
Выходные данные: трёхдиагональная симметричная вещественная матрица <math>T_k = \left[ \begin{array}{cccc}<br />
\alpha_1 & \beta_1 & & \\<br />
\beta_1 & \ddots & \ddots & \\<br />
& \ddots & \ddots & \beta_{k - 1}\\<br />
& & \beta_{k - 1} & \alpha_k<br />
\end{array} \right]</math>, ортонормированный набор векторов <math>q_1, \dots, q_k</math>: <math>T_k = [q_1, \dots, q_k]^T A [q_1, \dots, q_k]</math>.<br />
<br />
Формулы метода:<br />
<br />
<math><br />
\begin{array}{l}<br />
q_1 = b / \Vert b \Vert_2\\<br />
j = \overline{1, k}:\\<br />
\quad z_j = A q_j \\<br />
\quad \alpha_j = q_j^T A q_j = q_j^T z_j \\<br />
\quad z_j' = z_j - \sum_{i=1}^j (z_j^T q_i) q_i \\<br />
\quad z_j'' = z_j' - \sum_{i=1}^j (z_j'^T q_i) q_i\\<br />
\quad \beta_j = \Vert z_j'' \Vert_2\\<br />
\quad q_{j+1} = z_j'' / \Vert z_j'' \Vert_2 = z_j''/\beta_j<br />
\end{array}<br />
</math> <br />
<br />
Собственные значения и собственные векторы матрицы <math>T_k</math> ищутся любым прямым алгоритмом.<br />
<br />
Вычисление <math>z_j', z_j''</math> — это полная переортогонализация <math>z_j</math> методом Грама — Шмидта. Двойной запуск практически гарантирует, что <math>z_j''</math> будет ортогонален <math>q_1, \dots, q_j</math>. Заметим, что <math>\sum_{i=1}^j (z^T q_i) q_i = Q_j Q_j^T z</math>, где <math>Q_j = [q_1, \dots, q_j]</math>, поэтому переортогонализацию можно переписать в виде <math>z'_j = z_j - Q_j Q_j^T z_j, z_j'' = z_j' - Q_j Q_j^T z_j'</math>.<br />
<br />
Если <math>\beta_j = 0</math> для какого-либо <math>j < k</math>, то <math>\Vert T_{ju}\Vert_2 = 0</math>, а значит, собственные значения <math>T_j</math> в точности совпадают с каким-то собственными значениями <math>A</math>. В этом случае дальнейшие вычисления прекращаются и либо используется полученная <math>T_j</math> размерности меньшей, чем <math>k</math>, либо процедура запускается заново с другим начальным вектором <math>b</math>.<br />
<br />
=== Вычислительное ядро алгоритма ===<br />
У алгоритма построения матрицы <math>T_k</math> в том виде, как он описан выше, можно выделить два ядра:<br />
# умножение матрицы <math>A</math> на вектор <math>q_j</math>: <math>z_j = A q_j</math> (<math>O(n^2)</math> умножений вещественных чисел);<br />
# переортогонализация: <math>z'_j = z_j - Q_j Q_j^T z_j,\; z_j'' = z_j' - Q_j Q_j^T z_j'</math> (<math>O(nk^2)</math> умножений вещественных чисел).<br />
<br />
<br />
=== Макроструктура алгоритма ===<br />
На макроуровне выделяем 3 основные операции:<br />
<br />
1. Умножение исходной матрицы <math>A</math> на очередной вектор базиса <math>q_p</math>.<br />
<br />
<math><br />
z=Aq_p. <br />
</math><br />
<br />
2. Повторное проведения процесса Грамма-Шмидта для ортогонализации посчитанного вектора <math>z</math> со всеми построенными ранее векторами базиса.<br />
<br />
<math><br />
z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i, </math> <br />
<br />
<math>z=z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i. </math> <br />
<br />
3.Непосредственное вычисление нового базисного вектора <math>q_{j+1}</math> и элементов <math><br />
\alpha_j<br />
</math>, <math> \beta_{j+1}<br />
</math> трехдиагональной матрицы.<br />
<br />
<math><br />
\alpha_j=q_j^Tz,<br />
</math><br />
<br />
<math>z=z-\alpha_jq_j-\beta_{j}q_{j-1}, </math><br />
<br />
<math>\beta_{j+1}=||z||,<br />
</math><br />
<br />
<math>q_{j+1}=z/\beta_{j+1}.</math><br />
<br />
=== Схема реализации последовательного алгоритма ===<br />
Последовательность исполнения метода следующая:<br />
<br />
Сначала заполняем начальные значения. <br />
<br />
<math><br />
\begin{align}<br />
& q_1=b/||b||,\\<br />
& \beta_1=0,\\<br />
&q_0=0, \\<br />
\end{align}<br />
</math><br />
<br />
где <math>b</math>-произвольный вектор.<br />
<br />
Далее выполняется основная процедура, которая строит ортонормированный базис подпространства Крылова для симметричной матрицы и трехдиагональную матрицу размерности <math>k</math>.<br />
<br />
Для всех <math>j</math> от <math>1</math> до <math>k</math> по нарастанию выполняются<br />
<br />
<math><br />
1.z=Aq_j, <br />
</math><br />
<br />
Вычисляем элемент, который будет находится на позиции <math>t_{j,j}</math> конечной матрицы <math>T_k</math>,<br />
<br />
<math><br />
2.\alpha_j=q_j^Tz,<br />
</math><br />
<br />
Чтобы гарантировать ортогональность базиса на каждой итерации цикла два раза проводим полную переортогонализацию, использую процесс Грамма-Шмидта,<br />
<br />
<math><br />
3.z =z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i, </math> <br />
<br />
<math>4.z=z-\sum\nolimits_{i=1}^{j-1}(z^Tq_i)q_i, </math> <br />
<br />
После ортогонализации процедура продолжается следующим образом. <br />
<br />
<math>5.z=z-\alpha_jq_j-\beta_{j}q_{j-1}, </math><br />
<br />
Вычисляем элемент, который будет находится на позиции <math>t_{j,j+1}</math> и <math>t_{j+1,j}</math>,<br />
<br />
<math>6.\beta_{j+1}=||z||,<br />
</math><br />
<br />
Если <math>\beta_{j+1}=0</math>, то алгоритм завершается.<br />
<br />
<math>7.q_{j+1}=z/\beta_{j+1}.</math><br />
<br />
В конце каждой итерации получаем очередной вектор <math>q_{j+1}</math> базиса с единичной нормой, который ортогонален всем предыдущим векторам базиса,<br />
<br />
и элементы <math>\alpha_j</math>, <math>\beta_{j+1}</math> трехдиагональной матрицы размерности <math>k</math> .<br />
<br />
<br />
=== Последовательная сложность алгоритма ===<br />
На <math>j</math>-ой итерации алгоритм выполняет<br />
* <math>n^2 + n + 4nj + n + n = n^2 + 3n + 4nj</math> умножений и делений;<br />
* <math>n(n - 1) + (n - 1) + (4n - 2)j + (n - 1) = n^2 + (n - 2) + (4n - 2)j</math> сложений и вычитаний;<br />
* одно извлечение квадратного корня.<br />
<br />
Всего за <math>k</math> итераций алгоритм выполняет<br />
* <math>(n + 3)nk + 2nk(k + 1)</math> умножений и делений;<br />
* <math>(n^2 + n - 2)k + (2n - 1)k(k + 1)</math> сложений и вычитаний.<br />
<br />
Таким образом, алгоритм имеет последовательную сложность <math>O(n^2k + nk^2)</math>.</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9B%D0%B0%D0%BD%D1%86%D0%BE%D1%88%D0%B0_%D0%B4%D0%BB%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B8_%D1%81_%D0%BF%D0%BB%D0%B0%D0%B2%D0%B0%D1%8E%D1%89%D0%B5%D0%B9_%D1%82%D0%BE%D1%87%D0%BA%D0%BE%D0%B9_%D1%81_%D0%BF%D0%BE%D0%BB%D0%BD%D0%BE%D0%B9_%D0%BF%D0%B5%D1%80%D0%B5%D0%BE%D1%80%D1%82%D0%BE%D0%B3%D0%BE%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D0%B5%D0%B9&diff=22583Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией2017-05-03T13:02:13Z<p>Chernyavskiy: /* Свойства и структура алгоритма */</p>
<hr />
<div>Основные авторы описания: [[Участник:Sagak|С.А.Айвазян]], [[Участник:Kozlov_Vladimir|В.Козлов]] (Часть 1), [[Участник:Chernyavskiy|А.Ю.Чернявский]] (компоновка и редактирование), [[Участник:ASA|А.С.Антонов]] (предварительная проверка).<br />
<br />
<br />
<br />
== Свойства и структура алгоритма ==<br />
===Общее описание алгоритма===<br />
Алгоритм Ланцоша – итерационный метод , созданный Корнелиусом Ланцошем, для нахождения собственных значений и собственных векторов симметричной матрицы. Суть алгоритма в том, что он сводит частичную проблему собственных значений симметричной вещественной матрицы к полной проблеме собственных значений для симметричной трехдиагональной матрицы меньшей размерности. Алгоритм применяется к матрицам большой размерности, к которым не применимы никакие прямые методы. <br />
<br />
Алгоритм Ланцоша относится к методам аппроксимаций, которые применяют широко распространенную в математике процедуру Релея-Ритца к матричным вычислениям, посредством чего сводят исходную задачу к задаче гораздо меньшего размера, решив которую, получаем приближенные собственные значения и собственные векторы исходной задачи. Метод основан на применении процедуры Релея-Ритца к последовательности вложенных подпространств Крылова.<br />
Важной особенностью подпространства Крылова является трехдиагонольность ортогональной проекции на него исходной матрицы, что способствует тому, что процедура <br />
Релея-Ритца прорабатывает очень эффективно. Главными особенностями поведения алгоритмов метода Ланцоша являются потеря ортогональности векторов базиса и быстрая сходимость в области наибольших по значению собственных значений. Наиболее популярными средствами борьбы с потерей ортогональности векторов Ланцоша являются различные варианты переортогонализации: частичная, полная и выборочная.<br />
<br />
Симметричность исходной матрицы позволяет хранить и вычислять чуть больше половины её элементов, что почти вдвое экономит как необходимые для вычислений объёмы памяти, так и количество операций. Также алгоритм позволяет использовать так называемый режим накопления, обусловленный тем, что значительную часть вычислений составляют вычисления скалярных произведений.<br />
<br />
Преимущество алгоритма заключается в том, что он дает приближение за конечное число шагов. Метод Ланцоша выигрывает в конкуренции таким прямым методам, как метод прямых или обратных итераций, <math>QR</math> и <math>QL</math> преобразования, методы вращений (вращения Якоби), которые потеряли значение как самостоятельные методы поиска собственных<br />
значений матриц большого размера. Также нужно заметить, что метод Ланцоша практически всегда эффективнее других методов аппроксимаций.<br />
<br />
<br />
=== Математическое описание алгоритма ===<br />
<br />
<br />
'''Алгоритм Ланцоша''' — это итерационный алгоритм поиска <math>k</math> приближённых собственных значений симметричной вещественной матрицы <math>A</math> размера <math>n \times n</math>. Алгоритм применяется, когда матрица <math>A</math> слишком велика, чтобы к ней можно было применять точные прямые методы вычисления собственных значений. Алгоритм комбинирует '''метод Рэлея — Ритца''' поиска приближённых собственных значений и '''метод Ланцоша''' построения крыловского подпространства.<br />
<br />
Метод Рэлея — Ритца является методом поиска <math>k</math> приближённых собственных значений симметричной вещественной матрицы <math>A</math> размера <math>n \times n</math>. Если <math>Q = [Q_k, Q_u]</math> — ортонормированная матрица размера <math>n \times n</math>, <math>Q_k</math> имеет размер <math>n \times k</math>, <math>Q_u</math> имеет размер <math>n \times n - k</math>, то можно записать равенство<br />
<br />
<math>T = Q^T A Q = [Q_k, Q_u]^T A [Q_k, Q_u] = <br />
\left[ \begin{array}{cc}<br />
Q_k^T A Q_k & Q_k^T A Q_u\\<br />
Q_u^T A Q_k & Q_u^T A Q_u<br />
\end{array} \right]<br />
= \left[ \begin{array}{cc}<br />
T_{k} & T_{ku}^T\\<br />
T_{ku} & T_{u}<br />
\end{array} \right].</math><br />
<br />
Метод Рэлея — Ритца заключается в том, что собственные значения матрицы <math>T_k = Q_k^T A Q_k</math> объявляются приближёнными собственными значениями матрицы <math>A</math>. Такое приближение является в некотором смысле «наилучшим»: можно показать, что если <math>T_k = V \Lambda V^{-1}</math> — спектральное разложение <math>T_k</math>, то пара <math>(Q_k V, \Lambda)</math> минимизирует функционал <math>L(P_k, D) = \Vert A P_k - P_k D \Vert_2</math>, причём <math>L(Q_k V, \Lambda) = \Vert T_{ku} \Vert_2</math>, то есть <math>A \approx (Q_k V) \Lambda (Q_k V)^{-1}</math>. Из этого также видно, что метод Рэлея — Ритца позволяет получать приближения для собственных векторов матрицы <math>A</math>. Более того, можно показать, что собственные значения <math>T</math> отличаются от некоторых собственных значений <math>A</math> не более чем на <math>\Vert T_{ku} \Vert_2</math>. <br />
<br />
Метод Ланцоша — это метод построения матрицы <math>Q</math>, при использовании которого, во-первых, матрица <math>T</math> оказывается симметричной трёхдиагональной, во-вторых, столбцы <math>Q</math> и <math>T</math> вычисляются последовательно. Трёхдиагональность <math>T</math> приводит к следующим явлениям:<br />
# матрица <math>T_k</math> является трёхдиагональной матрицей меньшей размерности, а для трёхдиагональных матриц существуют высокоэффективные методы поиска собственных значений;<br />
# матрица <math>T_{ku}</math> имеет только один ненулевой (возможно) элемент — правый верхний, а значит, для оценки погрешности полученных собственных значений достаточно знать только этот элемент.<br />
<br />
В теории в методе Ланцоша для вычисления каждого следующего столбца <math>q_{j + 1}</math> матрицы <math>Q</math> достаточно знать только <math>q_{j - 1}</math> и <math>q_{j}</math> в силу трёхдиагональности матрицы <math>T</math>. На практике из-за ошибок округления, если не предпринимать специальных мер, набор векторов <math>q_{1}, \dots, q_{k}</math> перестаёт быть ортогональным. Для борьбы с этим явлением на каждом шаге метода Ланцоша приходится выполнять так называемую переортогонализацию — повторно запускать процесс ортогонализации Грама — Шмидта.<br />
<br />
Перейдем к описанию самого алгоритма.<br />
<br />
Исходные данные: симметричная вещественная матрица <math>A</math> — матрица, для которой будут вычисляться собственные значения, вектор <math>b</math> — начальное приближение для метода Ланцоша.<br />
<br />
Выходные данные: трёхдиагональная симметричная вещественная матрица <math>T_k = \left[ \begin{array}{cccc}<br />
\alpha_1 & \beta_1 & & \\<br />
\beta_1 & \ddots & \ddots & \\<br />
& \ddots & \ddots & \beta_{k - 1}\\<br />
& & \beta_{k - 1} & \alpha_k<br />
\end{array} \right]</math>, ортонормированный набор векторов <math>q_1, \dots, q_k</math>: <math>T_k = [q_1, \dots, q_k]^T A [q_1, \dots, q_k]</math>.<br />
<br />
Формулы метода:<br />
<br />
<math><br />
\begin{array}{l}<br />
q_1 = b / \Vert b \Vert_2\\<br />
j = \overline{1, k}:\\<br />
\quad z_j = A q_j \\<br />
\quad \alpha_j = q_j^T A q_j = q_j^T z_j \\<br />
\quad z_j' = z_j - \sum_{i=1}^j (z_j^T q_i) q_i \\<br />
\quad z_j'' = z_j' - \sum_{i=1}^j (z_j'^T q_i) q_i\\<br />
\quad \beta_j = \Vert z_j'' \Vert_2\\<br />
\quad q_{j+1} = z_j'' / \Vert z_j'' \Vert_2 = z_j''/\beta_j<br />
\end{array}<br />
</math> <br />
<br />
Собственные значения и собственные векторы матрицы <math>T_k</math> ищутся любым прямым алгоритмом.<br />
<br />
Вычисление <math>z_j', z_j''</math> — это полная переортогонализация <math>z_j</math> методом Грама — Шмидта. Двойной запуск практически гарантирует, что <math>z_j''</math> будет ортогонален <math>q_1, \dots, q_j</math>. Заметим, что <math>\sum_{i=1}^j (z^T q_i) q_i = Q_j Q_j^T z</math>, где <math>Q_j = [q_1, \dots, q_j]</math>, поэтому переортогонализацию можно переписать в виде <math>z'_j = z_j - Q_j Q_j^T z_j, z_j'' = z_j' - Q_j Q_j^T z_j'</math>.<br />
<br />
Если <math>\beta_j = 0</math> для какого-либо <math>j < k</math>, то <math>\Vert T_{ju}\Vert_2 = 0</math>, а значит, собственные значения <math>T_j</math> в точности совпадают с каким-то собственными значениями <math>A</math>. В этом случае дальнейшие вычисления прекращаются и либо используется полученная <math>T_j</math> размерности меньшей, чем <math>k</math>, либо процедура запускается заново с другим начальным вектором <math>b</math>.<br />
<br />
=== Вычислительное ядро алгоритма ===<br />
У алгоритма построения матрицы <math>T_k</math> в том виде, как он описан выше, можно выделить два ядра:<br />
# умножение матрицы <math>A</math> на вектор <math>q_j</math>: <math>z_j = A q_j</math> (<math>O(n^2)</math> умножений вещественных чисел);<br />
# переортогонализация: <math>z'_j = z_j - Q_j Q_j^T z_j,\; z_j'' = z_j' - Q_j Q_j^T z_j'</math> (<math>O(nk^2)</math> умножений вещественных чисел).</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9B%D0%B0%D0%BD%D1%86%D0%BE%D1%88%D0%B0_%D0%B4%D0%BB%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B8_%D1%81_%D0%BF%D0%BB%D0%B0%D0%B2%D0%B0%D1%8E%D1%89%D0%B5%D0%B9_%D1%82%D0%BE%D1%87%D0%BA%D0%BE%D0%B9_%D1%81_%D0%BF%D0%BE%D0%BB%D0%BD%D0%BE%D0%B9_%D0%BF%D0%B5%D1%80%D0%B5%D0%BE%D1%80%D1%82%D0%BE%D0%B3%D0%BE%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D0%B5%D0%B9&diff=22582Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией2017-05-03T12:59:59Z<p>Chernyavskiy: </p>
<hr />
<div>Основные авторы описания: [[Участник:Sagak|С.А.Айвазян]], [[Участник:Kozlov_Vladimir|В.Козлов]] (Часть 1), [[Участник:Chernyavskiy|А.Ю.Чернявский]] (компоновка и редактирование), [[Участник:ASA|А.С.Антонов]] (предварительная проверка).<br />
<br />
<br />
<br />
== Свойства и структура алгоритма ==<br />
===Общее описание алгоритма===<br />
Алгоритм Ланцоша – итерационный метод , созданный Корнелиусом Ланцошем, для нахождения собственных значений и собственных векторов симметричной матрицы. Суть алгоритма в том, что он сводит частичную проблему собственных значений симметричной вещественной матрицы к полной проблеме собственных значений для симметричной трехдиагональной матрицы меньшей размерности. Алгоритм применяется к матрицам большой размерности, к которым не применимы никакие прямые методы. <br />
<br />
Алгоритм Ланцоша относится к методам аппроксимаций, которые применяют широко распространенную в математике процедуру Релея-Ритца к матричным вычислениям, посредством чего сводят исходную задачу к задаче гораздо меньшего размера, решив которую, получаем приближенные собственные значения и собственные векторы исходной задачи. Метод основан на применении процедуры Релея-Ритца к последовательности вложенных подпространств Крылова.<br />
Важной особенностью подпространства Крылова является трехдиагонольность ортогональной проекции на него исходной матрицы, что способствует тому, что процедура <br />
Релея-Ритца прорабатывает очень эффективно. Главными особенностями поведения алгоритмов метода Ланцоша являются потеря ортогональности векторов базиса и быстрая сходимость в области наибольших по значению собственных значений. Наиболее популярными средствами борьбы с потерей ортогональности векторов Ланцоша являются различные варианты переортогонализации: частичная, полная и выборочная.<br />
<br />
Симметричность исходной матрицы позволяет хранить и вычислять чуть больше половины её элементов, что почти вдвое экономит как необходимые для вычислений объёмы памяти, так и количество операций. Также алгоритм позволяет использовать так называемый режим накопления, обусловленный тем, что значительную часть вычислений составляют вычисления скалярных произведений.<br />
<br />
Преимущество алгоритма заключается в том, что он дает приближение за конечное число шагов. Метод Ланцоша выигрывает в конкуренции таким прямым методам, как метод прямых или обратных итераций, <math>QR</math> и <math>QL</math> преобразования, методы вращений (вращения Якоби), которые потеряли значение как самостоятельные методы поиска собственных<br />
значений матриц большого размера. Также нужно заметить, что метод Ланцоша практически всегда эффективнее других методов аппроксимаций.</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9B%D0%B0%D0%BD%D1%86%D0%BE%D1%88%D0%B0_%D0%B4%D0%BB%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B8_%D1%81_%D0%BF%D0%BB%D0%B0%D0%B2%D0%B0%D1%8E%D1%89%D0%B5%D0%B9_%D1%82%D0%BE%D1%87%D0%BA%D0%BE%D0%B9_%D1%81_%D0%BF%D0%BE%D0%BB%D0%BD%D0%BE%D0%B9_%D0%BF%D0%B5%D1%80%D0%B5%D0%BE%D1%80%D1%82%D0%BE%D0%B3%D0%BE%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D0%B5%D0%B9&diff=22581Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией2017-05-03T12:47:47Z<p>Chernyavskiy: Новая страница: «Основные авторы описания: С.А.Айвазян, В.Козлов (Часть…»</p>
<hr />
<div>Основные авторы описания: [[Участник:Sagak|С.А.Айвазян]], [[Участник:Kozlov_Vladimir|В.Козлов]] (Часть 1), [[Участник:Chernyavskiy|А.Ю.Чернявский]] (компоновка и редактирование), [[Участник:ASA|А.С.Антонов]] (предварительная проверка).</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%C2%AB%D1%80%D0%B0%D0%B7%D0%B4%D0%B5%D0%BB%D1%8F%D0%B9_%D0%B8_%D0%B2%D0%BB%D0%B0%D1%81%D1%82%D0%B2%D1%83%D0%B9%C2%BB_%D0%B2%D1%8B%D1%87%D0%B8%D1%81%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F_%D1%81%D0%BE%D0%B1%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D1%8B%D1%85_%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B9_%D0%B8_%D0%B2%D0%B5%D0%BA%D1%82%D0%BE%D1%80%D0%BE%D0%B2_%D1%81%D0%B8%D0%BC%D0%BC%D0%B5%D1%82%D1%80%D0%B8%D1%87%D0%BD%D0%BE%D0%B9_%D1%82%D1%80%D0%B5%D1%85%D0%B4%D0%B8%D0%B0%D0%B3%D0%BE%D0%BD%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B9_%D0%BC%D0%B0%D1%82%D1%80%D0%B8%D1%86%D1%8B&diff=22580Метод «разделяй и властвуй» вычисления собственных значений и векторов симметричной трехдиагональной матрицы2017-04-29T20:44:24Z<p>Chernyavskiy: </p>
<hr />
<div>Основные авторы описания: [[Участник:Роман_Землянский|Р.Землянский]] (Разделы <br />
[[#Общее описание алгоритма|1.1]], [[#Математическое описание алгоритма|1.2]], [[#Последовательная сложность алгоритма|1.6]], [[#Ресурс параллелизма алгоритма|1.8]], [[#Входные и выходные данные алгоритма|1.9]], [[#Свойства алгоритма|1.10]]), В.Завольсков (Разделы [[#Вычислительное ядро алгоритма|1.3]], [[#Макроструктура алгоритма|1.4]], [[#Схема реализации последовательного алгоритма|1.5]], [[#Информационный граф|1.7]], [[#Существующие реализации алгоритма|2.7]]), [[Участник:IgorS]] (предварительная проверка), [[Участник:Chernyavskiy|А.Ю. Чернявский]] (проверка, редактирование).<br />
<br />
<br />
{{algorithm<br />
| name = Метод "Разделяй и властвуй" вычисления собственных значений и векторов трёхдиагональной матрицы<br />
| serial_complexity = <math> c\frac{4}{3}n^{3} </math><br />
| parallel_complexity = <math> O(n^{2.3}) </math><br />
<br />
крайне редко: <math> O(n^{2}) </math> <br />
| pf_width = <br />
| input_data = <math> 2n + 1 </math><br />
| output_data = <math> n(n + 1) </math><br />
}}<br />
<br />
<br />
= Свойства и структура алгоритмов =<br />
== Общее описание алгоритма ==<br />
'''Метод разделяй и властвуй вычисления собственных значений и векторов трёхдиагональной матрицы''' - это наиболее быстрый из существующих методов, если нужны все собственные значения и собственные векторы трехдиагональной матрицы, начиная с порядка n, примерно равного 26. (Точное значение этого порогового порядка зависит от компьютера.) Его численно устойчивая реализация весьма не тривиальна. В самом деле, хотя впервые метод был предложен еще в 1981 г., "правильный" способ его реализации был найден лишь в 1992 г. Этот способ воплощен LAPACK-программами ssyevd (для плотных матриц) и sstevd (для трехдиагональных матриц). В них стратегия "разделяй-и-влавствуй" используется для матриц порядка, большего чем 25. Для матриц меньшего порядка (или если нужны только собственные значения) происходит автоматический переход к QR-итерации.<br />
<br />
== Математическое описание алгоритма ==<br />
Пусть <br />
<br />
:<math><br />
T = \begin{bmatrix}<br />
a_{1} & b_{1}&&&&& \\<br />
b_{1} & \ddots & \ddots \\<br />
& \ddots & a_{m-1} & b_{m-1} \\<br />
&& b_{m-1} & a_{m} & b_{m} \\<br />
&&& b_{m} & a_{m+1} & b_{m+1} \\<br />
&&&& b_{m+1} & \ddots \\<br />
&&&&&& \ddots & b_{n-1} \\<br />
&&&&&& b_{n-1} & a_{n} \\<br />
\end{bmatrix}<br />
= \begin{bmatrix}<br />
a_{1} & b_{1} &&&&& \\<br />
b_{1} & \ddots & \ddots \\<br />
& \ddots & a_{m-1} & b_{m-1} \\<br />
&& b_{m-1} & a_{m} - b_{m} \\<br />
&&&& a_{m+1} - b_{m} & b_{m+1} \\<br />
&&&& b_{m+1} & \ddots \\<br />
&&&&&& \ddots & b_{n-1} \\<br />
&&&&&& b_{n-1} & a_{n} \\<br />
\end{bmatrix} +<br />
</math><br />
<br />
<math><br />
+ \begin{bmatrix}<br />
&&&&& \\<br />
&&b_{m} & b_{m} \\<br />
&&b_{m} & b_{m} \\<br />
&&&&& \\<br />
\end{bmatrix}<br />
<br />
= \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m} * \begin{bmatrix} 0 \\ \vdots \\ 0 \\ 1 \\ 1 \\ 0 \\ \vdots \\ 0 \end{bmatrix} \begin{bmatrix} 0 , \ldots , 0 , 1 , 1 , 0 \ldots , 0 \end{bmatrix} <br />
<br />
\equiv \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T}<br />
</math><br />
<br />
Предположим, что нам известны спектральные разложения матриц <math>T_{1}</math> и <math> T_{2} </math>: <br />
<math> T_{i} = Q_{i} \Lambda_{i} Q_{i}^{T} </math>. В действительности, они будут рекурсивно вычисляться тем же самым алгоритмом. Установим связь между собственными значениями матрицы Т и собственными значениями матриц<br />
<math>T_{1}</math> и <math>T_{2}</math>. Имеем:<br />
<br />
<math> <br />
T = \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T} <br />
= \begin{bmatrix} Q_{1} \Lambda_{1} Q_{1}^{T} & 0 \\ 0 & Q_{2} \Lambda_{2} Q_{2}^{T}\end{bmatrix} + b_{m}vv^{T} <br />
= \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}(\begin{bmatrix} \Lambda_{1} & \\ & \Lambda_{2}\end{bmatrix} + b_{m}uu^{T})\begin{bmatrix} Q_{1}^{T} & 0 \\ 0 & Q_{2}^{T}\end{bmatrix}<br />
</math>,<br />
<br />
где <br />
<br />
<math><br />
u = \begin{bmatrix} Q_{1}^{T} & 0 \\ 0 & Q_{2}^{T}\end{bmatrix}v<br />
</math><br />
<br />
так как <math>v = \begin{bmatrix} 0 , \ldots , 0 , 1 , 1 , 0 \ldots , 0 \end{bmatrix}^T</math>, получим матрицу, состоящую из последнего столбца матрицы <math> Q_{1}^{T}</math> и первого столбца матрицы <math> Q_{2}^{T}</math>.<br />
<br />
Следовательно, <math>T</math> имеет те же собственные значения, что и подобная ей матрица <math>D + \rho uu^{T}</math>, <br />
где <math>D = \begin{bmatrix} \Lambda_{1} & 0 \\ 0 & \Lambda_{2}\end{bmatrix}</math> - диагональная матрица, <br />
<math>\rho = b_{m}</math> - число, а <math>u</math> - вектор. <br />
<br />
Будем предполагать, не ограничивая общности, что диагональные элементы <math>d_{1}, \ldots, d_{n}</math> матрицы <math>D</math> упорядочены по убыванию: <math>d_{n} <= \ldots <=d_{1}</math>.<br />
<br />
Чтобы найти собственные значения матрицы <math>D + \rho uu^{T}</math>, вычислим её характеристический многочлен, считая пока матрицу <math>D - \lambda I</math> невырожденной.<br />
Тогда<br />
<br />
<math>det(D + \rho uu^{T} - \lambda I) = det((D - \lambda I)(I + \rho (D- \lambda I)^{-1} uu^{T}))</math>.<br />
<br />
Поскольку <math>D - \lambda I</math> невырожденна, <math>det(I + \rho (D - \lambda I)^{-1}uu^{T}) = 0</math> тогда и только тогда, когда <math>\lambda</math> - собственное значение. Заметим, что матрица <math>I + \rho (D - \lambda I)^{-1}uu^{T}</math> получается из единичной добавлением матрицы ранга 1. Определитель такой матрицы легко вычислить.<br />
<br />
'''Лемма 1.''' Справедливо равенство <math>det(I + xy^{T}) = 1 + y^{T}x</math>, где <math>x</math> и <math>y</math> - векторы.<br />
<br />
Таким образом,<br />
<br />
<math>det(I + \rho (D - \lambda I)^{-1}uu^{T}) = 1 + \rho u^{T}(D - \lambda I)^{-1}u</math> <math> = 1 + \rho \sum_{i=1, n} \frac{u_{i}^{2}} {d_{i}-\lambda} \equiv f(\lambda)</math> , <br />
<br />
т.е. собственные значения матрицы <math>T</math> есть корни так называемого векового уравнения <math>f(\lambda) = 0</math>. Если все числа <math>d_{i}</math> различны и все <math>u_{i} <> 0</math> (случай общего положения), то <math>f(\lambda)</math> имеет график типа показанного на рис.1(где <math>n = 4</math> и <math>\rho > 0</math>).<br />
<br />
[[File:Graphics.PNG|thumb|center|800px|Рис. 1. График функции <math> f(\lambda) = 1 + \frac{0.5}{1 - \lambda} + \frac{0.5}{2 - \lambda} + \frac{0.5}{3 - \lambda} + \frac{0.5}{4 - \lambda}</math>]]<br />
<br />
Можно видеть, что прямая <math>y = 1</math> является горизонтальной асимптотой для этого графика, а прямые <math>\lambda = d_{i}</math> есть вертикальные асимптоты. Поскольку <math>f^{'}(\lambda) = \rho \sum_{i=1, n} \frac{u_{i}^{2}} {(d_{i}-\lambda)^{2}}> 0 </math>, функция возрастает всюду, кроме точек <math>\lambda = d_{i}</math>. Поэтому корни функции разделяются числами <math>d_{i}</math> и ещё один корень находится справа от точки <math>d_{1}</math> (на рис. 1 <math>d_{1} = 4</math>). (При <math>\rho<0</math> функция <math>f(\lambda)</math> всюду убывает и соответствующий корень находится слева от точки <math>d_{n}</math>). Для функции <math>f(\lambda)</math>, монотонной и гладкой на каждом из интервалов <math>(d_{i+1},d_{i})</math>, можно найти вариант метода Ньютона, который быстро и монотонно сходится к каждому из корней, если начальная точка взята в <math>(d_{i+1},d_{i})</math>. Нам достаточно знать, что на практике метод сходится к каждому собственному значению за ограниченное число шагов. Поскольку вычисление <math>f(\lambda)</math> и <math>f^{'}(\lambda)</math> стоит <math>O(n)</math> флопов, для вычисления одного собственного значения достаточно <math>O(n)</math>, а для вычисления всех <math>n</math> собственных значений матрицы <math>D + \rho uu^{T}</math> требуется <math>O(n^{2})</math> флопов.<br />
Для собственных векторов матрицы <math>D + \rho uu^{T}</math> мы легко можем получить явные выражения.<br />
<br />
'''Лемма 2.''' Если <math>\alpha</math> - собственное значение матрицы <math>D + \rho uu^{T}</math>, то соответствующий вектор равен <math>(D - \alpha I)^{-1}u</math>. Поскольку матрица <math>D - \alpha I</math> диагональная, для вычисления такого вектора достаточно <math>O(n)</math> флопов.<br />
<br />
Доказательство.<br />
<br />
<math>(D + \rho uu^{T})[(D - \alpha I)^{-1}u] = (D - \alpha I + \alpha I + \rho uu^{T})(D - \alpha I)^{-1}u</math><br />
<br />
<math>=u + \alpha (D - \alpha I)^{-1}u + u[\rho u^{T}(D - \alpha I)^{-1}u] </math><br />
<br />
<math>=u + \alpha(D - \alpha I)^{-1}u - u</math> <br />
<br />
поскольку <math> \rho u^{T}(D - \alpha I)^{-1}u + 1 = f(\alpha) = 0 </math><br />
<br />
<math>=\alpha [(D - \alpha I)^{-1}u]</math>, что и требовалось.<br />
<br />
<br />
Для вычисления по этой простой формуле всех <math>n</math> собственных векторов требуется <math>O(n^{2})</math> флопов. К сожалению, формула не обеспечивает численной устойчивости, так как для двух очень близких значений <math>\alpha_{i}</math> может давать неортогональные приближенные собственные векторы <math>u_{i}</math>. Потребовалось целое десятилетие для того, чтобы найти устойчивую альтернативу исходному описанию алгоритма. Снова детали будут обсуждаться позднее в данном разделе. <br />
<br />
Алгоритм является рекурсивным.<br />
<br />
=== Дефляция ===<br />
<br />
До сих пор полагалось, что все <math>d_{i}</math> различны и все <math>u_{i}</math> отличны от нуля. Если это не так, вековое уравнение <math>f(\lambda)=0</math> имеет <math>k</math> вертикальных асимптот, где <math>k<n</math>, а потому <math>k</math> корней. Однако оказывается, что остальные <math>n - k</math> собственных значений могут быть определены без каких-либо усилий: если <math>d_{i}=d_{i+1}</math> или <math>u_{i}=0</math>, то легко показать, что <math>d_{i}</math> является собственным значением и для матрицы <math>D + \rho uu^{T}</math>. В такой ситуации мы говорим о ''дефляции''. На практике выбирается некоторое пороговое значение и дефляция для числа <math>d_{i}</math> регистрируется, если в смысле этого порога <math>d_{i}</math> достаточно близко к <math>d_{i+1}</math> либо <math>u_{i}</math> достаточно мало.<br />
<br />
Основной выигрыш от использования дефляции состоит не в том, что убыстряется решение векового уравнения - этот этап в любом случае стоит лишь <math>O(n^{2})</math> операций. Выигрыш заключается в ускорении матричного умножения на последнем шаге алгоритма. Действительно, если <math>u_{i}=0</math>, то соответствующий собственный вектор есть i-й столбец <math>e_{i}</math> единичной матрицы. Это означает, что <math>e_{i}</math> является i-м столбцом в матрице <math>Q_{'}</math>, поэтому при формировании матрицы <math>Q</math> посредством левого умножения <math>Q_{1}</math> на <math>Q_{2}</math> вычисление i-го столбца не требует никаких затрат. Аналогичное упрощение имеет место в случае <math>d_{i} = d_{i+1}</math>. При дефляции многих собственных значений устраняется большая часть работы, связанной с матричным умножением.<br />
<br />
=== Решение векового уравнения ===<br />
<br />
Подробно стоит поговорить о решении векового уравнения, которое является одной из основных частей алгоритма.<br />
<br />
Предположим, что некоторое <math>u_{i}</math>, хотя и мало, все же недостаточно мало для того, чтобы была зарегистрирована дефляция. В этом случае применение метода Ньютона к решению векового уравнения встречается с затруднениями. Вспомним, что пересчет приближённого решения <math>u_{j}</math> уравнения <math>f(\lambda) = 0</math> в методе Ньютона основан на следующих положениях:<br />
<br />
1. Вблизи точки <math>\lambda = \lambda_{j}</math> функция <math>f(\lambda)</math> аппроксимируется линейной функцией <math>l(\lambda)</math>; график есть прямая линия, касающаяся графика функции <math>f(\lambda)</math> при <math>\lambda = \lambda_{j}</math>.<br />
<br />
2. В качестве <math>\lambda_{j+1}</math> берётся нуль этого линейного приближения, т.е. <math>l(\lambda_{j+1})=0</math>.<br />
<br />
Функция, показанная на рис.1, не доставляет видимых трудностей методу Ньютона, поскольку вблизи каждого своего нуля <math>f(\lambda)</math> достаточно хорошо аппроксимируется линейными функциями. Однако рассмотрим график функции на рис.2. Она получена из функции на рис. 1 заменой значения .5 для <math>u_{i}^{2}</math> на .001. Это новое значение недостаточно мало для того, чтобы вызвать дефляцию. График функции в левой части рис.2 визуально не отличим от её вертикальных и горизонтальных асимптот, поэтому в правой части укрупненно воспроизведён фрагмент графика, прилегающий к вертикальной асимптоте <math>\lambda = 2</math>. Видно, что график слишком быстро "выполняет поворот" и для большей части значений <math>\lambda</math> почти горизонтален. Поэтому, применяя метод Ньютона почти к любому начальному приближению <math>\lambda_{0}</math>, мы получаем линейное приближение <math>l(\lambda)</math> с почти горизонтальным графиком и малым положительным угловым коэффициентом. В результате <math>\lambda_{1}</math> является отрицательным числом, огромным по абсолютной величине, которое совершенно бесполезно в качестве приближения к истинному корню.<br />
<br />
[[File:GraphNewton.png|thumb|center|800px|Рис. 2. График функции <math> f(\lambda) = 1 + \frac{10^{-3}}{1 - \lambda} + \frac{10^{-3}}{2 - \lambda} + \frac{10^{-3}}{3 - \lambda} + \frac{10^{-3}}{4 - \lambda}</math>]]<br />
<br />
Чтобы найти выход из этого положения, можно модифицировать метод Ньютона следующим образом: раз <math>f(\lambda)</math> нельзя хорошо приблизить линейной функцией <math>l(\lambda)</math>, попробуем взять в качестве приближения какую-нибудь другую простую функцию <math>h(\lambda)</math>. Нет ничего особого именно в прямых линиях: для метода Ньютона вместо <math>l(\lambda)</math> можно взять любое приближение <math>h(\lambda)</math>, значения и нули которого легко вычисляются. Функция <math>f(\lambda)</math> имеет полюсы в точках <math>d_{i}</math> и <math>d_{i+1}</math>, которые определяют её поведение в соответствующих окрестностях. Поэтому при поиске корня в интервале <math>(d_{i+1}, d_{i})</math> естественно выбрать функцию <math>h(\lambda)</math>, также имеющую эти полюсы, т.е. функцию вида<br />
<math>h(\lambda)= \frac{c_{1}}{d_{i}-\lambda} + \frac{c_{2}}{d_{i+1}-\lambda} + c_{3}</math><br />
<br />
Константы <math>c_{1},c_{2}</math> и <math>c_{3}</math> обеспечивающие, что <math>h(\lambda)</math> есть приближение к <math>f(\lambda)</math>, можно выбрать несколькими способами. Отметим, что если <math>c_{1},c_{2}</math> и <math>c_{3}</math> уже известны, то уравнение <math>h(\lambda)=0</math> легко решается относительно <math>\lambda</math>, поскольку сводится к эквивалентному квадратному уравнению<br />
<math>c_{1}(d_{i+1}-\lambda)+c_{2}(d_{i}-\lambda)+c_{3}(d_{i}-\lambda)(d_{i+1}-\lambda)=0</math><br />
<br />
Пусть <math>\lambda_{j}</math> - приближённое значение корня. определим <math>c_{1},c_{2}</math> и <math>c_{3}</math> так, чтобы<br />
<math>\frac{c_{1}}{d_{i}-\lambda} + \frac{c_{2}}{d_{i+1}-\lambda} + c_{3} = h(\lambda) \approx f(\lambda) = 1 + \rho \sum_{k=1, n} \frac{u_{k}^{2}} {d_{k}-\lambda} </math><br />
<br />
для <math>\lambda</math> в окрестности <math>\lambda_{j}</math>. Заметим, что<br />
<br />
<math>f(\lambda) = 1 + \rho \sum_{k=1, i} \frac{u_{k}^{2}} {d_{k}-\lambda} + \rho \sum_{k=i+1, n} \frac{u_{k}^{2}} {d_{k}-\lambda} \equiv 1 + \psi_{1}(\lambda) + \psi_{2}(\lambda)</math>.<br />
<br />
Если <math>\lambda \in (d_{i+1},d_{i})</math>, то <math>\psi_{1}(\lambda)</math> есть сумма положительных слагаемых, а <math>\psi_{2}(\lambda)</math> - сумма отрицательных. Поэтому и <math>\psi_{1}(\lambda)</math>, и <math>\psi_{2}(\lambda)</math> могут быть вычислены с высокой точностью; однако при их сложении вполне вероятно взаимное уничтожение верных разрядов и потеря относительной точности в сумме. Возьмем числа <math>c_{1}</math> и <math>\hat{c_{1}}</math>, такие, что функция <br />
<br />
<math>h_{1}(\lambda) \equiv \hat{c_{1}} + \frac{c_{1}}{d_{i}-\lambda}</math> удовлетворяет условиям <math>h_{1}(\lambda_{j}) = \psi_{1}(\lambda_{j})</math> и <math>h_{1}^{'}(\lambda_{j})=\psi_{1}^{'}(\lambda_{j})</math> (1)<br />
<br />
Это означает, что гипербола, являющаяся графиком функции <math>h_{1}(\lambda)</math>, касается графика функции <math>\psi_{i}(\lambda)</math> при <math>\lambda = \lambda_{j}</math>. Два условия в (1) - это обычные условия метода Ньютона, за исключением того, что вместо прямой в качестве приближения используется гипербола. Легко проверить, что <math>c_{1}=\psi_{1}^{'}(\lambda_{j})(d_{i} - \lambda_{j})^{2}</math> и <math>\hat{c_{1}}=\psi_{1}(\lambda_{j}) - \psi_{1}^{'}(\lambda_{j})(d_{i} - \lambda_{j})</math><br />
<br />
Подобным же образом выбираем <math>c_{2}</math> и <math>\hat{c_{2}}</math> так, чтобы функция <br />
<br />
<math>h_{2}(\lambda) \equiv \hat{c_{2}} + \frac{c_{2}}{d_{i+1}-\lambda}</math><br />
<br />
Удовлетворяла условиям<br />
<br />
<math>h_{2}(\lambda_{j}) = \psi_{2}(\lambda_{j})</math> и <math>h_{2}^{'}(\lambda_{j})=\psi_{2}^{'}(\lambda_{j})</math> (2)<br />
<br />
Наконец, полагаем<br />
<br />
<math>h(\lambda) = 1 + h_{1}(\lambda) + h_{2}(\lambda) = (1 + \hat{c_{1}} + \hat{c_{2}} + \frac{c_{1}}{d_{i}-\lambda} + \frac{c_{2}}{d_{i+1}-\lambda} </math><br />
<br />
<math>\equiv c_{3} + \frac{c_{1}}{d_{i}-\lambda} + \frac{c_{2}}{d_{i+1}-\lambda}</math>.<br />
<br />
== Вычислительное ядро алгоритма ==<br />
Вычислительным ядром последовательной схемы решения является вычисление матрицы <math>Q</math> собственных векторов путём умножения матрицы <math>Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}</math> на матрицу <math>Q^{'}</math> Данная операция имеет сложность <math>cn^{3}</math> о чём и говорится в разделе [[#Последовательная сложность алгоритма]] .<br />
Ей предшествует вычисление собственных значений и векторов матрицы <math> D + \rho uu^{T}</math><br />
<br />
== Макроструктура алгоритма ==<br />
Ниже описана структура алгоритма, в которой есть блок умножения матриц для вычисления собственных векторов, являющийся вычислительным ядром алгоритма. В соответствующем разделе ([[#Вычислительное ядро алгоритма]]) мы упоминали о том, что данному блоку предшествует вычисление собственных значений, которое производится [https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D0%9D%D1%8C%D1%8E%D1%82%D0%BE%D0%BD%D0%B0 методом Ньютона].<br />
<br />
[[File:DivideAndConquerTree.png|thumb|center|left|800px|Рис. 3. Дерево алгоритма "Разделяй и властвуй"]]<br />
<br />
[[File:InfoGraph.jpg|thumb|center|1200px|Рис. 4. Детальное описание одного блока алгоритма]]<br />
<br />
== Схема реализации последовательного алгоритма ==<br />
''Вычисление собственных значений и собственных векторов симметричной трехдиагональной матрицы посредством стратегии "разделяй и властвуй"'':<br />
<br />
<br />
''proc dc_eig''<math>(T,Q,\Lambda)...</math> по входной матрице <math>T</math> вычисляются выходные матрицы <math>Q</math> и <math>\Lambda</math>, такие, что <math>T = Q\Lambda Q^{T}</math><br />
<br />
'''Если <math>T</math> - матрица размера <math>1</math> x <math>1</math>'''<br />
<br />
1. Присвоить выходным параметрам значения <math> Q = 1, \Lambda = T</math><br />
<br />
'''Иначе'''<br />
<br />
1. Представить <math>T</math> в виде <math> T = \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T} </math><br />
<br />
2. ''call dc_eig''<math>(T_{1},Q_{1},\Lambda_{1})</math><br />
<br />
3. ''call dc_eig''<math>(T_{2},Q_{2},\Lambda_{2})</math><br />
<br />
4. Построить <math>D+\rho uu^{T}</math> по <math> \Lambda_{1},\Lambda_{2}, Q_{1}, Q_{2}</math><br />
<br />
5. Найти матрицу собственных значений <math>\Lambda</math><br />
<br />
6. Найти матрицу собственных векторов <math>Q^{'}</math> для матрицы <math>D+\rho uu^{T}</math><br />
<br />
7. Построить матрицу собственных векторов <math>Q</math> для матрицы <math>T</math> : <math> Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}* Q^{'} </math><br />
<br />
8. Присвоить выходным параметрам значения <math>Q</math> и <math>\Lambda</math><br />
<br />
'''endif'''<br />
<br />
== Последовательная сложность алгоритма ==<br />
Проанализируем сложность алгоритма. Пусть <math>t(n)</math> - число флопов при обработке матрицы размера <math> n x n</math> процедурой ''dc_eig''. Тогда <br />
<br />
<math> t(n) = 2t(n/2) </math> два рекурсивных обращения к ''dc_eig''<math>(T_{i},Q_{i},\Lambda_{i})</math><br />
<br />
<math> +O(n^{2})</math> вычисление собственных значений матрицы <math>D+\rho uu^{T}</math><br />
<br />
<math> +O(n^{2})</math> вычисление собственных векторов матрицы <math>D+\rho uu^{T}</math><br />
<br />
<math> +c*n^{3}</math> вычисление матрицы <math>Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}*Q^{'}</math><br />
<br />
<br />
Если <math> Q_{1}, Q_{2}</math> и <math>Q^{'}</math> рассматриваются как плотные матрицы и используется стандартный алгоритм матричного умножения, то константа <math> c </math> в последней строке равна 1. Таким образом, именно это умножение составляет наиболее трудоёмкую часть алгоритма в целом. Игнорируя члены порядка <math>n^{2}</math>, получаем <math>t(n) = 2t(n/2) + cn^{3}</math>. Решая это разностное уравнение, находим <math> t \approx c\frac{4}{3}n^{3} </math><br />
<br />
На практике константа <math>c</math> обычно гораздо меньше 1, потому что матрица <math>Q^{'}</math> весьма разрежена вследствие явления, называемого дефляцией.<br />
<br />
== Информационный граф ==<br />
В данном разделе на рисунке 5 представлен информационный граф алгоритма.<br />
<br />
[[File:InfoGraphSC.jpg|thumb|center|left|1200px|Рис. 5. Информационный граф алгоритма "Разделяй и властвуй" - шаг <b>Divide</b>]]<br />
<br />
Операции: <br />
<br />
<math>D</math> - операция Divide разделения матрицы <math> T </math> на матрицы <math>T_{1}</math> и <math>T_{2}</math><br />
<br />
Индексы - размерность <br />
<br />
<math>S_{k}</math> - операция Conquer сбора матрицы <math> D </math><br />
<br />
<math> L_{k} </math> - операция поиска собственных значений <br />
<br />
<math> S^{'} </math> - операция поиска собственных векторов матрицы <math> Q^{'} </math><br />
<br />
<math> S </math> - операция поиска собственных векторов матрицы <math> Q </math><br />
<br />
== Ресурс параллелизма алгоритма ==<br />
Рассмотрев информационный граф алгоритма, можно заметить, что в структуре имеется два параллельных блока - вызов рекурсивных функций ''dc_eig'' для вычисления собственных значений и векторов матриц <math>T_{1}</math> и <math>T_{2}</math> - это единственная часть алгоритма, в которой мы прибегаем к параллелизму. <br />
<br />
Рекурсивное разделение матрицы ведёт к иерархии вычислительных подблоков с графом зависимости данных, который выглядит, как двоичное дерево. Данная структура является естественным путем разделения вычислений между процессорами.<br />
<br />
В вершине дерева все процессы взаимодействуют. В каждой ветви дерева вычисление делится на два вычислительных подблока, внутри каждого из которых процессы параллельно взаимодействуют. В листьях деревьев каждый процесс занимается вычислением независимо.<br />
<br />
В случае реализации без параллелизма, функции ''dc_eig'' отрабатывают последовательно - сначала со входными параметрами <math>T_{1}, Q_{1}, \Lambda_{1}</math>, затем - <math>T_{2}, Q_{2}, \Lambda_{2}</math>.<br />
<br />
Таким образом, благодаря параллелизму высота алгоритма параллельного составляет <math>log_{2}(n)</math>, когда как при последовательной реализации высота алгоритма равна сумме геометрической прогрессии <math>1+2+4+8+...+2^{n-1} = 2^{n} - 1</math>, что значительно сокращает число итераций алгоритма.<br />
<br />
== Входные и выходные данные алгоритма ==<br />
'''Входные данные:''' <br />
<br />
На вход алгоритму подаётся трёхдиагональная симметричная матрица:<br />
<br />
<math><br />
L = \begin{bmatrix}<br />
a_{1} & b_{1}&&&&& \\<br />
b_{1} & \ddots & \ddots \\<br />
& \ddots & a_{m-1} & b_{m-1} \\<br />
&& b_{m-1} & a_{m} & b_{m} \\<br />
&&& b_{m} & a_{m+1} & b_{m+1} \\<br />
&&&& b_{m+1} & \ddots \\<br />
&&&&&& \ddots & b_{n-1} \\<br />
&&&&&& b_{n-1} & a_{n} \\<br />
\end{bmatrix}<br />
</math><br />
<br />
'''Объем входных данных:''' <br />
<br />
<math>2n + 1</math> - в силу симметрии, хранить следует только диагональные, поддиагональые и наддиагональные элементы.<br />
<br />
'''Выходные данные:'''<br />
<br />
На выходе мы получаем вектор собственных значений длины <math> n </math> и <math> n </math> собственных векторов длины <math> n </math> , соответствующих собственным значениям исходной матрицы.<br />
<br />
'''Объем выходных данных:'''<br />
<br />
<math> n + n^{2} = n(n + 1) </math><br />
<br />
== Свойства алгоритма ==<br />
Описанный в данной статье алгоритм является самым быстрым алгоритмом, среди существующих: QR / Бисекция и обратная итерация / Разделяй и властвуй.<br />
<br />
Последовательная сложность алгоритма (не принимая во внимание дефляцию) удовлетворяет рекурсивному соотношению: <br />
<br />
<math>t(n) = n^3 +2t(\frac{n}{2})</math><br />
<br />
Решение которого имеет вид:<br />
<br />
<math> t = c\frac{4}{3}n^{3} </math><br />
<br />
На практике же, параллельная сложность алгоритма в силу использования дефляции, позволяющей получить выигрыш в количестве операций, который заключается в ускорении матричного умножения на последнем шаге алгоритма (см. [[#Дефляция]]), имеет следующий вид: <math> O(n^{2.3})</math> или в самых редких случаях <math> O(n^{2}) </math> (см. [3] стр. 8).<br />
<br />
Особенности алгоритма:<br />
<br />
1. Использование дефляции ([[#Дефляция]])<br />
<br />
2. Использование адаптированного метода Ньютона ([[#Макроструктура алгоритма]])<br />
<br />
= Программная реализация алгоритма =<br />
Вторая часть описания алгоритмов в рамках AlgoWiki рассматривает все составные части процесса их реализации. Рассматривается как последовательная реализация алгоритма, так и параллельная. Описывается взаимосвязь свойств программ, реализующих алгоритм, и особенностей архитектуры компьютера, на которой они выполняются. Исследуется работа с памятью, локальность данных и вычислений, описывается масштабируемость и эффективность параллельных программ, производительность компьютеров, достигаемая на данной программе. Обсуждаются особенности реализации для разных классов архитектур компьютеров, приводятся ссылки на реализации в существующих библиотеках.<br />
<br />
<br />
== Особенности реализации последовательного алгоритма ==<br />
<br />
== Локальность данных и вычислений ==<br />
<br />
== Возможные способы и особенности параллельной реализации алгоритма ==<br />
== Масштабируемость алгоритма и его реализации ==<br />
Исследование проводилось на суперкомпьютере "Ломоносов" Суперкомпьютерного комплекса Московского университета.<br />
<br />
Набор и границы значений изменяемых параметров запуска реализации алгоритма: <br />
<br />
* число процессоров [1 : 8] (1,2,3,4,8);<br />
* размер матрицы [4 : 8192].<br />
<br />
Для исследования масштабируемости алгоритм был реализован на библиотеке OpenMP 1.5.5 для языка C++(компилятор g++) на cуперкомпьютере Ломоносов на узле compiler. Для данного узла максимально возможное число потоков - 8. В ходе оценки масштабируемости, программа была запущена в 1, 2, 4, 8 потока. <br />
Параметры компиляции и запуска: <br />
<br />
ssh compiler <br />
module add slurm<br />
module add openmpi/1.5.5-icc<br />
g++ _scratch/test.c++ -fopenmp -std=c++0x -o test <br />
sbatch -p test -n1 run ./test<br />
<br />
Для управления количеством потоков использовалась операция OpenMP omp_set_num_threads();<br />
<br />
[[File:ResultsDiagram.jpg|thumb|center|left|800px|Рис. 6. График времени работы программы в зависимости от числа процессов и размера задачи]]<br />
<br />
Масштабируемость рассматриваемой реализации алгоритма '''"Разделяй и властвуй"''':<br />
<br />
* При увеличении числа процессов общая эффективность программы увеличивается, т.к. время чтения и подготовки исходной матрицы остаётся неизменным, а время работы алгоритма уменьшается, однако рост незначительный.<br />
* При увеличении размерности матрицы общая эффективность программы постепенно уменьшается, т.к. время чтения и подготовки исходных данных растёт быстрее, чем время работы исследуемого алгоритма.<br />
* При одновременном увеличении как числа процессов, так и размерности матрицы общая эффективность программы уменьшается.<br />
<br />
Код исследуемой реализации представлен здесь [http://pastebin.com/QpfYZGkK pastebin.com]<br />
<br />
== Динамические характеристики и эффективность реализации алгоритма ==<br />
<br />
== Выводы для классов архитектур ==<br />
<br />
== Существующие реализации алгоритма ==<br />
Описываемый метод реализован в пакете LAPACK, описание которого можно найти в [http://www.netlib.org/lapack/lawnspdf/lawn132.pdf этой статье] на страницах 7, 19 и 20, которая указана в списке литературы.<br />
<br />
= Литература =<br />
[1] Дж. Деммель, «Вычислительная линейная алгебра» //С. 230-235<br />
<br />
[2] [http://www.netlib.org/utk/people/JackDongarra/PAPERS/104_1999_a-parallel-divide-and-conquer-algorithm.pdf Francoise Tisseury, Jack Dongarra, A Parallel Divide and Conquer Algorithm for the Symmetric Eigenvalue Problem on Distributed Memory Architectures]<br />
<br />
[3] [http://www.netlib.org/lapack/lawnspdf/lawn132.pdf Francoise Tisseury, Jack Dongarra, Parallelizing the Divide and Conquer Algorithm for the Symmetric Tridiagonal Eigenvalue Problem on Distributed Memory Architectures]<br />
<br />
[4] [https://en.wikipedia.org/wiki/Divide-and-conquer_eigenvalue_algorithm Алгоритм "Разделяй и властвуй" - Wikipedia]<br />
<br />
[5] [http://www.cscamm.umd.edu/tadmor/pub/linear-stability/Gill_Tadmor_SISC90.pdf Doron Grill and Eitan Tadmor AN <math>O(N2)</math> METHOD FOR COMPUTING THE EIGENSYSTEM OF <math>N</math>x<math>N</math> SYMMETRIC TRIDIAGONAL MATRICES BY THE DIVIDE AND CONQUER APPROACH]<br />
<br />
[[en:Description of algorithm properties and structure]]<br />
<br />
<br />
[[Категория:Статьи в работе]]</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%C2%AB%D1%80%D0%B0%D0%B7%D0%B4%D0%B5%D0%BB%D1%8F%D0%B9_%D0%B8_%D0%B2%D0%BB%D0%B0%D1%81%D1%82%D0%B2%D1%83%D0%B9%C2%BB_%D0%B2%D1%8B%D1%87%D0%B8%D1%81%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F_%D1%81%D0%BE%D0%B1%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D1%8B%D1%85_%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B9_%D0%B8_%D0%B2%D0%B5%D0%BA%D1%82%D0%BE%D1%80%D0%BE%D0%B2_%D1%81%D0%B8%D0%BC%D0%BC%D0%B5%D1%82%D1%80%D0%B8%D1%87%D0%BD%D0%BE%D0%B9_%D1%82%D1%80%D0%B5%D1%85%D0%B4%D0%B8%D0%B0%D0%B3%D0%BE%D0%BD%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B9_%D0%BC%D0%B0%D1%82%D1%80%D0%B8%D1%86%D1%8B&diff=22579Метод «разделяй и властвуй» вычисления собственных значений и векторов симметричной трехдиагональной матрицы2017-04-29T20:28:01Z<p>Chernyavskiy: /* Макроструктура алгоритма */</p>
<hr />
<div>Основные авторы описания: [[Участник:Роман_Землянский|Р.Землянский]] (Разделы <br />
[[#Общее описание алгоритма|1.1]], [[#Математическое описание алгоритма|1.2]], [[#Последовательная сложность алгоритма|1.6]], [[#Ресурс параллелизма алгоритма|1.8]], [[#Входные и выходные данные алгоритма|1.9]], [[#Свойства алгоритма|1.10]]), В.Завольсков (Разделы [[#Вычислительное ядро алгоритма|1.3]], [[#Макроструктура алгоритма|1.4]], [[#Схема реализации последовательного алгоритма|1.5]], [[#Информационный граф|1.7]], [[#Существующие реализации алгоритма|2.7]]), [[Участник:IgorS]] (предварительная проверка), [[Участник:Chernyavskiy|А.Ю. Чернявский]] (проверка, редактирование).<br />
<br />
<br />
{{algorithm<br />
| name = Метод "Разделяй и властвуй" вычисления собственных значений и векторов трёхдиагональной матрицы<br />
| serial_complexity = <math> c\frac{4}{3}n^{3} </math><br />
| parallel_complexity = <math> O(n^{2.3}) </math><br />
<br />
крайне редко: <math> O(n^{2}) </math> <br />
| pf_width = <br />
| input_data = <math> 2n + 1 </math><br />
| output_data = <math> n(n + 1) </math><br />
}}<br />
<br />
<br />
= Свойства и структура алгоритмов =<br />
== Общее описание алгоритма ==<br />
'''Метод разделяй и властвуй вычисления собственных значений и векторов трёхдиагональной матрицы''' - это наиболее быстрый из существующих методов, если нужны все собственные значения и собственные векторы трехдиагональной матрицы, начиная с порядка n, примерно равного 26. (Точное значение этого порогового порядка зависит от компьютера.) Его численно устойчивая реализация весьма не тривиальна. В самом деле, хотя впервые метод был предложен еще в 1981 г., "правильный" способ его реализации был найден лишь в 1992 г. Этот способ воплощен LAPACK-программами ssyevd (для плотных матриц) и sstevd (для трехдиагональных матриц). В них стратегия "разделяй-и-влавствуй" используется для матриц порядка, большего чем 25. Для матриц меньшего порядка (или если нужны только собственные значения) происходит автоматический переход к QR-итерации.<br />
<br />
== Математическое описание алгоритма ==<br />
Пусть <br />
<br />
:<math><br />
T = \begin{bmatrix}<br />
a_{1} & b_{1}&&&&& \\<br />
b_{1} & \ddots & \ddots \\<br />
& \ddots & a_{m-1} & b_{m-1} \\<br />
&& b_{m-1} & a_{m} & b_{m} \\<br />
&&& b_{m} & a_{m+1} & b_{m+1} \\<br />
&&&& b_{m+1} & \ddots \\<br />
&&&&&& \ddots & b_{n-1} \\<br />
&&&&&& b_{n-1} & a_{n} \\<br />
\end{bmatrix}<br />
= \begin{bmatrix}<br />
a_{1} & b_{1} &&&&& \\<br />
b_{1} & \ddots & \ddots \\<br />
& \ddots & a_{m-1} & b_{m-1} \\<br />
&& b_{m-1} & a_{m} - b_{m} \\<br />
&&&& a_{m+1} - b_{m} & b_{m+1} \\<br />
&&&& b_{m+1} & \ddots \\<br />
&&&&&& \ddots & b_{n-1} \\<br />
&&&&&& b_{n-1} & a_{n} \\<br />
\end{bmatrix} +<br />
</math><br />
<br />
<math><br />
+ \begin{bmatrix}<br />
&&&&& \\<br />
&&b_{m} & b_{m} \\<br />
&&b_{m} & b_{m} \\<br />
&&&&& \\<br />
\end{bmatrix}<br />
<br />
= \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m} * \begin{bmatrix} 0 \\ \vdots \\ 0 \\ 1 \\ 1 \\ 0 \\ \vdots \\ 0 \end{bmatrix} \begin{bmatrix} 0 , \ldots , 0 , 1 , 1 , 0 \ldots , 0 \end{bmatrix} <br />
<br />
\equiv \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T}<br />
</math><br />
<br />
Предположим, что нам известны спектральные разложения матриц <math>T_{1}</math> и <math> T_{2} </math>: <br />
<math> T_{i} = Q_{i} \Lambda_{i} Q_{i}^{T} </math>. В действительности, они будут рекурсивно вычисляться тем же самым алгоритмом. Установим связь между собственными значениями матрицы Т и собственными значениями матриц<br />
<math>T_{1}</math> и <math>T_{2}</math>. Имеем:<br />
<br />
<math> <br />
T = \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T} <br />
= \begin{bmatrix} Q_{1} \Lambda_{1} Q_{1}^{T} & 0 \\ 0 & Q_{2} \Lambda_{2} Q_{2}^{T}\end{bmatrix} + b_{m}vv^{T} <br />
= \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}(\begin{bmatrix} \Lambda_{1} & \\ & \Lambda_{2}\end{bmatrix} + b_{m}uu^{T})\begin{bmatrix} Q_{1}^{T} & 0 \\ 0 & Q_{2}^{T}\end{bmatrix}<br />
</math>,<br />
<br />
где <br />
<br />
<math><br />
u = \begin{bmatrix} Q_{1}^{T} & 0 \\ 0 & Q_{2}^{T}\end{bmatrix}v<br />
</math><br />
<br />
так как <math>v = \begin{bmatrix} 0 , \ldots , 0 , 1 , 1 , 0 \ldots , 0 \end{bmatrix}^T</math>, получим матрицу, состоящую из последнего столбца матрицы <math> Q_{1}^{T}</math> и первого столбца матрицы <math> Q_{2}^{T}</math>.<br />
<br />
Следовательно, <math>T</math> имеет те же собственные значения, что и подобная ей матрица <math>D + \rho uu^{T}</math>, <br />
где <math>D = \begin{bmatrix} \Lambda_{1} & 0 \\ 0 & \Lambda_{2}\end{bmatrix}</math> - диагональная матрица, <br />
<math>\rho = b_{m}</math> - число, а <math>u</math> - вектор. <br />
<br />
Будем предполагать, не ограничивая общности, что диагональные элементы <math>d_{1}, \ldots, d_{n}</math> матрицы <math>D</math> упорядочены по убыванию: <math>d_{n} <= \ldots <=d_{1}</math>.<br />
<br />
Чтобы найти собственные значения матрицы <math>D + \rho uu^{T}</math>, вычислим её характеристический многочлен, считая пока матрицу <math>D - \lambda I</math> невырожденной.<br />
Тогда<br />
<br />
<math>det(D + \rho uu^{T} - \lambda I) = det((D - \lambda I)(I + \rho (D- \lambda I)^{-1} uu^{T}))</math>.<br />
<br />
Поскольку <math>D - \lambda I</math> невырожденна, <math>det(I + \rho (D - \lambda I)^{-1}uu^{T}) = 0</math> тогда и только тогда, когда <math>\lambda</math> - собственное значение. Заметим, что матрица <math>I + \rho (D - \lambda I)^{-1}uu^{T}</math> получается из единичной добавлением матрицы ранга 1. Определитель такой матрицы легко вычислить.<br />
<br />
'''Лемма 1.''' Справедливо равенство <math>det(I + xy^{T}) = 1 + y^{T}x</math>, где <math>x</math> и <math>y</math> - векторы.<br />
<br />
Таким образом,<br />
<br />
<math>det(I + \rho (D - \lambda I)^{-1}uu^{T}) = 1 + \rho u^{T}(D - \lambda I)^{-1}u</math> <math> = 1 + \rho \sum_{i=1, n} \frac{u_{i}^{2}} {d_{i}-\lambda} \equiv f(\lambda)</math> , <br />
<br />
т.е. собственные значения матрицы <math>T</math> есть корни так называемого векового уравнения <math>f(\lambda) = 0</math>. Если все числа <math>d_{i}</math> различны и все <math>u_{i} <> 0</math> (случай общего положения), то <math>f(\lambda)</math> имеет график типа показанного на рис.1(где <math>n = 4</math> и <math>\rho > 0</math>).<br />
<br />
[[File:Graphics.PNG|thumb|center|800px|Рис. 1. График функции <math> f(\lambda) = 1 + \frac{0.5}{1 - \lambda} + \frac{0.5}{2 - \lambda} + \frac{0.5}{3 - \lambda} + \frac{0.5}{4 - \lambda}</math>]]<br />
<br />
Можно видеть, что прямая <math>y = 1</math> является горизонтальной асимптотой для этого графика, а прямые <math>\lambda = d_{i}</math> есть вертикальные асимптоты. Поскольку <math>f^{'}(\lambda) = \rho \sum_{i=1, n} \frac{u_{i}^{2}} {(d_{i}-\lambda)^{2}}> 0 </math>, функция возрастает всюду, кроме точек <math>\lambda = d_{i}</math>. Поэтому корни функции разделяются числами <math>d_{i}</math> и ещё один корень находится справа от точки <math>d_{1}</math> (на рис. 1 <math>d_{1} = 4</math>). (При <math>\rho<0</math> функция <math>f(\lambda)</math> всюду убывает и соответствующий корень находится слева от точки <math>d_{n}</math>). Для функции <math>f(\lambda)</math>, монотонной и гладкой на каждом из интервалов <math>(d_{i+1},d_{i})</math>, можно найти вариант метода Ньютона, который быстро и монотонно сходится к каждому из корней, если начальная точка взята в <math>(d_{i+1},d_{i})</math>. Нам достаточно знать, что на практике метод сходится к каждому собственному значению за ограниченное число шагов. Поскольку вычисление <math>f(\lambda)</math> и <math>f^{'}(\lambda)</math> стоит <math>O(n)</math> флопов, для вычисления одного собственного значения достаточно <math>O(n)</math>, а для вычисления всех <math>n</math> собственных значений матрицы <math>D + \rho uu^{T}</math> требуется <math>O(n^{2})</math> флопов.<br />
Для собственных векторов матрицы <math>D + \rho uu^{T}</math> мы легко можем получить явные выражения.<br />
<br />
'''Лемма 2.''' Если <math>\alpha</math> - собственное значение матрицы <math>D + \rho uu^{T}</math>, то соответствующий вектор равен <math>(D - \alpha I)^{-1}u</math>. Поскольку матрица <math>D - \alpha I</math> диагональная, для вычисления такого вектора достаточно <math>O(n)</math> флопов.<br />
<br />
Доказательство.<br />
<br />
<math>(D + \rho uu^{T})[(D - \alpha I)^{-1}u] = (D - \alpha I + \alpha I + \rho uu^{T})(D - \alpha I)^{-1}u</math><br />
<br />
<math>=u + \alpha (D - \alpha I)^{-1}u + u[\rho u^{T}(D - \alpha I)^{-1}u] </math><br />
<br />
<math>=u + \alpha(D - \alpha I)^{-1}u - u</math> <br />
<br />
поскольку <math> \rho u^{T}(D - \alpha I)^{-1}u + 1 = f(\alpha) = 0 </math><br />
<br />
<math>=\alpha [(D - \alpha I)^{-1}u]</math>, что и требовалось.<br />
<br />
<br />
Для вычисления по этой простой формуле всех <math>n</math> собственных векторов требуется <math>O(n^{2})</math> флопов. К сожалению, формула не обеспечивает численной устойчивости, так как для двух очень близких значений <math>\alpha_{i}</math> может давать неортогональные приближенные собственные векторы <math>u_{i}</math>. Потребовалось целое десятилетие для того, чтобы найти устойчивую альтернативу исходному описанию алгоритма. Снова детали будут обсуждаться позднее в данном разделе. <br />
<br />
Алгоритм является рекурсивным.<br />
<br />
=== Дефляция ===<br />
<br />
До сих пор полагалось, что все <math>d_{i}</math> различны и все <math>u_{i}</math> отличны от нуля. Если это не так, вековое уравнение <math>f(\lambda)=0</math> имеет <math>k</math> вертикальных асимптот, где <math>k<n</math>, а потому <math>k</math> корней. Однако оказывается, что остальные <math>n - k</math> собственных значений могут быть определены без каких-либо усилий: если <math>d_{i}=d_{i+1}</math> или <math>u_{i}=0</math>, то легко показать, что <math>d_{i}</math> является собственным значением и для матрицы <math>D + \rho uu^{T}</math>. В такой ситуации мы говорим о ''дефляции''. На практике выбирается некоторое пороговое значение и дефляция для числа <math>d_{i}</math> регистрируется, если в смысле этого порога <math>d_{i}</math> достаточно близко к <math>d_{i+1}</math> либо <math>u_{i}</math> достаточно мало.<br />
<br />
Основной выигрыш от использования дефляции состоит не в том, что убыстряется решение векового уравнения - этот этап в любом случае стоит лишь <math>O(n^{2})</math> операций. Выигрыш заключается в ускорении матричного умножения на последнем шаге алгоритма. Действительно, если <math>u_{i}=0</math>, то соответствующий собственный вектор есть i-й столбец <math>e_{i}</math> единичной матрицы. Это означает, что <math>e_{i}</math> является i-м столбцом в матрице <math>Q_{'}</math>, поэтому при формировании матрицы <math>Q</math> посредством левого умножения <math>Q_{1}</math> на <math>Q_{2}</math> вычисление i-го столбца не требует никаких затрат. Аналогичное упрощение имеет место в случае <math>d_{i} = d_{i+1}</math>. При дефляции многих собственных значений устраняется большая часть работы, связанной с матричным умножением.<br />
<br />
=== Решение векового уравнения ===<br />
<br />
Подробно стоит поговорить о решении векового уравнения, которое является одной из основных частей алгоритма.<br />
<br />
Предположим, что некоторое <math>u_{i}</math>, хотя и мало, все же недостаточно мало для того, чтобы была зарегистрирована дефляция. В этом случае применение метода Ньютона к решению векового уравнения встречается с затруднениями. Вспомним, что пересчет приближённого решения <math>u_{j}</math> уравнения <math>f(\lambda) = 0</math> в методе Ньютона основан на следующих положениях:<br />
<br />
1. Вблизи точки <math>\lambda = \lambda_{j}</math> функция <math>f(\lambda)</math> аппроксимируется линейной функцией <math>l(\lambda)</math>; график есть прямая линия, касающаяся графика функции <math>f(\lambda)</math> при <math>\lambda = \lambda_{j}</math>.<br />
<br />
2. В качестве <math>\lambda_{j+1}</math> берётся нуль этого линейного приближения, т.е. <math>l(\lambda_{j+1})=0</math>.<br />
<br />
Функция, показанная на рис.1, не доставляет видимых трудностей методу Ньютона, поскольку вблизи каждого своего нуля <math>f(\lambda)</math> достаточно хорошо аппроксимируется линейными функциями. Однако рассмотрим график функции на рис.2. Она получена из функции на рис. 1 заменой значения .5 для <math>u_{i}^{2}</math> на .001. Это новое значение недостаточно мало для того, чтобы вызвать дефляцию. График функции в левой части рис.2 визуально не отличим от её вертикальных и горизонтальных асимптот, поэтому в правой части укрупненно воспроизведён фрагмент графика, прилегающий к вертикальной асимптоте <math>\lambda = 2</math>. Видно, что график слишком быстро "выполняет поворот" и для большей части значений <math>\lambda</math> почти горизонтален. Поэтому, применяя метод Ньютона почти к любому начальному приближению <math>\lambda_{0}</math>, мы получаем линейное приближение <math>l(\lambda)</math> с почти горизонтальным графиком и малым положительным угловым коэффициентом. В результате <math>\lambda_{1}</math> является отрицательным числом, огромным по абсолютной величине, которое совершенно бесполезно в качестве приближения к истинному корню.<br />
<br />
[[File:GraphNewton.png|thumb|center|800px|Рис. 2. График функции <math> f(\lambda) = 1 + \frac{10^{-3}}{1 - \lambda} + \frac{10^{-3}}{2 - \lambda} + \frac{10^{-3}}{3 - \lambda} + \frac{10^{-3}}{4 - \lambda}</math>]]<br />
<br />
Чтобы найти выход из этого положения, можно модифицировать метод Ньютона следующим образом: раз <math>f(\lambda)</math> нельзя хорошо приблизить линейной функцией <math>l(\lambda)</math>, попробуем взять в качестве приближения какую-нибудь другую простую функцию <math>h(\lambda)</math>. Нет ничего особого именно в прямых линиях: для метода Ньютона вместо <math>l(\lambda)</math> можно взять любое приближение <math>h(\lambda)</math>, значения и нули которого легко вычисляются. Функция <math>f(\lambda)</math> имеет полюсы в точках <math>d_{i}</math> и <math>d_{i+1}</math>, которые определяют её поведение в соответствующих окрестностях. Поэтому при поиске корня в интервале <math>(d_{i+1}, d_{i})</math> естественно выбрать функцию <math>h(\lambda)</math>, также имеющую эти полюсы, т.е. функцию вида<br />
<math>h(\lambda)= \frac{c_{1}}{d_{i}-\lambda} + \frac{c_{2}}{d_{i+1}-\lambda} + c_{3}</math><br />
<br />
Константы <math>c_{1},c_{2}</math> и <math>c_{3}</math> обеспечивающие, что <math>h(\lambda)</math> есть приближение к <math>f(\lambda)</math>, можно выбрать несколькими способами. Отметим, что если <math>c_{1},c_{2}</math> и <math>c_{3}</math> уже известны, то уравнение <math>h(\lambda)=0</math> легко решается относительно <math>\lambda</math>, поскольку сводится к эквивалентному квадратному уравнению<br />
<math>c_{1}(d_{i+1}-\lambda)+c_{2}(d_{i}-\lambda)+c_{3}(d_{i}-\lambda)(d_{i+1}-\lambda)=0</math><br />
<br />
Пусть <math>\lambda_{j}</math> - приближённое значение корня. определим <math>c_{1},c_{2}</math> и <math>c_{3}</math> так, чтобы<br />
<math>\frac{c_{1}}{d_{i}-\lambda} + \frac{c_{2}}{d_{i+1}-\lambda} + c_{3} = h(\lambda) \approx f(\lambda) = 1 + \rho \sum_{k=1, n} \frac{u_{k}^{2}} {d_{k}-\lambda} </math><br />
<br />
для <math>\lambda</math> в окрестности <math>\lambda_{j}</math>. Заметим, что<br />
<br />
<math>f(\lambda) = 1 + \rho \sum_{k=1, i} \frac{u_{k}^{2}} {d_{k}-\lambda} + \rho \sum_{k=i+1, n} \frac{u_{k}^{2}} {d_{k}-\lambda} \equiv 1 + \psi_{1}(\lambda) + \psi_{2}(\lambda)</math>.<br />
<br />
Если <math>\lambda \in (d_{i+1},d_{i})</math>, то <math>\psi_{1}(\lambda)</math> есть сумма положительных слагаемых, а <math>\psi_{2}(\lambda)</math> - сумма отрицательных. Поэтому и <math>\psi_{1}(\lambda)</math>, и <math>\psi_{2}(\lambda)</math> могут быть вычислены с высокой точностью; однако при их сложении вполне вероятно взаимное уничтожение верных разрядов и потеря относительной точности в сумме. Возьмем числа <math>c_{1}</math> и <math>\hat{c_{1}}</math>, такие, что функция <br />
<br />
<math>h_{1}(\lambda) \equiv \hat{c_{1}} + \frac{c_{1}}{d_{i}-\lambda}</math> удовлетворяет условиям <math>h_{1}(\lambda_{j}) = \psi_{1}(\lambda_{j})</math> и <math>h_{1}^{'}(\lambda_{j})=\psi_{1}^{'}(\lambda_{j})</math> (1)<br />
<br />
Это означает, что гипербола, являющаяся графиком функции <math>h_{1}(\lambda)</math>, касается графика функции <math>\psi_{i}(\lambda)</math> при <math>\lambda = \lambda_{j}</math>. Два условия в (1) - это обычные условия метода Ньютона, за исключением того, что вместо прямой в качестве приближения используется гипербола. Легко проверить, что <math>c_{1}=\psi_{1}^{'}(\lambda_{j})(d_{i} - \lambda_{j})^{2}</math> и <math>\hat{c_{1}}=\psi_{1}(\lambda_{j}) - \psi_{1}^{'}(\lambda_{j})(d_{i} - \lambda_{j})</math><br />
<br />
Подобным же образом выбираем <math>c_{2}</math> и <math>\hat{c_{2}}</math> так, чтобы функция <br />
<br />
<math>h_{2}(\lambda) \equiv \hat{c_{2}} + \frac{c_{2}}{d_{i+1}-\lambda}</math><br />
<br />
Удовлетворяла условиям<br />
<br />
<math>h_{2}(\lambda_{j}) = \psi_{2}(\lambda_{j})</math> и <math>h_{2}^{'}(\lambda_{j})=\psi_{2}^{'}(\lambda_{j})</math> (2)<br />
<br />
Наконец, полагаем<br />
<br />
<math>h(\lambda) = 1 + h_{1}(\lambda) + h_{2}(\lambda) = (1 + \hat{c_{1}} + \hat{c_{2}} + \frac{c_{1}}{d_{i}-\lambda} + \frac{c_{2}}{d_{i+1}-\lambda} </math><br />
<br />
<math>\equiv c_{3} + \frac{c_{1}}{d_{i}-\lambda} + \frac{c_{2}}{d_{i+1}-\lambda}</math>.<br />
<br />
== Вычислительное ядро алгоритма ==<br />
Вычислительным ядром последовательной схемы решения является вычисление матрицы <math>Q</math> собственных векторов путём умножения матрицы <math>Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}</math> на матрицу <math>Q^{'}</math> Данная операция имеет сложность <math>cn^{3}</math> о чём и говорится в разделе [[#Последовательная сложность алгоритма]] .<br />
Ей предшествует вычисление собственных значений и векторов матрицы <math> D + \rho uu^{T}</math><br />
<br />
== Макроструктура алгоритма ==<br />
Ниже описана структура алгоритма, в которой есть блок умножения матриц для вычисления собственных векторов, являющийся вычислительным ядром алгоритма. В соответствующем разделе ([[#Вычислительное ядро алгоритма]]) мы упоминали о том, что данному блоку предшествует вычисление собственных значений, которое производится [https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D0%9D%D1%8C%D1%8E%D1%82%D0%BE%D0%BD%D0%B0 методом Ньютона].<br />
<br />
[[File:DivideAndConquerTree.png|thumb|center|left|800px|Рис. 3. Дерево алгоритма "Разделяй и властвуй"]]<br />
<br />
[[File:InfoGraph.jpg|thumb|center|1200px|Рис. 4. Детальное описание одного блока алгоритма]]<br />
<br />
== Схема реализации последовательного алгоритма ==<br />
''Вычисление собственных значений и собственных векторов симметричной трехдиагональной матрицы посредством стратегии "разделяй и властвуй"'':<br />
<br />
<br />
''proc dc_eig''<math>(T,Q,\Lambda)...</math> по входной матрице <math>T</math> вычисляются выходные матрицы <math>Q</math> и <math>\Lambda</math>, такие, что <math>T = Q\Lambda Q^{T}</math><br />
<br />
'''Если <math>T</math> - матрица размера <math>1</math> x <math>1</math>'''<br />
<br />
1. Присвоить выходным параметрам значения <math> Q = 1, \Lambda = T</math><br />
<br />
'''Иначе'''<br />
<br />
1. Представить <math>T</math> в виде <math> T = \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T} </math><br />
<br />
2. ''call dc_eig''<math>(T_{1},Q_{1},\Lambda_{1})</math><br />
<br />
3. ''call dc_eig''<math>(T_{2},Q_{2},\Lambda_{2})</math><br />
<br />
4. Построить <math>D+\rho uu^{T}</math> по <math> \Lambda_{1},\Lambda_{2}, Q_{1}, Q_{2}</math><br />
<br />
5. Найти матрицу собственных значений <math>\Lambda</math><br />
<br />
6. Найти матрицу собственных векторов <math>Q^{'}</math> для матрицы <math>D+\rho uu^{T}</math><br />
<br />
7. Построить матрицу собственных векторов <math>Q</math> для матрицы <math>T</math> : <math> Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}* Q^{'} </math><br />
<br />
8. Присвоить выходным параметрам значения <math>Q</math> и <math>\Lambda</math><br />
<br />
'''endif'''<br />
<br />
== Последовательная сложность алгоритма ==<br />
Проанализируем сложность алгоритма. Пусть <math>t(n)</math> - число флопов при обработке матрицы размера <math> n x n</math> процедурой ''dc_eig''. Тогда <br />
<br />
<math> t(n) = 2t(n/2) </math> два рекурсивных обращения к ''dc_eig''<math>(T_{i},Q_{i},\Lambda_{i})</math><br />
<br />
<math> +O(n^{2})</math> вычисление собственных значений матрицы <math>D+\rho uu^{T}</math><br />
<br />
<math> +O(n^{2})</math> вычисление собственных векторов матрицы <math>D+\rho uu^{T}</math><br />
<br />
<math> +c*n^{3}</math> вычисление матрицы <math>Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}*Q^{'}</math><br />
<br />
<br />
Если <math> Q_{1}, Q_{2}</math> и <math>Q^{'}</math> рассматриваются как плотные матрицы и используется стандартный алгоритм матричного умножения, то константа <math> c </math> в последней строке равна 1. Таким образом, именно это умножение составляет наиболее трудоёмкую часть алгоритма в целом. Игнорируя члены порядка <math>n^{2}</math>, получаем <math>t(n) = 2t(n/2) + cn^{3}</math>. Решая это разностное уравнение, находим <math> t \approx c\frac{4}{3}n^{3} </math><br />
<br />
На практике константа <math>c</math> обычно гораздо меньше 1, потому что матрица <math>Q^{'}</math> весьма разрежена вследствие явления, называемого дефляцией.<br />
<br />
== Информационный граф ==<br />
В данном разделе на рисунке 5 представлен информационный граф алгоритма.<br />
<br />
[[File:InfoGraphSC.jpg|thumb|center|left|1200px|Рис. 5. Информационный граф алгоритма "Разделяй и властвуй" - шаг <b>Divide</b>]]<br />
<br />
Операции: <br />
<br />
<math>D</math> - операция Divide разделения матрицы <math> T </math> на матрицы <math>T_{1}</math> и <math>T_{2}</math><br />
<br />
Индексы - размерность <br />
<br />
<math>S_{k}</math> - операция Conquer сбора матрицы <math> D </math><br />
<br />
<math> L_{k} </math> - операция поиска собственных значений <br />
<br />
<math> S^{'} </math> - операция поиска собственных векторов матрицы <math> Q^{'} </math><br />
<br />
<math> S </math> - операция поиска собственных векторов матрицы <math> Q </math><br />
<br />
== Ресурс параллелизма алгоритма ==<br />
Рассмотрев информационный граф алгоритма, можно заметить, что в структуре имеется два параллельных блока - вызов рекурсивных функций ''dc_eig'' для вычисления собственных значений и векторов матриц <math>T_{1}</math> и <math>T_{2}</math> - это единственная часть алгоритма, в которой мы прибегаем к параллелизму. <br />
<br />
Рекурсивное разделение матрицы ведёт к иерархии вычислительных подблоков с графом зависимости данных, который выглядит, как двоичное дерево. Данная структура является естественным путем разделения вычислений между процессорами.<br />
<br />
В вершине дерева все процессы взаимодействуют. В каждой ветви дерева вычисление делится на два вычислительных подблока, внутри каждого из которых процессы параллельно взаимодействуют. В листьях деревьев каждый процесс занимается вычислением независимо.<br />
<br />
В случае реализации без параллелизма, функции ''dc_eig'' отрабатывают последовательно - сначала со входными параметрами <math>T_{1}, Q_{1}, \Lambda_{1}</math>, затем - <math>T_{2}, Q_{2}, \Lambda_{2}</math>.<br />
<br />
Таким образом, благодаря параллелизму высота алгоритма параллельного составляет <math>log_{2}(n)</math>, когда как при последовательной реализации высота алгоритма равна сумме геометрической прогрессии <math>1+2+4+8+...+2^{n-1} = 2^{n} - 1</math>, что значительно сокращает число итераций алгоритма.<br />
<br />
== Входные и выходные данные алгоритма ==<br />
'''Входные данные:''' <br />
<br />
На вход алгоритму подаётся трёхдиагональная симметричная матрица:<br />
<br />
<math><br />
L = \begin{bmatrix}<br />
a_{1} & b_{1}&&&&& \\<br />
b_{1} & \ddots & \ddots \\<br />
& \ddots & a_{m-1} & b_{m-1} \\<br />
&& b_{m-1} & a_{m} & b_{m} \\<br />
&&& b_{m} & a_{m+1} & b_{m+1} \\<br />
&&&& b_{m+1} & \ddots \\<br />
&&&&&& \ddots & b_{n-1} \\<br />
&&&&&& b_{n-1} & a_{n} \\<br />
\end{bmatrix}<br />
</math><br />
<br />
'''Объем входных данных:''' <br />
<br />
<math>2n + 1</math> - в силу симметрии, хранить следует только диагональные, поддиагональые и наддиагональные элементы.<br />
<br />
'''Выходные данные:'''<br />
<br />
На выходе мы получаем вектор собственных значений длины <math> n </math> и <math> n </math> собственных векторов длины <math> n </math> , соответствующих собственным значениям исходной матрицы.<br />
<br />
'''Объем выходных данных:'''<br />
<br />
<math> n + n^{2} = n(n + 1) </math><br />
<br />
== Свойства алгоритма ==<br />
Описанный в данной статье алгоритм является самым быстрым алгоритмом, среди существующих: QR / Бисекция и обратная итерация / Разделяй и властвуй.<br />
<br />
Последовательная сложность алгоритма (не принимая во внимание дефляцию) удовлетворяет рекурсивному соотношению: <br />
<br />
<math>t(n) = n^3 +2t(\frac{n}{2})</math><br />
<br />
Решение которого имеет вид:<br />
<br />
<math> t = c\frac{4}{3}n^{3} </math><br />
<br />
На практике же, параллельная сложность алгоритма в силу использования дефляции, позволяющей получить выигрыш в количестве операций, который заключается в ускорении матричного умножения на последнем шаге алгоритма (см. [[#Дефляция]]), имеет следующий вид: <math> O(n^{2.3})</math> или в самых редких случаях <math> O(n^{2}) </math> (см. [3] стр. 8).<br />
<br />
Особенности алгоритма:<br />
<br />
1. Использование дефляции ([[#Дефляция]])<br />
<br />
2. Использование адаптированного метода Ньютона ([[#Макроструктура алгоритма]])<br />
<br />
= Программная реализация алгоритма =<br />
Вторая часть описания алгоритмов в рамках AlgoWiki рассматривает все составные части процесса их реализации. Рассматривается как последовательная реализация алгоритма, так и параллельная. Описывается взаимосвязь свойств программ, реализующих алгоритм, и особенностей архитектуры компьютера, на которой они выполняются. Исследуется работа с памятью, локальность данных и вычислений, описывается масштабируемость и эффективность параллельных программ, производительность компьютеров, достигаемая на данной программе. Обсуждаются особенности реализации для разных классов архитектур компьютеров, приводятся ссылки на реализации в существующих библиотеках.<br />
<br />
<br />
== Особенности реализации последовательного алгоритма ==<br />
<br />
== Локальность данных и вычислений ==<br />
<br />
== Возможные способы и особенности параллельной реализации алгоритма ==<br />
== Масштабируемость алгоритма и его реализации ==<br />
Исследование проводилось на суперкомпьютере "Ломоносов" Суперкомпьютерного комплекса Московского университета.<br />
<br />
Набор и границы значений изменяемых параметров запуска реализации алгоритма: <br />
<br />
* число процессоров [1 : 8] (1,2,3,4,8);<br />
* размер матрицы [4 : 8192].<br />
<br />
Для исследования масштабируемости алгоритм был реализован на библиотеке OpenMP 1.5.5 для языка C++(компилятор g++) на cуперкомпьютере Ломоносов на узле compiler. Для данного узла максимально возможное число потоков - 8. В ходе оценки масштабируемости, программа была запущена в 1, 2, 4, 8 потока. <br />
Параметры компиляции и запуска: <br />
<br />
ssh compiler <br />
module add slurm<br />
module add openmpi/1.5.5-icc<br />
g++ _scratch/test.c++ -fopenmp -std=c++0x -o test <br />
sbatch -p test -n1 run ./test<br />
<br />
Для управления количеством потоков использовалась операция OpenMP omp_set_num_threads();<br />
<br />
[[File:ResultsDiagram.jpg|thumb|center|left|800px|Рис. 6. График времени работы программы в зависимости от числа процессов и размера задачи]]<br />
<br />
Масштабируемость рассматриваемой реализации алгоритма '''"Разделяй и властвуй"''':<br />
<br />
* При увеличении числа процессов общая эффективность программы увеличивается, т.к. время чтения и подготовки исходной матрицы остаётся неизменным, а время работы алгоритма уменьшается, однако рост незначительный.<br />
* При увеличении размерности матрицы общая эффективность программы постепенно уменьшается, т.к. время чтения и подготовки исходных данных растёт быстрее, чем время работы исследуемого алгоритма.<br />
* При одновременном увеличении как числа процессов, так и размерности матрицы общая эффективность программы уменьшается.<br />
<br />
Код исследуемой реализации представлен здесь [http://pastebin.com/QpfYZGkK pastebin.com]<br />
<br />
== Динамические характеристики и эффективность реализации алгоритма ==<br />
<br />
== Выводы для классов архитектур ==<br />
<br />
== Существующие реализации алгоритма ==<br />
Описываемый метод реализован в пакете LAPACK, описание которого можно найти в [http://www.netlib.org/lapack/lawnspdf/lawn132.pdf этой статье] на страницах 7, 19 и 20, которая указана в списке литературы.<br />
<br />
= Литература =<br />
[1] Дж. Деммель, «Вычислительная линейная алгебра» //С. 230-235<br />
<br />
[2] [http://www.netlib.org/utk/people/JackDongarra/PAPERS/104_1999_a-parallel-divide-and-conquer-algorithm.pdf Francoise Tisseury, Jack Dongarra, A Parallel Divide and Conquer Algorithm for the Symmetric Eigenvalue Problem on Distributed Memory Architectures]<br />
<br />
[3] [http://www.netlib.org/lapack/lawnspdf/lawn132.pdf Francoise Tisseury, Jack Dongarra, Parallelizing the Divide and Conquer Algorithm for the Symmetric Tridiagonal Eigenvalue Problem on Distributed Memory Architectures]<br />
<br />
[4] [https://en.wikipedia.org/wiki/Divide-and-conquer_eigenvalue_algorithm Алгоритм "Разделяй и властвуй" - Wikipedia]<br />
<br />
[5] [http://www.cscamm.umd.edu/tadmor/pub/linear-stability/Gill_Tadmor_SISC90.pdf Doron Grill and Eitan Tadmor AN <math>O(N2)</math> METHOD FOR COMPUTING THE EIGENSYSTEM OF <math>N</math>x<math>N</math> SYMMETRIC TRIDIAGONAL MATRICES BY THE DIVIDE AND CONQUER APPROACH]<br />
<br />
[[en:Description of algorithm properties and structure]]</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%C2%AB%D1%80%D0%B0%D0%B7%D0%B4%D0%B5%D0%BB%D1%8F%D0%B9_%D0%B8_%D0%B2%D0%BB%D0%B0%D1%81%D1%82%D0%B2%D1%83%D0%B9%C2%BB_%D0%B2%D1%8B%D1%87%D0%B8%D1%81%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F_%D1%81%D0%BE%D0%B1%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D1%8B%D1%85_%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B9_%D0%B8_%D0%B2%D0%B5%D0%BA%D1%82%D0%BE%D1%80%D0%BE%D0%B2_%D1%81%D0%B8%D0%BC%D0%BC%D0%B5%D1%82%D1%80%D0%B8%D1%87%D0%BD%D0%BE%D0%B9_%D1%82%D1%80%D0%B5%D1%85%D0%B4%D0%B8%D0%B0%D0%B3%D0%BE%D0%BD%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B9_%D0%BC%D0%B0%D1%82%D1%80%D0%B8%D1%86%D1%8B&diff=22578Метод «разделяй и властвуй» вычисления собственных значений и векторов симметричной трехдиагональной матрицы2017-04-29T20:27:38Z<p>Chernyavskiy: /* Решение векового уравнения */</p>
<hr />
<div>Основные авторы описания: [[Участник:Роман_Землянский|Р.Землянский]] (Разделы <br />
[[#Общее описание алгоритма|1.1]], [[#Математическое описание алгоритма|1.2]], [[#Последовательная сложность алгоритма|1.6]], [[#Ресурс параллелизма алгоритма|1.8]], [[#Входные и выходные данные алгоритма|1.9]], [[#Свойства алгоритма|1.10]]), В.Завольсков (Разделы [[#Вычислительное ядро алгоритма|1.3]], [[#Макроструктура алгоритма|1.4]], [[#Схема реализации последовательного алгоритма|1.5]], [[#Информационный граф|1.7]], [[#Существующие реализации алгоритма|2.7]]), [[Участник:IgorS]] (предварительная проверка), [[Участник:Chernyavskiy|А.Ю. Чернявский]] (проверка, редактирование).<br />
<br />
<br />
{{algorithm<br />
| name = Метод "Разделяй и властвуй" вычисления собственных значений и векторов трёхдиагональной матрицы<br />
| serial_complexity = <math> c\frac{4}{3}n^{3} </math><br />
| parallel_complexity = <math> O(n^{2.3}) </math><br />
<br />
крайне редко: <math> O(n^{2}) </math> <br />
| pf_width = <br />
| input_data = <math> 2n + 1 </math><br />
| output_data = <math> n(n + 1) </math><br />
}}<br />
<br />
<br />
= Свойства и структура алгоритмов =<br />
== Общее описание алгоритма ==<br />
'''Метод разделяй и властвуй вычисления собственных значений и векторов трёхдиагональной матрицы''' - это наиболее быстрый из существующих методов, если нужны все собственные значения и собственные векторы трехдиагональной матрицы, начиная с порядка n, примерно равного 26. (Точное значение этого порогового порядка зависит от компьютера.) Его численно устойчивая реализация весьма не тривиальна. В самом деле, хотя впервые метод был предложен еще в 1981 г., "правильный" способ его реализации был найден лишь в 1992 г. Этот способ воплощен LAPACK-программами ssyevd (для плотных матриц) и sstevd (для трехдиагональных матриц). В них стратегия "разделяй-и-влавствуй" используется для матриц порядка, большего чем 25. Для матриц меньшего порядка (или если нужны только собственные значения) происходит автоматический переход к QR-итерации.<br />
<br />
== Математическое описание алгоритма ==<br />
Пусть <br />
<br />
:<math><br />
T = \begin{bmatrix}<br />
a_{1} & b_{1}&&&&& \\<br />
b_{1} & \ddots & \ddots \\<br />
& \ddots & a_{m-1} & b_{m-1} \\<br />
&& b_{m-1} & a_{m} & b_{m} \\<br />
&&& b_{m} & a_{m+1} & b_{m+1} \\<br />
&&&& b_{m+1} & \ddots \\<br />
&&&&&& \ddots & b_{n-1} \\<br />
&&&&&& b_{n-1} & a_{n} \\<br />
\end{bmatrix}<br />
= \begin{bmatrix}<br />
a_{1} & b_{1} &&&&& \\<br />
b_{1} & \ddots & \ddots \\<br />
& \ddots & a_{m-1} & b_{m-1} \\<br />
&& b_{m-1} & a_{m} - b_{m} \\<br />
&&&& a_{m+1} - b_{m} & b_{m+1} \\<br />
&&&& b_{m+1} & \ddots \\<br />
&&&&&& \ddots & b_{n-1} \\<br />
&&&&&& b_{n-1} & a_{n} \\<br />
\end{bmatrix} +<br />
</math><br />
<br />
<math><br />
+ \begin{bmatrix}<br />
&&&&& \\<br />
&&b_{m} & b_{m} \\<br />
&&b_{m} & b_{m} \\<br />
&&&&& \\<br />
\end{bmatrix}<br />
<br />
= \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m} * \begin{bmatrix} 0 \\ \vdots \\ 0 \\ 1 \\ 1 \\ 0 \\ \vdots \\ 0 \end{bmatrix} \begin{bmatrix} 0 , \ldots , 0 , 1 , 1 , 0 \ldots , 0 \end{bmatrix} <br />
<br />
\equiv \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T}<br />
</math><br />
<br />
Предположим, что нам известны спектральные разложения матриц <math>T_{1}</math> и <math> T_{2} </math>: <br />
<math> T_{i} = Q_{i} \Lambda_{i} Q_{i}^{T} </math>. В действительности, они будут рекурсивно вычисляться тем же самым алгоритмом. Установим связь между собственными значениями матрицы Т и собственными значениями матриц<br />
<math>T_{1}</math> и <math>T_{2}</math>. Имеем:<br />
<br />
<math> <br />
T = \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T} <br />
= \begin{bmatrix} Q_{1} \Lambda_{1} Q_{1}^{T} & 0 \\ 0 & Q_{2} \Lambda_{2} Q_{2}^{T}\end{bmatrix} + b_{m}vv^{T} <br />
= \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}(\begin{bmatrix} \Lambda_{1} & \\ & \Lambda_{2}\end{bmatrix} + b_{m}uu^{T})\begin{bmatrix} Q_{1}^{T} & 0 \\ 0 & Q_{2}^{T}\end{bmatrix}<br />
</math>,<br />
<br />
где <br />
<br />
<math><br />
u = \begin{bmatrix} Q_{1}^{T} & 0 \\ 0 & Q_{2}^{T}\end{bmatrix}v<br />
</math><br />
<br />
так как <math>v = \begin{bmatrix} 0 , \ldots , 0 , 1 , 1 , 0 \ldots , 0 \end{bmatrix}^T</math>, получим матрицу, состоящую из последнего столбца матрицы <math> Q_{1}^{T}</math> и первого столбца матрицы <math> Q_{2}^{T}</math>.<br />
<br />
Следовательно, <math>T</math> имеет те же собственные значения, что и подобная ей матрица <math>D + \rho uu^{T}</math>, <br />
где <math>D = \begin{bmatrix} \Lambda_{1} & 0 \\ 0 & \Lambda_{2}\end{bmatrix}</math> - диагональная матрица, <br />
<math>\rho = b_{m}</math> - число, а <math>u</math> - вектор. <br />
<br />
Будем предполагать, не ограничивая общности, что диагональные элементы <math>d_{1}, \ldots, d_{n}</math> матрицы <math>D</math> упорядочены по убыванию: <math>d_{n} <= \ldots <=d_{1}</math>.<br />
<br />
Чтобы найти собственные значения матрицы <math>D + \rho uu^{T}</math>, вычислим её характеристический многочлен, считая пока матрицу <math>D - \lambda I</math> невырожденной.<br />
Тогда<br />
<br />
<math>det(D + \rho uu^{T} - \lambda I) = det((D - \lambda I)(I + \rho (D- \lambda I)^{-1} uu^{T}))</math>.<br />
<br />
Поскольку <math>D - \lambda I</math> невырожденна, <math>det(I + \rho (D - \lambda I)^{-1}uu^{T}) = 0</math> тогда и только тогда, когда <math>\lambda</math> - собственное значение. Заметим, что матрица <math>I + \rho (D - \lambda I)^{-1}uu^{T}</math> получается из единичной добавлением матрицы ранга 1. Определитель такой матрицы легко вычислить.<br />
<br />
'''Лемма 1.''' Справедливо равенство <math>det(I + xy^{T}) = 1 + y^{T}x</math>, где <math>x</math> и <math>y</math> - векторы.<br />
<br />
Таким образом,<br />
<br />
<math>det(I + \rho (D - \lambda I)^{-1}uu^{T}) = 1 + \rho u^{T}(D - \lambda I)^{-1}u</math> <math> = 1 + \rho \sum_{i=1, n} \frac{u_{i}^{2}} {d_{i}-\lambda} \equiv f(\lambda)</math> , <br />
<br />
т.е. собственные значения матрицы <math>T</math> есть корни так называемого векового уравнения <math>f(\lambda) = 0</math>. Если все числа <math>d_{i}</math> различны и все <math>u_{i} <> 0</math> (случай общего положения), то <math>f(\lambda)</math> имеет график типа показанного на рис.1(где <math>n = 4</math> и <math>\rho > 0</math>).<br />
<br />
[[File:Graphics.PNG|thumb|center|800px|Рис. 1. График функции <math> f(\lambda) = 1 + \frac{0.5}{1 - \lambda} + \frac{0.5}{2 - \lambda} + \frac{0.5}{3 - \lambda} + \frac{0.5}{4 - \lambda}</math>]]<br />
<br />
Можно видеть, что прямая <math>y = 1</math> является горизонтальной асимптотой для этого графика, а прямые <math>\lambda = d_{i}</math> есть вертикальные асимптоты. Поскольку <math>f^{'}(\lambda) = \rho \sum_{i=1, n} \frac{u_{i}^{2}} {(d_{i}-\lambda)^{2}}> 0 </math>, функция возрастает всюду, кроме точек <math>\lambda = d_{i}</math>. Поэтому корни функции разделяются числами <math>d_{i}</math> и ещё один корень находится справа от точки <math>d_{1}</math> (на рис. 1 <math>d_{1} = 4</math>). (При <math>\rho<0</math> функция <math>f(\lambda)</math> всюду убывает и соответствующий корень находится слева от точки <math>d_{n}</math>). Для функции <math>f(\lambda)</math>, монотонной и гладкой на каждом из интервалов <math>(d_{i+1},d_{i})</math>, можно найти вариант метода Ньютона, который быстро и монотонно сходится к каждому из корней, если начальная точка взята в <math>(d_{i+1},d_{i})</math>. Нам достаточно знать, что на практике метод сходится к каждому собственному значению за ограниченное число шагов. Поскольку вычисление <math>f(\lambda)</math> и <math>f^{'}(\lambda)</math> стоит <math>O(n)</math> флопов, для вычисления одного собственного значения достаточно <math>O(n)</math>, а для вычисления всех <math>n</math> собственных значений матрицы <math>D + \rho uu^{T}</math> требуется <math>O(n^{2})</math> флопов.<br />
Для собственных векторов матрицы <math>D + \rho uu^{T}</math> мы легко можем получить явные выражения.<br />
<br />
'''Лемма 2.''' Если <math>\alpha</math> - собственное значение матрицы <math>D + \rho uu^{T}</math>, то соответствующий вектор равен <math>(D - \alpha I)^{-1}u</math>. Поскольку матрица <math>D - \alpha I</math> диагональная, для вычисления такого вектора достаточно <math>O(n)</math> флопов.<br />
<br />
Доказательство.<br />
<br />
<math>(D + \rho uu^{T})[(D - \alpha I)^{-1}u] = (D - \alpha I + \alpha I + \rho uu^{T})(D - \alpha I)^{-1}u</math><br />
<br />
<math>=u + \alpha (D - \alpha I)^{-1}u + u[\rho u^{T}(D - \alpha I)^{-1}u] </math><br />
<br />
<math>=u + \alpha(D - \alpha I)^{-1}u - u</math> <br />
<br />
поскольку <math> \rho u^{T}(D - \alpha I)^{-1}u + 1 = f(\alpha) = 0 </math><br />
<br />
<math>=\alpha [(D - \alpha I)^{-1}u]</math>, что и требовалось.<br />
<br />
<br />
Для вычисления по этой простой формуле всех <math>n</math> собственных векторов требуется <math>O(n^{2})</math> флопов. К сожалению, формула не обеспечивает численной устойчивости, так как для двух очень близких значений <math>\alpha_{i}</math> может давать неортогональные приближенные собственные векторы <math>u_{i}</math>. Потребовалось целое десятилетие для того, чтобы найти устойчивую альтернативу исходному описанию алгоритма. Снова детали будут обсуждаться позднее в данном разделе. <br />
<br />
Алгоритм является рекурсивным.<br />
<br />
=== Дефляция ===<br />
<br />
До сих пор полагалось, что все <math>d_{i}</math> различны и все <math>u_{i}</math> отличны от нуля. Если это не так, вековое уравнение <math>f(\lambda)=0</math> имеет <math>k</math> вертикальных асимптот, где <math>k<n</math>, а потому <math>k</math> корней. Однако оказывается, что остальные <math>n - k</math> собственных значений могут быть определены без каких-либо усилий: если <math>d_{i}=d_{i+1}</math> или <math>u_{i}=0</math>, то легко показать, что <math>d_{i}</math> является собственным значением и для матрицы <math>D + \rho uu^{T}</math>. В такой ситуации мы говорим о ''дефляции''. На практике выбирается некоторое пороговое значение и дефляция для числа <math>d_{i}</math> регистрируется, если в смысле этого порога <math>d_{i}</math> достаточно близко к <math>d_{i+1}</math> либо <math>u_{i}</math> достаточно мало.<br />
<br />
Основной выигрыш от использования дефляции состоит не в том, что убыстряется решение векового уравнения - этот этап в любом случае стоит лишь <math>O(n^{2})</math> операций. Выигрыш заключается в ускорении матричного умножения на последнем шаге алгоритма. Действительно, если <math>u_{i}=0</math>, то соответствующий собственный вектор есть i-й столбец <math>e_{i}</math> единичной матрицы. Это означает, что <math>e_{i}</math> является i-м столбцом в матрице <math>Q_{'}</math>, поэтому при формировании матрицы <math>Q</math> посредством левого умножения <math>Q_{1}</math> на <math>Q_{2}</math> вычисление i-го столбца не требует никаких затрат. Аналогичное упрощение имеет место в случае <math>d_{i} = d_{i+1}</math>. При дефляции многих собственных значений устраняется большая часть работы, связанной с матричным умножением.<br />
<br />
=== Решение векового уравнения ===<br />
<br />
Подробно стоит поговорить о решении векового уравнения, которое является одной из основных частей алгоритма.<br />
<br />
Предположим, что некоторое <math>u_{i}</math>, хотя и мало, все же недостаточно мало для того, чтобы была зарегистрирована дефляция. В этом случае применение метода Ньютона к решению векового уравнения встречается с затруднениями. Вспомним, что пересчет приближённого решения <math>u_{j}</math> уравнения <math>f(\lambda) = 0</math> в методе Ньютона основан на следующих положениях:<br />
<br />
1. Вблизи точки <math>\lambda = \lambda_{j}</math> функция <math>f(\lambda)</math> аппроксимируется линейной функцией <math>l(\lambda)</math>; график есть прямая линия, касающаяся графика функции <math>f(\lambda)</math> при <math>\lambda = \lambda_{j}</math>.<br />
<br />
2. В качестве <math>\lambda_{j+1}</math> берётся нуль этого линейного приближения, т.е. <math>l(\lambda_{j+1})=0</math>.<br />
<br />
Функция, показанная на рис.1, не доставляет видимых трудностей методу Ньютона, поскольку вблизи каждого своего нуля <math>f(\lambda)</math> достаточно хорошо аппроксимируется линейными функциями. Однако рассмотрим график функции на рис.2. Она получена из функции на рис. 1 заменой значения .5 для <math>u_{i}^{2}</math> на .001. Это новое значение недостаточно мало для того, чтобы вызвать дефляцию. График функции в левой части рис.2 визуально не отличим от её вертикальных и горизонтальных асимптот, поэтому в правой части укрупненно воспроизведён фрагмент графика, прилегающий к вертикальной асимптоте <math>\lambda = 2</math>. Видно, что график слишком быстро "выполняет поворот" и для большей части значений <math>\lambda</math> почти горизонтален. Поэтому, применяя метод Ньютона почти к любому начальному приближению <math>\lambda_{0}</math>, мы получаем линейное приближение <math>l(\lambda)</math> с почти горизонтальным графиком и малым положительным угловым коэффициентом. В результате <math>\lambda_{1}</math> является отрицательным числом, огромным по абсолютной величине, которое совершенно бесполезно в качестве приближения к истинному корню.<br />
<br />
[[File:GraphNewton.png|thumb|center|800px|Рис. 2. График функции <math> f(\lambda) = 1 + \frac{10^{-3}}{1 - \lambda} + \frac{10^{-3}}{2 - \lambda} + \frac{10^{-3}}{3 - \lambda} + \frac{10^{-3}}{4 - \lambda}</math>]]<br />
<br />
Чтобы найти выход из этого положения, можно модифицировать метод Ньютона следующим образом: раз <math>f(\lambda)</math> нельзя хорошо приблизить линейной функцией <math>l(\lambda)</math>, попробуем взять в качестве приближения какую-нибудь другую простую функцию <math>h(\lambda)</math>. Нет ничего особого именно в прямых линиях: для метода Ньютона вместо <math>l(\lambda)</math> можно взять любое приближение <math>h(\lambda)</math>, значения и нули которого легко вычисляются. Функция <math>f(\lambda)</math> имеет полюсы в точках <math>d_{i}</math> и <math>d_{i+1}</math>, которые определяют её поведение в соответствующих окрестностях. Поэтому при поиске корня в интервале <math>(d_{i+1}, d_{i})</math> естественно выбрать функцию <math>h(\lambda)</math>, также имеющую эти полюсы, т.е. функцию вида<br />
<math>h(\lambda)= \frac{c_{1}}{d_{i}-\lambda} + \frac{c_{2}}{d_{i+1}-\lambda} + c_{3}</math><br />
<br />
Константы <math>c_{1},c_{2}</math> и <math>c_{3}</math> обеспечивающие, что <math>h(\lambda)</math> есть приближение к <math>f(\lambda)</math>, можно выбрать несколькими способами. Отметим, что если <math>c_{1},c_{2}</math> и <math>c_{3}</math> уже известны, то уравнение <math>h(\lambda)=0</math> легко решается относительно <math>\lambda</math>, поскольку сводится к эквивалентному квадратному уравнению<br />
<math>c_{1}(d_{i+1}-\lambda)+c_{2}(d_{i}-\lambda)+c_{3}(d_{i}-\lambda)(d_{i+1}-\lambda)=0</math><br />
<br />
Пусть <math>\lambda_{j}</math> - приближённое значение корня. определим <math>c_{1},c_{2}</math> и <math>c_{3}</math> так, чтобы<br />
<math>\frac{c_{1}}{d_{i}-\lambda} + \frac{c_{2}}{d_{i+1}-\lambda} + c_{3} = h(\lambda) \approx f(\lambda) = 1 + \rho \sum_{k=1, n} \frac{u_{k}^{2}} {d_{k}-\lambda} </math><br />
<br />
для <math>\lambda</math> в окрестности <math>\lambda_{j}</math>. Заметим, что<br />
<br />
<math>f(\lambda) = 1 + \rho \sum_{k=1, i} \frac{u_{k}^{2}} {d_{k}-\lambda} + \rho \sum_{k=i+1, n} \frac{u_{k}^{2}} {d_{k}-\lambda} \equiv 1 + \psi_{1}(\lambda) + \psi_{2}(\lambda)</math>.<br />
<br />
Если <math>\lambda \in (d_{i+1},d_{i})</math>, то <math>\psi_{1}(\lambda)</math> есть сумма положительных слагаемых, а <math>\psi_{2}(\lambda)</math> - сумма отрицательных. Поэтому и <math>\psi_{1}(\lambda)</math>, и <math>\psi_{2}(\lambda)</math> могут быть вычислены с высокой точностью; однако при их сложении вполне вероятно взаимное уничтожение верных разрядов и потеря относительной точности в сумме. Возьмем числа <math>c_{1}</math> и <math>\hat{c_{1}}</math>, такие, что функция <br />
<br />
<math>h_{1}(\lambda) \equiv \hat{c_{1}} + \frac{c_{1}}{d_{i}-\lambda}</math> удовлетворяет условиям <math>h_{1}(\lambda_{j}) = \psi_{1}(\lambda_{j})</math> и <math>h_{1}^{'}(\lambda_{j})=\psi_{1}^{'}(\lambda_{j})</math> (1)<br />
<br />
Это означает, что гипербола, являющаяся графиком функции <math>h_{1}(\lambda)</math>, касается графика функции <math>\psi_{i}(\lambda)</math> при <math>\lambda = \lambda_{j}</math>. Два условия в (1) - это обычные условия метода Ньютона, за исключением того, что вместо прямой в качестве приближения используется гипербола. Легко проверить, что <math>c_{1}=\psi_{1}^{'}(\lambda_{j})(d_{i} - \lambda_{j})^{2}</math> и <math>\hat{c_{1}}=\psi_{1}(\lambda_{j}) - \psi_{1}^{'}(\lambda_{j})(d_{i} - \lambda_{j})</math><br />
<br />
Подобным же образом выбираем <math>c_{2}</math> и <math>\hat{c_{2}}</math> так, чтобы функция <br />
<br />
<math>h_{2}(\lambda) \equiv \hat{c_{2}} + \frac{c_{2}}{d_{i+1}-\lambda}</math><br />
<br />
Удовлетворяла условиям<br />
<br />
<math>h_{2}(\lambda_{j}) = \psi_{2}(\lambda_{j})</math> и <math>h_{2}^{'}(\lambda_{j})=\psi_{2}^{'}(\lambda_{j})</math> (2)<br />
<br />
Наконец, полагаем<br />
<br />
<math>h(\lambda) = 1 + h_{1}(\lambda) + h_{2}(\lambda) = (1 + \hat{c_{1}} + \hat{c_{2}} + \frac{c_{1}}{d_{i}-\lambda} + \frac{c_{2}}{d_{i+1}-\lambda} </math><br />
<br />
<math>\equiv c_{3} + \frac{c_{1}}{d_{i}-\lambda} + \frac{c_{2}}{d_{i+1}-\lambda}</math>.<br />
<br />
== Вычислительное ядро алгоритма ==<br />
Вычислительным ядром последовательной схемы решения является вычисление матрицы <math>Q</math> собственных векторов путём умножения матрицы <math>Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}</math> на матрицу <math>Q^{'}</math> Данная операция имеет сложность <math>cn^{3}</math> о чём и говорится в разделе [[#Последовательная сложность алгоритма]] .<br />
Ей предшествует вычисление собственных значений и векторов матрицы <math> D + \rho uu^{T}</math><br />
<br />
== Макроструктура алгоритма ==<br />
Ниже описана структура алгоритма, в которой есть блок умножения матриц для вычисления собственных векторов, являющийся вычислительным ядром алгоритма. В соответствующем разделе ([[#Вычислительное ядро алгоритма]]) мы упоминали о том, что данному блоку предшествует вычисление собственных значений, которое производится [https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D0%9D%D1%8C%D1%8E%D1%82%D0%BE%D0%BD%D0%B0 методом Ньютона].<br />
<br />
[[File:DivideAndConquerTree.png|thumb|center|left|800px|Рис. 2. Дерево алгоритма "Разделяй и властвуй"]]<br />
<br />
[[File:InfoGraph.jpg|thumb|center|1200px|Рис. 3. Детальное описание одного блока алгоритма]]<br />
<br />
== Схема реализации последовательного алгоритма ==<br />
''Вычисление собственных значений и собственных векторов симметричной трехдиагональной матрицы посредством стратегии "разделяй и властвуй"'':<br />
<br />
<br />
''proc dc_eig''<math>(T,Q,\Lambda)...</math> по входной матрице <math>T</math> вычисляются выходные матрицы <math>Q</math> и <math>\Lambda</math>, такие, что <math>T = Q\Lambda Q^{T}</math><br />
<br />
'''Если <math>T</math> - матрица размера <math>1</math> x <math>1</math>'''<br />
<br />
1. Присвоить выходным параметрам значения <math> Q = 1, \Lambda = T</math><br />
<br />
'''Иначе'''<br />
<br />
1. Представить <math>T</math> в виде <math> T = \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T} </math><br />
<br />
2. ''call dc_eig''<math>(T_{1},Q_{1},\Lambda_{1})</math><br />
<br />
3. ''call dc_eig''<math>(T_{2},Q_{2},\Lambda_{2})</math><br />
<br />
4. Построить <math>D+\rho uu^{T}</math> по <math> \Lambda_{1},\Lambda_{2}, Q_{1}, Q_{2}</math><br />
<br />
5. Найти матрицу собственных значений <math>\Lambda</math><br />
<br />
6. Найти матрицу собственных векторов <math>Q^{'}</math> для матрицы <math>D+\rho uu^{T}</math><br />
<br />
7. Построить матрицу собственных векторов <math>Q</math> для матрицы <math>T</math> : <math> Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}* Q^{'} </math><br />
<br />
8. Присвоить выходным параметрам значения <math>Q</math> и <math>\Lambda</math><br />
<br />
'''endif'''<br />
<br />
== Последовательная сложность алгоритма ==<br />
Проанализируем сложность алгоритма. Пусть <math>t(n)</math> - число флопов при обработке матрицы размера <math> n x n</math> процедурой ''dc_eig''. Тогда <br />
<br />
<math> t(n) = 2t(n/2) </math> два рекурсивных обращения к ''dc_eig''<math>(T_{i},Q_{i},\Lambda_{i})</math><br />
<br />
<math> +O(n^{2})</math> вычисление собственных значений матрицы <math>D+\rho uu^{T}</math><br />
<br />
<math> +O(n^{2})</math> вычисление собственных векторов матрицы <math>D+\rho uu^{T}</math><br />
<br />
<math> +c*n^{3}</math> вычисление матрицы <math>Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}*Q^{'}</math><br />
<br />
<br />
Если <math> Q_{1}, Q_{2}</math> и <math>Q^{'}</math> рассматриваются как плотные матрицы и используется стандартный алгоритм матричного умножения, то константа <math> c </math> в последней строке равна 1. Таким образом, именно это умножение составляет наиболее трудоёмкую часть алгоритма в целом. Игнорируя члены порядка <math>n^{2}</math>, получаем <math>t(n) = 2t(n/2) + cn^{3}</math>. Решая это разностное уравнение, находим <math> t \approx c\frac{4}{3}n^{3} </math><br />
<br />
На практике константа <math>c</math> обычно гораздо меньше 1, потому что матрица <math>Q^{'}</math> весьма разрежена вследствие явления, называемого дефляцией.<br />
<br />
== Информационный граф ==<br />
В данном разделе на рисунке 5 представлен информационный граф алгоритма.<br />
<br />
[[File:InfoGraphSC.jpg|thumb|center|left|1200px|Рис. 5. Информационный граф алгоритма "Разделяй и властвуй" - шаг <b>Divide</b>]]<br />
<br />
Операции: <br />
<br />
<math>D</math> - операция Divide разделения матрицы <math> T </math> на матрицы <math>T_{1}</math> и <math>T_{2}</math><br />
<br />
Индексы - размерность <br />
<br />
<math>S_{k}</math> - операция Conquer сбора матрицы <math> D </math><br />
<br />
<math> L_{k} </math> - операция поиска собственных значений <br />
<br />
<math> S^{'} </math> - операция поиска собственных векторов матрицы <math> Q^{'} </math><br />
<br />
<math> S </math> - операция поиска собственных векторов матрицы <math> Q </math><br />
<br />
== Ресурс параллелизма алгоритма ==<br />
Рассмотрев информационный граф алгоритма, можно заметить, что в структуре имеется два параллельных блока - вызов рекурсивных функций ''dc_eig'' для вычисления собственных значений и векторов матриц <math>T_{1}</math> и <math>T_{2}</math> - это единственная часть алгоритма, в которой мы прибегаем к параллелизму. <br />
<br />
Рекурсивное разделение матрицы ведёт к иерархии вычислительных подблоков с графом зависимости данных, который выглядит, как двоичное дерево. Данная структура является естественным путем разделения вычислений между процессорами.<br />
<br />
В вершине дерева все процессы взаимодействуют. В каждой ветви дерева вычисление делится на два вычислительных подблока, внутри каждого из которых процессы параллельно взаимодействуют. В листьях деревьев каждый процесс занимается вычислением независимо.<br />
<br />
В случае реализации без параллелизма, функции ''dc_eig'' отрабатывают последовательно - сначала со входными параметрами <math>T_{1}, Q_{1}, \Lambda_{1}</math>, затем - <math>T_{2}, Q_{2}, \Lambda_{2}</math>.<br />
<br />
Таким образом, благодаря параллелизму высота алгоритма параллельного составляет <math>log_{2}(n)</math>, когда как при последовательной реализации высота алгоритма равна сумме геометрической прогрессии <math>1+2+4+8+...+2^{n-1} = 2^{n} - 1</math>, что значительно сокращает число итераций алгоритма.<br />
<br />
== Входные и выходные данные алгоритма ==<br />
'''Входные данные:''' <br />
<br />
На вход алгоритму подаётся трёхдиагональная симметричная матрица:<br />
<br />
<math><br />
L = \begin{bmatrix}<br />
a_{1} & b_{1}&&&&& \\<br />
b_{1} & \ddots & \ddots \\<br />
& \ddots & a_{m-1} & b_{m-1} \\<br />
&& b_{m-1} & a_{m} & b_{m} \\<br />
&&& b_{m} & a_{m+1} & b_{m+1} \\<br />
&&&& b_{m+1} & \ddots \\<br />
&&&&&& \ddots & b_{n-1} \\<br />
&&&&&& b_{n-1} & a_{n} \\<br />
\end{bmatrix}<br />
</math><br />
<br />
'''Объем входных данных:''' <br />
<br />
<math>2n + 1</math> - в силу симметрии, хранить следует только диагональные, поддиагональые и наддиагональные элементы.<br />
<br />
'''Выходные данные:'''<br />
<br />
На выходе мы получаем вектор собственных значений длины <math> n </math> и <math> n </math> собственных векторов длины <math> n </math> , соответствующих собственным значениям исходной матрицы.<br />
<br />
'''Объем выходных данных:'''<br />
<br />
<math> n + n^{2} = n(n + 1) </math><br />
<br />
== Свойства алгоритма ==<br />
Описанный в данной статье алгоритм является самым быстрым алгоритмом, среди существующих: QR / Бисекция и обратная итерация / Разделяй и властвуй.<br />
<br />
Последовательная сложность алгоритма (не принимая во внимание дефляцию) удовлетворяет рекурсивному соотношению: <br />
<br />
<math>t(n) = n^3 +2t(\frac{n}{2})</math><br />
<br />
Решение которого имеет вид:<br />
<br />
<math> t = c\frac{4}{3}n^{3} </math><br />
<br />
На практике же, параллельная сложность алгоритма в силу использования дефляции, позволяющей получить выигрыш в количестве операций, который заключается в ускорении матричного умножения на последнем шаге алгоритма (см. [[#Дефляция]]), имеет следующий вид: <math> O(n^{2.3})</math> или в самых редких случаях <math> O(n^{2}) </math> (см. [3] стр. 8).<br />
<br />
Особенности алгоритма:<br />
<br />
1. Использование дефляции ([[#Дефляция]])<br />
<br />
2. Использование адаптированного метода Ньютона ([[#Макроструктура алгоритма]])<br />
<br />
= Программная реализация алгоритма =<br />
Вторая часть описания алгоритмов в рамках AlgoWiki рассматривает все составные части процесса их реализации. Рассматривается как последовательная реализация алгоритма, так и параллельная. Описывается взаимосвязь свойств программ, реализующих алгоритм, и особенностей архитектуры компьютера, на которой они выполняются. Исследуется работа с памятью, локальность данных и вычислений, описывается масштабируемость и эффективность параллельных программ, производительность компьютеров, достигаемая на данной программе. Обсуждаются особенности реализации для разных классов архитектур компьютеров, приводятся ссылки на реализации в существующих библиотеках.<br />
<br />
<br />
== Особенности реализации последовательного алгоритма ==<br />
<br />
== Локальность данных и вычислений ==<br />
<br />
== Возможные способы и особенности параллельной реализации алгоритма ==<br />
== Масштабируемость алгоритма и его реализации ==<br />
Исследование проводилось на суперкомпьютере "Ломоносов" Суперкомпьютерного комплекса Московского университета.<br />
<br />
Набор и границы значений изменяемых параметров запуска реализации алгоритма: <br />
<br />
* число процессоров [1 : 8] (1,2,3,4,8);<br />
* размер матрицы [4 : 8192].<br />
<br />
Для исследования масштабируемости алгоритм был реализован на библиотеке OpenMP 1.5.5 для языка C++(компилятор g++) на cуперкомпьютере Ломоносов на узле compiler. Для данного узла максимально возможное число потоков - 8. В ходе оценки масштабируемости, программа была запущена в 1, 2, 4, 8 потока. <br />
Параметры компиляции и запуска: <br />
<br />
ssh compiler <br />
module add slurm<br />
module add openmpi/1.5.5-icc<br />
g++ _scratch/test.c++ -fopenmp -std=c++0x -o test <br />
sbatch -p test -n1 run ./test<br />
<br />
Для управления количеством потоков использовалась операция OpenMP omp_set_num_threads();<br />
<br />
[[File:ResultsDiagram.jpg|thumb|center|left|800px|Рис. 6. График времени работы программы в зависимости от числа процессов и размера задачи]]<br />
<br />
Масштабируемость рассматриваемой реализации алгоритма '''"Разделяй и властвуй"''':<br />
<br />
* При увеличении числа процессов общая эффективность программы увеличивается, т.к. время чтения и подготовки исходной матрицы остаётся неизменным, а время работы алгоритма уменьшается, однако рост незначительный.<br />
* При увеличении размерности матрицы общая эффективность программы постепенно уменьшается, т.к. время чтения и подготовки исходных данных растёт быстрее, чем время работы исследуемого алгоритма.<br />
* При одновременном увеличении как числа процессов, так и размерности матрицы общая эффективность программы уменьшается.<br />
<br />
Код исследуемой реализации представлен здесь [http://pastebin.com/QpfYZGkK pastebin.com]<br />
<br />
== Динамические характеристики и эффективность реализации алгоритма ==<br />
<br />
== Выводы для классов архитектур ==<br />
<br />
== Существующие реализации алгоритма ==<br />
Описываемый метод реализован в пакете LAPACK, описание которого можно найти в [http://www.netlib.org/lapack/lawnspdf/lawn132.pdf этой статье] на страницах 7, 19 и 20, которая указана в списке литературы.<br />
<br />
= Литература =<br />
[1] Дж. Деммель, «Вычислительная линейная алгебра» //С. 230-235<br />
<br />
[2] [http://www.netlib.org/utk/people/JackDongarra/PAPERS/104_1999_a-parallel-divide-and-conquer-algorithm.pdf Francoise Tisseury, Jack Dongarra, A Parallel Divide and Conquer Algorithm for the Symmetric Eigenvalue Problem on Distributed Memory Architectures]<br />
<br />
[3] [http://www.netlib.org/lapack/lawnspdf/lawn132.pdf Francoise Tisseury, Jack Dongarra, Parallelizing the Divide and Conquer Algorithm for the Symmetric Tridiagonal Eigenvalue Problem on Distributed Memory Architectures]<br />
<br />
[4] [https://en.wikipedia.org/wiki/Divide-and-conquer_eigenvalue_algorithm Алгоритм "Разделяй и властвуй" - Wikipedia]<br />
<br />
[5] [http://www.cscamm.umd.edu/tadmor/pub/linear-stability/Gill_Tadmor_SISC90.pdf Doron Grill and Eitan Tadmor AN <math>O(N2)</math> METHOD FOR COMPUTING THE EIGENSYSTEM OF <math>N</math>x<math>N</math> SYMMETRIC TRIDIAGONAL MATRICES BY THE DIVIDE AND CONQUER APPROACH]<br />
<br />
[[en:Description of algorithm properties and structure]]</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%C2%AB%D1%80%D0%B0%D0%B7%D0%B4%D0%B5%D0%BB%D1%8F%D0%B9_%D0%B8_%D0%B2%D0%BB%D0%B0%D1%81%D1%82%D0%B2%D1%83%D0%B9%C2%BB_%D0%B2%D1%8B%D1%87%D0%B8%D1%81%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F_%D1%81%D0%BE%D0%B1%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D1%8B%D1%85_%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B9_%D0%B8_%D0%B2%D0%B5%D0%BA%D1%82%D0%BE%D1%80%D0%BE%D0%B2_%D1%81%D0%B8%D0%BC%D0%BC%D0%B5%D1%82%D1%80%D0%B8%D1%87%D0%BD%D0%BE%D0%B9_%D1%82%D1%80%D0%B5%D1%85%D0%B4%D0%B8%D0%B0%D0%B3%D0%BE%D0%BD%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B9_%D0%BC%D0%B0%D1%82%D1%80%D0%B8%D1%86%D1%8B&diff=22577Метод «разделяй и властвуй» вычисления собственных значений и векторов симметричной трехдиагональной матрицы2017-04-29T20:26:54Z<p>Chernyavskiy: /* ЧАСТЬ. Программная реализация алгоритма */</p>
<hr />
<div>Основные авторы описания: [[Участник:Роман_Землянский|Р.Землянский]] (Разделы <br />
[[#Общее описание алгоритма|1.1]], [[#Математическое описание алгоритма|1.2]], [[#Последовательная сложность алгоритма|1.6]], [[#Ресурс параллелизма алгоритма|1.8]], [[#Входные и выходные данные алгоритма|1.9]], [[#Свойства алгоритма|1.10]]), В.Завольсков (Разделы [[#Вычислительное ядро алгоритма|1.3]], [[#Макроструктура алгоритма|1.4]], [[#Схема реализации последовательного алгоритма|1.5]], [[#Информационный граф|1.7]], [[#Существующие реализации алгоритма|2.7]]), [[Участник:IgorS]] (предварительная проверка), [[Участник:Chernyavskiy|А.Ю. Чернявский]] (проверка, редактирование).<br />
<br />
<br />
{{algorithm<br />
| name = Метод "Разделяй и властвуй" вычисления собственных значений и векторов трёхдиагональной матрицы<br />
| serial_complexity = <math> c\frac{4}{3}n^{3} </math><br />
| parallel_complexity = <math> O(n^{2.3}) </math><br />
<br />
крайне редко: <math> O(n^{2}) </math> <br />
| pf_width = <br />
| input_data = <math> 2n + 1 </math><br />
| output_data = <math> n(n + 1) </math><br />
}}<br />
<br />
<br />
= Свойства и структура алгоритмов =<br />
== Общее описание алгоритма ==<br />
'''Метод разделяй и властвуй вычисления собственных значений и векторов трёхдиагональной матрицы''' - это наиболее быстрый из существующих методов, если нужны все собственные значения и собственные векторы трехдиагональной матрицы, начиная с порядка n, примерно равного 26. (Точное значение этого порогового порядка зависит от компьютера.) Его численно устойчивая реализация весьма не тривиальна. В самом деле, хотя впервые метод был предложен еще в 1981 г., "правильный" способ его реализации был найден лишь в 1992 г. Этот способ воплощен LAPACK-программами ssyevd (для плотных матриц) и sstevd (для трехдиагональных матриц). В них стратегия "разделяй-и-влавствуй" используется для матриц порядка, большего чем 25. Для матриц меньшего порядка (или если нужны только собственные значения) происходит автоматический переход к QR-итерации.<br />
<br />
== Математическое описание алгоритма ==<br />
Пусть <br />
<br />
:<math><br />
T = \begin{bmatrix}<br />
a_{1} & b_{1}&&&&& \\<br />
b_{1} & \ddots & \ddots \\<br />
& \ddots & a_{m-1} & b_{m-1} \\<br />
&& b_{m-1} & a_{m} & b_{m} \\<br />
&&& b_{m} & a_{m+1} & b_{m+1} \\<br />
&&&& b_{m+1} & \ddots \\<br />
&&&&&& \ddots & b_{n-1} \\<br />
&&&&&& b_{n-1} & a_{n} \\<br />
\end{bmatrix}<br />
= \begin{bmatrix}<br />
a_{1} & b_{1} &&&&& \\<br />
b_{1} & \ddots & \ddots \\<br />
& \ddots & a_{m-1} & b_{m-1} \\<br />
&& b_{m-1} & a_{m} - b_{m} \\<br />
&&&& a_{m+1} - b_{m} & b_{m+1} \\<br />
&&&& b_{m+1} & \ddots \\<br />
&&&&&& \ddots & b_{n-1} \\<br />
&&&&&& b_{n-1} & a_{n} \\<br />
\end{bmatrix} +<br />
</math><br />
<br />
<math><br />
+ \begin{bmatrix}<br />
&&&&& \\<br />
&&b_{m} & b_{m} \\<br />
&&b_{m} & b_{m} \\<br />
&&&&& \\<br />
\end{bmatrix}<br />
<br />
= \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m} * \begin{bmatrix} 0 \\ \vdots \\ 0 \\ 1 \\ 1 \\ 0 \\ \vdots \\ 0 \end{bmatrix} \begin{bmatrix} 0 , \ldots , 0 , 1 , 1 , 0 \ldots , 0 \end{bmatrix} <br />
<br />
\equiv \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T}<br />
</math><br />
<br />
Предположим, что нам известны спектральные разложения матриц <math>T_{1}</math> и <math> T_{2} </math>: <br />
<math> T_{i} = Q_{i} \Lambda_{i} Q_{i}^{T} </math>. В действительности, они будут рекурсивно вычисляться тем же самым алгоритмом. Установим связь между собственными значениями матрицы Т и собственными значениями матриц<br />
<math>T_{1}</math> и <math>T_{2}</math>. Имеем:<br />
<br />
<math> <br />
T = \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T} <br />
= \begin{bmatrix} Q_{1} \Lambda_{1} Q_{1}^{T} & 0 \\ 0 & Q_{2} \Lambda_{2} Q_{2}^{T}\end{bmatrix} + b_{m}vv^{T} <br />
= \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}(\begin{bmatrix} \Lambda_{1} & \\ & \Lambda_{2}\end{bmatrix} + b_{m}uu^{T})\begin{bmatrix} Q_{1}^{T} & 0 \\ 0 & Q_{2}^{T}\end{bmatrix}<br />
</math>,<br />
<br />
где <br />
<br />
<math><br />
u = \begin{bmatrix} Q_{1}^{T} & 0 \\ 0 & Q_{2}^{T}\end{bmatrix}v<br />
</math><br />
<br />
так как <math>v = \begin{bmatrix} 0 , \ldots , 0 , 1 , 1 , 0 \ldots , 0 \end{bmatrix}^T</math>, получим матрицу, состоящую из последнего столбца матрицы <math> Q_{1}^{T}</math> и первого столбца матрицы <math> Q_{2}^{T}</math>.<br />
<br />
Следовательно, <math>T</math> имеет те же собственные значения, что и подобная ей матрица <math>D + \rho uu^{T}</math>, <br />
где <math>D = \begin{bmatrix} \Lambda_{1} & 0 \\ 0 & \Lambda_{2}\end{bmatrix}</math> - диагональная матрица, <br />
<math>\rho = b_{m}</math> - число, а <math>u</math> - вектор. <br />
<br />
Будем предполагать, не ограничивая общности, что диагональные элементы <math>d_{1}, \ldots, d_{n}</math> матрицы <math>D</math> упорядочены по убыванию: <math>d_{n} <= \ldots <=d_{1}</math>.<br />
<br />
Чтобы найти собственные значения матрицы <math>D + \rho uu^{T}</math>, вычислим её характеристический многочлен, считая пока матрицу <math>D - \lambda I</math> невырожденной.<br />
Тогда<br />
<br />
<math>det(D + \rho uu^{T} - \lambda I) = det((D - \lambda I)(I + \rho (D- \lambda I)^{-1} uu^{T}))</math>.<br />
<br />
Поскольку <math>D - \lambda I</math> невырожденна, <math>det(I + \rho (D - \lambda I)^{-1}uu^{T}) = 0</math> тогда и только тогда, когда <math>\lambda</math> - собственное значение. Заметим, что матрица <math>I + \rho (D - \lambda I)^{-1}uu^{T}</math> получается из единичной добавлением матрицы ранга 1. Определитель такой матрицы легко вычислить.<br />
<br />
'''Лемма 1.''' Справедливо равенство <math>det(I + xy^{T}) = 1 + y^{T}x</math>, где <math>x</math> и <math>y</math> - векторы.<br />
<br />
Таким образом,<br />
<br />
<math>det(I + \rho (D - \lambda I)^{-1}uu^{T}) = 1 + \rho u^{T}(D - \lambda I)^{-1}u</math> <math> = 1 + \rho \sum_{i=1, n} \frac{u_{i}^{2}} {d_{i}-\lambda} \equiv f(\lambda)</math> , <br />
<br />
т.е. собственные значения матрицы <math>T</math> есть корни так называемого векового уравнения <math>f(\lambda) = 0</math>. Если все числа <math>d_{i}</math> различны и все <math>u_{i} <> 0</math> (случай общего положения), то <math>f(\lambda)</math> имеет график типа показанного на рис.1(где <math>n = 4</math> и <math>\rho > 0</math>).<br />
<br />
[[File:Graphics.PNG|thumb|center|800px|Рис. 1. График функции <math> f(\lambda) = 1 + \frac{0.5}{1 - \lambda} + \frac{0.5}{2 - \lambda} + \frac{0.5}{3 - \lambda} + \frac{0.5}{4 - \lambda}</math>]]<br />
<br />
Можно видеть, что прямая <math>y = 1</math> является горизонтальной асимптотой для этого графика, а прямые <math>\lambda = d_{i}</math> есть вертикальные асимптоты. Поскольку <math>f^{'}(\lambda) = \rho \sum_{i=1, n} \frac{u_{i}^{2}} {(d_{i}-\lambda)^{2}}> 0 </math>, функция возрастает всюду, кроме точек <math>\lambda = d_{i}</math>. Поэтому корни функции разделяются числами <math>d_{i}</math> и ещё один корень находится справа от точки <math>d_{1}</math> (на рис. 1 <math>d_{1} = 4</math>). (При <math>\rho<0</math> функция <math>f(\lambda)</math> всюду убывает и соответствующий корень находится слева от точки <math>d_{n}</math>). Для функции <math>f(\lambda)</math>, монотонной и гладкой на каждом из интервалов <math>(d_{i+1},d_{i})</math>, можно найти вариант метода Ньютона, который быстро и монотонно сходится к каждому из корней, если начальная точка взята в <math>(d_{i+1},d_{i})</math>. Нам достаточно знать, что на практике метод сходится к каждому собственному значению за ограниченное число шагов. Поскольку вычисление <math>f(\lambda)</math> и <math>f^{'}(\lambda)</math> стоит <math>O(n)</math> флопов, для вычисления одного собственного значения достаточно <math>O(n)</math>, а для вычисления всех <math>n</math> собственных значений матрицы <math>D + \rho uu^{T}</math> требуется <math>O(n^{2})</math> флопов.<br />
Для собственных векторов матрицы <math>D + \rho uu^{T}</math> мы легко можем получить явные выражения.<br />
<br />
'''Лемма 2.''' Если <math>\alpha</math> - собственное значение матрицы <math>D + \rho uu^{T}</math>, то соответствующий вектор равен <math>(D - \alpha I)^{-1}u</math>. Поскольку матрица <math>D - \alpha I</math> диагональная, для вычисления такого вектора достаточно <math>O(n)</math> флопов.<br />
<br />
Доказательство.<br />
<br />
<math>(D + \rho uu^{T})[(D - \alpha I)^{-1}u] = (D - \alpha I + \alpha I + \rho uu^{T})(D - \alpha I)^{-1}u</math><br />
<br />
<math>=u + \alpha (D - \alpha I)^{-1}u + u[\rho u^{T}(D - \alpha I)^{-1}u] </math><br />
<br />
<math>=u + \alpha(D - \alpha I)^{-1}u - u</math> <br />
<br />
поскольку <math> \rho u^{T}(D - \alpha I)^{-1}u + 1 = f(\alpha) = 0 </math><br />
<br />
<math>=\alpha [(D - \alpha I)^{-1}u]</math>, что и требовалось.<br />
<br />
<br />
Для вычисления по этой простой формуле всех <math>n</math> собственных векторов требуется <math>O(n^{2})</math> флопов. К сожалению, формула не обеспечивает численной устойчивости, так как для двух очень близких значений <math>\alpha_{i}</math> может давать неортогональные приближенные собственные векторы <math>u_{i}</math>. Потребовалось целое десятилетие для того, чтобы найти устойчивую альтернативу исходному описанию алгоритма. Снова детали будут обсуждаться позднее в данном разделе. <br />
<br />
Алгоритм является рекурсивным.<br />
<br />
=== Дефляция ===<br />
<br />
До сих пор полагалось, что все <math>d_{i}</math> различны и все <math>u_{i}</math> отличны от нуля. Если это не так, вековое уравнение <math>f(\lambda)=0</math> имеет <math>k</math> вертикальных асимптот, где <math>k<n</math>, а потому <math>k</math> корней. Однако оказывается, что остальные <math>n - k</math> собственных значений могут быть определены без каких-либо усилий: если <math>d_{i}=d_{i+1}</math> или <math>u_{i}=0</math>, то легко показать, что <math>d_{i}</math> является собственным значением и для матрицы <math>D + \rho uu^{T}</math>. В такой ситуации мы говорим о ''дефляции''. На практике выбирается некоторое пороговое значение и дефляция для числа <math>d_{i}</math> регистрируется, если в смысле этого порога <math>d_{i}</math> достаточно близко к <math>d_{i+1}</math> либо <math>u_{i}</math> достаточно мало.<br />
<br />
Основной выигрыш от использования дефляции состоит не в том, что убыстряется решение векового уравнения - этот этап в любом случае стоит лишь <math>O(n^{2})</math> операций. Выигрыш заключается в ускорении матричного умножения на последнем шаге алгоритма. Действительно, если <math>u_{i}=0</math>, то соответствующий собственный вектор есть i-й столбец <math>e_{i}</math> единичной матрицы. Это означает, что <math>e_{i}</math> является i-м столбцом в матрице <math>Q_{'}</math>, поэтому при формировании матрицы <math>Q</math> посредством левого умножения <math>Q_{1}</math> на <math>Q_{2}</math> вычисление i-го столбца не требует никаких затрат. Аналогичное упрощение имеет место в случае <math>d_{i} = d_{i+1}</math>. При дефляции многих собственных значений устраняется большая часть работы, связанной с матричным умножением.<br />
<br />
=== Решение векового уравнения ===<br />
<br />
Подробно стоит поговорить о решении векового уравнения, которое является одной из основных частей алгоритма.<br />
<br />
Предположим, что некоторое <math>u_{i}</math>, хотя и мало, все же недостаточно мало для того, чтобы была зарегистрирована дефляция. В этом случае применение метода Ньютона к решению векового уравнения встречается с затруднениями. Вспомним, что пересчет приближённого решения <math>u_{j}</math> уравнения <math>f(\lambda) = 0</math> в методе Ньютона основан на следующих положениях:<br />
<br />
1. Вблизи точки <math>\lambda = \lambda_{j}</math> функция <math>f(\lambda)</math> аппроксимируется линейной функцией <math>l(\lambda)</math>; график есть прямая линия, касающаяся графика функции <math>f(\lambda)</math> при <math>\lambda = \lambda_{j}</math>.<br />
<br />
2. В качестве <math>\lambda_{j+1}</math> берётся нуль этого линейного приближения, т.е. <math>l(\lambda_{j+1})=0</math>.<br />
<br />
Функция, показанная на рис.1, не доставляет видимых трудностей методу Ньютона, поскольку вблизи каждого своего нуля <math>f(\lambda)</math> достаточно хорошо аппроксимируется линейными функциями. Однако рассмотрим график функции на рис. 4. Она получена из функции на рис. 1 заменой значения .5 для <math>u_{i}^{2}</math> на .001. Это новое значение недостаточно мало для того, чтобы вызвать дефляцию. График функции в левой части рис.4 визуально не отличим от её вертикальных и горизонтальных асимптот, поэтому в правой части укрупненно воспроизведён фрагмент графика, прилегающий к вертикальной асимптоте <math>\lambda = 2</math>. Видно, что график слишком быстро "выполняет поворот" и для большей части значений <math>\lambda</math> почти горизонтален. Поэтому, применяя метод Ньютона почти к любому начальному приближению <math>\lambda_{0}</math>, мы получаем линейное приближение <math>l(\lambda)</math> с почти горизонтальным графиком и малым положительным угловым коэффициентом. В результате <math>\lambda_{1}</math> является отрицательным числом, огромным по абсолютной величине, которое совершенно бесполезно в качестве приближения к истинному корню.<br />
<br />
[[File:GraphNewton.png|thumb|center|800px|Рис. 4. График функции <math> f(\lambda) = 1 + \frac{10^{-3}}{1 - \lambda} + \frac{10^{-3}}{2 - \lambda} + \frac{10^{-3}}{3 - \lambda} + \frac{10^{-3}}{4 - \lambda}</math>]]<br />
<br />
Чтобы найти выход из этого положения, можно модифицировать метод Ньютона следующим образом: раз <math>f(\lambda)</math> нельзя хорошо приблизить линейной функцией <math>l(\lambda)</math>, попробуем взять в качестве приближения какую-нибудь другую простую функцию <math>h(\lambda)</math>. Нет ничего особого именно в прямых линиях: для метода Ньютона вместо <math>l(\lambda)</math> можно взять любое приближение <math>h(\lambda)</math>, значения и нули которого легко вычисляются. Функция <math>f(\lambda)</math> имеет полюсы в точках <math>d_{i}</math> и <math>d_{i+1}</math>, которые определяют её поведение в соответствующих окрестностях. Поэтому при поиске корня в интервале <math>(d_{i+1}, d_{i})</math> естественно выбрать функцию <math>h(\lambda)</math>, также имеющую эти полюсы, т.е. функцию вида<br />
<math>h(\lambda)= \frac{c_{1}}{d_{i}-\lambda} + \frac{c_{2}}{d_{i+1}-\lambda} + c_{3}</math><br />
<br />
Константы <math>c_{1},c_{2}</math> и <math>c_{3}</math> обеспечивающие, что <math>h(\lambda)</math> есть приближение к <math>f(\lambda)</math>, можно выбрать несколькими способами. Отметим, что если <math>c_{1},c_{2}</math> и <math>c_{3}</math> уже известны, то уравнение <math>h(\lambda)=0</math> легко решается относительно <math>\lambda</math>, поскольку сводится к эквивалентному квадратному уравнению<br />
<math>c_{1}(d_{i+1}-\lambda)+c_{2}(d_{i}-\lambda)+c_{3}(d_{i}-\lambda)(d_{i+1}-\lambda)=0</math><br />
<br />
Пусть <math>\lambda_{j}</math> - приближённое значение корня. определим <math>c_{1},c_{2}</math> и <math>c_{3}</math> так, чтобы<br />
<math>\frac{c_{1}}{d_{i}-\lambda} + \frac{c_{2}}{d_{i+1}-\lambda} + c_{3} = h(\lambda) \approx f(\lambda) = 1 + \rho \sum_{k=1, n} \frac{u_{k}^{2}} {d_{k}-\lambda} </math><br />
<br />
для <math>\lambda</math> в окрестности <math>\lambda_{j}</math>. Заметим, что<br />
<br />
<math>f(\lambda) = 1 + \rho \sum_{k=1, i} \frac{u_{k}^{2}} {d_{k}-\lambda} + \rho \sum_{k=i+1, n} \frac{u_{k}^{2}} {d_{k}-\lambda} \equiv 1 + \psi_{1}(\lambda) + \psi_{2}(\lambda)</math>.<br />
<br />
Если <math>\lambda \in (d_{i+1},d_{i})</math>, то <math>\psi_{1}(\lambda)</math> есть сумма положительных слагаемых, а <math>\psi_{2}(\lambda)</math> - сумма отрицательных. Поэтому и <math>\psi_{1}(\lambda)</math>, и <math>\psi_{2}(\lambda)</math> могут быть вычислены с высокой точностью; однако при их сложении вполне вероятно взаимное уничтожение верных разрядов и потеря относительной точности в сумме. Возьмем числа <math>c_{1}</math> и <math>\hat{c_{1}}</math>, такие, что функция <br />
<br />
<math>h_{1}(\lambda) \equiv \hat{c_{1}} + \frac{c_{1}}{d_{i}-\lambda}</math> удовлетворяет условиям <math>h_{1}(\lambda_{j}) = \psi_{1}(\lambda_{j})</math> и <math>h_{1}^{'}(\lambda_{j})=\psi_{1}^{'}(\lambda_{j})</math> (1)<br />
<br />
Это означает, что гипербола, являющаяся графиком функции <math>h_{1}(\lambda)</math>, касается графика функции <math>\psi_{i}(\lambda)</math> при <math>\lambda = \lambda_{j}</math>. Два условия в (1) - это обычные условия метода Ньютона, за исключением того, что вместо прямой в качестве приближения используется гипербола. Легко проверить, что <math>c_{1}=\psi_{1}^{'}(\lambda_{j})(d_{i} - \lambda_{j})^{2}</math> и <math>\hat{c_{1}}=\psi_{1}(\lambda_{j}) - \psi_{1}^{'}(\lambda_{j})(d_{i} - \lambda_{j})</math><br />
<br />
Подобным же образом выбираем <math>c_{2}</math> и <math>\hat{c_{2}}</math> так, чтобы функция <br />
<br />
<math>h_{2}(\lambda) \equiv \hat{c_{2}} + \frac{c_{2}}{d_{i+1}-\lambda}</math><br />
<br />
Удовлетворяла условиям<br />
<br />
<math>h_{2}(\lambda_{j}) = \psi_{2}(\lambda_{j})</math> и <math>h_{2}^{'}(\lambda_{j})=\psi_{2}^{'}(\lambda_{j})</math> (2)<br />
<br />
Наконец, полагаем<br />
<br />
<math>h(\lambda) = 1 + h_{1}(\lambda) + h_{2}(\lambda) = (1 + \hat{c_{1}} + \hat{c_{2}} + \frac{c_{1}}{d_{i}-\lambda} + \frac{c_{2}}{d_{i+1}-\lambda} </math><br />
<br />
<math>\equiv c_{3} + \frac{c_{1}}{d_{i}-\lambda} + \frac{c_{2}}{d_{i+1}-\lambda}</math>.<br />
<br />
== Вычислительное ядро алгоритма ==<br />
Вычислительным ядром последовательной схемы решения является вычисление матрицы <math>Q</math> собственных векторов путём умножения матрицы <math>Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}</math> на матрицу <math>Q^{'}</math> Данная операция имеет сложность <math>cn^{3}</math> о чём и говорится в разделе [[#Последовательная сложность алгоритма]] .<br />
Ей предшествует вычисление собственных значений и векторов матрицы <math> D + \rho uu^{T}</math><br />
<br />
== Макроструктура алгоритма ==<br />
Ниже описана структура алгоритма, в которой есть блок умножения матриц для вычисления собственных векторов, являющийся вычислительным ядром алгоритма. В соответствующем разделе ([[#Вычислительное ядро алгоритма]]) мы упоминали о том, что данному блоку предшествует вычисление собственных значений, которое производится [https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D0%9D%D1%8C%D1%8E%D1%82%D0%BE%D0%BD%D0%B0 методом Ньютона].<br />
<br />
[[File:DivideAndConquerTree.png|thumb|center|left|800px|Рис. 2. Дерево алгоритма "Разделяй и властвуй"]]<br />
<br />
[[File:InfoGraph.jpg|thumb|center|1200px|Рис. 3. Детальное описание одного блока алгоритма]]<br />
<br />
== Схема реализации последовательного алгоритма ==<br />
''Вычисление собственных значений и собственных векторов симметричной трехдиагональной матрицы посредством стратегии "разделяй и властвуй"'':<br />
<br />
<br />
''proc dc_eig''<math>(T,Q,\Lambda)...</math> по входной матрице <math>T</math> вычисляются выходные матрицы <math>Q</math> и <math>\Lambda</math>, такие, что <math>T = Q\Lambda Q^{T}</math><br />
<br />
'''Если <math>T</math> - матрица размера <math>1</math> x <math>1</math>'''<br />
<br />
1. Присвоить выходным параметрам значения <math> Q = 1, \Lambda = T</math><br />
<br />
'''Иначе'''<br />
<br />
1. Представить <math>T</math> в виде <math> T = \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T} </math><br />
<br />
2. ''call dc_eig''<math>(T_{1},Q_{1},\Lambda_{1})</math><br />
<br />
3. ''call dc_eig''<math>(T_{2},Q_{2},\Lambda_{2})</math><br />
<br />
4. Построить <math>D+\rho uu^{T}</math> по <math> \Lambda_{1},\Lambda_{2}, Q_{1}, Q_{2}</math><br />
<br />
5. Найти матрицу собственных значений <math>\Lambda</math><br />
<br />
6. Найти матрицу собственных векторов <math>Q^{'}</math> для матрицы <math>D+\rho uu^{T}</math><br />
<br />
7. Построить матрицу собственных векторов <math>Q</math> для матрицы <math>T</math> : <math> Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}* Q^{'} </math><br />
<br />
8. Присвоить выходным параметрам значения <math>Q</math> и <math>\Lambda</math><br />
<br />
'''endif'''<br />
<br />
== Последовательная сложность алгоритма ==<br />
Проанализируем сложность алгоритма. Пусть <math>t(n)</math> - число флопов при обработке матрицы размера <math> n x n</math> процедурой ''dc_eig''. Тогда <br />
<br />
<math> t(n) = 2t(n/2) </math> два рекурсивных обращения к ''dc_eig''<math>(T_{i},Q_{i},\Lambda_{i})</math><br />
<br />
<math> +O(n^{2})</math> вычисление собственных значений матрицы <math>D+\rho uu^{T}</math><br />
<br />
<math> +O(n^{2})</math> вычисление собственных векторов матрицы <math>D+\rho uu^{T}</math><br />
<br />
<math> +c*n^{3}</math> вычисление матрицы <math>Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}*Q^{'}</math><br />
<br />
<br />
Если <math> Q_{1}, Q_{2}</math> и <math>Q^{'}</math> рассматриваются как плотные матрицы и используется стандартный алгоритм матричного умножения, то константа <math> c </math> в последней строке равна 1. Таким образом, именно это умножение составляет наиболее трудоёмкую часть алгоритма в целом. Игнорируя члены порядка <math>n^{2}</math>, получаем <math>t(n) = 2t(n/2) + cn^{3}</math>. Решая это разностное уравнение, находим <math> t \approx c\frac{4}{3}n^{3} </math><br />
<br />
На практике константа <math>c</math> обычно гораздо меньше 1, потому что матрица <math>Q^{'}</math> весьма разрежена вследствие явления, называемого дефляцией.<br />
<br />
== Информационный граф ==<br />
В данном разделе на рисунке 5 представлен информационный граф алгоритма.<br />
<br />
[[File:InfoGraphSC.jpg|thumb|center|left|1200px|Рис. 5. Информационный граф алгоритма "Разделяй и властвуй" - шаг <b>Divide</b>]]<br />
<br />
Операции: <br />
<br />
<math>D</math> - операция Divide разделения матрицы <math> T </math> на матрицы <math>T_{1}</math> и <math>T_{2}</math><br />
<br />
Индексы - размерность <br />
<br />
<math>S_{k}</math> - операция Conquer сбора матрицы <math> D </math><br />
<br />
<math> L_{k} </math> - операция поиска собственных значений <br />
<br />
<math> S^{'} </math> - операция поиска собственных векторов матрицы <math> Q^{'} </math><br />
<br />
<math> S </math> - операция поиска собственных векторов матрицы <math> Q </math><br />
<br />
== Ресурс параллелизма алгоритма ==<br />
Рассмотрев информационный граф алгоритма, можно заметить, что в структуре имеется два параллельных блока - вызов рекурсивных функций ''dc_eig'' для вычисления собственных значений и векторов матриц <math>T_{1}</math> и <math>T_{2}</math> - это единственная часть алгоритма, в которой мы прибегаем к параллелизму. <br />
<br />
Рекурсивное разделение матрицы ведёт к иерархии вычислительных подблоков с графом зависимости данных, который выглядит, как двоичное дерево. Данная структура является естественным путем разделения вычислений между процессорами.<br />
<br />
В вершине дерева все процессы взаимодействуют. В каждой ветви дерева вычисление делится на два вычислительных подблока, внутри каждого из которых процессы параллельно взаимодействуют. В листьях деревьев каждый процесс занимается вычислением независимо.<br />
<br />
В случае реализации без параллелизма, функции ''dc_eig'' отрабатывают последовательно - сначала со входными параметрами <math>T_{1}, Q_{1}, \Lambda_{1}</math>, затем - <math>T_{2}, Q_{2}, \Lambda_{2}</math>.<br />
<br />
Таким образом, благодаря параллелизму высота алгоритма параллельного составляет <math>log_{2}(n)</math>, когда как при последовательной реализации высота алгоритма равна сумме геометрической прогрессии <math>1+2+4+8+...+2^{n-1} = 2^{n} - 1</math>, что значительно сокращает число итераций алгоритма.<br />
<br />
== Входные и выходные данные алгоритма ==<br />
'''Входные данные:''' <br />
<br />
На вход алгоритму подаётся трёхдиагональная симметричная матрица:<br />
<br />
<math><br />
L = \begin{bmatrix}<br />
a_{1} & b_{1}&&&&& \\<br />
b_{1} & \ddots & \ddots \\<br />
& \ddots & a_{m-1} & b_{m-1} \\<br />
&& b_{m-1} & a_{m} & b_{m} \\<br />
&&& b_{m} & a_{m+1} & b_{m+1} \\<br />
&&&& b_{m+1} & \ddots \\<br />
&&&&&& \ddots & b_{n-1} \\<br />
&&&&&& b_{n-1} & a_{n} \\<br />
\end{bmatrix}<br />
</math><br />
<br />
'''Объем входных данных:''' <br />
<br />
<math>2n + 1</math> - в силу симметрии, хранить следует только диагональные, поддиагональые и наддиагональные элементы.<br />
<br />
'''Выходные данные:'''<br />
<br />
На выходе мы получаем вектор собственных значений длины <math> n </math> и <math> n </math> собственных векторов длины <math> n </math> , соответствующих собственным значениям исходной матрицы.<br />
<br />
'''Объем выходных данных:'''<br />
<br />
<math> n + n^{2} = n(n + 1) </math><br />
<br />
== Свойства алгоритма ==<br />
Описанный в данной статье алгоритм является самым быстрым алгоритмом, среди существующих: QR / Бисекция и обратная итерация / Разделяй и властвуй.<br />
<br />
Последовательная сложность алгоритма (не принимая во внимание дефляцию) удовлетворяет рекурсивному соотношению: <br />
<br />
<math>t(n) = n^3 +2t(\frac{n}{2})</math><br />
<br />
Решение которого имеет вид:<br />
<br />
<math> t = c\frac{4}{3}n^{3} </math><br />
<br />
На практике же, параллельная сложность алгоритма в силу использования дефляции, позволяющей получить выигрыш в количестве операций, который заключается в ускорении матричного умножения на последнем шаге алгоритма (см. [[#Дефляция]]), имеет следующий вид: <math> O(n^{2.3})</math> или в самых редких случаях <math> O(n^{2}) </math> (см. [3] стр. 8).<br />
<br />
Особенности алгоритма:<br />
<br />
1. Использование дефляции ([[#Дефляция]])<br />
<br />
2. Использование адаптированного метода Ньютона ([[#Макроструктура алгоритма]])<br />
<br />
= Программная реализация алгоритма =<br />
Вторая часть описания алгоритмов в рамках AlgoWiki рассматривает все составные части процесса их реализации. Рассматривается как последовательная реализация алгоритма, так и параллельная. Описывается взаимосвязь свойств программ, реализующих алгоритм, и особенностей архитектуры компьютера, на которой они выполняются. Исследуется работа с памятью, локальность данных и вычислений, описывается масштабируемость и эффективность параллельных программ, производительность компьютеров, достигаемая на данной программе. Обсуждаются особенности реализации для разных классов архитектур компьютеров, приводятся ссылки на реализации в существующих библиотеках.<br />
<br />
<br />
== Особенности реализации последовательного алгоритма ==<br />
<br />
== Локальность данных и вычислений ==<br />
<br />
== Возможные способы и особенности параллельной реализации алгоритма ==<br />
== Масштабируемость алгоритма и его реализации ==<br />
Исследование проводилось на суперкомпьютере "Ломоносов" Суперкомпьютерного комплекса Московского университета.<br />
<br />
Набор и границы значений изменяемых параметров запуска реализации алгоритма: <br />
<br />
* число процессоров [1 : 8] (1,2,3,4,8);<br />
* размер матрицы [4 : 8192].<br />
<br />
Для исследования масштабируемости алгоритм был реализован на библиотеке OpenMP 1.5.5 для языка C++(компилятор g++) на cуперкомпьютере Ломоносов на узле compiler. Для данного узла максимально возможное число потоков - 8. В ходе оценки масштабируемости, программа была запущена в 1, 2, 4, 8 потока. <br />
Параметры компиляции и запуска: <br />
<br />
ssh compiler <br />
module add slurm<br />
module add openmpi/1.5.5-icc<br />
g++ _scratch/test.c++ -fopenmp -std=c++0x -o test <br />
sbatch -p test -n1 run ./test<br />
<br />
Для управления количеством потоков использовалась операция OpenMP omp_set_num_threads();<br />
<br />
[[File:ResultsDiagram.jpg|thumb|center|left|800px|Рис. 6. График времени работы программы в зависимости от числа процессов и размера задачи]]<br />
<br />
Масштабируемость рассматриваемой реализации алгоритма '''"Разделяй и властвуй"''':<br />
<br />
* При увеличении числа процессов общая эффективность программы увеличивается, т.к. время чтения и подготовки исходной матрицы остаётся неизменным, а время работы алгоритма уменьшается, однако рост незначительный.<br />
* При увеличении размерности матрицы общая эффективность программы постепенно уменьшается, т.к. время чтения и подготовки исходных данных растёт быстрее, чем время работы исследуемого алгоритма.<br />
* При одновременном увеличении как числа процессов, так и размерности матрицы общая эффективность программы уменьшается.<br />
<br />
Код исследуемой реализации представлен здесь [http://pastebin.com/QpfYZGkK pastebin.com]<br />
<br />
== Динамические характеристики и эффективность реализации алгоритма ==<br />
<br />
== Выводы для классов архитектур ==<br />
<br />
== Существующие реализации алгоритма ==<br />
Описываемый метод реализован в пакете LAPACK, описание которого можно найти в [http://www.netlib.org/lapack/lawnspdf/lawn132.pdf этой статье] на страницах 7, 19 и 20, которая указана в списке литературы.<br />
<br />
= Литература =<br />
[1] Дж. Деммель, «Вычислительная линейная алгебра» //С. 230-235<br />
<br />
[2] [http://www.netlib.org/utk/people/JackDongarra/PAPERS/104_1999_a-parallel-divide-and-conquer-algorithm.pdf Francoise Tisseury, Jack Dongarra, A Parallel Divide and Conquer Algorithm for the Symmetric Eigenvalue Problem on Distributed Memory Architectures]<br />
<br />
[3] [http://www.netlib.org/lapack/lawnspdf/lawn132.pdf Francoise Tisseury, Jack Dongarra, Parallelizing the Divide and Conquer Algorithm for the Symmetric Tridiagonal Eigenvalue Problem on Distributed Memory Architectures]<br />
<br />
[4] [https://en.wikipedia.org/wiki/Divide-and-conquer_eigenvalue_algorithm Алгоритм "Разделяй и властвуй" - Wikipedia]<br />
<br />
[5] [http://www.cscamm.umd.edu/tadmor/pub/linear-stability/Gill_Tadmor_SISC90.pdf Doron Grill and Eitan Tadmor AN <math>O(N2)</math> METHOD FOR COMPUTING THE EIGENSYSTEM OF <math>N</math>x<math>N</math> SYMMETRIC TRIDIAGONAL MATRICES BY THE DIVIDE AND CONQUER APPROACH]<br />
<br />
[[en:Description of algorithm properties and structure]]</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%C2%AB%D1%80%D0%B0%D0%B7%D0%B4%D0%B5%D0%BB%D1%8F%D0%B9_%D0%B8_%D0%B2%D0%BB%D0%B0%D1%81%D1%82%D0%B2%D1%83%D0%B9%C2%BB_%D0%B2%D1%8B%D1%87%D0%B8%D1%81%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F_%D1%81%D0%BE%D0%B1%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D1%8B%D1%85_%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B9_%D0%B8_%D0%B2%D0%B5%D0%BA%D1%82%D0%BE%D1%80%D0%BE%D0%B2_%D1%81%D0%B8%D0%BC%D0%BC%D0%B5%D1%82%D1%80%D0%B8%D1%87%D0%BD%D0%BE%D0%B9_%D1%82%D1%80%D0%B5%D1%85%D0%B4%D0%B8%D0%B0%D0%B3%D0%BE%D0%BD%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B9_%D0%BC%D0%B0%D1%82%D1%80%D0%B8%D1%86%D1%8B&diff=22576Метод «разделяй и властвуй» вычисления собственных значений и векторов симметричной трехдиагональной матрицы2017-04-29T20:14:10Z<p>Chernyavskiy: </p>
<hr />
<div>Основные авторы описания: [[Участник:Роман_Землянский|Р.Землянский]] (Разделы <br />
[[#Общее описание алгоритма|1.1]], [[#Математическое описание алгоритма|1.2]], [[#Последовательная сложность алгоритма|1.6]], [[#Ресурс параллелизма алгоритма|1.8]], [[#Входные и выходные данные алгоритма|1.9]], [[#Свойства алгоритма|1.10]]), В.Завольсков (Разделы [[#Вычислительное ядро алгоритма|1.3]], [[#Макроструктура алгоритма|1.4]], [[#Схема реализации последовательного алгоритма|1.5]], [[#Информационный граф|1.7]], [[#Существующие реализации алгоритма|2.7]]), [[Участник:IgorS]] (предварительная проверка), [[Участник:Chernyavskiy|А.Ю. Чернявский]] (проверка, редактирование).<br />
<br />
<br />
{{algorithm<br />
| name = Метод "Разделяй и властвуй" вычисления собственных значений и векторов трёхдиагональной матрицы<br />
| serial_complexity = <math> c\frac{4}{3}n^{3} </math><br />
| parallel_complexity = <math> O(n^{2.3}) </math><br />
<br />
крайне редко: <math> O(n^{2}) </math> <br />
| pf_width = <br />
| input_data = <math> 2n + 1 </math><br />
| output_data = <math> n(n + 1) </math><br />
}}<br />
<br />
<br />
= Свойства и структура алгоритмов =<br />
== Общее описание алгоритма ==<br />
'''Метод разделяй и властвуй вычисления собственных значений и векторов трёхдиагональной матрицы''' - это наиболее быстрый из существующих методов, если нужны все собственные значения и собственные векторы трехдиагональной матрицы, начиная с порядка n, примерно равного 26. (Точное значение этого порогового порядка зависит от компьютера.) Его численно устойчивая реализация весьма не тривиальна. В самом деле, хотя впервые метод был предложен еще в 1981 г., "правильный" способ его реализации был найден лишь в 1992 г. Этот способ воплощен LAPACK-программами ssyevd (для плотных матриц) и sstevd (для трехдиагональных матриц). В них стратегия "разделяй-и-влавствуй" используется для матриц порядка, большего чем 25. Для матриц меньшего порядка (или если нужны только собственные значения) происходит автоматический переход к QR-итерации.<br />
<br />
== Математическое описание алгоритма ==<br />
Пусть <br />
<br />
:<math><br />
T = \begin{bmatrix}<br />
a_{1} & b_{1}&&&&& \\<br />
b_{1} & \ddots & \ddots \\<br />
& \ddots & a_{m-1} & b_{m-1} \\<br />
&& b_{m-1} & a_{m} & b_{m} \\<br />
&&& b_{m} & a_{m+1} & b_{m+1} \\<br />
&&&& b_{m+1} & \ddots \\<br />
&&&&&& \ddots & b_{n-1} \\<br />
&&&&&& b_{n-1} & a_{n} \\<br />
\end{bmatrix}<br />
= \begin{bmatrix}<br />
a_{1} & b_{1} &&&&& \\<br />
b_{1} & \ddots & \ddots \\<br />
& \ddots & a_{m-1} & b_{m-1} \\<br />
&& b_{m-1} & a_{m} - b_{m} \\<br />
&&&& a_{m+1} - b_{m} & b_{m+1} \\<br />
&&&& b_{m+1} & \ddots \\<br />
&&&&&& \ddots & b_{n-1} \\<br />
&&&&&& b_{n-1} & a_{n} \\<br />
\end{bmatrix} +<br />
</math><br />
<br />
<math><br />
+ \begin{bmatrix}<br />
&&&&& \\<br />
&&b_{m} & b_{m} \\<br />
&&b_{m} & b_{m} \\<br />
&&&&& \\<br />
\end{bmatrix}<br />
<br />
= \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m} * \begin{bmatrix} 0 \\ \vdots \\ 0 \\ 1 \\ 1 \\ 0 \\ \vdots \\ 0 \end{bmatrix} \begin{bmatrix} 0 , \ldots , 0 , 1 , 1 , 0 \ldots , 0 \end{bmatrix} <br />
<br />
\equiv \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T}<br />
</math><br />
<br />
Предположим, что нам известны спектральные разложения матриц <math>T_{1}</math> и <math> T_{2} </math>: <br />
<math> T_{i} = Q_{i} \Lambda_{i} Q_{i}^{T} </math>. В действительности, они будут рекурсивно вычисляться тем же самым алгоритмом. Установим связь между собственными значениями матрицы Т и собственными значениями матриц<br />
<math>T_{1}</math> и <math>T_{2}</math>. Имеем:<br />
<br />
<math> <br />
T = \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T} <br />
= \begin{bmatrix} Q_{1} \Lambda_{1} Q_{1}^{T} & 0 \\ 0 & Q_{2} \Lambda_{2} Q_{2}^{T}\end{bmatrix} + b_{m}vv^{T} <br />
= \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}(\begin{bmatrix} \Lambda_{1} & \\ & \Lambda_{2}\end{bmatrix} + b_{m}uu^{T})\begin{bmatrix} Q_{1}^{T} & 0 \\ 0 & Q_{2}^{T}\end{bmatrix}<br />
</math>,<br />
<br />
где <br />
<br />
<math><br />
u = \begin{bmatrix} Q_{1}^{T} & 0 \\ 0 & Q_{2}^{T}\end{bmatrix}v<br />
</math><br />
<br />
так как <math>v = \begin{bmatrix} 0 , \ldots , 0 , 1 , 1 , 0 \ldots , 0 \end{bmatrix}^T</math>, получим матрицу, состоящую из последнего столбца матрицы <math> Q_{1}^{T}</math> и первого столбца матрицы <math> Q_{2}^{T}</math>.<br />
<br />
Следовательно, <math>T</math> имеет те же собственные значения, что и подобная ей матрица <math>D + \rho uu^{T}</math>, <br />
где <math>D = \begin{bmatrix} \Lambda_{1} & 0 \\ 0 & \Lambda_{2}\end{bmatrix}</math> - диагональная матрица, <br />
<math>\rho = b_{m}</math> - число, а <math>u</math> - вектор. <br />
<br />
Будем предполагать, не ограничивая общности, что диагональные элементы <math>d_{1}, \ldots, d_{n}</math> матрицы <math>D</math> упорядочены по убыванию: <math>d_{n} <= \ldots <=d_{1}</math>.<br />
<br />
Чтобы найти собственные значения матрицы <math>D + \rho uu^{T}</math>, вычислим её характеристический многочлен, считая пока матрицу <math>D - \lambda I</math> невырожденной.<br />
Тогда<br />
<br />
<math>det(D + \rho uu^{T} - \lambda I) = det((D - \lambda I)(I + \rho (D- \lambda I)^{-1} uu^{T}))</math>.<br />
<br />
Поскольку <math>D - \lambda I</math> невырожденна, <math>det(I + \rho (D - \lambda I)^{-1}uu^{T}) = 0</math> тогда и только тогда, когда <math>\lambda</math> - собственное значение. Заметим, что матрица <math>I + \rho (D - \lambda I)^{-1}uu^{T}</math> получается из единичной добавлением матрицы ранга 1. Определитель такой матрицы легко вычислить.<br />
<br />
'''Лемма 1.''' Справедливо равенство <math>det(I + xy^{T}) = 1 + y^{T}x</math>, где <math>x</math> и <math>y</math> - векторы.<br />
<br />
Таким образом,<br />
<br />
<math>det(I + \rho (D - \lambda I)^{-1}uu^{T}) = 1 + \rho u^{T}(D - \lambda I)^{-1}u</math> <math> = 1 + \rho \sum_{i=1, n} \frac{u_{i}^{2}} {d_{i}-\lambda} \equiv f(\lambda)</math> , <br />
<br />
т.е. собственные значения матрицы <math>T</math> есть корни так называемого векового уравнения <math>f(\lambda) = 0</math>. Если все числа <math>d_{i}</math> различны и все <math>u_{i} <> 0</math> (случай общего положения), то <math>f(\lambda)</math> имеет график типа показанного на рис.1(где <math>n = 4</math> и <math>\rho > 0</math>).<br />
<br />
[[File:Graphics.PNG|thumb|center|800px|Рис. 1. График функции <math> f(\lambda) = 1 + \frac{0.5}{1 - \lambda} + \frac{0.5}{2 - \lambda} + \frac{0.5}{3 - \lambda} + \frac{0.5}{4 - \lambda}</math>]]<br />
<br />
Можно видеть, что прямая <math>y = 1</math> является горизонтальной асимптотой для этого графика, а прямые <math>\lambda = d_{i}</math> есть вертикальные асимптоты. Поскольку <math>f^{'}(\lambda) = \rho \sum_{i=1, n} \frac{u_{i}^{2}} {(d_{i}-\lambda)^{2}}> 0 </math>, функция возрастает всюду, кроме точек <math>\lambda = d_{i}</math>. Поэтому корни функции разделяются числами <math>d_{i}</math> и ещё один корень находится справа от точки <math>d_{1}</math> (на рис. 1 <math>d_{1} = 4</math>). (При <math>\rho<0</math> функция <math>f(\lambda)</math> всюду убывает и соответствующий корень находится слева от точки <math>d_{n}</math>). Для функции <math>f(\lambda)</math>, монотонной и гладкой на каждом из интервалов <math>(d_{i+1},d_{i})</math>, можно найти вариант метода Ньютона, который быстро и монотонно сходится к каждому из корней, если начальная точка взята в <math>(d_{i+1},d_{i})</math>. Нам достаточно знать, что на практике метод сходится к каждому собственному значению за ограниченное число шагов. Поскольку вычисление <math>f(\lambda)</math> и <math>f^{'}(\lambda)</math> стоит <math>O(n)</math> флопов, для вычисления одного собственного значения достаточно <math>O(n)</math>, а для вычисления всех <math>n</math> собственных значений матрицы <math>D + \rho uu^{T}</math> требуется <math>O(n^{2})</math> флопов.<br />
Для собственных векторов матрицы <math>D + \rho uu^{T}</math> мы легко можем получить явные выражения.<br />
<br />
'''Лемма 2.''' Если <math>\alpha</math> - собственное значение матрицы <math>D + \rho uu^{T}</math>, то соответствующий вектор равен <math>(D - \alpha I)^{-1}u</math>. Поскольку матрица <math>D - \alpha I</math> диагональная, для вычисления такого вектора достаточно <math>O(n)</math> флопов.<br />
<br />
Доказательство.<br />
<br />
<math>(D + \rho uu^{T})[(D - \alpha I)^{-1}u] = (D - \alpha I + \alpha I + \rho uu^{T})(D - \alpha I)^{-1}u</math><br />
<br />
<math>=u + \alpha (D - \alpha I)^{-1}u + u[\rho u^{T}(D - \alpha I)^{-1}u] </math><br />
<br />
<math>=u + \alpha(D - \alpha I)^{-1}u - u</math> <br />
<br />
поскольку <math> \rho u^{T}(D - \alpha I)^{-1}u + 1 = f(\alpha) = 0 </math><br />
<br />
<math>=\alpha [(D - \alpha I)^{-1}u]</math>, что и требовалось.<br />
<br />
<br />
Для вычисления по этой простой формуле всех <math>n</math> собственных векторов требуется <math>O(n^{2})</math> флопов. К сожалению, формула не обеспечивает численной устойчивости, так как для двух очень близких значений <math>\alpha_{i}</math> может давать неортогональные приближенные собственные векторы <math>u_{i}</math>. Потребовалось целое десятилетие для того, чтобы найти устойчивую альтернативу исходному описанию алгоритма. Снова детали будут обсуждаться позднее в данном разделе. <br />
<br />
Алгоритм является рекурсивным.<br />
<br />
=== Дефляция ===<br />
<br />
До сих пор полагалось, что все <math>d_{i}</math> различны и все <math>u_{i}</math> отличны от нуля. Если это не так, вековое уравнение <math>f(\lambda)=0</math> имеет <math>k</math> вертикальных асимптот, где <math>k<n</math>, а потому <math>k</math> корней. Однако оказывается, что остальные <math>n - k</math> собственных значений могут быть определены без каких-либо усилий: если <math>d_{i}=d_{i+1}</math> или <math>u_{i}=0</math>, то легко показать, что <math>d_{i}</math> является собственным значением и для матрицы <math>D + \rho uu^{T}</math>. В такой ситуации мы говорим о ''дефляции''. На практике выбирается некоторое пороговое значение и дефляция для числа <math>d_{i}</math> регистрируется, если в смысле этого порога <math>d_{i}</math> достаточно близко к <math>d_{i+1}</math> либо <math>u_{i}</math> достаточно мало.<br />
<br />
Основной выигрыш от использования дефляции состоит не в том, что убыстряется решение векового уравнения - этот этап в любом случае стоит лишь <math>O(n^{2})</math> операций. Выигрыш заключается в ускорении матричного умножения на последнем шаге алгоритма. Действительно, если <math>u_{i}=0</math>, то соответствующий собственный вектор есть i-й столбец <math>e_{i}</math> единичной матрицы. Это означает, что <math>e_{i}</math> является i-м столбцом в матрице <math>Q_{'}</math>, поэтому при формировании матрицы <math>Q</math> посредством левого умножения <math>Q_{1}</math> на <math>Q_{2}</math> вычисление i-го столбца не требует никаких затрат. Аналогичное упрощение имеет место в случае <math>d_{i} = d_{i+1}</math>. При дефляции многих собственных значений устраняется большая часть работы, связанной с матричным умножением.<br />
<br />
=== Решение векового уравнения ===<br />
<br />
Подробно стоит поговорить о решении векового уравнения, которое является одной из основных частей алгоритма.<br />
<br />
Предположим, что некоторое <math>u_{i}</math>, хотя и мало, все же недостаточно мало для того, чтобы была зарегистрирована дефляция. В этом случае применение метода Ньютона к решению векового уравнения встречается с затруднениями. Вспомним, что пересчет приближённого решения <math>u_{j}</math> уравнения <math>f(\lambda) = 0</math> в методе Ньютона основан на следующих положениях:<br />
<br />
1. Вблизи точки <math>\lambda = \lambda_{j}</math> функция <math>f(\lambda)</math> аппроксимируется линейной функцией <math>l(\lambda)</math>; график есть прямая линия, касающаяся графика функции <math>f(\lambda)</math> при <math>\lambda = \lambda_{j}</math>.<br />
<br />
2. В качестве <math>\lambda_{j+1}</math> берётся нуль этого линейного приближения, т.е. <math>l(\lambda_{j+1})=0</math>.<br />
<br />
Функция, показанная на рис.1, не доставляет видимых трудностей методу Ньютона, поскольку вблизи каждого своего нуля <math>f(\lambda)</math> достаточно хорошо аппроксимируется линейными функциями. Однако рассмотрим график функции на рис. 4. Она получена из функции на рис. 1 заменой значения .5 для <math>u_{i}^{2}</math> на .001. Это новое значение недостаточно мало для того, чтобы вызвать дефляцию. График функции в левой части рис.4 визуально не отличим от её вертикальных и горизонтальных асимптот, поэтому в правой части укрупненно воспроизведён фрагмент графика, прилегающий к вертикальной асимптоте <math>\lambda = 2</math>. Видно, что график слишком быстро "выполняет поворот" и для большей части значений <math>\lambda</math> почти горизонтален. Поэтому, применяя метод Ньютона почти к любому начальному приближению <math>\lambda_{0}</math>, мы получаем линейное приближение <math>l(\lambda)</math> с почти горизонтальным графиком и малым положительным угловым коэффициентом. В результате <math>\lambda_{1}</math> является отрицательным числом, огромным по абсолютной величине, которое совершенно бесполезно в качестве приближения к истинному корню.<br />
<br />
[[File:GraphNewton.png|thumb|center|800px|Рис. 4. График функции <math> f(\lambda) = 1 + \frac{10^{-3}}{1 - \lambda} + \frac{10^{-3}}{2 - \lambda} + \frac{10^{-3}}{3 - \lambda} + \frac{10^{-3}}{4 - \lambda}</math>]]<br />
<br />
Чтобы найти выход из этого положения, можно модифицировать метод Ньютона следующим образом: раз <math>f(\lambda)</math> нельзя хорошо приблизить линейной функцией <math>l(\lambda)</math>, попробуем взять в качестве приближения какую-нибудь другую простую функцию <math>h(\lambda)</math>. Нет ничего особого именно в прямых линиях: для метода Ньютона вместо <math>l(\lambda)</math> можно взять любое приближение <math>h(\lambda)</math>, значения и нули которого легко вычисляются. Функция <math>f(\lambda)</math> имеет полюсы в точках <math>d_{i}</math> и <math>d_{i+1}</math>, которые определяют её поведение в соответствующих окрестностях. Поэтому при поиске корня в интервале <math>(d_{i+1}, d_{i})</math> естественно выбрать функцию <math>h(\lambda)</math>, также имеющую эти полюсы, т.е. функцию вида<br />
<math>h(\lambda)= \frac{c_{1}}{d_{i}-\lambda} + \frac{c_{2}}{d_{i+1}-\lambda} + c_{3}</math><br />
<br />
Константы <math>c_{1},c_{2}</math> и <math>c_{3}</math> обеспечивающие, что <math>h(\lambda)</math> есть приближение к <math>f(\lambda)</math>, можно выбрать несколькими способами. Отметим, что если <math>c_{1},c_{2}</math> и <math>c_{3}</math> уже известны, то уравнение <math>h(\lambda)=0</math> легко решается относительно <math>\lambda</math>, поскольку сводится к эквивалентному квадратному уравнению<br />
<math>c_{1}(d_{i+1}-\lambda)+c_{2}(d_{i}-\lambda)+c_{3}(d_{i}-\lambda)(d_{i+1}-\lambda)=0</math><br />
<br />
Пусть <math>\lambda_{j}</math> - приближённое значение корня. определим <math>c_{1},c_{2}</math> и <math>c_{3}</math> так, чтобы<br />
<math>\frac{c_{1}}{d_{i}-\lambda} + \frac{c_{2}}{d_{i+1}-\lambda} + c_{3} = h(\lambda) \approx f(\lambda) = 1 + \rho \sum_{k=1, n} \frac{u_{k}^{2}} {d_{k}-\lambda} </math><br />
<br />
для <math>\lambda</math> в окрестности <math>\lambda_{j}</math>. Заметим, что<br />
<br />
<math>f(\lambda) = 1 + \rho \sum_{k=1, i} \frac{u_{k}^{2}} {d_{k}-\lambda} + \rho \sum_{k=i+1, n} \frac{u_{k}^{2}} {d_{k}-\lambda} \equiv 1 + \psi_{1}(\lambda) + \psi_{2}(\lambda)</math>.<br />
<br />
Если <math>\lambda \in (d_{i+1},d_{i})</math>, то <math>\psi_{1}(\lambda)</math> есть сумма положительных слагаемых, а <math>\psi_{2}(\lambda)</math> - сумма отрицательных. Поэтому и <math>\psi_{1}(\lambda)</math>, и <math>\psi_{2}(\lambda)</math> могут быть вычислены с высокой точностью; однако при их сложении вполне вероятно взаимное уничтожение верных разрядов и потеря относительной точности в сумме. Возьмем числа <math>c_{1}</math> и <math>\hat{c_{1}}</math>, такие, что функция <br />
<br />
<math>h_{1}(\lambda) \equiv \hat{c_{1}} + \frac{c_{1}}{d_{i}-\lambda}</math> удовлетворяет условиям <math>h_{1}(\lambda_{j}) = \psi_{1}(\lambda_{j})</math> и <math>h_{1}^{'}(\lambda_{j})=\psi_{1}^{'}(\lambda_{j})</math> (1)<br />
<br />
Это означает, что гипербола, являющаяся графиком функции <math>h_{1}(\lambda)</math>, касается графика функции <math>\psi_{i}(\lambda)</math> при <math>\lambda = \lambda_{j}</math>. Два условия в (1) - это обычные условия метода Ньютона, за исключением того, что вместо прямой в качестве приближения используется гипербола. Легко проверить, что <math>c_{1}=\psi_{1}^{'}(\lambda_{j})(d_{i} - \lambda_{j})^{2}</math> и <math>\hat{c_{1}}=\psi_{1}(\lambda_{j}) - \psi_{1}^{'}(\lambda_{j})(d_{i} - \lambda_{j})</math><br />
<br />
Подобным же образом выбираем <math>c_{2}</math> и <math>\hat{c_{2}}</math> так, чтобы функция <br />
<br />
<math>h_{2}(\lambda) \equiv \hat{c_{2}} + \frac{c_{2}}{d_{i+1}-\lambda}</math><br />
<br />
Удовлетворяла условиям<br />
<br />
<math>h_{2}(\lambda_{j}) = \psi_{2}(\lambda_{j})</math> и <math>h_{2}^{'}(\lambda_{j})=\psi_{2}^{'}(\lambda_{j})</math> (2)<br />
<br />
Наконец, полагаем<br />
<br />
<math>h(\lambda) = 1 + h_{1}(\lambda) + h_{2}(\lambda) = (1 + \hat{c_{1}} + \hat{c_{2}} + \frac{c_{1}}{d_{i}-\lambda} + \frac{c_{2}}{d_{i+1}-\lambda} </math><br />
<br />
<math>\equiv c_{3} + \frac{c_{1}}{d_{i}-\lambda} + \frac{c_{2}}{d_{i+1}-\lambda}</math>.<br />
<br />
== Вычислительное ядро алгоритма ==<br />
Вычислительным ядром последовательной схемы решения является вычисление матрицы <math>Q</math> собственных векторов путём умножения матрицы <math>Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}</math> на матрицу <math>Q^{'}</math> Данная операция имеет сложность <math>cn^{3}</math> о чём и говорится в разделе [[#Последовательная сложность алгоритма]] .<br />
Ей предшествует вычисление собственных значений и векторов матрицы <math> D + \rho uu^{T}</math><br />
<br />
== Макроструктура алгоритма ==<br />
Ниже описана структура алгоритма, в которой есть блок умножения матриц для вычисления собственных векторов, являющийся вычислительным ядром алгоритма. В соответствующем разделе ([[#Вычислительное ядро алгоритма]]) мы упоминали о том, что данному блоку предшествует вычисление собственных значений, которое производится [https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D0%9D%D1%8C%D1%8E%D1%82%D0%BE%D0%BD%D0%B0 методом Ньютона].<br />
<br />
[[File:DivideAndConquerTree.png|thumb|center|left|800px|Рис. 2. Дерево алгоритма "Разделяй и властвуй"]]<br />
<br />
[[File:InfoGraph.jpg|thumb|center|1200px|Рис. 3. Детальное описание одного блока алгоритма]]<br />
<br />
== Схема реализации последовательного алгоритма ==<br />
''Вычисление собственных значений и собственных векторов симметричной трехдиагональной матрицы посредством стратегии "разделяй и властвуй"'':<br />
<br />
<br />
''proc dc_eig''<math>(T,Q,\Lambda)...</math> по входной матрице <math>T</math> вычисляются выходные матрицы <math>Q</math> и <math>\Lambda</math>, такие, что <math>T = Q\Lambda Q^{T}</math><br />
<br />
'''Если <math>T</math> - матрица размера <math>1</math> x <math>1</math>'''<br />
<br />
1. Присвоить выходным параметрам значения <math> Q = 1, \Lambda = T</math><br />
<br />
'''Иначе'''<br />
<br />
1. Представить <math>T</math> в виде <math> T = \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T} </math><br />
<br />
2. ''call dc_eig''<math>(T_{1},Q_{1},\Lambda_{1})</math><br />
<br />
3. ''call dc_eig''<math>(T_{2},Q_{2},\Lambda_{2})</math><br />
<br />
4. Построить <math>D+\rho uu^{T}</math> по <math> \Lambda_{1},\Lambda_{2}, Q_{1}, Q_{2}</math><br />
<br />
5. Найти матрицу собственных значений <math>\Lambda</math><br />
<br />
6. Найти матрицу собственных векторов <math>Q^{'}</math> для матрицы <math>D+\rho uu^{T}</math><br />
<br />
7. Построить матрицу собственных векторов <math>Q</math> для матрицы <math>T</math> : <math> Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}* Q^{'} </math><br />
<br />
8. Присвоить выходным параметрам значения <math>Q</math> и <math>\Lambda</math><br />
<br />
'''endif'''<br />
<br />
== Последовательная сложность алгоритма ==<br />
Проанализируем сложность алгоритма. Пусть <math>t(n)</math> - число флопов при обработке матрицы размера <math> n x n</math> процедурой ''dc_eig''. Тогда <br />
<br />
<math> t(n) = 2t(n/2) </math> два рекурсивных обращения к ''dc_eig''<math>(T_{i},Q_{i},\Lambda_{i})</math><br />
<br />
<math> +O(n^{2})</math> вычисление собственных значений матрицы <math>D+\rho uu^{T}</math><br />
<br />
<math> +O(n^{2})</math> вычисление собственных векторов матрицы <math>D+\rho uu^{T}</math><br />
<br />
<math> +c*n^{3}</math> вычисление матрицы <math>Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}*Q^{'}</math><br />
<br />
<br />
Если <math> Q_{1}, Q_{2}</math> и <math>Q^{'}</math> рассматриваются как плотные матрицы и используется стандартный алгоритм матричного умножения, то константа <math> c </math> в последней строке равна 1. Таким образом, именно это умножение составляет наиболее трудоёмкую часть алгоритма в целом. Игнорируя члены порядка <math>n^{2}</math>, получаем <math>t(n) = 2t(n/2) + cn^{3}</math>. Решая это разностное уравнение, находим <math> t \approx c\frac{4}{3}n^{3} </math><br />
<br />
На практике константа <math>c</math> обычно гораздо меньше 1, потому что матрица <math>Q^{'}</math> весьма разрежена вследствие явления, называемого дефляцией.<br />
<br />
== Информационный граф ==<br />
В данном разделе на рисунке 5 представлен информационный граф алгоритма.<br />
<br />
[[File:InfoGraphSC.jpg|thumb|center|left|1200px|Рис. 5. Информационный граф алгоритма "Разделяй и властвуй" - шаг <b>Divide</b>]]<br />
<br />
Операции: <br />
<br />
<math>D</math> - операция Divide разделения матрицы <math> T </math> на матрицы <math>T_{1}</math> и <math>T_{2}</math><br />
<br />
Индексы - размерность <br />
<br />
<math>S_{k}</math> - операция Conquer сбора матрицы <math> D </math><br />
<br />
<math> L_{k} </math> - операция поиска собственных значений <br />
<br />
<math> S^{'} </math> - операция поиска собственных векторов матрицы <math> Q^{'} </math><br />
<br />
<math> S </math> - операция поиска собственных векторов матрицы <math> Q </math><br />
<br />
== Ресурс параллелизма алгоритма ==<br />
Рассмотрев информационный граф алгоритма, можно заметить, что в структуре имеется два параллельных блока - вызов рекурсивных функций ''dc_eig'' для вычисления собственных значений и векторов матриц <math>T_{1}</math> и <math>T_{2}</math> - это единственная часть алгоритма, в которой мы прибегаем к параллелизму. <br />
<br />
Рекурсивное разделение матрицы ведёт к иерархии вычислительных подблоков с графом зависимости данных, который выглядит, как двоичное дерево. Данная структура является естественным путем разделения вычислений между процессорами.<br />
<br />
В вершине дерева все процессы взаимодействуют. В каждой ветви дерева вычисление делится на два вычислительных подблока, внутри каждого из которых процессы параллельно взаимодействуют. В листьях деревьев каждый процесс занимается вычислением независимо.<br />
<br />
В случае реализации без параллелизма, функции ''dc_eig'' отрабатывают последовательно - сначала со входными параметрами <math>T_{1}, Q_{1}, \Lambda_{1}</math>, затем - <math>T_{2}, Q_{2}, \Lambda_{2}</math>.<br />
<br />
Таким образом, благодаря параллелизму высота алгоритма параллельного составляет <math>log_{2}(n)</math>, когда как при последовательной реализации высота алгоритма равна сумме геометрической прогрессии <math>1+2+4+8+...+2^{n-1} = 2^{n} - 1</math>, что значительно сокращает число итераций алгоритма.<br />
<br />
== Входные и выходные данные алгоритма ==<br />
'''Входные данные:''' <br />
<br />
На вход алгоритму подаётся трёхдиагональная симметричная матрица:<br />
<br />
<math><br />
L = \begin{bmatrix}<br />
a_{1} & b_{1}&&&&& \\<br />
b_{1} & \ddots & \ddots \\<br />
& \ddots & a_{m-1} & b_{m-1} \\<br />
&& b_{m-1} & a_{m} & b_{m} \\<br />
&&& b_{m} & a_{m+1} & b_{m+1} \\<br />
&&&& b_{m+1} & \ddots \\<br />
&&&&&& \ddots & b_{n-1} \\<br />
&&&&&& b_{n-1} & a_{n} \\<br />
\end{bmatrix}<br />
</math><br />
<br />
'''Объем входных данных:''' <br />
<br />
<math>2n + 1</math> - в силу симметрии, хранить следует только диагональные, поддиагональые и наддиагональные элементы.<br />
<br />
'''Выходные данные:'''<br />
<br />
На выходе мы получаем вектор собственных значений длины <math> n </math> и <math> n </math> собственных векторов длины <math> n </math> , соответствующих собственным значениям исходной матрицы.<br />
<br />
'''Объем выходных данных:'''<br />
<br />
<math> n + n^{2} = n(n + 1) </math><br />
<br />
== Свойства алгоритма ==<br />
Описанный в данной статье алгоритм является самым быстрым алгоритмом, среди существующих: QR / Бисекция и обратная итерация / Разделяй и властвуй.<br />
<br />
Последовательная сложность алгоритма (не принимая во внимание дефляцию) удовлетворяет рекурсивному соотношению: <br />
<br />
<math>t(n) = n^3 +2t(\frac{n}{2})</math><br />
<br />
Решение которого имеет вид:<br />
<br />
<math> t = c\frac{4}{3}n^{3} </math><br />
<br />
На практике же, параллельная сложность алгоритма в силу использования дефляции, позволяющей получить выигрыш в количестве операций, который заключается в ускорении матричного умножения на последнем шаге алгоритма (см. [[#Дефляция]]), имеет следующий вид: <math> O(n^{2.3})</math> или в самых редких случаях <math> O(n^{2}) </math> (см. [3] стр. 8).<br />
<br />
Особенности алгоритма:<br />
<br />
1. Использование дефляции ([[#Дефляция]])<br />
<br />
2. Использование адаптированного метода Ньютона ([[#Макроструктура алгоритма]])<br />
<br />
= ЧАСТЬ. Программная реализация алгоритма =<br />
Вторая часть описания алгоритмов в рамках AlgoWiki рассматривает все составные части процесса их реализации. Рассматривается как последовательная реализация алгоритма, так и параллельная. Описывается взаимосвязь свойств программ, реализующих алгоритм, и особенностей архитектуры компьютера, на которой они выполняются. Исследуется работа с памятью, локальность данных и вычислений, описывается масштабируемость и эффективность параллельных программ, производительность компьютеров, достигаемая на данной программе. Обсуждаются особенности реализации для разных классов архитектур компьютеров, приводятся ссылки на реализации в существующих библиотеках.<br />
<br />
<br />
== Особенности реализации последовательного алгоритма ==<br />
<br />
== Локальность данных и вычислений ==<br />
<br />
== Возможные способы и особенности параллельной реализации алгоритма ==<br />
== Масштабируемость алгоритма и его реализации ==<br />
Исследование проводилось на суперкомпьютере "Ломоносов" Суперкомпьютерного комплекса Московского университета.<br />
<br />
Набор и границы значений изменяемых параметров запуска реализации алгоритма: <br />
<br />
* число процессоров [1 : 8] (1,2,3,4,8);<br />
* размер матрицы [4 : 8192].<br />
<br />
Для исследования масштабируемости алгоритм был реализован на библиотеке OpenMP 1.5.5 для языка C++(компилятор g++) на cуперкомпьютере Ломоносов на узле compiler. Для данного узла максимально возможное число потоков - 8. В ходе оценки масштабируемости, программа была запущена в 1, 2, 4, 8 потока. <br />
Параметры компиляции и запуска: <br />
<br />
ssh compiler <br />
module add slurm<br />
module add openmpi/1.5.5-icc<br />
g++ _scratch/test.c++ -fopenmp -std=c++0x -o test <br />
sbatch -p test -n1 run ./test<br />
<br />
Для управления количеством потоков использовалась операция OpenMP omp_set_num_threads();<br />
<br />
[[File:ResultsDiagram.jpg|thumb|center|left|800px|Рис. 6. График времени работы программы в зависимости от числа процессов и размера задачи]]<br />
<br />
Масштабируемость рассматриваемой реализации алгоритма '''"Разделяй и властвуй"''':<br />
<br />
* При увеличении числа процессов общая эффективность программы увеличивается, т.к. время чтения и подготовки исходной матрицы остаётся неизменным, а время работы алгоритма уменьшается, однако рост незначительный.<br />
* При увеличении размерности матрицы общая эффективность программы постепенно уменьшается, т.к. время чтения и подготовки исходных данных растёт быстрее, чем время работы исследуемого алгоритма.<br />
* При одновременном увеличении как числа процессов, так и размерности матрицы общая эффективность программы уменьшается.<br />
<br />
Код исследуемой реализации представлен здесь [http://pastebin.com/QpfYZGkK pastebin.com]<br />
<br />
== Динамические характеристики и эффективность реализации алгоритма ==<br />
<br />
== Выводы для классов архитектур ==<br />
<br />
== Существующие реализации алгоритма ==<br />
Описываемый метод реализован в пакете LAPACK, описание которого можно найти в [http://www.netlib.org/lapack/lawnspdf/lawn132.pdf этой статье] на страницах 7, 19 и 20, которая указана в списке литературы.<br />
<br />
= Литература =<br />
[1] Дж. Деммель, «Вычислительная линейная алгебра» //С. 230-235<br />
<br />
[2] [http://www.netlib.org/utk/people/JackDongarra/PAPERS/104_1999_a-parallel-divide-and-conquer-algorithm.pdf Francoise Tisseury, Jack Dongarra, A Parallel Divide and Conquer Algorithm for the Symmetric Eigenvalue Problem on Distributed Memory Architectures]<br />
<br />
[3] [http://www.netlib.org/lapack/lawnspdf/lawn132.pdf Francoise Tisseury, Jack Dongarra, Parallelizing the Divide and Conquer Algorithm for the Symmetric Tridiagonal Eigenvalue Problem on Distributed Memory Architectures]<br />
<br />
[4] [https://en.wikipedia.org/wiki/Divide-and-conquer_eigenvalue_algorithm Алгоритм "Разделяй и властвуй" - Wikipedia]<br />
<br />
[5] [http://www.cscamm.umd.edu/tadmor/pub/linear-stability/Gill_Tadmor_SISC90.pdf Doron Grill and Eitan Tadmor AN <math>O(N2)</math> METHOD FOR COMPUTING THE EIGENSYSTEM OF <math>N</math>x<math>N</math> SYMMETRIC TRIDIAGONAL MATRICES BY THE DIVIDE AND CONQUER APPROACH]<br />
<br />
[[en:Description of algorithm properties and structure]]</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%C2%AB%D1%80%D0%B0%D0%B7%D0%B4%D0%B5%D0%BB%D1%8F%D0%B9_%D0%B8_%D0%B2%D0%BB%D0%B0%D1%81%D1%82%D0%B2%D1%83%D0%B9%C2%BB_%D0%B2%D1%8B%D1%87%D0%B8%D1%81%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F_%D1%81%D0%BE%D0%B1%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D1%8B%D1%85_%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B9_%D0%B8_%D0%B2%D0%B5%D0%BA%D1%82%D0%BE%D1%80%D0%BE%D0%B2_%D1%81%D0%B8%D0%BC%D0%BC%D0%B5%D1%82%D1%80%D0%B8%D1%87%D0%BD%D0%BE%D0%B9_%D1%82%D1%80%D0%B5%D1%85%D0%B4%D0%B8%D0%B0%D0%B3%D0%BE%D0%BD%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B9_%D0%BC%D0%B0%D1%82%D1%80%D0%B8%D1%86%D1%8B&diff=22575Метод «разделяй и властвуй» вычисления собственных значений и векторов симметричной трехдиагональной матрицы2017-04-29T20:09:45Z<p>Chernyavskiy: </p>
<hr />
<div>Основные авторы описания: [[Участник:Роман_Землянский|Р.Землянский]] (Разделы <br />
[[#Общее описание алгоритма|1.1]], [[#Математическое описание алгоритма|1.2]], [[#Последовательная сложность алгоритма|1.6]], [[#Ресурс параллелизма алгоритма|1.8]], [[#Входные и выходные данные алгоритма|1.9]], [[#Свойства алгоритма|1.10]]), В.Завольсков (Разделы [[#Вычислительное ядро алгоритма|1.3]], [[#Макроструктура алгоритма|1.4]], [[#Схема реализации последовательного алгоритма|1.5]], [[#Информационный граф|1.7]], [[#Существующие реализации алгоритма|2.7]]), [[Участник:IgorS]] (предварительная проверка), [[Участник:Chernyavskiy|А.Ю. Чернявский]] (проверка, редактирование).</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%C2%AB%D1%80%D0%B0%D0%B7%D0%B4%D0%B5%D0%BB%D1%8F%D0%B9_%D0%B8_%D0%B2%D0%BB%D0%B0%D1%81%D1%82%D0%B2%D1%83%D0%B9%C2%BB_%D0%B2%D1%8B%D1%87%D0%B8%D1%81%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F_%D1%81%D0%BE%D0%B1%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D1%8B%D1%85_%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B9_%D0%B8_%D0%B2%D0%B5%D0%BA%D1%82%D0%BE%D1%80%D0%BE%D0%B2_%D1%81%D0%B8%D0%BC%D0%BC%D0%B5%D1%82%D1%80%D0%B8%D1%87%D0%BD%D0%BE%D0%B9_%D1%82%D1%80%D0%B5%D1%85%D0%B4%D0%B8%D0%B0%D0%B3%D0%BE%D0%BD%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B9_%D0%BC%D0%B0%D1%82%D1%80%D0%B8%D1%86%D1%8B&diff=22574Метод «разделяй и властвуй» вычисления собственных значений и векторов симметричной трехдиагональной матрицы2017-04-29T20:06:35Z<p>Chernyavskiy: </p>
<hr />
<div>Основные авторы описания: [[Участник:Роман_Землянский|Р.Землянский]] (Разделы ), [[Участник:Владислав_Завольсков|В.Завольсков]] (Разделы [[#Вычислительное ядро алгоритма|1.3]], [[#Макроструктура алгоритма|1.4]], [[#Схема реализации последовательного алгоритма|1.5]], [[#Информационный граф|1.7]], [[#Существующие реализации алгоритма|2.7]]), [[Участник:IgorS]] (предварительная проверка), [[Участник:Chernyavskiy|А.Ю. Чернявский]] (проверка, редактирование).</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%C2%AB%D1%80%D0%B0%D0%B7%D0%B4%D0%B5%D0%BB%D1%8F%D0%B9_%D0%B8_%D0%B2%D0%BB%D0%B0%D1%81%D1%82%D0%B2%D1%83%D0%B9%C2%BB_%D0%B2%D1%8B%D1%87%D0%B8%D1%81%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F_%D1%81%D0%BE%D0%B1%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D1%8B%D1%85_%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B9_%D0%B8_%D0%B2%D0%B5%D0%BA%D1%82%D0%BE%D1%80%D0%BE%D0%B2_%D1%81%D0%B8%D0%BC%D0%BC%D0%B5%D1%82%D1%80%D0%B8%D1%87%D0%BD%D0%BE%D0%B9_%D1%82%D1%80%D0%B5%D1%85%D0%B4%D0%B8%D0%B0%D0%B3%D0%BE%D0%BD%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B9_%D0%BC%D0%B0%D1%82%D1%80%D0%B8%D1%86%D1%8B&diff=22573Метод «разделяй и властвуй» вычисления собственных значений и векторов симметричной трехдиагональной матрицы2017-04-29T20:01:09Z<p>Chernyavskiy: </p>
<hr />
<div>Основные авторы описания: [[Участник:Zemlyanskiy|Р.Землянский]] (Разделы ), [[Участник:Zavolskov|В.Завольсков]] (Разделы [[#Вычислительное ядро алгоритма|1.3]], [[#Макроструктура алгоритма|1.4]], [[#Схема реализации последовательного алгоритма|1.5]], [[#Информационный граф|1.7]], [[#Существующие реализации алгоритма|2.7]]), [[Участник:IgorS]] (предварительная проверка), [[Участник:Chernyavskiy|А.Ю. Чернявский]] (проверка, редактирование).</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%C2%AB%D1%80%D0%B0%D0%B7%D0%B4%D0%B5%D0%BB%D1%8F%D0%B9_%D0%B8_%D0%B2%D0%BB%D0%B0%D1%81%D1%82%D0%B2%D1%83%D0%B9%C2%BB_%D0%B2%D1%8B%D1%87%D0%B8%D1%81%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F_%D1%81%D0%BE%D0%B1%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D1%8B%D1%85_%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B9_%D0%B8_%D0%B2%D0%B5%D0%BA%D1%82%D0%BE%D1%80%D0%BE%D0%B2_%D1%81%D0%B8%D0%BC%D0%BC%D0%B5%D1%82%D1%80%D0%B8%D1%87%D0%BD%D0%BE%D0%B9_%D1%82%D1%80%D0%B5%D1%85%D0%B4%D0%B8%D0%B0%D0%B3%D0%BE%D0%BD%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B9_%D0%BC%D0%B0%D1%82%D1%80%D0%B8%D1%86%D1%8B&diff=22572Метод «разделяй и властвуй» вычисления собственных значений и векторов симметричной трехдиагональной матрицы2017-04-29T20:00:39Z<p>Chernyavskiy: </p>
<hr />
<div>Основные авторы описания: [[Участник:Zemlyansky|Р.Землянский]] (Разделы ), [[Участник:Zavolskov|В.Завольсков]] (Разделы [[#Вычислительное ядро алгоритма|1.3]], [[#Макроструктура алгоритма|1.4]], [[#Схема реализации последовательного алгоритма|1.5]], [[#Информационный граф|1.7]], [[#Существующие реализации алгоритма|2.7]]), [[Участник:IgorS]] (предварительная проверка), [[Участник:Chernyavskiy|А.Ю. Чернявский]] (проверка, редактирование).</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA:Error0x0/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9B%D0%B0%D0%BD%D1%86%D0%BE%D1%88%D0%B0_%D0%B4%D0%BB%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B8_%D1%81_%D0%BF%D0%BB%D0%B0%D0%B2%D0%B0%D1%8E%D1%89%D0%B5%D0%B9_%D1%82%D0%BE%D1%87%D0%BA%D0%BE%D0%B9_%D1%81_%D0%BF%D0%BE%D0%BB%D0%BD%D0%BE%D0%B9_%D0%BF%D0%B5%D1%80%D0%B5%D0%BE%D1%80%D1%82%D0%BE%D0%B3%D0%BE%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D0%B5%D0%B9&diff=22492Участник:Error0x0/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией2017-02-11T17:34:24Z<p>Chernyavskiy: </p>
<hr />
<div><br />
<br />
{{algorithm<br />
| name = Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией<br />
| serial_complexity = <math>O(k^2 n)</math><br />
| pf_height = <math>O(k \log k \log n)</math><br />
| pf_width = <math>O(kn)</math><br />
| input_data = <math>n^2</math><br />
| output_data = <math>n</math><br />
}}<br />
Автор описания: [[Участник:Error0x0|В. А. Янушковский]]<br />
<br />
= Свойства и структура алгоритма =<br />
<br />
== Общее описание алгоритма ==<br />
Алгоритм Ланцоша представляет собой итерационный алгоритм для вычисления собственных значений симметрической матрицы. <br />
Идея алгоритма заключается в построении матрицы <math>Q_k = [q_1, ..., q_k]</math> из ортонормированных векторов Ланцоша и использовании собственных значений трёхдиагональной матрицы <math>T_k = Q_k^T A Q_k</math> (чисел Ритца) как приближения к искомым собственным числам матрицы<ref name="Деммель">Деммель&nbsp;Дж. Вычислительная линейная алгебра</ref>.<br />
<br />
== Математическое описание алгоритма ==<br />
Пусть дана матрица <math>A</math>.<br />
Пусть <math>q_1 = b/||b||_2, \beta_0=0, q_0=0</math><br />
Алгоритм производит <math>k</math> итераций на каждой из которых:<br />
# вычисляется <math>z = Aq_j</math>,<br />
# производится переортогонализация <math>z = z - \sum^{j-1}_{i=1} {(z^T q_i)q_i}</math>,<br />
# <math>\beta_j = ||z||_2</math>, если <math>\beta_j = 0</math>, алгоритм останавливается,<br />
# <math>q_{j+1} = z/\beta_j</math>,<br />
# вычисляются собственные значения и векторы матрицы <math>T_j = Q_j^T A Q_j</math>.<br />
<br />
== Вычислительное ядро алгоритма ==<br />
Основной вклад в сложность алгоритма даёт полная переортогонализация внутри каждой итерации:<br />
<br />
<math>z = z - \sum^{j-1}_{i=1} {(z^T q_i)q_i}</math><br />
<br />
== Макроструктура алгоритма ==<br />
Алгоритм имеет следующую макроструктуру:<br />
* Начальная инициализация (деление вектора на норму <math>q_1 = b/||b||_2</math>)<br />
* Далее <math>k</math> итераций, каждая из которых может быть разложена:<br />
** Умножение матрицы на вектор (<math>z = Aq_j</math>)<br />
** Переортогонализация <math>z = z - \sum^{j-1}_{i=1} {(z^T q_i)q_i}</math><br />
** Нахождение следующего вектора <math>q_{j+1} = z/\beta_j</math>, где <math>\beta_j = ||z||_2</math><br />
** Нахождение следующего собственного значения и вектора матрицы <math>T_j = Q_j^T A Q_j</math> (числа Ритца, используется метод "разделяй и властвуй")<br />
<br />
== Схема реализации последовательного алгоритма ==<br />
<syntaxhighlight lang="python"><br />
beta[0] = 0 # инициализация<br />
q[0] = 0<br />
q[1] = b / norm(b) # вычисление первого столбца<br />
for j in [1 .. k]: # k итераций<br />
z = mul(A, q[j]) # вектор Ланцоша как произведение матрицы A на столбец q[j]<br />
alpha[j] = scalar_mul(q[j], z) # вычисление alpha[j]<br />
for i in [1 .. j - 1]: # полная переортогонализация<br />
z -= scalar_mul(z, q[i]) * q[i]<br />
beta[j] = norm(z) # вычисление нормы z<br />
if beta[j] == 0: # останов, если норма z равна нулю<br />
break<br />
result.append(next_ritz_number(alpha, beta, j)) # вычисление следующего собственного значения и вектора матрицы Tj<br />
return result<br />
</syntaxhighlight><br />
<br />
== Последовательная сложность алгоритма ==<br />
<br />
Основной вклад в сложность даёт полная переортогонализация: на каждой из <math>k</math> итераций для всех <math>i \in [0...j-1]</math> выполняется <math>2n</math> умножений и <math>2n</math> сложений, итого <math>\frac{k(k-1)}{2} 4n \approx 2k^2 n</math>. <br />
Таким образом, для метода с полной переортогонализацией сложность составляет <math>O(k^2 n)</math>, сложность по памяти -- <math>O(kn)</math>.<br />
<br />
== Информационный граф ==<br />
На рисунке приведён информационный граф одной итерации алгоритма<br />
[[File:Lanczos graph.png|thumb|center|800px|Рисунок 1. Информационный граф итерации алгоритма]]<br />
<br />
== Ресурс параллелизма алгоритма ==<br />
Для процесса переортогонализации возможна параллельная оптимизация в двух местах:<br />
* Итерации внутреннего цикла могут вычисляться параллельно, однако, требуется суммирование вычитаемых векторов, соответственно, сложность переортогонализации можно снизить с <math>O(kn)</math> до <math>O(n \log k)</math><br />
* В каждой итерации внутреннего цикла возможно распараллеливание вычисления выражения справа (скалярное произведение и умножение вектора на число), что теоретически позволяет снизить сложность итерации с <math>O(n)</math> до <math>O(log(n))</math><br />
<br />
== Входные и выходные данные алгоритма ==<br />
'''Входные данны'''е: квадратная симметрическая матрица <math>A</math> порядка <math>n</math><br />
<br />
'''Объём входных данных''': <math>n^2</math><br />
<br />
'''Выходные данные''': собственные числа матрицы<br />
<br />
'''Объём выходных данных''': <math>n</math><br />
<br />
== Свойства алгоритма ==<br />
Полная переортогонализация соответствует повторной процедуре ортогонализациии Грама-Шмидта для обеспечения ортогональности вектора <math>z</math> векторам <math>q_1, ..., q_k</math>. В случае идеально точной арифметики данная переортогонализация не требовалась бы, однако в реальных вычислениях ошибки округления приводят к потере ортогональности, в связи с чем требуется переортогонализация.<br />
Однако, единственной проблемой, возникающей при отсутствии переортогонализации, является появление повторных копий чисел Ритца (собственных значений), что в случае, если не требуется установление кратностей собственных значений, допустимо.<br />
<br />
Вычислительная мощность алгоритма примерно равна <math>2k^2 / n</math>.<br />
<br />
= Программная реализация алгоритма =<br />
<br />
<br />
== Особенности реализации последовательного алгоритма ==<br />
<br />
<br />
== [[Локальность данных и вычислений]] ==<br />
<br />
<br />
== Возможные способы и особенности параллельной реализации алгоритма ==<br />
<br />
== Масштабируемость алгоритма и его реализации ==<br />
<br />
Исследование масштабируемости алгоритма проводилось на суперкомпьютере IBM Blue Gene/P ВМК МГУ.<br />
<br />
Алгоритм тестировался на следующих параметрах:<br />
* размер входной матрицы: 2048-8192 с шагом 512<br />
* число узлов: 1-256 <br />
<br />
Зависимость времени выполнения от параметров изображена на графике:<br />
<br />
[[Файл:Lanczos full chart.png|center|border |800px]]<br />
Из рисунка видно, что алгоритм хорошо масштабируется, время выполнения на одном ядре растёт существенно быстрее чем на множестве ядер. При этом, для маленькой матрице на большом числе ядер прирост эффективности практически отсутствует.<br />
<br />
[http://pastebin.com/u7KThy6D Используемая реализация алгоритма на языке C++]<br />
<br />
Пример компиляции и запуска:<br />
$ mpixlcxx_r -o lanczos lanczos.cpp<br />
$ mpisubmit.bg -n 256 -w 00:5:00 lanczos<br />
<br />
== Динамические характеристики и эффективность реализации алгоритма ==<br />
<br />
== Выводы для классов архитектур ==<br />
<br />
<br />
== Существующие реализации алгоритма ==<br />
Библиотека [http://www.nag.co.uk/numeric/fl/nagdoc_fl23/html/INDEXES/KWIC/lanczos.html NAG Library] содержит ряд процедур для решения СЛАУ и поиска собственных значений на основе алгоритма Ланцоша.<br />
<br />
[http://www.mathworks.com/help/techdoc/ref/eigs.html MATLAB] и [https://www.gnu.org/software/octave/doc/interpreter/Sparse-Linear-Algebra.html#doc_002deigs GNU Octave] позволяют с помощью функции ''eigs()'' находить собственные значения на основе данного алгоритма.<br />
<br />
Matlab-реализация доступна как часть [http://www.cs.cmu.edu/~bickson/gabp/#download Gaussian Belief Propagation Matlab Package]. [http://www.graphlab.ml.cmu.edu/pmf.html GraphLab] содержит несколько параллельных реализаций алгоритма на C++.<br />
<br />
= Литература =</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%9E%D0%B1%D1%81%D1%83%D0%B6%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5_%D1%83%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA%D0%B0:Error0x0&diff=22491Обсуждение участника:Error0x02017-02-11T17:34:02Z<p>Chernyavskiy: /* Статья Участник:Error0x0/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией */</p>
<hr />
<div>== Статья [[Участник:Error0x0/Алгоритм Ланцоша для арифметики с плавающей точкой с полной переортогонализацией]] ==<br />
<br />
* В разделе 1.3 не приведено описание вычислительного ядра<br />
* Не указано ФИО автора<br />
* Не приведена краткая сводка свойств алгоритма в начале статьи<br />
<br />
Добавил.<br />
<br />
* В разделе 1.4 требуется привести описание алгоритма на верхнем уровне (на основе макроопераций). [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 17:35, 1 ноября 2016 (MSK)<br />
* В разделе 1.5 кроме кода нужны также текстовые пояснения. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 17:35, 1 ноября 2016 (MSK)<br />
* В разделе 1.10 должна быть оценка вычислительной мощности алгоритма. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 17:35, 1 ноября 2016 (MSK)<br />
* Не заполнен раздел 2.4 описания. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:44, 16 ноября 2016 (MSK)<br />
<br />
Пункты 1.4, 1.5, 1.10 исправлены, пункт 2.4 добавлен<br />
* В разделе 1.4 должно быть не перечисление макроопераций, а нужно показать структуру алгоритма на макроуровне. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 17:10, 3 февраля 2017 (MSK)<br />
* Граф, приведённый в разделе 1.7, не является информационным графом (направленный ациклический граф, вершины - операции, дуги - информационные зависимости). [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 17:10, 3 февраля 2017 (MSK)<br />
* В разделе 2.4 не приведены все параметры запуска теста - например, с какими опциями проводилась компиляция. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 17:10, 3 февраля 2017 (MSK) <br />
* Из графиков в разделе 2.4 следует сделать выводы о масштабируемости реализации. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 17:10, 3 февраля 2017 (MSK)<br />
<br />
Исправлено.<br />
<br />
<br />
Замечания:<br />
<br />
*Информационный граф должен содержать не просто макроструктуру, но и взаимодействие на уровне данных между различными операциями.<br />
*Из общего и, главное, математического описания алгоритма должно быть понятно, почему он работает (необходимы хотя бы краткие объяснения, а не просто шаги).<br />
*Сколько раз делается ортогонализация? Один или два?<br />
*Объясните, почему основной вклад дает только переортогонализация. Она сильно затратнее умножения матрицы на вектор?<br />
*Не совсем понятна последовательная сложность. В цикле ведь происходит умножение матрицы на вектор, а это квадратичная по размерности матрицы операция.</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA:Amirida/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%C2%AB%D1%80%D0%B0%D0%B7%D0%B4%D0%B5%D0%BB%D1%8F%D0%B9_%D0%B8_%D0%B2%D0%BB%D0%B0%D1%81%D1%82%D0%B2%D1%83%D0%B9%C2%BB_%D0%B2%D1%8B%D1%87%D0%B8%D1%81%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F_%D1%81%D0%BE%D0%B1%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D1%8B%D1%85_%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D0%B9_%D0%B8_%D0%B2%D0%B5%D0%BA%D1%82%D0%BE%D1%80%D0%BE%D0%B2_%D1%81%D0%B8%D0%BC%D0%BC%D0%B5%D1%82%D1%80%D0%B8%D1%87%D0%BD%D0%BE%D0%B9_%D1%82%D1%80%D0%B5%D1%85%D0%B4%D0%B8%D0%B0%D0%B3%D0%BE%D0%BD%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B9_%D0%BC%D0%B0%D1%82%D1%80%D0%B8%D1%86%D1%8B&diff=21800Участник:Amirida/Метод «разделяй и властвуй» вычисления собственных значений и векторов симметричной трехдиагональной матрицы2017-01-30T08:52:04Z<p>Chernyavskiy: </p>
<hr />
<div><br />
Метод «разделяй и властвуй» вычисления собственных значений и векторов симметричной трехдиагональной матрицы.<br />
<br />
Авторы:<br />
<br />
Изотова И.А. (619 группа) пункты 1.1, 1.2, 1.5, 1.7, 1.9<br />
<br />
Ульянов Г.В. (619 группа) пункты 1.3, 1.4, 1.6, 1.8, 1.10<br />
<br />
<br />
= Свойства и структура алгоритма =<br />
<br />
== Общее описание алгоритма ==<br />
'''«Разделяй и властвуй»''' - метод вычисления собственных значений и векторов симметричной трехдиагональной матрицы. В настоящее время это один из самых быстрых методов при вычислении собственных значений и векторов симметричной трехдиагональной матрицы порядка <math>n > 25</math> (точное значение этого порогового порядка зависит от компьютера.) Однако алгоритм не гарантирует высокой относительной точности для малых собственных значений.Его численно устойчивая реализация весьма не тривиальна. Хотя впервые метод был предложен еще в 1981 г., "правильный" способ его реализации был найден лишь в 1992 г. Этот способ воплощен LAPACK-программами ssyevd (для плотных матриц) и sstevd (для трехдиагональных матриц). В них стратегия "разделяй-и-влавствуй" используется для матриц порядка, большего чем 25. Для матриц меньшего порядка (или если нужны только собственные значения) происходит автоматический переход к QR-итерации. Однако, из-за высокой сложности, алгоритм пока не вошел в состав ALGLIB.<br />
<br />
В наихудшем случае алгоритм «разделяй-и-властвуй» требует <math> O(n^{3})</math> операций, но константа, на практике оказывается весьма малой. На большой выборке случайных тестовых матриц в среднем затрачивается лишь <math> O(n^{2.3})</math> операций с плавающей точкой, а для некоторых специальных распределений собственных значений — <math> O(n^{2})</math> (подробнее в разделе [[1.6 Последовательная сложность алгоритма]]).<br />
<br />
== Математическое описание алгоритма ==<br />
'''Разделяй'''<br />
<br />
Пусть матрицы <math>T, T_{1}</math>, <math>T_{2}</math> имеют размерность <math>n \times n</math>, <math>m \times m</math>, <math>(n - m) \times (n - m)</math>.<br />
<br />
Запишем матрицу <math>T</math> в следующем виде:<br />
<br />
:<math><br />
T = \begin{bmatrix}<br />
a_{1} & b_{1}&&&&& \\<br />
b_{1} & \ddots & \ddots \\<br />
& \ddots & a_{m-1} & b_{m-1} \\<br />
&& b_{m-1} & a_{m} & b_{m} \\<br />
&&& b_{m} & a_{m+1} & b_{m+1} \\<br />
&&&& b_{m+1} & \ddots \\<br />
&&&&&& \ddots & b_{n-1} \\<br />
&&&&&& b_{n-1} & a_{n} \\<br />
\end{bmatrix}<br />
= \begin{bmatrix}<br />
a_{1} & b_{1} &&&&& \\<br />
b_{1} & \ddots & \ddots \\<br />
& \ddots & a_{m-1} & b_{m-1} \\<br />
&& b_{m-1} & a_{m} - b_{m} \\<br />
&&&& a_{m+1} - b_{m} & b_{m+1} \\<br />
&&&& b_{m+1} & \ddots \\<br />
&&&&&& \ddots & b_{n-1} \\<br />
&&&&&& b_{n-1} & a_{n} \\<br />
\end{bmatrix} +<br />
</math><br />
<br />
<math><br />
+ \begin{bmatrix}<br />
b_{m} & b_{m} \\<br />
b_{m} & b_{m} \\<br />
\end{bmatrix}<br />
<br />
= \begin{bmatrix}<br />
T_{1} & 0 \\ <br />
0 & T_{2}<br />
\end{bmatrix} + b_{m} * \begin{bmatrix} 0 \\ \vdots \\ 0 \\ 1 \\ 1 \\ 0 \\ \vdots \\ 0 \end{bmatrix} \begin{bmatrix} 0 , \ldots , 0 , 1 , 1 , 0 \ldots , 0 \end{bmatrix} <br />
<br />
\equiv \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T}<br />
</math><br />
<br />
Предположим, что нам известны спектральные разложения матриц <math>\hat{T}_{1}</math> и <math>\hat{T}_{2}</math>, т.е.:<br />
<math>\hat{T}_{1} = Q_{1} D_{1} Q_{1}^{T}</math> и <math>\hat{T}_{2} = Q_{2} D_{2} Q_{2}^{T}</math>. <br />
<br />
'''Властвуй'''<br />
<br />
Установим связь между собственными значениями матрицы <math>T</math> и собственными значениями матриц <math>T_{1}</math> и <math>T_{2}</math>:<br />
<br />
<math> <br />
T = \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T} <br />
= \begin{bmatrix} Q_{1} \Lambda_{1} Q_{1}^{T} & 0 \\ 0 & Q_{2} L_{2} Q_{2}^{T}\end{bmatrix} + b_{m}vv^{T} <br />
= \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}(\begin{bmatrix} \Lambda_{1} & \\ & \Lambda_{2}\end{bmatrix} + b_{m}vv^{T})\begin{bmatrix} Q_{1}^{T} & 0 \\ 0 & Q_{2}^{T}\end{bmatrix}<br />
</math>,<br />
<br />
где <math> u = \begin{bmatrix} Q_{1}^{T} & 0 \\ 0 & Q_{2}^{T}\end{bmatrix}v </math> - матрица, в первой строке которой находятся элементы последнего столбца матрицы <math> Q_{1}^{T}</math>, а во второй - элементы первого столбца матрицы <math> Q_{2}^{T}</math>, так как <math>v = \begin{bmatrix} 0 , \ldots , 0 , 1 , 1 , 0 \ldots , 0 \end{bmatrix}^T</math>.<br />
Следовательно, <math>T</math> имеет такие же собственные значения, что и подобная ей матрица <math>D + \rho uu^{T}</math>, <br />
где <math>D = \begin{bmatrix} L_{1} & 0 \\ 0 & L_{2}\end{bmatrix}</math> - диагональная матрица, <br />
<math>\rho = b_{m}</math> - число, а <math>u</math> - вектор. <br />
В дальнейшем предполагаем, не ограничивая общности, что диагональные элементы <math>d_{1}, \ldots, d_{n}</math> матрицы <math>D</math> упорядочены по не возрастанию: <math>d_{n} <= \ldots <=d_{1}</math>.<br />
<br />
Для того, чтобы найти собственные значения матрицы <math>D + \rho uu^{T}</math>, потребуется вычислить её характеристический многочлен, считая пока матрицу <math>D - \lambda I</math> невырожденной.<br />
Тогда получаем<br />
<math>det(D + \rho uu^{T} - \lambda I) = det((D - \lambda I)(I + \rho (D- \lambda I)^{-1} uu^{T}))</math>.<br />
<br />
Так как <math>D - \lambda I</math> невырожденная, <math>det(I + \rho (D - \lambda I)^{-1}uu^{T}) = 0</math> тогда и только тогда, когда <math>\lambda</math> - является собственным значением. Можем заметить, что матрица <math>I + \rho (D - \lambda I)^{-1}uu^{T}</math> получается из единичной путём добавления матрицы ранга 1. Определитель такой матрицы не сложно вычислить.<br />
<br />
''Лемма 1.'' Справедливо равенство <math>det(I + xy^{T}) = 1 + y^{T}x</math>, где <math>x</math> и <math>y</math> - векторы.<br />
<br />
Следовательно, получаем<br />
<math>det(I + \rho (D - \lambda I)^{-1}uu^{T}) = 1 + \rho u^{T}(D - \lambda I)^{-1}u</math> <math> = 1 + \rho \sum_{i=1, n} \frac{u_{i}^{2}} {d_{i}-\lambda} \equiv f(\lambda)</math> , <br />
<br />
т.е. собственные значения матрицы <math>T</math> являются корнями так называемого векового уравнения <math>f(\lambda) = 0</math>. Если все числа <math>d_{i}</math> различны между собой и все <math>u_{i} <> 0</math> (случай общего положения), то <math>f(\lambda)</math> имеет график типа, который показан на рис.1(где <math>n = 4</math> и <math>\rho > 0</math>).<br />
<br />
[[File:График_функции.PNG|thumb|center|600px|Рис. 1. График функции <math> f(\lambda) = 1 + \frac{0.5}{1 - \lambda} + \frac{0.5}{2 - \lambda} + \frac{0.5}{3 - \lambda} + \frac{0.5}{4 - \lambda}</math>]]<br />
<br />
По Рис.1 можно заметить, что прямая <math>y = 1</math> является горизонтальной асимптотой для данного графика, а прямые <math>\lambda = d_{i}</math> есть вертикальные асимптоты. Так как <math>f^{'}(\lambda) = \rho \sum_{i=1, n} \frac{u_{i}^{2}} {(d_{i}-\lambda)^{2}}> 0 </math>, функция возрастает всюду, кроме точек <math>\lambda = d_{i}</math>. Из этого следует, что корни функции разделяются числами <math>d_{i}</math> и ещё один корень находится справа от точки <math>d_{1}</math> (на рис. 1 <math>d_{1} = 4</math>). (При <math>\rho<0</math> функция <math>f(\lambda)</math> всюду убывает и соответствующий корень будет находиться слева от точки <math>d_{n}</math>). Для функции <math>f(\lambda)</math>, которая является монотонной и гладкой на каждом из интервалов <math>(d_{i+1},d_{i})</math>, можно найти вариант метода Ньютона, который будет быстро и монотонно сходиться к каждому из корней, при условии, что начальная точка взята в <math>(d_{i+1},d_{i})</math>. Нам достаточно знать тот факт, что на практике метод сходится к каждому собственному значению за строго ограниченное число шагов. Поскольку вычисление <math>f(\lambda)</math> и <math>f^{'}(\lambda)</math> стоит <math>O(n)</math> флопов, для вычисления одного собственного значения достаточно <math>O(n)</math> флопов, следовательно для вычисления всех <math>n</math> собственных значений матрицы <math>D + \rho uu^{T}</math> потребуется <math>O(n^{2})</math> флопов.<br />
Для собственных векторов матрицы <math>D + \rho uu^{T}</math> мы легко можем получить явные выражения.<br />
<br />
''Лемма 2.'' Если <math>\alpha</math> - собственное значение матрицы <math>D + \rho uu^{T}</math>, то соответствующий вектор равен <math>(D - \alpha I)^{-1}u</math>. Поскольку матрица <math>D - \alpha I</math> диагональная, для вычисления такого вектора достаточно <math>O(n)</math> флопов.<br />
<br />
'''Доказательство:'''<br />
<br />
<math>(D + \rho uu^{T})[(D - \alpha I)^{-1}u] = <br />
<br />
(D - \alpha I + \alpha I + \rho uu^{T})(D - \alpha I)^{-1}u = <br />
<br />
u + \alpha (D - \alpha I)^{-1}u + u[\rho u^{T}(D - \alpha I)^{-1}u]= </math> <br />
<br />
<math> = u + \alpha(D - \alpha I)^{-1}u - u = \alpha [(D - \alpha I)^{-1}u]</math>, <br />
<br />
поскольку <br />
<br />
<math> \rho u^{T}(D - \alpha I)^{-1}u + 1 = f(\alpha) = 0 </math>. <br />
<br />
Что и требовалось доказать.<br />
<br />
Получается, что для вычисления по этой простой формуле всех <math>n</math> собственных векторов потребуется <math>O(n^{2})</math> флопов. К сожалению, данная формула не обеспечивает нам численной устойчивости, так как для двух очень близких значений <math>\alpha_{i}</math> может давать неортогональные приближенные собственные векторы <math>u_{i}</math>. Учёным потребовалось целое десятилетие для того, чтобы найти устойчивую альтернативу исходному описанию алгоритма. Подробнее детали будут обсуждаться ниже в данном разделе. <br />
<br />
== Вычислительное ядро алгоритма ==<br />
Вычислительным ядром последовательной схемы решения будет являться вычисление матрицы <math>Q</math> собственных векторов при помощи умножения матрицы <math>Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}</math> на матрицу <math>Q^{'}</math>. Эта операция имеет сложность <math>cn^{3}</math> о чём будет говориться ниже, в разделе [[#Последовательная сложность алгоритма|1.6 Последовательная сложность алгоритма]].<br />
<br />
Данной операции предшествует вычисление собственных значений и векторов матрицы <math> D + \rho uu^{T}</math>.<br />
<br />
== Макроструктура алгоритма ==<br />
<br />
Алгоритм "разделяй и властвуй" для вычисления собственных значений и векторов симметричной трехдиагональной матрицы состоит из вызова рекурсивной функции ''proc dc_eig'' <math>(T, Q, \Lambda)</math>, выполнение которой описывается следующими этапами: <br />
<br />
*Подаваемая на вход матрица <math>T</math> представляется в виде <math> T = \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T} </math>, представление в таком виде возможно до тех пор, пока размерность матрицы <math>T</math> не достгнет 1. <br />
<br />
*От матриц <math>T_{1}</math> и <math>T_{2}</math> также вызываются соотвтетствующие функции ''proc dc_eig'' <math>(T_{1}, Q_{1}, \Lambda_{1})</math> и ''proc dc_eig'' <math>(T_{2}, Q_{2}, \Lambda_{2})</math>.<br />
<br />
*Вычисляются матрицы <math>D+\rho uu^{T}</math> по <math> \Lambda_{1},\Lambda_{2}, Q_{1}, Q_{2}</math>.<br />
<br />
*Вычисление собственных значений<math>\Lambda</math> и векторов <math>Q^{'}</math> для матрицы <math>D+\rho uu^{T}</math>.<br />
<br />
*Построение матрицы собственных векторов <math>Q</math>для матрицы <math>T</math>.<br />
<br />
== Схема реализации последовательного алгоритма ==<br />
Рассмотри реализацию метода "разделяй и властвуй" в виде алгоритма, состоящего из частного случая, когда матрица <math>T</math> имеет размерность <math>1 \times 1</math> и общего случая, когда матрица <math>T</math> - симметричная трехдиагональная матрица произвольной размерности, кроме <math>1 \times 1</math>:<br />
<br />
''proc dc_eig'' <math>(T, Q, \Lambda) ... </math> по входной матрице <math>T</math> вычисляются выходные матрицы <math>Q</math> и <math>\Lambda</math>, такие, что <math>T = Q\Lambda Q^{T}</math><br />
''if'' матрица <math>T</math> имеет размерность <math>1 \times 1</math> (''проверяем матрицу <math>T</math> на принадлежность частному случаю алгоритма'')<br />
''then''<br />
присвоить выходным параметрам значения <math>Q = 1, \Lambda = T</math> (''если матрица <math>T</math> <math>1 \times 1</math>, то СЗ и СВ матрицы <math>T</math> найдены'')<br />
''else'' (''если матрица <math>T</math> имеет общей вид, то:'')<br />
<math>T</math> в виде <math> T = \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T} </math> (''разложим матрицу <math>T</math>'')<br />
''call dc_eig''<math>(T_{1},Q_{1},\Lambda_{1})</math> (''вызываем рекурсивно функцию ''dc_eig'', вычисляющую СЗ и СВ матрицы <math>T_1</math>'')<br />
''call dc_eig''<math>(T_{2},Q_{2},\Lambda_{2})</math> (''вызываем рекурсивно функцию ''dc_eig'', вычисляющую СЗ и СВ матрицы <math>T_2</math>'')<br />
Построить <math>D+\rho uu^{T}</math> по <math> \Lambda_{1},\Lambda_{2}, Q_{1}, Q_{2}</math><br />
Найти матрицу собственных значений <math>\Lambda</math><br />
Найти матрицу собственных векторов <math>Q^{'}</math> для матрицы <math>D+\rho uu^{T}</math><br />
Построить матрицу собственных векторов <math>Q</math> для матрицы <math>T</math> : <math> Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & <br />
Q_{2}\end{bmatrix}* Q^{'} </math><br />
Присвоить выходным параметрам значения <math>Q</math> и <math>\Lambda</math><br />
'''endif'''<br />
<br />
== Последовательная сложность алгоритма ==<br />
Пусть <math>t(n)</math> - число флопов при обработке матрицы размера <math>n \times n</math> процедурой ''dc_eig''. Тогда <br />
<br />
<math>t(n) = 2t(n/2)</math> два рекурсивных обращения к ''dc_eig''<math>(T_{i},Q_{i},\Lambda_{i})</math><br />
<br />
''<math>+O(n^{2})</math> вычисление собственных значений матрицы <math>D+\rho uu^{T}</math><br />
<br />
<math>+O(n^{2})</math> вычисление собственных векторов матрицы <math>D+\rho uu^{T}</math><br />
<br />
<math>+c*n^{3}</math> вычисление матрицы <math>Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}*Q^{'}</math>''<br />
<br />
<br />
Если <math> Q_{1}, Q_{2}</math> и <math>Q^{'}</math> рассматриваются как плотные матрицы и используется стандартный алгоритм матричного умножения, то константа <math> c </math> в последней строке равна 1. Таким образом, именно это умножение составляет наиболее трудоёмкую часть алгоритма в целом. Игнорируя члены порядка <math>n^{2}</math>, получаем <math>t(n) = 2t(n/2) + cn^{3}</math>. Решая это разностное уравнение, находим <math> t \approx c\frac{4}{3}n^{3} </math><br />
<br />
На практике обычно <math>c<<1</math> ( так как матрица <math>Q^{'}</math> весьма разрежена вследствие дефляциии).<br />
<br />
== Информационный граф ==<br />
В данном разделе представлен информационный граф алгоритма: на рисунке 2 изображена часть алгоритма, в которой происходит деление - "разделяй", а на рисунке 3 описана часть "властвуй".<br />
<br />
[[File:Divide.png|thumb|center|left|8000px|Рис. 2 Информационный граф шага "разделяй"]]<br />
<br />
[[File:Conq.png|thumb|center|left|8000px|Рис. 3 Информационный граф шага "властвуй"]]<br />
<br />
Операции: <br />
<br />
*<math>D</math> - операция "разделяй" разделения матрицы <math> T </math> на матрицы <math>T_{1}</math> и <math>T_{2}</math><br />
<br />
*<math>C_{n}</math> - операция "властвуй" сбора матрицы <math> D_{n*n} </math><br />
<br />
*<math> R_{n} </math> - операция поиска собственных значений матрицы <math> T_{n*n} </math><br />
<br />
*<math> S^{'}_{n} </math> - операция поиска собственных векторов матрицы <math> D_{n*n} </math><br />
<br />
*<math> S_{n} </math> - операция поиска собственных векторов матрицы <math> T_{n*n} </math><br />
<br />
Данные:<br />
<br />
*<math>Q_{n}</math> - вектор собственных значений размерности <b>n</b>. <br />
<br />
*<math>V_{n*n}</math> - матрица собственных векторов размерности <b>n</b>.<br />
<br />
== Ресурс параллелизма алгоритма ==<br />
Параллелизм достигается за счёт вызова рекурсивных функций ''dc_eig'', вычисляющих собственные значения и собственные вектора матриц <math>T_1</math> и <math>T_2</math>. Рекурсивное разделение матрицы приводит к возможности построения структуры в виде двоичного дерева, в каждой вершине которого происходит вычисение функции ''dc_eig''. Таким образом высота ярусно-параллельной формы, где вычисления для каждого листа дерева в такой структуре происходят независимо, составляет <math>log_2(n)</math>.<br />
<br />
== Входные и выходные данные алгоритма ==<br />
'''Входные данные:'''<br />
<br />
Матрица <math>T</math> размерностью <math>n \times n</math>:<br />
:<math><br />
T = \begin{bmatrix}<br />
a_{1} & b_{1}&&&&& \\<br />
b_{1} & \ddots & \ddots \\<br />
& \ddots & a_{m-1} & b_{m-1} \\<br />
&& b_{m-1} & a_{m} & b_{m} \\<br />
&&& b_{m} & a_{m+1} & b_{m+1} \\<br />
&&&& b_{m+1} & \ddots \\<br />
&&&&&& \ddots & b_{n-1} \\<br />
&&&&&& b_{n-1} & a_{n} \\<br />
\end{bmatrix}<br />
</math><br />
<br />
'''Объем входных данных:'''<br />
<br />
<math>2n-1</math> - хранить следует только диагональные, поддиагональные и наддиагональные элементы.<br />
<br />
'''Выходные данные:'''<br />
<br />
Собственные значения <math>\alpha_{i}</math> (всего <math>n</math>) и собственные векторы <math>\lambda_{i}</math> (всего <math>n^2</math>).<br />
<br />
'''Объем выходных данных:'''<br />
<br />
<math>n+n^2</math><br />
<br />
== Свойства алгоритма ==<br />
1. Один из самых быстрых алгоритмов вычисления вектора собственных значений и собственных векторов, соответствующих собственным значениям, матриц порядка большего, чем 25.<br />
<br />
2. Вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных – линейна.<br />
<br />
3. Алгоритм не гарантирует высокой относительной точности для малых собственных значений.<br />
<br />
= Программная реализация алгоритма =<br />
<br />
== Особенности реализации последовательного алгоритма ==<br />
<br />
== Локальность данных и вычислений ==<br />
<br />
== Возможные способы и особенности параллельной реализации алгоритма ==<br />
<br />
== Масштабируемость алгоритма и его реализации ==<br />
<br />
Исследование проводилось на суперкомпьютере "Ломоносов" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].<br />
<br />
Для исследования масштабируемости алгоритм был реализован с использованием библиотеки OpenMP 1.5.5 для языка C++(компилятор g++) на cуперкомпьютере Ломоносов на узле compiler. Максимальное число потоков для данного узла равно 8. Для оценки масштабируемости, программа была запущена в 1, 2, 4, 8 потока. Код исследуемой реализации представлен по [https://github.com/Zero-ger/Tasks следующей ссылке]<br />
<br />
Набор и границы значений изменяемых параметров запуска реализации алгоритма: <br />
<br />
* число процессоров [1 : 8] (1,2,3,4,8);<br />
* размер матрицы [4 : 8192].<br />
<br />
Параметры компиляции и запуска: <br />
<br />
ssh compiler <br />
module add slurm<br />
module add openmpi/1.5.5-icc<br />
g++ GetValues.cxx -fopenmp -std=c++0x -o _scratch/mytask<br />
cd _scratch/<br />
sbatch -p test -n1 run ./mytask<br />
<br />
Для управления количеством потоков использовалась операция OpenMP omp_set_num_threads();<br />
<br />
<br />
[[File:Graph.png|thumb|center|left|800px|Рис. 6. График времени работы программы в зависимости от размера задачи и числа процессов]]<br />
<br />
<br />
Проведем оценки масштабируемости:<br />
<br />
* '''По размеру задачи''' — при увеличении размерности матрицы общая эффективность программы постепенно уменьшается. Это связано с тем, что время чтения и подготовки исходных данных растёт быстрее, чем время работы исследуемого алгоритма.<br />
* '''По числу процессов''' - при увеличении числа процессов общая эффективность программы увеличивается. Это связано с тем, что время чтения и подготовки исходной матрицы остаётся неизменным, а время работы алгоритма уменьшается, однако рост незначительный.<br />
* При одновременном увеличении числа процессов и размерности матрицы общая эффективность программы уменьшается.<br />
<br />
== Динамические характеристики и эффективность реализации алгоритма ==<br />
<br />
== Выводы для классов архитектур ==<br />
<br />
== Существующие реализации алгоритма ==<br />
<br />
Метод "Разделяй и властвуй" реализован в пакете LAPACK, описание которого можно найти в данной [http://www.netlib.org/lapack/lawnspdf/lawn132.pdf статье].<br />
<br />
= Литература =<br />
[1] Джеймс Деммель. Вычислительная линейная алгебра. Теория и приложения. изд. Мир, 1/1/2001. — С. 228 - 236.<br />
<br />
[2] [https://en.wikipedia.org/wiki/Divide-and-conquer_eigenvalue_algorithm Divide-and-conquer eigenvalue algorithm]<br />
<br />
[3] Gr´egoire Pichon, Azzam Haidar, Mathieu Faverge, Jakub Kurzak. Divide and Conquer Symmetric Tridiagonal Eigensolver<br />
for Multicore Architectures. 2015. — С. 1 - 11.<br />
<br />
[4] C.F. Borges, W.B. Gragg, A parallel divide-and-conquer method for the generalized real symmetric definite tridiagonal<br />
eigenproblem, in: L. Reichel, A. Ruttan, R.S. Varga (Eds.), Numerical Linear Algebra, Proc. Conf. in Numerical<br />
Linear Algebra and Scientific Computation, Kent, OH, de Gruyter, Berlin, 1993. — С. 11–29<br />
<br />
[5] L. Elsner, A. Fasse, E. Langmann. A divide-and-conquer method for the tridiagonal generalized eigenvalue problem. Journal of Computational and Applied Mathematics. 1997. — С. 141 - 148.<br />
<br />
[6] [http://www.netlib.org/lapack/lawnspdf/lawn132.pdf Francoise Tisseury, Jack Dongarra, Parallelizing the Divide and Conquer Algorithm for the Symmetric Tridiagonal Eigenvalue Problem on Distributed Memory Architectures]<br />
<br />
[[en:Description of algorithm properties and structure]]</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%9E%D0%B1%D1%81%D1%83%D0%B6%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5_%D1%83%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA%D0%B0:Amirida&diff=21799Обсуждение участника:Amirida2017-01-30T08:51:47Z<p>Chernyavskiy: </p>
<hr />
<div>== Статья [[Участник:Amirida/Метод «разделяй и властвуй» вычисления собственных значений и векторов симметричной трехдиагональной матрицы ]] ==<br />
<br />
=== Отсутствующие части ===<br />
* Пропущен раздел описания 2.4. Масштабируемость алгоритма и его реализации. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 11:25, 9 ноября 2016 (MSK)<br />
* Не заполнен раздел 2.4 описания. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:28, 16 ноября 2016 (MSK)<br />
<br />
=== Замечания по тексту ===<br />
* В разделе 1.4 требуется привести описание алгоритма на верхнем уровне (на основе макроопераций). [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 11:25, 9 ноября 2016 (MSK)<br />
* В разделе 1.5 кроме кода нужны также текстовые пояснения. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 11:25, 9 ноября 2016 (MSK)<br />
* Граф, приведённый в разделе 1.7 не является информационным графом (ациклический граф, вершины - операции, дуги - информационные зависимости). [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 11:25, 9 ноября 2016 (MSK)<br />
* В разделе 1.8 используется непонятный термин "высота алгоритма". [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 11:25, 9 ноября 2016 (MSK)<br />
* В разделе 1.10 не нужно дублировать последовательную сложность алгоритма, но требуется привести оценку вычислительной мощности. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 11:25, 9 ноября 2016 (MSK)<br />
* Отсутствует информация в разделе 2.7 (по текущей нумерации 2.6). [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 11:25, 9 ноября 2016 (MSK)<br />
<br />
<br />
=== Дополнительно (03.12) === <br />
[[Участник:chernyavskiy]]<br />
<br />
*Для ускорение дальнейшей проверки укажите на этой странице (в данном разделе) подробно источники, из которых брались разделы и их части. Если раздел писался самостоятельно - укажите это.<br />
<br />
Разделы:<br />
<br />
1.1 - Джеймс Деммель. Вычислительная линейная алгебра. стр. 228<br />
<br />
1.2 - Джеймс Деммель. Вычислительная линейная алгебра. стр. 228-233<br />
<br />
1.3 - Джеймс Деммель. Вычислительная линейная алгебра. стр. 232<br />
<br />
1.4 - Джеймс Деммель. Вычислительная линейная алгебра. стр. 232<br />
<br />
1.5 - Джеймс Деммель. Вычислительная линейная алгебра. стр. 232<br />
<br />
1.6 - Джеймс Деммель. Вычислительная линейная алгебра. стр. 232, https://en.wikipedia.org/wiki/Divide-and-conquer_eigenvalue_algorithm<br />
<br />
1.7 - Писали сами<br />
<br />
1.8 - Писали сами<br />
<br />
1.9 - Писали сами<br />
<br />
1.10 - Джеймс Деммель. Вычислительная линейная алгебра<br />
<br />
2.4 - Писали сами<br />
<br />
2.7 - Писали сами<br />
<br />
=== Новые замечания и вопросы ===<br />
<br />
Замечания:<br />
1) Необходимо исправить ошибки в разделе 1.2.<br />
2) Необходимо изменить информационный граф: не видна связь между шагами "разделяй" и "властвуй". <br />
3) В разделе 1.1 написано:<br />
<br />
"В наихудшем случае алгоритм «разделяй-и-властвуй» требует <math> O(n^{3})</math> операций, но константа, на практике оказывается весьма малой. На большой выборке случайных тестовых матриц в среднем затрачивается лишь <math> O(n^{2.3})</math> операций с плавающей точкой, а для некоторых специальных распределений собственных значений — <math> O(n^{2})</math> (подробнее в разделе [[1.6 Последовательная сложность алгоритма]])."<br />
<br />
Во-первых, не работает ссылка, а во-вторых, в разделе 1.6. я не вижу обоснования приведенным здесь оценкам.<br />
<br />
4) В разделе 1.6. встречается слово "дефляция". Больше в описании про дефляцию ни слова. Необходимо добавить. И определение, и роль в алгоритме.<br />
<br />
Также прошу ответить на несколько вопросов:<br />
1) Что такое общая ''эффективность программы''?<br />
2) Чем ''общая эффективность программы'' отличается от ''эффективности программы''?<br />
3) Как алгоритм работает с кратными собственными значениями?</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA:%D0%A0%D0%BE%D0%BC%D0%B0%D0%BD_%D0%97%D0%B5%D0%BC%D0%BB%D1%8F%D0%BD%D1%81%D0%BA%D0%B8%D0%B9/Zavolskov/Zemlyanskiy&diff=20094Участник:Роман Землянский/Zavolskov/Zemlyanskiy2016-12-05T12:11:11Z<p>Chernyavskiy: </p>
<hr />
<div><!--{{Assignment|IgorS}}--><br />
<br />
'''Метод «разделяй и властвуй» вычисления собственных значений и векторов симметричной трехдиагональной матрицы'''<br />
<br />
Авторы статьи: <br />
<br />
'''Завольсков Владислав''' <br />
<br />
[[#Вычислительное ядро алгоритма]]<br />
<br />
[[#Макроструктура алгоритма]]<br />
<br />
[[#Схема реализации последовательного алгоритма]]<br />
<br />
[[#Информационный граф]]<br />
<br />
[[#Существующие реализации алгоритма]]<br />
<br />
'''Землянский Роман'''<br />
<br />
[[#Общее описание алгоритма]]<br />
<br />
[[#Математическое описание алгоритма]]<br />
<br />
[[#Последовательная сложность алгоритма]]<br />
<br />
[[#Ресурс параллелизма алгоритма]]<br />
<br />
[[#Входные и выходные данные алгоритма]]<br />
<br />
[[#Свойства алгоритма]]<br />
<br />
<br />
614 группа<br />
<br />
= ЧАСТЬ. Свойства и структура алгоритмов =<br />
== Общее описание алгоритма ==<br />
'''Метод разделяй и властвуй вычисления собственных значений и векторов трёхдиагональной матрицы''' - это наиболее быстрый из существующих методов, если нужны все собственные значения и собственные векторы трехдиагональной матрицы, начиная с порядка n, примерно равного 26. (Точное значение этого порогового порядка зависит от компьютера.) Его численно устойчивая реализация весьма не тривиальна. В самом деле, хотя впервые метод был предложен еще в 1981 г., "правильный" способ его реализации был найден лишь в 1992 г. Этот способ воплощен LAPACK-программами ssyevd (для плотных матриц) и sstevd (для трехдиагональных матриц). В них стратегия "разделяй-и-влавствуй" используется для матриц порядка, большего чем 25. Для матриц меньшего порядка (или если нужны только собственные значения) происходит автоматический переход к QR-итерации.<br />
<br />
== Математическое описание алгоритма ==<br />
Пусть <br />
<br />
:<math><br />
L = \begin{bmatrix}<br />
a_{1} & b_{1}&&&&& \\<br />
b_{1} & \ddots & \ddots \\<br />
& \ddots & a_{m-1} & b_{m-1} \\<br />
&& b_{m-1} & a_{m} & b_{m} \\<br />
&&& b_{m} & a_{m+1} & b_{m+1} \\<br />
&&&& b_{m+1} & \ddots \\<br />
&&&&&& \ddots & b_{n-1} \\<br />
&&&&&& b_{n-1} & a_{n} \\<br />
\end{bmatrix}<br />
= \begin{bmatrix}<br />
a_{1} & b_{1} &&&&& \\<br />
b_{1} & \ddots & \ddots \\<br />
& \ddots & a_{m-1} & b_{m-1} \\<br />
&& b_{m-1} & a_{m} - b_{m} \\<br />
&&&& a_{m+1} - b_{m} & b_{m+1} \\<br />
&&&& b_{m+1} & \ddots \\<br />
&&&&&& \ddots & b_{n-1} \\<br />
&&&&&& b_{n-1} & a_{n} \\<br />
\end{bmatrix} +<br />
</math><br />
<br />
<math><br />
+ \begin{bmatrix}<br />
&&&&& \\<br />
&&b_{m} & b_{m} \\<br />
&&b_{m} & b_{m} \\<br />
&&&&& \\<br />
\end{bmatrix}<br />
<br />
= \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m} * \begin{bmatrix} 0 \\ \vdots \\ 0 \\ 1 \\ 1 \\ 0 \\ \vdots \\ 0 \end{bmatrix} \begin{bmatrix} 0 , \ldots , 0 , 1 , 1 , 0 \ldots , 0 \end{bmatrix} <br />
<br />
\equiv \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T}<br />
</math><br />
<br />
Предположим, что нам известны спектральные разложения матриц <math>T_{1}</math> и <math> T_{2} </math>: <br />
<math> T_{i} = Q_{i} \Lambda_{i} Q_{i}^{T} </math>. В действительности, они будут рекурсивно вычисляться тем же самым алгоритмом. Установим связь между собственными значениями матрицы Т и собственными значениями матриц<br />
<math>T_{1}</math> и <math>T_{2}</math>. Имеем:<br />
<br />
<math> <br />
T = \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T} <br />
= \begin{bmatrix} Q_{1} \Lambda_{1} Q_{1}^{T} & 0 \\ 0 & Q_{2} \Lambda_{2} Q_{2}^{T}\end{bmatrix} + b_{m}vv^{T} <br />
= \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}(\begin{bmatrix} \Lambda_{1} & \\ & \Lambda_{2}\end{bmatrix} + b_{m}vv^{T})\begin{bmatrix} Q_{1}^{T} & 0 \\ 0 & Q_{2}^{T}\end{bmatrix}<br />
</math>,<br />
<br />
где <br />
<br />
<math><br />
u = \begin{bmatrix} Q_{1}^{T} & 0 \\ 0 & Q_{2}^{T}\end{bmatrix}v<br />
</math><br />
<br />
так как <math>v = \begin{bmatrix} 0 , \ldots , 0 , 1 , 1 , 0 \ldots , 0 \end{bmatrix}^T</math>, получим матрицу, состоящую из последнего столбца матрицы <math> Q_{1}^{T}</math> и первого столбца матрицы <math> Q_{2}^{T}</math>.<br />
<br />
Следовательно, <math>T</math> имеет те же собственные значения, что и подобная ей матрица <math>D + \rho uu^{T}</math>, <br />
где <math>D = \begin{bmatrix} \Lambda_{1} & 0 \\ 0 & \Lambda_{2}\end{bmatrix}</math> - диагональная матрица, <br />
<math>\rho = b_{m}</math> - число, а <math>u</math> - вектор. <br />
<br />
Будем предполагать, не ограничивая общности, что диагональные элементы <math>d_{1}, \ldots, d_{n}</math> матрицы <math>D</math> упорядочены по убыванию: <math>d_{n} <= \ldots <=d_{1}</math>.<br />
<br />
Чтобы найти собственные значения матрицы <math>D + \rho uu^{T}</math>, вычислим её характеристический многочлен, считая пока матрицу <math>D - \lambda I</math> невырожденной.<br />
Тогда<br />
<br />
<math>det(D + \rho uu^{T} - \lambda I) = det((D - \lambda I)(I + \rho (D- \lambda I)^{-1} uu^{T}))</math>.<br />
<br />
Поскольку <math>D - \lambda I</math> невырожденна, <math>det(I + \rho (D - \lambda I)^{-1}uu^{T}) = 0</math> тогда и только тогда, когда <math>\lambda</math> - собственное значение. Заметим, что матрица <math>I + \rho (D - \lambda I)^{-1}uu^{T}</math> получается из единичной добавлением матрицы ранга 1. Определитель такой матрицы легко вычислить.<br />
<br />
'''Лемма 1.''' Справедливо равенство <math>det(I + xy^{T}) = 1 + y^{T}x</math>, где <math>x</math> и <math>y</math> - векторы.<br />
<br />
Таким образом,<br />
<br />
<math>det(I + \rho (D - \lambda I)^{-1}uu^{T}) = 1 + \rho u^{T}(D - \lambda I)^{-1}u</math> <math> = 1 + \rho \sum_{i=1, n} \frac{u_{i}^{2}} {d_{i}-\lambda} \equiv f(\lambda)</math> , <br />
<br />
т.е. собственные значения матрицы <math>T</math> есть корни так называемого векового уравнения <math>f(\lambda) = 0</math>. Если все числа <math>d_{i}</math> различны и все <math>u_{i} <> 0</math> (случай общего положения), то <math>f(\lambda)</math> имеет график типа показанного на рис.1(где <math>n = 4</math> и <math>\rho > 0</math>).<br />
<br />
[[File:Graphics.PNG|thumb|center|800px|Рис. 1. График функции <math> f(\lambda) = 1 + \frac{0.5}{1 - \lambda} + \frac{0.5}{2 - \lambda} + \frac{0.5}{3 - \lambda} + \frac{0.5}{4 - \lambda}</math>]]<br />
<br />
Можно видеть, что прямая <math>y = 1</math> является горизонтальной асимптотой для этого графика, а прямые <math>\lambda = d_{i}</math> есть вертикальные асимптоты. Поскольку <math>f^{'}(\lambda) = \rho \sum_{i=1, n} \frac{u_{i}^{2}} {(d_{i}-\lambda)^{2}}> 0 </math>, функция возрастает всюду, кроме точек <math>\lambda = d_{i}</math>. Поэтому корни функции разделяются числами <math>d_{i}</math> и ещё один корень находится справа от точки <math>d_{1}</math> (на рис. 1 <math>d_{1} = 4</math>). (При <math>\rho<0</math> функция <math>f(\lambda)</math> всюду убывает и соответствующий корень находится слева от точки <math>d_{n}</math>). Для функции <math>f(\lambda)</math>, монотонной и гладкой на каждом из интервалов <math>(d_{i+1},d_{i})</math>, можно найти вариант метода Ньютона, который быстро и монотонно сходится к каждому из корней, если начальная точка взята в <math>(d_{i+1},d_{i})</math>. Нам достаточно знать, что на практике метод сходится к каждому собственному значению за ограниченное число шагов. Поскольку вычисление <math>f(\lambda)</math> и <math>f^{'}(\lambda)</math> стоит <math>O(n)</math> флопов, для вычисления одного собственного значения достаточно <math>O(n)</math>, а для вычисления всех <math>n</math> собственных значений матрицы <math>D + \rho uu^{T}</math> требуется <math>O(n^{2})</math> флопов.<br />
Для собственных векторов матрицы <math>D + \rho uu^{T}</math> мы легко можем получить явные выражения.<br />
<br />
'''Лемма 2.''' Если <math>\alpha</math> - собственное значение матрицы <math>D + \rho uu^{T}</math>, то соответствующий вектор равен <math>(D - \alpha I)^{-1}u</math>. Поскольку матрица <math>D - \alpha I</math> диагональная, для вычисления такого вектора достаточно <math>O(n)</math> флопов.<br />
<br />
Доказательство.<br />
<br />
<math>(D + \rho uu^{T})[(D - \alpha I)^{-1}u] = (D - \alpha I + \alpha I + \rho uu^{T})(D - \alpha I)^{-1}u</math><br />
<br />
<math>=u + \alpha (D - \alpha I)^{-1}u + u[\rho u^{T}(D - \alpha I)^{-1}u] </math><br />
<br />
<math>=u + \alpha(D - \alpha I)^{-1}u - u</math> <br />
<br />
поскольку <math> \rho u^{T}(D - \alpha I)^{-1}u + 1 = f(\alpha) = 0 </math><br />
<br />
<math>=\alpha [(D - \alpha I)^{-1}u]</math>, что и требовалось.<br />
<br />
<br />
Для вычисления по этой простой формуле всех <math>n</math> собственных векторов требуется <math>O(n^{2})</math> флопов. К сожалению, формула не обеспечивает численной устойчивости, так как для двух очень близких значений <math>\alpha_{i}</math> может давать неортогональные приближенные собственные векторы <math>u_{i}</math>. Потребовалось целое десятилетие для того, чтобы найти устойчивую альтернативу исходному описанию алгоритма. Снова детали будут обсуждаться позднее в данном разделе. <br />
<br />
Алгоритм является рекурсивным.<br />
<br />
=== Дефляция ===<br />
<br />
До сих пор полагалось, что все <math>d_{i}</math> различны и все <math>u_{i}</math> отличны от нуля. Если это не так, вековое уравнение <math>f(\lambda)=0</math> имеет <math>k</math> вертикальных асимптот, где <math>k<n</math>, а потому <math>k</math> корней. Однако оказывается, что остальные <math>n - k</math> собственных значений могут быть определены без каких-либо усилий: если <math>d_{i}=d_{i+1}</math> или <math>u_{i}=0</math>, то легко показать, что <math>d_{i}</math> является собственным значением и для матрицы <math>D + \rho uu^{T}</math>. В такой ситуации мы говорим о ''дефляции''. На практике выбирается некоторое пороговое значение и дефляция для числа <math>d_{i}</math> регистрируется, если в смысле этого порога <math>d_{i}</math> достаточно близко к <math>d_{i+1}</math> либо <math>u_{i}</math> достаточно мало.<br />
<br />
Основной выигрыш от использования дефляции состоит не в том, что убыстряется решение векового уравнения - этот этап в любом случае стоит лишь <math>O(n^{2})</math> операций. Выигрыш заключается в ускорении матричного умножения на последнем шаге алгоритма. Действительно, если <math>u_{i}=0</math>, то соответствующий собственный вектор есть i-й столбец <math>e_{i}</math> единичной матрицы. Это означает, что <math>e_{i}</math> является i-м столбцом в матрице <math>Q_{'}</math>, поэтому при формировании матрицы <math>Q</math> посредством левого умножения <math>Q_{1}</math> на <math>Q_{2}</math> вычисление i-го столбца не требует никаких затрат. Аналогичное упрощение имеет место в случае <math>d_{i} = d_{i+1}</math>. При дефляции многих собственных значений устраняется большая часть работы, связанной с матричным умножением.<br />
<br />
== Вычислительное ядро алгоритма ==<br />
Вычислительным ядром последовательной схемы решения является вычисление матрицы <math>Q</math> собственных векторов путём умножения матрицы <math>Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}</math> на матрицу <math>Q^{'}</math> Данная операция имеет сложность <math>cn^{3}</math> о чём и говорится в разделе [[#Последовательная сложность алгоритма]] .<br />
Ей предшествует вычисление собственных значений и векторов матрицы <math> D + \rho uu^{T}</math><br />
<br />
== Макроструктура алгоритма ==<br />
Ниже описана структура алгоритма, в которой есть блок умножения матриц для вычисления собственных векторов, являющийся вычислительным ядром алгоритма. В соответствующем разделе ([[#Вычислительное ядро алгоритма]]) мы упоминали о том, что данному блоку предшествует вычисление собственных значений, которое производится [https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D0%9D%D1%8C%D1%8E%D1%82%D0%BE%D0%BD%D0%B0 методом Ньютона].<br />
<br />
[[File:DivideAndConquerTree.png|thumb|center|left|800px|Рис. 2. Дерево алгоритма "Разделяй и властвуй"]]<br />
<br />
[[File:InfoGraph.jpg|thumb|center|1200px|Рис. 3. Детальное описание одного блока алгоритма]]<br />
<br />
=== Решение векового уравнения ===<br />
Подробно стоит поговорить о решении векового уравнения, которое является одной из основных частей алгоритма.<br />
<br />
Предположим, что некоторое <math>u_{i}</math>, хотя и мало, все же недостаточно мало для того, чтобы была зарегистрирована дефляция. В этом случае применение метода Ньютона к решению векового уравнения встречается с затруднениями. Вспомним, что пересчет приближённого решения <math>u_{j}</math> уравнения <math>f(\lambda) = 0</math> в методе Ньютона основан на следующих положениях:<br />
<br />
1. Вблизи точки <math>\lambda = \lambda_{j}</math> функция <math>f(\lambda)</math> аппроксимируется линейной функцией <math>l(\lambda)</math>; график есть прямая линия, касающаяся графика функции <math>f(\lambda)</math> при <math>\lambda = \lambda_{j}</math>.<br />
<br />
2. В качестве <math>\lambda_{j+1}</math> берётся нуль этого линейного приближения, т.е. <math>l(\lambda_{j+1})=0</math>.<br />
<br />
Функция, показанная на рис.1, не доставляет видимых трудностей методу Ньютона, поскольку вблизи каждого своего нуля <math>f(\lambda)</math> достаточно хорошо аппроксимируется линейными функциями. Однако рассмотрим график функции на рис. 4. Она получена из функции на рис. 1 заменой значения .5 для <math>u_{i}^{2}</math> на .001. Это новое значение недостаточно мало для того, чтобы вызвать дефляцию. График функции в левой части рис.4 визуально не отличим от её вертикальных и горизонтальных асимптот, поэтому в правой части укрупненно воспроизведён фрагмент графика, прилегающий к вертикальной асимптоте <math>\lambda = 2</math>. Видно, что график слишком быстро "выполняет поворот" и для большей части значений <math>\lambda</math> почти горизонтален. Поэтому, применяя метод Ньютона почти к любому начальному приближению <math>\lambda_{0}</math>, мы получаем линейное приближение <math>l(\lambda)</math> с почти горизонтальным графиком и малым положительным угловым коэффициентом. В результате <math>\lambda_{1}</math> является отрицательным числом, огромным по абсолютной величине, которое совершенно бесполезно в качестве приближения к истинному корню.<br />
<br />
[[File:GraphNewton.png|thumb|center|800px|Рис. 4. График функции <math> f(\lambda) = 1 + \frac{10^{-3}}{1 - \lambda} + \frac{10^{-3}}{2 - \lambda} + \frac{10^{-3}}{3 - \lambda} + \frac{10^{-3}}{4 - \lambda}</math>]]<br />
<br />
Чтобы найти выход из этого положения, можно модифицировать метод Ньютона следующим образом: раз <math>f(\lambda)</math> нельзя хорошо приблизить линейной функцией <math>l(\lambda)</math>, попробуем взять в качестве приближения какую-нибудь другую простую функцию <math>h(\lambda)</math>. Нет ничего особого именно в прямых линиях: для метода Ньютона вместо <math>l(\lambda)</math> можно взять любое приближение <math>h(\lambda)</math>, значения и нули которого легко вычисляются. Функция <math>f(\lambda)</math> имеет полюсы в точках <math>d_{i}</math> и <math>d_{i+1}</math>, которые определяют её поведение в соответствующих окрестностях. Поэтому при поиске корня в интервале <math>(d_{i+1}, d_{i})</math> естественно выбрать функцию <math>h(\lambda)</math>, также имеющую эти полюсы, т.е. функцию вида<br />
<math>h(\lambda)= \frac{c_{1}}{d_{i}-\lambda} + \frac{c_{2}}{d_{i+1}-\lambda} + c_{3}</math><br />
<br />
Константы <math>c_{1},c_{2}</math> и <math>c_{3}</math> обеспечивающие, что <math>h(\lambda)</math> есть приближение к <math>f(\lambda)</math>, можно выбрать несколькими способами. Отметим, что если <math>c_{1},c_{2}</math> и <math>c_{3}</math> уже известны, то уравнение <math>h(\lambda)=0</math> легко решается относительно <math>\lambda</math>, поскольку сводится к эквивалентному квадратному уравнению<br />
<math>c_{1}(d_{i+1}-\lambda)+c_{2}(d_{i}-\lambda)+c_{3}(d_{i}-\lambda)(d_{i+1}-\lambda)=0</math><br />
<br />
Пусть <math>\lambda_{j}</math> - приближённое значение корня. определим <math>c_{1},c_{2}</math> и <math>c_{3}</math> так, чтобы<br />
<math>\frac{c_{1}}{d_{i}-\lambda} + \frac{c_{2}}{d_{i+1}-\lambda} + c_{3} = h(\lambda) \approx f(\lambda) = 1 + \rho \sum_{k=1, n} \frac{u_{k}^{2}} {d_{k}-\lambda} </math><br />
<br />
для <math>\lambda</math> в окрестности <math>\lambda_{j}</math>. Заметим, что<br />
<br />
<math>f(\lambda) = 1 + \rho \sum_{k=1, i} \frac{u_{k}^{2}} {d_{k}-\lambda} + \rho \sum_{k=i+1, n} \frac{u_{k}^{2}} {d_{k}-\lambda} \equiv 1 + \psi_{1}(\lambda) + \psi_{2}(\lambda)</math>.<br />
<br />
Если <math>\lambda \in (d_{i+1},d_{i})</math>, то <math>\psi_{1}(\lambda)</math> есть сумма положительных слагаемых, а <math>\psi_{2}(\lambda)</math> - сумма отрицательных. Поэтому и <math>\psi_{1}(\lambda)</math>, и <math>\psi_{2}(\lambda)</math> могут быть вычислены с высокой точностью; однако при их сложении вполне вероятно взаимное уничтожение верных разрядов и потеря относительной точности в сумме. Возьмем числа <math>c_{1}</math> и <math>\hat{c_{1}}</math>, такие, что функция <br />
<br />
<math>h_{1}(\lambda) \equiv \hat{c_{1}} + \frac{c_{1}}{d_{i}-\lambda}</math> удовлетворяет условиям <math>h_{1}(\lambda_{j}) = \psi_{1}(\lambda_{j})</math> и <math>h_{1}^{'}(\lambda_{j})=\psi_{1}^{'}(\lambda_{j})</math> (1)<br />
<br />
Это означает, что гипербола, являющаяся графиком функции <math>h_{1}(\lambda)</math>, касается графика функции <math>\psi_{i}(\lambda)</math> при <math>\lambda = \lambda_{j}</math>. Два условия в (1) - это обычные условия метода Ньютона, за исключением того, что вместо прямой в качестве приближения используется гипербола. Легко проверить, что <math>c_{1}=\psi_{1}^{'}(\lambda_{j})(d_{i} - \lambda_{j})^{2}</math> и <math>\hat{c_{1}}=\psi_{1}(\lambda_{j}) - \psi_{1}^{'}(\lambda_{j})(d_{i} - \lambda_{j})</math><br />
<br />
Подобным же образом выбираем <math>c_{2}</math> и <math>\hat{c_{2}}</math> так, чтобы функция <br />
<br />
<math>h_{2}(\lambda) \equiv \hat{c_{2}} + \frac{c_{2}}{d_{i+1}-\lambda}</math><br />
<br />
Удовлетворяла условиям<br />
<br />
<math>h_{2}(\lambda_{j}) = \psi_{2}(\lambda_{j})</math> и <math>h_{2}^{'}(\lambda_{j})=\psi_{2}^{'}(\lambda_{j})</math> (2)<br />
<br />
Наконец, полагаем<br />
<br />
<math>h(\lambda) = 1 + h_{1}(\lambda) + h_{2}(\lambda) = (1 + \hat{c_{1}} + \hat{c_{2}} + \frac{c_{1}}{d_{i}-\lambda} + \frac{c_{2}}{d_{i+1}-\lambda} </math><br />
<br />
<math>\equiv c_{3} + \frac{c_{1}}{d_{i}-\lambda} + \frac{c_{2}}{d_{i+1}-\lambda}</math>.<br />
<br />
== Схема реализации последовательного алгоритма ==<br />
''Вычисление собственных значений и собственных векторов симметричной трехдиагональной матрицы посредством стратегии "разделяй и властвуй"'':<br />
<br />
<br />
''proc dc_eig''<math>(T,Q,\Lambda)...</math> по входной матрице <math>T</math> вычисляются выходные матрицы <math>Q</math> и <math>\Lambda</math>, такие, что <math>T = Q\Lambda Q^{T}</math><br />
<br />
'''Если <math>T</math> - матрица размера <math>1</math> x <math>1</math>'''<br />
<br />
1. Присвоить выходным параметрам значения <math> Q = 1, \Lambda = T</math><br />
<br />
'''Иначе'''<br />
<br />
1. Представить <math>T</math> в виде <math> T = \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T} </math><br />
<br />
2. ''call dc_eig''<math>(T_{1},Q_{1},\Lambda_{1})</math><br />
<br />
3. ''call dc_eig''<math>(T_{2},Q_{2},\Lambda_{2})</math><br />
<br />
4. Построить <math>D+\rho uu^{T}</math> по <math> \Lambda_{1},\Lambda_{2}, Q_{1}, Q_{2}</math><br />
<br />
5. Найти матрицу собственных значений <math>\Lambda</math><br />
<br />
6. Найти матрицу собственных векторов <math>Q^{'}</math> для матрицы <math>D+\rho uu^{T}</math><br />
<br />
7. Построить матрицу собственных векторов <math>Q</math> для матрицы <math>T</math> : <math> Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}* Q^{'} </math><br />
<br />
8. Присвоить выходным параметрам значения <math>Q</math> и <math>\Lambda</math><br />
<br />
'''endif'''<br />
<br />
== Последовательная сложность алгоритма ==<br />
Проанализируем сложность алгоритма. Пусть <math>t(n)</math> - число флопов при обработке матрицы размера <math> n x n</math> процедурой ''dc_eig''. Тогда <br />
<br />
<math> t(n) = 2t(n/2) </math> два рекурсивных обращения к ''dc_eig''<math>(T_{i},Q_{i},\Lambda_{i})</math><br />
<br />
<math> +O(n^{2})</math> вычисление собственных значений матрицы <math>D+\rho uu^{T}</math><br />
<br />
<math> +O(n^{2})</math> вычисление собственных векторов матрицы <math>D+\rho uu^{T}</math><br />
<br />
<math> +c*n^{3}</math> вычисление матрицы <math>Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}*Q^{'}</math><br />
<br />
<br />
Если <math> Q_{1}, Q_{2}</math> и <math>Q^{'}</math> рассматриваются как плотные матрицы и используется стандартный алгоритм матричного умножения, то константа <math> c </math> в последней строке равна 1. Таким образом, именно это умножение составляет наиболее трудоёмкую часть алгоритма в целом. Игнорируя члены порядка <math>n^{2}</math>, получаем <math>t(n) = 2t(n/2) + cn^{3}</math>. Решая это разностное уравнение, находим <math> t \approx c\frac{4}{3}n^{3} </math><br />
<br />
На практике константа <math>c</math> обычно гораздо меньше 1, потому что матрица <math>Q^{'}</math> весьма разрежена вследствие явления, называемого дефляцией.<br />
<br />
== Информационный граф ==<br />
В данном разделе представлен информационный граф алгоритма: на рисунке 5 изображена часть алгоритма, в которой происходит деление - "Divide", а на рисунке 6 описана часть "Conquer".<br />
<br />
[[File:Infograph1.jpg|thumb|center|left|800px|Рис. 5. Информационный граф алгоритма "Разделяй и властвуй" - шаг <b>Divide</b>]]<br />
<br />
[[File:Infograph2.jpg|thumb|center|1200px|Рис. 6. Информационный граф алгоритма "Разделяй и властвуй" - шаг <b>Conquer</b>. Qk*k - матрица собственных значений размерности <b>k</b>. Lk*k - матрица собственных векторов размерности <b>k</b>.]]<br />
<br />
Операции: <br />
<br />
<math>D</math> - операция Divide разделения матрицы <math> T </math> на матрицы <math>T_{1}</math> и <math>T_{2}</math><br />
<br />
Индексы - размерность <br />
<br />
<math>S_{k}</math> - операция Conquer сбора матрицы <math> D </math><br />
<br />
<math> L_{k} </math> - операция поиска собственных значений <br />
<br />
<math> S^{'} </math> - операция поиска собственных векторов матрицы <math> Q^{'} </math><br />
<br />
<math> S </math> - операция поиска собственных векторов матрицы <math> Q </math><br />
<br />
== Ресурс параллелизма алгоритма ==<br />
Рассмотрев информационный граф алгоритма, можно заметить, что в структуре имеется два параллельных блока - вызов рекурсивных функций ''dc_eig'' для вычисления собственных значений и векторов матриц <math>T_{1}</math> и <math>T_{2}</math> - это единственная часть алгоритма, в которой мы прибегаем к параллелизму. <br />
<br />
Рекурсивное разделение матрицы ведёт к иерархии вычислительных подблоков с графом зависимости данных, который выглядит, как двоичное дерево. Данная структура является естественным путем разделения вычислений между процессорами.<br />
<br />
В вершине дерева все процессы взаимодействуют. В каждой ветви дерева вычисление делится на два вычислительных подблока, внутри каждого из которых процессы параллельно взаимодействуют. В листьях деревьев каждый процесс занимается вычислением независимо.<br />
<br />
В случае реализации без параллелизма, функции ''dc_eig'' отрабатывают последовательно - сначала со входными параметрами <math>T_{1}, Q_{1}, \Lambda_{1}</math>, затем - <math>T_{2}, Q_{2}, \Lambda_{2}</math>.<br />
<br />
Таким образом, благодаря параллелизму высота алгоритма параллельного составляет <math>log_{2}(n)</math>, когда как при последовательной реализации высота алгоритма равна сумме геометрической прогрессии <math>1+2+4+8+...+2^{n-1} = 2^{n} - 1</math>, что значительно сокращает число итераций алгоритма.<br />
<br />
== Входные и выходные данные алгоритма ==<br />
'''Входные данные:''' <br />
<br />
На вход алгоритму подаётся трёхдиагональная симметричная матрица:<br />
<br />
<math><br />
L = \begin{bmatrix}<br />
a_{1} & b_{1}&&&&& \\<br />
b_{1} & \ddots & \ddots \\<br />
& \ddots & a_{m-1} & b_{m-1} \\<br />
&& b_{m-1} & a_{m} & b_{m} \\<br />
&&& b_{m} & a_{m+1} & b_{m+1} \\<br />
&&&& b_{m+1} & \ddots \\<br />
&&&&&& \ddots & b_{n-1} \\<br />
&&&&&& b_{n-1} & a_{n} \\<br />
\end{bmatrix}<br />
</math><br />
<br />
'''Объем входных данных:''' <br />
<br />
<math>2n + 1</math> - в силу симметрии, хранить следует только диагональные, поддиагональые и наддиагональные элементы.<br />
<br />
'''Выходные данные:'''<br />
<br />
На выходе мы получаем вектор собственных значений длины <math> n </math> и <math> n </math> собственных векторов длины <math> n </math> , соответствующих собственным значениям исходной матрицы.<br />
<br />
'''Объем выходных данных:'''<br />
<br />
<math> n + n^{2} = n(n + 1) </math><br />
<br />
== Свойства алгоритма ==<br />
Описанный в данной статье алгоритм является самым быстрым алгоритмом, среди существующих: QR / Бисекция и обратная итерация / Разделяй и властвуй.<br />
<br />
Последовательная сложность алгоритма: <math> t = c\frac{4}{3}n^{3} </math><br />
<br />
Параллельная сложность алгоритма (в силу использования дефляции): <math> O(n^{2.3})</math> или в самых редких случаях <math> O(n^{2}) </math> (см. [3] стр. 8).<br />
<br />
Особенности алгоритма:<br />
<br />
1. Использование дефляции ([[#Дефляция]])<br />
<br />
2. Использование адаптированного метода Ньютона ([[#Макроструктура алгоритма]])<br />
<br />
= ЧАСТЬ. Программная реализация алгоритма =<br />
Вторая часть описания алгоритмов в рамках AlgoWiki рассматривает все составные части процесса их реализации. Рассматривается как последовательная реализация алгоритма, так и параллельная. Описывается взаимосвязь свойств программ, реализующих алгоритм, и особенностей архитектуры компьютера, на которой они выполняются. Исследуется работа с памятью, локальность данных и вычислений, описывается масштабируемость и эффективность параллельных программ, производительность компьютеров, достигаемая на данной программе. Обсуждаются особенности реализации для разных классов архитектур компьютеров, приводятся ссылки на реализации в существующих библиотеках.<br />
<br />
<br />
== Особенности реализации последовательного алгоритма ==<br />
<br />
== Локальность данных и вычислений ==<br />
<br />
== Возможные способы и особенности параллельной реализации алгоритма ==<br />
== Масштабируемость алгоритма и его реализации ==<br />
Исследование проводилось на суперкомпьютере "Ломоносов" Суперкомпьютерного комплекса Московского университета.<br />
<br />
Набор и границы значений изменяемых параметров запуска реализации алгоритма: <br />
<br />
* число процессоров [1 : 8] (1,2,3,4,8);<br />
* размер матрицы [4 : 8192].<br />
<br />
Для исследования масштабируемости алгоритм был реализован на библиотеке OpenMP 1.5.5 для языка C++(компилятор g++) на cуперкомпьютере Ломоносов на узле compiler. Для данного узла максимально возможное число потоков - 8. В ходе оценки масштабируемости, программа была запущена в 1, 2, 4, 8 потока. <br />
Параметры компиляции и запуска: <br />
<br />
ssh compiler <br />
module add slurm<br />
module add openmpi/1.5.5-icc<br />
g++ _scratch/test.c++ -fopenmp -std=c++0x -o test <br />
sbatch -p test -n1 run ./test<br />
<br />
Для управления количеством потоков использовалась операция OpenMP omp_set_num_threads();<br />
<br />
[[File:ResultsDiagram.jpg|thumb|center|left|800px|Рис. 7. График времени работы программы в зависимости от числа процессов и размера задачи]]<br />
<br />
Масштабируемость рассматриваемой реализации алгоритма '''"Разделяй и властвуй"''':<br />
<br />
* При увеличении числа процессов общая эффективность программы увеличивается, т.к. время чтения и подготовки исходной матрицы остаётся неизменным, а время работы алгоритма уменьшается, однако рост незначительный.<br />
* При увеличении размерности матрицы общая эффективность программы постепенно уменьшается, т.к. время чтения и подготовки исходных данных растёт быстрее, чем время работы исследуемого алгоритма.<br />
* При одновременном увеличении как числа процессов, так и размерности матрицы общая эффективность программы уменьшается.<br />
<br />
Код исследуемой реализации представлен здесь [http://pastebin.com/QpfYZGkK pastebin.com]<br />
<br />
== Динамические характеристики и эффективность реализации алгоритма ==<br />
<br />
== Выводы для классов архитектур ==<br />
<br />
== Существующие реализации алгоритма ==<br />
Описываемый метод реализован в пакете LAPACK, описание которого можно найти в [http://www.netlib.org/lapack/lawnspdf/lawn132.pdf этой статье] на страницах 7, 19 и 20, которая указана в списке литературы.<br />
<br />
= Литература =<br />
[1] Дж. Деммель, «Вычислительная линейная алгебра» //С. 230-235<br />
<br />
[2] [http://www.netlib.org/utk/people/JackDongarra/PAPERS/104_1999_a-parallel-divide-and-conquer-algorithm.pdf Francoise Tisseury, Jack Dongarra, A Parallel Divide and Conquer Algorithm for the Symmetric Eigenvalue Problem on Distributed Memory Architectures]<br />
<br />
[3] [http://www.netlib.org/lapack/lawnspdf/lawn132.pdf Francoise Tisseury, Jack Dongarra, Parallelizing the Divide and Conquer Algorithm for the Symmetric Tridiagonal Eigenvalue Problem on Distributed Memory Architectures]<br />
<br />
[4] [https://en.wikipedia.org/wiki/Divide-and-conquer_eigenvalue_algorithm Алгоритм "Разделяй и властвуй" - Wikipedia]<br />
<br />
[5] [http://www.cscamm.umd.edu/tadmor/pub/linear-stability/Gill_Tadmor_SISC90.pdf Doron Grill and Eitan Tadmor AN <math>O(N2)</math> METHOD FOR COMPUTING THE EIGENSYSTEM OF <math>N</math>x<math>N</math> SYMMETRIC TRIDIAGONAL MATRICES BY THE DIVIDE AND CONQUER APPROACH]<br />
<br />
[[en:Description of algorithm properties and structure]]</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%9E%D0%B1%D1%81%D1%83%D0%B6%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5_%D1%83%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA%D0%B0:%D0%A0%D0%BE%D0%BC%D0%B0%D0%BD_%D0%97%D0%B5%D0%BC%D0%BB%D1%8F%D0%BD%D1%81%D0%BA%D0%B8%D0%B9&diff=20038Обсуждение участника:Роман Землянский2016-12-05T07:58:16Z<p>Chernyavskiy: /* Второй этап проверки */</p>
<hr />
<div>== Замечания к статье ==<br />
<br />
* п. 1.1 "...собственные векторы трехдиагональной матриц," заменить на "...собственные векторы трехдиагональной матрицы,"--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:48, 26 октября 2016 (MSK)<br />
* п. 1.7 приведенный рисунок не является рисунком информационного графа--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:48, 26 октября 2016 (MSK)<br />
* п. 1.8, 1.9 оценка не произведена--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:48, 26 октября 2016 (MSK)<br />
* п. 2.4 не заполнен--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 13:26, 16 ноября 2016 (MSK)<br />
** в п.п. 2.4 следует добавить код исследуемой программы, а также подробное описание условий, в которых производились эксперименты: характеристики программно-аппаратной платформы (какой компилятор, с какими опциями использовался, какие версии библиотек, на каких узлах проводился запуск и т.д.)--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 12:16, 21 ноября 2016 (MSK) <br />
<br />
<br />
== Второй этап проверки ==<br />
<br />
=== Итерация 1 ===<br />
<br />
Начальные замечания и комментарии (возможно будут появляться новые, пишите, пожалуйста, комментарии по ходу исправлений и ответы):<br />
<br />
* Исправить ошибки в формулах в разделе 1.2<br />
* Исправить ошибку в разделе 1.9<br />
* Раздел 2.7 - как это не найдены реализации, если в пункте 1.1 они указаны?<br />
* По информационному графу не видно, что дерево может быть большей высоты, нужно бы это как-то отразить. И не совсем очевидно, как Divide переходит в Conquer. Нужно постараться, чтобы граф был более информативен и без чтения остальных разделов.<br />
<br />
=== Итерация 2 ===<br />
<br />
ПИШИТЕ В КОММЕНТАРИЯХ ЗДЕСЬ ХОД ИСПРАВЛЕНИЙ И ОТВЕТЫ! Так легче своевременно отслеживать изменения.<br />
<br />
* В разделе 1.2 есть как минимум еще одна ошибка.<br />
* Какое всё-таки отношение имеет вековое уравнени к макроструктуре алгоритма?<br />
* В пункте 1.10 написано про сложность O(n^{2/3}) просто со ссылкой. Этого недостаточно. Подумайте, как написать. Можно что-то вроде "теоретическая сложность такая-то, на практике же получается так-то и происходит в силу того-то..."<br />
* Информационный граф пока еще требует доработки. Прочтите ещё раз внимательно его описание на соответствующей странице. Основная его задача - показать взаимосвязь между опреациями алгоритма. Согласен, что в данном случае не нужно опускаться на уровень элементов матриц. Но пока граф не очень хорошо отражает структуру. И более конкретные вещи:<br />
1) В операции divivde разве матрицы половинной размерности возникают не из предыдущего шага? И где собственно вычисления?<br />
2) Связь между divide и conquer вообще не видна.<br />
Древовидная структура - это правильно. Но, снова повтрою, весь граф должен полностью отражать схему вычислений.<br />
Можно еще для дополнительной наглядности раскрыть полностью рекурсию для конкретного небольшого примера (например, 4Х4) и отразить полностью все происходящие вычисления.</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%9E%D0%B1%D1%81%D1%83%D0%B6%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5_%D1%83%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA%D0%B0:Nikita&diff=20037Обсуждение участника:Nikita2016-12-05T07:42:11Z<p>Chernyavskiy: </p>
<hr />
<div>Замечания к оформлению:<br />
<br />
1. Пункт 1.7 что обозначают серые вершины на графе?<br />
<br />
2. в пункте 1.9 указать чему соответствуют разные входные и выходные данные. Иначе непонятно будет человеку, который первый раз на сайте.<br />
<br />
3. Ссылки на литературу внутри текста статьи не нашел.<br />
<br />
<br />
'''Второй этап проверки:'''<br />
Добавляйте сюда ответы на вопросы и ход исправлений. <br />
Возможно появление дополнительных замечаний.<br />
<br />
1. Думаю, описание метода Пейли разумнее переместить в раздел "Математическое описание"<br />
<br />
2. В математическом описании желательно хотя бы минимально кратко обосновать корректность (что достаточно проверить (p-1)/2 квадратов, и что матрица будет состоять только из элементов +1 и -1). <br />
<br />
3. Исправить код. Есть как опечатки, так и ошибки. Вообще говоря, для любой похожей математической задачи необходимо писать тесты. Здесь он очевиден - проверить получившуюся матрицу по определению. В Algowiki тест вставлять не нужно, приведите его здесь.<br />
<br />
4. Информационный граф неправилен. У вас, скорее, отражена макроструктура. Алгоритм довольно прост, поэтому необходимо построить граф по всем правилам, где выход операции переходит строго на вход следующей операции. Разумно будет взять конкретный пример n=4. Лучше построить граф, как с данными, так и без них. Представленный граф тоже можно будет оставить для наглядности. Его основная проблема в том, что не видно, как функция построения итоговой матрицы обращается к элементам residual, что может быть важным для каких-либо архитектур.<br />
<br />
5. (22.11) с учетом ошибки и в параллельном коде, эксперимент в пункте 2.4. нужно провести заново.<br />
<br />
'''Исправления по второму этапу:'''<br />
<br />
На данный момент были исправлены все замечания, кроме пункта 4. Скажите, пожалуйста, будут ли применяться штрафы в период правки замечаний?<br />
''Ответ:'' нет, если, как в вашем случае, происходит просто исправление, штрафов не будет. Но лучше всё же не тянуть, т.к. могут возникнуть новые комментарии.</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%9E%D0%B1%D1%81%D1%83%D0%B6%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5_%D1%83%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA%D0%B0:Amirida&diff=19968Обсуждение участника:Amirida2016-12-03T10:19:24Z<p>Chernyavskiy: </p>
<hr />
<div>== Статья [[Участник:Amirida/Метод «разделяй и властвуй» вычисления собственных значений и векторов симметричной трехдиагональной матрицы ]] ==<br />
<br />
=== Отсутствующие части ===<br />
* Пропущен раздел описания 2.4. Масштабируемость алгоритма и его реализации. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 11:25, 9 ноября 2016 (MSK)<br />
* Не заполнен раздел 2.4 описания. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:28, 16 ноября 2016 (MSK)<br />
<br />
=== Замечания по тексту ===<br />
* В разделе 1.4 требуется привести описание алгоритма на верхнем уровне (на основе макроопераций). [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 11:25, 9 ноября 2016 (MSK)<br />
* В разделе 1.5 кроме кода нужны также текстовые пояснения. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 11:25, 9 ноября 2016 (MSK)<br />
* Граф, приведённый в разделе 1.7 не является информационным графом (ациклический граф, вершины - операции, дуги - информационные зависимости). [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 11:25, 9 ноября 2016 (MSK)<br />
* В разделе 1.8 используется непонятный термин "высота алгоритма". [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 11:25, 9 ноября 2016 (MSK)<br />
* В разделе 1.10 не нужно дублировать последовательную сложность алгоритма, но требуется привести оценку вычислительной мощности. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 11:25, 9 ноября 2016 (MSK)<br />
* Отсутствует информация в разделе 2.7 (по текущей нумерации 2.6). [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 11:25, 9 ноября 2016 (MSK)<br />
<br />
<br />
=== Дополнительно (03.12) === <br />
[[Участник:chernyavskiy]]<br />
<br />
*Для ускорение дальнейшей проверки укажите на этой странице (в данном разделе) подробно источники, из которых брались разделы и их части. Если раздел писался самостоятельно - укажите это.</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%9E%D0%B1%D1%81%D1%83%D0%B6%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5_%D1%83%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA%D0%B0:Nikita&diff=18953Обсуждение участника:Nikita2016-11-22T13:04:36Z<p>Chernyavskiy: </p>
<hr />
<div>Замечания к оформлению:<br />
<br />
1. Пункт 1.7 что обозначают серые вершины на графе?<br />
<br />
2. в пункте 1.9 указать чему соответствуют разные входные и выходные данные. Иначе непонятно будет человеку, который первый раз на сайте.<br />
<br />
3. Ссылки на литературу внутри текста статьи не нашел.<br />
<br />
<br />
'''Второй этап проверки:'''<br />
Добавляйте сюда ответы на вопросы и ход исправлений. <br />
Возможно появление дополнительных замечаний.<br />
<br />
1. Думаю, описание метода Пейли разумнее переместить в раздел "Математическое описание"<br />
<br />
2. В математическом описании желательно хотя бы минимально кратко обосновать корректность (что достаточно проверить (p-1)/2 квадратов, и что матрица будет состоять только из элементов +1 и -1). <br />
<br />
3. Исправить код. Есть как опечатки, так и ошибки. Вообще говоря, для любой похожей математической задачи необходимо писать тесты. Здесь он очевиден - проверить получившуюся матрицу по определению. В Algowiki тест вставлять не нужно, приведите его здесь.<br />
<br />
4. Информационный граф неправилен. У вас, скорее, отражена макроструктура. Алгоритм довольно прост, поэтому необходимо построить граф по всем правилам, где выход операции переходит строго на вход следующей операции. Разумно будет взять конкретный пример n=4. Лучше построить граф, как с данными, так и без них. Представленный граф тоже можно будет оставить для наглядности. Его основная проблема в том, что не видно, как функция построения итоговой матрицы обращается к элементам residual, что может быть важным для каких-либо архитектур.<br />
<br />
5. (22.11) с учетом ошибки и в параллельном коде, эксперимент в пункте 2.4. нужно провести заново.</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA:Nikita/%D0%9F%D0%BE%D1%81%D1%82%D1%80%D0%BE%D0%B5%D0%BD%D0%B8%D0%B5_%D0%BC%D0%B0%D1%82%D1%80%D0%B8%D1%86%D1%8B_%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80%D0%B0&diff=18891Участник:Nikita/Построение матрицы Адамара2016-11-21T21:09:45Z<p>Chernyavskiy: </p>
<hr />
<div><br />
<br />
<!--{{Assignment|Sleo}}<br />
--><br />
<br />
{{algorithm<br />
| name = Построение матрицы Адамара<br />
| serial_complexity = <math>O(n^2)</math><br />
| pf_height = <math>O(1)</math><br />
| pf_width = <math>O(n^2)</math><br />
| input_data = <math>1</math><br />
| output_data = <math>n^2</math><br />
}}<br />
<br />
Авторы статьи: [[Участник:Nikita|Иванов Н.В.]] (1.1,1.7,1.9,1.10,2.4,2.7), [[Участник:Tsyganov Nikita|Цыганов Н.И.]] (1.2,1.3,1.4,1.5,1.6,1.7,1.8,2.4).<br />
<br />
== Свойства и структура алгоритма ==<br />
<br />
<br />
=== Общее описание алгоритма ===<br />
<br />
Матрицы Адамара были введены в математический обиход в конце прошлого века и играют важную роль в алгебре и комбинаторике. Они находят широкое применение в теории кодирования (коды, исправляющие ошибки), теории планирования многофакторных экспериментов (блок-схемы) и других областях математики.<ref name="rt">http://cyberleninka.ru/article/n/matritsy-adamara-nechetnogo-poryadka.pdf</ref> Сравнительно недавно (в 1960 г.) было замечено, что эти матрицы могут быть использованы для построения кодов с большим кодовым расстоянием.<br />
<br />
'''''Матрицей Адамара порядка n''''' называется <math>n*n</math> матрица <math>H</math>, элементами которой являются +1 и −1 такая, что <math>H H^T = n E_n</math>, <br />
где <math>E_n</math> - единичная матрица размера n.<br />
<br />
Матрица Адамара обладает следующими ''свойствами'':<br />
* Различные строки матрицы ортогональны<br />
* Скалярное произведение любой строки саму на себя равно n<br />
* Умножение любой строки или столбца на -1 переводит H в другую матрицу Адамара<br />
* Если все элементы первой строки и первого столбца равны +1, то матрица Адамара называется нормализованной<br />
<br />
Ниже показаны примеры нормализованных матриц Адамара порядка 1,2 и 4, причем нормализованность матриц сохраняется при перестановке любых строк и столбцов, кроме первых:<br />
<br />
<math>H_1 = (1)</math><br />
<math>,<br />
H_2 =<br />
\begin{pmatrix}<br />
1 & 1\\<br />
1 & -1\end{pmatrix}<br />
</math>,<br />
<math>,<br />
H_4 =<br />
\begin{pmatrix}<br />
1 & 1 & 1 & 1\\<br />
1 & -1 & 1 & -1\\<br />
1 & 1 & -1 & -1\\<br />
1 & -1 & -1 & 1\end{pmatrix}<br />
</math><br />
<br />
<br />
Предполагается, что существуют матрицы Адамара порядка 1, 2 и всех порядков n, кратных 4, хотя это до сих пор еще не было доказано. Нет универсального алгоритма построения матрицы Адамара произвольного размера, но известно большое число методов для различных частных случаев, и наименьший порядок, для которого матрица Адамара еще не построена, равен 268 (на 1977 г.). <ref name="rt2">Мак-Вильямс Ф. Дж., Слоэн Н. Дж. А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — c. 52-57</ref> Мы приведем метод построения Пейли, который важен для теории кодирования. <br />
<br />
====Метод Пейли====<br />
Это построение дает матрицы Адамара любого порядка <math>n=p+1</math>, кратного 4, где p-простое число.<br />
<br />
'''Определение.''' Пусть p-простое число. Ненулевые квадраты чисел, приведенные по модулю p, называются квадратичными вычетами по модулю p или просто вычетами по модулю p.<br />
<br />
Функция <math>X(i)</math>, называемая символом Лежандра, определяется на целых числах следующим образом:<br />
* <math>X(i)=0</math>, если i кратно p;<br />
* <math>X(i)=1</math>, если остаток от деления i на p является квадратным вычетом по модулю p;<br />
* <math>X(i)=-1</math>, если остаток от деления i на p является невычетом.<br />
<br />
<br />
Теперь мы построим матрицу Джекобстола <math>Q=(q_{ij})</math>. Она представляет собой <math>(p*p)</math>-матрицу, строки и столбцы которой пронумерованы числами 0,1,..., p-1, а элементы <math>q_{ij}=X(j-i)</math>. <br />
<br />
Пусть теперь <math><br />
H =<br />
\begin{pmatrix}<br />
1 & 1\\<br />
1^T & Q-I\end{pmatrix}<br />
</math>.<br />
<br />
Доказано, что такая матрица <math>H</math> представляет собой нормализованную матрицу Адамара порядка p+1, которую называют матрицей типа Пейли.<ref name="rt3">http://tc.nsu.ru/uploads/codingtheory.pdf</ref><br />
<br />
=== Математическое описание алгоритма ===<br />
<br />
Исходные данные - это порядок генерируемой матрицы Адамара <math>n</math>, удовлетворяющее следующим свойствам: <br />
<br />
* <math>n>0</math>;<br />
<br />
* <math>n</math> делится на 4;<br />
<br />
* <math>n-1</math> - простое число.<br />
<br />
Вспомогательные данные: <br />
<br />
* Число <math>p=n-1</math>;<br />
* Вектор квадратичных вычетов (по модулю <math>p</math>) <math>R</math> (элементы <math>r_i</math>) размера <math>2p</math>. В этом векторе индексация идёт с нуля.<br />
<br />
Вычисляемые данные:<br />
<br />
* Матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>) размера <math>n \times n</math>. Индексация строчек и столбцов идёт с нуля. <br />
<br />
Алгоритм:<br />
:1. Строится вектор квадратичных вычетов <math>R</math>.<br />
:: Первые <math>p</math> элементов вектора <math>R</math> (<math>i=0,1,...,p-1</math>) определяются следующим образом:<br />
::: <math>r_i=1</math>, если <math>i \in \{1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod</math> <math> p\}</math>, <math>i=0,1,...,p-1</math>, то есть если <math>i</math> является квадратичным вычетом по модулю <math>p</math>;<br />
::: <math>r_i=-1</math>, иначе.<br />
::Вторые <math>p</math> элементов (<math>i=p,1,...,2p-1</math>) являются копией первых <math>p</math> элементов:<br />
:::<math>r_i=r_{i-p}, i=p,1,...,2p-1.</math><br />
:2. Строится матрица Адамара <math>H</math>.<br />
::Элементы матрицы Адамара <math>H</math> находятся следующим образом:<br />
::: <math>h_{0j}=1, j=0,1, ... ,n-1;</math><br />
::: <math>h_{i0}=1, i=1,2, ... ,n-1;</math><br />
::: <math>h_{ij}=r_{j-i+p}, i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math><br />
<br />
=== Вычислительное ядро алгоритма ===<br />
<br />
Вычислительное ядро алгоритма состоит из <math>(n-1) \times (n-1)</math> операций присваивания следующего вида:<br />
<br />
:<math>h_{ij}=r_{j-i+p},</math> <math> i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math><br />
<br />
=== Макроструктура алгоритма ===<br />
<br />
Как видно из математического описания, алгоритм основан на простейших операциях с числами, поэтому макроструктура алгоритма полностью соответствует его математическому описанию.<br />
<br />
=== Схема реализации последовательного алгоритма ===<br />
<br />
Приведем процедуру на языке С++, реализующую описанный алгоритм. На вход процедуре подается порядок матрицы <math>n</math> и ссылка на заполняемую матрицу <math>result</math>. Считаем, что <math>n</math> положительно, делится на <math>4</math>, <math>n-1</math> - простое число, а размер матрицы <math>result</math> равен <math>n \times n</math>.<br />
<br />
<source lang="C"><br />
void buildHadamardMatrix(int n, vector<vector<int>> & result)<br />
{<br />
// 1) Считаем вычеты по модулю p=n-1 и создаем вспомогательный массив вычетов residues<br />
// Достаточно посчитать значения (1^2 mod p), (2^2 mod p), ... , (((p-1)/2)^2 mod p) - эти значениями и будут являться вычетами.<br />
// Строим массив residues размера 2*p, в котором первые p элементов заполняются по следующей схеме: 1, если индекс элемента - вычет, -1 - иначе.<br />
// Вторая половина массива получается дублированием первой половины<br />
int p=n-1;<br />
vector<int> residues;<br />
residues.resize(2*p);<br />
// Заполняем массив<br />
for (int i=0; i<p; i++) {<br />
residue[i] = -1;<br />
}<br />
for (int i=1; i<= (p-1)/2; i++) {<br />
residue[i^2 % p] = 1;<br />
}<br />
for (int i=p; i<2*p; i++) {<br />
residue[i] = residue[i-p];<br />
}<br />
<br />
// 2) Построение матрицы Адамара<br />
// Заполнение первой строки 1-цами<br />
for (int j=0; j<n; j++) {<br />
result[0][j] = 1;<br />
}<br />
// Заполнение первого столбца 1-цами<br />
for (int i=1; i<n; i++) {<br />
result[i][0] = 1;<br />
}<br />
// Заполнение оставшейся части матрицы с использованием вспомогательного массива вычетов residues<br />
for (int i=1; i<n; i++) {<br />
for (int j=1; j<n; j++) {<br />
result[i][j] = residues[j-i+p];<br />
}<br />
}<br />
}<br />
</source><br />
<br />
=== Последовательная сложность алгоритма ===<br />
<br />
Под сложностью будем понимать зависимость числа операций от задаваемого порядка матрицы <math>n</math>. <br />
<br />
Основными операциями алгоритма являются:<br />
<br />
* <math>\frac{n}{2}-2</math> операций умножения;<br />
* <math>\frac{n}{2}-2</math> операций взятия остатка;<br />
* <math>n^2+\frac{5}{2}n-3</math> операций присваивания.<br />
<br />
Из чего следует, что алгоритм имеет квадратичную последовательную сложность.<br />
<br />
=== Информационный граф ===<br />
<br />
Информационный граф алгоритма можно представить в виде четырёх последовательных блоков. Первый блок содержит <math>n-1</math> параллельных ветвей, второй блок - <math>\frac{n}{2}-1</math> параллельных ветвей, третий - <math>n-1</math> и четвёртый - <math>n^2</math>.<br />
<br />
[[Файл:i_graph2.png]]<br />
<br />
Каждая вершина из <math>A_1-A_{n-1}</math>, <math>C_1-C_{n-1}</math>, <math>D_1-D_{n^2}</math> соответствует операции присваивания, каждая вершина из <math>B_1-B_{\frac{n}{2}-1}</math> соответствует трём последовательным операциям: умножения, взятия остатка по модулю и присваивания, а вершины, окрашенные серым, представляют собой промежуточные точки синхронизации.<br />
<br />
=== Ресурс параллелизма алгоритма ===<br />
<br />
Как видно из информационного графа алгоритма, в параллельном варианте необходимо последовательно выполнить следующие блоки:<br />
<br />
* <math>n-1</math> операций присваивания;<br />
* <math>\frac{n}{2}-1</math> участков, состоящих из трёх операций: умножения, взятия остатка и присваивания;<br />
* <math>n-1</math> операций присваивания;<br />
* <math>n^2</math> операций присваивания.<br />
<br />
Из этого можно сделать вывод, что высота ярусно-параллельной формы информационного графа равняется 6 (присваивание, умножение, взятие остатка, присваивание, присваивание, присваивание). Ширина ярусно-параллельной формы равняется <math>n^2</math>, что означает, что при использовании <math>n^2</math> процессоров матрица Адамара будет строиться за 6 операций.<br />
<br />
=== Входные и выходные данные алгоритма ===<br />
<br />
'''Входные данные:''' число <math>n</math> - порядок матрицы Адамара <math>H_n</math>. Дополнительные ограничения на <math>n</math>:<br />
* <math>n</math> - натуральное;<br />
* <math>n</math> делится на 4;<br />
* <math>n-1</math> - простое.<br />
'''Объем входных данных:''' 1 (число <math>n</math>).<br />
<br />
'''Выходные данные:''' построенная матрица Адамара <math>H_n</math> (её элементы <math>h_{ij}</math>).<br />
<br />
'''Объем выходных данных:''' <math>n^2</math> (количество элементов матрицы Адамара размера <math>n*n</math>).<br />
<br />
=== Свойства алгоритма ===<br />
<br />
Соотношение последовательной и параллельной сложности в случае неограниченных ресурсов является квадратичным. <br />
<br />
Вычислительная мощность алгоритма является постоянной (<math>O(1)</math>). <br />
<br />
Алгоритм является полностью детерминированным. <br />
<br />
Для вершин <math>A_1-A_{n-1}</math>, <math>B_1-B_{\frac{n}{2}-1}</math>, <math>C_1-C_{n-1}</math> информационного графа степени исхода являются линейными, что означает, что при возможности на этапе реализации необходимо позаботиться об эффективном доступе к элементам массива "<math>residues</math>".<br />
<br />
== Программная реализация алгоритма ==<br />
<br />
=== Особенности реализации последовательного алгоритма ===<br />
<br />
=== Локальность данных и вычислений ===<br />
<br />
=== Возможные способы и особенности параллельной реализации алгоритма ===<br />
<br />
=== Масштабируемость алгоритма и его реализации ===<br />
<br />
<br />
Исследование масштабируемости параллельной реализации алгоритма построения матрицы Адамара проводилось на суперкомпьютере «Ломоносов». Для этого была исследована собственная реализация алгоритма с использованием средств MPI. В ходе исследования было произведено множество запусков программы с различными значениями параметра <math>n</math> (размер матрицы Адамара) и числом процессоров.<br />
<br />
Набор и границы значений изменяемых параметров запуска реализации алгоритма:<br />
*число процессоров (p): [2,64] с шагом 2;<br />
*размер матрицы: простые числа в диапазоне [4,10000].<br />
<br />
В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:<br />
*минимальная эффективность реализации 0.0000029% при n=4, p=2;<br />
*максимальная эффективность реализации 0.323409% при n=908, p=2.<br />
<br />
Ниже представлены графики времени работы, производительности и эффективности данной реализации алгоритма построения матрицы Адамара в зависимости от изменяемых параметров запуска.<br />
[[Файл:time_graph.png|500px|thumb|center|Время работы параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]<br />
[[Файл:perform_graph.png|500px|thumb|center|Изменение производительности параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]<br />
[[Файл:efficiency_graph.png|500px|thumb|center|Эффективность работы параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]<br />
<br />
<br />
[https://github.com/snikersman/Hadamard Исследованная параллельная реализация на языке C++]<br />
<br />
Построим оценки масштабируемости, используя полученные результаты:<br />
*По размерности задачи. Увеличение размерности задачи приводит к увеличению производительности.<br />
*По числу процессоров. С ростом числа процессоров растет производительность, но при малых размерностях задачи этот рост незначителен. Это связано с дополнительными издержками по записи в участок памяти каждого процессора вспомогательного массива вычетов, а также с обменом информации между процессорами.<br />
*По двум направлениям. При увеличении как числа процессоров, так и размерности задачи, производительность увеличивается. Причем чем больше используется процессоров, тем сильнее увеличивается производительность при увеличении размерности.<br />
<br />
=== Динамические характеристики и эффективность реализации алгоритма ===<br />
<br />
=== Выводы для классов архитектур ===<br />
<br />
=== Существующие реализации алгоритма ===<br />
<br />
Алгоритм построения матрицы Адамара реализован в различных математических пакетах и библиотеках: <br />
* [https://www.mathworks.com/help/matlab/ref/hadamard.html?requestedDomain=www.mathworks.com MATLAB] (вносятся дополнительные ограничения, когда n, или n/12, или n/20 являются степенями по основанию 2)<br />
* [http://r-survey.r-forge.r-project.org/survey/html/hadamard.html R]<br />
* [https://reference.wolframcloud.com/cloudplatform/ref/HadamardMatrix.html Wolfram Mathematica]<br />
* [http://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.linalg.hadamard.html SciPy для Python]<br />
<br />
== Литература ==</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA:Nikita/%D0%9F%D0%BE%D1%81%D1%82%D1%80%D0%BE%D0%B5%D0%BD%D0%B8%D0%B5_%D0%BC%D0%B0%D1%82%D1%80%D0%B8%D1%86%D1%8B_%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80%D0%B0&diff=18890Участник:Nikita/Построение матрицы Адамара2016-11-21T21:04:53Z<p>Chernyavskiy: </p>
<hr />
<div><br />
<br />
{{Assignment|Sleo}}<br />
{{algorithm<br />
| name = Построение матрицы Адамара<br />
| serial_complexity = <math>O(n^2)</math><br />
| pf_height = <math>O(1)</math><br />
| pf_width = <math>O(n^2)</math><br />
| input_data = <math>1</math><br />
| output_data = <math>n^2</math><br />
}}<br />
<br />
Авторы статьи: [[Участник:Nikita|Иванов Н.В.]] (1.1,1.7,1.9,1.10,2.4,2.7), [[Участник:Tsyganov Nikita|Цыганов Н.И.]] (1.2,1.3,1.4,1.5,1.6,1.7,1.8,2.4).<br />
<br />
== Свойства и структура алгоритма ==<br />
<br />
<br />
=== Общее описание алгоритма ===<br />
<br />
Матрицы Адамара были введены в математический обиход в конце прошлого века и играют важную роль в алгебре и комбинаторике. Они находят широкое применение в теории кодирования (коды, исправляющие ошибки), теории планирования многофакторных экспериментов (блок-схемы) и других областях математики.<ref name="rt">http://cyberleninka.ru/article/n/matritsy-adamara-nechetnogo-poryadka.pdf</ref> Сравнительно недавно (в 1960 г.) было замечено, что эти матрицы могут быть использованы для построения кодов с большим кодовым расстоянием.<br />
<br />
'''''Матрицей Адамара порядка n''''' называется <math>n*n</math> матрица <math>H</math>, элементами которой являются +1 и −1 такая, что <math>H H^T = n E_n</math>, <br />
где <math>E_n</math> - единичная матрица размера n.<br />
<br />
Матрица Адамара обладает следующими ''свойствами'':<br />
* Различные строки матрицы ортогональны<br />
* Скалярное произведение любой строки саму на себя равно n<br />
* Умножение любой строки или столбца на -1 переводит H в другую матрицу Адамара<br />
* Если все элементы первой строки и первого столбца равны +1, то матрица Адамара называется нормализованной<br />
<br />
Ниже показаны примеры нормализованных матриц Адамара порядка 1,2 и 4, причем нормализованность матриц сохраняется при перестановке любых строк и столбцов, кроме первых:<br />
<br />
<math>H_1 = (1)</math><br />
<math>,<br />
H_2 =<br />
\begin{pmatrix}<br />
1 & 1\\<br />
1 & -1\end{pmatrix}<br />
</math>,<br />
<math>,<br />
H_4 =<br />
\begin{pmatrix}<br />
1 & 1 & 1 & 1\\<br />
1 & -1 & 1 & -1\\<br />
1 & 1 & -1 & -1\\<br />
1 & -1 & -1 & 1\end{pmatrix}<br />
</math><br />
<br />
<br />
Предполагается, что существуют матрицы Адамара порядка 1, 2 и всех порядков n, кратных 4, хотя это до сих пор еще не было доказано. Нет универсального алгоритма построения матрицы Адамара произвольного размера, но известно большое число методов для различных частных случаев, и наименьший порядок, для которого матрица Адамара еще не построена, равен 268 (на 1977 г.). <ref name="rt2">Мак-Вильямс Ф. Дж., Слоэн Н. Дж. А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — c. 52-57</ref> Мы приведем метод построения Пейли, который важен для теории кодирования. <br />
<br />
====Метод Пейли====<br />
Это построение дает матрицы Адамара любого порядка <math>n=p+1</math>, кратного 4, где p-простое число.<br />
<br />
'''Определение.''' Пусть p-простое число. Ненулевые квадраты чисел, приведенные по модулю p, называются квадратичными вычетами по модулю p или просто вычетами по модулю p.<br />
<br />
Функция <math>X(i)</math>, называемая символом Лежандра, определяется на целых числах следующим образом:<br />
* <math>X(i)=0</math>, если i кратно p;<br />
* <math>X(i)=1</math>, если остаток от деления i на p является квадратным вычетом по модулю p;<br />
* <math>X(i)=-1</math>, если остаток от деления i на p является невычетом.<br />
<br />
<br />
Теперь мы построим матрицу Джекобстола <math>Q=(q_{ij})</math>. Она представляет собой <math>(p*p)</math>-матрицу, строки и столбцы которой пронумерованы числами 0,1,..., p-1, а элементы <math>q_{ij}=X(j-i)</math>. <br />
<br />
Пусть теперь <math><br />
H =<br />
\begin{pmatrix}<br />
1 & 1\\<br />
1^T & Q-I\end{pmatrix}<br />
</math>.<br />
<br />
Доказано, что такая матрица <math>H</math> представляет собой нормализованную матрицу Адамара порядка p+1, которую называют матрицей типа Пейли.<ref name="rt3">http://tc.nsu.ru/uploads/codingtheory.pdf</ref><br />
<br />
=== Математическое описание алгоритма ===<br />
<br />
Исходные данные - это порядок генерируемой матрицы Адамара <math>n</math>, удовлетворяющее следующим свойствам: <br />
<br />
* <math>n>0</math>;<br />
<br />
* <math>n</math> делится на 4;<br />
<br />
* <math>n-1</math> - простое число.<br />
<br />
Вспомогательные данные: <br />
<br />
* Число <math>p=n-1</math>;<br />
* Вектор квадратичных вычетов (по модулю <math>p</math>) <math>R</math> (элементы <math>r_i</math>) размера <math>2p</math>. В этом векторе индексация идёт с нуля.<br />
<br />
Вычисляемые данные:<br />
<br />
* Матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>) размера <math>n \times n</math>. Индексация строчек и столбцов идёт с нуля. <br />
<br />
Алгоритм:<br />
:1. Строится вектор квадратичных вычетов <math>R</math>.<br />
:: Первые <math>p</math> элементов вектора <math>R</math> (<math>i=0,1,...,p-1</math>) определяются следующим образом:<br />
::: <math>r_i=1</math>, если <math>i \in \{1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod</math> <math> p\}</math>, <math>i=0,1,...,p-1</math>, то есть если <math>i</math> является квадратичным вычетом по модулю <math>p</math>;<br />
::: <math>r_i=-1</math>, иначе.<br />
::Вторые <math>p</math> элементов (<math>i=p,1,...,2p-1</math>) являются копией первых <math>p</math> элементов:<br />
:::<math>r_i=r_{i-p}, i=p,1,...,2p-1.</math><br />
:2. Строится матрица Адамара <math>H</math>.<br />
::Элементы матрицы Адамара <math>H</math> находятся следующим образом:<br />
::: <math>h_{0j}=1, j=0,1, ... ,n-1;</math><br />
::: <math>h_{i0}=1, i=1,2, ... ,n-1;</math><br />
::: <math>h_{ij}=r_{j-i+p}, i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math><br />
<br />
=== Вычислительное ядро алгоритма ===<br />
<br />
Вычислительное ядро алгоритма состоит из <math>(n-1) \times (n-1)</math> операций присваивания следующего вида:<br />
<br />
:<math>h_{ij}=r_{j-i+p},</math> <math> i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math><br />
<br />
=== Макроструктура алгоритма ===<br />
<br />
Как видно из математического описания, алгоритм основан на простейших операциях с числами, поэтому макроструктура алгоритма полностью соответствует его математическому описанию.<br />
<br />
=== Схема реализации последовательного алгоритма ===<br />
<br />
Приведем процедуру на языке С++, реализующую описанный алгоритм. На вход процедуре подается порядок матрицы <math>n</math> и ссылка на заполняемую матрицу <math>result</math>. Считаем, что <math>n</math> положительно, делится на <math>4</math>, <math>n-1</math> - простое число, а размер матрицы <math>result</math> равен <math>n \times n</math>.<br />
<br />
<source lang="C"><br />
void buildHadamardMatrix(int n, vector<vector<int>> & result)<br />
{<br />
// 1) Считаем вычеты по модулю p=n-1 и создаем вспомогательный массив вычетов residues<br />
// Достаточно посчитать значения (1^2 mod p), (2^2 mod p), ... , (((p-1)/2)^2 mod p) - эти значениями и будут являться вычетами.<br />
// Строим массив residues размера 2*p, в котором первые p элементов заполняются по следующей схеме: 1, если индекс элемента - вычет, -1 - иначе.<br />
// Вторая половина массива получается дублированием первой половины<br />
int p=n-1;<br />
vector<int> residues;<br />
residues.resize(2*p);<br />
// Заполняем массив<br />
for (int i=0; i<p; i++) {<br />
residue[i] = -1;<br />
}<br />
for (int i=1; i<= (p-1)/2; i++) {<br />
residue[i^2 % p] = 1;<br />
}<br />
for (int i=p; i<2*p; i++) {<br />
residue[i] = residue[i-p];<br />
}<br />
<br />
// 2) Построение матрицы Адамара<br />
// Заполнение первой строки 1-цами<br />
for (int j=0; j<n; j++) {<br />
result[0][j] = 1;<br />
}<br />
// Заполнение первого столбца 1-цами<br />
for (int i=1; i<n; i++) {<br />
result[i][0] = 1;<br />
}<br />
// Заполнение оставшейся части матрицы с использованием вспомогательного массива вычетов residues<br />
for (int i=1; i<n; i++) {<br />
for (int j=1; j<n; j++) {<br />
result[i][j] = residues[j-i+p];<br />
}<br />
}<br />
}<br />
</source><br />
<br />
=== Последовательная сложность алгоритма ===<br />
<br />
Под сложностью будем понимать зависимость числа операций от задаваемого порядка матрицы <math>n</math>. <br />
<br />
Основными операциями алгоритма являются:<br />
<br />
* <math>\frac{n}{2}-2</math> операций умножения;<br />
* <math>\frac{n}{2}-2</math> операций взятия остатка;<br />
* <math>n^2+\frac{5}{2}n-3</math> операций присваивания.<br />
<br />
Из чего следует, что алгоритм имеет квадратичную последовательную сложность.<br />
<br />
=== Информационный граф ===<br />
<br />
Информационный граф алгоритма можно представить в виде четырёх последовательных блоков. Первый блок содержит <math>n-1</math> параллельных ветвей, второй блок - <math>\frac{n}{2}-1</math> параллельных ветвей, третий - <math>n-1</math> и четвёртый - <math>n^2</math>.<br />
<br />
[[Файл:i_graph2.png]]<br />
<br />
Каждая вершина из <math>A_1-A_{n-1}</math>, <math>C_1-C_{n-1}</math>, <math>D_1-D_{n^2}</math> соответствует операции присваивания, каждая вершина из <math>B_1-B_{\frac{n}{2}-1}</math> соответствует трём последовательным операциям: умножения, взятия остатка по модулю и присваивания, а вершины, окрашенные серым, представляют собой промежуточные точки синхронизации.<br />
<br />
=== Ресурс параллелизма алгоритма ===<br />
<br />
Как видно из информационного графа алгоритма, в параллельном варианте необходимо последовательно выполнить следующие блоки:<br />
<br />
* <math>n-1</math> операций присваивания;<br />
* <math>\frac{n}{2}-1</math> участков, состоящих из трёх операций: умножения, взятия остатка и присваивания;<br />
* <math>n-1</math> операций присваивания;<br />
* <math>n^2</math> операций присваивания.<br />
<br />
Из этого можно сделать вывод, что высота ярусно-параллельной формы информационного графа равняется 6 (присваивание, умножение, взятие остатка, присваивание, присваивание, присваивание). Ширина ярусно-параллельной формы равняется <math>n^2</math>, что означает, что при использовании <math>n^2</math> процессоров матрица Адамара будет строиться за 6 операций.<br />
<br />
=== Входные и выходные данные алгоритма ===<br />
<br />
'''Входные данные:''' число <math>n</math> - порядок матрицы Адамара <math>H_n</math>. Дополнительные ограничения на <math>n</math>:<br />
* <math>n</math> - натуральное;<br />
* <math>n</math> делится на 4;<br />
* <math>n-1</math> - простое.<br />
'''Объем входных данных:''' 1 (число <math>n</math>).<br />
<br />
'''Выходные данные:''' построенная матрица Адамара <math>H_n</math> (её элементы <math>h_{ij}</math>).<br />
<br />
'''Объем выходных данных:''' <math>n^2</math> (количество элементов матрицы Адамара размера <math>n*n</math>).<br />
<br />
=== Свойства алгоритма ===<br />
<br />
Соотношение последовательной и параллельной сложности в случае неограниченных ресурсов является квадратичным. <br />
<br />
Вычислительная мощность алгоритма является постоянной (<math>O(1)</math>). <br />
<br />
Алгоритм является полностью детерминированным. <br />
<br />
Для вершин <math>A_1-A_{n-1}</math>, <math>B_1-B_{\frac{n}{2}-1}</math>, <math>C_1-C_{n-1}</math> информационного графа степени исхода являются линейными, что означает, что при возможности на этапе реализации необходимо позаботиться об эффективном доступе к элементам массива "<math>residues</math>".<br />
<br />
== Программная реализация алгоритма ==<br />
<br />
=== Особенности реализации последовательного алгоритма ===<br />
<br />
=== Локальность данных и вычислений ===<br />
<br />
=== Возможные способы и особенности параллельной реализации алгоритма ===<br />
<br />
=== Масштабируемость алгоритма и его реализации ===<br />
<br />
<br />
Исследование масштабируемости параллельной реализации алгоритма построения матрицы Адамара проводилось на суперкомпьютере «Ломоносов». Для этого была исследована собственная реализация алгоритма с использованием средств MPI. В ходе исследования было произведено множество запусков программы с различными значениями параметра <math>n</math> (размер матрицы Адамара) и числом процессоров.<br />
<br />
Набор и границы значений изменяемых параметров запуска реализации алгоритма:<br />
*число процессоров (p): [2,64] с шагом 2;<br />
*размер матрицы: простые числа в диапазоне [4,10000].<br />
<br />
В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:<br />
*минимальная эффективность реализации 0.0000029% при n=4, p=2;<br />
*максимальная эффективность реализации 0.323409% при n=908, p=2.<br />
<br />
Ниже представлены графики времени работы, производительности и эффективности данной реализации алгоритма построения матрицы Адамара в зависимости от изменяемых параметров запуска.<br />
[[Файл:time_graph.png|500px|thumb|center|Время работы параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]<br />
[[Файл:perform_graph.png|500px|thumb|center|Изменение производительности параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]<br />
[[Файл:efficiency_graph.png|500px|thumb|center|Эффективность работы параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]<br />
<br />
<br />
[https://github.com/snikersman/Hadamard Исследованная параллельная реализация на языке C++]<br />
<br />
Построим оценки масштабируемости, используя полученные результаты:<br />
*По размерности задачи. Увеличение размерности задачи приводит к увеличению производительности.<br />
*По числу процессоров. С ростом числа процессоров растет производительность, но при малых размерностях задачи этот рост незначителен. Это связано с дополнительными издержками по записи в участок памяти каждого процессора вспомогательного массива вычетов, а также с обменом информации между процессорами.<br />
*По двум направлениям. При увеличении как числа процессоров, так и размерности задачи, производительность увеличивается. Причем чем больше используется процессоров, тем сильнее увеличивается производительность при увеличении размерности.<br />
<br />
=== Динамические характеристики и эффективность реализации алгоритма ===<br />
<br />
=== Выводы для классов архитектур ===<br />
<br />
=== Существующие реализации алгоритма ===<br />
<br />
Алгоритм построения матрицы Адамара реализован в различных математических пакетах и библиотеках: <br />
* [https://www.mathworks.com/help/matlab/ref/hadamard.html?requestedDomain=www.mathworks.com MATLAB] (вносятся дополнительные ограничения, когда n, или n/12, или n/20 являются степенями по основанию 2)<br />
* [http://r-survey.r-forge.r-project.org/survey/html/hadamard.html R]<br />
* [https://reference.wolframcloud.com/cloudplatform/ref/HadamardMatrix.html Wolfram Mathematica]<br />
* [http://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.linalg.hadamard.html SciPy для Python]<br />
<br />
== Литература ==</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%9E%D0%B1%D1%81%D1%83%D0%B6%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5_%D1%83%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA%D0%B0:Nikita&diff=18889Обсуждение участника:Nikita2016-11-21T21:04:19Z<p>Chernyavskiy: </p>
<hr />
<div>Замечания к оформлению:<br />
<br />
1. Пункт 1.7 что обозначают серые вершины на графе?<br />
<br />
2. в пункте 1.9 указать чему соответствуют разные входные и выходные данные. Иначе непонятно будет человеку, который первый раз на сайте.<br />
<br />
3. Ссылки на литературу внутри текста статьи не нашел.<br />
<br />
<br />
'''Второй этап проверки:'''<br />
Добавляйте сюда ответы на вопросы и ход исправлений. <br />
Возможно появление дополнительных замечаний.<br />
<br />
1. Думаю, описание метода Пейли разумнее переместить в раздел "Математическое описание"<br />
2. В математическом описании желательно хотя бы минимально кратко обосновать корректность (что достаточно проверить (p-1)/2 квадратов, и что матрица будет состоять только из элементов +1 и -1). <br />
3. Исправить код. Есть как опечатки, так и ошибки. Вообще говоря, для любой похожей математической задачи необходимо писать тесты. Здесь он очевиден - проверить получившуюся матрицу по определению. В Algowiki тест вставлять не нужно, приведите его здесь.<br />
4. Информационный граф неправилен. У вас, скорее, отражена макроструктура. Алгоритм довольно прост, поэтому необходимо построить граф по всем правилам, где выход операции переходит строго на вход следующей операции. Разумно будет взять конкретный пример n=4. Лучше построить граф, как с данными, так и без них. Представленный граф тоже можно будет оставить для наглядности. Его основная проблема в том, что не видно, как функция построения итоговой матрицы обращается к элементам residual, что может быть важным для каких-либо архитектур.</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA:Vika3410/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D0%A0%D0%B0%D0%B7%D0%B4%D0%B5%D0%BB%D1%8F%D0%B9_%D0%B8_%D0%B2%D0%BB%D0%B0%D1%81%D1%82%D0%B2%D1%83%D0%B9&diff=16200Участник:Vika3410/Метод Разделяй и властвуй2016-11-08T19:03:41Z<p>Chernyavskiy: </p>
<hr />
<div><!--{{Assignment|IgorS}}--><br />
Авторы статьи: [[Участник:NikoSergAlex|Сергеев Никита]] (группа 614) (1.1, 1.2, 1.5, 1.6, 1.7, 1.8, 1.10), [[Участница:Vika3410|Стрельцова Виктория]] (группа 614) (1.2, 1.3, 1.4, 1.6, 1.7, 1.9, 1.10)<br />
{{algorithm<br />
| name = Метод "Разделяй и властвуй" вычисления собственных значений и векторов трёхдиагональной матрицы<br />
| serial_complexity = <math> c\frac{4}{3}n^{3} </math><br />
| parallel_complexity = <math> O(n^{2.3}) </math><br />
<br />
крайне редко: <math> O(n^{2}) </math> <br />
| pf_width = <br />
| input_data = <math> 2n - 1 </math><br />
| output_data = <math> n + n^2 </math><br />
}}<br />
<br />
= Свойства и структура алгоритма =<br />
<br />
<br />
== Общее описание алгоритма ==<br />
'''Метод разделяй и властвуй вычисления собственных значений и векторов трёхдиагональной матрицы''' - является наиболее быстрым из существующих методов вычисления всех собственных значений и собственных векторов трехдиагональной матрицы, начиная с порядка n, который примерно равен 26. (Точное значение этого порогового порядка в конкретном случае зависит от компьютера.) <br />
<br />
Численно устойчивая реализация данного метода весьма не тривиальна, так как не смотря на то, что впервые метод был предложен в 1981 г., "правильный" способ реализации метода был найден лишь в 1992 г. Этот способ был воплощен при помощи LAPACK-программ ssyevd (для плотных матриц) и sstevd (для трехдиагональных матриц). В этих программах стратегия "разделяй-и-влавствуй" используется для матриц порядка выше 25. <br />
<br />
Для матриц порядка ниже 25 (или в тех случаях, когда требуются только собственные значения) автоматически происходит переход к методу QR-итерации.<br />
<br />
== Математическое описание алгоритма ==<br />
Пусть <br />
<br />
:<math><br />
L = \begin{bmatrix}<br />
a_{1} & b_{1}&&&&& \\<br />
b_{1} & \ddots & \ddots \\<br />
& \ddots & a_{m-1} & b_{m-1} \\<br />
&& b_{m-1} & a_{m} & b_{m} \\<br />
&&& b_{m} & a_{m+1} & b_{m+1} \\<br />
&&&& b_{m+1} & \ddots \\<br />
&&&&&& \ddots & b_{n-1} \\<br />
&&&&&& b_{n-1} & a_{n} \\<br />
\end{bmatrix}<br />
= \begin{bmatrix}<br />
a_{1} & b_{1} &&&&& \\<br />
b_{1} & \ddots & \ddots \\<br />
& \ddots & a_{m-1} & b_{m-1} \\<br />
&& b_{m-1} & a_{m} - b_{m} \\<br />
&&&& a_{m+1} - b_{m} & b_{m+1} \\<br />
&&&& b_{m+1} & \ddots \\<br />
&&&&&& \ddots & b_{n-1} \\<br />
&&&&&& b_{n-1} & a_{n} \\<br />
\end{bmatrix} +<br />
</math><br />
<br />
<math><br />
+ \begin{bmatrix}<br />
&&&&&&& \\<br />
&&&&&&& \\<br />
&&&b_{m} & b_{m} \\<br />
&&&b_{m} & b_{m} \\<br />
&&&&&&& \\<br />
&&&&&&& \\<br />
\end{bmatrix}<br />
<br />
= \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m} * \begin{bmatrix} 0 \\ \vdots \\ 0 \\ 1 \\ 1 \\ 0 \\ \vdots \\ 0 \end{bmatrix} \begin{bmatrix} 0 , \ldots , 0 , 1 , 1 , 0 \ldots , 0 \end{bmatrix} <br />
<br />
\equiv \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T}<br />
</math><br />
<br />
В предположении, что известны спектральные разложения матриц <math>T_{1}</math> и <math>T_{2}</math>: <br />
<math>T_{i}=Q_{i} \Lambda_{i} Q_{i}^{T} </math>. На самом деле, они будут вычисляться рекурсивно тем же самым алгоритмом. <br />
<br />
Можно установить связь между собственными значениями матрицы Т и собственными значениями матриц<br />
<math>T_{1}</math> и <math>T_{2}</math>. Получается:<br />
<br />
<math> <br />
T = \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T} <br />
= \begin{bmatrix} Q_{1} \Lambda_{1} Q_{1}^{T} & 0 \\ 0 & Q_{2} L_{2} Q_{2}^{T}\end{bmatrix} + b_{m}vv^{T} <br />
= \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}(\begin{bmatrix} \Lambda_{1} & \\ & \Lambda_{2}\end{bmatrix} + b_{m}vv^{T})\begin{bmatrix} Q_{1}^{T} & 0 \\ 0 & Q_{2}^{T}\end{bmatrix}<br />
</math>,<br />
<br />
где <math> u = \begin{bmatrix} Q_{1}^{T} & 0 \\ 0 & Q_{2}^{T}\end{bmatrix}v </math> - матрица, в первой строке которой находятся элементы последнего столбца матрицы <math> Q_{1}^{T}</math>, а во второй - элементы первого столбца матрицы <math> Q_{2}^{T}</math>, так как <math>v = \begin{bmatrix} 0 , \ldots , 0 , 1 , 1 , 0 \ldots , 0 \end{bmatrix}^T</math>.<br />
Следовательно, <math>T</math> имеет такие же собственные значения, что и подобная ей матрица <math>D + \rho uu^{T}</math>, <br />
где <math>D = \begin{bmatrix} L_{1} & 0 \\ 0 & L_{2}\end{bmatrix}</math> - диагональная матрица, <br />
<math>\rho = b_{m}</math> - число, а <math>u</math> - вектор. <br />
В дальнейшем предполагаем, не ограничивая общности, что диагональные элементы <math>d_{1}, \ldots, d_{n}</math> матрицы <math>D</math> упорядочены по не возрастанию: <math>d_{n} <= \ldots <=d_{1}</math>.<br />
<br />
Для того, чтобы найти собственные значения матрицы <math>D + \rho uu^{T}</math>, потребуется вычислить её характеристический многочлен, считая пока матрицу <math>D - \lambda I</math> невырожденной.<br />
Тогда получаем<br />
<math>det(D + \rho uu^{T} - \lambda I) = det((D - \lambda I)(I + \rho (D- \lambda I)^{-1} uu^{T}))</math>.<br />
<br />
Так как <math>D - \lambda I</math> невырожденная, <math>det(I + \rho (D - \lambda I)^{-1}uu^{T}) = 0</math> тогда и только тогда, когда <math>\lambda</math> - является собственным значением. Можем заметить, что матрица <math>I + \rho (D - \lambda I)^{-1}uu^{T}</math> получается из единичной путём добавления матрицы ранга 1. Определитель такой матрицы не сложно вычислить.<br />
<br />
''Лемма 1.'' Справедливо равенство <math>det(I + xy^{T}) = 1 + y^{T}x</math>, где <math>x</math> и <math>y</math> - векторы.<br />
<br />
Следовательно, получаем<br />
<math>det(I + \rho (D - \lambda I)^{-1}uu^{T}) = 1 + \rho u^{T}(D - \lambda I)^{-1}u</math> <math> = 1 + \rho \sum_{i=1, n} \frac{u_{i}^{2}} {d_{i}-\lambda} \equiv f(\lambda)</math> , <br />
<br />
т.е. собственные значения матрицы <math>T</math> являются корнями так называемого векового уравнения <math>f(\lambda) = 0</math>. Если все числа <math>d_{i}</math> различны между собой и все <math>u_{i} <> 0</math> (случай общего положения), то <math>f(\lambda)</math> имеет график типа, который показан на рис.1(где <math>n = 4</math> и <math>\rho > 0</math>).<br />
<br />
[[File:Сергеев 1.jpg|thumb|center|800px|Рис. 1. График функции <math> f(\lambda) = 1 + \frac{0.5}{1 - \lambda} + \frac{0.5}{2 - \lambda} + \frac{0.5}{3 - \lambda} + \frac{0.5}{4 - \lambda}</math>]]<br />
<br />
По рисунку можно заметить, что прямая <math>y = 1</math> является горизонтальной асимптотой для данного графика, а прямые <math>\lambda = d_{i}</math> есть вертикальные асимптоты. Так как <math>f^{'}(\lambda) = \rho \sum_{i=1, n} \frac{u_{i}^{2}} {(d_{i}-\lambda)^{2}}> 0 </math>, функция возрастает всюду, кроме точек <math>\lambda = d_{i}</math>. Из этого следует, что корни функции разделяются числами <math>d_{i}</math> и ещё один корень находится справа от точки <math>d_{1}</math> (на рис. 1 <math>d_{1} = 4</math>). (При <math>\rho<0</math> функция <math>f(\lambda)</math> всюду убывает и соответствующий корень будет находиться слева от точки <math>d_{n}</math>). Для функции <math>f(\lambda)</math>, которая является монотонной и гладкой на каждом из интервалов <math>(d_{i+1},d_{i})</math>, можно найти вариант метода Ньютона, который будет быстро и монотонно сходиться к каждому из корней, при условии, что начальная точка взята в <math>(d_{i+1},d_{i})</math>. Нам достаточно знать тот факт, что на практике метод сходится к каждому собственному значению за строго ограниченное число шагов. Поскольку вычисление <math>f(\lambda)</math> и <math>f^{'}(\lambda)</math> стоит <math>O(n)</math> флопов, для вычисления одного собственного значения достаточно <math>O(n)</math> флопов, следовательно для вычисления всех <math>n</math> собственных значений матрицы <math>D + \rho uu^{T}</math> потребуется <math>O(n^{2})</math> флопов.<br />
Для собственных векторов матрицы <math>D + \rho uu^{T}</math> мы легко можем получить явные выражения.<br />
<br />
''Лемма 2.'' Если <math>\alpha</math> - собственное значение матрицы <math>D + \rho uu^{T}</math>, то соответствующий вектор равен <math>(D - \alpha I)^{-1}u</math>. Поскольку матрица <math>D - \alpha I</math> диагональная, для вычисления такого вектора достаточно <math>O(n)</math> флопов.<br />
<br />
Доказательство.<br />
<math>(D + \rho uu^{T})[(D - \alpha I)^{-1}u] = <br />
<br />
(D - \alpha I + \alpha I + \rho uu^{T})(D - \alpha I)^{-1}u = <br />
<br />
u + \alpha (D - \alpha I)^{-1}u + u[\rho u^{T}(D - \alpha I)^{-1}u]= </math> <br />
<br />
<math> = u + \alpha(D - \alpha I)^{-1}u - u = \alpha [(D - \alpha I)^{-1}u]</math>, <br />
<br />
поскольку <br />
<br />
<math> \rho u^{T}(D - \alpha I)^{-1}u + 1 = f(\alpha) = 0 </math>. <br />
<br />
Что и требовалось доказать.<br />
<br />
Получается, что для вычисления по этой простой формуле всех <math>n</math> собственных векторов потребуется <math>O(n^{2})</math> флопов. К сожалению, данная формула не обеспечивает нам численной устойчивости, так как для двух очень близких значений <math>\alpha_{i}</math> может давать неортогональные приближенные собственные векторы <math>u_{i}</math>. Учёным потребовалось целое десятилетие для того, чтобы найти устойчивую альтернативу исходному описанию алгоритма. Подробнее детали будут обсуждаться ниже в данном разделе. <br />
<br />
Алгоритм является рекурсивным.<br />
<br />
До сих пор полагалось, что все <math>d_{i}</math> различны и все <math>u_{i}</math> отличны от нуля. Если это будет не так, то вековое уравнение <math>f(\lambda)=0</math> имеет <math>k</math> вертикальных асимптот, где <math>k<n</math>, а следовательно <math>k</math> корней. Однако оказывается, что остальные <math>n - k</math> собственных значений могут быть определены без каких-либо усилий: в случае, если <math>d_{i}=d_{i+1}</math> или <math>u_{i}=0</math>, легко показать, что <math>d_{i}</math> является собственным значением и для матрицы <math>D + \rho uu^{T}</math>. В такой ситуации мы говорим о '''дефляции'''. На практике выбирается некоторое пороговое значение и дефляция для числа <math>d_{i}</math> регистрируется, в том случает, если в смысле этого порога <math>d_{i}</math> достаточно близко к <math>d_{i+1}</math> либо <math>u_{i}</math> достаточно мало.<br />
<br />
Основной выигрыш от использования дефляции состоит не в том, что убыстряется решение векового уравнения - этот этап в любом случае стоит лишь <math>O(n^{2})</math> операций. Выигрыш заключается в ускорении матричного умножения на последнем шаге алгоритма. Действительно, если <math>u_{i}=0</math>, то соответствующий собственный вектор есть i-й столбец <math>e_{i}</math> единичной матрицы. Это означает, что <math>e_{i}</math> является i-м столбцом в матрице <math>Q_{'}</math>, следовательно при формировании матрицы <math>Q</math> применяя левое умножение <math>Q_{1}</math> на <math>Q_{2}</math> вычисление i-го столбца не будет требовать никаких затрат. Аналогичное упрощение возможно в случае <math>d_{i} = d_{i+1}</math>. При дефляции многих собственных значений устраняется большая часть работы, которая связана с матричным умножением.<br />
<br />
== Вычислительное ядро алгоритма ==<br />
Вычислительным ядром последовательной схемы решения будет являться вычисление матрицы <math>Q</math> собственных векторов при помощи умножения матрицы <math>Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}</math> на матрицу <math>Q^{'}</math>. Эта операция имеет сложность <math>cn^{3}</math> о чём будет говориться ниже, в разделе [[#Последовательная сложность алгоритма]] .<br />
<br />
Данной операции предшествует вычисление собственных значений и векторов матрицы <math> D + \rho uu^{T}</math>.<br />
<br />
== Макроструктура алгоритма ==<br />
В разделе [[#Информационный граф]] описана структура алгоритма, в которой есть блок умножения матриц для вычисления собственных векторов, являющийся вычислительным ядром алгоритма. В соответствующем разделе ([[#Вычислительное ядро алгоритма]]) мы упоминали о том, что данному блоку предшествует вычисление собственных значений, которое производится [https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D0%9D%D1%8C%D1%8E%D1%82%D0%BE%D0%BD%D0%B0 методом Ньютона].<br />
<br />
Далее пойдет речь о решении '''векового уравнения''', которое является одной из основных частей алгоритма.<br />
<br />
Предположим, что некоторое <math>u_{i}</math>, хотя и мало, все же недостаточно мало для того, чтобы была зарегистрирована дефляция. В этом случае применение метода Ньютона к решению векового уравнения встречается с затруднениями. Вспомним, что пересчет приближённого решения <math>u_{j}</math> уравнения <math>f(\lambda) = 0</math> в методе Ньютона основан на следующих положениях:<br />
<br />
1. Вблизи точки <math>\lambda = \lambda_{j}</math> функция <math>f(\lambda)</math> аппроксимируется линейной функцией <math>l(\lambda)</math>; график есть прямая линия, касающаяся графика функции <math>f(\lambda)</math> при <math>\lambda = \lambda_{j}</math>.<br />
<br />
2. В качестве <math>\lambda_{j+1}</math> берётся нуль этого линейного приближения, т.е. <math>l(\lambda_{j+1})=0</math>.<br />
<br />
Функция, показанная на рис.1, не доставляет видимых трудностей методу Ньютона, поскольку вблизи каждого своего нуля <math>f(\lambda)</math> достаточно хорошо аппроксимируется линейными функциями. Однако рассмотрим график функции на рис. 2. Она получена из функции на рис. 1 заменой значения .5 для <math>u_{i}^{2}</math> на .001. Это новое значение недостаточно мало для того, чтобы вызвать дефляцию. График функции в левой части рис.2 визуально не отличим от её вертикальных и горизонтальных асимптот, поэтому в правой части укрупненно воспроизведён фрагмент графика, прилегающий к вертикальной асимптоте <math>\lambda = 2</math>. Видно, что график слишком быстро "выполняет поворот" и для большей части значений <math>\lambda</math> почти горизонтален. Поэтому, применяя метод Ньютона почти к любому начальному приближению <math>\lambda_{0}</math>, мы получаем линейное приближение <math>l(\lambda)</math> с почти горизонтальным графиком и малым положительным угловым коэффициентом. В результате <math>\lambda_{1}</math> является отрицательным числом, огромным по абсолютной величине, которое совершенно бесполезно в качестве приближения к истинному корню.<br />
<br />
[[File:Сергеев 2.jpg|thumb|center|800px|Рис. 2. График функции <math> f(\lambda) = 1 + \frac{10^{-3}}{1 - \lambda} + \frac{10^{-3}}{2 - \lambda} + \frac{10^{-3}}{3 - \lambda} + \frac{10^{-3}}{4 - \lambda}</math>]]<br />
<br />
Чтобы найти выход из этого положения, можно модифицировать метод Ньютона следующим образом: раз <math>f(\lambda)</math> нельзя хорошо приблизить линейной функцией <math>l(\lambda)</math>, попробуем взять в качестве приближения какую-нибудь другую простую функцию <math>h(\lambda)</math>. Нет ничего особого именно в прямых линиях: для метода Ньютона вместо <math>l(\lambda)</math> можно взять любое приближение <math>h(\lambda)</math>, значения и нули которого легко вычисляются. Функция <math>f(\lambda)</math> имеет полюсы в точках <math>d_{i}</math> и <math>d_{i+1}</math>, которые определяют её поведение в соответствующих окрестностях. Поэтому при поиске корня в интервале <math>(d_{i+1}, d_{i})</math> естественно выбрать функцию <math>h(\lambda)</math>, также имеющую эти полюсы, т.е. функцию вида<br />
<math>h(\lambda)= \frac{c_{1}}{d_{i}-\lambda} + \frac{c_{2}}{d_{i+1}-\lambda} + c_{3}</math><br />
<br />
Константы <math>c_{1},c_{2}</math> и <math>c_{3}</math> обеспечивающие, что <math>h(\lambda)</math> есть приближение к <math>f(\lambda)</math>, можно выбрать несколькими способами. Отметим, что если <math>c_{1},c_{2}</math> и <math>c_{3}</math> уже известны, то уравнение <math>h(\lambda)=0</math> легко решается относительно <math>\lambda</math>, поскольку сводится к эквивалентному квадратному уравнению<br />
<math>c_{1}(d_{i+1}-\lambda)+c_{2}(d_{i}-\lambda)+c_{3}(d_{i}-\lambda)(d_{i+1}-\lambda)=0</math><br />
<br />
Пусть <math>\lambda_{j}</math> - приближённое значение корня. определим <math>c_{1},c_{2}</math> и <math>c_{3}</math> так, чтобы<br />
<math>\frac{c_{1}}{d_{i}-\lambda} + \frac{c_{2}}{d_{i+1}-\lambda} + c_{3} = h(\lambda) \approx f(\lambda) = 1 + \rho \sum_{k=1, n} \frac{u_{k}^{2}} {d_{k}-\lambda} </math><br />
для <math>\lambda</math> в окрестности <math>\lambda_{j}</math>. Заметим, что<br />
<math>f(\lambda) = 1 + \rho \sum_{k=1, i} \frac{u_{k}^{2}} {d_{k}-\lambda} + \rho \sum_{k=i+1, n} \frac{u_{k}^{2}} {d_{k}-\lambda} \equiv 1 + \psi_{1}(\lambda) + \psi_{2}(\lambda)</math>.<br />
<br />
Если <math>\lambda \in (d_{i+1},d_{i})</math>, то <math>\psi_{1}(\lambda)</math> есть сумма положительных слагаемых, а <math>\psi_{2}(\lambda)</math> - сумма отрицательных. Поэтому и <math>\psi_{1}(\lambda)</math>, и <math>\psi_{2}(\lambda)</math> могут быть вычислены с высокой точностью; однако при их сложении вполне вероятно взаимное уничтожение верных разрядов и потеря относительной точности в сумме. Возьмем числа <math>c_{1}</math> и <math>\hat{c_{1}}</math>, такие, что функция <br />
<math>h_{1}(\lambda) \equiv \hat{c_{1}} + \frac{c_{1}}{d_{i}-\lambda}</math> удовлетворяет условиям <math>h_{1}(\lambda_{j}) = \psi_{1}(\lambda_{j})</math> и <math>h_{1}^{'}(\lambda_{j})=\psi_{1}^{'}(\lambda_{j})</math> (*)<br />
<br />
Это означает, что гипербола, являющаяся графиком функции <math>h_{1}(\lambda)</math>, касается графика функции <math>\psi_{i}(\lambda)</math> при <math>\lambda = \lambda_{j}</math>. Два условия в (*) - это обычные условия метода Ньютона, за исключением того, что вместо прямой в качестве приближения используется гипербола. Легко проверить, что <math>c_{1}=\psi_{1}^{'}(\lambda_{j})(d_{i} - \lambda_{j})^{2}</math> и <math>\hat{c_{1}}=\psi_{1}(\lambda_{j}) - \psi_{1}^{'}(\lambda_{j})(d_{i} - \lambda_{j})</math>.<br />
<br />
Подобным же образом выбираем <math>c_{2}</math> и <math>\hat{c_{2}}</math> так, чтобы функция <br />
<math>h_{2}(\lambda) \equiv \hat{c_{2}} + \frac{c_{2}}{d_{i+1}-\lambda}</math> удовлетворяла условиям<br />
<math>h_{2}(\lambda_{j}) = \psi_{2}(\lambda_{j})</math> и <math>h_{2}^{'}(\lambda_{j})=\psi_{2}^{'}(\lambda_{j})</math><br />
<br />
Наконец, полагаем<br />
<math>h(\lambda) = 1 + h_{1}(\lambda) + h_{2}(\lambda) = (1 + \hat{c_{1}} + \hat{c_{2}} + \frac{c_{1}}{d_{i}-\lambda} + \frac{c_{2}}{d_{i+1}-\lambda} \equiv c_{3} + \frac{c_{1}}{d_{i}-\lambda} + \frac{c_{2}}{d_{i+1}-\lambda}</math>.<br />
<br />
== Схема реализации последовательного алгоритма ==<br />
Рассмотрим каким именно образом происходит вычисление собственных значений и собственных векторов симметричной трехдиагональной матрицы при помощи стратегии "разделяй и властвуй":<br />
<br />
''proc dc_eig''<math>(T,Q,\Lambda)...</math> по входной матрице <math>T</math> вычисляются выходные матрицы <math>Q</math> и <math>\Lambda</math>, такие, что <math>T = Q\Lambda Q^{T}</math><br />
<br />
В случае, '''если''' <math>T</math> - матрица размера <math>1</math> x <math>1</math> :<br />
<br />
1. Присвоить выходным параметрам значения <math> Q = 1, \Lambda = T</math><br />
<br />
'''Иначе''':<br />
<br />
1. Представить <math>T</math> в виде <math> T = \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T} </math><br />
<br />
2. ''call dc_eig''<math>(T_{1},Q_{1},\Lambda_{1})</math><br />
<br />
3. ''call dc_eig''<math>(T_{2},Q_{2},\Lambda_{2})</math><br />
<br />
4. Построить <math>D+\rho uu^{T}</math> по <math> \Lambda_{1},\Lambda_{2}, Q_{1}, Q_{2}</math><br />
<br />
5. Найти матрицу собственных значений <math>\Lambda</math><br />
<br />
6. Найти матрицу собственных векторов <math>Q^{'}</math> для матрицы <math>D+\rho uu^{T}</math><br />
<br />
7. Построить матрицу собственных векторов <math>Q</math> для матрицы <math>T</math> : <math> Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}* Q^{'} </math><br />
<br />
8. Присвоить выходным параметрам значения <math>Q</math> и <math>\Lambda</math><br />
<br />
'''endif'''<br />
<br />
== Последовательная сложность алгоритма ==<br />
Рассмотрим сложность алгоритма. Пусть <math>t(n)</math> - число флопов, которое потребуется при обработке матрицы размера <math> n * <br />
n</math> процедурой ''dc_eig''. В таком случае <br />
<br />
<math> t(n) = 2t(n/2) </math> два рекурсивных обращения к ''dc_eig''<math>(T_{i},Q_{i},\Lambda_{i})</math><br />
<math> +O(n^{2})</math> вычисление собственных значений матрицы <math>D+\rho uu^{T}</math><br />
<math> +O(n^{2})</math> вычисление собственных векторов матрицы <math>D+\rho uu^{T}</math><br />
<math> +c*n^{3}</math> вычисление матрицы <math>Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}*Q^{'}</math><br />
<br />
<br />
Если <math> Q_{1}, Q_{2}</math> и <math>Q^{'}</math> рассматривать как плотные матрицы и использовать стандартный алгоритм матричного умножения, то константа <math> c </math> в последней строке будет равна 1. Следовательно, именно это умножение и будет составлять наиболее трудоёмкую часть алгоритма в целом. Игнорируя члены порядка <math>n^{2}</math>, получаем <math>t(n) = 2t(n/2) + cn^{3}</math>. Решив это разностное уравнение, находим <math> t \approx c\frac{4}{3}n^{3} </math><br />
<br />
На практике константа <math>c</math> обычно оказывается гораздо меньше 1, так как матрица <math>Q^{'}</math> весьма разрежена вследствие явления, которое называется дефляцией, и которое было описано выше.<br />
<br />
== Информационный граф ==<br />
На рисунке 3 изображена структура алгоритма.<br />
[[File:Сергеев 5.jpg|thumb|center|left|1000px|Рис. 3. Дерево алгоритма "Разделяй и властвуй"]]<br />
<br />
== Ресурс параллелизма алгоритма ==<br />
Данная структура алгоритма позволяет выполнять рекурсивный вызов функций для двух подматриц исходной матрицы как последовательно, так и параллельно. <br />
При последовательной реализации алгоритма вызов функций производится по очереди - сначала для одной подматрицы, затем для другой. При параллельной реализации алгоритма данные функции могут отрабатывать одновременно.<br />
Поскольку функции являются рекурсивными, их параллельный вызов даст значительный выигрыш во времени.<br />
При размерности матрицы больше 3 параллельная реализация позволяет сократить количество этапов работы алгоритма больше, чем в два раза.<br />
<br />
== Входные и выходные данные алгоритма ==<br />
'''Входные данные''': трёхдиагональная симметрическая матрица, описанная в разделе [[#Математическое описание алгоритма]].<br />
<br />
'''Объём входных данных''': <math> 2n - 1 </math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы).<br />
<br />
'''Выходные данные''': матрица собственных значений размера <math> 1 * n </math> и матрица собственных векторов размера <math> n * n </math><br />
<br />
'''Объём выходных данных''': <math> n + n^2 </math><br />
<br />
== Свойства алгоритма ==<br />
Данный алгоритм является самым быстрым алгоритмом среди существующих: Разделяй и властвуй, QR, Бисекция и обратная итерация.<br />
<br />
'''Последовательная сложность данного алгоритма:''' <math> t = c\frac{4}{3}n^{3} </math><br />
<br />
'''Параллельная сложность алгоритма (за счет дефляции):''' <math> O(n^{2.3})</math>; в крайне редких случаях: <math> O(n^{2}) </math>.<br />
<br />
'''Особенности алгоритма:'''<br />
<br />
1. Дефляция ([[#Дефляция]])<br />
<br />
2. Адаптированный метод Ньютона ([[#Макроструктура алгоритма]])<br />
<br />
= Программная реализация алгоритма =<br />
Вторая часть описания алгоритмов в рамках AlgoWiki рассматривает все составные части процесса их реализации. Рассматривается как последовательная реализация алгоритма, так и параллельная. Описывается взаимосвязь свойств программ, реализующих алгоритм, и особенностей архитектуры компьютера, на которой они выполняются. Исследуется работа с памятью, локальность данных и вычислений, описывается масштабируемость и эффективность параллельных программ, производительность компьютеров, достигаемая на данной программе. Обсуждаются особенности реализации для разных классов архитектур компьютеров, приводятся ссылки на реализации в существующих библиотеках.<br />
<br />
<br />
== Особенности реализации последовательного алгоритма ==<br />
<br />
== Локальность данных и вычислений ==<br />
<br />
== Возможные способы и особенности параллельной реализации алгоритма ==<br />
== Масштабируемость алгоритма и его реализации ==<br />
TBD<br />
<br />
== Динамические характеристики и эффективность реализации алгоритма ==<br />
<br />
== Выводы для классов архитектур ==<br />
<br />
== Существующие реализации алгоритма ==<br />
Единственный найденный пример реализации описан в [http://www.netlib.org/lapack/lawnspdf/lawn132.pdf Francoise Tisseury, Jack Dongarra, "Parallelizing the Divide and Conquer Algorithm for the Symmetric Tridiagonal Eigenvalue Problem on Distributed Memory Architectures" ] ([3] с. 7, 19-20).<br />
<br />
= Литература =<br />
[1] Дж. Деммель, "Вычислительная линейная алгебра"<br />
<br />
[2] [http://www.netlib.org/lapack/lawnspdf/lawn132.pdf Francoise Tisseury, Jack Dongarra, "Parallelizing the Divide and Conquer Algorithm for the Symmetric Tridiagonal Eigenvalue Problem on Distributed Memory Architectures"]<br />
<br />
[3] [https://en.wikipedia.org/wiki/Divide-and-conquer_eigenvalue_algorithm Алгоритм "Разделяй и властвуй" - Wikipedia]<br />
<br />
<br />
[[en:Description of algorithm properties and structure]]</div>Chernyavskiyhttps://xn--80aecvaldz.xn--80ahdrnmvk.xn--p1ai/w/ru/index.php?title=%D0%9E%D0%B1%D1%81%D1%83%D0%B6%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5_%D1%83%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA%D0%B0:NikoSergAlex&diff=16199Обсуждение участника:NikoSergAlex2016-11-08T19:02:18Z<p>Chernyavskiy: </p>
<hr />
<div>== Замечания к статье ==<br />
<br />
* отсутствует описание вклада каждого автора--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:53, 26 октября 2016 (MSK)<br />
** +--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:52, 2 ноября 2016 (MSK)<br />
<br />
* п.п. 1.7 не соответствует рисунку информационного графа--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:53, 26 октября 2016 (MSK)<br />
<br />
* п.п. 1.8 и 1.9 не раскрыт--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:53, 26 октября 2016 (MSK)<br />
<br />
===Пример правильно оформленной работы===<br />
<br />
* http://algowiki-project.org/ru/Разложение_Холецкого_(метод_квадратного_корня)<br />
<br />
<br />
== Второй этап проверки ==<br />
<br />
=== Итерация 1 ===<br />
<br />
Начальные замечания и вопросы (возможно будут появляться новые, пишите, пожалуйста, комментарии по ходу исправлений и ответы):<br />
<br />
* Исправить ошибки в формулах в разделе 1.2<br />
* Как решение векового уравнения относится к макроструктуре алгоритма (раздел 1.4)<br />
* Исправлялся ли информационный граф? То, что имеется сейчас не соответствует инструкции (https://algowiki-project.org/ru/%D0%A1%D1%82%D0%B0%D0%BD%D0%B4%D0%B0%D1%80%D1%82_%D0%B2%D0%B8%D0%B7%D1%83%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D0%B8_%D0%93%D0%90) <br />
Граф нужно кардинально переработать.<br />
* Раздел 1.8 необзодимо написать намного более подробно.<br />
* Откуда получены значения параллельной сложности алгоритма в разделе 1.10?</div>Chernyavskiy