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

Участник:Vika3410/Метод Разделяй и властвуй

2017-01-09T10:28:53Z

IgorS:

{{Assignment|IgorS}}

Авторы статьи: [[Участник:NikoSergAlex|Сергеев Никита]] (группа 614) (1.1, 1.2, 1.5, 1.6, 1.7, 1.8, 1.10, 2.4), [[Участница:Vika3410|Стрельцова Виктория]] (группа 614) (1.2, 1.3, 1.4, 1.6, 1.7, 1.9, 1.10, 2.4)
{{algorithm
| name = Метод "Разделяй и властвуй" вычисления собственных значений и векторов трёхдиагональной матрицы
| serial_complexity = <math> c\frac{4}{3}n^{3} </math>
| parallel_complexity = <math> O(n^{2.3}) </math>

крайне редко: <math> O(n^{2}) </math>
| pf_width =
| input_data = <math> 2n + 1 </math>
| output_data = <math> n(n + 1) </math>
}}

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

== Общее описание алгоритма ==
'''Метод разделяй и властвуй вычисления собственных значений и векторов трёхдиагональной матрицы''' - является наиболее быстрым из существующих методов вычисления всех собственных значений и собственных векторов трехдиагональной матрицы, начиная с порядка n, который примерно равен 26. (Точное значение этого порогового порядка в конкретном случае зависит от компьютера.)

Численно устойчивая реализация данного метода весьма не тривиальна, так как не смотря на то, что впервые метод был предложен в 1981 г., "правильный" способ реализации метода был найден лишь в 1992 г. Этот способ был воплощен при помощи LAPACK-программ ssyevd (для плотных матриц) и sstevd (для трехдиагональных матриц). В этих программах стратегия "разделяй-и-влавствуй" используется для матриц порядка выше 25.

Для матриц порядка ниже 25 (или в тех случаях, когда требуются только собственные значения) автоматически происходит переход к методу QR-итерации.

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

:<math>
L = \begin{bmatrix}
a_{1} & b_{1}&&&&& \\
b_{1} & \ddots & \ddots \\
& \ddots & a_{m-1} & b_{m-1} \\
&& b_{m-1} & a_{m} & b_{m} \\
&&& b_{m} & a_{m+1} & b_{m+1} \\
&&&& b_{m+1} & \ddots \\
&&&&&& \ddots & b_{n-1} \\
&&&&&& b_{n-1} & a_{n} \\
\end{bmatrix}
= \begin{bmatrix}
a_{1} & b_{1} &&&&& \\
b_{1} & \ddots & \ddots \\
& \ddots & a_{m-1} & b_{m-1} \\
&& b_{m-1} & a_{m} - b_{m} \\
&&&& a_{m+1} - b_{m} & b_{m+1} \\
&&&& b_{m+1} & \ddots \\
&&&&&& \ddots & b_{n-1} \\
&&&&&& b_{n-1} & a_{n} \\
\end{bmatrix} +
</math>

<math>
+ \begin{bmatrix}
&&&&&&& \\
&&&&&&& \\
&&&b_{m} & b_{m} \\
&&&b_{m} & b_{m} \\
&&&&&&& \\
&&&&&&& \\
\end{bmatrix}

= \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}

\equiv \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T}
</math>

В предположении, что известны спектральные разложения матриц <math>T_{1}</math> и <math>T_{2}</math>:
<math>T_{i}=Q_{i} \Lambda_{i} Q_{i}^{T} </math>. На самом деле, они будут вычисляться рекурсивно тем же самым алгоритмом.

Можно установить связь между собственными значениями матрицы Т и собственными значениями матриц
<math>T_{1}</math> и <math>T_{2}</math>. Получается:

<math>
T = \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T}
= \begin{bmatrix} Q_{1} \Lambda_{1} Q_{1}^{T} & 0 \\ 0 & Q_{2} L_{2} Q_{2}^{T}\end{bmatrix} + b_{m}vv^{T}
= \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}
</math>,

где <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>.
Следовательно, <math>T</math> имеет такие же собственные значения, что и подобная ей матрица <math>D + \rho uu^{T}</math>,
где <math>D = \begin{bmatrix} L_{1} & 0 \\ 0 & L_{2}\end{bmatrix}</math> - диагональная матрица,
<math>\rho = b_{m}</math> - число, а <math>u</math> - вектор.
В дальнейшем предполагаем, не ограничивая общности, что диагональные элементы <math>d_{1}, \ldots, d_{n}</math> матрицы <math>D</math> упорядочены по не возрастанию: <math>d_{n} <= \ldots <=d_{1}</math>.

Для того, чтобы найти собственные значения матрицы <math>D + \rho uu^{T}</math>, потребуется вычислить её характеристический многочлен, считая пока матрицу <math>D - \lambda I</math> невырожденной.
Тогда получаем
<math>det(D + \rho uu^{T} - \lambda I) = det((D - \lambda I)(I + \rho (D- \lambda I)^{-1} uu^{T}))</math>.

Так как <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. Определитель такой матрицы не сложно вычислить.

''Лемма 1.'' Справедливо равенство <math>det(I + xy^{T}) = 1 + y^{T}x</math>, где <math>x</math> и <math>y</math> - векторы.

Следовательно, получаем
<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> ,

т.е. собственные значения матрицы <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>).

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

По рисунку можно заметить, что прямая <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> флопов.
Для собственных векторов матрицы <math>D + \rho uu^{T}</math> мы легко можем получить явные выражения.

''Лемма 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> флопов.

Доказательство.
<math>(D + \rho uu^{T})[(D - \alpha I)^{-1}u] =

(D - \alpha I + \alpha I + \rho uu^{T})(D - \alpha I)^{-1}u =

u + \alpha (D - \alpha I)^{-1}u + u[\rho u^{T}(D - \alpha I)^{-1}u]= </math>

<math> = u + \alpha(D - \alpha I)^{-1}u - u = \alpha [(D - \alpha I)^{-1}u]</math>,

поскольку

<math> \rho u^{T}(D - \alpha I)^{-1}u + 1 = f(\alpha) = 0 </math>.

Что и требовалось доказать.

Получается, что для вычисления по этой простой формуле всех <math>n</math> собственных векторов потребуется <math>O(n^{2})</math> флопов. К сожалению, данная формула не обеспечивает нам численной устойчивости, так как для двух очень близких значений <math>\alpha_{i}</math> может давать неортогональные приближенные собственные векторы <math>u_{i}</math>. Учёным потребовалось целое десятилетие для того, чтобы найти устойчивую альтернативу исходному описанию алгоритма. Подробнее детали будут обсуждаться ниже в данном разделе.

Алгоритм является рекурсивным.

До сих пор полагалось, что все <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> достаточно мало.

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

Далее пойдет речь о решении '''векового уравнения''', которое является одной из основных частей алгоритма.

Предположим, что некоторое <math>u_{i}</math>, хотя и мало, все же недостаточно мало для того, чтобы была зарегистрирована дефляция. В этом случае применение метода Ньютона к решению векового уравнения встречается с затруднениями. Вспомним, что пересчет приближённого решения <math>u_{j}</math> уравнения <math>f(\lambda) = 0</math> в методе Ньютона основан на следующих положениях:

1. Вблизи точки <math>\lambda = \lambda_{j}</math> функция <math>f(\lambda)</math> аппроксимируется линейной функцией <math>l(\lambda)</math>; график есть прямая линия, касающаяся графика функции <math>f(\lambda)</math> при <math>\lambda = \lambda_{j}</math>.

2. В качестве <math>\lambda_{j+1}</math> берётся нуль этого линейного приближения, т.е. <math>l(\lambda_{j+1})=0</math>.

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

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

Чтобы найти выход из этого положения, можно модифицировать метод Ньютона следующим образом: раз <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>, также имеющую эти полюсы, т.е. функцию вида
<math>h(\lambda)= \frac{c_{1}}{d_{i}-\lambda} + \frac{c_{2}}{d_{i+1}-\lambda} + c_{3}</math>

Константы <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>, поскольку сводится к эквивалентному квадратному уравнению
<math>c_{1}(d_{i+1}-\lambda)+c_{2}(d_{i}-\lambda)+c_{3}(d_{i}-\lambda)(d_{i+1}-\lambda)=0</math>

Пусть <math>\lambda_{j}</math> - приближённое значение корня. определим <math>c_{1},c_{2}</math> и <math>c_{3}</math> так, чтобы
<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>
для <math>\lambda</math> в окрестности <math>\lambda_{j}</math>. Заметим, что
<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>.

Если <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>, такие, что функция
<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> (*)

Это означает, что гипербола, являющаяся графиком функции <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>.

Подобным же образом выбираем <math>c_{2}</math> и <math>\hat{c_{2}}</math> так, чтобы функция
<math>h_{2}(\lambda) \equiv \hat{c_{2}} + \frac{c_{2}}{d_{i+1}-\lambda}</math> удовлетворяла условиям
<math>h_{2}(\lambda_{j}) = \psi_{2}(\lambda_{j})</math> и <math>h_{2}^{'}(\lambda_{j})=\psi_{2}^{'}(\lambda_{j})</math>

Наконец, полагаем
<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>.

== Вычислительное ядро алгоритма ==
Вычислительным ядром последовательной схемы решения будет являться вычисление матрицы <math>Q</math> собственных векторов при помощи умножения матрицы <math>Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}</math> на матрицу <math>Q^{'}</math>. Эта операция имеет сложность <math>cn^{3}</math> о чём будет говориться ниже, в разделе [[#Последовательная сложность алгоритма]] .

Данной операции предшествует вычисление собственных значений и векторов матрицы <math> D + \rho uu^{T}</math>.

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

== Схема реализации последовательного алгоритма ==
Рассмотрим каким именно образом происходит вычисление собственных значений и собственных векторов симметричной трехдиагональной матрицы при помощи стратегии "разделяй и властвуй":

''proc dc_eig''<math>(T,Q,\Lambda)...</math> по входной матрице <math>T</math> вычисляются выходные матрицы <math>Q</math> и <math>\Lambda</math>, такие, что <math>T = Q\Lambda Q^{T}</math>

В случае, '''если''' <math>T</math> - матрица размера <math>1</math> x <math>1</math> :

1. Присвоить выходным параметрам значения <math> Q = 1, \Lambda = T</math>

'''Иначе''':

1. Представить <math>T</math> в виде <math> T = \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T} </math>

2. ''call dc_eig''<math>(T_{1},Q_{1},\Lambda_{1})</math>

3. ''call dc_eig''<math>(T_{2},Q_{2},\Lambda_{2})</math>

4. Построить <math>D+\rho uu^{T}</math> по <math> \Lambda_{1},\Lambda_{2}, Q_{1}, Q_{2}</math>

5. Найти матрицу собственных значений <math>\Lambda</math>

6. Найти матрицу собственных векторов <math>Q^{'}</math> для матрицы <math>D+\rho uu^{T}</math>

7. Построить матрицу собственных векторов <math>Q</math> для матрицы <math>T</math> : <math> Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}* Q^{'} </math>

8. Присвоить выходным параметрам значения <math>Q</math> и <math>\Lambda</math>

'''endif'''

== Последовательная сложность алгоритма ==
Рассмотрим сложность алгоритма. Пусть <math>t(n)</math> - число флопов, которое потребуется при обработке матрицы размера <math> n *
n</math> процедурой ''dc_eig''. В таком случае

<math> t(n) = 2t(n/2) </math> два рекурсивных обращения к ''dc_eig''<math>(T_{i},Q_{i},\Lambda_{i})</math>
<math> +O(n^{2})</math> вычисление собственных значений матрицы <math>D+\rho uu^{T}</math>
<math> +O(n^{2})</math> вычисление собственных векторов матрицы <math>D+\rho uu^{T}</math>
<math> +c*n^{3}</math> вычисление матрицы <math>Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}*Q^{'}</math>

Если <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>

На практике константа <math>c</math> обычно оказывается гораздо меньше 1, так как матрица <math>Q^{'}</math> весьма разрежена вследствие явления, которое называется дефляцией, и которое было описано выше.

== Информационный граф ==
На рисунке 3 изображена структура алгоритма.

[[File:Sergeev_5.png|thumb|center|left|1000px|Рис. 3. Дерево алгоритма "Разделяй и властвуй"]]

Операции:

<math>D</math> - операция Divide разделения матрицы <math> T </math> на матрицы <math>T_{1}</math> и <math>T_{2}</math>

Индексы - размерность

<math>S_{k}</math> - операция Conquer сбора матрицы <math> D </math>

<math> L_{k} </math> - операция поиска собственных значений

<math> S^{'} </math> - операция поиска собственных векторов матрицы <math> Q^{'} </math>

<math> S </math> - операция поиска собственных векторов матрицы <math> Q </math>

== Ресурс параллелизма алгоритма ==
В структуре алгоритма имеем два параллельных блока - вызов рекурсивных функций ''dc_eig'' для вычисления собственных значений и векторов матриц <math>T_{1}</math> и <math>T_{2}</math> - это единственная часть алгоритма, в которой возможно использовать параллелизм.

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

- В вершине дерева все процессы взаимодействуют.

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

- В листьях деревьев каждый процесс занимается вычислением независимо.

В случае реализации без параллелизма, функции ''dc_eig'' отрабатывают последовательно - сначала со входными параметрами <math>T_{1}, Q_{1}, \Lambda_{1}</math>, затем - <math>T_{2}, Q_{2}, \Lambda_{2}</math>.

Таким образом, благодаря параллелизму высота алгоритма параллельного составляет <math>log_{2}(n)</math>, тогда как при последовательной реализации высота алгоритма равна сумме геометрической прогрессии <math>1+2+4+8+...+2^{n-1} = 2^{n} - 1</math>, что значительно сокращает число итераций алгоритма.

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

При размерности матрицы больше 3 параллельная реализация позволяет сократить количество этапов работы алгоритма больше, чем в два раза.

== Входные и выходные данные алгоритма ==
'''Входные данные''': трёхдиагональная симметрическая матрица, описанная в разделе [[#Математическое описание алгоритма]].

<math>
L = \begin{bmatrix}
a_{1} & b_{1}&&&&& \\
b_{1} & \ddots & \ddots \\
& \ddots & a_{m-1} & b_{m-1} \\
&& b_{m-1} & a_{m} & b_{m} \\
&&& b_{m} & a_{m+1} & b_{m+1} \\
&&&& b_{m+1} & \ddots \\
&&&&&& \ddots & b_{n-1} \\
&&&&&& b_{n-1} & a_{n} \\
\end{bmatrix}
</math>

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

'''Выходные данные''': Вектор собственных значений длины <math> n </math> и <math> n </math> собственных векторов длины <math> n </math> , соответствующих собственным значениям исходной матрицы.

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

== Свойства алгоритма ==
Данный алгоритм является самым быстрым алгоритмом среди существующих: Разделяй и властвуй, QR, Бисекция и обратная итерация.

'''Последовательная сложность данного алгоритма:''' <math> t = c\frac{4}{3}n^{3} </math>

Она удовлетворяет соотношению <math>t(n) = n^3 +2t(\frac{n}{2})</math>

'''Параллельная сложность алгоритма (за счет дефляции):''' <math> O(n^{2.3})</math>; в крайне редких случаях: <math> O(n^{2}) </math>.

'''Особенности алгоритма:'''

1. Дефляция ([[#Дефляция]])

2. Адаптированный метод Ньютона ([[#Макроструктура алгоритма]])

= Программная реализация алгоритма =
Вторая часть описания алгоритмов в рамках AlgoWiki рассматривает все составные части процесса их реализации. Рассматривается как последовательная реализация алгоритма, так и параллельная. Описывается взаимосвязь свойств программ, реализующих алгоритм, и особенностей архитектуры компьютера, на которой они выполняются. Исследуется работа с памятью, локальность данных и вычислений, описывается масштабируемость и эффективность параллельных программ, производительность компьютеров, достигаемая на данной программе. Обсуждаются особенности реализации для разных классов архитектур компьютеров, приводятся ссылки на реализации в существующих библиотеках.

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

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

== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
Тестирование реализации алгоритма проводилось на суперкомпьютере "Ломоносов" с использованием 1, 2, 4, 8, 16 процессоров на матрицах размера от 4 до 4096. Реализация произведена на библиотеке OpenMP.

Общая эффективность программы увеличивается при увеличении числа процессоров (за счет сокращения времени работы программы) и уменьшается при увеличении размера матрицы (за счет увеличения времени обработки входных данных). При одновременном увеличении числа процессоров и размерности матрицы общая эффективность падает.

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

[[File:DivAndConq11.png|thumb|center|left|1000px|Рис. 4. Зависимость времени работы от размера матрицы]]

Параметры компиляции и запуска:

ssh compiler
module add slurm
module add openmpi/1.5.5-icc
g++ _scratch/DivideAndConquer.c++ -fopenmp -std=c++0x -o DC
sbatch -p test -n1 run ./DC

Код реализации: https://drive.google.com/open?id=0B0G2UV7cuLwHQk9xd1lyeDNJOXc

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

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

== Существующие реализации алгоритма ==
Единственный найденный пример реализации описан в [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).

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

[1] Дж. Деммель, «Вычислительная линейная алгебра» //С. 230-235

[2] [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]

[3] [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]

[4] [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]

[5] [https://en.wikipedia.org/wiki/Divide-and-conquer_eigenvalue_algorithm Алгоритм "Разделяй и властвуй" - Wikipedia]

[[en:Description of algorithm properties and structure]]

Участник:Timokhinivan/Быстрое преобразование Фурье

2016-12-26T07:59:33Z

IgorS:

{{algorithm
| name = Быстрое преобразование Фурье
| serial_complexity = <math>O(N \log N)</math>
| pf_height = <math>O(\log N)</math>
| pf_width = <math>O(N)</math>
| input_data = <math>N</math>
| output_data = <math>N</math>
}}

Автор описания: [[U:Timokhinivan|Тимохин И.В.]], ВМК МГУ.

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

=== Общее описание алгоритма ===
В общем случае многомерное преобразование Фурье соответствует умножению на матрицу преобразования по каждой из координат, что для массива данных <math>N_1\times N_2 \times \cdots \times N_m</math> означает выполнение <math>\sum_{i=1}^m \prod_{k\neq i} N_k</math> одномерных преобразований. Ключевым наблюдением, приводящим к быстрому алгоримту для вычисления преобразования, является возможность свести (с некоторыми оговорками) одномерное преобразование к двумерному, которое для <math>N = mn</math> требует <math>m + n</math> рекурсивных вызовов, что, при применении такого метода на всех уровнях рекурсии, даёт общую сложность алгоритма <math>O(N \log N)</math>.

=== Математическое описание алгоритма ===
Преобразование Фурье задаётся следующей формулой:
:<math>
Y_k = \sum_{l = 0}^{N-1} X_l \epsilon^{kl}_N,\qquad k = \overline{0,N-1}
</math>
где <math>\epsilon_N = e^{-\frac{2i\pi}{N}}</math> — первообразный корень
из 1 степени <math>N</math> (т.е. <math>\epsilon_N</math> является корнем из 1 степени <math>N</math>, но не является корнем никакой меньшей степени). Число <math>N</math> при этом называется порядком преобразования.

Таким образом, преобразование Фурье является линейным и задаётся
матрицей <math>F = \left\{ \epsilon^{kl}_N \right\}_{k,l = 0}^{N-1}</math>.

==== Многомерное преобразование Фурье ====
Естественным обобщением описанного одномерного преобразования Фурье является многомерный вариант:
:<math>
Y(l_1,\ldots,l_d) = \sum_{k_1 = 0}^{N_1-1} \cdots \sum_{k_d = 0}^{N_d-1} X(k_1,\ldots,k_d) \prod_{j=1}^{d} \epsilon_{N_j}^{l_j k_j}
</math>

Многомерное преобразование Фурье эквивалентно последовательному выполнению одномерных преобразований по каждому измерению; при использовании для этого рекурсивного алгоритма, общая сложность вычислений также составляет <math>O(N\log N)</math>, <math>N = \prod_{j=1}^d N_j</math>.

==== Сведение к (почти) двумерному преобразованию (алгоритм Кули-Тьюки) ====

Если <math>N</math> — составное, т.е. <math>N = mn</math>, то возможно
существенно сократить вычислительные расходы за счёт сведения к
двумерному преобразованию Фурье. А именно, положим <math>X(l_1, l_2)
= X_{l_1 n + l_2}</math>, <math> Y(k_1, k_2) = Y_{k_1 m + k_2}</math>,
где <math>l_1, k_2 = \overline{0, m-1}</math>, <math>l_2, k_1 =
\overline{0, n-1}</math>.

В этом случае<ref name="bachv">Н.С. Бахвалов, Н.П. Жидков, Г.М. Кобельков, ''Численные методы'', 2003 г., ISBN: 5-94774-060-5</ref>
:<math>
\begin{align}
Y(k_1, k_2) &=& \sum_{l_2=0}^{n-1} (\epsilon^{k_2 l_2}_N \hat{X}(k_2, l_2)) \epsilon^{k_1 l_2}_n \\
\hat{X}(k_2, l_2) &=& \sum_{l_1=0}^{m-1} X(l_1, l_2) \epsilon^{k_2 l_1}_m
\end{align}
</math>

Это даёт следующий алгоритм вычисления преобразования:

# Записываем исходный вектор в матрицу <math>m\times n</math> по строкам.
# Применяем к каждому столбцу преобразование Фурье.
# Умножаем элемент в позиции <math>(i,j)</math> на <math>\epsilon^{ij}_N</math>.
# Применяем к каждой строке преобразование Фурье.
# Результат записан в получившейся матрице по столбцам.

Данный алгоритм уже даёт существенный выигрыш по сравнению с обычным
умножением матрицы на вектор: <math> O(m^2 n + n^2 m) </math> против
<math>O(m^2 n^2)</math>. Однако наилучших результатов можно добиться,
если применять этот алгоритм рекурсивно на этапах 2 и 4.

Так, если <math>N = \prod_{i=1}^{K} p_i</math>, то целесообразно
на каждом уровне рекурсии «отщеплять» одно <math>p_i</math> (уровней рекурсии при этом будет <math>K \sim \log N</math>). В этом
случае задача сводится к вычислению <math> \prod_{i\neq j} p_i </math>
преобразований Фурье порядка <math>p_j</math> для всех
<math>j</math>. При небольших <math>p_i</math> (например, 2), это
можно проделывать «в лоб».

==== Преобразование Фурье с большим простым порядком (алгоритм Радера) ====

В случае, если порядок преобразования простой, но ещё слишком большой, чтобы вычислять его непосредственно, задача усложняется. Алгоритм в этом случае такой:

# <math> Y_0 = \sum_{l=0}^{N-1} X_l</math> вычисляется непосредственно.
# Любым способом вычисляется <math>g</math> — первообразный корень мультипликативной группы поля <math>\mathbb{Z}_{N}</math>.
# <math> Y_{g^{N-p} \bmod N} = X_0 + \sum_{q=0}^{N-2} X_{g^q \bmod N} \epsilon_N^{g^{q-p}\bmod N} </math>.

Последнее выражение представляет собой свёртку и вычисляется с помощью всё того же преобразования Фурье. В принципе, это можно проделывать непосредственно, поскольку порядок свёртки <math>N - 1</math> уже составной (по меньшей мере чётный), но, поскольку свёртка, в отличие от самого преобразования Фурье, допускает увеличение порядка, имеет смысл воспользоваться этим и выбрать порядок с небольшими простыми множителями.

Таким образом, поскольку при правильной реализации подавляющее большинство рекурсивных вызовов будет использовать алгоритм Кули-Тьюки, в дальнейшем будет рассматриваться именно он.

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

На каждом уровне рекурсии наиболее дорогостоящими этапами являются
рекурсивные вызовы преобразования Фурье: они требуют в сумме
<math>O(mn (\log m + \log n))</math> операций против
<math>O(mn)</math> для умножения на поправочные коэффициенты (шаг 3).

То же верно и для алгоритма в целом в случае <math>N = \prod_{i=1}^{K} p_i</math>;
а именно, суммарно наибольшие вычислительные затраты связаны с
вычислением преобразований Фурье порядка <math>p_i</math>.

=== Макроструктура алгоритма ===
Фактически, макроструктура алгоритма уже описана в разделе
математического описания. На каждом уровне рекурсии, алгоритм состоит
из

# <math>n</math> рекурсивных вызовов алгоритма.
# Умножение всех элементов рабочего вектора на поправочные коэффициенты.
# Ещё <math>m</math> рекурсивных вызовов.

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

Псевдокод (для метода Кули-Тьюки):
<nowiki>fft(X, N)
begin
(m, n) = factor(N)

if (n == 1) // Предполагается, что n <= m
direct_fft(X, N) // Через умножение на матрицу

// 1
transpose(X, m, n) //Транспонирует X как матрицу m x n, хранящуюся по строкам

// 2
do i = 0, n - 1
fft(X(i * m : (i + 1) * m - 1), m)

// 3
do i = 0, n - 1
do j = 0, m - 1
X(i * m + j) *= eps(i * j, N)

// 4
transpose(X, n, m)

// 5
do j = 0, m - 1
fft(X(j * n : (j + 1) * n - 1), n)

// 6
transpose(X, m, n)
end</nowiki>

Здесь <code>eps</code> может как вычислять соответствующие коэффициенты, так и брать их из заранее заготовленной таблицы. Последний способ требует увеличения затрат по памяти, но позволяет существенно сэкономить на вычислениях, а потому является предпочтительным.

Кроме того, шаги 3 и 4 можно переставлять произвольным образом (с очевидными изменениями в шаге 3).

Особо следует отметить, что если порядок элементов в выходном массиве не важен, шаг 6 можно пропустить.

Так, например, если преобразование Фурье используется для вычисления свёртки векторов, то конкретный порядок элементов в их образах Фурье совершенно не важен, лишь бы он был одинаков для обоих векторов. В этом случае в прямом преобразовании можно опустить шаг 6, а в обратном — 1.

Если необходимо учитывать случай большого простого <math>N</math> (что может и не требоваться, в зависимости от задачи), то в первом условном операторе следует дополнительно проверить величину <math>N</math> и, если <math>N</math> большое, переключиться на алгоритм Радера.

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

Непосредственно из описания алгоритма получаем, что если сложность
вычисления преобразования Фурье обозначить <math>f_N</math>, то
<math>f_{mn} = n f_{m} + m f_{n} + mn</math>.

Если <math>N = \prod_{i=1}^K p_i</math>, и на каждом шаге
«отщеплять» от него одно <math>p_i</math>, а преобразование Фурье для
<math>p_i</math> вычислять «в лоб», то общее количество операций
составит <math>O\left(N\sum_{i=1}^K p_i\right)</math>.

В частности, если <math>p_i \leq P</math>, то <math>K \leq \log_P N</math>
и для сложности получаем <math>O(NP\log_P N)</math>. Полагая
<math>P</math> фиксированным, получаем заявленную сложность <math>O(N \log N)</math>.

=== Информационный граф ===
[[Файл:FourierRecursiveGraph.svg|center|thumb|600px|'''Рисунок 1.''' Информационный граф алгоритма Кули-Тьюки для <math>N = 15</math>. Исходные данные обозначены фиолетовым, результат — красным. Преобразования Фурье для <math>m = 5</math> и <math>n = 3</math> представлены как «чёрные ящики». Умножение на поворотные коэффициенты представлено оранжевыми узлами.]]

Каждый уровень рекурсивного вызова состоит из трёх этапов: рекурсивный вызов по столбцам, умножение на поправочные коэффициенты и рекурсивного вызова по строкам. Таким образом для высоты ЯПФ имеем
:<math>
h(mn) = 1 + h(m) + h(n)
</math>

Для «элементарных» БПФ высота ЯПФ будет та же, что и для [[Умножение плотной матрицы на вектор|умножения матрицы на вектор]].

Таким образом, с учётом разложения <math>N</math>, <math>h(N) = O\left(\sum_{i=1}^K p_i\right) = O(P \log_P N) = O(\log N)</math>.

=== Ресурс параллелизма алгоритма ===
Поскольку все рекурсивные вызовы преобразования Фурье на каждом из этапов совершенно
независимы, кажется естественным распределить их по доступным
вычислительным узлам. Умножение на поворотные коэффициенты при этом и вовсе выполняется независимо
на каждом элементе рабочего вектора, и может быть беспрепятственно
присоединёно к любому из этапов.

При этом, в отличие от традиционной реализации, в которой на каждом этапе один из множителей берётся
малым, при параллельной реализации целесообразно взять и
<math>m</math> и <math>n</math> по возможности близкими к кратным
доступному количеству вычислительных узлов, поскольку в этом случае
возможно равномерно распределить работу между ними и реализовать весь
алгоритм всего с одной внутренней пересылкой.

=== Входные и выходные данные алгоритма ===
В общем случае на входе и на выходе имеются комплексные векторы
порядка <math>N</math>. Однако в частных случаях, возможны более компактные представления для параметров и результатов.

Для описания этих случаев нам понадобится матрица
:<math>
Q = \begin{bmatrix}
1 & & & & & \\
& & & & & 1 \\
& & & & 1 & \\
& & & \cdots & & \\
& & 1 & & & \\
& 1 & & & &
\end{bmatrix}
</math>

# Если <math>X</math> — вещественный, то <math>Y = Q\bar{Y}</math>.
# Если <math>X</math> — чисто мнимый, то <math>Y = -Q\bar{Y}</math>.
# Если <math>X = Q\bar{X}</math>, то <math>Y</math> — вещественный.
# Если <math>X = -Q\bar{X}</math>, то <math>Y</math> — чисто мнимый.

В каждом случае, <math>X</math> и <math>Y</math> требуют для своего хранения в два раза меньше памяти, чем в общем случае.

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

=== Свойства алгоритма ===
Обозначая матрицу преобразования <math>F</math>, имеем<ref name="voevodtyrt">В.В. Воеводин, Е.Е. Тыртышников, ''Вычислительные процессы с теплицевыми матрицами'', Москва, «Наука», 1987 г.</ref>:

# <math>F = F^T</math>
# <math>F^{-1} = \tfrac{1}{N} F^*</math>
# <math>F^* = QF </math>

Свойство 2 представляет особый интерес, поскольку позволяет вычислять обратное преобразование Фурье по тем же алгоритмам, что и прямое, поскольку <math>F^*</math> представляет собой матрицу того же вида, что и <math>F</math>, но с <math>\bar{\epsilon}</math> вместо <math>\epsilon</math>. В сущности, свойство 3 позволяет свести задачу к исходной непосредственно, но ценой дополнительных пересылок.

Кроме того, из второго свойства следует
:<math>
\|F x\|_2 = \sqrt{N} \|x\|_2
</math>
что свидетельствует о численной устойчивости алгоритма.

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

При реализации последовательной версии алгоритма (а равно и параллельной, поскольку на определённом уровне рекурсии алгоритм всё равно будет выполняться на каждом узле независимо) стоит иметь ввиду несколько вещей:

==== Поворотные коэффициенты ====

Как уже упоминалось, поворотные коэффициенты имеет смысл вычислить заранее и хранить в специальном массиве. Отдельное внимание при этом стоит обратить на передачу этого массива в рекурсивные вызовы.

В самом деле, поскольку <math>\epsilon^{l}_{n} = \epsilon^{lm}_{mn} = \epsilon^{lm}_{N}</math>, все необходимые рекурсивному вызову значения поворотных коэффициентов уже имеются в используемом в текущем вызове массиве, а потому его достаточно подготовить один раз на весь алгоритм.

==== Нерекурсивный случай ====

На нижнем уровне рекурсии преобразование Фурье вычисляется путём умножения на матрицу. Поскольку этот алгоритм, вообще говоря, более пригоден для векторизации, чем рекурсивная реализация, имеет смысл не разбивать <math>N</math> на ''совсем'' мелкие множители (<math>p_i \equiv 2</math> в алгоритме Кули-Тьюки) а останавливаться на преобразованиях несколько большего порядка; конкретный уровень зависит от конкретной реализации и архитектуры и должен быть установлен экспериментально.

==== Пересылки ====

Теоретически, возможна реализация алгоритма совсем без пересылок, если предполагать, что алгоритм оперирует «разреженным» вектором, элементы которого расположены с некоторым шагом по памяти. Однако ценой такой экономии будет существенно худшая локальность обращений к данным в рекурсивных вызовах. По-видимому, выбор нужно опять-таки осуществлять экспериментально.

Эти соображения в равной степени относятся как к рабочему массиву, так и к массиву поворотных коэффициентов.

==== Предварительные вычисления ====

''Многие'' используемые в алгоритме данные зависят только от порядка преобразования — массив поворотных коэффициентов, факторизация <math>N</math>, <math>g</math> в алгоритме Радера, конкретная задаваемая им перестановка и оптимальный порядок свёртки там же. Вычисление некоторых из них сопоставимо по сложности со всем остальным алгоритмом. Имея это ввиду, если планируется вычисление нескольких преобразований Фурье одного порядка, имеет смысл подготовить все эти данные заранее.

==== Численная устойчивость ====

Поскольку все преобразования в алгоритме являются, с точностью до константы <math>\leq \sqrt{N}</math>, унитарными, катастрофического роста ошибок округления не предвидится, а потому все вычисления возможно проводить с целевой точностью.

=== Локальность данных и вычислений ===
[[Файл:IT_FFTMemaccess.png|center|thumb|800px|Рисунок 2. Профиль обращений в память простого алгоритма Кули-Тьюки с <math>p = (2, 2, 3, 5, 2)</math>. Сверху вниз: вспомогательная память для прямого умножения матрицы на вектор, память для хранения поворотных коэффициентов, рабочий вектор. Реализация не использует транспонирования векторов в явном виде.]]

Как видно, алгоритм в целом обладает невысокой локальностью, что связано с его структурой (множество рекурсивных шагов, каждый из которых охватывает существенную часть рабочего вектора) и организацией доступа к поворотным коэффициентам. Некоторого улучшения локальности можно добиться, если транспонировать рабочую «матрицу» в памяти, но это либо требует дополнительной памяти, либо, если транспонировать «на месте», существенно усложняет алгоритм.

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

В случае составного <math>N</math> с ''достаточно'' большими делителями, наиболее очевидным и простым вариантом является распределение по процессорам рекурсивных вызовов алгоритма Кули-Тьюки. В этом случае на весь алгоритм приходится только три пересылки, но зато они проходят по схеме «все-со-всеми» (транспонирование матрицы) и не могут выполняться параллельно с вычислениями.

Отдельно заметим, что, как уже упоминалось, первой либо последней группы пересылок можно избежать, если порядок элементов результата не важен.

Если <math>N</math> простое либо один из множителей в <math>N = mn</math> всегда мал, ситуация усложняется. В этом случае придётся применять алгоритм Радера на межпроцессорном уровне, что связано с более сложной схемой пересылок и большим их количеством (т.к. приходится осуществлять преобразование Фурье дважды: прямое и обратное).

В связи с этим, некоторые существующие реализации (например, Intel® MKL) просто не поддерживают этот случай. Впрочем, некоторые реализации не поддерживают большие простые делители ''вовсе''.

=== Масштабируемость алгоритма и его реализации ===
Хотя, как уже было указано, алгоритм поддаётся реализации с относительно небольшим числом пересылок, следует отметить, что вычислительна нагрузка на отдельные вычислительные ядра невелика и сопоставима с объёмом пересылок. При этом сами пересылки достаточно объёмны (весь рабочий вектор), нелокальны (все-со-всеми), и не могут проводиться одновременно с вычислениями. По этим причинам, ожидать от алгоритма хорошей масштабируемости не приходится, несмотря на «хорошие» свойства информационного графа. Это и подтверждается экспериментом:

[[Файл:TIFFTEfficiency.png|center|thumb|800px|Рисунок 3. Эффективность распараллеливания быстрого преобразования Фурье, выраженная как отношение времени работы на одном процессоре к произведению времени работы на <math>n</math> процессорах на <math>n</math>. <math>N</math> — порядок преобразования.]]

При этом, однако, умеренного ускорения всё же удаётся добиться:
[[Файл:TIFFTSpeedup.png|center|thumb|800px|Рисунок 4. Ускорение, получаемое при распараллеливании преобразования Фурье. Обозначения те же, что и на рис. 3]]

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

При измерениях использовалась реализация алгоритма, имеющаяся в библиотеке Intel® MKL, расчёты проводились на суперкомпьютере «Ломоносов». Код доступен [https://bitbucket.org/timokhin_ivan/fft/src здесь].

=== Динамические характеристики и особенности реализации алгоритма ===
Как уже отмечалось выше, алгоритм существенно нелокален и плохо поддаётся распараллеливанию, а также обладает достаточно сложной структурой (почти весь состоит из рекурсивных вызовов). В связи с этими обстоятельствами, рассчитывать на эффективное использование системных ресурсов не приходится.

=== Выводы для классов архитектур ===
Как уже было указано, эффективность параллельной реализации крайне низкая, что связано с заложенными с саму структуру алгоритма глобальными пересылками, так что существенно повлиять на эту ситуацию без кардинальных изменений в алгоритме не представляется возможным. При работе на системе с распределённой памятью лучше всего по возможности избегать параллельного преобразования Фурье вовсе, используя по возможности параллелизм в других частях задачи.

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

Алгоритм быстрого преобразования Фурье относится к базовым алгоритмам вычислительной математики, а потому его реализации существуют во многих библиотеках. Перечислим некоторые из них:

* [//software.intel.com/en-us/intel-mkl Intel® Math Kernel Library] — содержит в том числе и версию для распределённых систем. Имеет интерфейсы для C, C++ и Fortran.
* [http://www.fftw.org FFTW] — содержит распределённую реализацию начиная с версии 3.3. Имеет интерфейсы для C и Fortran.
* [//www.gnu.org/software/gsl GNU Scientific Library] — имеет интерфейс для C.
* [//developer.nvidia.com/cufft cuFFT] — реализация алгоритма для GPU от NVIDIA.
* [http://gpuopen.com/compute-product/clfft clFFT] — реализация алгоритма на OpenCL для CPU и GPU. Поддерживает только <math>N = 2^p 3^q 5^r 7^s</math>
* [http://www.ibm.com/systems/power/software/essl IBM® Engineering and Scientific Subroutine Library] — для процессоров IBM® POWER™, имеет интерфейсы для C, C++ и Fortran, существует версия для многопроцессорных систем.

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

Участник:Timokhinivan/Быстрое преобразование Фурье

2016-12-05T07:21:38Z

IgorS:

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

2016-11-29T08:01:54Z

IgorS:

== Замечания к статье ==

* п.п. 2.4-2.6 не соответствуют содержанию описания алгоритма--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 15:10, 25 октября 2016 (MSK)
* не указаны авторы статьи и их вклад--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 15:10, 25 октября 2016 (MSK)
** Автор один, я (Тимохин Иван, 603 гр. ВМК МГУ) --[[Участник:Timokhinivan|Timokhinivan]] ([[Обсуждение участника:Timokhinivan|обсуждение]]) 14:50, 27 октября 2016 (MSK)
*** Так укажите себя, чтобы не было таких вопросов--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:41, 31 октября 2016 (MSK).
* в п.п. 2.4 следует добавить исходный код программы и описание компьютерной платформы, с подробным описанием условий, в которых производились эксперименты.--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:37, 18 ноября 2016 (MSK)
*Подробнее опишите компьютерную платформу и условия, в которых производились эксперименты: (какой компилятор, с какими опциями использовался, какие версии библиотек, на каких узлах проводился запуск и т.д.)--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 11:01, 29 ноября 2016 (MSK)
** Исходный код нужен даже если это просто вызов библиотечной функции? --[[Участник:Timokhinivan|Timokhinivan]] ([[Обсуждение участника:Timokhinivan|обсуждение]]) 23:55, 18 ноября 2016 (MSK)
*** да.--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 12:30, 21 ноября 2016 (MSK)

== Замечания к статье "Быстрое преобразование Фурье" ==

* В общем описании алгоритма нужны слова именно про алгоритм: следует рассказать идею быстрого преобразования, с минимумом формул [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:46, 11 ноября 2016 (MSK)
* Не вполне понятны слова "первообразный корень из 1 степени N" [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:46, 11 ноября 2016 (MSK)
* В последней формуле раздела 1.2 индексы k и l, кажется, должны идти через запятую. Если там рассматривается их произведение, следует уточнить, какие значения принимает каждый из них [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:46, 11 ноября 2016 (MSK)
* Раздел 1.2.3 - понятие "порядок преобразования" нуждается в пояснении [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:46, 11 ноября 2016 (MSK)
* Не хватает слов о глубине рекурсии [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:46, 11 ноября 2016 (MSK)

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

2016-11-29T08:01:18Z

IgorS:

== Замечания к статье ==

* п.п. 2.4-2.6 не соответствуют содержанию описания алгоритма--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 15:10, 25 октября 2016 (MSK)
* не указаны авторы статьи и их вклад--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 15:10, 25 октября 2016 (MSK)
** Автор один, я (Тимохин Иван, 603 гр. ВМК МГУ) --[[Участник:Timokhinivan|Timokhinivan]] ([[Обсуждение участника:Timokhinivan|обсуждение]]) 14:50, 27 октября 2016 (MSK)
*** Так укажите себя, чтобы не было таких вопросов--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:41, 31 октября 2016 (MSK).
* в п.п. 2.4 следует добавить исходный код программы и описание компьютерной платформы, с подробным описанием условий, в которых производились эксперименты.--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:37, 18 ноября 2016 (MSK)
**Подробнее опишите компьютерную платформу и условия, в которых производились эксперименты: (какой компилятор, с какими опциями использовался, какие версии библиотек, на каких узлах проводился запуск и т.д.)--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 11:01, 29 ноября 2016 (MSK)
** Исходный код нужен даже если это просто вызов библиотечной функции? --[[Участник:Timokhinivan|Timokhinivan]] ([[Обсуждение участника:Timokhinivan|обсуждение]]) 23:55, 18 ноября 2016 (MSK)
*** да.--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 12:30, 21 ноября 2016 (MSK)

== Замечания к статье "Быстрое преобразование Фурье" ==

* В общем описании алгоритма нужны слова именно про алгоритм: следует рассказать идею быстрого преобразования, с минимумом формул [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:46, 11 ноября 2016 (MSK)
* Не вполне понятны слова "первообразный корень из 1 степени N" [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:46, 11 ноября 2016 (MSK)
* В последней формуле раздела 1.2 индексы k и l, кажется, должны идти через запятую. Если там рассматривается их произведение, следует уточнить, какие значения принимает каждый из них [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:46, 11 ноября 2016 (MSK)
* Раздел 1.2.3 - понятие "порядок преобразования" нуждается в пояснении [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:46, 11 ноября 2016 (MSK)
* Не хватает слов о глубине рекурсии [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:46, 11 ноября 2016 (MSK)

Участник:Ivanov.kir.m/Быстрое дискретное преобразование Фурье

2016-11-22T13:03:18Z

IgorS:

{{Assignment|IgorS}}

{{algorithm
| name = Алгоритм одномерного преобразования Фурье для действительных чисел
| serial_complexity = <math>O (N \log N)</math>
| pf_height = <math>O (\log N)</math>
| pf_width = <math>N</math>
| input_data = <math>N</math> действительных чисел
| output_data = <math>\lfloor N/2 \rfloor+1</math> комплексных чисел
}}
Авторы описания [[Участник:Ivanov.kir.m | К.М.Иванов]], [[Участник:Pumpkin | А.C.Сапин]] Вклад каждого участника равномерный, поскольку каждый пункт вычитывался и исправлялся обоими участниками. При сильном приближении можно сказать,что больший вклад [[Участник:Ivanov.kir.m | К.М.Иванов]] внес в заполнение теоретической части, а [[Участник:Pumpkin | А.C.Сапин]] в заполнение практической части.

'''Быстрое преобразование Фурье (БПФ, FFT)''' — алгоритм быстрого вычисления дискретного преобразования Фурье (ДПФ). То есть, алгоритм вычисления за количество действий, меньшее чем <math>O(N^{2})</math>, требуемых для прямого (по формуле) вычисления ДПФ. Иногда под БПФ понимается один из быстрых алгоритмов, называемый алгоритмом прореживания по частоте/времени или алгоритмом по основанию 2, имеющий сложность <math>O(N\log(N))</math>. Cуществует несколько различных алгоритмов для вычисления ДПФ считающимся быстрым преобразование Фурье:
* Алгоритм Кули-Тьюки [https://en.wikipedia.org/wiki/Cooley%E2%80%93Tukey_FFT_algorithm]
* Алгоритм Гуда-Томаса [https://en.wikipedia.org/wiki/Prime-factor_FFT_algorithm]
* Алгоритм Бруна [https://en.wikipedia.org/wiki/Bruun%27s_FFT_algorithm]
* Алгоритм Блюштейна [https://en.wikipedia.org/wiki/Chirp_Z-transform#Bluestein.27s_algorithm]
= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==
'''Быстрое дискретное преобразование Фурье''' (''БПФ'') - популярный в современном мире математический метод преобразования вектора/матрицы комплексных/действительных чисел — ''сигнала'' — в вектор/матрицу комплексных чисел — ''спектр''. С математической точки зрения преобразование сигнала <math>s</math> (как функции по времени <math>t</math>) в спектр <math>\hat{s}</math> описывается формулой
:<math>
\hat{s}(\omega)=\frac{1}{\sqrt{2\pi}}\int\limits_{-\infty}^{\infty}s(t)e^{-it\omega}\,dt
</math>

В отличие от своего классического аналога, БПФ имеет сложность <math>O(N\log{N})</math>, а не <math>O(N^2)</math>, это достигается благодаря разделению исходного вектора на несколько частей так, чтобы, применив к этим частям БПФ и объединив результаты путем умножения на поворотные множители и дополнительного БПФ, можно было получить преобразование Фурье исходного вектора — принцип «разделяй и властвуй».

Область применения данного метода простирается от обработки аудио информации до собственно спектрального анализа.
Поскольку в общем случае алгоритм БПФ применим к произвольным векторам чисел, выделяют отдельные подзадачи, для которых можно ввести дополнительную оптимизацию. Одной из таких подзадач является быстрое преобразование Фурье вектора действительных чисел, которому и посвящена данная статья. В качестве тестируемой реализации был выбран алгоритм Кули-Тьюки в библиотеке FFTW, написанной на языке C.

'''Замечание''': Поскольку общие описание алгоритма БПФ весьма сложно, в некоторых пунктах данная статья будет ссылаться на простой случай — алгоритм Кули-Тьюки быстрого преобразование Фурье для векторов ''с размерностью равной степени двойки''. Отличительной особенностью данного алгоритма является то, что он обходится без использования специфических приемов, использующихся именно для степеней четверки, восьмерки и т.п. Однако благодаря тому, что на вход данному алгоритму подается вектор чисто вещественных чисел, выходной вектор удовлетворяет ''эрмитовой избыточности'' (''Hermitian redundancy'') , т.е. <math>out[i]</math> является сопряженным с <math>out[n-i]</math>. Это обстоятельство позволяет достичь роста скорости и снижения затрат памяти примерно в 2 раза по сравнению с ''комплексным'' аналогом алгоритма.

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

Входные данные: вектор действительных чисел <math>x = (x_1,x_2,...,x_N)</math>.

Выходные данные: вектор комплексных чисел <math>X = (X_1,X_2,...,X_N)</math>.

Дискретное преобразование Фурье задается следующей формулой:

<math>X_k = \sum_{n=0}^{N-1} x_n e^{-\frac{2\pi i}{N} nk}, k = \overline{0,N-1}</math>

В простейшем случае(для степеней двойки) алгоритм Кули-Тьюки рассчитывает ДПФ для четных <math>(x_{2m}=x_0, x_2, \ldots, x_{N-2})</math> и нечетных элементов отдельно <math>(x_{2m+1}=x_1, x_3, \ldots, x_{N-1})</math>. Затем результаты рассчетов объединяются для получения ДПФ всей последовательности:

<math>
\begin{matrix} X_k & =
& \sum \limits_{m=0}^{N/2-1} x_{2m}e^{-\frac{2\pi i}{N} (2m)k} + \sum \limits_{m=0}^{N/2-1} x_{2m+1} e^{-\frac{2\pi i}{N} (2m+1)k}
\end{matrix}
</math>

Таким образом, получается рекурсивный алгоритм, работающий по принципу [https://ru.wikipedia.org/wiki/%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_(%D0%B8%D0%BD%D1%84%D0%BE%D1%80%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B0) разделяй и влавствуй].

=== Рекурсивное описание ===
Алгоритм:
# Входной вектор <math>a = (a_0,a_2,...,a_{N-1})</math> преобразуется в матрицу <math>A</math> размера <math>n_1 \times n_2 </math>, где <math>N=n_1 \cdot n_2</math> и <math>n_1 < n_2</math>
<math> A = \begin{pmatrix}
a_0 & a_1 & \cdots & a_{n_1-1} \\
a_{n_1} & a_{n_1+1} & \cdots & a_{2n_1-1} \\
\vdots & \vdots & \ddots & \vdots \\
a_{(n_2-1)\cdot n_1} & a_{(n_2-1)\cdot n_1+1} & \cdots & a_{n_2\cdot n_1-1}
\end{pmatrix} </math>
# К каждой строке полученной матрицы применяется быстрое дискретное преобразование Фурье (БПФ) порядка <math>n_1</math>
# Каждый элемент полученный после применения БПФ умножается на ''поворотные множители'' <math>exp (2 \pi i(m-1)(j-1)/N)</math>, где <math>m</math> - номер строки, а <math>j</math> - номер столбца
# Полученная после шагов 1-2 матрица <math>A</math> транспонируется
# К каждой строке матрицы <math>A^T</math> применяется БПФ порядка <math>n_2</math>

Так как алгоритм реализует принцип «разделяй и властвуй», глубина рекурсии составляет <math>O (\log N)</math> от числа входных элементов.

'''Замечание:''' Как правило все ''поворотные множители'' вычисляются заранее и хранятся в специальном массиве.

'''Замечание:''' В общем случае <math>N</math> разбивается на <math>n_1 \cdot n_2</math> так, чтобы <math>n_1</math> и <math>n_2</math> сами не являлись простыми числами и разлагались на множители, не являющиеся простыми числами.

'''Замечание:''' В случае простого <math>N</math> оно дополняется(как правило единицей) до составного числа. В процессе слияния добавленные значения отбрасываются.

== Вычислительное ядро алгоритма ==
В случае размерности входа равной степени двойки, вычислительным ядром алгоритма является так называемая, "''бабочка''". В простейшем случае "''бабочка''" представляет из себя двухточечное преобразование. Рассмотрим этот случай:

На вход алгоритму подается двухэлементный вектор ‒ <math> v = (v[0], v[1]) </math>. Тогда для вычисления будут происходить по следующим формулам:

<math>V[0] = W_2^0 v[0] + W_2^0 v[1] = v[0] + W_2^0 v[1] </math>

<math>V[1] = W_2^0 v[0] + W_2^1 v[1] = v[0] + W_2^1 v[1] </math>

Данный процесс удобно изобразить с помощью следующей схемы:

[[file:Fftbutterfly.png | Рис. 1. "''Бабочка''" для двумерного входа ]]

Для 4-х элеметного вектора <math>v=(v[0],v[1],v[2],v[3])</math>, алгоритм строится похожим образом. Сначала создаются простейшие "''бабочки''", а потом их результаты соединяются с противоположеной "бабочкой":

<math>V[0]=v[0]+W_2^0 v[2]+W_4^0(v[1]+W_2^0 v[3])</math>

<math>V[1]=v[0]-W_2^0 v[2]+W_4^1(v[1]-W_2^0 v[3])</math>

<math>V[2]=v[0]+W_2^0 v[2]-W_4^0(v[1]+W_2^0 v[3])</math>

<math>V[3]=v[0]-W_2^0 v[2]-W_4^1(v[1]-W_2^0 v[3])</math>

Схема в таком случае будет выглядеть следующим образом:

[[file:Fftbutterfly4.png| Рис. 2. "''Бабочка''" для четырёхмерного входа ]]

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

== Макроструктура алгоритма ==
Для исходного вектора <math>a = (a_1,a_2,...,a_N)</math> размерности <math>N = n_1 \cdot n_2</math>, <math>n_1 < n_2</math> БПФ представляется как:
#<math>n_2</math> БПФ порядка <math>n_1</math>
#<math>n_1 \cdot n_2</math> умножение комплексных чисел
#<math>n_1</math> БПФ порядка <math>n_2</math>

== Схема реализации последовательного алгоритма ==
Схема организации состоит в том, что на каждом шаге <math>i</math> для выполнения "''бабочки''" все элементы разбиваются на <math>n_{i_1}</math> векторов по <math>n_{i_2}</math> элементов, причем <math>n_{i_1} \cdot n_{i_2} = n_i</math>, где <math>n_i</math> длина входного вектора на текущем шаге <math>i</math>. В случае если такое разбиение невозможно, по причине того что <math>n_i</math> простое число, исходный вектор на текущем шаге дополняется элементом. В зависимости от номера шага, разница координат для каждой пары элементов увеличивается соразмерно разбиению <math>(n_{i_1},n_{i_2})</math>.
При этом результат суммы записывается в элемент с меньшим номером, а результат вычитания с последующим умножением - в элемент с большим.

== Последовательная сложность алгоритма ==
Быстрое дискретное преобразование Фурье выполнимо за <math>O(N(n_1+\cdots+n_m))</math> действий при <math>N=n_1n_2\cdots n_m</math> (в простом случае, при <math>N=2^m</math> необходимо <math>O(N\log_2(N))</math> действий). Дискретное преобразование Фурье преобразует вектор <math>a = (a_0, \dots, a_{N-1})</math> в вектор комплексных чисел <math>b = (b_0, \dots, b_{N-1})</math>, такой, что <math>b_i=\sum_{j=0}^{N-1}a_j\varepsilon^{ij}</math>, где <math>\varepsilon^n=1</math> и <math>\varepsilon^k\neq 1</math> при <math>0<k<N</math>.

Основной шаг алгоритма состоит в сведении задачи для <math>N</math> чисел к задаче для <math>n_1=N/n_2</math> числам, где <math>n_2</math> — делитель <math>N</math>.

Пусть мы уже умеем решать задачу для <math>N/n_2</math> чисел. Применим преобразование Фурье к векторам <math>a_i,a_{n_2+i}, \dots, a_{n_2(n_1-1)+i}</math> для <math>i=0,1,\dots,n_2-1</math>. Покажем теперь, что за <math>O(Np)</math> действий можно решить исходную задачу. Заметим, что <math>b_i=\sum_{j=0}^{n_2-1} \varepsilon^{ij} \left(\sum_{k=0}^{n_1-1}a_{kn_2+j}\varepsilon^{kin_2}\right)</math>.
Выражения в скобках нам уже известны — это <math>(i\mod p)</math>-тое число после преобразования Фурье <math>j</math>-го вектора. Таким образом, для вычисления каждого <math>b_i</math> нужно <math>O(n_2)</math> действий, а для вычисления всех <math>b_i</math> всего <math>O(Nn_2)</math> действий, что и требовалось.

В общем случае:

Пусть <math>4N>2^k\ge2N</math>. Заметим, что тогда <math>b_i=\varepsilon^{-i^2/2}\sum_{j=0}^{N-1}\varepsilon^{(i+j)^2/2}\varepsilon^{-j^2/2}a_j</math>. Обозначим <math>\bar{a}_i=\varepsilon^{-i^2/2}a_i</math>, <math>\bar{b}_i=\varepsilon^{i^2/2}b_i</math>, <math>c_i=\varepsilon^{(2N-2-i)^2/2}</math>. Тогда <math>\bar{b}_i=\sum_{j=0}^{2N-2-i}\bar{a}_jc_{2N-2-i-j}</math>, если положить <math>\bar{a}_i=0</math> при <math>i\ge N</math>.

Таким образом задача сведена к вычислению ''свёртки'', а это можно сделать с помощью трёх преобразований Фурье для <math>2^k</math> элементов. Выполняем прямое преобразование Фурье для <math>(\bar{a_0}, \cdots, \bar{a}_{2^k-1})</math> и <math>(c_1,\cdots,c_{2^k-1})</math>, перемножаем поэлементно результаты и выполняем обратное преобразование Фурье.

Вычисления всех <math>\bar{a}_i</math> и <math>c_i</math> требуют <math>O(N)</math> действий, три преобразования Фурье требуют <math>O(N\log(N))</math> действий, перемножение результатов преобразований Фурье требует <math>O(N)</math> действий, вычисление всех <math>b_i</math> зная значения свертки требует <math>O(N)</math> действий. Итого для дискретного преобразования Фурье требуется <math>O(N\log(N))</math> действий для любого <math>N</math>.

== Информационный граф ==
[[Файл:InfoGraph Ivanov Sapin.png |center|thumb|800px| Информационный граф алгоритма Кули-Тьюки для <math>N = 21</math>. Исходные данные обозначены зеленым, результат — синим. Преобразования Фурье для <math>n_1 = 7</math> и <math>n_2 = 3 \text{ } (N = n_1 \cdot n_2)</math> представлены как «чёрные ящики». Умножение на поворотные коэффициенты (множители) представлено коричневыми ромбами.]]
Как видно из рисунка, размер этого графа линейно-логарифмический, а формулы дуг имеют экспоненциальные компоненты.

== Ресурс параллелизма алгоритма ==
Если считать только главные члены выражений, то простой алгоритм Кули-Тьюки имеет критический путь, состоящий из <math>log(N)</math> операций комплексного сложения/вычитания и <math>log(N)</math> операций комплексного умножения (основание <math>log</math> целиком зависит от выбранного на каждом шаге алгоритма разбиения). Здесь стоит отметить, что все рекурсивные вызовы БПФ на каждом шаге выполняются независимо, это приводит к тому, что их можно распределить по доступным вычислительным узлам. Аналогичная ситуация обстоит и с умножением на поворотные множетели, что позволяет независимо присоединять его к любому шагу. Таким образом алгоритм БПФ имеет высокий ресурс параллелизма, а алгоритм БПФ в общем случае может быть отнесён к ''логарифмическому'' классу по параллельной сложности.

Кроме того, параллелизм БПФ можно увеличить, если брать <math>n_1</math> и <math>n_2</math> по возможности близкими к кратным доступному количеству вычислительных узлов (а не брать просто один из множителей близким к нулю, как в традиционной реализации), это позволит равномерно распределить работу между вычислительными узлами, что сильно повысит эффективность алгоритма благодаря лишь одной внутренней пересылке данных.

== Входные и выходные данные алгоритма ==
'''Входные данные:''' вектор действительных/комплексных чисел <math>a = (a_1,a_2,...,a_N)</math>.

'''Выходные данные:''' вектор комплексных чисел <math>b = (b_1,b_2,...,b_{\lfloor N/2 \rfloor+1})</math>.

Есть несколько ситуаций, при которых количество потребляемой памяти для хранения входного вектора <math>a</math> и выходного вектора <math>b</math> тможет быть снижено вдвое:
# Если <math>a</math> — вектор действительных чисел, тогда <math>b = E\bar{b}</math>;
# Если <math>a</math> — вектор чисто-мнимых чисел, тогда <math>b = -E\bar{b}</math>;
# Если <math>a = E\bar{a}</math>, тогда <math>b</math> — вектор действительных чисел;
# Если <math>a = -E\bar{b}</math>, то <math>b</math> — вектор чисто-мнимых чисел.

Где матрица <math>E</math>:
:<math>
E = \begin{bmatrix}
1 & 0 & 0 & \cdots & 0 & 0 \\
0 & 0 & 0 & \cdots & 0 & 1 \\
0 & 0 & 0 & \cdots & 1 & 0 \\
0 & 0 & 0 & \ddots & 0 & 0 \\
0 & 0 & 1 & \cdots & 0 & 0 \\
0 & 1 & 0 & \cdots & 0 & 0
\end{bmatrix}
</math>

== Свойства алгоритма ==
Таким образом в общем у алгоритма БПФ в случае неограниченных ресурсов:
*последовательная сложность - ''линейно-логарифмическая''
*параллельная сложность - ''логарифмическая''.

При этом алгоритм полностью детерминирован.

= ЧАСТЬ. Программная реализация алгоритма =
В качестве тестируемой реализации была выбрана библиотека FFTW, а именно функция, выполняющая БПФ одномерного вектора действительных чисел.
== Особенности последовательной реализации алгоритма ==
Простейший вариант алгоритма для степеней двойки на языке C:
<source lang="C++">
#include <stdio.h>
#include <math.h>
#include <complex.h>

typedef double complex cplx;

void _fft(cplx *buf, cplx *out, int n, int step)
{
if (step < n) {
_fft(out, buf, n, step * 2); //рекурсивный рассчет
_fft(out + step, buf + step, n, step * 2);

for (int i = 0; i < n; i += 2 * step) {
cplx t = cexp(-I * PI * i / n) * out[i + step];
buf[i / 2] = out[i] + t;
buf[(i + n)/2] = out[i] - t;
}
}
}

void fft(cplx *buf, int n)
{
cplx out[n];
for (int i = 0; i < n; i++) out[i] = buf[i];

_fft(buf, out, n, 1);
}
</source>

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

=== Описание платформы IBM Blue Gene/P ===
IBM Blue Gene/P — массивно-параллельная вычислительная система, которая состоит из двух стоек, включающих 8192 процессорных ядер (2 x 1024 четырехъядерных вычислительных узлов), с пиковой производительностью 27,9 терафлопс (27,8528 триллионов операций с плавающей точкой в секунду).

Характеристики системы:

* две стойки с вычислительными узлами и узлами ввода-вывода
* 1024 четырехъядерных вычислительных узла в каждой из стоек
* 16 узлов ввода-вывода в стойке (в текущей конфигурации активны 8, т.е. одна I/O-карта на 128 вычислительных узлов)
* выделенные коммуникационные сети для межпроцессорных обменов и глобальных операций
* программирование с использованием MPI, OpenMP/pthreads, POSIX I/O
* высокая энергоэффективность: ∼ 372 MFlops/W (см. список Green500)
* система воздушного охлаждения

Стойка (rack, cabinet) состоит из двух midplane'ов. В midplane входит 16 node-карт (compute node card), на каждой из которых установлено 32 вычислительных узла (compute card). Midplane, 8 x 8 x 8 = 512 вычислительных узлов, — минимальный раздел, на котором становится доступна топология трехмерного тора; для разделов меньших размеров используется топология трехмерной решетки. Node-карта может содержать до двух узлов ввода-вывода (I/O card). Вычислительный узел включает в себя четырехъядерный процессор, 2 ГБ общей памяти и сетевые интерфейсы.

Микропроцессорное ядро:

* модель: PowerPC 450
* рабочая частота: 850 MHz
* адресация: 32-битная
* кэш инструкций 1-го уровня (L1 instruction): 32 KB
* кэш данных 1-го уровня (L1 data): 32 KB
* кэш предвыборки (L2 prefetch): 14 потоков предварительной выборки (stream prefetching): 14 x 256 байтов
* два блока 64-битной арифметики с плавающей точкой (Floating Point Unit, FPU), каждый из которых может выдавать за один такт результат совмещенной операции умножения-сложения (Fused Multiply-Add, FMA)
* пиковая производительность: 2 FPU x 2 FMA x 850 MHz = 3,4 GFlop/sec per core

Вычислительные узлы и I/O-карты в аппаратном смысле неразличимы и являются взаимозаменяемыми, разница между ними состоит лишь в способе их использования. У них нет локальной файловой системы, поэтому все операции ввода-вывода перенаправляются внешним устройствам.

Вычислительной узел:

* четыре микропроцессорных ядра PowerPC 450 (4-way SMP)
* пиковая производительность: 4 cores x 3,4 GFlop/sec per core = 13,6 GFlop/sec
* пропускная способность памяти: 13,6 GB/sec
* 2 ГБ общей памяти
* 2 x 4 МБ кэш-памяти 2-го уровня (в документации по BG/P носит название L3)
* легковесное ядро (compute node kernel, CNK), представляющее собой Linux-подобную операционную систему, поддерживающую значительное подмножество Linux-совместимых системных вызовов
* асинхронные операции межпроцессорных обменов (выполняются параллельно с вычислениями)
* операции ввода-вывода перенаправляются I/O-картам через сеть коллективных операций

=== Оценка масштабируемости алгоритма ===
Масштабируемость алгоритма проверялась с помощью тестовой программы расположенной по [https://github.com/alesapin/parallel_fftw ссылке]. Для эксперимента использовались:
* Компилятор mpicc
* Библиотека OpenMPI версии 1.68
* Библиотека FFTW 3.3.5
Алгоритм тестировался на входных векторах размера <math>2^{15}</math> до <math>2^{26}</math>. При этом использовались от 8 до 128 процессоров с шагом степени двойки.

[[File:Fftw time good cr.png |center|thumb|800px| Замеры времени работы параллельной реализации FFTW для входного вектора действительных чисел. По оси Data Size указано <math>N</math> -- число входных элементов. По оси Procs Num указано <math>p</math> -- число задействованных процессоров. По оси Elapsed Time -- время затраченное на выполненине алгоритма в секундах.]]

[[File:Fftw efficency good cr.png |center|thumb|800px| Эффективность параллельной реализации FFTW для входного вектора действительных чисел. По оси Data Size указано <math>N</math> -- число входных элементов. По оси Procs Num указано <math>p</math> -- число задействованных процессоров. По оси Effeciency -- эффективность алгоритма в процентах.]]

Из графиков можно сделать следующие выводы:
* Значительное увеличение числа процессоров не дает значимого уменьшения времени исполнения, что отражено и на графике эффективности. Это означает, что время, в основном, расходуется на пересылки данных, а не на рассчет.
* При большом количестве элементов и маленьком числе процессоров наблюдается сверхлинейное ускорение, что связано с маленьким число пересылок и активным использованием кеша.

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [http://www.fftw.org/ FFTW], разработанная Матео Фриго и Стивеном Джонсоном в Массачусетском технологическом институте. Для преобразования небольших объемов данных используется алгоритм [https://en.wikipedia.org/wiki/Cooley%E2%80%93Tukey_FFT_algorithm Кули - Тьюки], в случае входа больших размеров используется алгоритм [https://en.wikipedia.org/wiki/Rader%27s_FFT_algorithm Радера] или [https://en.wikipedia.org/wiki/Chirp_Z-transform#Bluestein.27s_algorithm Блюштейна]. Библиотека считается самой быстрой реализацией БПФ и на входах любых размеров и размерностей сохраняет ассимптотическую сложность <math>O(N\cdot log(N))</math>. Также, существует версия FFTW с поддержкой [http://www.fftw.org/doc/Distributed_002dmemory-FFTW-with-MPI.html#Distributed_002dmemory-FFTW-with-MPI MPI], которая позволяет с объемами данных не умещающимися в память.

FFTW изначально написана на языке C, однако имеет API для нескольких языков, в том числе Fortran и Ada. Открытая версия библиотеки распространяется под лицензией [https://en.wikipedia.org/wiki/GNU_General_Public_License GNU General Public License]. Также существует реализация для коммерческого использования распространяемая под лицензией [https://en.wikipedia.org/wiki/MIT MIT].

Существует несколько реализаций алгоритма, для рассчета на GPU:
* [https://developer.nvidia.com/cufft cuFFT] для рассчета на графических ускорителях от NVIDIA.
* [http://gpuopen.com/compute-product/clfft/ clFFT] для рассчета на GPU и CPU.

= Литература =
[1] Википедия [Электронный ресурс]. Тема: Быстрое преобразование Фурье – Электрон. дан. – URL [https://ru.wikipedia.org/wiki/%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%BE%D0%B5_%D0%BF%D1%80%D0%B5%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%A4%D1%83%D1%80%D1%8C%D0%B5 Быстрое преобразование Фурье] (дата обращения 17.09.2016)

[2] Бахвалов Н. С., Жидков Н. П., Кобельков. Г. М. — 6-е изд. — М. : БИНОМ. Лаборатория знаний, 2008. — 636 с.
[[en:Fast Discrete Fourier Transform]]

[3] FFTW [Электронный ресурс]. Тема: One-Dimensional DFTs of Real Data – Электрон. дан. – URL [http://www.fftw.org/doc/One_002dDimensional-DFTs-of-Real-Data.html#One_002dDimensional-DFTs-of-Real-Data One-Dimensional DFTs of Real Data] (последняя дата обращения 14.19.2016)

[4] FFTW [Электронный ресурс]. – Электрон. дан. – URL [http://www.fftw.org/ FFTW Lib] (последняя дата обращения 14.19.2016)

Участник:Роман Землянский/Zavolskov/Zemlyanskiy

2016-11-22T09:28:32Z

IgorS:

{{Assignment|IgorS}}

'''Метод «разделяй и властвуй» вычисления собственных значений и векторов симметричной трехдиагональной матрицы'''

Авторы статьи:

'''Завольсков Владислав'''

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

[[#Макроструктура алгоритма]]

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

[[#Информационный граф]]

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

'''Землянский Роман'''

[[#Общее описание алгоритма]]

[[#Математическое описание алгоритма]]

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

[[#Ресурс параллелизма алгоритма]]

[[#Входные и выходные данные алгоритма]]

[[#Свойства алгоритма]]

614 группа

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
'''Метод разделяй и властвуй вычисления собственных значений и векторов трёхдиагональной матрицы''' - это наиболее быстрый из существующих методов, если нужны все собственные значения и собственные векторы трехдиагональной матрицы, начиная с порядка n, примерно равного 26. (Точное значение этого порогового порядка зависит от компьютера.) Его численно устойчивая реализация весьма не тривиальна. В самом деле, хотя впервые метод был предложен еще в 1981 г., "правильный" способ его реализации был найден лишь в 1992 г. Этот способ воплощен LAPACK-программами ssyevd (для плотных матриц) и sstevd (для трехдиагональных матриц). В них стратегия "разделяй-и-влавствуй" используется для матриц порядка, большего чем 25. Для матриц меньшего порядка (или если нужны только собственные значения) происходит автоматический переход к QR-итерации.

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

:<math>
L = \begin{bmatrix}
a_{1} & b_{1}&&&&& \\
b_{1} & \ddots & \ddots \\
& \ddots & a_{m-1} & b_{m-1} \\
&& b_{m-1} & a_{m} & b_{m} \\
&&& b_{m} & a_{m+1} & b_{m+1} \\
&&&& b_{m+1} & \ddots \\
&&&&&& \ddots & b_{n-1} \\
&&&&&& b_{n-1} & a_{n} \\
\end{bmatrix}
= \begin{bmatrix}
a_{1} & b_{1} &&&&& \\
b_{1} & \ddots & \ddots \\
& \ddots & a_{m-1} & b_{m-1} \\
&& b_{m-1} & a_{m} - b_{m} \\
&&&& a_{m+1} - b_{m} & b_{m+1} \\
&&&& b_{m+1} & \ddots \\
&&&&&& \ddots & b_{n-1} \\
&&&&&& b_{n-1} & a_{n} \\
\end{bmatrix} +
</math>

<math>
+ \begin{bmatrix}
&&&&& \\
&&b_{m} & b_{m} \\
&&b_{m} & b_{m} \\
&&&&& \\
\end{bmatrix}

= \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}

\equiv \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T}
</math>

Предположим, что нам известны спектральные разложения матриц <math>T_{1}</math> и <math> T_{2} </math>:
<math> T_{i} = Q_{i} \Lambda_{i} Q_{i}^{T} </math>. В действительности, они будут рекурсивно вычисляться тем же самым алгоритмом. Установим связь между собственными значениями матрицы Т и собственными значениями матриц
<math>T_{1}</math> и <math>T_{2}</math>. Имеем:

<math>
T = \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T}
= \begin{bmatrix} Q_{1} \Lambda_{1} Q_{1}^{T} & 0 \\ 0 & Q_{2} \Lambda_{2} Q_{2}^{T}\end{bmatrix} + b_{m}vv^{T}
= \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}
</math>,

где

<math>
u = \begin{bmatrix} Q_{1}^{T} & 0 \\ 0 & Q_{2}^{T}\end{bmatrix}v
</math>

так как <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>.

Следовательно, <math>T</math> имеет те же собственные значения, что и подобная ей матрица <math>D + \rho uu^{T}</math>,
где <math>D = \begin{bmatrix} \Lambda_{1} & 0 \\ 0 & \Lambda_{2}\end{bmatrix}</math> - диагональная матрица,
<math>\rho = b_{m}</math> - число, а <math>u</math> - вектор.

Будем предполагать, не ограничивая общности, что диагональные элементы <math>d_{1}, \ldots, d_{n}</math> матрицы <math>D</math> упорядочены по убыванию: <math>d_{n} <= \ldots <=d_{1}</math>.

Чтобы найти собственные значения матрицы <math>D + \rho uu^{T}</math>, вычислим её характеристический многочлен, считая пока матрицу <math>D - \lambda I</math> невырожденной.
Тогда

<math>det(D + \rho uu^{T} - \lambda I) = det((D - \lambda I)(I + \rho (D- \lambda I)^{-1} uu^{T}))</math>.

Поскольку <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. Определитель такой матрицы легко вычислить.

'''Лемма 1.''' Справедливо равенство <math>det(I + xy^{T}) = 1 + y^{T}x</math>, где <math>x</math> и <math>y</math> - векторы.

Таким образом,

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

т.е. собственные значения матрицы <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>).

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

Можно видеть, что прямая <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> флопов.
Для собственных векторов матрицы <math>D + \rho uu^{T}</math> мы легко можем получить явные выражения.

'''Лемма 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> флопов.

Доказательство.

<math>(D + \rho uu^{T})[(D - \alpha I)^{-1}u] = (D - \alpha I + \alpha I + \rho uu^{T})(D - \alpha I)^{-1}u</math>

<math>=u + \alpha (D - \alpha I)^{-1}u + u[\rho u^{T}(D - \alpha I)^{-1}u] </math>

<math>=u + \alpha(D - \alpha I)^{-1}u - u</math>

поскольку <math> \rho u^{T}(D - \alpha I)^{-1}u + 1 = f(\alpha) = 0 </math>

<math>=\alpha [(D - \alpha I)^{-1}u]</math>, что и требовалось.

Для вычисления по этой простой формуле всех <math>n</math> собственных векторов требуется <math>O(n^{2})</math> флопов. К сожалению, формула не обеспечивает численной устойчивости, так как для двух очень близких значений <math>\alpha_{i}</math> может давать неортогональные приближенные собственные векторы <math>u_{i}</math>. Потребовалось целое десятилетие для того, чтобы найти устойчивую альтернативу исходному описанию алгоритма. Снова детали будут обсуждаться позднее в данном разделе.

Алгоритм является рекурсивным.

=== Дефляция ===

До сих пор полагалось, что все <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> достаточно мало.

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

== Вычислительное ядро алгоритма ==
Вычислительным ядром последовательной схемы решения является вычисление матрицы <math>Q</math> собственных векторов путём умножения матрицы <math>Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}</math> на матрицу <math>Q^{'}</math> Данная операция имеет сложность <math>cn^{3}</math> о чём и говорится в разделе [[#Последовательная сложность алгоритма]] .
Ей предшествует вычисление собственных значений и векторов матрицы <math> D + \rho uu^{T}</math>

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

[[File:DivideAndConquerTree.png|thumb|center|left|800px|Рис. 2. Дерево алгоритма "Разделяй и властвуй"]]

[[File:InfoGraph.jpg|thumb|center|1200px|Рис. 3. Детальное описание одного блока алгоритма]]

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

Предположим, что некоторое <math>u_{i}</math>, хотя и мало, все же недостаточно мало для того, чтобы была зарегистрирована дефляция. В этом случае применение метода Ньютона к решению векового уравнения встречается с затруднениями. Вспомним, что пересчет приближённого решения <math>u_{j}</math> уравнения <math>f(\lambda) = 0</math> в методе Ньютона основан на следующих положениях:

1. Вблизи точки <math>\lambda = \lambda_{j}</math> функция <math>f(\lambda)</math> аппроксимируется линейной функцией <math>l(\lambda)</math>; график есть прямая линия, касающаяся графика функции <math>f(\lambda)</math> при <math>\lambda = \lambda_{j}</math>.

2. В качестве <math>\lambda_{j+1}</math> берётся нуль этого линейного приближения, т.е. <math>l(\lambda_{j+1})=0</math>.

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

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

Чтобы найти выход из этого положения, можно модифицировать метод Ньютона следующим образом: раз <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>, также имеющую эти полюсы, т.е. функцию вида
<math>h(\lambda)= \frac{c_{1}}{d_{i}-\lambda} + \frac{c_{2}}{d_{i+1}-\lambda} + c_{3}</math>

Константы <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>, поскольку сводится к эквивалентному квадратному уравнению
<math>c_{1}(d_{i+1}-\lambda)+c_{2}(d_{i}-\lambda)+c_{3}(d_{i}-\lambda)(d_{i+1}-\lambda)=0</math>

Пусть <math>\lambda_{j}</math> - приближённое значение корня. определим <math>c_{1},c_{2}</math> и <math>c_{3}</math> так, чтобы
<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>

для <math>\lambda</math> в окрестности <math>\lambda_{j}</math>. Заметим, что

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

Если <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>, такие, что функция

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

Это означает, что гипербола, являющаяся графиком функции <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>

Подобным же образом выбираем <math>c_{2}</math> и <math>\hat{c_{2}}</math> так, чтобы функция

<math>h_{2}(\lambda) \equiv \hat{c_{2}} + \frac{c_{2}}{d_{i+1}-\lambda}</math>

Удовлетворяла условиям

<math>h_{2}(\lambda_{j}) = \psi_{2}(\lambda_{j})</math> и <math>h_{2}^{'}(\lambda_{j})=\psi_{2}^{'}(\lambda_{j})</math> (2)

Наконец, полагаем

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

<math>\equiv c_{3} + \frac{c_{1}}{d_{i}-\lambda} + \frac{c_{2}}{d_{i+1}-\lambda}</math>.

== Схема реализации последовательного алгоритма ==
''Вычисление собственных значений и собственных векторов симметричной трехдиагональной матрицы посредством стратегии "разделяй и властвуй"'':

''proc dc_eig''<math>(T,Q,\Lambda)...</math> по входной матрице <math>T</math> вычисляются выходные матрицы <math>Q</math> и <math>\Lambda</math>, такие, что <math>T = Q\Lambda Q^{T}</math>

'''Если <math>T</math> - матрица размера <math>1</math> x <math>1</math>'''

1. Присвоить выходным параметрам значения <math> Q = 1, \Lambda = T</math>

'''Иначе'''

1. Представить <math>T</math> в виде <math> T = \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T} </math>

2. ''call dc_eig''<math>(T_{1},Q_{1},\Lambda_{1})</math>

3. ''call dc_eig''<math>(T_{2},Q_{2},\Lambda_{2})</math>

4. Построить <math>D+\rho uu^{T}</math> по <math> \Lambda_{1},\Lambda_{2}, Q_{1}, Q_{2}</math>

5. Найти матрицу собственных значений <math>\Lambda</math>

6. Найти матрицу собственных векторов <math>Q^{'}</math> для матрицы <math>D+\rho uu^{T}</math>

7. Построить матрицу собственных векторов <math>Q</math> для матрицы <math>T</math> : <math> Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}* Q^{'} </math>

8. Присвоить выходным параметрам значения <math>Q</math> и <math>\Lambda</math>

'''endif'''

== Последовательная сложность алгоритма ==
Проанализируем сложность алгоритма. Пусть <math>t(n)</math> - число флопов при обработке матрицы размера <math> n x n</math> процедурой ''dc_eig''. Тогда

<math> t(n) = 2t(n/2) </math> два рекурсивных обращения к ''dc_eig''<math>(T_{i},Q_{i},\Lambda_{i})</math>

<math> +O(n^{2})</math> вычисление собственных значений матрицы <math>D+\rho uu^{T}</math>

<math> +O(n^{2})</math> вычисление собственных векторов матрицы <math>D+\rho uu^{T}</math>

<math> +c*n^{3}</math> вычисление матрицы <math>Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}*Q^{'}</math>

Если <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>

На практике константа <math>c</math> обычно гораздо меньше 1, потому что матрица <math>Q^{'}</math> весьма разрежена вследствие явления, называемого дефляцией.

== Информационный граф ==
В данном разделе представлен информационный граф алгоритма: на рисунке 5 изображена часть алгоритма, в которой происходит деление - "Divide", а на рисунке 6 описана часть "Conquer".

[[File:Infograph1.jpg|thumb|center|left|800px|Рис. 5. Информационный граф алгоритма "Разделяй и властвуй" - шаг Divide]]

[[File:Infograph2.jpg|thumb|center|1200px|Рис. 6. Информационный граф алгоритма "Разделяй и властвуй" - шаг Conquer. Qk*k - матрица собственных значений размерности k. Lk*k - матрица собственных векторов размерности k.]]

Операции:

<math>D</math> - операция Divide разделения матрицы <math> T </math> на матрицы <math>T_{1}</math> и <math>T_{2}</math>

Индексы - размерность

<math>S_{k}</math> - операция Conquer сбора матрицы <math> D </math>

<math> L_{k} </math> - операция поиска собственных значений

<math> S^{'} </math> - операция поиска собственных векторов матрицы <math> Q^{'} </math>

<math> S </math> - операция поиска собственных векторов матрицы <math> Q </math>

== Ресурс параллелизма алгоритма ==
Рассмотрев информационный граф алгоритма, можно заметить, что в структуре имеется два параллельных блока - вызов рекурсивных функций ''dc_eig'' для вычисления собственных значений и векторов матриц <math>T_{1}</math> и <math>T_{2}</math> - это единственная часть алгоритма, в которой мы прибегаем к параллелизму.

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

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

В случае реализации без параллелизма, функции ''dc_eig'' отрабатывают последовательно - сначала со входными параметрами <math>T_{1}, Q_{1}, \Lambda_{1}</math>, затем - <math>T_{2}, Q_{2}, \Lambda_{2}</math>.

Таким образом, благодаря параллелизму высота алгоритма параллельного составляет <math>log_{2}(n)</math>, когда как при последовательной реализации высота алгоритма равна сумме геометрической прогрессии <math>1+2+4+8+...+2^{n-1} = 2^{n} - 1</math>, что значительно сокращает число итераций алгоритма.

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

На вход алгоритму подаётся трёхдиагональная симметричная матрица:

<math>
L = \begin{bmatrix}
a_{1} & b_{1}&&&&& \\
b_{1} & \ddots & \ddots \\
& \ddots & a_{m-1} & b_{m-1} \\
&& b_{m-1} & a_{m} & b_{m} \\
&&& b_{m} & a_{m+1} & b_{m+1} \\
&&&& b_{m+1} & \ddots \\
&&&&&& \ddots & b_{n-1} \\
&&&&&& b_{n-1} & a_{n} \\
\end{bmatrix}
</math>

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

<math>2n + 1</math> - в силу симметрии, хранить следует только диагональные, поддиагональые и наддиагональные элементы.

'''Выходные данные:'''

На выходе мы получаем вектор собственных значений длины <math> n </math> и <math> n </math> собственных векторов длины <math> n </math> , соответствующих собственным значениям исходной матрицы.

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

<math> n + n^{2} = n(n + 1) </math>

== Свойства алгоритма ==
Описанный в данной статье алгоритм является самым быстрым алгоритмом, среди существующих: QR / Бисекция и обратная итерация / Разделяй и властвуй.

Последовательная сложность алгоритма: <math> t = c\frac{4}{3}n^{3} </math>

Параллельная сложность алгоритма (в силу использования дефляции): <math> O(n^{2.3})</math> или в самых редких случаях <math> O(n^{2}) </math> (см. [3] стр. 8).

Особенности алгоритма:

1. Использование дефляции ([[#Дефляция]])

2. Использование адаптированного метода Ньютона ([[#Макроструктура алгоритма]])

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

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

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

== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
Исследование проводилось на суперкомпьютере "Ломоносов" Суперкомпьютерного комплекса Московского университета.

Набор и границы значений изменяемых параметров запуска реализации алгоритма:

* число процессоров [1 : 8] (1,2,3,4,8);
* размер матрицы [4 : 8192].

Для исследования масштабируемости алгоритм был реализован на библиотеке OpenMP 1.5.5 для языка C++(компилятор g++) на cуперкомпьютере Ломоносов на узле compiler. Для данного узла максимально возможное число потоков - 8. В ходе оценки масштабируемости, программа была запущена в 1, 2, 4, 8 потока.
Параметры компиляции и запуска:

ssh compiler
module add slurm
module add openmpi/1.5.5-icc
g++ _scratch/test.c++ -fopenmp -std=c++0x -o test
sbatch -p test -n1 run ./test

Для управления количеством потоков использовалась операция OpenMP omp_set_num_threads();

[[File:ResultsDiagram.jpg|thumb|center|left|800px|Рис. 7. График времени работы программы в зависимости от числа процессов и размера задачи]]

Масштабируемость рассматриваемой реализации алгоритма '''"Разделяй и властвуй"''':

* При увеличении числа процессов общая эффективность программы увеличивается, т.к. время чтения и подготовки исходной матрицы остаётся неизменным, а время работы алгоритма уменьшается, однако рост незначительный.
* При увеличении размерности матрицы общая эффективность программы постепенно уменьшается, т.к. время чтения и подготовки исходных данных растёт быстрее, чем время работы исследуемого алгоритма.
* При одновременном увеличении как числа процессов, так и размерности матрицы общая эффективность программы уменьшается.

Код исследуемой реализации представлен здесь [http://pastebin.com/QpfYZGkK pastebin.com]

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

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

== Существующие реализации алгоритма ==
Описываемый метод реализован в пакете LAPACK, описание которого можно найти в [http://www.netlib.org/lapack/lawnspdf/lawn132.pdf этой статье] на страницах 7, 19 и 20, которая указана в списке литературы.

= Литература =
[1] Дж. Деммель, «Вычислительная линейная алгебра» //С. 230-235

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

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

[4] [https://en.wikipedia.org/wiki/Divide-and-conquer_eigenvalue_algorithm Алгоритм "Разделяй и властвуй" - Wikipedia]

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

[[en:Description of algorithm properties and structure]]

Участник:Kanast74/Алгоритм кластеризации, основанный на минимальном покрывающем дереве

2016-11-21T09:40:05Z

IgorS:

{{Assignment|IgorS}}
Статью подготовила: [[Участник:kanast74|Дмитриева Анастасия Владимировна]].

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

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

Кластеризация - это задача статистического анализа, состоящая в разбиении множества объектов на группы, называемые кластерами, внутри которых объекты обладают одними и теми же свойствами (чаще всего, это означает близость относительно заданной метрики). Основное отличие от задачи классификации состоит в том, что группы заранее не заданы и определяются в процессе работы алгоритма.

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

Пусть на начальном этапе решения задачи имеются набор тестовых примеров <math>X=\{x_1...x_n\}</math>, а также функция расстояния между ними <math>r(e)</math>. Отметим, что метрика, в которой вычисляются расстояния между объектами, выбирается исходя из требований задачи; наиболее распространенные - это Евклидово расстояние, квадрат Евклидова расстояния, манхэттенская метрика, расстояние Чебышева и степенное расстояние. Далее необходимо применить один из алгоритмов кластеризации, которые можно разделить на две категории: иерархические, состоящие в последовательном поиске кластеров из уже найденных кластеров, а также неиерархические, цель которых состоит в минимизации некоторой целевой функции. К последней группе относятся такие алгоритмы, как алгоритм k-средних, алгоритм EM, нечеткие алгоритмы, а также алгоритмы теории графов, к категории которых относится алгоритм, описываемый в данной статье.

Рассмотрим алгоритм кластеризации на k кластеров, основанный на построении минимального остовного дерева (MST) и который состоит в следующем:

# По исходным данным строится взвешенный неориентированный граф: каждый объект представляется в виде вершины графа, а вес ребра, связывающего две вершины, есть расстояние между объектами в выбранной заранее метрике
# Для полученного графа строится минимальное остовное дерево, то есть дерево, содержащее все вершины графа и имеющее минимальный суммарный вес своих ребер
# Удаляется k-1 ребро минимального остовного дерева с максимальным весом
# Получаются k компонент связности, которые интерпретируются как кластеры

Для построения минимального остовного дерева могут быть использованы различные алгоритмы, среди которых наиболее распространены:

# Алгоритм Крускала
# Алгоритм Борувки
# Алгоритм Прима

Отметим, что в рамках проведенного исследования использовался алгоритм Крускала<nowiki>, наиболее подробно изучить который можно, пройдя по ссылке [</nowiki>[https://algowiki-project.org/ru/Алгоритм_Крускала Алгоритм Крускала]], поэтому в данной статье его описание не приводится.

=== Математическое описание алгоритма ===
С математической точки зрения задачу кластеризации можно рассматривать как минимизацию среднего внутрикластерного расстояния <math> \frac{\sum_{i<j, c(x_i)=c(x_j)} r(x_i,x_j)}{\sum_{i<j, c(x_i)=c(x_j)} 1} \to min </math> с одной стороны и максимизации межкластерного расстояния <math> \frac{\sum_{i<j, c(x_i)\neq c(x_j)} r(x_i,x_j)}{\sum_{i<j, c(x_i) \neq c(x_j)} 1} \to max </math> с другой стороны, где <math>c(x)</math> - кластер, к которому принадлежит объект <math>x</math>.

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

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

Вычислительным ядром описываемого алгоритма является построение минимального остовного дерева. В случае, если программа предполагается быть распараллеленной, то операция построения MST будет производиться в отдельности в каждом процессе. Как уже было отмечено, в данном исследовании для построения MST использовался алгоритм Крускала, который будет работать наиболее эффективно, если веса ребер исходного графа отсортированы, поэтому сортировка - это еще одна операция, которая должна быть включена в вычислительное ядро, что предполагает выбранная ревлизация алгоритма. Поэтому в дальнейшем мы не будем разделять сортировку и поиск минимального остовного дерева, предполагая, что они объеденены в единый эффективный алгоритм.

Дадим некоторую справку касательно адгоритма поиска MST, фигурирующего в данном исследовании. Алгоритм Крускала — алгоритм построения минимального остовного дерева взвешенного связного неориентированного графа. Алгоритм впервые описан Джозефом Крускалом в 1956 году.

Алгоритм Крускала находит безопасное ребро для добавления в растущий лес путем поиска ребра <math>(u, v)</math> с минимальным весом среди всех ребер, соединяющих два дерева в лесу. Обозначим два дерева, соединяемые ребром <math>(u, v) </math>, как <math>C_1</math> и <math>C_2</math>. <math>(u, v)</math> — безопасное для <math>C_1</math> ребро. Алгоритм Крускала является жадным, поскольку на каждом шаге он добавляет к лесу ребро с минимально возможным весом.

=== Макроструктура алгоритма ===
# Построение графа путем задания списков ребер. В общем случае, когда задано некоторое множество объектов, для построения графа может быть использован алгоритм, позволяющий рассчитать расстояние от каждого объекта до каждого за <math>O(n^2)</math> операций, где <math>n</math> число объектов (вообще говоря, данная операция требует <math>O(E)</math> операций, где <math>E</math> - число ребер в графе, но в нашем случае число ребер подразумевается равным <math>E=\frac{D (n(n-1))}{2}</math>, <math>D</math> - плотность графа). Однако в рамках данного исследования для тестирования алгоритма использовалась такая технология построения графов, когда в качестве веса каждого ребра назначается некоторое произвольное число из заданного промежутка (например, от 1 до 1000), что также требует <math>O(n^2)</math>
# Построение минимального остовного дерева на основании полученного ранее графа, для чего может быть использован один из известных и наиболее распространенных алгоритмов (алгоритм Крускала, алгоритм Борувки или алгоритм Прима). Рассмотрим, например, алгоритм Крускала. На начальном этапе имеется граф, состоящий из вершин - объектов исходной выборки и не содержащий ребер, следовательно, каждая из вершин изначально представляет собой компоненту связности и даже дерево. Алгоритм состоит в выборе на каждом шаге ребра с минимальным весом и добавлении его в дерево, если оно соединяет два дерева. Алгоритм будет работать максимально эффективно, если изначально ребра графа, полученного на первом шаге будут отсортированы (например, по возрастанию).
# Для получения <math>k</math> кластеров необходимо удалить из получившегося минимального остовного дерева <math>k-1</math> ребро с максимальным весом. В частности, в случае, если на предыдущем шаге мы пользовались алгоритмом Крускала для построения MST, ребра получившегося дерева отсортированы по возрастанию, значит для удаления указанных выше ребер потребуется лишь <math>O(1)</math> операций
# Наконец, необходимо правильно интерпретировать результат работы алгоритма и перечислить вершины, принадлежащие полученным кластерам; на выполнение данного шага может потребоваться различное число операций в зависимости от формата выходных данных программы: например, в данной реализации выходные данные, как будет сказано в дальнейшем, представлены в виде списка ребер, формирующий итоговый минимальный остовный лес, следовательно в общем случае на его обработку потребуется <math>O(V)</math> операций

==== Используемые обозначения и структуры данных ====

Обозначим в качестве <math>G=(V,E)</math> граф, содержащий <math>V</math> вершин и <math>E</math> ребер. Для построения минимального остовного дерева для данного графа используются три операции [2], опишем здесь каждую из них:

# операция MakeSet(<math>v</math>) генерирует дерево (множество) для вершины графа <math>v</math>, являющейся корнем искомого дерева
# операция Find(<math>v</math>) определяет, которому из деревьев принадлежит интересующая вершина <math>v</math>. Условимся, что данная операция возвращает ту вершину, которая является корнем искомого дерева
# операция Union(<math>u, v</math>) объединяет два множества (два дерева, содержащих соответствующие вершины) под одним корнем

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

Приведем здесь псевдокод основной части алгоритма - а именно построения локального минимального остовного дерева при помощи алгоритма Крускала.

Kruskal ( G=(V,E) ):

1. mst = ∅;

2. сортировать E по возрастанию;

3. для каждой вершины v из множества вершин V:

4. MakeSet(v);

5. для каждого ребра e = (u, v) из множества ребер E:

6. if Find(u) ≠ Find(v):

7. mst = mst ∪ { (u,v) };

8. Union(u, v);

9. return mst;

=== Последовательная сложность алгоритма ===
Сперва оценим последовательную сложность составных частей алгоритма.

0. O(E): Формирование графа

1. O(1): Инициализация пустого множества.

2. O(Elog(E)): сортировка ребер из множества E.

3. O(V): Инициализация одноточечного множества для каждой вершины из V.

4. ▲ MakeSet за O(1).

5. O(Elog(V)): Операции Union и Find для каждого ребра из E.

6. ▲ Find за O(1).

7. ▲ Присоединение элемента за O(1).

8. ▲ Union за O(log(V)).

9. O(1): Удаление k-1 ребра для получения k компонент связности

10. O(V): Перечисление вершин, входящих в соответствующие кластеры

11. O(1): Return.

Таким образом, с учетом того, что, получаем:

<math>T( G = (V, E) ) = O(1) + O(E\log(E)) + O(V) + O(E\log(V)) + O(E) = O(E\log(E)) + O(E\log(V)) = O(E\log(V)) + O(E\log(V))</math>

Итак, оценка сложности алгоритма есть <math>T( G = (V, E) ) = O(E\log(V)) + O(\log(V))</math>

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

[[file:Clustering kruskal.png|thumb|center|1400px|Рисунок 1. Информационный граф алгоритма]]

По структуре информационного графа можно сделать вывод что высота канонической ярусно-параллельной формы [1] есть <math>\log{p}</math>, где <math>p</math> число процессов.

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

Описанный алгоритм позволяет произвести распараллеливание, источник которого будет описан в данном пункте. Прежде всего, необходимо отметить, что данный алгоритм допускает преобразование в гибридную параллельную версию, а именно версию с использованием технологий MPI и OpenMP.

Тем не менее, прежде всего следует установить справедливость свойства используемого алгоритма поиска MST, позволяющего произвести его распараллеливание [3]:

'''Ассоциативность по рёбрам'''. Пусть <math>MSF(E)</math> – минимальный остовный лес графа с рёбрами <math>E</math>. Тогда
:<math>
MSF(E_1 \cup E_2 \cup \dots \cup E_k) = MSF(MSF(E_1) \cup MSF(E_2) \cup \dots \cup MSF(E_k)).
</math>

В том случае, когда все объекты заранее известны, и между ними можно рассчитать все попарные расстояния, первый шаг - построение графа - позволяет произвести распараллеливание при помощи обеих вышеуказанных технологий, а именно: разделить объекты между процессами при помощи MPI, а внутри каждой из полученных групп будем рассчитывать попарные расстояния параллельно на нескольких ядрах, использовав технологию OpenMP. Однако в данном исследовании кластеризуемые объекты предполагались заранее неизвестными, так как попарные расстояния между объектами задаются случайным образом, а это означает, что произвести распараллеливание этого шага, которое бы дало хотя бы небольшое ускорение (уменьшение времени работы), не получится.

Если все же объекты заранее были известны, можно сохранить полученную на предыдущем этапе группировку их на отдельные процессы и внутри каждого произвести сортировку расстояний между объектами по возрастанию при помощи алгоритма QSort с использованием технологии OpenMP (в противном случае параллельная структура алгоритма поддерживается начиная с этого шага).

Далее внутри каждой группы объектов (каждый процесс в отдельности) строим минимальное остовное дерево, в конце шага деревья объединяются в одно - общее MST для всех объектов, поддерживая при этом отсортированность расстояний по возрастанию.

Наконец, будем удалять необходимое количество ребер глобального остовного дерева для того, чтобы получить требуемое количество кластеров - компонент связности графа.

==== Стратегии распараллеливания ====
Необходимо отметить, что несмотря на всю простоту идеи распараллеливания алгоритма, описанную выше, существует несколько стратегий реализовать ее на практике. При этом, как будет показано далее, указанные стратегии дают различные приросты в производительности. Перечислим некоторые из них:

# первая стратегия, наиболее очевидная, состоит в том, чтобы в самом начале главный процесс считывает данные о ребрах и распределяет считанную информацию между остальными процессами, не имеющим доступа к файлу с исходными данными. Далее каждый из процессов рассчитывает локальное минимальное остовное дерево и передает его обратно главному процессу, который объединяет деревья в одно, глобальное
# вторая стратегия во многом напоминает первую, но основное различие между ними состоит в том, что во втором случае файл с исходными данными не разделяется между процессами, а является доступным для каждого из них в полном объеме. Таким образом, каждый процесс способен считать данные о ребрах, за которые они отвечают, самостоятельно, что значительно снижает объем коммуникации между процессами. Также еще одно улучшение состоит в том, что теперь главный процесс не простаивает во время работы остальных, а, как и остальные, рассчитывает локальное минимальное остовное дерево
# наконец, третья стратегия состоит в том, чтобы оптимизировать процесс слияния локальных минимальных остовных деревьев. Предлагается сделать так, чтобы не только главный процесс занимался слиянием, но каждый процесс участвует в процессе слияния. Для того, чтобы добиться максимальной эффективности будем предполагать, что число процессов <math>p=2^n,n>1</math>. В этом случае потребуется <math>\log{p}</math> шагов, чтобы выполнить слияние. На каждом шаге половина активных процессов пересылает свое локальное дерево процессу с меньшим номером на единицу, а другая половина занимается приемом и слиянием. Таким образом, через <math> \log{p} </math> шагов главный процесс, который имеет номер 0, будет иметь в своем распоряжении глобальное минимальное остовное дерево.

==== Способы разделения графа ====

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

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

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

По исходным данным формируется граф <math>G = (V, E)</math>, являющийся неориентированным, взвешенным, связным и не имеющим кратных ребер. Пусть полученный граф содержит <math> |V|</math> вершин и <math>|E|</math> ребер. Предполагая, что каждый объект можно сравнить с каждым, можно считать, что получаемый граф является полным, а значит число ребер может быть оценено следующим образом: <math>|E|=\frac{|V|(|V|-1)}{2} \le \frac{|V|^2}{2}-\frac{|V|}{2} \Rightarrow O(E)=O(V^2)</math>

Обозначим в виде <math>w(u,v)</math> вес ребра, соединяющего вершины <math>u</math> и <math>v</math>. Тогда граф может быть задан в виде списка ребер, а именно списка троек: <math>(u,v,w(u,v))</math>, что является более удобным представлением графа для реализации многих алгоритмов по сравнению с матрицей смежности. Помимо этого, данный способ помогает сэкономить память. Недостатков указанного подхода является только то, что установить, с какими вершинами связана интересующая вершина, а также вес соответствующих ребер является весьма затруднительно. Однако для решения поставленной задачи нам это и не потребуется.

Формат выходных данных аналогичный

=== Свойства алгоритма ===
==== Вычислительная мощность ====
Оценим вычислительную мощность алгоритма в том случае, когда для его реализации используется <math>p</math> процессов. Предположим, что алгоритм реализован при помощи первой стратегии (см. выше) и применяется к графу <math>G = (V, E)</math>, тогда:

* Ввод данных: <math>\frac{|E|}{p}</math> - в среднем столько ребер содержит получаемый каждым процессом связный подграф
* Вывод данных: <math>\frac{|V| - 1}{p}</math> - каждый из процессов должен вывести посчитанное локальное минимальное дерево, которое содержит указанное количество ребер, так как остальные ребра, изначально входившие в состав подграфа, не будут входит в локальное MST
* Вычисление: для вычисления локального MST каждому из процессов требуется <math>\frac{|E|}{p} \log{\frac{|V|}{p}}</math> операций

Таким образом, искомое соотношение может быть записано в следующем виде: <math>\frac{\frac{|E|}{p} \log{\frac{|V|}{p}}}{\frac{|E|}{p} + \frac{|V| - 1}{p}} = \frac{|E| \log{\frac{|V|}{p}}}{|E|+|V|-1}</math>

На основании полученной формулы можно сделать несколько выводов:

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

==== Оценка прироста в производительности ====
===== Закон Амдала =====

В данном рзеделе будет производиться оценка прироста производительности параллельного алгоритма по сравнению с последовательным. Наиболее простой способ оценить прирост производительности – использовать закон Амдала, который гласит, что прирост может быть оценен следующим образом: <math> S_p \le \frac{1}{f+\frac{1-f}{p}}</math>,

где <math>f</math> – часть алгоритма, которая не может быть распараллелена, <math>p</math> – число процессов.

В наиболее тривиальном случае (первая стратегия распараллеливания) распараллеливанию не подлежит считывание входных данных и их разделение между процессами, а также объединение локальных MST в одно. Поэтому сложность последовательной части программы может быть оценена следующим образом: <math>2O(V^2)+O(V^2 \log{V})</math>. Распараллеливанию подлежит инициализация подграфов при помощи операции MakeSet за <math>O(V)</math>, сортировка ребер по возрастанию внутри каждой группы за <math>O(V^2 \log{V})</math>, а также построение локальных минимальных остовных деревьев за аналогичное время. Поэтому сложность параллельной части алгоритма может быть оценена так: <math>O(V)+2 O(V^2 \log{V})</math>. Таким образом, вычислив отношение сложностей частей программы, получаем, что <math>f=0.44</math>. Устремим число процессов <math>p</math> к бесконечности и получим, что максимальное ускорение, которое можно получить путем распараллеливания алгоритма есть <math>2.27</math>. К сожалению, данная оценка не является точной. Для того, чтобы оценить прирост производительности более качественно, произведем анализ временных диаграмм программы.

===== Анализ временных диаграмм =====

Обозначим за <math>t_d</math> – время, которое требуется для того, чтобы разделить граф на подграфы, <math>t_p</math> – суммарное время вычислений, <math>t_b</math> – время обратной пересылки локально полученных результатов, <math>t_l</math> – задержка одной пересылки. Причем можно убедиться в том, что <math>t_p > t_d > t_b > t_l</math>, также известно, что время выполнения последовательного кода <math>t_{serial} = t_p</math>.

[[Файл:FirstStrategy.PNG|thumb|center|400px|Рисунок 2. Первая стратегия распараллеливания вычислительного ядра алгоритма]]
Произведем анализ первой (наивной) стратегии распараллеливания программы. На временной диаграмме жирным обозначен критический путь, время выполнения которого может быть вычислено по формуле (см: [2]):
<math>t_{paralel} = 4 t_l + t_d + \frac{t_p}{3} + \frac{t_b}{3}</math>

Тогда максимальное ускорение для одного процесса есть: <math>speedup=\frac{t_{serial}}{t_{parallel}} = \frac{t_p}{4 t_l + t_d + \frac{t_p}{3} + \frac{t_b}{3}}</math>

А в случае n процессов: <math>speedup = \frac{n}{1+\frac{n (n+1) t_l + n t_d + t_b}{t_p}}</math>

[[Файл:SecondStrategy.PNG|thumb|center|400px|Рисунок 3. Вторая стратегия распараллеливания вычислительного ядра алгоритма]]
Теперь проанализируем вторую стратегию, основная задача которой – уменьшить объем коммуникаций между процессами за счет того, что файл с исходными данными теперь доступен всем процессам. Помимо этого введем в рассмотрение новую величину <math>t_i</math> – время, требующееся на инициализацию множеств вершин. Тогда для одного процесса <math>t_{parallel} = t_i + \frac{t_p}{4} + t_l + 3 \frac{t_b}{4}</math>, а максимальное ускорение в случае n процессов есть: <math>speedup= \frac{t_{serial}}{t_{parallel}} = \frac{4}{1+\frac{4 t_i + 4 t_l + 3 t_b}{t_p}}</math>

[[Файл:ThirdStrategy.PNG|thumb|center|400px|Рисунок 4. Третья стратегия распараллеливания вычислительного ядра алгоритма]]
Наконец, проанализируем третью стратегию, основная цель которой – оптимизировать процесс слияния локальных минимальных остовных деревьев, а также привлечь все активные процессы (включая главный) к процессу построения локального MST. В этом случае время выполнения параллельной части программы с использованием лишь одного процесса: <math> t_{parallel}=t_i + \frac{t_p}{4} + t_l + 2 \frac{t_b}{4}</math>, а суммарное ускорение в общем случае: <math>speedup=\frac{t_{serial}}{t_{parallel}} = \frac{n}{1+\frac{n t_i + n t_l + \log_2{n} t_b}{t_p}}</math>

На рисунке 5 приведены графики, отражающие зависимость получаемых возможных ускорений в зависимости от числа задействованных процессов, посчитанные с использованием четырех различных подходов.
[[Файл:Comparison.PNG|thumb|center|400px|Рисунок 5. Сравнение стратегий распараллеливания]]

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===

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

# первая стратегия, наиболее очевидная, состоит в том, чтобы в самом начале главный процесс считал данные о ребрах и распределил считанную информацию между остальными процессами, причем каждый из них не имеет доступа к файлу с данными. Далее каждый из процессов рассчитывает локальное минимальное остовное дерево и передает его обратно главному процессу, который объединяет деревья в одно, глобальное
# вторая стратегия во многом напоминает первую, но основное различие между ними состоит в том, что во втором случае файл с исходными данными не разделяется между процессами, а является доступным для каждого из них в полном объеме. Таким образом, каждый процесс способен считать данные о ребрах, за которые они отвечают, самостоятельно, что значительно снижает объем коммуникации между процессами. Также еще одно улучшение состоит в том, что теперь главный процесс не простаивает во время работы остальных, а, как и остальные, рассчитывает локальное минимальное остовное дерево
# наконец, третья стратегия состоит в том, чтобы оптимизировать процесс слияния локальных минимальных остовных деревьев. Предлагается сделать так, чтобы не только главный процесс занимался слиянием, но каждый процесс участвует в процессе слияния. Для того, чтобы добиться максимальной эффективности будем предполагать, что число процессов <math>p=2^n,n>1</math>. В этом случае потребуется <math>\log{p}</math> шагов, чтобы выполнить слияние. На каждом шаге половина активных процессов пересылает свое локальное дерево процессу с меньшим номером на единицу, а другая половина занимается приемом и слиянием. Таким образом, через шагов главный процесс, который имеет номер 0, будет иметь в своем распоряжении глобальное минимальное остовное дерево.

=== Масштабируемость алгоритма и его реализации ===
[[file:Total.png|thumb|center|400px|Рисунок 6. График зависимости времени вычисления от размера задачи и числа процессов (с учетом времени ввода-вывода)]]
[[file:Wo_io.png|thumb|center|400px|Рисунок 7. График зависимости времени вычисления от размера задачи и числа процессов (без учета времени ввода-вывода)]]

На графиках видно, как с увеличением объема вычислительных ресурсов происходит прирост в производительности. Данный эффект происходит до некоторых пор, после чего накладные расходы на коммуникацию между процессами нивелируют его. При дальнейшем увеличении числа процессов время решения задачи заметно увеличивается, однако, ввиду длинных очередей на суперкомпьютере Ломоносов данные с числом процессов <math> \ge 256</math> получить не удалось

Исходный код, запускавшийся на суперкомпьютере Ломоносов-1:

[[Файл:Source codes.docx]]

Для компиляции исходных кодов использовался сервер compiler, компилятор mpicc (из модуля openmpi/1.5.5-icc) с опциями -Wall -O3 -fopenmp.
Запуск задачи производился скриптом следующего вида: sbatch -n $PROCESSES —ntasks-per-node 4 -t $TIME -p regular4 ompi kruscal_mpi_test_data_bin

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма [3]===
* C++: [http://www.boost.org/libs/graph/doc/ Boost Graph Library] (функция <code>[http://www.boost.org/libs/graph/doc/kruskal_min_spanning_tree.html kruskal_min_spanning_tree]</code>).
* C++, MPI: [http://www.boost.org/libs/graph_parallel/doc/html/index.html Parallel Boost Graph Library]
** функция <code>[http://www.boost.org/libs/graph_parallel/doc/html/dehne_gotz_min_spanning_tree.html#merge-local-minimum-spanning-trees merge_local_minimum_spanning_trees]</code> реализует алгоритм Крускала;
** функции <code>[http://www.boost.org/libs/graph_parallel/doc/html/dehne_gotz_min_spanning_tree.html#dense-boruvka-minimum-spanning-tree dense_boruvka_minimum_spanning_tree]</code>, <code>[http://www.boost.org/libs/graph_parallel/doc/html/dehne_gotz_min_spanning_tree.html#boruvka-then-merge boruvka_then_merge]</code>, <code>[http://www.boost.org/libs/graph_parallel/doc/html/dehne_gotz_min_spanning_tree.html#boruvka-mixed-merge boruvka_mixed_merge]</code> сочетают [[алгоритм Борувки]] и алгоритм Крускала.
* Python: [https://networkx.github.io NetworkX] (функция <code>[http://networkx.github.io/documentation/networkx-1.9.1/reference/generated/networkx.algorithms.mst.minimum_spanning_tree.html minimum_spanning_tree]</code>).
* Java: [http://jgrapht.org JGraphT] (класс <code>[http://jgrapht.org/javadoc/org/jgrapht/alg/KruskalMinimumSpanningTree.html KruskalMinimumSpanningTree]</code>).

= Литература =
[1] Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.

[2] http://www.gpiskas.com/pdf/kruskal_mpi.pdf (дата обращения: 02.10.2016)

[3] https://algowiki-project.org/ru/Алгоритм_Крускала

Участник:Vagabond/Алгоритм быстрого дискретного пребразования Фурье

2016-11-21T09:36:25Z

IgorS:

{{Assignment|IgorS}}
'''Автор''': Данилишин А.Р.
= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Пусть <math>X=(x_{1},...,x_{n-1})^{T}</math> - исходный сигнал, который необходимо преобразовать умножением на тензор второго ранга <math>E_{pk}=e^{\frac{-2kpi\pi}{n}} </math>. Результатом данного преобразования (<math>E*X</math>) будет вектор <math>Y=(y_{1},...,y_{n-1})^{T}</math>, где <math> y_{p}=\sum_{k=0}^{n-1}x_{k}e^{\frac{-2kpi\pi}{n}}, p=\overline{0,n-1}</math>. Данная формула является классической формулой ДПФ. Известно, что в общем случае умножение матрицы на вектор требует <math>O(n^{2})</math> арифметических операций, поэтому возникает вопрос о сокращении данного количества.

Главная идея БПФ состоит в сокращении многочисленных повторов сложения и умножения, которые выполняются в ДПФ (повторяющиеся множители: <math>e^{\frac{-2kpi\pi}{n}}</math> Например при условии, что <math>(pk)mod(n)=const</math>, при всех <math>k=\overline{0,n-1}</math> и <math>p=\overline{0,n-1}</math>

За счет использования данного факта, происходит значительное сокращение количества вычислительных операций. В данной статье используется алгоритм Cooley – Tukey, который предполагает собой разбиение исходного множества входных сигналов на два равных подмножества. При этом множество входных сигналов должно быть степенью двойки. Далее операция деления множества продолжается для образовавшихся подмножеств, и так далее. В результате над каждым из полученных подмножеств выполняется БПФ. Данные вычисления можно выполнять независимо друг от друга. Этот факт используется для реализации параллельной версии алгоритма.

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

*Пусть <math>e^{\frac{-2kpi\pi}{n}}</math> = <math>\omega _{n}^{kp}</math>.
*Разобьем исходный сигнал <math>x(n)</math> на два подмножества, с четными <math>x_{1}(2n)</math> и нечетными <math>x_{2}(2n+1)</math> номерами.
Тогда получаем: <math>y_{p}=\sum_{k=0}^{n-1}x_{k}\omega _{n}^{kp}= \sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega _{n}^{2kp}+\sum_{k=0}^{\frac{n}{2}-1}x_{2k+1}\omega _{n}^{(2k+1)p}</math>.

Выпишем два свойства омеги:
*<math>\omega_{\frac{n}{2}}=e^{2(\frac{-2i\pi}{n})}=\omega_{n}^{2}</math>
*<math>\omega_{n}^{\frac{n}{2}}=e^{\frac{-2ni\pi}{2n}}=e^{-i\pi}=-1</math>
Воспользуемся первым: <math>y_{p}= \sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega _{n}^{2kp}+\omega_{n}^{p}\sum_{k=0}^{\frac{n}{2}-1}x_{2k+1}\omega _{n}^{2kp}=\sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega _{\frac{n}{2}}^{kp}+\omega_{n}^{p}\sum_{k=0}^{\frac{n}{2}-1}x_{2k+1}\omega _{\frac{n}{2}}^{kp}</math>. Или, если обозначить <math>y_{1}(p)=\sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega _{\frac{n}{2}}^{kp}</math>, а <math>y_{2}(p)=\sum_{k=0}^{\frac{n}{2}-1}x_{2k+1}\omega _{\frac{n}{2}}^{kp}</math>, то получим формулу для вычисления координат изображения БПФ при <math>p=\overline{0...n/2}</math>: <math>y_(p)=y_{1}(p)+\omega_{n}^{p}y_{2}(p)</math>.

Заметим, что <math>y(p); y_{1}(p); y_{2}(p)</math> обладают свойством периодичности, с периодом <math>\frac{n}{2}</math>. Покажем это для <math>y_{1}(p)</math> : <math>y_{1}(p+\frac{n}{2})=\sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega_{\frac{n}{2}}^{k(p+\frac{n}{2})}=\sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega_{\frac{n}{2}}^{kp}\omega_{\frac{n}{2}}^{\frac{kn}{2}}=\sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega_{\frac{n}{2}}^{kp}</math>

Так как: <math>\omega_{\frac{n}{2}}^{\frac{kn}{2}}=e^{\frac{-4kni\pi}{2n}}=e^{-2ki\pi}=1</math>

Далее необходимо определить <math>y(p)</math> при <math>p\geq \frac{n}{2}</math>. Теперь воспользуемся свойством периодичности обнаруженными нами ранее: <math>y(p+\frac{n}{2})=y_{1}(p+\frac{n}{2})+\omega_{n}^{(p+\frac{n}{2})}y_{2}(p+\frac{n}{2})</math>. Воспользуемся вторым свойством омеги: <math>y(p)=y_{1}(p)-\omega_{n}^{p}y_{2}(p)</math>. Все выкладки, приведенные выше, относятся ко второму этапу алгоритма Cooley – Tukey, который был использован в данной статье. Последующие шаги данного этапа делят подмножества полученные на предыдущем шаге вычисления БПФ.

В конечном итоге вышеупомянутый алгоритм сводится к двум этапам:

'''Бит-реверсирование'''

Бит-реверсирование – это преобразование двоичного числа путем изменения порядка следования бит в нем на противоположный. Бит-реверсирование применимо только к индексам элементов массива и предназначено для изменения порядка следования этих элементов, при этом значения самих элементов не изменяются. Так, к примеру, четырехмерный вектор <math>(x_{0},x_{1},x_{2},x_{3})</math> изменится на <math>(x_{0},x_{2},x_{1},x_{3})</math>. Данная процедура необходима для разделения исходного сигнала на элементы подмножеств с четными и нечетными номерами, которые необходимы для вычисления <math>y_{1}(p)</math> и <math>y_{2}(p)</math>.

'''Вычисление БПФ'''

После выполнения этапа бит-реверсирования выполняются вычисления проиллюстрированные ''на рисунке 1'' в разделе [[#Информационный граф|Информационный граф]]. Рисунок 1 приведен для случая четырехмерного входного сигнала. Он предполагает совершение двух этапов. В общем же количество этапов равно <math>log_{2}n</math>. Каждый этап содержит в себе вычисление одной и той же операции "бабочки", где на вход подаются два числа <math>a</math> и <math>b</math>, на выходе же получаются <math>a+bU</math> и <math>a-bU</math>, где <math>U</math>- это ''коэффициент поворота''. Общая формула для коэффициента поворота: <math>e^{\frac{-ji\pi}{k}}</math>, где <math>k</math>- размер шага "бабочки", <math>j</math>- номер итерации вычислений над группой элементов, размером <math>2k</math> <math>(0\leq j < k )</math>.

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

Из двух вышеописанных этапов БПФ, бит-реверсирование является самым быстровыполнимым. Поэтому вычислительное ядро алгоритма будет лежать именно во втором этапе. А именно, им будет являться вычисление "бабочек". Количество этапов выполнения БПФ, как описывалось выше, равно <math>log_{2}n</math>. Учитывая количество этапов, размерность входного сигнала и идею деления на подмножества, всего "бабочек" получается <math>\frac{nlog_{2}n}{2}</math>. При этом операция умножения выполняется <math>\frac{n}{2}</math> раз. Это связано с тем, что результаты вычисления "бабочки" <math>a+bU</math> и <math>a-bU</math>.

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

Из всего вышесказанного заключаем, что макроструктуру алгоритма легче всего описать при помощи рекурсии:
*<math>\frac{n}{2}</math> преобразований Фурье порядка 2
*умножение <math>\frac{n}{2}</math> пар комплексных чисел
*<math>n</math> комплексных сложений
*снова преобразование Фурье
Также необходимо заметить, что количеством рекурсий будет количество этапов выполнения БПФ, то есть глубина рекурсии будет равняться <math>log_{2}n</math>

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

Программный код (описан на языке С++) строится из ряда функций:
*бит-реверсирование
*инициализация размерности входного сигнала
*инициализация входного сигнала (при помощи генератора случайных чисел)
*процесс очистки памяти
*выполнение операции "бабочка"
*выполнение БПФ
*функция вывода результата (для тестирования)
----
'''главный программный код БПФ:'''
<source lang="С++">
int main()
{
complex<double> *inputSignal = NULL;
complex<double> *outputSignal = NULL;
int size = 0;
cout << "FFT. Serial version." << endl;
ProcessInitialization(inputSignal, outputSignal, size);
bit(inputSignal, outputSignal, size);
SerialFFTCalculation(outputSignal, size);
PrintSignal(outputSignal, size); //в случае тестирования
ProcessTermination(inputSignal, outputSignal);
cin.get();
}
</source>
----
=== функция бит-реверсирования ===
<source lang="С++">
void bit(complex<double> inputSignal[], complex<double> *outputSignal, int size)
{ // процесс бит-реверсирования
int j = 0, i = 0;
while (i < size)
{
if (j > i)
{
outputSignal[i] = inputSignal[j];
outputSignal[j] = inputSignal[i];
}
else
if (j == i)
outputSignal[i] = inputSignal[i];

int m = size >> 1;
while ((m >= 1) && (j >= m))
{
j -= m;
m = m >> 1;
}
j += m;
i++;
}
}
</source>
=== инициализация размерности входного сигнала ===
<source lang="С++">
void ProcessInitialization(complex<double>* &inputSignal, complex<double>* &outputSignal, int &size)
{
// инициализация размера входного сигнала
do
{
cout << "Enter the input signal length: ";
cin >> size;
if (size < 4)
cout << "Input signal length should be >= 4" << endl;
else
{
int tmpSize = size;
while (tmpSize != 1)
{
if (tmpSize % 2 != 0)
{
cout << "Input signal length should be powers of two" << endl;
size = -1;
break;
}
tmpSize /= 2;
}
}
}
while (size < 4);
cout << "Input signal length = " << size << endl;
inputSignal = new complex<double>[size];
outputSignal = new complex<double>[size];
DummyDataInitialization(inputSignal, size);
}
</source>
=== инициализация входного сигнала ===
<source lang="С++">
void DummyDataInitialization(complex<double>* mas, int size)
{
for (int i = 0; i < size; i++)
{
mas[i] = int(rand() % 100);
}
}
</source>
=== процесс очистки памяти ===
<source lang="С++">
void ProcessTermination(complex<double>* &inputSignal, complex<double>* &outputSignal)
{
//очистка памяти
delete[] inputSignal;
inputSignal = NULL;
delete[] outputSignal;
outputSignal = NULL;
}
</source>
=== выполнение операции "бабочка" ===
<source lang="С++">
void Butterfly(complex<double> *signal, complex<double> &u,int offset, int butterflySize)
{
complex<double> tem = signal[offset + butterflySize] * u;
signal[offset + butterflySize] = signal[offset] - tem;
signal[offset] += tem;
}
</source>
=== выполнение БПФ ===
<source lang="С++">
void SerialFFTCalculation(complex<double> *signal, int size)
{
int m = 0;
for (int tmp_size = size; tmp_size > 1; tmp_size /= 2, m++);
for (int p = 0; p < m; p++)
{
int butterflyOffset = 1 << (p + 1);
int butterflySize = butterflyOffset >> 1;
double coeff = M_PI / butterflySize;

for (int i = 0; i < size / butterflyOffset; i++)
for (int j = 0; j < butterflySize; j++)
Butterfly(signal,complex<double>(cos(-j*coeff),sin(-j*coeff)),j+i*butterflyOffset,butterflySize);
}
}
</source>
=== функция вывода результата (для тестирования) ===
<source lang="С++">
void PrintSignal(complex<double> *signal, int size)
{
cout << "Result signal" << endl;
for (int i = 0; i < size; i++)
cout << signal[i] << endl;
}
</source>
== Последовательная сложность алгоритма ==
Рассмотренный алгоритм Cooley – Tukey выполняется за <math>nlog_{2}n</math> операций комплексного сложения и <math>\frac{n}{2}log_{2}n</math> операций комплексного умножения. Таким образом последовательная сложность алгоритма является '''линейно-логарифмической'''.
== Информационный граф ==
[[file:Граф.jpg|center|thumb|800px|Рисунок 1. Алгоритм Cooley – Tukey для n=4, при предварительно сделанном бит-реверсировании]]
== Ресурс параллелизма алгоритма ==
[[file:Парал.jpg|center|thumb|800px|Рисунок 2. Распараллеливание алгоритма Cooley – Tukey для n=8]]
Рисунок 2 получен из информационного графа, главной идеей которого является процедура деления множеств полученных на предыдущем шаге на два равных по мощности подмножества и применение к ним БПФ. То есть процесс вычисления распределяется между <math>\frac{n}{2}</math> процессорами. И так как при последовательной реализации алгоритма было <math>\frac{n}{2}\log_{2}n</math> операций комплексного умножения и <math>n\log_{2}n</math> комплексного сложения/вычитания. Получается, что при параллельной реализации алгоритма мы будем иметь <math>\log_{2}n</math> операций комплексного умножения и <math>2\log_{2}n</math> комплексного сложения/вычитания. При этом, если используется функция HT(Hyper threading), то параллельная сложность быстрого преобразования Фурье (базовый алгоритм Кули-Тьюки) для векторов с длиной, равной степени двойки составляет <math>\log_{2}n</math>.
== Входные и выходные данные алгоритма ==
*'''Вещественное ДФП'''
**входные данные:
***вектор <math>\overline{a}=(a_{1},a_{2},...,a_{N})</math>, где <math>a_{i}\in \mathbb{R}</math>
***размерность: <math>N</math> точек
**выходные данные:
***вектор <math>\overline{b}=(b_{1},b_{2},...,b_{N})</math>, где <math>b_{i}\in \mathbb{C}</math>
***размерность: <math>2N</math> точек
*'''Комплексное ДФП'''
**входные данные:
***вектор <math>\overline{a}=(a_{1},a_{2},...,a_{N})</math>, где <math>a_{i}\in \mathbb{C}</math>
***размерность: <math>2N</math> точек
**выходные данные:
***вектор <math>\overline{b}=(b_{1},b_{2},...,b_{N})</math>, где <math>b_{i}\in \mathbb{C}</math>
***размерность: <math>2N</math> точек
== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности является ''линейным''. Это хорошо видно из пункта [[#Ресурс параллелизма алгоритма|ресурс параллелизма алгоритма]].
*Вычислительная мощность алгоритма является ''логарифмической''.
*Устойчивость.
**Рассмотрим вопрос об устойчивости поближе. Так как БПФ отличается от ДПФ простым лишь сокращением одинаковых операций, то вопрос устойчивости можно рассматривать на примере ДПФ. Так, к примеру, возьмем формулу ДПФ и добавим возмущение: <math> y_{p}=\sum_{k=0}^{n-1}(x_{k}+\varepsilon )e^{\frac{-2*\pi*k*p*i}{n}}, p=\overline{0,n-1}</math>. После чего преобразуем ее: <math>y_{p}=\sum_{k=0}^{n-1}x_{k}e^{\frac{-2*\pi*k*p*i}{n}}+\varepsilon\sum_{k=0}^{n-1} e^{\frac{-2*\pi*k*p*i}{n}}</math> и оценим вторую сумму, которая является геометрической прогрессией со знаменателем <math>q=e^{\frac{-2*\pi*p*i}{n}}</math>. Таким образом оцениваемая сумма будет равняться: <math>\varepsilon\frac{1-e^{\frac{-2*\pi*p*i*(n-1))}{n}}}{1-e^{\frac{-2*\pi*p*i}{n}}}</math>. При достаточно больших размерностях входного сигнала данное выражение сводится к: <math>\varepsilon (1-e^{-2*\pi*p*i})</math>. В тригонометрической форме данного выражения: <math>\varepsilon (cos(\frac{2*\pi*p*(n-1)}{n})-i*sin(\frac{2*\pi*p*(n-1)}{n}))</math> видно, что принимая во внимание целочисленность индексов <math>p</math> получается 0. Таким образом, мы можем говорить об устойчивости алгоритма в целом, и абсолютной устойчивости алгоритма в асимптотике.
*исходя из информационного графа, можно сделать вывод о сбалансированности алгоритма.
*алгоритм полностью детерминирован.
*Степень исхода вершины информационного графа не превышает двух.
= ЧАСТЬ. Программная реализация алгоритма =
== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
Вычисления проводились на суперкомпьютере «Ломоносов».

'''Основные технические характеристики суперкомпьютера "Ломоносов":'''
*Пиковая производительность: 1,7 Пфлопс
*Производительность на тесте Linpack: 901.9 Тфлопс
*Число вычислительных узлов х86: 5 104
*Число графических вычислительных узлов: 1 065
*Число вычислительных узлов PowerXCell: 30
*Число процессоров/ядер x86: 12 346 / 52 168
*Число графических ядер: 954 240
*Оперативная память: 92 ТБ
*Общий объем дисковой памяти вычислителя: 1,75 ПБ
*Основной тип процессора: Intel Xeon X5570/Intel Xeon 5670, Nvidia X2070
*Число типов вычислительных узлов: 8
*Основной тип вычислительных узлов: TB2-XN
*Все узлы связаны тремя независимыми сетями:
**Системная сеть - QDR InfiniBand, 40 Гбит/сек
**Сервисная сеть - Ethernet, 10 Гбит/сек, 1 Гбит/сек и 100 Мбит/сек
**Управляющая сеть - Ethernet, 10 Гбит/сек и 1 Гбит/сек
**Сеть барьерной синхронизации и сеть глобальных прерываний, Т-Платформы
При работе была использована библиотека FFTW последней версии (3.3.5). Скрипт mpicxx с компилятором Intel. Вычислительные узлы х86. Код исследуемой программы представлен в разделе [[#Существующие реализации алгоритма|Существующие реализации алгоритма]].
[[file:масш.jpg|center|thumb|1000px|Рисунок 3. Параллельная реализация алгоритма. Изменение эффективности(%)в зависимости от числа процессоров и размера области.]]
Как описывалось выше, каждый процессор получает достаточно низкий объем работы, что приводит к неэффективному распараллеливанию алгоритма (высокие затраты на передачу данных между процессорами по сравнению с вычислениями на них). Поэтому необходимо находить оптимальное количество процессоров для каждой отдельно взятой задачи. В данном примере, при размерности входного сигнала менее 262144, оптимальное количество процессоров составляет 1. При размерности 262144-4194304 оптимум достигался при 8 процессорах. И при размерности более 4194304- 16 процессоров.
== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Самой распространенной и известной реализацией дискретного БПФ является библиотека [http://www.fftw.org/ FFTW], разработанная Маттео Фриго и Стивеном Г. Джонсоном в Массачусетском технологическом институте. Данная библиотека существует для языков C и FORTRAN и позволяет производить вычисления в одном или нескольких измерениях. Входной сигнал может быть как действительным так и комплексным, а его размерность не обязательно должна быть степенью двойки. На данный момент последняя версия FFTW 3.3.5. Другие особенности библиотеки:
*Скорость. (Поддержка SSE / SSE2 / Altivec, начиная с версии 3.0. Версия 3.3.1 поддерживает AVX и ARM Neon.)
*Параллельные вычисления (OpenMP, MPI).
*[http://www.fftw.org/fftw3_doc/ Документация] в форматах HTML, PDF.
*Данное программное обеспечение является свободным и распространяется по лицензии GNU (General Public License).
Здесь приводится пример реализации прямого БПФ для комплексных данных входного сигнала на языке C++.
<source lang="С++">
#include <fftw3-mpi.h>
# include <stdlib.h>
# include <stdio.h>
#include <sys/stat.h>
#include <fcntl.h>
# include <time.h>
#include <math.h>

int main(int argc, char **argv)
{
const ptrdiff_t N0 = 4194304;
fftw_plan planForw;
fftw_complex *data, *dataOut;
ptrdiff_t alloc_local, local_ni, local_i_start, i, j, local_no, local_o_start;
int index, size;
double startwtime, endwtime;
MPI_Init(&argc, &argv);
fftw_mpi_init();
MPI_Comm_rank(MPI_COMM_WORLD, &index);
MPI_Comm_size(MPI_COMM_WORLD, &size);

/* get local data size and allocate */
alloc_local = fftw_mpi_local_size_1d(N0, MPI_COMM_WORLD, FFTW_FORWARD, FFTW_ESTIMATE,
&local_ni, &local_i_start, &local_no, &local_o_start);
data = fftw_alloc_complex(alloc_local);
dataOut = fftw_alloc_complex(alloc_local);
/* create plan */
planForw = fftw_mpi_plan_dft_1d(N0, data, dataOut, MPI_COMM_WORLD,
FFTW_FORWARD, FFTW_ESTIMATE);
/* initialize data to some function my_function(x,y) */
for (i = 0; i < local_ni; ++i)
{
data[i][0] = rand() / (double)RAND_MAX;
data[i][1] = rand() / (double)RAND_MAX;
}
if (index == 0){
startwtime = MPI_Wtime();

}

fftw_execute(planForw);
if (index == 0){
endwtime = MPI_Wtime();
printf("wall clock time = %f\n",
endwtime - startwtime);

}

fftw_destroy_plan(planForw);
MPI_Finalize();
}
</source>
[http://www.fftw.org/download.html Скачав] библиотеку и установив ее на рабочий компьютер, можно поэкспериментировать, используя вышеописанный исходный код. При этом, на стадии компиляции необходимо указывать директорию, где находятся заголовочные файлы и директорию, где находятся библиотечные файлы. Пример: mpicxx name.cpp -I/path/to/include/files -L/path/to/lib/files -lfftw3_mpi -lfftw3 -lm. Для версии 2.1.4 описание на русском языке приводится [https://parallel.ru/cluster/fftw.html здесь].

Остальные реализации:
*[http://www.gnu.org/software/gsl/ GSL - GNU Scientific Library]
*[https://developer.nvidia.com/cufft cuFFT]
*[http://www-03.ibm.com/systems/power/software/essl/ Engineering and Scientific Subroutine Library (ESSL) and Parallel ESSL]
=Литература=
[1] Бахвалов Н. С., Жидков Н. П., Кобельков. Г. М. — 6-е изд. — М. : БИНОМ. Лаборатория знаний

[2] Г. Нуссбаумер. Быстрое преобразование Фурье и алгоритмы вычисления сверток

[3] А.О. Лапаев Параллельное вычисление дискретного преобразования Фурье полинома в простом поле

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

2016-11-21T09:32:05Z

IgorS:

=== Замечания к статье ===

* содержание не соответствуют шаблону описания алгоритма--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 15:21, 25 октября 2016 (MSK)
* не указан конкретный вклад каждого автора--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 15:21, 25 октября 2016 (MSK)
* п.п. 1.9 не раскрыт--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 15:21, 25 октября 2016 (MSK)
* п.п. 2.4 не заполнен--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 13:46, 16 ноября 2016 (MSK)
** в п.п. 2.4 следует добавить подробное описание компьютерной платформы и описание условий, в которых производились эксперименты: (какой компилятор, с какими опциями использовался, какие версии библиотек, на каких узлах проводился запуск и т.д.)--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 12:32, 21 ноября 2016 (MSK)

== Замечания к статье "Быстрое преобразование Фурье" ==

* Раздел про общее описание алгоритма слишком большой и нарезан на много частей. Было бы лучше написать статью про саму задачу преобразования Фурье, где и упоминались бы в частности области применения, а также разные алгоритмы с краткими описаниями (а впоследствии со ссылками на статьи с полным описанием) [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:56, 11 ноября 2016 (MSK)
* При упоминании рекурсивного решения задачи следует сказать о глубине рекурсии [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:56, 11 ноября 2016 (MSK)

Участник:Victoria Stepanischeva/Быстрое преобразование Фурье (FFT)

2016-11-21T09:31:12Z

IgorS:

Авторы:

* [[Участник:Victoria_Stepanischeva|Степанищева В.С.]], группа 601 (Общее описание алгоритма, Вычислителное ядро алгоритма, Макроструктура алгоритма, Информационный граф, Ресурс параллелизма алгоритма)
* [[Участник:Igor_Munkin|Мунькин И.А.]], группа 601 (Математическое описание алгоритма, Схема реализации последовательного алгоритма, Последовательная сложность алгоритма, Входные и выходные данные алгоритма, Свойства алгоритма, Существующие реализации алгоритма)

{{algorithm
| name = Быстрое преобразования Фурье
| serial_complexity = <math>O(N \; log \, N)</math>
| input_data = <math>N</math>
| output_data = <math>N</math>
| pf_height = <math>O(log \,N)</math>
| pf_width = <math>N</math>
}}

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

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

Алгоритм '''быстрого преобразования Фурье''', включая его рекурсивную
реализацию, был использован
[https://en.wikipedia.org/wiki/Carl_Friedrich_Gauss Карлом Фридрихом Гауссом]
еще в 1805 году для интерполяции траекторий астероидов, однако эта работа не
получила широкого признания. Алгоритм быстрого преобразования Фурье обрел свою
популярность благодаря работе
[https://en.wikipedia.org/wiki/James_Cooley James Cooley], работающего в то
время в [https://en.wikipedia.org/wiki/IBM IBM], и
[https://en.wikipedia.org/wiki/John_Tukey John Tukey], параллельно принимающего
участие в разработках [https://en.wikipedia.org/wiki/Bell_Labs Bell Labs] и
работающего в
[https://en.wikipedia.org/wiki/Princeton_University Принстонском университетe].
В их статье, изданной в 1965 году, они представили подробное описание алгоритма
и его программной реализации.

====Разновидности алгоритма быстрого преобразования Фурье====
Помимо традиционного и наиболее распространенного алгоритма
[https://en.wikipedia.org/wiki/Cooley%E2%80%93Tukey_FFT_algorithm Cooley-Tukey]
существует также несколько других часто используемых реализаций алгоритма
быстрого преобразования Фурье.

=====PFA-алгоритм=====
Алгоритм [https://en.wikipedia.org/wiki/Prime-factor_FFT_algorithm prime-factor]
(PFA), также называемый алгоритмом Good-Thomas, представляет собой алгоритм
быстрого преобразования Фурье, который представляет дискретное преобразование
Фурье размера <math>N = N_1 \cdot N_2</math> в виде двумерного
<math>N_1 \times N_2</math> дискретного преобразования Фурье, при условии, что
<math>N_1</math> и <math>N_2</math> - взаимно простые числа. Представленные
преобразования меньшего размера могут быть вычислены либо рекурсивным
применением PFA либо используя какой-либо иной метод быстрого преобразования
Фурье.

=====Алгоритм Bluestein=====
Алгоритм
[https://en.wikipedia.org/wiki/Chirp_Z-transform#Bluestein.27s_algorithm Bluestein],
обычно называемый <math>\mathcal{Z}</math>-чирп алгоритмом, представляет собой
алгоритм быстрого преобразования Фурье, который вычисляет дискретное
преобразование Фурье различных размеров с помощью представления оного в виде
линейной свертки. Другой алгоритм быстрого преобразования Фурье, использующий
свойства простых чисел, алгоритм
[https://en.wikipedia.org/wiki/Rader%27s_FFT_algorithm Rader], также вычисляет
дискретное преобразование Фурье в виде свертки.

====Приложения быстрого преобразования Фурье====

Алгоритм быстрого преобразования Фурье имеет множество областей приложения,
таких как:
* Обработка изображений
* Цифровое сжатие
* Численное интегрирование
* Быстрые методы решения уравнения Пуассона
* Спектральные методы решения обыкновенных дифференциальных уравнений

Рассмотрим подробнее те приложения, с которыми мы наиболее часто сталкиваемся
в повседневной жизни.

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

Частотная фильтрация является более общим механизмом фильтрации, чем
пространственная. Все пространственные фильтры можно реализовать с помощью
частотных. Частотные фильтры выполняют фильтрацию изображений в частотной
области. Для этого с помощью преобразования Фурье происходит получение спектра
изображения. После применения фильтра к спектру изображения выполняется обратное
преобразование Фурье и получается отфильтрованное изображение.

Простота фильтрации в частотной области заключается в простой интерпретации
частот:
* низкие частоты - плавное изменение яркости изображения
* высокие частоты - быстрое изменение яркости изображения (границы объектов)
За счет изменения значений определенных частот можно добиться размытия
изображения, повышение резкости и др.

=====Цифровое сжатие=====
Одним из первых форматов файла-контейнера для хранения записи оцифрованного
аудипотока является формат WAV. Этот формат чаще всего используется в качестве
оболочки для несжатого звука. При таком кодировании в WAV-файле хранится полная
информация об исходном звуке, оцифрованном и проквантованном с некоторой
частотой, например 44 кГц. Этой информации абсолютно достаточно для
воспроизведения всех частот исходного сигнала, меньших половины частоты
квантования (по [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BE%D1%80%D0%B5%D0%BC%D0%B0_%D0%9A%D0%BE%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D0%B8%D0%BA%D0%BE%D0%B2%D0%B0 теореме Котельникова] ). При этом одна
минута записи занимает около 15 Мб, поэтому в настоящее время очень популярным
стал формат кодирования MPEG Layer-3 со сжатием.

При сжатии кодеком MPEG Layer-3 исходный звуковой сигнал разбивается на
фрагменты, длительностью по 50 миллисекунд, каждый из которых анализируется
отдельно. При анализе фрагмент раскладывается на гармоники по методу Фурье, из
которых в соответствии с теорией восприятия звука человеческим ухом
выбрасываются те гармоники, которые человек хуже воспринимает на фоне остальных:
* более тихие гармоники на фоне более громких
* звуки, замаскированные вследствие инертности слуха (так, например, если за очень громким хлопком, с задержкой в долю секунды, пойдет какой-то иной кратковременный сигнал, то его слышно не будет)

При воспроизведении файла закодированного MPEG Layer-3 производится обратное
преобразование, при котором оставшиеся гармоники вновь преобразуются в звуковую
волну. Поскольку часть информации об исходном сигнале была удалена, звук
получается не совпадающий с исходным. Одной из основных характеристик качества
аудио потока является битрейт.

''Битрейт'' - это объем информации на каждую секунду записи:
* чем он меньше, тем меньший размер имеют файлы с одинаковой по времени длине
* чем он меньше, тем большее количество "лишних" гармоник приходится удалять

===Математическое описание алгоритма===
Пусть задан вектор действительных чисел
<math>\left(f_1, f_2, f_3, \dots, f_{N-1} \right)</math>

Дискретное преобразование Фурье определено следующим образом

<math>
F_k = \sum_{n = 0}^{N - 1}\, f_n\, e^{\left(\frac{i2\pi kn}{N}\right)}
</math>

Обозначим <math>W_N = e^{\left(\frac{i2\pi}{N}\right)}</math> - <math>N</math>-ый
корень единицы. Таким образом <math>(W_N)^N = 1</math>. Несложные математические
преобразования приводят формулу дискретного преобразования Фурье к следующему
виду

<math>
F_k = \sum_{n = 0}^{N - 1}\, f_n\, W_n^{-nk}
</math>

Таким образом, алгоритм вычисления дискретного преобразования Фурье состоит из
2 шагов:
# Вычисление поворотных коэффициентов <math>W_n^{-nk},\; n,k = 0, 1, \dots, N-1</math>
# Вычисление коэффициентов Фурье <math>F_k,\; k = 0, 1, \dots, N-1</math>

В основе концепции быстрого преобразования Фурье лежит идея отдельного расчета четных и
нечетных коэффициентов с использованием векторов меньшего размера. Разобъем дискретное
преобразование Фурье следующим образом

<math>
F_k = \sum_{n = 0}^{N - 1}\, f_n\, W_{N}^{-nk}
= \sum_{n = 0}^{N/2 - 1}\, g_n\, W_{N/2}^{-nk}
+ \sum_{n = 0}^{N/2 - 1}\, h_n\, W_{N/2}^{-nk}
</math>

Следовательно, четные и нечетные коэффициенты Фурье могут быть записаны в
следующем виде:

<math>
F_{2k} = \sum_{n = 0}^{N/2 - 1}\, \underbrace{
\left(f_n + f_{n + N/2}\right)
}_{g_n} \, W_{N/2}^{-nk}
</math>

<math>
F_{2k+1} = \sum_{n = 0}^{N/2 - 1}\, \underbrace{
\left((f_n + f_{n + N/2}) W^{-n}\right)
}_{h_n} \, W_{N/2}^{-nk}
</math>

Таким образом, вычисление дискретного преобразования Фурье от <math>N</math>
коэффициентов сводится к вычислению 2 дискретных преобразований Фурье от
<math>N/2</math> коэффициентов. Применяя данную идею рекурсивно, получаем
алгоритм быстрого преобразования Фурье.

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

[[File:Stepmoon_buttefly.png|left|200px]]
В случае размера входных данных равному <math>N = 2^M</math> вычислительным
ядром алгоритма являются так называемые "бабочки". В элементарном случае
"бабочка" является двухточечным преобразованием.

<math>
g_n = f_n + f_{n + N/2}
</math>

<math>
h_n = \left(f_n - f_{n + N/2}\right)\, W^{-n}
</math>

===Макроструктура алгоритма===
Описываемый алгоритм работает по принципу
[https://en.wikipedia.org/wiki/Divide_and_conquer_algorithms "разделяй и властвуй"].

Рассмотрим общую структуру для входных данных размера <math>N = N1 \cdot N2</math>
# Исходное множество точек разбивается на <math>N2</math> равных подмножеств размером <math>N1</math>.
# Над каждым из полученных множеств выполняется быстрое преобразование Фурье. Для его вычисления над каждым из подмножеств рассматриваемого множества снова выполняется деление на равные части. Такое разбиение продолжается до тех пор, пока количество элементов, над которыми необходимо выполнить быстрое преобразование Фурье, не будет равно одному.
# После этого выполняется объединение всех промежуточных результатов. Полученные на предыдущем шаге множества объединяются за линейное время.

Ниже представлена схема алгоритма Cooley-Tukey для <math>N = 2^M</math>

[[File:Stepmoon_macro.png|center|800px]]

===Схема реализации последовательного алгоритма===
Ниже представлен прототип реализации для <math>N = 2^M</math>.
<source lang=perl>
use Math::Complex;

sub fft {
my $input = shift;
return $input if @{ $input } == 1;
my @w = map {
my $theta = 2 * pi * $_ / @{ $input };
Math::Complex->make(cos($theta), sin($theta));
} (0 .. $#input);
my $odd = fft([ map { $input->[2 * $_ + 1] }, (0 .. @{ $input } / 2 - 1) ]);
my $even = fft([ map { $input->[2 * $_] }, (0 .. @{ $input } / 2 - 1) ]);
return [ map {
$even->[$_ % @{ $even }] + $w[$_] * $odd->[$_ % @{ $odd }];
} (0 .. $#input) ];
};
</source>

===Последовательная сложность алгоритма===
Если считать только главные члены выражений для последовательной сложности алгоритма, то простой алгоритм Cooley-Tukey может быть выполнен за <math>N\, log\, N</math> операций. Таким образом, простой алгоритм Cooley-Tukey относится к линейно-логарифмическому классу по последовательной сложности.

===Информационный граф===
Ниже представлен информационный граф для простого алгоритма Cooley-Tukey для <math>N = 8</math>, <math>\;h</math> - операция сложения двух комплексных чисел, <math>g</math> - операция вычитания двух комплексных чисел и умножения результата вычитания на комплексное число (поворотный множитель). В последнем столбце операций умножения не производится.

[[File:Stepmoon_Info_graph.png|center|500px]]

===Ресурс параллелизма алгоритма===
Простой алгоритм Cooley-Tukey имеет критический путь, состоящий из
<math>log\, N</math> операций сложения и вычитания и <math>log\, N</math>
операций комплексного умножения (основание логарифма зависит от выбранного на
каждом шаге алгоритма разбиения). Следовательно, простой алгоритм быстрого
преобразования Фурье в общем случае может быть отнесен к логарифмическому классу
по параллельной сложности.

===Входные и выходные данные алгоритма===
'''Входные данные:''' измеренные значения сигнала в дискретных временных точках с номерами <math>0 \dots N</math>: <math>f \in \mathbb{R}^N</math>.

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

'''Выходные данные:''' вектор компонент спектра исходного сигнала: <math>F \in \mathbb{C}^N</math>.

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

===Свойства алгоритма===
Обработку подмножеств, получаемых после разбиения, можно выполнять независимо,
этот факт можно использовать при распараллеливании алгоритма.
В случае рекурсивной реализации глубина рекурсии составит <math>log\, N</math>.
Соотношение последовательной и параллельной сложности в случае неограниченных
ресурсов является линейным.
Вычислительная мощность алгоритма, как отношение числа операций к
суммарному объему входных и выходных данных, является логарифмической.

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

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

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

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

===Масштабируемость алгоритма и его реализации===
Набор и границы значений изменяемых параметров запуска реализации алгоритма:
* число процессоров [ 5 : 45 ] с шагом 5
* размер вектора [ 256 : 16384 ] с шагом равным степени двойки

На следующем рисунке приведен график производительности выбранной реализации алгоритма в зависимости от изменяемых параметров запуска.
[[File:Stepmoon_performance.png|center|800px]]

[https://github.com/FFTW/fftw3 Текст исследуемой программы]

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

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

===Существующие реализации алгоритма===
Наиболее популярной библиотекой, содержащей реализацию быстрого преобразования
Фурье, является [http://fftw.org/ FFTW], изначально разработанная сотрудниками
[https://en.wikipedia.org/wiki/Massachusetts_Institute_of_Technology MIT]
Matteo Frigo и Steven G. Johnson. На сегодняшний день исходный код библиотеки
распространяется под свободной лицензией
[https://en.wikipedia.org/wiki/GNU_General_Public_License#Version_2 GNU General Public Licence v2]
с помощью сервиса [https://github.com/FFTW/fftw3 Github], тем самым давая
возможность сообществу принимать участие в разработке. Несмотря на то, что сама
библиотека [http://fftw.org/faq/section2.html#whynotfortran написана на языке C]
существуют интерфейсы для работы с ней используя такие языки программирования
как Fortran, C++ и другиe.

Для разбиения преобразований, размеры которых являются составным числом, на
меньшие используется одна из многочисленных реализаций алгоритма
[https://en.wikipedia.org/wiki/Cooley%E2%80%93Tukey_FFT_algorithm Cooley-Tukey]
(в зависимости от разложения на простые множители и паттернов доступа к памяти).
В свою очередь для преобразований, размеры которых являются простыми числом
используется либо алгоритм
[https://en.wikipedia.org/wiki/Rader%27s_FFT_algorithm Raider], либо алгоритм
[https://en.wikipedia.org/wiki/Chirp_Z-transform#Bluestein.27s_algorithm Bluestein].
Библиотека признана самой быстрой реализацией быстрого преобразования Фурье,
гарантируя на любых объемах входных данных сложность
<math>O \left(n\; log\, n \right)</math>. Существует реализация FFTW и с
поддержкой [https://en.wikipedia.org/wiki/Message_Passing_Interface MPI],
позволяющая работать с данными не помещающимися в память. Однако перегруппировка
данных приводит к оверхеду, которого трудно избежать при in-place вычислении
преобразований различных размеров.

==Литература==
[1] L. Rabiner, B. Gold, ''"Theory and application of digital signal processing"'' // Prentice Hall, New Jersey, 1975.

[2] Бахвалов Н.С., Жидков Н.П., Кобельков Г.М. ''"Численные методы"'' // БИНОМ. Лаборатория знаний, Москва, 2008.

[3] M. Frigo, S. G. Johnson ''"FFTW Documentation"'' // [http://fftw.org/fftw3_doc/ fftw.org]

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

2016-11-21T09:30:15Z

IgorS:

== Замечания к статье ==

* п.п. 2.4-2.6 не соответствуют содержанию описания алгоритма--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 15:10, 25 октября 2016 (MSK)
* не указаны авторы статьи и их вклад--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 15:10, 25 октября 2016 (MSK)
** Автор один, я (Тимохин Иван, 603 гр. ВМК МГУ) --[[Участник:Timokhinivan|Timokhinivan]] ([[Обсуждение участника:Timokhinivan|обсуждение]]) 14:50, 27 октября 2016 (MSK)
*** Так укажите себя, чтобы не было таких вопросов--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:41, 31 октября 2016 (MSK).
* в п.п. 2.4 следует добавить исходный код программы и описание компьютерной платформы, с подробным описанием условий, в которых производились эксперименты.--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:37, 18 ноября 2016 (MSK)
** Исходный код нужен даже если это просто вызов библиотечной функции? --[[Участник:Timokhinivan|Timokhinivan]] ([[Обсуждение участника:Timokhinivan|обсуждение]]) 23:55, 18 ноября 2016 (MSK)
*** да.--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 12:30, 21 ноября 2016 (MSK)

== Замечания к статье "Быстрое преобразование Фурье" ==

* В общем описании алгоритма нужны слова именно про алгоритм: следует рассказать идею быстрого преобразования, с минимумом формул [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:46, 11 ноября 2016 (MSK)
* Не вполне понятны слова "первообразный корень из 1 степени N" [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:46, 11 ноября 2016 (MSK)
* В последней формуле раздела 1.2 индексы k и l, кажется, должны идти через запятую. Если там рассматривается их произведение, следует уточнить, какие значения принимает каждый из них [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:46, 11 ноября 2016 (MSK)
* Раздел 1.2.3 - понятие "порядок преобразования" нуждается в пояснении [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:46, 11 ноября 2016 (MSK)
* Не хватает слов о глубине рекурсии [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:46, 11 ноября 2016 (MSK)

Обсуждение участника:Роман Землянский

2016-11-21T09:16:34Z

IgorS:

== Замечания к статье ==

* п. 1.1 "...собственные векторы трехдиагональной матриц," заменить на "...собственные векторы трехдиагональной матрицы,"--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:48, 26 октября 2016 (MSK)
* п. 1.7 приведенный рисунок не является рисунком информационного графа--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:48, 26 октября 2016 (MSK)
* п. 1.8, 1.9 оценка не произведена--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:48, 26 октября 2016 (MSK)
* п. 2.4 не заполнен--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 13:26, 16 ноября 2016 (MSK)
** в п.п. 2.4 следует добавить код исследуемой программы, а также подробное описание условий, в которых производились эксперименты: характеристики программно-аппаратной платформы (какой компилятор, с какими опциями использовался, какие версии библиотек, на каких узлах проводился запуск и т.д.)--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 12:16, 21 ноября 2016 (MSK)

== Второй этап проверки ==

=== Итерация 1 ===

Начальные замечания и комментарии (возможно будут появляться новые, пишите, пожалуйста, комментарии по ходу исправлений и ответы):

* Исправить ошибки в формулах в разделе 1.2
* Исправить ошибку в разделе 1.9
* Раздел 2.7 - как это не найдены реализации, если в пункте 1.1 они указаны?
* По информационному графу не видно, что дерево может быть большей высоты, нужно бы это как-то отразить. И не совсем очевидно, как Divide переходит в Conquer. Нужно постараться, чтобы граф был более информативен и без чтения остальных разделов.

Участник:Роман Землянский/Zavolskov/Zemlyanskiy

2016-11-21T09:13:19Z

IgorS:

'''Метод «разделяй и властвуй» вычисления собственных значений и векторов симметричной трехдиагональной матрицы'''

Авторы статьи:

'''Завольсков Владислав'''

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

[[#Макроструктура алгоритма]]

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

[[#Информационный граф]]

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

'''Землянский Роман'''

[[#Общее описание алгоритма]]

[[#Математическое описание алгоритма]]

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

[[#Ресурс параллелизма алгоритма]]

[[#Входные и выходные данные алгоритма]]

[[#Свойства алгоритма]]

614 группа

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
'''Метод разделяй и властвуй вычисления собственных значений и векторов трёхдиагональной матрицы''' - это наиболее быстрый из существующих методов, если нужны все собственные значения и собственные векторы трехдиагональной матрицы, начиная с порядка n, примерно равного 26. (Точное значение этого порогового порядка зависит от компьютера.) Его численно устойчивая реализация весьма не тривиальна. В самом деле, хотя впервые метод был предложен еще в 1981 г., "правильный" способ его реализации был найден лишь в 1992 г. Этот способ воплощен LAPACK-программами ssyevd (для плотных матриц) и sstevd (для трехдиагональных матриц). В них стратегия "разделяй-и-влавствуй" используется для матриц порядка, большего чем 25. Для матриц меньшего порядка (или если нужны только собственные значения) происходит автоматический переход к QR-итерации.

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

:<math>
L = \begin{bmatrix}
a_{1} & b_{1}&&&&& \\
b_{1} & \ddots & \ddots \\
& \ddots & a_{m-1} & b_{m-1} \\
&& b_{m-1} & a_{m} & b_{m} \\
&&& b_{m} & a_{m+1} & b_{m+1} \\
&&&& b_{m+1} & \ddots \\
&&&&&& \ddots & b_{n-1} \\
&&&&&& b_{n-1} & a_{n} \\
\end{bmatrix}
= \begin{bmatrix}
a_{1} & b_{1} &&&&& \\
b_{1} & \ddots & \ddots \\
& \ddots & a_{m-1} & b_{m-1} \\
&& b_{m-1} & a_{m} - b_{m} \\
&&&& a_{m+1} - b_{m} & b_{m+1} \\
&&&& b_{m+1} & \ddots \\
&&&&&& \ddots & b_{n-1} \\
&&&&&& b_{n-1} & a_{n} \\
\end{bmatrix} +
</math>

<math>
+ \begin{bmatrix}
&&&&& \\
&&b_{m} & b_{m} \\
&&b_{m} & b_{m} \\
&&&&& \\
\end{bmatrix}

= \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}

\equiv \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T}
</math>

Предположим, что нам известны спектральные разложения матриц <math>T_{1}</math> и <math> T_{2} </math>:
<math> T_{i} = Q_{i} \Lambda_{i} Q_{i}^{T} </math>. В действительности, они будут рекурсивно вычисляться тем же самым алгоритмом. Установим связь между собственными значениями матрицы Т и собственными значениями матриц
<math>T_{1}</math> и <math>T_{2}</math>. Имеем:

<math>
T = \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T}
= \begin{bmatrix} Q_{1} \Lambda_{1} Q_{1}^{T} & 0 \\ 0 & Q_{2} \Lambda_{2} Q_{2}^{T}\end{bmatrix} + b_{m}vv^{T}
= \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}
</math>,

где

<math>
u = \begin{bmatrix} Q_{1}^{T} & 0 \\ 0 & Q_{2}^{T}\end{bmatrix}v
</math>

так как <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>.

Следовательно, <math>T</math> имеет те же собственные значения, что и подобная ей матрица <math>D + \rho uu^{T}</math>,
где <math>D = \begin{bmatrix} \Lambda_{1} & 0 \\ 0 & \Lambda_{2}\end{bmatrix}</math> - диагональная матрица,
<math>\rho = b_{m}</math> - число, а <math>u</math> - вектор.

Будем предполагать, не ограничивая общности, что диагональные элементы <math>d_{1}, \ldots, d_{n}</math> матрицы <math>D</math> упорядочены по убыванию: <math>d_{n} <= \ldots <=d_{1}</math>.

Чтобы найти собственные значения матрицы <math>D + \rho uu^{T}</math>, вычислим её характеристический многочлен, считая пока матрицу <math>D - \lambda I</math> невырожденной.
Тогда

<math>det(D + \rho uu^{T} - \lambda I) = det((D - \lambda I)(I + \rho (D- \lambda I)^{-1} uu^{T}))</math>.

Поскольку <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. Определитель такой матрицы легко вычислить.

'''Лемма 1.''' Справедливо равенство <math>det(I + xy^{T}) = 1 + y^{T}x</math>, где <math>x</math> и <math>y</math> - векторы.

Таким образом,

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

т.е. собственные значения матрицы <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>).

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

Можно видеть, что прямая <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> флопов.
Для собственных векторов матрицы <math>D + \rho uu^{T}</math> мы легко можем получить явные выражения.

'''Лемма 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> флопов.

Доказательство.

<math>(D + \rho uu^{T})[(D - \alpha I)^{-1}u] = (D - \alpha I + \alpha I + \rho uu^{T})(D - \alpha I)^{-1}u</math>

<math>=u + \alpha (D - \alpha I)^{-1}u + u[\rho u^{T}(D - \alpha I)^{-1}u] </math>

<math>=u + \alpha(D - \alpha I)^{-1}u - u</math>

поскольку <math> \rho u^{T}(D - \alpha I)^{-1}u + 1 = f(\alpha) = 0 </math>

<math>=\alpha [(D - \alpha I)^{-1}u]</math>, что и требовалось.

Для вычисления по этой простой формуле всех <math>n</math> собственных векторов требуется <math>O(n^{2})</math> флопов. К сожалению, формула не обеспечивает численной устойчивости, так как для двух очень близких значений <math>\alpha_{i}</math> может давать неортогональные приближенные собственные векторы <math>u_{i}</math>. Потребовалось целое десятилетие для того, чтобы найти устойчивую альтернативу исходному описанию алгоритма. Снова детали будут обсуждаться позднее в данном разделе.

Алгоритм является рекурсивным.

=== Дефляция ===

До сих пор полагалось, что все <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> достаточно мало.

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

== Вычислительное ядро алгоритма ==
Вычислительным ядром последовательной схемы решения является вычисление матрицы <math>Q</math> собственных векторов путём умножения матрицы <math>Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}</math> на матрицу <math>Q^{'}</math> Данная операция имеет сложность <math>cn^{3}</math> о чём и говорится в разделе [[#Последовательная сложность алгоритма]] .
Ей предшествует вычисление собственных значений и векторов матрицы <math> D + \rho uu^{T}</math>

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

[[File:DivideAndConquerTree.png|thumb|center|left|800px|Рис. 2. Дерево алгоритма "Разделяй и властвуй"]]

[[File:InfoGraph.jpg|thumb|center|1200px|Рис. 3. Детальное описание одного блока алгоритма]]

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

Предположим, что некоторое <math>u_{i}</math>, хотя и мало, все же недостаточно мало для того, чтобы была зарегистрирована дефляция. В этом случае применение метода Ньютона к решению векового уравнения встречается с затруднениями. Вспомним, что пересчет приближённого решения <math>u_{j}</math> уравнения <math>f(\lambda) = 0</math> в методе Ньютона основан на следующих положениях:

1. Вблизи точки <math>\lambda = \lambda_{j}</math> функция <math>f(\lambda)</math> аппроксимируется линейной функцией <math>l(\lambda)</math>; график есть прямая линия, касающаяся графика функции <math>f(\lambda)</math> при <math>\lambda = \lambda_{j}</math>.

2. В качестве <math>\lambda_{j+1}</math> берётся нуль этого линейного приближения, т.е. <math>l(\lambda_{j+1})=0</math>.

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

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

Чтобы найти выход из этого положения, можно модифицировать метод Ньютона следующим образом: раз <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>, также имеющую эти полюсы, т.е. функцию вида
<math>h(\lambda)= \frac{c_{1}}{d_{i}-\lambda} + \frac{c_{2}}{d_{i+1}-\lambda} + c_{3}</math>

Константы <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>, поскольку сводится к эквивалентному квадратному уравнению
<math>c_{1}(d_{i+1}-\lambda)+c_{2}(d_{i}-\lambda)+c_{3}(d_{i}-\lambda)(d_{i+1}-\lambda)=0</math>

Пусть <math>\lambda_{j}</math> - приближённое значение корня. определим <math>c_{1},c_{2}</math> и <math>c_{3}</math> так, чтобы
<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>

для <math>\lambda</math> в окрестности <math>\lambda_{j}</math>. Заметим, что

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

Если <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>, такие, что функция

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

Это означает, что гипербола, являющаяся графиком функции <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>

Подобным же образом выбираем <math>c_{2}</math> и <math>\hat{c_{2}}</math> так, чтобы функция

<math>h_{2}(\lambda) \equiv \hat{c_{2}} + \frac{c_{2}}{d_{i+1}-\lambda}</math>

Удовлетворяла условиям

<math>h_{2}(\lambda_{j}) = \psi_{2}(\lambda_{j})</math> и <math>h_{2}^{'}(\lambda_{j})=\psi_{2}^{'}(\lambda_{j})</math> (2)

Наконец, полагаем

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

<math>\equiv c_{3} + \frac{c_{1}}{d_{i}-\lambda} + \frac{c_{2}}{d_{i+1}-\lambda}</math>.

== Схема реализации последовательного алгоритма ==
''Вычисление собственных значений и собственных векторов симметричной трехдиагональной матрицы посредством стратегии "разделяй и властвуй"'':

''proc dc_eig''<math>(T,Q,\Lambda)...</math> по входной матрице <math>T</math> вычисляются выходные матрицы <math>Q</math> и <math>\Lambda</math>, такие, что <math>T = Q\Lambda Q^{T}</math>

'''Если <math>T</math> - матрица размера <math>1</math> x <math>1</math>'''

1. Присвоить выходным параметрам значения <math> Q = 1, \Lambda = T</math>

'''Иначе'''

1. Представить <math>T</math> в виде <math> T = \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T} </math>

2. ''call dc_eig''<math>(T_{1},Q_{1},\Lambda_{1})</math>

3. ''call dc_eig''<math>(T_{2},Q_{2},\Lambda_{2})</math>

4. Построить <math>D+\rho uu^{T}</math> по <math> \Lambda_{1},\Lambda_{2}, Q_{1}, Q_{2}</math>

5. Найти матрицу собственных значений <math>\Lambda</math>

6. Найти матрицу собственных векторов <math>Q^{'}</math> для матрицы <math>D+\rho uu^{T}</math>

7. Построить матрицу собственных векторов <math>Q</math> для матрицы <math>T</math> : <math> Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}* Q^{'} </math>

8. Присвоить выходным параметрам значения <math>Q</math> и <math>\Lambda</math>

'''endif'''

== Последовательная сложность алгоритма ==
Проанализируем сложность алгоритма. Пусть <math>t(n)</math> - число флопов при обработке матрицы размера <math> n x n</math> процедурой ''dc_eig''. Тогда

<math> t(n) = 2t(n/2) </math> два рекурсивных обращения к ''dc_eig''<math>(T_{i},Q_{i},\Lambda_{i})</math>

<math> +O(n^{2})</math> вычисление собственных значений матрицы <math>D+\rho uu^{T}</math>

<math> +O(n^{2})</math> вычисление собственных векторов матрицы <math>D+\rho uu^{T}</math>

<math> +c*n^{3}</math> вычисление матрицы <math>Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}*Q^{'}</math>

Если <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>

На практике константа <math>c</math> обычно гораздо меньше 1, потому что матрица <math>Q^{'}</math> весьма разрежена вследствие явления, называемого дефляцией.

== Информационный граф ==
В данном разделе представлен информационный граф алгоритма: на рисунке 5 изображена часть алгоритма, в которой происходит деление - "Divide", а на рисунке 6 описана часть "Conquer".

[[File:Infograph1.jpg|thumb|center|left|800px|Рис. 5. Информационный граф алгоритма "Разделяй и властвуй" - шаг Divide]]

[[File:Infograph2.jpg|thumb|center|1200px|Рис. 6. Информационный граф алгоритма "Разделяй и властвуй" - шаг Conquer. Qk*k - матрица собственных значений размерности k. Lk*k - матрица собственных векторов размерности k.]]

Операции:

<math>D</math> - операция Divide разделения матрицы <math> T </math> на матрицы <math>T_{1}</math> и <math>T_{2}</math>

Индексы - размерность

<math>S_{k}</math> - операция Conquer сбора матрицы <math> D </math>

<math> L_{k} </math> - операция поиска собственных значений

<math> S^{'} </math> - операция поиска собственных векторов матрицы <math> Q^{'} </math>

<math> S </math> - операция поиска собственных векторов матрицы <math> Q </math>

== Ресурс параллелизма алгоритма ==
Рассмотрев информационный граф алгоритма, можно заметить, что в структуре имеется два параллельных блока - вызов рекурсивных функций ''dc_eig'' для вычисления собственных значений и векторов матриц <math>T_{1}</math> и <math>T_{2}</math> - это единственная часть алгоритма, в которой мы прибегаем к параллелизму.

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

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

В случае реализации без параллелизма, функции ''dc_eig'' отрабатывают последовательно - сначала со входными параметрами <math>T_{1}, Q_{1}, \Lambda_{1}</math>, затем - <math>T_{2}, Q_{2}, \Lambda_{2}</math>.

Таким образом, благодаря параллелизму высота алгоритма параллельного составляет <math>log_{2}(n)</math>, когда как при последовательной реализации высота алгоритма равна сумме геометрической прогрессии <math>1+2+4+8+...+2^{n-1} = 2^{n} - 1</math>, что значительно сокращает число итераций алгоритма.

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

На вход алгоритму подаётся трёхдиагональная симметричная матрица:

<math>
L = \begin{bmatrix}
a_{1} & b_{1}&&&&& \\
b_{1} & \ddots & \ddots \\
& \ddots & a_{m-1} & b_{m-1} \\
&& b_{m-1} & a_{m} & b_{m} \\
&&& b_{m} & a_{m+1} & b_{m+1} \\
&&&& b_{m+1} & \ddots \\
&&&&&& \ddots & b_{n-1} \\
&&&&&& b_{n-1} & a_{n} \\
\end{bmatrix}
</math>

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

<math>2n + 1</math> - в силу симметрии, хранить следует только диагональные, поддиагональые и наддиагональные элементы.

'''Выходные данные:'''

На выходе мы получаем вектор собственных значений длины <math> n </math> и <math> n </math> собственных векторов длины <math> n </math> , соответствующих собственным значениям исходной матрицы.

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

<math> n + n^{2} = n(n + 1) </math>

== Свойства алгоритма ==
Описанный в данной статье алгоритм является самым быстрым алгоритмом, среди существующих: QR / Бисекция и обратная итерация / Разделяй и властвуй.

Последовательная сложность алгоритма: <math> t = c\frac{4}{3}n^{3} </math>

Параллельная сложность алгоритма (в силу использования дефляции): <math> O(n^{2.3})</math> или в самых редких случаях <math> O(n^{2}) </math> (см. [3] стр. 8).

Особенности алгоритма:

1. Использование дефляции ([[#Дефляция]])

2. Использование адаптированного метода Ньютона ([[#Макроструктура алгоритма]])

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

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

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

== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
Исследование проводилось на суперкомпьютере "Ломоносов" Суперкомпьютерного комплекса Московского университета.

Набор и границы значений изменяемых параметров запуска реализации алгоритма:

* число процессоров [1 : 8] (1,2,3,4,8);
* размер матрицы [4 : 8192].

[[File:ResultsDiagram.jpg|thumb|center|left|800px|Рис. 7. График времени работы программы в зависимости от числа процессов и размера задачи]]

Масштабируемость рассматриваемой реализации алгоритма '''"Разделяй и властвуй"''':

* При увеличении числа процессов общая эффективность программы увеличивается, т.к. время чтения и подготовки исходной матрицы остаётся неизменным, а время работы алгоритма уменьшается, однако рост незначительный.
* При увеличении размерности матрицы общая эффективность программы постепенно уменьшается, т.к. время чтения и подготовки исходных данных растёт быстрее, чем время работы исследуемого алгоритма.
* При одновременном увеличении как числа процессов, так и размерности матрицы общая эффективность программы уменьшается.

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

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

== Существующие реализации алгоритма ==
Описываемый метод реализован в пакете LAPACK, описание которого можно найти в [http://www.netlib.org/lapack/lawnspdf/lawn132.pdf этой статье] на страницах 7, 19 и 20, которая указана в списке литературы.

= Литература =
[1] Дж. Деммель, «Вычислительная линейная алгебра» //С. 230-235

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

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

[4] [https://en.wikipedia.org/wiki/Divide-and-conquer_eigenvalue_algorithm Алгоритм "Разделяй и властвуй" - Wikipedia]

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

[[en:Description of algorithm properties and structure]]

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

2016-11-18T11:41:43Z

IgorS: /* Статья Алгоритм кластеризации, основанный на минимальном покрывающем дереве */

= Статья [[Алгоритм кластеризации, основанный на минимальном покрывающем дереве]] =

* п.п. 2.4 дополнить текстом исследуемой программы--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:05, 16 ноября 2016 (MSK)
* следует добавить подробное описание условий, в которых производились эксперименты: характеристики программно-аппаратной платформы (какой компилятор, с какими опциями использовался, какие версии библиотек, на каких узлах проводился запуск и т.д.)--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:41, 18 ноября 2016 (MSK)

Участник:Kanast74/Алгоритм кластеризации, основанный на минимальном покрывающем дереве

2016-11-18T11:41:10Z

IgorS:

Статью подготовила: [[Участник:kanast74|Дмитриева Анастасия Владимировна]].

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

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

Кластеризация - это задача статистического анализа, состоящая в разбиении множества объектов на группы, называемые кластерами, внутри которых объекты обладают одними и теми же свойствами (чаще всего, это означает близость относительно заданной метрики). Основное отличие от задачи классификации состоит в том, что группы заранее не заданы и определяются в процессе работы алгоритма.

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

Пусть на начальном этапе решения задачи имеются набор тестовых примеров <math>X=\{x_1...x_n\}</math>, а также функция расстояния между ними <math>r(e)</math>. Отметим, что метрика, в которой вычисляются расстояния между объектами, выбирается исходя из требований задачи; наиболее распространенные - это Евклидово расстояние, квадрат Евклидова расстояния, манхэттенская метрика, расстояние Чебышева и степенное расстояние. Далее необходимо применить один из алгоритмов кластеризации, которые можно разделить на две категории: иерархические, состоящие в последовательном поиске кластеров из уже найденных кластеров, а также неиерархические, цель которых состоит в минимизации некоторой целевой функции. К последней группе относятся такие алгоритмы, как алгоритм k-средних, алгоритм EM, нечеткие алгоритмы, а также алгоритмы теории графов, к категории которых относится алгоритм, описываемый в данной статье.

Рассмотрим алгоритм кластеризации на k кластеров, основанный на построении минимального остовного дерева (MST) и который состоит в следующем:

# По исходным данным строится взвешенный неориентированный граф: каждый объект представляется в виде вершины графа, а вес ребра, связывающего две вершины, есть расстояние между объектами в выбранной заранее метрике
# Для полученного графа строится минимальное остовное дерево, то есть дерево, содержащее все вершины графа и имеющее минимальный суммарный вес своих ребер
# Удаляется k-1 ребро минимального остовного дерева с максимальным весом
# Получаются k компонент связности, которые интерпретируются как кластеры

Для построения минимального остовного дерева могут быть использованы различные алгоритмы, среди которых наиболее распространены:

# Алгоритм Крускала
# Алгоритм Борувки
# Алгоритм Прима

Отметим, что в рамках проведенного исследования использовался алгоритм Крускала<nowiki>, наиболее подробно изучить который можно, пройдя по ссылке [</nowiki>[https://algowiki-project.org/ru/Алгоритм_Крускала Алгоритм Крускала]], поэтому в данной статье его описание не приводится.

=== Математическое описание алгоритма ===
С математической точки зрения задачу кластеризации можно рассматривать как минимизацию среднего внутрикластерного расстояния <math> \frac{\sum_{i<j, c(x_i)=c(x_j)} r(x_i,x_j)}{\sum_{i<j, c(x_i)=c(x_j)} 1} \to min </math> с одной стороны и максимизации межкластерного расстояния <math> \frac{\sum_{i<j, c(x_i)\neq c(x_j)} r(x_i,x_j)}{\sum_{i<j, c(x_i) \neq c(x_j)} 1} \to max </math> с другой стороны, где <math>c(x)</math> - кластер, к которому принадлежит объект <math>x</math>.

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

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

Вычислительным ядром описываемого алгоритма является построение минимального остовного дерева. В случае, если программа предполагается быть распараллеленной, то операция построения MST будет производиться в отдельности в каждом процессе. Как уже было отмечено, в данном исследовании для построения MST использовался алгоритм Крускала, который будет работать наиболее эффективно, если веса ребер исходного графа отсортированы, поэтому сортировка - это еще одна операция, которая должна быть включена в вычислительное ядро, что предполагает выбранная ревлизация алгоритма. Поэтому в дальнейшем мы не будем разделять сортировку и поиск минимального остовного дерева, предполагая, что они объеденены в единый эффективный алгоритм.

Дадим некоторую справку касательно адгоритма поиска MST, фигурирующего в данном исследовании. Алгоритм Крускала — алгоритм построения минимального остовного дерева взвешенного связного неориентированного графа. Алгоритм впервые описан Джозефом Крускалом в 1956 году.

Алгоритм Крускала находит безопасное ребро для добавления в растущий лес путем поиска ребра <math>(u, v)</math> с минимальным весом среди всех ребер, соединяющих два дерева в лесу. Обозначим два дерева, соединяемые ребром <math>(u, v) </math>, как <math>C_1</math> и <math>C_2</math>. <math>(u, v)</math> — безопасное для <math>C_1</math> ребро. Алгоритм Крускала является жадным, поскольку на каждом шаге он добавляет к лесу ребро с минимально возможным весом.

=== Макроструктура алгоритма ===
# Построение графа путем задания списков ребер. В общем случае, когда задано некоторое множество объектов, для построения графа может быть использован алгоритм, позволяющий рассчитать расстояние от каждого объекта до каждого за <math>O(n^2)</math> операций, где <math>n</math> число объектов (вообще говоря, данная операция требует <math>O(E)</math> операций, где <math>E</math> - число ребер в графе, но в нашем случае число ребер подразумевается равным <math>E=\frac{D (n(n-1))}{2}</math>, <math>D</math> - плотность графа). Однако в рамках данного исследования для тестирования алгоритма использовалась такая технология построения графов, когда в качестве веса каждого ребра назначается некоторое произвольное число из заданного промежутка (например, от 1 до 1000), что также требует <math>O(n^2)</math>
# Построение минимального остовного дерева на основании полученного ранее графа, для чего может быть использован один из известных и наиболее распространенных алгоритмов (алгоритм Крускала, алгоритм Борувки или алгоритм Прима). Рассмотрим, например, алгоритм Крускала. На начальном этапе имеется граф, состоящий из вершин - объектов исходной выборки и не содержащий ребер, следовательно, каждая из вершин изначально представляет собой компоненту связности и даже дерево. Алгоритм состоит в выборе на каждом шаге ребра с минимальным весом и добавлении его в дерево, если оно соединяет два дерева. Алгоритм будет работать максимально эффективно, если изначально ребра графа, полученного на первом шаге будут отсортированы (например, по возрастанию).
# Для получения <math>k</math> кластеров необходимо удалить из получившегося минимального остовного дерева <math>k-1</math> ребро с максимальным весом. В частности, в случае, если на предыдущем шаге мы пользовались алгоритмом Крускала для построения MST, ребра получившегося дерева отсортированы по возрастанию, значит для удаления указанных выше ребер потребуется лишь <math>O(1)</math> операций
# Наконец, необходимо правильно интерпретировать результат работы алгоритма и перечислить вершины, принадлежащие полученным кластерам; на выполнение данного шага может потребоваться различное число операций в зависимости от формата выходных данных программы: например, в данной реализации выходные данные, как будет сказано в дальнейшем, представлены в виде списка ребер, формирующий итоговый минимальный остовный лес, следовательно в общем случае на его обработку потребуется <math>O(V)</math> операций

==== Используемые обозначения и структуры данных ====

Обозначим в качестве <math>G=(V,E)</math> граф, содержащий <math>V</math> вершин и <math>E</math> ребер. Для построения минимального остовного дерева для данного графа используются три операции [2], опишем здесь каждую из них:

# операция MakeSet(<math>v</math>) генерирует дерево (множество) для вершины графа <math>v</math>, являющейся корнем искомого дерева
# операция Find(<math>v</math>) определяет, которому из деревьев принадлежит интересующая вершина <math>v</math>. Условимся, что данная операция возвращает ту вершину, которая является корнем искомого дерева
# операция Union(<math>u, v</math>) объединяет два множества (два дерева, содержащих соответствующие вершины) под одним корнем

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

Приведем здесь псевдокод основной части алгоритма - а именно построения локального минимального остовного дерева при помощи алгоритма Крускала.

Kruskal ( G=(V,E) ):

1. mst = ∅;

2. сортировать E по возрастанию;

3. для каждой вершины v из множества вершин V:

4. MakeSet(v);

5. для каждого ребра e = (u, v) из множества ребер E:

6. if Find(u) ≠ Find(v):

7. mst = mst ∪ { (u,v) };

8. Union(u, v);

9. return mst;

=== Последовательная сложность алгоритма ===
Сперва оценим последовательную сложность составных частей алгоритма.

0. O(E): Формирование графа

1. O(1): Инициализация пустого множества.

2. O(Elog(E)): сортировка ребер из множества E.

3. O(V): Инициализация одноточечного множества для каждой вершины из V.

4. ▲ MakeSet за O(1).

5. O(Elog(V)): Операции Union и Find для каждого ребра из E.

6. ▲ Find за O(1).

7. ▲ Присоединение элемента за O(1).

8. ▲ Union за O(log(V)).

9. O(1): Удаление k-1 ребра для получения k компонент связности

10. O(V): Перечисление вершин, входящих в соответствующие кластеры

11. O(1): Return.

Таким образом, с учетом того, что, получаем:

<math>T( G = (V, E) ) = O(1) + O(E\log(E)) + O(V) + O(E\log(V)) + O(E) = O(E\log(E)) + O(E\log(V)) = O(E\log(V)) + O(E\log(V))</math>

Итак, оценка сложности алгоритма есть <math>T( G = (V, E) ) = O(E\log(V)) + O(\log(V))</math>

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

[[file:Clustering kruskal.png|thumb|center|1400px|Рисунок 1. Информационный граф алгоритма]]

По структуре информационного графа можно сделать вывод что высота канонической ярусно-параллельной формы [1] есть <math>\log{p}</math>, где <math>p</math> число процессов.

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

Описанный алгоритм позволяет произвести распараллеливание, источник которого будет описан в данном пункте. Прежде всего, необходимо отметить, что данный алгоритм допускает преобразование в гибридную параллельную версию, а именно версию с использованием технологий MPI и OpenMP.

Тем не менее, прежде всего следует установить справедливость свойства используемого алгоритма поиска MST, позволяющего произвести его распараллеливание [3]:

'''Ассоциативность по рёбрам'''. Пусть <math>MSF(E)</math> – минимальный остовный лес графа с рёбрами <math>E</math>. Тогда
:<math>
MSF(E_1 \cup E_2 \cup \dots \cup E_k) = MSF(MSF(E_1) \cup MSF(E_2) \cup \dots \cup MSF(E_k)).
</math>

В том случае, когда все объекты заранее известны, и между ними можно рассчитать все попарные расстояния, первый шаг - построение графа - позволяет произвести распараллеливание при помощи обеих вышеуказанных технологий, а именно: разделить объекты между процессами при помощи MPI, а внутри каждой из полученных групп будем рассчитывать попарные расстояния параллельно на нескольких ядрах, использовав технологию OpenMP. Однако в данном исследовании кластеризуемые объекты предполагались заранее неизвестными, так как попарные расстояния между объектами задаются случайным образом, а это означает, что произвести распараллеливание этого шага, которое бы дало хотя бы небольшое ускорение (уменьшение времени работы), не получится.

Если все же объекты заранее были известны, можно сохранить полученную на предыдущем этапе группировку их на отдельные процессы и внутри каждого произвести сортировку расстояний между объектами по возрастанию при помощи алгоритма QSort с использованием технологии OpenMP (в противном случае параллельная структура алгоритма поддерживается начиная с этого шага).

Далее внутри каждой группы объектов (каждый процесс в отдельности) строим минимальное остовное дерево, в конце шага деревья объединяются в одно - общее MST для всех объектов, поддерживая при этом отсортированность расстояний по возрастанию.

Наконец, будем удалять необходимое количество ребер глобального остовного дерева для того, чтобы получить требуемое количество кластеров - компонент связности графа.

==== Стратегии распараллеливания ====
Необходимо отметить, что несмотря на всю простоту идеи распараллеливания алгоритма, описанную выше, существует несколько стратегий реализовать ее на практике. При этом, как будет показано далее, указанные стратегии дают различные приросты в производительности. Перечислим некоторые из них:

# первая стратегия, наиболее очевидная, состоит в том, чтобы в самом начале главный процесс считывает данные о ребрах и распределяет считанную информацию между остальными процессами, не имеющим доступа к файлу с исходными данными. Далее каждый из процессов рассчитывает локальное минимальное остовное дерево и передает его обратно главному процессу, который объединяет деревья в одно, глобальное
# вторая стратегия во многом напоминает первую, но основное различие между ними состоит в том, что во втором случае файл с исходными данными не разделяется между процессами, а является доступным для каждого из них в полном объеме. Таким образом, каждый процесс способен считать данные о ребрах, за которые они отвечают, самостоятельно, что значительно снижает объем коммуникации между процессами. Также еще одно улучшение состоит в том, что теперь главный процесс не простаивает во время работы остальных, а, как и остальные, рассчитывает локальное минимальное остовное дерево
# наконец, третья стратегия состоит в том, чтобы оптимизировать процесс слияния локальных минимальных остовных деревьев. Предлагается сделать так, чтобы не только главный процесс занимался слиянием, но каждый процесс участвует в процессе слияния. Для того, чтобы добиться максимальной эффективности будем предполагать, что число процессов <math>p=2^n,n>1</math>. В этом случае потребуется <math>\log{p}</math> шагов, чтобы выполнить слияние. На каждом шаге половина активных процессов пересылает свое локальное дерево процессу с меньшим номером на единицу, а другая половина занимается приемом и слиянием. Таким образом, через <math> \log{p} </math> шагов главный процесс, который имеет номер 0, будет иметь в своем распоряжении глобальное минимальное остовное дерево.

==== Способы разделения графа ====

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

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

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

По исходным данным формируется граф <math>G = (V, E)</math>, являющийся неориентированным, взвешенным, связным и не имеющим кратных ребер. Пусть полученный граф содержит <math> |V|</math> вершин и <math>|E|</math> ребер. Предполагая, что каждый объект можно сравнить с каждым, можно считать, что получаемый граф является полным, а значит число ребер может быть оценено следующим образом: <math>|E|=\frac{|V|(|V|-1)}{2} \le \frac{|V|^2}{2}-\frac{|V|}{2} \Rightarrow O(E)=O(V^2)</math>

Обозначим в виде <math>w(u,v)</math> вес ребра, соединяющего вершины <math>u</math> и <math>v</math>. Тогда граф может быть задан в виде списка ребер, а именно списка троек: <math>(u,v,w(u,v))</math>, что является более удобным представлением графа для реализации многих алгоритмов по сравнению с матрицей смежности. Помимо этого, данный способ помогает сэкономить память. Недостатков указанного подхода является только то, что установить, с какими вершинами связана интересующая вершина, а также вес соответствующих ребер является весьма затруднительно. Однако для решения поставленной задачи нам это и не потребуется.

Формат выходных данных аналогичный

=== Свойства алгоритма ===
==== Вычислительная мощность ====
Оценим вычислительную мощность алгоритма в том случае, когда для его реализации используется <math>p</math> процессов. Предположим, что алгоритм реализован при помощи первой стратегии (см. выше) и применяется к графу <math>G = (V, E)</math>, тогда:

* Ввод данных: <math>\frac{|E|}{p}</math> - в среднем столько ребер содержит получаемый каждым процессом связный подграф
* Вывод данных: <math>\frac{|V| - 1}{p}</math> - каждый из процессов должен вывести посчитанное локальное минимальное дерево, которое содержит указанное количество ребер, так как остальные ребра, изначально входившие в состав подграфа, не будут входит в локальное MST
* Вычисление: для вычисления локального MST каждому из процессов требуется <math>\frac{|E|}{p} \log{\frac{|V|}{p}}</math> операций

Таким образом, искомое соотношение может быть записано в следующем виде: <math>\frac{\frac{|E|}{p} \log{\frac{|V|}{p}}}{\frac{|E|}{p} + \frac{|V| - 1}{p}} = \frac{|E| \log{\frac{|V|}{p}}}{|E|+|V|-1}</math>

На основании полученной формулы можно сделать несколько выводов:

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

==== Оценка прироста в производительности ====
===== Закон Амдала =====

В данном рзеделе будет производиться оценка прироста производительности параллельного алгоритма по сравнению с последовательным. Наиболее простой способ оценить прирост производительности – использовать закон Амдала, который гласит, что прирост может быть оценен следующим образом: <math> S_p \le \frac{1}{f+\frac{1-f}{p}}</math>,

где <math>f</math> – часть алгоритма, которая не может быть распараллелена, <math>p</math> – число процессов.

В наиболее тривиальном случае (первая стратегия распараллеливания) распараллеливанию не подлежит считывание входных данных и их разделение между процессами, а также объединение локальных MST в одно. Поэтому сложность последовательной части программы может быть оценена следующим образом: <math>2O(V^2)+O(V^2 \log{V})</math>. Распараллеливанию подлежит инициализация подграфов при помощи операции MakeSet за <math>O(V)</math>, сортировка ребер по возрастанию внутри каждой группы за <math>O(V^2 \log{V})</math>, а также построение локальных минимальных остовных деревьев за аналогичное время. Поэтому сложность параллельной части алгоритма может быть оценена так: <math>O(V)+2 O(V^2 \log{V})</math>. Таким образом, вычислив отношение сложностей частей программы, получаем, что <math>f=0.44</math>. Устремим число процессов <math>p</math> к бесконечности и получим, что максимальное ускорение, которое можно получить путем распараллеливания алгоритма есть <math>2.27</math>. К сожалению, данная оценка не является точной. Для того, чтобы оценить прирост производительности более качественно, произведем анализ временных диаграмм программы.

===== Анализ временных диаграмм =====

Обозначим за <math>t_d</math> – время, которое требуется для того, чтобы разделить граф на подграфы, <math>t_p</math> – суммарное время вычислений, <math>t_b</math> – время обратной пересылки локально полученных результатов, <math>t_l</math> – задержка одной пересылки. Причем можно убедиться в том, что <math>t_p > t_d > t_b > t_l</math>, также известно, что время выполнения последовательного кода <math>t_{serial} = t_p</math>.

[[Файл:FirstStrategy.PNG|thumb|center|400px|Рисунок 2. Первая стратегия распараллеливания вычислительного ядра алгоритма]]
Произведем анализ первой (наивной) стратегии распараллеливания программы. На временной диаграмме жирным обозначен критический путь, время выполнения которого может быть вычислено по формуле (см: [2]):
<math>t_{paralel} = 4 t_l + t_d + \frac{t_p}{3} + \frac{t_b}{3}</math>

Тогда максимальное ускорение для одного процесса есть: <math>speedup=\frac{t_{serial}}{t_{parallel}} = \frac{t_p}{4 t_l + t_d + \frac{t_p}{3} + \frac{t_b}{3}}</math>

А в случае n процессов: <math>speedup = \frac{n}{1+\frac{n (n+1) t_l + n t_d + t_b}{t_p}}</math>

[[Файл:SecondStrategy.PNG|thumb|center|400px|Рисунок 3. Вторая стратегия распараллеливания вычислительного ядра алгоритма]]
Теперь проанализируем вторую стратегию, основная задача которой – уменьшить объем коммуникаций между процессами за счет того, что файл с исходными данными теперь доступен всем процессам. Помимо этого введем в рассмотрение новую величину <math>t_i</math> – время, требующееся на инициализацию множеств вершин. Тогда для одного процесса <math>t_{parallel} = t_i + \frac{t_p}{4} + t_l + 3 \frac{t_b}{4}</math>, а максимальное ускорение в случае n процессов есть: <math>speedup= \frac{t_{serial}}{t_{parallel}} = \frac{4}{1+\frac{4 t_i + 4 t_l + 3 t_b}{t_p}}</math>

[[Файл:ThirdStrategy.PNG|thumb|center|400px|Рисунок 4. Третья стратегия распараллеливания вычислительного ядра алгоритма]]
Наконец, проанализируем третью стратегию, основная цель которой – оптимизировать процесс слияния локальных минимальных остовных деревьев, а также привлечь все активные процессы (включая главный) к процессу построения локального MST. В этом случае время выполнения параллельной части программы с использованием лишь одного процесса: <math> t_{parallel}=t_i + \frac{t_p}{4} + t_l + 2 \frac{t_b}{4}</math>, а суммарное ускорение в общем случае: <math>speedup=\frac{t_{serial}}{t_{parallel}} = \frac{n}{1+\frac{n t_i + n t_l + \log_2{n} t_b}{t_p}}</math>

На рисунке 5 приведены графики, отражающие зависимость получаемых возможных ускорений в зависимости от числа задействованных процессов, посчитанные с использованием четырех различных подходов.
[[Файл:Comparison.PNG|thumb|center|400px|Рисунок 5. Сравнение стратегий распараллеливания]]

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===

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

# первая стратегия, наиболее очевидная, состоит в том, чтобы в самом начале главный процесс считал данные о ребрах и распределил считанную информацию между остальными процессами, причем каждый из них не имеет доступа к файлу с данными. Далее каждый из процессов рассчитывает локальное минимальное остовное дерево и передает его обратно главному процессу, который объединяет деревья в одно, глобальное
# вторая стратегия во многом напоминает первую, но основное различие между ними состоит в том, что во втором случае файл с исходными данными не разделяется между процессами, а является доступным для каждого из них в полном объеме. Таким образом, каждый процесс способен считать данные о ребрах, за которые они отвечают, самостоятельно, что значительно снижает объем коммуникации между процессами. Также еще одно улучшение состоит в том, что теперь главный процесс не простаивает во время работы остальных, а, как и остальные, рассчитывает локальное минимальное остовное дерево
# наконец, третья стратегия состоит в том, чтобы оптимизировать процесс слияния локальных минимальных остовных деревьев. Предлагается сделать так, чтобы не только главный процесс занимался слиянием, но каждый процесс участвует в процессе слияния. Для того, чтобы добиться максимальной эффективности будем предполагать, что число процессов <math>p=2^n,n>1</math>. В этом случае потребуется <math>\log{p}</math> шагов, чтобы выполнить слияние. На каждом шаге половина активных процессов пересылает свое локальное дерево процессу с меньшим номером на единицу, а другая половина занимается приемом и слиянием. Таким образом, через шагов главный процесс, который имеет номер 0, будет иметь в своем распоряжении глобальное минимальное остовное дерево.

=== Масштабируемость алгоритма и его реализации ===
[[file:Total.png|thumb|center|400px|Рисунок 6. График зависимости времени вычисления от размера задачи и числа процессов (с учетом времени ввода-вывода)]]
[[file:Wo_io.png|thumb|center|400px|Рисунок 7. График зависимости времени вычисления от размера задачи и числа процессов (без учета времени ввода-вывода)]]

На графиках видно, как с увеличением объема вычислительных ресурсов происходит прирост в производительности. Данный эффект происходит до некоторых пор, после чего накладные расходы на коммуникацию между процессами нивелируют его. При дальнейшем увеличении числа процессов время решения задачи заметно увеличивается, однако, ввиду длинных очередей на суперкомпьютере Ломоносов данные с числом процессов <math> \ge 256</math> получить не удалось

Исходный код, запускавшийся на суперкомпьютере Ломоносов-1:

[[Файл:Source codes.docx]]

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма [3]===
* C++: [http://www.boost.org/libs/graph/doc/ Boost Graph Library] (функция <code>[http://www.boost.org/libs/graph/doc/kruskal_min_spanning_tree.html kruskal_min_spanning_tree]</code>).
* C++, MPI: [http://www.boost.org/libs/graph_parallel/doc/html/index.html Parallel Boost Graph Library]
** функция <code>[http://www.boost.org/libs/graph_parallel/doc/html/dehne_gotz_min_spanning_tree.html#merge-local-minimum-spanning-trees merge_local_minimum_spanning_trees]</code> реализует алгоритм Крускала;
** функции <code>[http://www.boost.org/libs/graph_parallel/doc/html/dehne_gotz_min_spanning_tree.html#dense-boruvka-minimum-spanning-tree dense_boruvka_minimum_spanning_tree]</code>, <code>[http://www.boost.org/libs/graph_parallel/doc/html/dehne_gotz_min_spanning_tree.html#boruvka-then-merge boruvka_then_merge]</code>, <code>[http://www.boost.org/libs/graph_parallel/doc/html/dehne_gotz_min_spanning_tree.html#boruvka-mixed-merge boruvka_mixed_merge]</code> сочетают [[алгоритм Борувки]] и алгоритм Крускала.
* Python: [https://networkx.github.io NetworkX] (функция <code>[http://networkx.github.io/documentation/networkx-1.9.1/reference/generated/networkx.algorithms.mst.minimum_spanning_tree.html minimum_spanning_tree]</code>).
* Java: [http://jgrapht.org JGraphT] (класс <code>[http://jgrapht.org/javadoc/org/jgrapht/alg/KruskalMinimumSpanningTree.html KruskalMinimumSpanningTree]</code>).

= Литература =
[1] Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.

[2] http://www.gpiskas.com/pdf/kruskal_mpi.pdf (дата обращения: 02.10.2016)

[3] https://algowiki-project.org/ru/Алгоритм_Крускала

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

2016-11-18T11:40:03Z

IgorS:

=== Замечания к статье ===

* содержание не соответствуют шаблону описания алгоритма: неверная нумерация, отсутствуют п.п.--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 15:30, 25 октября 2016 (MSK)
* не указан конкретный вклад каждого автора--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 15:30, 25 октября 2016 (MSK)
* п.п. 1.9 не раскрыт--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 15:30, 25 октября 2016 (MSK)
* п.п. 2.4 дополнить кодом исследуемой программы--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 13:52, 16 ноября 2016 (MSK)
* следует добавить подробное описание условия, в которых производились эксперименты: характеристики программно-аппаратной платформы (какой компилятор, с какими опциями использовался, какие версии библиотек, на каких узлах проводился запуск и т.д.)--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:40, 18 ноября 2016 (MSK)

== Замечания к статье "Алгоритм быстрого дискретного преобразования Фурье" ==

* Раздел 1.1 - вместо общего описания алгоритма написано именно что математическое описание. В общем описании должна быть поставлена задача и изложена основная идея, с минимумом формул [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 14:08, 11 ноября 2016 (MSK)
* Раздел 1.2 - не очень ясны слова про "проиллюстрированные на рисунке 2 в разделе Информационный граф". Раздел "Информационный граф" содержит рисунок 1. [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 14:08, 11 ноября 2016 (MSK)
* Если упоминаем рекурсию, нужны слова о глубине рекурсии [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 14:08, 11 ноября 2016 (MSK)

Участник:Vagabond/Алгоритм быстрого дискретного пребразования Фурье

2016-11-18T11:38:44Z

IgorS:

'''Автор''': Данилишин А.Р.
= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Пусть <math>X=(x_{1},...,x_{n-1})^{T}</math> - исходный сигнал, который необходимо преобразовать умножением на тензор второго ранга <math>E_{pk}=e^{\frac{-2kpi\pi}{n}} </math>. Результатом данного преобразования (<math>E*X</math>) будет вектор <math>Y=(y_{1},...,y_{n-1})^{T}</math>, где <math> y_{p}=\sum_{k=0}^{n-1}x_{k}e^{\frac{-2kpi\pi}{n}}, p=\overline{0,n-1}</math>. Данная формула является классической формулой ДПФ. Известно, что в общем случае умножение матрицы на вектор требует <math>O(n^{2})</math> арифметических операций, поэтому возникает вопрос о сокращении данного количества.

Главная идея БПФ состоит в сокращении многочисленных повторов сложения и умножения, которые выполняются в ДПФ (повторяющиеся множители: <math>e^{\frac{-2kpi\pi}{n}}</math> Например при условии, что <math>(pk)mod(n)=const</math>, при всех <math>k=\overline{0,n-1}</math> и <math>p=\overline{0,n-1}</math>

За счет использования данного факта, происходит значительное сокращение количества вычислительных операций. В данной статье используется алгоритм Cooley – Tukey, который предполагает собой разбиение исходного множества входных сигналов на два равных подмножества. При этом множество входных сигналов должно быть степенью двойки. Далее операция деления множества продолжается для образовавшихся подмножеств, и так далее. В результате над каждым из полученных подмножеств выполняется БПФ. Данные вычисления можно выполнять независимо друг от друга. Этот факт используется для реализации параллельной версии алгоритма.

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

*Пусть <math>e^{\frac{-2kpi\pi}{n}}</math> = <math>\omega _{n}^{kp}</math>.
*Разобьем исходный сигнал <math>x(n)</math> на два подмножества, с четными <math>x_{1}(2n)</math> и нечетными <math>x_{2}(2n+1)</math> номерами.
Тогда получаем: <math>y_{p}=\sum_{k=0}^{n-1}x_{k}\omega _{n}^{kp}= \sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega _{n}^{2kp}+\sum_{k=0}^{\frac{n}{2}-1}x_{2k+1}\omega _{n}^{(2k+1)p}</math>.

Выпишем два свойства омеги:
*<math>\omega_{\frac{n}{2}}=e^{2(\frac{-2i\pi}{n})}=\omega_{n}^{2}</math>
*<math>\omega_{n}^{\frac{n}{2}}=e^{\frac{-2ni\pi}{2n}}=e^{-i\pi}=-1</math>
Воспользуемся первым: <math>y_{p}= \sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega _{n}^{2kp}+\omega_{n}^{p}\sum_{k=0}^{\frac{n}{2}-1}x_{2k+1}\omega _{n}^{2kp}=\sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega _{\frac{n}{2}}^{kp}+\omega_{n}^{p}\sum_{k=0}^{\frac{n}{2}-1}x_{2k+1}\omega _{\frac{n}{2}}^{kp}</math>. Или, если обозначить <math>y_{1}(p)=\sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega _{\frac{n}{2}}^{kp}</math>, а <math>y_{2}(p)=\sum_{k=0}^{\frac{n}{2}-1}x_{2k+1}\omega _{\frac{n}{2}}^{kp}</math>, то получим формулу для вычисления координат изображения БПФ при <math>p=\overline{0...n/2}</math>: <math>y_(p)=y_{1}(p)+\omega_{n}^{p}y_{2}(p)</math>.

Заметим, что <math>y(p); y_{1}(p); y_{2}(p)</math> обладают свойством периодичности, с периодом <math>\frac{n}{2}</math>. Покажем это для <math>y_{1}(p)</math> : <math>y_{1}(p+\frac{n}{2})=\sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega_{\frac{n}{2}}^{k(p+\frac{n}{2})}=\sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega_{\frac{n}{2}}^{kp}\omega_{\frac{n}{2}}^{\frac{kn}{2}}=\sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega_{\frac{n}{2}}^{kp}</math>

Так как: <math>\omega_{\frac{n}{2}}^{\frac{kn}{2}}=e^{\frac{-4kni\pi}{2n}}=e^{-2ki\pi}=1</math>

Далее необходимо определить <math>y(p)</math> при <math>p\geq \frac{n}{2}</math>. Теперь воспользуемся свойством периодичности обнаруженными нами ранее: <math>y(p+\frac{n}{2})=y_{1}(p+\frac{n}{2})+\omega_{n}^{(p+\frac{n}{2})}y_{2}(p+\frac{n}{2})</math>. Воспользуемся вторым свойством омеги: <math>y(p)=y_{1}(p)-\omega_{n}^{p}y_{2}(p)</math>. Все выкладки, приведенные выше, относятся ко второму этапу алгоритма Cooley – Tukey, который был использован в данной статье. Последующие шаги данного этапа делят подмножества полученные на предыдущем шаге вычисления БПФ.

В конечном итоге вышеупомянутый алгоритм сводится к двум этапам:

'''Бит-реверсирование'''

Бит-реверсирование – это преобразование двоичного числа путем изменения порядка следования бит в нем на противоположный. Бит-реверсирование применимо только к индексам элементов массива и предназначено для изменения порядка следования этих элементов, при этом значения самих элементов не изменяются. Так, к примеру, четырехмерный вектор <math>(x_{0},x_{1},x_{2},x_{3})</math> изменится на <math>(x_{0},x_{2},x_{1},x_{3})</math>. Данная процедура необходима для разделения исходного сигнала на элементы подмножеств с четными и нечетными номерами, которые необходимы для вычисления <math>y_{1}(p)</math> и <math>y_{2}(p)</math>.

'''Вычисление БПФ'''

После выполнения этапа бит-реверсирования выполняются вычисления проиллюстрированные ''на рисунке 1'' в разделе [[#Информационный граф|Информационный граф]]. Рисунок 1 приведен для случая четырехмерного входного сигнала. Он предполагает совершение двух этапов. В общем же количество этапов равно <math>log_{2}n</math>. Каждый этап содержит в себе вычисление одной и той же операции "бабочки", где на вход подаются два числа <math>a</math> и <math>b</math>, на выходе же получаются <math>a+bU</math> и <math>a-bU</math>, где <math>U</math>- это ''коэффициент поворота''. Общая формула для коэффициента поворота: <math>e^{\frac{-ji\pi}{k}}</math>, где <math>k</math>- размер шага "бабочки", <math>j</math>- номер итерации вычислений над группой элементов, размером <math>2k</math> <math>(0\leq j < k )</math>.

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

Из двух вышеописанных этапов БПФ, бит-реверсирование является самым быстровыполнимым. Поэтому вычислительное ядро алгоритма будет лежать именно во втором этапе. А именно, им будет являться вычисление "бабочек". Количество этапов выполнения БПФ, как описывалось выше, равно <math>log_{2}n</math>. Учитывая количество этапов, размерность входного сигнала и идею деления на подмножества, всего "бабочек" получается <math>\frac{nlog_{2}n}{2}</math>. При этом операция умножения выполняется <math>\frac{n}{2}</math> раз. Это связано с тем, что результаты вычисления "бабочки" <math>a+bU</math> и <math>a-bU</math>.

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

Из всего вышесказанного заключаем, что макроструктуру алгоритма легче всего описать при помощи рекурсии:
*<math>\frac{n}{2}</math> преобразований Фурье порядка 2
*умножение <math>\frac{n}{2}</math> пар комплексных чисел
*<math>n</math> комплексных сложений
*снова преобразование Фурье
Также необходимо заметить, что количеством рекурсий будет количество этапов выполнения БПФ, то есть глубина рекурсии будет равняться <math>log_{2}n</math>

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

Программный код (описан на языке С++) строится из ряда функций:
*бит-реверсирование
*инициализация размерности входного сигнала
*инициализация входного сигнала (при помощи генератора случайных чисел)
*процесс очистки памяти
*выполнение операции "бабочка"
*выполнение БПФ
*функция вывода результата (для тестирования)
----
'''главный программный код БПФ:'''
<source lang="С++">
int main()
{
complex<double> *inputSignal = NULL;
complex<double> *outputSignal = NULL;
int size = 0;
cout << "FFT. Serial version." << endl;
ProcessInitialization(inputSignal, outputSignal, size);
bit(inputSignal, outputSignal, size);
SerialFFTCalculation(outputSignal, size);
PrintSignal(outputSignal, size); //в случае тестирования
ProcessTermination(inputSignal, outputSignal);
cin.get();
}
</source>
----
=== функция бит-реверсирования ===
<source lang="С++">
void bit(complex<double> inputSignal[], complex<double> *outputSignal, int size)
{ // процесс бит-реверсирования
int j = 0, i = 0;
while (i < size)
{
if (j > i)
{
outputSignal[i] = inputSignal[j];
outputSignal[j] = inputSignal[i];
}
else
if (j == i)
outputSignal[i] = inputSignal[i];

int m = size >> 1;
while ((m >= 1) && (j >= m))
{
j -= m;
m = m >> 1;
}
j += m;
i++;
}
}
</source>
=== инициализация размерности входного сигнала ===
<source lang="С++">
void ProcessInitialization(complex<double>* &inputSignal, complex<double>* &outputSignal, int &size)
{
// инициализация размера входного сигнала
do
{
cout << "Enter the input signal length: ";
cin >> size;
if (size < 4)
cout << "Input signal length should be >= 4" << endl;
else
{
int tmpSize = size;
while (tmpSize != 1)
{
if (tmpSize % 2 != 0)
{
cout << "Input signal length should be powers of two" << endl;
size = -1;
break;
}
tmpSize /= 2;
}
}
}
while (size < 4);
cout << "Input signal length = " << size << endl;
inputSignal = new complex<double>[size];
outputSignal = new complex<double>[size];
DummyDataInitialization(inputSignal, size);
}
</source>
=== инициализация входного сигнала ===
<source lang="С++">
void DummyDataInitialization(complex<double>* mas, int size)
{
for (int i = 0; i < size; i++)
{
mas[i] = int(rand() % 100);
}
}
</source>
=== процесс очистки памяти ===
<source lang="С++">
void ProcessTermination(complex<double>* &inputSignal, complex<double>* &outputSignal)
{
//очистка памяти
delete[] inputSignal;
inputSignal = NULL;
delete[] outputSignal;
outputSignal = NULL;
}
</source>
=== выполнение операции "бабочка" ===
<source lang="С++">
void Butterfly(complex<double> *signal, complex<double> &u,int offset, int butterflySize)
{
complex<double> tem = signal[offset + butterflySize] * u;
signal[offset + butterflySize] = signal[offset] - tem;
signal[offset] += tem;
}
</source>
=== выполнение БПФ ===
<source lang="С++">
void SerialFFTCalculation(complex<double> *signal, int size)
{
int m = 0;
for (int tmp_size = size; tmp_size > 1; tmp_size /= 2, m++);
for (int p = 0; p < m; p++)
{
int butterflyOffset = 1 << (p + 1);
int butterflySize = butterflyOffset >> 1;
double coeff = M_PI / butterflySize;

for (int i = 0; i < size / butterflyOffset; i++)
for (int j = 0; j < butterflySize; j++)
Butterfly(signal,complex<double>(cos(-j*coeff),sin(-j*coeff)),j+i*butterflyOffset,butterflySize);
}
}
</source>
=== функция вывода результата (для тестирования) ===
<source lang="С++">
void PrintSignal(complex<double> *signal, int size)
{
cout << "Result signal" << endl;
for (int i = 0; i < size; i++)
cout << signal[i] << endl;
}
</source>
== Последовательная сложность алгоритма ==
Рассмотренный алгоритм Cooley – Tukey выполняется за <math>nlog_{2}n</math> операций комплексного сложения и <math>\frac{n}{2}log_{2}n</math> операций комплексного умножения. Таким образом последовательная сложность алгоритма является '''линейно-логарифмической'''.
== Информационный граф ==
[[file:Граф.jpg|center|thumb|800px|Рисунок 1. Алгоритм Cooley – Tukey для n=4, при предварительно сделанном бит-реверсировании]]
== Ресурс параллелизма алгоритма ==
[[file:Парал.jpg|center|thumb|800px|Рисунок 2. Распараллеливание алгоритма Cooley – Tukey для n=8]]
Рисунок 2 получен из информационного графа, главной идеей которого является процедура деления множеств полученных на предыдущем шаге на два равных по мощности подмножества и применение к ним БПФ. То есть процесс вычисления распределяется между <math>\frac{n}{2}</math> процессорами. И так как при последовательной реализации алгоритма было <math>\frac{n}{2}\log_{2}n</math> операций комплексного умножения и <math>n\log_{2}n</math> комплексного сложения/вычитания. Получается, что при параллельной реализации алгоритма мы будем иметь <math>\log_{2}n</math> операций комплексного умножения и <math>2\log_{2}n</math> комплексного сложения/вычитания. При этом, если используется функция HT(Hyper threading), то параллельная сложность быстрого преобразования Фурье (базовый алгоритм Кули-Тьюки) для векторов с длиной, равной степени двойки составляет <math>\log_{2}n</math>.
== Входные и выходные данные алгоритма ==
*'''Вещественное ДФП'''
**входные данные:
***вектор <math>\overline{a}=(a_{1},a_{2},...,a_{N})</math>, где <math>a_{i}\in \mathbb{R}</math>
***размерность: <math>N</math> точек
**выходные данные:
***вектор <math>\overline{b}=(b_{1},b_{2},...,b_{N})</math>, где <math>b_{i}\in \mathbb{C}</math>
***размерность: <math>2N</math> точек
*'''Комплексное ДФП'''
**входные данные:
***вектор <math>\overline{a}=(a_{1},a_{2},...,a_{N})</math>, где <math>a_{i}\in \mathbb{C}</math>
***размерность: <math>2N</math> точек
**выходные данные:
***вектор <math>\overline{b}=(b_{1},b_{2},...,b_{N})</math>, где <math>b_{i}\in \mathbb{C}</math>
***размерность: <math>2N</math> точек
== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности является ''линейным''. Это хорошо видно из пункта [[#Ресурс параллелизма алгоритма|ресурс параллелизма алгоритма]].
*Вычислительная мощность алгоритма является ''логарифмической''.
*Устойчивость.
**Рассмотрим вопрос об устойчивости поближе. Так как БПФ отличается от ДПФ простым лишь сокращением одинаковых операций, то вопрос устойчивости можно рассматривать на примере ДПФ. Так, к примеру, возьмем формулу ДПФ и добавим возмущение: <math> y_{p}=\sum_{k=0}^{n-1}(x_{k}+\varepsilon )e^{\frac{-2*\pi*k*p*i}{n}}, p=\overline{0,n-1}</math>. После чего преобразуем ее: <math>y_{p}=\sum_{k=0}^{n-1}x_{k}e^{\frac{-2*\pi*k*p*i}{n}}+\varepsilon\sum_{k=0}^{n-1} e^{\frac{-2*\pi*k*p*i}{n}}</math> и оценим вторую сумму, которая является геометрической прогрессией со знаменателем <math>q=e^{\frac{-2*\pi*p*i}{n}}</math>. Таким образом оцениваемая сумма будет равняться: <math>\varepsilon\frac{1-e^{\frac{-2*\pi*p*i*(n-1))}{n}}}{1-e^{\frac{-2*\pi*p*i}{n}}}</math>. При достаточно больших размерностях входного сигнала данное выражение сводится к: <math>\varepsilon (1-e^{-2*\pi*p*i})</math>. В тригонометрической форме данного выражения: <math>\varepsilon (cos(\frac{2*\pi*p*(n-1)}{n})-i*sin(\frac{2*\pi*p*(n-1)}{n}))</math> видно, что принимая во внимание целочисленность индексов <math>p</math> получается 0. Таким образом, мы можем говорить об устойчивости алгоритма в целом, и абсолютной устойчивости алгоритма в асимптотике.
*исходя из информационного графа, можно сделать вывод о сбалансированности алгоритма.
*алгоритм полностью детерминирован.
*Степень исхода вершины информационного графа не превышает двух.
= ЧАСТЬ. Программная реализация алгоритма =
== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
[[file:масш.jpg|center|thumb|1000px|Рисунок 3. Параллельная реализация алгоритма. Изменение эффективности(%)в зависимости от числа процессоров и размера области.]]
Как описывалось выше, каждый процессор получает достаточно низкий объем работы, что приводит к неэффективному распараллеливанию алгоритма (высокие затраты на передачу данных между процессорами по сравнению с вычислениями на них). Поэтому необходимо находить оптимальное количество процессоров для каждой отдельно взятой задачи. В данном примере, при размерности входного сигнала менее 262144, оптимальное количество процессоров составляет 1. При размерности 262144-4194304 оптимум достигался при 8 процессорах. И при размерности более 4194304- 16 процессоров. Вычисления проводились на суперкомпьютере «Ломоносов».
Код исследуемой программы представлен в разделе [[#Существующие реализации алгоритма|Существующие реализации алгоритма]]
== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Самой распространенной и известной реализацией дискретного БПФ является библиотека [http://www.fftw.org/ FFTW], разработанная Маттео Фриго и Стивеном Г. Джонсоном в Массачусетском технологическом институте. Данная библиотека существует для языков C и FORTRAN и позволяет производить вычисления в одном или нескольких измерениях. Входной сигнал может быть как действительным так и комплексным, а его размерность не обязательно должна быть степенью двойки. На данный момент последняя версия FFTW 3.3.5. Другие особенности библиотеки:
*Скорость. (Поддержка SSE / SSE2 / Altivec, начиная с версии 3.0. Версия 3.3.1 поддерживает AVX и ARM Neon.)
*Параллельные вычисления (OpenMP, MPI).
*[http://www.fftw.org/fftw3_doc/ Документация] в форматах HTML, PDF.
*Данное программное обеспечение является свободным и распространяется по лицензии GNU (General Public License).
Здесь приводится пример реализации прямого БПФ для комплексных данных входного сигнала на языке C++.
<source lang="С++">
#include <fftw3-mpi.h>
# include <stdlib.h>
# include <stdio.h>
#include <sys/stat.h>
#include <fcntl.h>
# include <time.h>
#include <math.h>

int main(int argc, char **argv)
{
const ptrdiff_t N0 = 4194304;
fftw_plan planForw;
fftw_complex *data, *dataOut;
ptrdiff_t alloc_local, local_ni, local_i_start, i, j, local_no, local_o_start;
int index, size;
double startwtime, endwtime;
MPI_Init(&argc, &argv);
fftw_mpi_init();
MPI_Comm_rank(MPI_COMM_WORLD, &index);
MPI_Comm_size(MPI_COMM_WORLD, &size);

/* get local data size and allocate */
alloc_local = fftw_mpi_local_size_1d(N0, MPI_COMM_WORLD, FFTW_FORWARD, FFTW_ESTIMATE,
&local_ni, &local_i_start, &local_no, &local_o_start);
data = fftw_alloc_complex(alloc_local);
dataOut = fftw_alloc_complex(alloc_local);
/* create plan */
planForw = fftw_mpi_plan_dft_1d(N0, data, dataOut, MPI_COMM_WORLD,
FFTW_FORWARD, FFTW_ESTIMATE);
/* initialize data to some function my_function(x,y) */
for (i = 0; i < local_ni; ++i)
{
data[i][0] = rand() / (double)RAND_MAX;
data[i][1] = rand() / (double)RAND_MAX;
}
if (index == 0){
startwtime = MPI_Wtime();

}

fftw_execute(planForw);
if (index == 0){
endwtime = MPI_Wtime();
printf("wall clock time = %f\n",
endwtime - startwtime);

}

fftw_destroy_plan(planForw);
MPI_Finalize();
}
</source>
[http://www.fftw.org/download.html Скачав] библиотеку и установив ее на рабочий компьютер, можно поэкспериментировать, используя вышеописанный исходный код. При этом, на стадии компиляции необходимо указывать директорию, где находятся заголовочные файлы и директорию, где находятся библиотечные файлы. Пример: mpicxx name.cpp -I/path/to/include/files -L/path/to/lib/files -lfftw3_mpi -lfftw3 -lm. Для версии 2.1.4 описание на русском языке приводится [https://parallel.ru/cluster/fftw.html здесь].

Остальные реализации:
*[http://www.gnu.org/software/gsl/ GSL - GNU Scientific Library]
*[https://developer.nvidia.com/cufft cuFFT]
*[http://www-03.ibm.com/systems/power/software/essl/ Engineering and Scientific Subroutine Library (ESSL) and Parallel ESSL]
=Литература=
[1] Бахвалов Н. С., Жидков Н. П., Кобельков. Г. М. — 6-е изд. — М. : БИНОМ. Лаборатория знаний

[2] Г. Нуссбаумер. Быстрое преобразование Фурье и алгоритмы вычисления сверток

[3] А.О. Лапаев Параллельное вычисление дискретного преобразования Фурье полинома в простом поле

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

2016-11-18T11:37:21Z

IgorS:

== Замечания к статье ==

* п.п. 2.4-2.6 не соответствуют содержанию описания алгоритма--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 15:10, 25 октября 2016 (MSK)
* не указаны авторы статьи и их вклад--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 15:10, 25 октября 2016 (MSK)
** Автор один, я (Тимохин Иван, 603 гр. ВМК МГУ) --[[Участник:Timokhinivan|Timokhinivan]] ([[Обсуждение участника:Timokhinivan|обсуждение]]) 14:50, 27 октября 2016 (MSK)
*** Так укажите себя, чтобы не было таких вопросов--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:41, 31 октября 2016 (MSK).
* в п.п. 2.4 следует добавить исходный код программы и описание компьютерной платформы, с подробным описанием условий, в которых производились эксперименты.--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:37, 18 ноября 2016 (MSK)
== Замечания к статье "Быстрое преобразование Фурье" ==

* В общем описании алгоритма нужны слова именно про алгоритм: следует рассказать идею быстрого преобразования, с минимумом формул [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:46, 11 ноября 2016 (MSK)
* Не вполне понятны слова "первообразный корень из 1 степени N" [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:46, 11 ноября 2016 (MSK)
* В последней формуле раздела 1.2 индексы k и l, кажется, должны идти через запятую. Если там рассматривается их произведение, следует уточнить, какие значения принимает каждый из них [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:46, 11 ноября 2016 (MSK)
* Раздел 1.2.3 - понятие "порядок преобразования" нуждается в пояснении [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:46, 11 ноября 2016 (MSK)
* Не хватает слов о глубине рекурсии [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:46, 11 ноября 2016 (MSK)

Участник:Vagabond/Алгоритм быстрого дискретного пребразования Фурье

2016-11-17T10:58:33Z

IgorS:

{{Assignment|IgorS}}
'''Автор''': Данилишин А.Р.
= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Пусть <math>X=(x_{1},...,x_{n-1})^{T}</math> - исходный сигнал, который необходимо преобразовать умножением на тензор второго ранга <math>E_{pk}=e^{\frac{-2kpi\pi}{n}} </math>. Результатом данного преобразования (<math>E*X</math>) будет вектор <math>Y=(y_{1},...,y_{n-1})^{T}</math>, где <math> y_{p}=\sum_{k=0}^{n-1}x_{k}e^{\frac{-2kpi\pi}{n}}, p=\overline{0,n-1}</math>. Данная формула является классической формулой ДПФ. Известно, что в общем случае умножение матрицы на вектор требует <math>O(n^{2})</math> арифметических операций, поэтому возникает вопрос о сокращении данного количества.

Главная идея БПФ состоит в сокращении многочисленных повторов сложения и умножения, которые выполняются в ДПФ (повторяющиеся множители: <math>e^{\frac{-2kpi\pi}{n}}</math> Например при условии, что <math>(pk)mod(n)=const</math>, при всех <math>k=\overline{0,n-1}</math> и <math>p=\overline{0,n-1}</math>

За счет использования данного факта, происходит значительное сокращение количества вычислительных операций. В данной статье используется алгоритм Cooley – Tukey, который предполагает собой разбиение исходного множества входных сигналов на два равных подмножества. При этом множество входных сигналов должно быть степенью двойки. Далее операция деления множества продолжается для образовавшихся подмножеств, и так далее. В результате над каждым из полученных подмножеств выполняется БПФ. Данные вычисления можно выполнять независимо друг от друга. Этот факт используется для реализации параллельной версии алгоритма.

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

*Пусть <math>e^{\frac{-2kpi\pi}{n}}</math> = <math>\omega _{n}^{kp}</math>.
*Разобьем исходный сигнал <math>x(n)</math> на два подмножества, с четными <math>x_{1}(2n)</math> и нечетными <math>x_{2}(2n+1)</math> номерами.
Тогда получаем: <math>y_{p}=\sum_{k=0}^{n-1}x_{k}\omega _{n}^{kp}= \sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega _{n}^{2kp}+\sum_{k=0}^{\frac{n}{2}-1}x_{2k+1}\omega _{n}^{(2k+1)p}</math>.

Выпишем два свойства омеги:
*<math>\omega_{\frac{n}{2}}=e^{2(\frac{-2i\pi}{n})}=\omega_{n}^{2}</math>
*<math>\omega_{n}^{\frac{n}{2}}=e^{\frac{-2ni\pi}{2n}}=e^{-i\pi}=-1</math>
Воспользуемся первым: <math>y_{p}= \sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega _{n}^{2kp}+\omega_{n}^{p}\sum_{k=0}^{\frac{n}{2}-1}x_{2k+1}\omega _{n}^{2kp}=\sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega _{\frac{n}{2}}^{kp}+\omega_{n}^{p}\sum_{k=0}^{\frac{n}{2}-1}x_{2k+1}\omega _{\frac{n}{2}}^{kp}</math>. Или, если обозначить <math>y_{1}(p)=\sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega _{\frac{n}{2}}^{kp}</math>, а <math>y_{2}(p)=\sum_{k=0}^{\frac{n}{2}-1}x_{2k+1}\omega _{\frac{n}{2}}^{kp}</math>, то получим формулу для вычисления координат изображения БПФ при <math>p=\overline{0...n/2}</math>: <math>y_(p)=y_{1}(p)+\omega_{n}^{p}y_{2}(p)</math>.

Заметим, что <math>y(p); y_{1}(p); y_{2}(p)</math> обладают свойством периодичности, с периодом <math>\frac{n}{2}</math>. Покажем это для <math>y_{1}(p)</math> : <math>y_{1}(p+\frac{n}{2})=\sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega_{\frac{n}{2}}^{k(p+\frac{n}{2})}=\sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega_{\frac{n}{2}}^{kp}\omega_{\frac{n}{2}}^{\frac{kn}{2}}=\sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega_{\frac{n}{2}}^{kp}</math>

Так как: <math>\omega_{\frac{n}{2}}^{\frac{kn}{2}}=e^{\frac{-4kni\pi}{2n}}=e^{-2ki\pi}=1</math>

Далее необходимо определить <math>y(p)</math> при <math>p\geq \frac{n}{2}</math>. Теперь воспользуемся свойством периодичности обнаруженными нами ранее: <math>y(p+\frac{n}{2})=y_{1}(p+\frac{n}{2})+\omega_{n}^{(p+\frac{n}{2})}y_{2}(p+\frac{n}{2})</math>. Воспользуемся вторым свойством омеги: <math>y(p)=y_{1}(p)-\omega_{n}^{p}y_{2}(p)</math>. Все выкладки, приведенные выше, относятся ко второму этапу алгоритма Cooley – Tukey, который был использован в данной статье. Последующие шаги данного этапа делят подмножества полученные на предыдущем шаге вычисления БПФ.

В конечном итоге вышеупомянутый алгоритм сводится к двум этапам:

'''Бит-реверсирование'''

Бит-реверсирование – это преобразование двоичного числа путем изменения порядка следования бит в нем на противоположный. Бит-реверсирование применимо только к индексам элементов массива и предназначено для изменения порядка следования этих элементов, при этом значения самих элементов не изменяются. Так, к примеру, четырехмерный вектор <math>(x_{0},x_{1},x_{2},x_{3})</math> изменится на <math>(x_{0},x_{2},x_{1},x_{3})</math>. Данная процедура необходима для разделения исходного сигнала на элементы подмножеств с четными и нечетными номерами, которые необходимы для вычисления <math>y_{1}(p)</math> и <math>y_{2}(p)</math>.

'''Вычисление БПФ'''

После выполнения этапа бит-реверсирования выполняются вычисления проиллюстрированные ''на рисунке 1'' в разделе [[#Информационный граф|Информационный граф]]. Рисунок 1 приведен для случая четырехмерного входного сигнала. Он предполагает совершение двух этапов. В общем же количество этапов равно <math>log_{2}n</math>. Каждый этап содержит в себе вычисление одной и той же операции "бабочки", где на вход подаются два числа <math>a</math> и <math>b</math>, на выходе же получаются <math>a+bU</math> и <math>a-bU</math>, где <math>U</math>- это ''коэффициент поворота''. Общая формула для коэффициента поворота: <math>e^{\frac{-ji\pi}{k}}</math>, где <math>k</math>- размер шага "бабочки", <math>j</math>- номер итерации вычислений над группой элементов, размером <math>2k</math> <math>(0\leq j < k )</math>.

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

Из двух вышеописанных этапов БПФ, бит-реверсирование является самым быстровыполнимым. Поэтому вычислительное ядро алгоритма будет лежать именно во втором этапе. А именно, им будет являться вычисление "бабочек". Количество этапов выполнения БПФ, как описывалось выше, равно <math>log_{2}n</math>. Учитывая количество этапов, размерность входного сигнала и идею деления на подмножества, всего "бабочек" получается <math>\frac{nlog_{2}n}{2}</math>. При этом операция умножения выполняется <math>\frac{n}{2}</math> раз. Это связано с тем, что результаты вычисления "бабочки" <math>a+bU</math> и <math>a-bU</math>.

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

Из всего вышесказанного заключаем, что макроструктуру алгоритма легче всего описать при помощи рекурсии:
*<math>\frac{n}{2}</math> преобразований Фурье порядка 2
*умножение <math>\frac{n}{2}</math> пар комплексных чисел
*<math>n</math> комплексных сложений
*снова преобразование Фурье
Также необходимо заметить, что количеством рекурсий будет количество этапов выполнения БПФ, то есть глубина рекурсии будет равняться <math>log_{2}n</math>

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

Программный код (описан на языке С++) строится из ряда функций:
*бит-реверсирование
*инициализация размерности входного сигнала
*инициализация входного сигнала (при помощи генератора случайных чисел)
*процесс очистки памяти
*выполнение операции "бабочка"
*выполнение БПФ
*функция вывода результата (для тестирования)
----
'''главный программный код БПФ:'''
<source lang="С++">
int main()
{
complex<double> *inputSignal = NULL;
complex<double> *outputSignal = NULL;
int size = 0;
cout << "FFT. Serial version." << endl;
ProcessInitialization(inputSignal, outputSignal, size);
bit(inputSignal, outputSignal, size);
SerialFFTCalculation(outputSignal, size);
PrintSignal(outputSignal, size); //в случае тестирования
ProcessTermination(inputSignal, outputSignal);
cin.get();
}
</source>
----
=== функция бит-реверсирования ===
<source lang="С++">
void bit(complex<double> inputSignal[], complex<double> *outputSignal, int size)
{ // процесс бит-реверсирования
int j = 0, i = 0;
while (i < size)
{
if (j > i)
{
outputSignal[i] = inputSignal[j];
outputSignal[j] = inputSignal[i];
}
else
if (j == i)
outputSignal[i] = inputSignal[i];

int m = size >> 1;
while ((m >= 1) && (j >= m))
{
j -= m;
m = m >> 1;
}
j += m;
i++;
}
}
</source>
=== инициализация размерности входного сигнала ===
<source lang="С++">
void ProcessInitialization(complex<double>* &inputSignal, complex<double>* &outputSignal, int &size)
{
// инициализация размера входного сигнала
do
{
cout << "Enter the input signal length: ";
cin >> size;
if (size < 4)
cout << "Input signal length should be >= 4" << endl;
else
{
int tmpSize = size;
while (tmpSize != 1)
{
if (tmpSize % 2 != 0)
{
cout << "Input signal length should be powers of two" << endl;
size = -1;
break;
}
tmpSize /= 2;
}
}
}
while (size < 4);
cout << "Input signal length = " << size << endl;
inputSignal = new complex<double>[size];
outputSignal = new complex<double>[size];
DummyDataInitialization(inputSignal, size);
}
</source>
=== инициализация входного сигнала ===
<source lang="С++">
void DummyDataInitialization(complex<double>* mas, int size)
{
for (int i = 0; i < size; i++)
{
mas[i] = int(rand() % 100);
}
}
</source>
=== процесс очистки памяти ===
<source lang="С++">
void ProcessTermination(complex<double>* &inputSignal, complex<double>* &outputSignal)
{
//очистка памяти
delete[] inputSignal;
inputSignal = NULL;
delete[] outputSignal;
outputSignal = NULL;
}
</source>
=== выполнение операции "бабочка" ===
<source lang="С++">
void Butterfly(complex<double> *signal, complex<double> &u,int offset, int butterflySize)
{
complex<double> tem = signal[offset + butterflySize] * u;
signal[offset + butterflySize] = signal[offset] - tem;
signal[offset] += tem;
}
</source>
=== выполнение БПФ ===
<source lang="С++">
void SerialFFTCalculation(complex<double> *signal, int size)
{
int m = 0;
for (int tmp_size = size; tmp_size > 1; tmp_size /= 2, m++);
for (int p = 0; p < m; p++)
{
int butterflyOffset = 1 << (p + 1);
int butterflySize = butterflyOffset >> 1;
double coeff = M_PI / butterflySize;

for (int i = 0; i < size / butterflyOffset; i++)
for (int j = 0; j < butterflySize; j++)
Butterfly(signal,complex<double>(cos(-j*coeff),sin(-j*coeff)),j+i*butterflyOffset,butterflySize);
}
}
</source>
=== функция вывода результата (для тестирования) ===
<source lang="С++">
void PrintSignal(complex<double> *signal, int size)
{
cout << "Result signal" << endl;
for (int i = 0; i < size; i++)
cout << signal[i] << endl;
}
</source>
== Последовательная сложность алгоритма ==
Рассмотренный алгоритм Cooley – Tukey выполняется за <math>nlog_{2}n</math> операций комплексного сложения и <math>\frac{n}{2}log_{2}n</math> операций комплексного умножения. Таким образом последовательная сложность алгоритма является '''линейно-логарифмической'''.
== Информационный граф ==
[[file:Граф.jpg|center|thumb|800px|Рисунок 1. Алгоритм Cooley – Tukey для n=4, при предварительно сделанном бит-реверсировании]]
== Ресурс параллелизма алгоритма ==
[[file:Парал.jpg|center|thumb|800px|Рисунок 2. Распараллеливание алгоритма Cooley – Tukey для n=8]]
Рисунок 2 получен из информационного графа, главной идеей которого является процедура деления множеств полученных на предыдущем шаге на два равных по мощности подмножества и применение к ним БПФ. То есть процесс вычисления распределяется между <math>\frac{n}{2}</math> процессорами. И так как при последовательной реализации алгоритма было <math>\frac{n}{2}\log_{2}n</math> операций комплексного умножения и <math>n\log_{2}n</math> комплексного сложения/вычитания. Получается, что при параллельной реализации алгоритма мы будем иметь <math>\log_{2}n</math> операций комплексного умножения и <math>2\log_{2}n</math> комплексного сложения/вычитания. При этом, если используется функция HT(Hyper threading), то параллельная сложность быстрого преобразования Фурье (базовый алгоритм Кули-Тьюки) для векторов с длиной, равной степени двойки составляет <math>\log_{2}n</math>.
== Входные и выходные данные алгоритма ==
*'''Вещественное ДФП'''
**входные данные:
***вектор <math>\overline{a}=(a_{1},a_{2},...,a_{N})</math>, где <math>a_{i}\in \mathbb{R}</math>
***размерность: <math>N</math> точек
**выходные данные:
***вектор <math>\overline{b}=(b_{1},b_{2},...,b_{N})</math>, где <math>b_{i}\in \mathbb{C}</math>
***размерность: <math>2N</math> точек
*'''Комплексное ДФП'''
**входные данные:
***вектор <math>\overline{a}=(a_{1},a_{2},...,a_{N})</math>, где <math>a_{i}\in \mathbb{C}</math>
***размерность: <math>2N</math> точек
**выходные данные:
***вектор <math>\overline{b}=(b_{1},b_{2},...,b_{N})</math>, где <math>b_{i}\in \mathbb{C}</math>
***размерность: <math>2N</math> точек
== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности является ''линейным''. Это хорошо видно из пункта [[#Ресурс параллелизма алгоритма|ресурс параллелизма алгоритма]].
*Вычислительная мощность алгоритма является ''логарифмической''.
*Устойчивость.
**Рассмотрим вопрос об устойчивости поближе. Так как БПФ отличается от ДПФ простым лишь сокращением одинаковых операций, то вопрос устойчивости можно рассматривать на примере ДПФ. Так, к примеру, возьмем формулу ДПФ и добавим возмущение: <math> y_{p}=\sum_{k=0}^{n-1}(x_{k}+\varepsilon )e^{\frac{-2*\pi*k*p*i}{n}}, p=\overline{0,n-1}</math>. После чего преобразуем ее: <math>y_{p}=\sum_{k=0}^{n-1}x_{k}e^{\frac{-2*\pi*k*p*i}{n}}+\varepsilon\sum_{k=0}^{n-1} e^{\frac{-2*\pi*k*p*i}{n}}</math> и оценим вторую сумму, которая является геометрической прогрессией со знаменателем <math>q=e^{\frac{-2*\pi*p*i}{n}}</math>. Таким образом оцениваемая сумма будет равняться: <math>\varepsilon\frac{1-e^{\frac{-2*\pi*p*i*(n-1))}{n}}}{1-e^{\frac{-2*\pi*p*i}{n}}}</math>. При достаточно больших размерностях входного сигнала данное выражение сводится к: <math>\varepsilon (1-e^{-2*\pi*p*i})</math>. В тригонометрической форме данного выражения: <math>\varepsilon (cos(\frac{2*\pi*p*(n-1)}{n})-i*sin(\frac{2*\pi*p*(n-1)}{n}))</math> видно, что принимая во внимание целочисленность индексов <math>p</math> получается 0. Таким образом, мы можем говорить об устойчивости алгоритма в целом, и абсолютной устойчивости алгоритма в асимптотике.
*исходя из информационного графа, можно сделать вывод о сбалансированности алгоритма.
*алгоритм полностью детерминирован.
*Степень исхода вершины информационного графа не превышает двух.
= ЧАСТЬ. Программная реализация алгоритма =
== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
[[file:масш.jpg|center|thumb|1000px|Рисунок 3. Параллельная реализация алгоритма. Изменение эффективности(%)в зависимости от числа процессоров и размера области.]]
Как описывалось выше, каждый процессор получает достаточно низкий объем работы, что приводит к неэффективному распараллеливанию алгоритма (высокие затраты на передачу данных между процессорами по сравнению с вычислениями на них). Поэтому необходимо находить оптимальное количество процессоров для каждой отдельно взятой задачи. В данном примере, при размерности входного сигнала менее 262144, оптимальное количество процессоров составляет 1. При размерности 262144-4194304 оптимум достигался при 8 процессорах. И при размерности более 4194304- 16 процессоров. Вычисления проводились на суперкомпьютере «Ломоносов».
Код исследуемой программы представлен в разделе [[#Существующие реализации алгоритма|Существующие реализации алгоритма]]
== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Самой распространенной и известной реализацией дискретного БПФ является библиотека [http://www.fftw.org/ FFTW], разработанная Маттео Фриго и Стивеном Г. Джонсоном в Массачусетском технологическом институте. Данная библиотека существует для языков C и FORTRAN и позволяет производить вычисления в одном или нескольких измерениях. Входной сигнал может быть как действительным так и комплексным, а его размерность не обязательно должна быть степенью двойки. На данный момент последняя версия FFTW 3.3.5. Другие особенности библиотеки:
*Скорость. (Поддержка SSE / SSE2 / Altivec, начиная с версии 3.0. Версия 3.3.1 поддерживает AVX и ARM Neon.)
*Параллельные вычисления (OpenMP, MPI).
*[http://www.fftw.org/fftw3_doc/ Документация] в форматах HTML, PDF.
*Данное программное обеспечение является свободным и распространяется по лицензии GNU (General Public License).
Здесь приводится пример реализации прямого БПФ для комплексных данных входного сигнала на языке C++.
<source lang="С++">
#include <fftw3-mpi.h>
# include <stdlib.h>
# include <stdio.h>
#include <sys/stat.h>
#include <fcntl.h>
# include <time.h>
#include <math.h>

int main(int argc, char **argv)
{
const ptrdiff_t N0 = 4194304;
fftw_plan planForw;
fftw_complex *data, *dataOut;
ptrdiff_t alloc_local, local_ni, local_i_start, i, j, local_no, local_o_start;
int index, size;
double startwtime, endwtime;
MPI_Init(&argc, &argv);
fftw_mpi_init();
MPI_Comm_rank(MPI_COMM_WORLD, &index);
MPI_Comm_size(MPI_COMM_WORLD, &size);

/* get local data size and allocate */
alloc_local = fftw_mpi_local_size_1d(N0, MPI_COMM_WORLD, FFTW_FORWARD, FFTW_ESTIMATE,
&local_ni, &local_i_start, &local_no, &local_o_start);
data = fftw_alloc_complex(alloc_local);
dataOut = fftw_alloc_complex(alloc_local);
/* create plan */
planForw = fftw_mpi_plan_dft_1d(N0, data, dataOut, MPI_COMM_WORLD,
FFTW_FORWARD, FFTW_ESTIMATE);
/* initialize data to some function my_function(x,y) */
for (i = 0; i < local_ni; ++i)
{
data[i][0] = rand() / (double)RAND_MAX;
data[i][1] = rand() / (double)RAND_MAX;
}
if (index == 0){
startwtime = MPI_Wtime();

}

fftw_execute(planForw);
if (index == 0){
endwtime = MPI_Wtime();
printf("wall clock time = %f\n",
endwtime - startwtime);

}

fftw_destroy_plan(planForw);
MPI_Finalize();
}
</source>
[http://www.fftw.org/download.html Скачав] библиотеку и установив ее на рабочий компьютер, можно поэкспериментировать, используя вышеописанный исходный код. При этом, на стадии компиляции необходимо указывать директорию, где находятся заголовочные файлы и директорию, где находятся библиотечные файлы. Пример: mpicxx name.cpp -I/path/to/include/files -L/path/to/lib/files -lfftw3_mpi -lfftw3 -lm. Для версии 2.1.4 описание на русском языке приводится [https://parallel.ru/cluster/fftw.html здесь].

Остальные реализации:
*[http://www.gnu.org/software/gsl/ GSL - GNU Scientific Library]
*[https://developer.nvidia.com/cufft cuFFT]
*[http://www-03.ibm.com/systems/power/software/essl/ Engineering and Scientific Subroutine Library (ESSL) and Parallel ESSL]
=Литература=
[1] Бахвалов Н. С., Жидков Н. П., Кобельков. Г. М. — 6-е изд. — М. : БИНОМ. Лаборатория знаний

[2] Г. Нуссбаумер. Быстрое преобразование Фурье и алгоритмы вычисления сверток

[3] А.О. Лапаев Параллельное вычисление дискретного преобразования Фурье полинома в простом поле

Быстрое дискретное преобразование Фурье (БПФ)

2016-11-17T10:57:12Z

IgorS:

{{Assignment|IgorS}}
Авторы: [[Участник:Chachba.A|Чачба А.Н.]], [[Участник:Weasel|Костоев Р.С.]]

[[Участник:Chachba.A|Чачба А.Н.]] заполнил половину всех заполненных пунктов (а именно 1.1, 1.2, 1.6, 1.8, 1.9) и построил информационный граф алгоритма, [[Участник:Weasel|Костоев Р.С.]] написал программу и провел серию запусков на суперкомпьютере и заполнил вторую половину пунктов. Оба после заполнения исправляли найденные ошибки во всех пунктах.

{{algorithm
| name = Быстрое преобразование Фурье (БПФ)
| serial_complexity = <math>O(N \log N)</math>
| pf_height = <math>O(\log N)</math>
| pf_width = <math>O(N)</math>
| input_data = <math>N</math>
| output_data = <math>N</math>
}}

= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Преобразование Фурье - взаимно однозначное отображение одной функции <math>f</math> вещественной переменной, называемой таргетным сигналом, с другой функцией <math>\hat{f}</math> вещественной переменной, называемой образом Фурье или спектром исходной функции по формуле:

:<math>
\hat{f}(\omega)=\frac{1}{\sqrt{2\pi}}\int\limits_{-\infty}^{\infty}f(x)e^{-ix\omega}\,dx
</math>
Дискретное преобразование Фурье, в свою очередь, есть аналог непрерывного преобразования Фурье, но для дискретного сигнала содержащего <math>N</math> отсчетов.
Широко применяется в цифровой обработке сигналов, теории вероятностей, криптографии и акустике.
Преобразование Фурье обратимо, причем обратное преобразование имеет практически ту же форму, что и прямое.
Преобразование Фурье имеет сложность <math>O(N^2)</math>, но существует быстрый вариант преобразование Фурье со сложностью <math>O(N\log{N})</math>.
Такая скорость достигается благодаря применению схемы "разделяй и властвуй". Общий вид преобразования позволяет разделить массив на несколько частей таким образом, что, применяя преобразование Фурье к отдельным его частям и объединяя специальным образом результаты (при помощи поворотных множителей и повторного применения преобразования), получать на выходе образ исходного вектора. Но благодаря разделению массива исходного размера на части суммарная асимптотическая сложность алгоритма уменьшается.

== Математическое описание алгоритма ==
Пусть исходный сигнал имеет значения <math>x_n,\quad n = 0,\dots,N-1</math>, тогда дискретное прямое преобразование Фурье (ДПФ) имеет вид:
:<math>
X_k = \sum_{n=0}^{N-1}x_ne^{-\frac{2\pi i}{N}kn},\quad k = 0, \dots, N-1
</math>
Обозначим <math> \varepsilon_{N} = e^{-\frac{2\pi i}{N}}</math>, тогда ДПФ можно перезаписать в матричной форме:
:<math>
\bar X = A\bar x
</math>
где матрица <math>A = \{\varepsilon_{N}^{(i - 1)(j - 1)}\}_{i,j=1}^{N}</math>
== Вычислительное ядро алгоритма ==
Пусть, для простоты <math> N = km</math>, тогда рекурсивная реализация преобразования Фурье, за счет <math>{k}</math> рекурсий на первом этапе и <math>m</math> на последнем этапе, имеет суммарную сложность <math>O(Nk + Nm + km) = O(N(k + m))</math>.

В случае, например <math>N = 2^n</math> сложность БПФ составляет <math>O(N\log{N})</math>.

В общем же случае, когда <math>N = \prod_{i=1}^np_i</math> сложность БПФ составляет <math> O(N(\sum_{i=1}^np_i))</math>. Так как рекурсия применяется каждый раз при отщеплении одного множителя, то можно заключить, что глубина рекурсии алгоритма составляет <math>O(n)</math>, где <math>n</math>-число множителей в факторизации <math>N</math>.

В свою очередь, если число <math>N</math> не факторизуется в произведение простых множителей (то есть <math>N</math> - простое число), то данный алгоритм не применим. На замену ему приходит алгоритм Радера, имеющий худшую асимптотику, нежели обычный БПФ, но лучшую чем <math>O(N^2)</math>. Также алгоритм Радера потребует дополнительного взаимодействия процессоров, что приведет к ухудшению эффективности.

== Макроструктура алгоритма ==
Макроструктура БПФ для случая <math>N = km</math> описывается рекурсивно:
# <math>k</math> независимых преобразований векторов меньшей размерности <math>m</math>
#Умножение элементов на поворотные коэффициенты (<math>N</math> умножений)
# <math>m</math> обратных преобразований векторов размерностей <math>k</math>

== Схема реализации последовательного алгоритма ==
Рекурсивный метод для случая <math>N = 2^k</math>, без оптимизации на C++:
<nowiki>#include <vector>
#include <complex>

using namespace std;

typedef complex<double> cd;
typedef vector<cd> vcd;

vcd fft(const vcd &as) {
int n = as.size();
if (n == 1) return vcd(1, as[0]);

vcd w(n); // Calculate roots
for (int i = 0; i < n; i++) {
double alpha = 2 * M_PI * i / n;
w[i] = cd(cos(alpha), sin(alpha));
}

vcd A(n / 2), B(n / 2);
for (int i = 0; i < n / 2; i++) {
A[i] = as[i * 2];
B[i] = as[i * 2 + 1];
}
vcd Av = fft(A);
vcd Bv = fft(B);
vcd res(n);
for (int i = 0; i < n; i++)
res[i] = Av[i % (n / 2)] +
w[i] * Bv[i % (n / 2)];
return res;
}
</nowiki>
В последовательном варианте можно бороться за улучшение константы сложности, предподсчитав значения соответствующих коэффициентов.

== Последовательная сложность алгоритма ==
Алгоритм состоит из трех этапов, следовательно если <math>N = \prod_{i = 1}^np_i</math>, то общая сложность составляет порядка <math>O(N\sum_{i=1}^np_i)</math> операций.

Пусть существует некоторое фиксированное число <math>P</math>, такое что:
:<math>
p_i \leq P \quad \forall i = 1...n,
</math>
тогда, учитывая, что <math>n \leq \log_{P}{N}</math>, сложность алгоритма можно записать в виде <math>O(N\log{N})</math>.

== Информационный граф ==
[[Файл:FourierGraph2.png|center|thumb|640px|'''Рисунок 1.''' Информационный граф преобразования Кули-Тьюки для <math>N = km = 25, k = 5, m = 5</math>. Желтые вершины - умножение на поворотные множители.]]

== Ресурс параллелизма алгоритма ==
В силу независимости всех рекурсивных вызовов и того факта, что путь максимальной длины в графе (так называемый критический путь) имеет порядок <math>O(\log{N})</math>, можно утверждать, что параллельная сложность алгоритма составит <math>O(\log{N})</math>.

''Замечание'': формально основание логарифма на каждом рекурсивном шаге зависит от множителя в факторизации <math>N</math>, потому использована О-символика.

При условии ограниченности количества доступных вычислительных узлов рекомендуется выбирать множители в разложении числа $N$ близкими к числу доступных узлов, таким образом доступные ресурсы будут использованы максимально эффективно.

Итого алгоритм относится к логарифмическому классу алгоритмов по параллельной сложности.

== Входные и выходные данные алгоритма ==
'''Входные данные''':
Чаще всего для обработки сигналов в качестве входных данных для БПФ подается вектор размерности <math>N</math> вещественных элементов. Но БПФ работает и для случая элементов над комплексным полем. Таким образом, например, можно экономить на количестве применений БПФ в некоторой конкретной задаче путем приведения двух векторов вещественных чисел к одному вектору комплексных чисел с вещественной частью равной первому вектору и комплексной частью равной второму вектору:
<math>x, y</math> - исходные сигналы. Обозначим <math>z = x + iy</math>, а <math>F(k, x)</math> - это <math>k</math>-ый коэффициент образа Фурье вектора <math>x</math>. Тогда:

:<math>F(k, x) = \frac{F(k, z) + F(k, \bar z)}{2}</math>
:<math>F(k, y) = -i\frac{F(k, z) - F(k, \bar z)}{2}</math>

Учитывая, что <math>F(k, \bar z) = \overline{F(N - k, z)}</math>, получаем:

:<math>F(k, x) = \frac{F(k, z) + \overline{F(N-k, z)}}{2}</math>
:<math>F(k, y) = -i\frac{F(k, z) - \overline{F(N-k,z)}}{2}</math>

Такой способ позволяет приблизительно в два раза уменьшить количество вычислений.

'''Выходные данные''':
Вектор размерности <math>N</math> комплексных чисел - спектр исходного сигнала.

== Свойства алгоритма ==
Матрица Вандермонда преобразования <math>A = \{e^{-\frac{2\pi i}{N}(i - 1)(j - 1)}\}_{i,j=1}^{N}</math> такая, что:
:<math>
A^{-1} = \frac{1}{N}A^*
</math>
Таким образом обратное преобразование Фурье с точностью до нормирующего множителя и сопряжения элементов матрицы совпадает с прямым.

= ЧАСТЬ. Программная реализация алгоритма =

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

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

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

== Масштабируемость алгоритма и его реализации ==
Все запуски программы[http://pastebin.com/raw/xajKb9JN] проводились на с/к Blue Gene/P с использованием библиотеки Intel MKL.

IBM Blue Gene/P — массивно-параллельная вычислительная система, которая состоит из двух стоек, включающих 2048 четырехъядерных вычислительных узлов, с пиковой производительностью 27,9 терафлопс.

Характеристики системы:
* две стойки с вычислительными узлами и узлами ввода-вывода
* 1024 четырехъядерных вычислительных узла в каждой из стоек
* 16 узлов ввода-вывода в стойке (в текущей конфигурации активны 8, т.е. одна I/O-карта на 128 вычислительных узлов)
* программирование с использованием MPI, OpenMP/pthreads, POSIX I/O
* высокая энергоэффективность: ∼ 372 MFlops/W

Вычислительный узел включает в себя четырехъядерный процессор, 2 ГБ общей памяти и сетевые интерфейсы.

Вычислительной узел:
* четыре микропроцессорных ядра PowerPC 450 (4-way SMP)
* пиковая производительность: 4 ядра x 3,4 GFlop/sec на ядро = 13,6 GFlop/sec
* пропускная способность памяти: 13,6 GB/sec
* 2 ГБ общей памяти
* 2 x 4 МБ кэш-памяти 2-го уровня (в документации по BG/P носит название L3)
* легковесное ядро (compute node kernel, CNK), представляющее собой Linux-подобную операционную систему, поддерживающую значительное подмножество Linux-совместимых системных вызовов
* асинхронные операции межпроцессорных обменов (выполняются параллельно с вычислениями)
* операции ввода-вывода перенаправляются I/O-картам через сеть коллективных операций

[[Файл:Time.PNG|center|thumb|640px|'''Рисунок 2.''' Время выполнения параллельной реализации БПФ в секундах. Size - число элементов массива. Р - число использованных процессоров.]]

[[Файл:Efff.PNG|center|thumb|640px|'''Рисунок 3.''' Эффективность параллельной реализации БПФ. Size - число элементов массива. Р - число использованных процессоров. Эффективность в пределах от 0 до 1.]]

Как видно из графика, эффективность параллельной реализации резко падает с ростом количества используемых процессоров, связано это с увеличением количества накладных расходов.

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

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

== Существующие реализации алгоритма ==
* Самая популярная библиотека для работы с преобразованиями Фурье это [http://www.fftw.org FFTW]
* Реализация от Intel в рамках [//software.intel.com/en-us/intel-mkl Math Kernel Library]
* Реализация ДПФ на графических картах от NVidia - [//developer.nvidia.com/cufft cuFFT]

= Литература =
* Бахвалов Н. С., Жидков Н. П., Кобельков. Г. М. — 6-е изд. — М. : БИНОМ. Лаборатория знаний, 2008. — 636 с.
* Описание алгоритма на Википедии: [https://ru.wikipedia.org/wiki/%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%BE%D0%B5_%D0%BF%D1%80%D0%B5%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%A4%D1%83%D1%80%D1%8C%D0%B5 Быстрое преобразование Фурье]
* Материалы лекций по "Алгоритмам и структурам данных" Школы Анализа Данных Яндекса

Участник:Ivanov.kir.m/Быстрое дискретное преобразование Фурье

2016-11-17T09:33:46Z

IgorS:

{{Assignment|IgorS}}
{{algorithm
| name = Алгоритм одномерного преобразования Фурье для действительных чисел
| serial_complexity = <math>O (N \log N)</math>
| pf_height = <math>O (\log N)</math>
| pf_width = <math>N</math>
| input_data = <math>N</math> действительных чисел
| output_data = <math>\lfloor N/2 \rfloor+1</math> комплексных чисел
}}
Авторы описания [[Участник:Ivanov.kir.m | К.М.Иванов]], [[Участник:Pumpkin | А.C.Сапин]] Вклад каждого участника равномерный, поскольку каждый пункт вычитывался и исправлялся обоими участниками. При сильном приближении можно сказать,что больший вклад [[Участник:Ivanov.kir.m | К.М.Иванов]] внес в заполнение теоретической части, а [[Участник:Pumpkin | А.C.Сапин]] в заполнение практической части.

'''Быстрое преобразование Фурье (БПФ, FFT)''' — алгоритм быстрого вычисления дискретного преобразования Фурье (ДПФ). То есть, алгоритм вычисления за количество действий, меньшее чем <math>O(N^{2})</math>, требуемых для прямого (по формуле) вычисления ДПФ. Иногда под БПФ понимается один из быстрых алгоритмов, называемый алгоритмом прореживания по частоте/времени или алгоритмом по основанию 2, имеющий сложность <math>O(N\log(N))</math>. Cуществует несколько различных алгоритмов для вычисления ДПФ считающимся быстрым преобразование Фурье:
* Алгоритм Кули-Тьюки [https://en.wikipedia.org/wiki/Cooley%E2%80%93Tukey_FFT_algorithm]
* Алгоритм Гуда-Томаса [https://en.wikipedia.org/wiki/Prime-factor_FFT_algorithm]
* Алгоритм Бруна [https://en.wikipedia.org/wiki/Bruun%27s_FFT_algorithm]
* Алгоритм Блюштейна [https://en.wikipedia.org/wiki/Chirp_Z-transform#Bluestein.27s_algorithm]
= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==
'''Быстрое дискретное преобразование Фурье''' (''БПФ'') - популярный в современном мире математический метод преобразования вектора/матрицы комплексных/действительных чисел - ''сигнала'' - в вектор/матрицу комплексных чисел - ''спектр''. С математической точки зрения преобразование сигнала <math>s</math> (как функции по времени <math>t</math>) в спектр <math>\hat{s}</math> описывается формулой
:<math>
\hat{s}(\omega)=\frac{1}{\sqrt{2\pi}}\int\limits_{-\infty}^{\infty}s(t)e^{-it\omega}\,dt
</math>

В отличии от своего классического аналога БПФ имеет сложность <math>O(N\log{N})</math>, а не <math>O(N^2)</math>, это достигается благодаря разделению исходного вектора на несколько частей, так чтобы применив к этим частям БПФ и объединив результаты путем умножения на поворотные множители и дополнительного БПФ, можно было получить преобразование Фурье исходного вектора - принцип "разделяй и властвуй".

Область применения данного метода простирается от обработки аудио информации до собственно спектрального анализа.
Поскольку в общем случае алгоритм БПФ применим к произвольным векторам чисел, выделяют отдельные подзадачи, для которых можно ввести дополнительную оптимизацию. Одной из таких подзадач является быстрое преобразование Фурье вектора действительных чисел, которому и посвящена данная статья. В качестве тестируемой реализации был выбран алгоритм Кули-Тьюки в библиотеке FFTW, написанной на языке C.

'''Замечание''': Поскольку общие описание алгоритма БПФ весьма сложно, в некоторых пунктах данная статья будет ссылаться на простой случай - алгоритм Кули-Тьюки быстрого преобразование Фурье для векторов ''с размерностью равной степени двойки''. Отличительной особенностью данного алгоритма является то, что он обходится без использования специфических приемов, использующихся именно для степеней четверки, восьмерки и т.п. Однако благодаря тому, что на вход данному алгоритму подается вектор чисто вещественных чисел, выходной вектор удовлетворяет ''эрмитовой избыточности'' (''Hermitian redundancy'') , т.е. <math>out[i]</math> является сопряженным с <math>out[n-i]</math>. Это обстоятельство позволяет достичь роста скорости и снижения затрат памяти примерно в 2 раза по сравнению с ''комплексным'' аналогом алгоритма.

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

Входные данные: вектор действительных чисел <math>x = (x_1,x_2,...,x_N)</math>.

Выходные данные: вектор комплексных чисел <math>X = (X_1,X_2,...,X_N)</math>.

Дискретное преобразование Фурье задается следующей формулой:

<math>X_k = \sum_{n=0}^{N-1} x_n e^{-\frac{2\pi i}{N} nk}, k = \overline{0,N-1}</math>

В простейшем случае(для степеней двойки) алгоритм Кули-Тьюки рассчитывает ДПФ для четных <math>(x_{2m}=x_0, x_2, \ldots, x_{N-2})</math> и нечетных элементов отдельно <math>(x_{2m+1}=x_1, x_3, \ldots, x_{N-1})</math>. Затем результаты рассчетов объединяются для получения ДПФ всей последовательности:

<math>
\begin{matrix} X_k & =
& \sum \limits_{m=0}^{N/2-1} x_{2m}e^{-\frac{2\pi i}{N} (2m)k} + \sum \limits_{m=0}^{N/2-1} x_{2m+1} e^{-\frac{2\pi i}{N} (2m+1)k}
\end{matrix}
</math>

Таким образом, получается рекурсивный алгоритм, работающий по принципу [https://ru.wikipedia.org/wiki/%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_(%D0%B8%D0%BD%D1%84%D0%BE%D1%80%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B0) разделяй и влавствуй].

=== Рекурсивное описание ===
Алгоритм:
# Входной вектор <math>a = (a_0,a_2,...,a_{N-1})</math> преобразуется в матрицу <math>A</math> размера <math>n_1 \times n_2 </math>, где <math>N=n_1 \cdot n_2</math> и <math>n_1 < n_2</math>
<math> A = \begin{pmatrix}
a_0 & a_1 & \cdots & a_{n_1-1} \\
a_{n_1} & a_{n_1+1} & \cdots & a_{2n_1-1} \\
\vdots & \vdots & \ddots & \vdots \\
a_{(n_2-1)\cdot n_1} & a_{(n_2-1)\cdot n_1+1} & \cdots & a_{n_2\cdot n_1-1}
\end{pmatrix} </math>
# К каждой строке полученной матрицы применяется быстрое дискретное преобразование Фурье (БПФ) порядка <math>n_1</math>
# Каждый элемент полученный после применения БПФ умножается на ''поворотные множители'' <math>exp (2 \pi i(m-1)(j-1)/N)</math>, где <math>m</math> - номер строки, а <math>j</math> - номер столбца
# Полученная после шагов 1-2 матрица <math>A</math> транспонируется
# К каждой строке матрицы <math>A^T</math> применяется БПФ порядка <math>n_2</math>

Так как алгоритм реализует принцип "разделяй и властвуй" глубина рекурсии составляет <math>O (\log N)</math> от числа входных элементов.

'''Замечание:''' Как правило все ''поворотные множители'' вычисляются заранее и хранятся в специальном массиве.

'''Замечание:''' В общем случае <math>N</math> разбивается на <math>n_1 \cdot n_2</math> так, чтобы <math>n_1</math> и <math>n_2</math> сами не являлись простыми числами и разлагались на множители не являющиеся простыми числами.

'''Замечание:''' В случае простого <math>N</math> оно дополняется(как правило единицией) до непростого числа. В процессе слияния добавленные значения отбрасываются.

== Вычислительное ядро алгоритма ==
В случае размерности входа равной степени двойки, вычислительным ядром алгоритма является так называемая, "''бабочка''". В простейшем случае "''бабочка''" представляет из себя двухточечное преобразование. Рассмотрим этот случай:

На вход алгоритму подается двухэлементный вектор ‒ <math> v = (v[0], v[1]) </math>. Тогда для вычисления будут происходить по следующим формулам:

<math>V[0] = W_2^0 v[0] + W_2^0 v[1] = v[0] + W_2^0 v[1] </math>

<math>V[1] = W_2^0 v[0] + W_2^1 v[1] = v[0] + W_2^1 v[1] </math>

Данный процесс удобно изобразить с помощью следующей схемы:

[[file:Fftbutterfly.png | Рис. 1. "''Бабочка''" для двумерного входа ]]

Для 4-х элеметного вектора <math>v=(v[0],v[1],v[2],v[3])</math>, алгоритм строится похожим образом. Сначала создаются простейшие "''бабочки''", а потом их результаты соединяются с противоположеной "бабочкой":

<math>V[0]=v[0]+W_2^0 v[2]+W_4^0(v[1]+W_2^0 v[3])</math>

<math>V[1]=v[0]-W_2^0 v[2]+W_4^1(v[1]-W_2^0 v[3])</math>

<math>V[2]=v[0]+W_2^0 v[2]-W_4^0(v[1]+W_2^0 v[3])</math>

<math>V[3]=v[0]-W_2^0 v[2]-W_4^1(v[1]-W_2^0 v[3])</math>

Схема в таком случае будет выглядеть следующим образом:

[[file:Fftbutterfly4.png| Рис. 2. "''Бабочка''" для четырёхмерного входа ]]

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

== Макроструктура алгоритма ==
Для исходного вектора <math>a = (a_1,a_2,...,a_N)</math> размерности <math>N = n_1 \cdot n_2</math>, <math>n_1 < n_2</math> БПФ представляется как:
#<math>n_2</math> БПФ порядка <math>n_1</math>
#<math>n_1 \cdot n_2</math> умножение комплексных чисел
#<math>n_1</math> БПФ порядка <math>n_2</math>

== Схема реализации последовательного алгоритма ==
Схема организации состоит в том, что на каждом шаге <math>i</math> для выполнения "''бабочки''" все элементы разбиваются на <math>n_{i_1}</math> векторов по <math>n_{i_2}</math> элементов, причем <math>n_{i_1} \cdot n_{i_2} = n_i</math>, где <math>n_i</math> длина входного вектора на текущем шаге <math>i</math>. В случае если такое разбиение невозможно, по причине того что <math>n_i</math> простое число, исходный вектор на текущем шаге дополняется элементом. В зависимости от номера шага, разница координат для каждой пары элементов увеличивается соразмерно разбиению <math>(n_{i_1},n_{i_2})</math>.
При этом результат суммы записывается в элемент с меньшим номером, а результат вычитания с последующим умножением - в элемент с большим.

== Последовательная сложность алгоритма ==
Быстрое дискретное преобразование Фурье выполнимо за <math>O(N(n_1+\cdots+n_m))</math> действий при <math>N=n_1n_2\cdots n_m</math> (в простом случае, при <math>N=2^m</math> необходимо <math>O(N\log_2(N))</math> действий). Дискретное преобразование Фурье преобразует вектор <math>a = (a_0, \dots, a_{N-1})</math> в вектор комплексных чисел <math>b = (b_0, \dots, b_{N-1})</math>, такой, что <math>b_i=\sum_{j=0}^{N-1}a_j\varepsilon^{ij}</math>, где <math>\varepsilon^n=1</math> и <math>\varepsilon^k\neq 1</math> при <math>0<k<N</math>.

Основной шаг алгоритма состоит в сведении задачи для <math>N</math> чисел к задаче для <math>n_1=N/n_2</math> числам, где <math>n_2</math> — делитель <math>N</math>.

Пусть мы уже умеем решать задачу для <math>N/n_2</math> чисел. Применим преобразование Фурье к векторам <math>a_i,a_{n_2+i}, \dots, a_{n_2(n_1-1)+i}</math> для <math>i=0,1,\dots,n_2-1</math>. Покажем теперь, что за <math>O(Np)</math> действий можно решить исходную задачу. Заметим, что <math>b_i=\sum_{j=0}^{n_2-1} \varepsilon^{ij} \left(\sum_{k=0}^{n_1-1}a_{kn_2+j}\varepsilon^{kin_2}\right)</math>.
Выражения в скобках нам уже известны — это <math>(i\mod p)</math>-тое число после преобразования Фурье <math>j</math>-го вектора. Таким образом, для вычисления каждого <math>b_i</math> нужно <math>O(n_2)</math> действий, а для вычисления всех <math>b_i</math> всего <math>O(Nn_2)</math> действий, что и требовалось.

В общем случае:

Пусть <math>4N>2^k\ge2N</math>. Заметим, что тогда <math>b_i=\varepsilon^{-i^2/2}\sum_{j=0}^{N-1}\varepsilon^{(i+j)^2/2}\varepsilon^{-j^2/2}a_j</math>. Обозначим <math>\bar{a}_i=\varepsilon^{-i^2/2}a_i</math>, <math>\bar{b}_i=\varepsilon^{i^2/2}b_i</math>, <math>c_i=\varepsilon^{(2N-2-i)^2/2}</math>. Тогда <math>\bar{b}_i=\sum_{j=0}^{2N-2-i}\bar{a}_jc_{2N-2-i-j}</math>, если положить <math>\bar{a}_i=0</math> при <math>i\ge N</math>.

Таким образом задача сведена к вычислению ''свёртки'', а это можно сделать с помощью трёх преобразований Фурье для <math>2^k</math> элементов. Выполняем прямое преобразование Фурье для <math>(\bar{a_0}, \cdots, \bar{a}_{2^k-1})</math> и <math>(c_1,\cdots,c_{2^k-1})</math>, перемножаем поэлементно результаты и выполняем обратное преобразование Фурье.

Вычисления всех <math>\bar{a}_i</math> и <math>c_i</math> требуют <math>O(N)</math> действий, три преобразования Фурье требуют <math>O(N\log(N))</math> действий, перемножение результатов преобразований Фурье требует <math>O(N)</math> действий, вычисление всех <math>b_i</math> зная значения свертки требует <math>O(N)</math> действий. Итого для дискретного преобразования Фурье требуется <math>O(N\log(N))</math> действий для любого <math>N</math>.

== Информационный граф ==
[[Файл:InfoGraph Ivanov Sapin.png |center|thumb|800px| Информационный граф алгоритма Кули-Тьюки для <math>N = 21</math>. Исходные данные обозначены зеленым, результат — синим. Преобразования Фурье для <math>n_1 = 7</math> и <math>n_2 = 3 \text{ } (N = n_1 \cdot n_2)</math> представлены как «чёрные ящики». Умножение на поворотные коэффициенты (множители) представлено коричневыми ромбами.]]
Как видно из рисунка, размер этого графа линейно-логарифмический, а формулы дуг имеют экспоненциальные компоненты.

== Ресурс параллелизма алгоритма ==
Если считать только главные члены выражений, то простой алгоритм Кули-Тьюки имеет критический путь, состоящий из <math>log(N)</math> операций комплексного сложения/вычитания и <math>log(N)</math> операций комплексного умножения (основание <math>log</math> целиком зависит от выбранного на каждом шаге алгоритма разбиения). Здесь стоит отметить, что все рекурсивные вызовы БПФ на каждом шаге выполняются независимо, это приводит к тому, что их можно распределить по доступным вычислительным узлам. Аналогичная ситуация обстоит и с умножением на поворотные множетели, что позволяет независимо присоединять его к любому шагу. Таким образом алгоритм БПФ имеет высокий ресурс параллелизма, а алгоритм БПФ в общем случае может быть отнесён к ''логарифмическому'' классу по параллельной сложности.

Кроме того, параллелизм БПФ можно увеличить, если брать <math>n_1</math> и <math>n_2</math> по возможности близкими к кратным доступному количеству вычислительных узлов (а не брать просто один из множителей близким к нулю, как в традиционной реализации), это позволит равномерно распределить работу между вычислительными узлами, что сильно повысит эффективность алгоритма благодаря лишь одной внутренней пересылке данных.

== Входные и выходные данные алгоритма ==
'''Входные данные:''' вектор действительных/комплексных чисел <math>a = (a_1,a_2,...,a_N)</math>.

'''Выходные данные:''' вектор комплексных чисел <math>b = (b_1,b_2,...,b_{\lfloor N/2 \rfloor+1})</math>.

Есть несколько ситуаций, при которых количество потребляемой памяти для хранения входного вектора <math>a</math> и выходного вектора <math>b</math> тможет быть снижено вдвое:
# Если <math>a</math> — вектор действительных чисел, тогда <math>b = E\bar{b}</math>;
# Если <math>a</math> — вектор чисто-мнимых чисел, тогда <math>b = -E\bar{b}</math>;
# Если <math>a = E\bar{a}</math>, тогда <math>b</math> — вектор действительных чисел;
# Если <math>a = -E\bar{b}</math>, то <math>b</math> — вектор чисто-мнимых чисел.

Где матрица <math>E</math>:
:<math>
E = \begin{bmatrix}
1 & 0 & 0 & \cdots & 0 & 0 \\
0 & 0 & 0 & \cdots & 0 & 1 \\
0 & 0 & 0 & \cdots & 1 & 0 \\
0 & 0 & 0 & \ddots & 0 & 0 \\
0 & 0 & 1 & \cdots & 0 & 0 \\
0 & 1 & 0 & \cdots & 0 & 0
\end{bmatrix}
</math>

== Свойства алгоритма ==
Таким образом в общем у алгоритма БПФ в случае неограниченных ресурсов:
*последовательная сложность - ''линейно-логарифмическая''
*параллельная сложность - ''логарифмическая''.

При этом алгоритм полностью детерминирован.

= ЧАСТЬ. Программная реализация алгоритма =
В качестве тестируемой реализации была выбрана библиотека FFTW, а именно функция, выполняющая БПФ одномерного вектора действительных чисел.
== Особенности последовательной реализации алгоритма ==
Простейший вариант алгоритма для степеней двойки на языке C:
<source lang="C++">
#include <stdio.h>
#include <math.h>
#include <complex.h>

typedef double complex cplx;

void _fft(cplx *buf, cplx *out, int n, int step)
{
if (step < n) {
_fft(out, buf, n, step * 2); //рекурсивный рассчет
_fft(out + step, buf + step, n, step * 2);

for (int i = 0; i < n; i += 2 * step) {
cplx t = cexp(-I * PI * i / n) * out[i + step];
buf[i / 2] = out[i] + t;
buf[(i + n)/2] = out[i] - t;
}
}
}

void fft(cplx *buf, int n)
{
cplx out[n];
for (int i = 0; i < n; i++) out[i] = buf[i];

_fft(buf, out, n, 1);
}
</source>

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

=== Описание платформы IBM Blue Gene/P ===
IBM Blue Gene/P — массивно-параллельная вычислительная система, которая состоит из двух стоек, включающих 8192 процессорных ядер (2 x 1024 четырехъядерных вычислительных узлов), с пиковой производительностью 27,9 терафлопс (27,8528 триллионов операций с плавающей точкой в секунду).

Характеристики системы:

* две стойки с вычислительными узлами и узлами ввода-вывода
* 1024 четырехъядерных вычислительных узла в каждой из стоек
* 16 узлов ввода-вывода в стойке (в текущей конфигурации активны 8, т.е. одна I/O-карта на 128 вычислительных узлов)
* выделенные коммуникационные сети для межпроцессорных обменов и глобальных операций
* программирование с использованием MPI, OpenMP/pthreads, POSIX I/O
* высокая энергоэффективность: ∼ 372 MFlops/W (см. список Green500)
* система воздушного охлаждения

Стойка (rack, cabinet) состоит из двух midplane'ов. В midplane входит 16 node-карт (compute node card), на каждой из которых установлено 32 вычислительных узла (compute card). Midplane, 8 x 8 x 8 = 512 вычислительных узлов, — минимальный раздел, на котором становится доступна топология трехмерного тора; для разделов меньших размеров используется топология трехмерной решетки. Node-карта может содержать до двух узлов ввода-вывода (I/O card). Вычислительный узел включает в себя четырехъядерный процессор, 2 ГБ общей памяти и сетевые интерфейсы.

Микропроцессорное ядро:

* модель: PowerPC 450
* рабочая частота: 850 MHz
* адресация: 32-битная
* кэш инструкций 1-го уровня (L1 instruction): 32 KB
* кэш данных 1-го уровня (L1 data): 32 KB
* кэш предвыборки (L2 prefetch): 14 потоков предварительной выборки (stream prefetching): 14 x 256 байтов
* два блока 64-битной арифметики с плавающей точкой (Floating Point Unit, FPU), каждый из которых может выдавать за один такт результат совмещенной операции умножения-сложения (Fused Multiply-Add, FMA)
* пиковая производительность: 2 FPU x 2 FMA x 850 MHz = 3,4 GFlop/sec per core

Вычислительные узлы и I/O-карты в аппаратном смысле неразличимы и являются взаимозаменяемыми, разница между ними состоит лишь в способе их использования. У них нет локальной файловой системы, поэтому все операции ввода-вывода перенаправляются внешним устройствам.

Вычислительной узел:

* четыре микропроцессорных ядра PowerPC 450 (4-way SMP)
* пиковая производительность: 4 cores x 3,4 GFlop/sec per core = 13,6 GFlop/sec
* пропускная способность памяти: 13,6 GB/sec
* 2 ГБ общей памяти
* 2 x 4 МБ кэш-памяти 2-го уровня (в документации по BG/P носит название L3)
* легковесное ядро (compute node kernel, CNK), представляющее собой Linux-подобную операционную систему, поддерживающую значительное подмножество Linux-совместимых системных вызовов
* асинхронные операции межпроцессорных обменов (выполняются параллельно с вычислениями)
* операции ввода-вывода перенаправляются I/O-картам через сеть коллективных операций

=== Оценка масштабируемости алгоритма ===
Масштабируемость алгоритма проверялась с помощью тестовой программы расположенной по [https://github.com/alesapin/parallel_fftw ссылке]. Для эксперимента использовались:
* Компилятор mpicc
* Библиотека OpenMPI версии 1.68
* Библиотека FFTW 3.3.5
Алгоритм тестировался на входных векторах размера <math>2^{15}</math> до <math>2^{26}</math>. При этом использовались от 8 до 128 процессоров с шагом степени двойки.

[[File:Fftw time good cr.png |center|thumb|800px| Замеры времени работы параллельной реализации FFTW для входного вектора действительных чисел. По оси Data Size указано <math>N</math> -- число входных элементов. По оси Procs Num указано <math>p</math> -- число задействованных процессоров. По оси Elapsed Time -- время затраченное на выполненине алгоритма в секундах.]]

[[File:Fftw efficency good cr.png |center|thumb|800px| Эффективность параллельной реализации FFTW для входного вектора действительных чисел. По оси Data Size указано <math>N</math> -- число входных элементов. По оси Procs Num указано <math>p</math> -- число задействованных процессоров. По оси Effeciency -- эффективность алгоритма в процентах.]]

Из графиков можно сделать следующие выводы:
* Значительное увеличение числа процессоров не дает значимого уменьшения времени исполнения, что отражено и на графике эффективности. Это означает, что время, в основном, расходуется на пересылки данных, а не на рассчет.
* При большом количестве элементов и маленьком числе процессоров наблюдается сверхлинейное ускорение, что связано с маленьким число пересылок и активным использованием кеша.

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [http://www.fftw.org/ FFTW], разработанная Матео Фриго и Стивеном Джонсоном в Массачусетском технологическом институте. Для преобразования небольших объемов данных используется алгоритм [https://en.wikipedia.org/wiki/Cooley%E2%80%93Tukey_FFT_algorithm Кули - Тьюки], в случае входа больших размеров используется алгоритм [https://en.wikipedia.org/wiki/Rader%27s_FFT_algorithm Радера] или [https://en.wikipedia.org/wiki/Chirp_Z-transform#Bluestein.27s_algorithm Блюштейна]. Библиотека считается самой быстрой реализацией БПФ и на входах любых размеров и размерностей сохраняет ассимптотическую сложность <math>O(N\cdot log(N))</math>. Также, существует версия FFTW с поддержкой [http://www.fftw.org/doc/Distributed_002dmemory-FFTW-with-MPI.html#Distributed_002dmemory-FFTW-with-MPI MPI], которая позволяет с объемами данных не умещающимися в память.

FFTW изначально написана на языке C, однако имеет API для нескольких языков, в том числе Fortran и Ada. Открытая версия библиотеки распространяется под лицензией [https://en.wikipedia.org/wiki/GNU_General_Public_License GNU General Public License]. Также существует реализация для коммерческого использования распространяемая под лицензией [https://en.wikipedia.org/wiki/MIT MIT].

Существует несколько реализаций алгоритма, для рассчета на GPU:
* [https://developer.nvidia.com/cufft cuFFT] для рассчета на графических ускорителях от NVIDIA.
* [http://gpuopen.com/compute-product/clfft/ clFFT] для рассчета на GPU и CPU.

= Литература =
[1] Википедия [Электронный ресурс]. Тема: Быстрое преобразование Фурье – Электрон. дан. – URL [https://ru.wikipedia.org/wiki/%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%BE%D0%B5_%D0%BF%D1%80%D0%B5%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%A4%D1%83%D1%80%D1%8C%D0%B5 Быстрое преобразование Фурье] (дата обращения 17.09.2016)

[2] Бахвалов Н. С., Жидков Н. П., Кобельков. Г. М. — 6-е изд. — М. : БИНОМ. Лаборатория знаний, 2008. — 636 с.
[[en:Fast Discrete Fourier Transform]]

[3] FFTW [Электронный ресурс]. Тема: One-Dimensional DFTs of Real Data – Электрон. дан. – URL [http://www.fftw.org/doc/One_002dDimensional-DFTs-of-Real-Data.html#One_002dDimensional-DFTs-of-Real-Data One-Dimensional DFTs of Real Data] (последняя дата обращения 14.19.2016)

[4] FFTW [Электронный ресурс]. – Электрон. дан. – URL [http://www.fftw.org/ FFTW Lib] (последняя дата обращения 14.19.2016)

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

2016-11-16T11:06:56Z

IgorS:

=== Замечания к статье ===

* не указан конкретный вклад каждого автора--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 16:04, 25 октября 2016 (MSK)
* п.п. 2.4 не заполнен--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:06, 16 ноября 2016 (MSK)

== Замечания к статье "Алгоритм кластеризации с использованием представлений" ==

* П.1.2. Мало сказано о входном наборе данных. Если это могут быть точки произвольной размерности, это надо формализовать [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 16:30, 11 ноября 2016 (MSK)
* П.1.2. Не сказано, как именно выбираются точки-представители, чтобы они были максимально удалены, это нетривиально [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 16:30, 11 ноября 2016 (MSK)
* не сказано об оптимальном выборе параметров алгоритма [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 16:30, 11 ноября 2016 (MSK)

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

2016-11-16T11:05:31Z

IgorS:

Обсуждение участника:Лукьянова Анна

2016-11-16T11:00:55Z

IgorS:

=== Замечания к статье ===

* содержание не соответствуют шаблону описания алгоритма: отсутствуют п.п. во 2 части--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 16:01, 25 октября 2016 (MSK)
* п.п. 2.4 не заполнен--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:00, 16 ноября 2016 (MSK)

== Замечания к статье "Алгоритм кластеризации с использованием представлений" ==

* п.1.1.1. Если взялись за классификацию алгоритмов, лучше разъяснить, что такое агломеративные, дивизивные, "четкие" и "нечеткие" алгоритмы. Было бы здорово даже сделать это в отдельной статье про задачу кластеризации, но это не обязательно [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 16:24, 11 ноября 2016 (MSK)
* п.1.1.2. Метрики и некоторые подробности лучше перенести ниже, к "математическому описанию" [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 16:24, 11 ноября 2016 (MSK)
* п.1.2 выглядит дописанным не до конца. Там нужно разъяснить те неформальные конструкции, которые встречались ранее в п. 1.1.2. [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 16:24, 11 ноября 2016 (MSK)
* п.1.5. Псевдокод слишком псевдо, его следует сделать больше похожим на код, с соответствующим форматированием [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 16:24, 11 ноября 2016 (MSK)
* следует добавить информацию об оптимальном выборе параметров алгоритма [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 16:24, 11 ноября 2016 (MSK)

Участник:Лукьянова Анна/Алгоритм кластеризации с использованием представлений2

2016-11-16T11:00:21Z

IgorS:

Основные авторы описания: [[U:Лукьянова Анна|А.Я. Лукьянова]]

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

===Понятие кластеризации===

Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны. Главное отличие кластеризации от классификации состоит в том, что перечень групп четко не задан и определяется в процессе работы алгоритма.

Применение кластерного анализа в общем виде сводится к следующим этапам:

#Отбор выборки объектов для кластеризации.
#Определение множества переменных, по которым будут оцениваться объекты в выборке. При необходимости – нормализация значений переменных.
#Вычисление значений меры сходства между объектами.
#Применение метода кластерного анализа для создания групп сходных объектов (кластеров).
#Представление результатов анализа.

'''Классификация алгоритмов'''

'''Методы по способу обработки данных:'''

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

*Агломеративные методы AGNES (Agglomerative Nesting) - характеризуются последовательным объединением исходных элементов и соответствующим уменьшением числа кластеров. В начале работы алгоритма все объекты являются отдельными кластерами. На первом шаге наиболее похожие объекты объединяются в кластер. На последующих шагах объединение продолжается до тех пор,
пока все объекты не будут составлять один кластер.

*Дивизимные методы DIANA (Divisive Analysis) - характеризуются последовательным разделением исходного кластера, состоящего из всех объектов, и соответствующим увеличением числа кластеров. В начале работы алгоритма все объекты принадлежат одному кластеру, который на последующих шагах делится на меньшие кластеры, в результате образуется последовательность расщепляющих групп.

''Неиерархические методы:'' строят одно разбиение объектов на кластеры.
*Итеративные

'''Алгоритмы по способу анализа данных:'''

*''Четкие'' (непересекающиеся) алгоритмы каждому объекту выборки ставят в соответствие номер кластера, т.е. каждый объект принадлежит только одному кластеру;

*''Нечеткие'' (пересекающиеся) алгоритмы каждому объекту ставят в соответствие набор вещественных значений, показывающих степень отношения объекта к кластерам. Т.е. каждый объект относится к каждому кластеру с некоторой вероятностью.

'''Методы по количеству применений алгоритмов кластеризации:'''

*С одноэтапной кластеризацией;

*С многоэтапной кластеризацией.

'''Методы по возможности расширения объема обрабатываемых данных:'''

*Масштабируемые;

*Немасштабируемые

'''Методы по времени выполнения кластеризации:'''

*Потоковые (on-line);

*Не потоковые (off-line).

===CURE===

Алгоритм '''CURE (Clustering Using REpresentatives)''' выполняет иерархическую кластеризацию с использованием набора определяющих точек для определения объекта в кластер. Относится к алгомеративным методам.

''Назначение'': кластеризация очень больших наборов числовых данных.

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

''Недостатки'': есть необходимость в задании пороговых значений и количества кластеров.

Описание алгоритма :

[[file:Page1.png|thumb|center|1400px|Рисунок 1: Обзор CURE ]]

'''Шаг 1:''' Построение дерева кластеров, состоящего из каждой строки входного набора данных.

'''Шаг 2:''' Формирование «кучи» в оперативной памяти, расчет расстояния до ближайшего кластера (строки данных) для каждого кластера. При формировании кучи кластеры сортируются по возрастанию дистанции от кластера до ближайшего кластера. Расстояние между кластерами определяется по двум ближайшим элементам из соседних кластеров. Для определения расстояния между кластерами используются «манхеттенская», «евклидова» метрики или похожие на них функции.

'''Шаг 3:''' Слияние ближних кластеров в один кластер. Новый кластер получает все точки входящих в него входных данных. Расчет расстояния до остальных кластеров для новообразованного кластера. Для расчета расстояния кластеры делятся на две группы: первая группа – кластеры, у которых ближайшими кластерами считаются кластеры, входящие в новообразованный кластер, остальные кластеры – вторая группа. И при этом для кластеров из первой группы, если расстояние до новообразованного кластера меньше чем до предыдущего ближайшего кластера, то ближайший кластер меняется на новообразованный кластер. В противном случае ищется новый ближайший кластер, но при этом не берутся кластеры, расстояния до которых больше, чем до новообразованного кластера. Для кластеров второй группы выполняется следующее: если расстояние до новообразованного кластера ближе, чем предыдущий ближайший кластер, то ближайший кластер меняется. В противном случае ничего не происходит.

'''Шаг 4:''' Переход на шаг 3, если не получено требуемое количество кластеров.

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

Прежде всего, алгоритм использует случайное разбиение выборки из <math> s </math> элементов на <math> p </math> частей, которые могут поместиться в память отдельной машины кластера. Затем во время первого прохода алгоритм уменьшает число кластеров в каждой подвыборке до <math> \frac{s}{pq} </math>, где <math> q \geq 1 </math> – некоторая константа (происходит объединение ближайших кластеров). Для определения расстояния между кластерами используются «манхеттенская», «евклидова» метрики или похожие на них функции.

''Метрика Евклида:'' <math>\rho(p,k) = \sqrt{\sum_{i=1}^n (p_{i} - k_{i})^2}</math>

''«Манхеттенская» метрика:'' <math>\rho(p,k) =\sum_{i=1}^n |p_{i} - k_{i}|</math>

Если расстояние между ближайшей парой кластеров больше некоторого парогового(критического) значения, то объединения не происходит.

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

Число точек представителей выбирается в зависимости от данных. Если возможно появление кластеров сложной формы, то точек должно быть больше, чтобы выявить их форму. В оригинальной статье авторы показывают что уже при <math>c</math> равном <math>10</math> достигается неплохая эффективность.

[[Файл:Param_c.png|400px|thumb|center| Рисунок 2: Результат работы алгоритка в зависимости от количесва представлений <math>c</math>.]]

Из рисунка видно, что при меньших значениях <math>c</math> качество работы алгоритма ухудшается

Выбранные точки сдвигаются на <math>\alpha</math> к центроиду кластера. Алгоритм становится основанным на методе поиска центроида при <math>\alpha = 1</math>, и основанным на всех точках кластера при <math>\alpha = 0</math>.

[[Файл:Factor_a.png|400px|thumb|center| Рисунок 3: Чувствительность алгоритма к параметру <math>\alpha </math>.]]

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

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

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

Основную часть метода составляют разбиение случайной выборки строк на <math>k</math> кластеров и нахождение точек-представителей для каждого кластера.

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

Входные параметры: набор входных данных <math>S</math>, содержащий <math>m</math> точек в <math>n</math>-мерном пространстве
и требуемое количество кластеров <math>k</math>. Начиная с отдельных точек в виде отдельных кластеров, на каждом шаге ближайшая пара кластеров объединяются, чтобы сформировать новый кластер.Процесс повторяется до тех пор, пока не достигнет <math>k</math>.

'''procedure''' cluster(S,k)
'''begin'''
1. T:=build_kd_tree(S)
2. Q:-build_heap(S)
3. '''while''' size(Q)>k '''do''' {
4. u:=extract_min(Q)
5. v:= u.closest
6. delete(Q, V)
7. w := merge(u,v)
8. delete_rep(T, u); delete_rep(T, v); insert_rep(T, w)
9. w.closest := x /* x is an arbitrary cluster in Q */
10. '''for each''' x \in Q'''do''' {
11. '''if''' dist(w, x) < dist(w, w.closest)
12. w.closest := x
13. '''if''' x.closest is either u or w {
14. ''' if''' dist(x, x.closest) < dist(x, w)
15. x.closest := closest_cluster(T, x, dist(x, w))
16. '''else'''
17. x.closest := w
18. relocate(Q, x)
19. }
20. '''else if''' dist(x, x.closest) > d&(x, w) {
21. x.closest := w
22. relocate(Q, x)
23. }
24. }
25. insert(Q, w)
26. }
'''end'''

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

Являясь представителем иерархических алгоритмов кластеризации, имеет сложность <math> O(n^2 log(n)) </math> и <math> O(n^2) </math> для признаковых пространств малой размерности

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

В начале работы алгоритма все объекты являются отдельными кластерами. На первом шаге наиболее похожие объекты объединяются в кластер. На последующих шагах объединение продолжается до тех пор, пока все объекты не будут составлять один кластер.

[[Файл:Metod.png|400px|thumb|center| Рисунок 4: Дендрограмма агломеративных методов]]

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

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

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

'''Входные данные:''' набор данных <math> S </math> , количество кластеров <math>k</math>, число точек представителей <math>c</math>, параметр <math>\alpha</math>, параметр <math>q</math>, <math>p</math> число разбиений выборки, <math>n</math> размерность.

Параметр <math>\alpha</math> для сжатия точек представления к центру кластера.

'''Выходные данные:''' требуемое количество <math> k </math> крастеров

===Оптимальный выбор параметров для алгоритма===

*размер случайной выборки <math> S </math> (''а'')

При запуске CURE со случайными размерами выборки в пределах от 500 до 5000 видно, что при размерах до 2000 были найдены кластеры низкого качества, начиная с 2500 точек и выше (2,5% от установленного размера данных), CURE всегда правильно определяет кластеры.

*число точек представителей <math> c </math> (''b'')
В оригинальной статье авторы показывают что уже при <math> c </math> равном <math>10</math> достигается неплохая эффективность.

*число разбиений выборки <math> p </math> ('''c''')
<math> p </math> должно быть выбрано таким, что <math> \frac{s}{pq} </math> > <math> k </math>

*размерность (''d'')
CURE хорошо себя чувствует при больших размерностях

*сжимающий фактор <math>\alpha</math>
В оригинальной статье авторы показывают что <math>\alpha</math> от 0.2 до 0.7 помогает хорошо выявлять несферические кластеры и подавлять редкие выбросы.

[[Файл:4pic.png|800px|thumb|center| Рисунок 5: Влияние параметров <math> S </math>, <math> c </math>, <math> p </math> и размерности на работу алгоритма.]]

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

* является масштабируемым алгоритмом

* неважна форма кластера и размер

*работает только на числовых данных

= ЧАСТЬ. Программная реализация алгоритма =

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

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

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

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

будет..

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

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

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

Последовательная реализация CURE-алгоритма для кластеризации для Python/C++ представлена в пакете: [https://github.com/annoviko/pyclustering pyclustering].

Также существует параллельная реализация алгоритма, описанная в сборнике [4]. Алгоритм предложенный в статье использует массив данных состоящий из размеров кластера, его центроида и репрезентативных точек, а при объединении кластеров информацию о новом кластере просто записывают в строчку предыдущего. Также для каждого кластера требуется считать индекс и расстояние до ближайшего кластера. Именно их поиск авторы статьи и предлагают распараллелить.

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

[1] Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.

[2] Theodoridis, Sergios; Koutroumbas, Konstantinos (2006). Pattern recognition. Academic Press. pp. 572–574. ISBN 978-0-12-369531-4.

[3] Guha, Sudipto; Rastogi, Rajeev; Shim, Kyuseok (2001). "CURE: An Efficient Clustering Algorithm for Large Databases" (PDF). Information Systems. 26 (1): 35–58. doi:10.1016/S0306-4379(01)00008-4

[4] Panagiotis E. Hadjidoukas, Laurent Amsaleg. OpenMP Shared Memory Parallel Programming.
Volume 4315 of the series Lecture Notes in Computer Science pp 289-299
Parallelization of a Hierarchical Data Clustering Algorithm Using OpenMP

Участник:Kanast74/Алгоритм кластеризации, основанный на минимальном покрывающем дереве

2016-11-16T10:59:19Z

IgorS:

Статью подготовила: [[Участник:kanast74|Дмитриева Анастасия Владимировна]].

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

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

Кластеризация - это задача статистического анализа, состоящая в разбиении множества объектов на группы, называемые кластерами, внутри которых объекты обладают одними и теми же свойствами (чаще всего, это означает близость относительно заданной метрики). Основное отличие от задачи классификации состоит в том, что группы заранее не заданы и определяются в процессе работы алгоритма.

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

Пусть на начальном этапе решения задачи имеются набор тестовых примеров <math>X=\{x_1...x_n\}</math>, а также функция расстояния между ними <math>r(e)</math>. Отметим, что метрика, в которой вычисляются расстояния между объектами, выбирается исходя из требований задачи; наиболее распространенные - это Евклидово расстояние, квадрат Евклидова расстояния, манхэттенская метрика, расстояние Чебышева и степенное расстояние. Далее необходимо применить один из алгоритмов кластеризации, которые можно разделить на две категории: иерархические, состоящие в последовательном поиске кластеров из уже найденных кластеров, а также неиерархические, цель которых состоит в минимизации некоторой целевой функции. К последней группе относятся такие алгоритмы, как алгоритм k-средних, алгоритм EM, нечеткие алгоритмы, а также алгоритмы теории графов, к категории которых относится алгоритм, описываемый в данной статье.

Рассмотрим алгоритм кластеризации на k кластеров, основанный на построении минимального остовного дерева (MST) и который состоит в следующем:

# По исходным данным строится взвешенный неориентированный граф: каждый объект представляется в виде вершины графа, а вес ребра, связывающего две вершины, есть расстояние между объектами в выбранной заранее метрике
# Для полученного графа строится минимальное остовное дерево, то есть дерево, содержащее все вершины графа и имеющее минимальный суммарный вес своих ребер
# Удаляется k-1 ребро минимального остовного дерева с максимальным весом
# Получаются k компонент связности, которые интерпретируются как кластеры

Для построения минимального остовного дерева могут быть использованы различные алгоритмы, среди которых наиболее распространены:

# Алгоритм Крускала
# Алгоритм Борувки
# Алгоритм Прима

Отметим, что в рамках проведенного исследования использовался алгоритм Крускала<nowiki>, наиболее подробно изучить который можно, пройдя по ссылке [</nowiki>[https://algowiki-project.org/ru/Алгоритм_Крускала Алгоритм Крускала]], поэтому в данной статье его описание не приводится.

=== Математическое описание алгоритма ===
С математической точки зрения задачу кластеризации можно рассматривать как минимизацию среднего внутрикластерного расстояния <math> \frac{\sum_{i<j, c(x_i)=c(x_j)} r(x_i,x_j)}{\sum_{i<j, c(x_i)=c(x_j)} 1} \to min </math> с одной стороны и максимизации межкластерного расстояния <math> \frac{\sum_{i<j, c(x_i)\neq c(x_j)} r(x_i,x_j)}{\sum_{i<j, c(x_i) \neq c(x_j)} 1} \to max </math> с другой стороны, где <math>c(x)</math> - кластер, к которому принадлежит объект <math>x</math>.

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

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

Вычислительным ядром описываемого алгоритма является построение минимального остовного дерева. В случае, если программа предполагается быть распараллеленной, то операция построения MST будет производиться в отдельности в каждом процессе. Как уже было отмечено, в данном исследовании для построения MST использовался алгоритм Крускала, который будет работать наиболее эффективно, если веса ребер исходного графа отсортированы, поэтому сортировка - это еще одна операция, которая должна быть включена в вычислительное ядро, что предполагает выбранная ревлизация алгоритма. Поэтому в дальнейшем мы не будем разделять сортировку и поиск минимального остовного дерева, предполагая, что они объеденены в единый эффективный алгоритм.

Дадим некоторую справку касательно адгоритма поиска MST, фигурирующего в данном исследовании. Алгоритм Крускала — алгоритм построения минимального остовного дерева взвешенного связного неориентированного графа. Алгоритм впервые описан Джозефом Крускалом в 1956 году.

Алгоритм Крускала находит безопасное ребро для добавления в растущий лес путем поиска ребра <math>(u, v)</math> с минимальным весом среди всех ребер, соединяющих два дерева в лесу. Обозначим два дерева, соединяемые ребром <math>(u, v) </math>, как <math>C_1</math> и <math>C_2</math>. <math>(u, v)</math> — безопасное для <math>C_1</math> ребро. Алгоритм Крускала является жадным, поскольку на каждом шаге он добавляет к лесу ребро с минимально возможным весом.

=== Макроструктура алгоритма ===
# Построение графа путем задания списков ребер. В общем случае, когда задано некоторое множество объектов, для построения графа может быть использован алгоритм, позволяющий рассчитать расстояние от каждого объекта до каждого за <math>O(n^2)</math> операций, где <math>n</math> число объектов (вообще говоря, данная операция требует <math>O(E)</math> операций, где <math>E</math> - число ребер в графе, но в нашем случае число ребер подразумевается равным <math>E=\frac{D (n(n-1))}{2}</math>, <math>D</math> - плотность графа). Однако в рамках данного исследования для тестирования алгоритма использовалась такая технология построения графов, когда в качестве веса каждого ребра назначается некоторое произвольное число из заданного промежутка (например, от 1 до 1000), что также требует <math>O(n^2)</math>
# Построение минимального остовного дерева на основании полученного ранее графа, для чего может быть использован один из известных и наиболее распространенных алгоритмов (алгоритм Крускала, алгоритм Борувки или алгоритм Прима). Рассмотрим, например, алгоритм Крускала. На начальном этапе имеется граф, состоящий из вершин - объектов исходной выборки и не содержащий ребер, следовательно, каждая из вершин изначально представляет собой компоненту связности и даже дерево. Алгоритм состоит в выборе на каждом шаге ребра с минимальным весом и добавлении его в дерево, если оно соединяет два дерева. Алгоритм будет работать максимально эффективно, если изначально ребра графа, полученного на первом шаге будут отсортированы (например, по возрастанию).
# Для получения <math>k</math> кластеров необходимо удалить из получившегося минимального остовного дерева <math>k-1</math> ребро с максимальным весом. В частности, в случае, если на предыдущем шаге мы пользовались алгоритмом Крускала для построения MST, ребра получившегося дерева отсортированы по возрастанию, значит для удаления указанных выше ребер потребуется лишь <math>O(1)</math> операций
# Наконец, необходимо правильно интерпретировать результат работы алгоритма и перечислить вершины, принадлежащие полученным кластерам; на выполнение данного шага может потребоваться различное число операций в зависимости от формата выходных данных программы: например, в данной реализации выходные данные, как будет сказано в дальнейшем, представлены в виде списка ребер, формирующий итоговый минимальный остовный лес, следовательно в общем случае на его обработку потребуется <math>O(V)</math> операций

==== Используемые обозначения и структуры данных ====

Обозначим в качестве <math>G=(V,E)</math> граф, содержащий <math>V</math> вершин и <math>E</math> ребер. Для построения минимального остовного дерева для данного графа используются три операции [2], опишем здесь каждую из них:

# операция MakeSet(<math>v</math>) генерирует дерево (множество) для вершины графа <math>v</math>, являющейся корнем искомого дерева
# операция Find(<math>v</math>) определяет, которому из деревьев принадлежит интересующая вершина <math>v</math>. Условимся, что данная операция возвращает ту вершину, которая является корнем искомого дерева
# операция Union(<math>u, v</math>) объединяет два множества (два дерева, содержащих соответствующие вершины) под одним корнем

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

Приведем здесь псевдокод основной части алгоритма - а именно построения локального минимального остовного дерева при помощи алгоритма Крускала.

Kruskal ( G=(V,E) ):

1. mst = ∅;

2. сортировать E по возрастанию;

3. для каждой вершины v из множества вершин V:

4. MakeSet(v);

5. для каждого ребра e = (u, v) из множества ребер E:

6. if Find(u) ≠ Find(v):

7. mst = mst ∪ { (u,v) };

8. Union(u, v);

9. return mst;

=== Последовательная сложность алгоритма ===
Сперва оценим последовательную сложность составных частей алгоритма.

0. O(E): Формирование графа

1. O(1): Инициализация пустого множества.

2. O(Elog(E)): сортировка ребер из множества E.

3. O(V): Инициализация одноточечного множества для каждой вершины из V.

4. ▲ MakeSet за O(1).

5. O(Elog(V)): Операции Union и Find для каждого ребра из E.

6. ▲ Find за O(1).

7. ▲ Присоединение элемента за O(1).

8. ▲ Union за O(log(V)).

9. O(1): Удаление k-1 ребра для получения k компонент связности

10. O(V): Перечисление вершин, входящих в соответствующие кластеры

11. O(1): Return.

Таким образом, с учетом того, что, получаем:

<math>T( G = (V, E) ) = O(1) + O(E\log(E)) + O(V) + O(E\log(V)) + O(E) = O(E\log(E)) + O(E\log(V)) = O(E\log(V)) + O(E\log(V))</math>

Итак, оценка сложности алгоритма есть <math>T( G = (V, E) ) = O(E\log(V)) + O(\log(V))</math>

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

[[file:Clustering kruskal.png|thumb|center|1400px|Рисунок 1. Информационный граф алгоритма]]

По структуре информационного графа можно сделать вывод что высота канонической ярусно-параллельной формы [1] есть <math>\log{p}</math>, где <math>p</math> число процессов.

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

Описанный алгоритм позволяет произвести распараллеливание, источник которого будет описан в данном пункте. Прежде всего, необходимо отметить, что данный алгоритм допускает преобразование в гибридную параллельную версию, а именно версию с использованием технологий MPI и OpenMP.

Тем не менее, прежде всего следует установить справедливость свойства используемого алгоритма поиска MST, позволяющего произвести его распараллеливание [3]:

'''Ассоциативность по рёбрам'''. Пусть <math>MSF(E)</math> – минимальный остовный лес графа с рёбрами <math>E</math>. Тогда
:<math>
MSF(E_1 \cup E_2 \cup \dots \cup E_k) = MSF(MSF(E_1) \cup MSF(E_2) \cup \dots \cup MSF(E_k)).
</math>

В том случае, когда все объекты заранее известны, и между ними можно рассчитать все попарные расстояния, первый шаг - построение графа - позволяет произвести распараллеливание при помощи обеих вышеуказанных технологий, а именно: разделить объекты между процессами при помощи MPI, а внутри каждой из полученных групп будем рассчитывать попарные расстояния параллельно на нескольких ядрах, использовав технологию OpenMP. Однако в данном исследовании кластеризуемые объекты предполагались заранее неизвестными, так как попарные расстояния между объектами задаются случайным образом, а это означает, что произвести распараллеливание этого шага, которое бы дало хотя бы небольшое ускорение (уменьшение времени работы), не получится.

Если все же объекты заранее были известны, можно сохранить полученную на предыдущем этапе группировку их на отдельные процессы и внутри каждого произвести сортировку расстояний между объектами по возрастанию при помощи алгоритма QSort с использованием технологии OpenMP (в противном случае параллельная структура алгоритма поддерживается начиная с этого шага).

Далее внутри каждой группы объектов (каждый процесс в отдельности) строим минимальное остовное дерево, в конце шага деревья объединяются в одно - общее MST для всех объектов, поддерживая при этом отсортированность расстояний по возрастанию.

Наконец, будем удалять необходимое количество ребер глобального остовного дерева для того, чтобы получить требуемое количество кластеров - компонент связности графа.

==== Стратегии распараллеливания ====
Необходимо отметить, что несмотря на всю простоту идеи распараллеливания алгоритма, описанную выше, существует несколько стратегий реализовать ее на практике. При этом, как будет показано далее, указанные стратегии дают различные приросты в производительности. Перечислим некоторые из них:

# первая стратегия, наиболее очевидная, состоит в том, чтобы в самом начале главный процесс считывает данные о ребрах и распределяет считанную информацию между остальными процессами, не имеющим доступа к файлу с исходными данными. Далее каждый из процессов рассчитывает локальное минимальное остовное дерево и передает его обратно главному процессу, который объединяет деревья в одно, глобальное
# вторая стратегия во многом напоминает первую, но основное различие между ними состоит в том, что во втором случае файл с исходными данными не разделяется между процессами, а является доступным для каждого из них в полном объеме. Таким образом, каждый процесс способен считать данные о ребрах, за которые они отвечают, самостоятельно, что значительно снижает объем коммуникации между процессами. Также еще одно улучшение состоит в том, что теперь главный процесс не простаивает во время работы остальных, а, как и остальные, рассчитывает локальное минимальное остовное дерево
# наконец, третья стратегия состоит в том, чтобы оптимизировать процесс слияния локальных минимальных остовных деревьев. Предлагается сделать так, чтобы не только главный процесс занимался слиянием, но каждый процесс участвует в процессе слияния. Для того, чтобы добиться максимальной эффективности будем предполагать, что число процессов <math>p=2^n,n>1</math>. В этом случае потребуется <math>\log{p}</math> шагов, чтобы выполнить слияние. На каждом шаге половина активных процессов пересылает свое локальное дерево процессу с меньшим номером на единицу, а другая половина занимается приемом и слиянием. Таким образом, через <math> \log{p} </math> шагов главный процесс, который имеет номер 0, будет иметь в своем распоряжении глобальное минимальное остовное дерево.

==== Способы разделения графа ====

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

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

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

По исходным данным формируется граф <math>G = (V, E)</math>, являющийся неориентированным, взвешенным, связным и не имеющим кратных ребер. Пусть полученный граф содержит <math> |V|</math> вершин и <math>|E|</math> ребер. Предполагая, что каждый объект можно сравнить с каждым, можно считать, что получаемый граф является полным, а значит число ребер может быть оценено следующим образом: <math>|E|=\frac{|V|(|V|-1)}{2} \le \frac{|V|^2}{2}-\frac{|V|}{2} \Rightarrow O(E)=O(V^2)</math>

Обозначим в виде <math>w(u,v)</math> вес ребра, соединяющего вершины <math>u</math> и <math>v</math>. Тогда граф может быть задан в виде списка ребер, а именно списка троек: <math>(u,v,w(u,v))</math>, что является более удобным представлением графа для реализации многих алгоритмов по сравнению с матрицей смежности. Помимо этого, данный способ помогает сэкономить память. Недостатков указанного подхода является только то, что установить, с какими вершинами связана интересующая вершина, а также вес соответствующих ребер является весьма затруднительно. Однако для решения поставленной задачи нам это и не потребуется.

Формат выходных данных аналогичный

=== Свойства алгоритма ===
==== Вычислительная мощность ====
Оценим вычислительную мощность алгоритма в том случае, когда для его реализации используется <math>p</math> процессов. Предположим, что алгоритм реализован при помощи первой стратегии (см. выше) и применяется к графу <math>G = (V, E)</math>, тогда:

* Ввод данных: <math>\frac{|E|}{p}</math> - в среднем столько ребер содержит получаемый каждым процессом связный подграф
* Вывод данных: <math>\frac{|V| - 1}{p}</math> - каждый из процессов должен вывести посчитанное локальное минимальное дерево, которое содержит указанное количество ребер, так как остальные ребра, изначально входившие в состав подграфа, не будут входит в локальное MST
* Вычисление: для вычисления локального MST каждому из процессов требуется <math>\frac{|E|}{p} \log{\frac{|V|}{p}}</math> операций

Таким образом, искомое соотношение может быть записано в следующем виде: <math>\frac{\frac{|E|}{p} \log{\frac{|V|}{p}}}{\frac{|E|}{p} + \frac{|V| - 1}{p}} = \frac{|E| \log{\frac{|V|}{p}}}{|E|+|V|-1}</math>

На основании полученной формулы можно сделать несколько выводов:

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

==== Оценка прироста в производительности ====
===== Закон Амдала =====

В данном рзеделе будет производиться оценка прироста производительности параллельного алгоритма по сравнению с последовательным. Наиболее простой способ оценить прирост производительности – использовать закон Амдала, который гласит, что прирост может быть оценен следующим образом: <math> S_p \le \frac{1}{f+\frac{1-f}{p}}</math>,

где <math>f</math> – часть алгоритма, которая не может быть распараллелена, <math>p</math> – число процессов.

В наиболее тривиальном случае (первая стратегия распараллеливания) распараллеливанию не подлежит считывание входных данных и их разделение между процессами, а также объединение локальных MST в одно. Поэтому сложность последовательной части программы может быть оценена следующим образом: <math>2O(V^2)+O(V^2 \log{V})</math>. Распараллеливанию подлежит инициализация подграфов при помощи операции MakeSet за <math>O(V)</math>, сортировка ребер по возрастанию внутри каждой группы за <math>O(V^2 \log{V})</math>, а также построение локальных минимальных остовных деревьев за аналогичное время. Поэтому сложность параллельной части алгоритма может быть оценена так: <math>O(V)+2 O(V^2 \log{V})</math>. Таким образом, вычислив отношение сложностей частей программы, получаем, что <math>f=0.44</math>. Устремим число процессов <math>p</math> к бесконечности и получим, что максимальное ускорение, которое можно получить путем распараллеливания алгоритма есть <math>2.27</math>. К сожалению, данная оценка не является точной. Для того, чтобы оценить прирост производительности более качественно, произведем анализ временных диаграмм программы.

===== Анализ временных диаграмм =====

Обозначим за <math>t_d</math> – время, которое требуется для того, чтобы разделить граф на подграфы, <math>t_p</math> – суммарное время вычислений, <math>t_b</math> – время обратной пересылки локально полученных результатов, <math>t_l</math> – задержка одной пересылки. Причем можно убедиться в том, что <math>t_p > t_d > t_b > t_l</math>, также известно, что время выполнения последовательного кода <math>t_{serial} = t_p</math>.

[[Файл:FirstStrategy.PNG|thumb|center|400px|Рисунок 2. Первая стратегия распараллеливания вычислительного ядра алгоритма]]
Произведем анализ первой (наивной) стратегии распараллеливания программы. На временной диаграмме жирным обозначен критический путь, время выполнения которого может быть вычислено по формуле (см: [2]):
<math>t_{paralel} = 4 t_l + t_d + \frac{t_p}{3} + \frac{t_b}{3}</math>

Тогда максимальное ускорение для одного процесса есть: <math>speedup=\frac{t_{serial}}{t_{parallel}} = \frac{t_p}{4 t_l + t_d + \frac{t_p}{3} + \frac{t_b}{3}}</math>

А в случае n процессов: <math>speedup = \frac{n}{1+\frac{n (n+1) t_l + n t_d + t_b}{t_p}}</math>

[[Файл:SecondStrategy.PNG|thumb|center|400px|Рисунок 3. Вторая стратегия распараллеливания вычислительного ядра алгоритма]]
Теперь проанализируем вторую стратегию, основная задача которой – уменьшить объем коммуникаций между процессами за счет того, что файл с исходными данными теперь доступен всем процессам. Помимо этого введем в рассмотрение новую величину <math>t_i</math> – время, требующееся на инициализацию множеств вершин. Тогда для одного процесса <math>t_{parallel} = t_i + \frac{t_p}{4} + t_l + 3 \frac{t_b}{4}</math>, а максимальное ускорение в случае n процессов есть: <math>speedup= \frac{t_{serial}}{t_{parallel}} = \frac{4}{1+\frac{4 t_i + 4 t_l + 3 t_b}{t_p}}</math>

[[Файл:ThirdStrategy.PNG|thumb|center|400px|Рисунок 4. Третья стратегия распараллеливания вычислительного ядра алгоритма]]
Наконец, проанализируем третью стратегию, основная цель которой – оптимизировать процесс слияния локальных минимальных остовных деревьев, а также привлечь все активные процессы (включая главный) к процессу построения локального MST. В этом случае время выполнения параллельной части программы с использованием лишь одного процесса: <math> t_{parallel}=t_i + \frac{t_p}{4} + t_l + 2 \frac{t_b}{4}</math>, а суммарное ускорение в общем случае: <math>speedup=\frac{t_{serial}}{t_{parallel}} = \frac{n}{1+\frac{n t_i + n t_l + \log_2{n} t_b}{t_p}}</math>

На рисунке 5 приведены графики, отражающие зависимость получаемых возможных ускорений в зависимости от числа задействованных процессов, посчитанные с использованием четырех различных подходов.
[[Файл:Comparison.PNG|thumb|center|400px|Рисунок 5. Сравнение стратегий распараллеливания]]

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===

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

# первая стратегия, наиболее очевидная, состоит в том, чтобы в самом начале главный процесс считал данные о ребрах и распределил считанную информацию между остальными процессами, причем каждый из них не имеет доступа к файлу с данными. Далее каждый из процессов рассчитывает локальное минимальное остовное дерево и передает его обратно главному процессу, который объединяет деревья в одно, глобальное
# вторая стратегия во многом напоминает первую, но основное различие между ними состоит в том, что во втором случае файл с исходными данными не разделяется между процессами, а является доступным для каждого из них в полном объеме. Таким образом, каждый процесс способен считать данные о ребрах, за которые они отвечают, самостоятельно, что значительно снижает объем коммуникации между процессами. Также еще одно улучшение состоит в том, что теперь главный процесс не простаивает во время работы остальных, а, как и остальные, рассчитывает локальное минимальное остовное дерево
# наконец, третья стратегия состоит в том, чтобы оптимизировать процесс слияния локальных минимальных остовных деревьев. Предлагается сделать так, чтобы не только главный процесс занимался слиянием, но каждый процесс участвует в процессе слияния. Для того, чтобы добиться максимальной эффективности будем предполагать, что число процессов <math>p=2^n,n>1</math>. В этом случае потребуется <math>\log{p}</math> шагов, чтобы выполнить слияние. На каждом шаге половина активных процессов пересылает свое локальное дерево процессу с меньшим номером на единицу, а другая половина занимается приемом и слиянием. Таким образом, через шагов главный процесс, который имеет номер 0, будет иметь в своем распоряжении глобальное минимальное остовное дерево.

=== Масштабируемость алгоритма и его реализации ===
[[file:Total.png|thumb|center|400px|Рисунок 6. График зависимости времени вычисления от размера задачи и числа процессов (с учетом времени ввода-вывода)]]
[[file:Wo_io.png|thumb|center|400px|Рисунок 7. График зависимости времени вычисления от размера задачи и числа процессов (без учета времени ввода-вывода)]]

На графиках видно, как с увеличением объема вычислительных ресурсов происходит прирост в производительности. Данный эффект происходит до некоторых пор, после чего накладные расходы на коммуникацию между процессами нивелируют его. При дальнейшем увеличении числа процессов время решения задачи заметно увеличивается, однако, ввиду длинных очередей на суперкомпьютере Ломоносов данные с числом процессов <math> \ge 256</math> получить не удалось

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма [3]===
* C++: [http://www.boost.org/libs/graph/doc/ Boost Graph Library] (функция <code>[http://www.boost.org/libs/graph/doc/kruskal_min_spanning_tree.html kruskal_min_spanning_tree]</code>).
* C++, MPI: [http://www.boost.org/libs/graph_parallel/doc/html/index.html Parallel Boost Graph Library]
** функция <code>[http://www.boost.org/libs/graph_parallel/doc/html/dehne_gotz_min_spanning_tree.html#merge-local-minimum-spanning-trees merge_local_minimum_spanning_trees]</code> реализует алгоритм Крускала;
** функции <code>[http://www.boost.org/libs/graph_parallel/doc/html/dehne_gotz_min_spanning_tree.html#dense-boruvka-minimum-spanning-tree dense_boruvka_minimum_spanning_tree]</code>, <code>[http://www.boost.org/libs/graph_parallel/doc/html/dehne_gotz_min_spanning_tree.html#boruvka-then-merge boruvka_then_merge]</code>, <code>[http://www.boost.org/libs/graph_parallel/doc/html/dehne_gotz_min_spanning_tree.html#boruvka-mixed-merge boruvka_mixed_merge]</code> сочетают [[алгоритм Борувки]] и алгоритм Крускала.
* Python: [https://networkx.github.io NetworkX] (функция <code>[http://networkx.github.io/documentation/networkx-1.9.1/reference/generated/networkx.algorithms.mst.minimum_spanning_tree.html minimum_spanning_tree]</code>).
* Java: [http://jgrapht.org JGraphT] (класс <code>[http://jgrapht.org/javadoc/org/jgrapht/alg/KruskalMinimumSpanningTree.html KruskalMinimumSpanningTree]</code>).

= Литература =
[1] Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.

[2] http://www.gpiskas.com/pdf/kruskal_mpi.pdf (дата обращения: 02.10.2016)

[3] https://algowiki-project.org/ru/Алгоритм_Крускала

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

2016-11-16T10:58:34Z

IgorS: Новая страница: «= Статья Алгоритм кластеризации, основанный на минимальном покрывающем дереве = * п.п. 2…»

= Статья [[Алгоритм кластеризации, основанный на минимальном покрывающем дереве]] =

* п.п. 2.4 дополнить текстом исследуемой программы

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

2016-11-16T10:52:52Z

IgorS:

=== Замечания к статье ===

* содержание не соответствуют шаблону описания алгоритма: неверная нумерация, отсутствуют п.п.--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 15:30, 25 октября 2016 (MSK)
* не указан конкретный вклад каждого автора--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 15:30, 25 октября 2016 (MSK)
* п.п. 1.9 не раскрыт--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 15:30, 25 октября 2016 (MSK)
* п.п. 2.4 дополнить кодом исследуемой программы--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 13:52, 16 ноября 2016 (MSK)

== Замечания к статье "Алгоритм быстрого дискретного преобразования Фурье" ==

* Раздел 1.1 - вместо общего описания алгоритма написано именно что математическое описание. В общем описании должна быть поставлена задача и изложена основная идея, с минимумом формул [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 14:08, 11 ноября 2016 (MSK)
* Раздел 1.2 - не очень ясны слова про "проиллюстрированные на рисунке 2 в разделе Информационный граф". Раздел "Информационный граф" содержит рисунок 1. [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 14:08, 11 ноября 2016 (MSK)
* Если упоминаем рекурсию, нужны слова о глубине рекурсии [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 14:08, 11 ноября 2016 (MSK)

Участник:Vagabond/Алгоритм быстрого дискретного пребразования Фурье

2016-11-16T10:51:27Z

IgorS:

'''Автор''': Данилишин А.Р.
= ЧАСТЬ. Свойства и структура алгоритмов =

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

Главная идея БПФ состоит в сокращении многочисленных повторов сложения и умножения, которые выполняются в ДПФ (повторяющиеся множители: <math>e^{\frac{-2kpi\pi}{n}}</math> Например при условии, что <math>(pk)mod(n)=const</math>, при всех <math>k=\overline{0,n-1}</math> и <math>p=\overline{0,n-1}</math>

Напомним формулу ДПФ:

<math> y_{p}=\sum_{k=0}^{n-1}x_{k}e^{\frac{-2kpi\pi}{n}}, p=\overline{0,n-1}</math>

За счет использования данного факта, происходит значительное сокращение количества вычислительных операций. В данной статье используется алгоритм Cooley – Tukey, который предполагает собой разбиение исходного множества входных сигналов на два равных подмножества. При этом множество входных сигналов должно быть степенью двойки. Далее операция деления множества продолжается для образовавшихся подмножеств, и так далее. В результате над каждым из полученных подмножеств выполняется БПФ. Данные вычисления можно выполнять независимо друг от друга. Этот факт используется для реализации параллельной версии алгоритма. В общем алгоритм Cooley – Tukey строится из двух основных шагов:

* Преобразование входного массива данных (бит-реверсирование).
* Вычисление БПФ.
Приведем более детальное описание БПФ (математическое описание):
*Пусть <math>e^{\frac{-2kpi\pi}{n}}</math> = <math>\omega _{n}^{kp}</math>.
*Разобьем исходный сигнал <math>x(n)</math> на два подмножества, с четными <math>x_{1}(2n)</math> и нечетными <math>x_{2}(2n+1)</math> номерами.
Тогда получаем: <math>y_{p}=\sum_{k=0}^{n-1}x_{k}\omega _{n}^{kp}= \sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega _{n}^{2kp}+\sum_{k=0}^{\frac{n}{2}-1}x_{2k+1}\omega _{n}^{(2k+1)p}</math>.

Выпишем два свойства омеги:
*<math>\omega_{\frac{n}{2}}=e^{2(\frac{-2i\pi}{n})}=\omega_{n}^{2}</math>
*<math>\omega_{n}^{\frac{n}{2}}=e^{\frac{-2ni\pi}{2n}}=e^{-i\pi}=-1</math>
Воспользуемся первым: <math>y_{p}= \sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega _{n}^{2kp}+\omega_{n}^{p}\sum_{k=0}^{\frac{n}{2}-1}x_{2k+1}\omega _{n}^{2kp}=\sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega _{\frac{n}{2}}^{kp}+\omega_{n}^{p}\sum_{k=0}^{\frac{n}{2}-1}x_{2k+1}\omega _{\frac{n}{2}}^{kp}</math>. Или, если обозначить <math>y_{1}(p)=\sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega _{\frac{n}{2}}^{kp}</math>, а <math>y_{2}(p)=\sum_{k=0}^{\frac{n}{2}-1}x_{2k+1}\omega _{\frac{n}{2}}^{kp}</math>, то получим формулу для вычисления координат изображения БПФ при <math>p=\overline{0...n/2}</math>: <math>y_(p)=y_{1}(p)+\omega_{n}^{p}y_{2}(p)</math>.

Заметим, что <math>y(p); y_{1}(p); y_{2}(p)</math> обладают свойством периодичности, с периодом <math>\frac{n}{2}</math>. Покажем это для <math>y_{1}(p)</math> : <math>y_{1}(p+\frac{n}{2})=\sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega_{\frac{n}{2}}^{k(p+\frac{n}{2})}=\sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega_{\frac{n}{2}}^{kp}\omega_{\frac{n}{2}}^{\frac{kn}{2}}=\sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega_{\frac{n}{2}}^{kp}</math>

Так как: <math>\omega_{\frac{n}{2}}^{\frac{kn}{2}}=e^{\frac{-4kni\pi}{2n}}=e^{-2ki\pi}=1</math>

Далее необходимо определить <math>y(p)</math> при <math>p\geq \frac{n}{2}</math>. Теперь воспользуемся свойством периодичности обнаруженными нами ранее: <math>y(p+\frac{n}{2})=y_{1}(p+\frac{n}{2})+\omega_{n}^{(p+\frac{n}{2})}y_{2}(p+\frac{n}{2})</math>. Воспользуемся вторым свойством омеги: <math>y(p)=y_{1}(p)-\omega_{n}^{p}y_{2}(p)</math>.

В конечном итоге мы пришли к конечной формуле для первого этапа вычисления БПФ. Дальнейшие этапы делят подмножества полученные на предыдущим этапе вычисления БПФ.

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

'''Бит-реверсирование'''

Бит-реверсирование – это преобразование двоичного числа путем изменения порядка следования бит в нем на противоположный. Бит-реверсирование применимо только к индексам элементов массива и предназначено для изменения порядка следования этих элементов, при этом значения самих элементов не изменяются. Так, к примеру, четырехмерный вектор <math>(x_{0},x_{1},x_{2},x_{3})</math> изменится на <math>(x_{0},x_{2},x_{1},x_{3})</math>. Данная процедура необходима для разделения исходного сигнала на элементы подмножеств с четными и нечетными номерами, которые необходимы для вычисления <math>y_{1}(p)</math> и <math>y_{2}(p)</math>.

'''Вычисление БПФ'''

После выполнения этапа бит-реверсирования выполняются вычисления проиллюстрированные ''на рисунке 2'' в разделе [[#Информационный граф|Информационный граф]]. Рисунок 2 приведен для случая четырехмерного входного сигнала. Он предполагает совершение двух этапов. В общем же количество этапов равно <math>log_{2}n</math>. Каждый этап содержит в себе вычисление одной и той же операции "бабочки", где на вход подаются два числа <math>a</math> и <math>b</math>, на выходе же получаются <math>a+bU</math> и <math>a-bU</math>, где <math>U</math>- это ''коэффициент поворота''. Общая формула для коэффициента поворота: <math>e^{\frac{-ji\pi}{k}}</math>, где <math>k</math>- размер шага "бабочки", <math>j</math>- номер итерации вычислений над группой элементов, размером <math>2k</math> <math>(0\leq j < k )</math>.

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

Из двух вышеописанных этапов БПФ, бит-реверсирование является самым быстровыполнимым. Поэтому вычислительное ядро алгоритма будет лежать именно во втором этапе. А именно, им будет являться вычисление "бабочек". Количество этапов выполнения БПФ, как описывалось выше, равно <math>log_{2}n</math>. Учитывая количество этапов, размерность входного сигнала и идею деления на подмножества, всего "бабочек" получается <math>\frac{nlog_{2}n}{2}</math>. При этом операция умножения выполняется <math>\frac{n}{2}</math> раз. Это связано с тем, что результаты вычисления "бабочки" <math>a+bU</math> и <math>a-bU</math>.

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

Из всего вышесказанного заключаем, что макроструктуру алгоритма легче всего описать при помощи рекурсии:
*<math>\frac{n}{2}</math> преобразований Фурье порядка 2
*умножение <math>\frac{n}{2}</math> пар комплексных чисел
*<math>n</math> комплексных сложений
*снова преобразование Фурье

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

Программный код (описан на языке С++) строится из ряда функций:
*бит-реверсирование
*инициализация размерности входного сигнала
*инициализация входного сигнала (при помощи генератора случайных чисел)
*процесс очистки памяти
*выполнение операции "бабочка"
*выполнение БПФ
*функция вывода результата (для тестирования)
----
'''главный программный код БПФ:'''
<source lang="С++">
int main()
{
complex<double> *inputSignal = NULL;
complex<double> *outputSignal = NULL;
int size = 0;
cout << "FFT. Serial version." << endl;
ProcessInitialization(inputSignal, outputSignal, size);
bit(inputSignal, outputSignal, size);
SerialFFTCalculation(outputSignal, size);
PrintSignal(outputSignal, size); //в случае тестирования
ProcessTermination(inputSignal, outputSignal);
cin.get();
}
</source>
----
=== функция бит-реверсирования ===
<source lang="С++">
void bit(complex<double> inputSignal[], complex<double> *outputSignal, int size)
{ // процесс бит-реверсирования
int j = 0, i = 0;
while (i < size)
{
if (j > i)
{
outputSignal[i] = inputSignal[j];
outputSignal[j] = inputSignal[i];
}
else
if (j == i)
outputSignal[i] = inputSignal[i];

int m = size >> 1;
while ((m >= 1) && (j >= m))
{
j -= m;
m = m >> 1;
}
j += m;
i++;
}
}
</source>
=== инициализация размерности входного сигнала ===
<source lang="С++">
void ProcessInitialization(complex<double>* &inputSignal, complex<double>* &outputSignal, int &size)
{
// инициализация размера входного сигнала
do
{
cout << "Enter the input signal length: ";
cin >> size;
if (size < 4)
cout << "Input signal length should be >= 4" << endl;
else
{
int tmpSize = size;
while (tmpSize != 1)
{
if (tmpSize % 2 != 0)
{
cout << "Input signal length should be powers of two" << endl;
size = -1;
break;
}
tmpSize /= 2;
}
}
}
while (size < 4);
cout << "Input signal length = " << size << endl;
inputSignal = new complex<double>[size];
outputSignal = new complex<double>[size];
DummyDataInitialization(inputSignal, size);
}
</source>
=== инициализация входного сигнала ===
<source lang="С++">
void DummyDataInitialization(complex<double>* mas, int size)
{
for (int i = 0; i < size; i++)
{
mas[i] = int(rand() % 100);
}
}
</source>
=== процесс очистки памяти ===
<source lang="С++">
void ProcessTermination(complex<double>* &inputSignal, complex<double>* &outputSignal)
{
//очистка памяти
delete[] inputSignal;
inputSignal = NULL;
delete[] outputSignal;
outputSignal = NULL;
}
</source>
=== выполнение операции "бабочка" ===
<source lang="С++">
void Butterfly(complex<double> *signal, complex<double> &u,int offset, int butterflySize)
{
complex<double> tem = signal[offset + butterflySize] * u;
signal[offset + butterflySize] = signal[offset] - tem;
signal[offset] += tem;
}
</source>
=== выполнение БПФ ===
<source lang="С++">
void SerialFFTCalculation(complex<double> *signal, int size)
{
int m = 0;
for (int tmp_size = size; tmp_size > 1; tmp_size /= 2, m++);
for (int p = 0; p < m; p++)
{
int butterflyOffset = 1 << (p + 1);
int butterflySize = butterflyOffset >> 1;
double coeff = M_PI / butterflySize;

for (int i = 0; i < size / butterflyOffset; i++)
for (int j = 0; j < butterflySize; j++)
Butterfly(signal,complex<double>(cos(-j*coeff),sin(-j*coeff)),j+i*butterflyOffset,butterflySize);
}
}
</source>
=== функция вывода результата (для тестирования) ===
<source lang="С++">
void PrintSignal(complex<double> *signal, int size)
{
cout << "Result signal" << endl;
for (int i = 0; i < size; i++)
cout << signal[i] << endl;
}
</source>
== Последовательная сложность алгоритма ==
Рассмотренный алгоритм Cooley – Tukey выполняется за <math>nlog_{2}n</math> операций комплексного сложения и <math>\frac{n}{2}log_{2}n</math> операций комплексного умножения. Таким образом последовательная сложность алгоритма является '''линейно-логарифмической'''.
== Информационный граф ==
[[file:Граф.jpg|center|thumb|800px|Рисунок 1. Алгоритм Cooley – Tukey для n=4, при предварительно сделанном бит-реверсировании]]
== Ресурс параллелизма алгоритма ==
[[file:Парал.jpg|center|thumb|800px|Рисунок 2. Распараллеливание алгоритма Cooley – Tukey для n=8]]
Рисунок 2 получен из информационного графа, главной идеей которого является процедура деления множеств полученных на предыдущем шаге на два равных по мощности подмножества и применение к ним БПФ. То есть процесс вычисления распределяется между <math>\frac{n}{2}</math> процессорами. И так как при последовательной реализации алгоритма было <math>\frac{n}{2}\log_{2}n</math> операций комплексного умножения и <math>n\log_{2}n</math> комплексного сложения/вычитания. Получается, что при параллельной реализации алгоритма мы будем иметь <math>\log_{2}n</math> операций комплексного умножения и <math>2\log_{2}n</math> комплексного сложения/вычитания. При этом, если используется функция HT(Hyper threading), то параллельная сложность быстрого преобразования Фурье (базовый алгоритм Кули-Тьюки) для векторов с длиной, равной степени двойки составляет <math>\log_{2}n</math>.
== Входные и выходные данные алгоритма ==
*'''Вещественное ДФП'''
**входные данные:
***вектор <math>\overline{a}=(a_{1},a_{2},...,a_{N})</math>, где <math>a_{i}\in \mathbb{R}</math>
***размерность: <math>N</math> точек
**выходные данные:
***вектор <math>\overline{b}=(b_{1},b_{2},...,b_{N})</math>, где <math>b_{i}\in \mathbb{C}</math>
***размерность: <math>2N</math> точек
*'''Комплексное ДФП'''
**входные данные:
***вектор <math>\overline{a}=(a_{1},a_{2},...,a_{N})</math>, где <math>a_{i}\in \mathbb{C}</math>
***размерность: <math>2N</math> точек
**выходные данные:
***вектор <math>\overline{b}=(b_{1},b_{2},...,b_{N})</math>, где <math>b_{i}\in \mathbb{C}</math>
***размерность: <math>2N</math> точек
== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности является ''линейным''. Это хорошо видно из пункта [[#Ресурс параллелизма алгоритма|ресурс параллелизма алгоритма]].
*Вычислительная мощность алгоритма является ''логарифмической''.
*Устойчивость.
**Рассмотрим вопрос об устойчивости поближе. Так как БПФ отличается от ДПФ простым лишь сокращением одинаковых операций, то вопрос устойчивости можно рассматривать на примере ДПФ. Так, к примеру, возьмем формулу ДПФ и добавим возмущение: <math> y_{p}=\sum_{k=0}^{n-1}(x_{k}+\varepsilon )e^{\frac{-2*\pi*k*p*i}{n}}, p=\overline{0,n-1}</math>. После чего преобразуем ее: <math>y_{p}=\sum_{k=0}^{n-1}x_{k}e^{\frac{-2*\pi*k*p*i}{n}}+\varepsilon\sum_{k=0}^{n-1} e^{\frac{-2*\pi*k*p*i}{n}}</math> и оценим вторую сумму, которая является геометрической прогрессией со знаменателем <math>q=e^{\frac{-2*\pi*p*i}{n}}</math>. Таким образом оцениваемая сумма будет равняться: <math>\varepsilon\frac{1-e^{\frac{-2*\pi*p*i*(n-1))}{n}}}{1-e^{\frac{-2*\pi*p*i}{n}}}</math>. При достаточно больших размерностях входного сигнала данное выражение сводится к: <math>\varepsilon (1-e^{-2*\pi*p*i})</math>. В тригонометрической форме данного выражения: <math>\varepsilon (cos(\frac{2*\pi*p*(n-1)}{n})-i*sin(\frac{2*\pi*p*(n-1)}{n}))</math> видно, что принимая во внимание целочисленность индексов <math>p</math> получается 0. Таким образом, мы можем говорить об устойчивости алгоритма в целом, и абсолютной устойчивости алгоритма в асимптотике.
*исходя из информационного графа, можно сделать вывод о сбалансированности алгоритма.
*алгоритм полностью детерминирован.
*Степень исхода вершины информационного графа не превышает двух.
= ЧАСТЬ. Программная реализация алгоритма =
== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
[[file:масш.jpg|center|thumb|1000px|Рисунок 3. Параллельная реализация алгоритма. Изменение эффективности(%)в зависимости от числа процессоров и размера области.]]
Как описывалось выше, каждый процессор получает достаточно низкий объем работы, что приводит к неэффективному распараллеливанию алгоритма (высокие затраты на передачу данных между процессорами по сравнению с вычислениями на них). Поэтому необходимо находить оптимальное количество процессоров для каждой отдельно взятой задачи. В данном примере, при размерности входного сигнала менее 262144, оптимальное количество процессоров составляет 1. При размерности 262144-4194304 оптимум достигался при 8 процессорах. И при размерности более 4194304- 16 процессоров. Вычисления проводились на суперкомпьютере «Ломоносов».
== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Самой распространенной и известной реализацией дискретного БПФ является библиотека [http://www.fftw.org/ FFTW], разработанная Маттео Фриго и Стивеном Г. Джонсоном в Массачусетском технологическом институте. Данная библиотека существует для языков C и FORTRAN и позволяет производить вычисления в одном или нескольких измерениях. Входной сигнал может быть как действительным так и комплексным, а его размерность не обязательно должна быть степенью двойки. На данный момент последняя версия FFTW 3.3.5. Другие особенности библиотеки:
*Скорость. (Поддержка SSE / SSE2 / Altivec, начиная с версии 3.0. Версия 3.3.1 поддерживает AVX и ARM Neon.)
*Параллельные вычисления (OpenMP, MPI).
*[http://www.fftw.org/fftw3_doc/ Документация] в форматах HTML, PDF.
*Данное программное обеспечение является свободным и распространяется по лицензии GNU (General Public License).
Здесь приводится пример реализации прямого БПФ для комплексных данных входного сигнала на языке C++.
<source lang="С++">
#include <fftw3-mpi.h>
# include <stdlib.h>
# include <stdio.h>
#include <sys/stat.h>
#include <fcntl.h>
# include <time.h>
#include <math.h>

int main(int argc, char **argv)
{
const ptrdiff_t N0 = 4194304;
fftw_plan planForw;
fftw_complex *data, *dataOut;
ptrdiff_t alloc_local, local_ni, local_i_start, i, j, local_no, local_o_start;
int index, size;
double startwtime, endwtime;
MPI_Init(&argc, &argv);
fftw_mpi_init();
MPI_Comm_rank(MPI_COMM_WORLD, &index);
MPI_Comm_size(MPI_COMM_WORLD, &size);

/* get local data size and allocate */
alloc_local = fftw_mpi_local_size_1d(N0, MPI_COMM_WORLD, FFTW_FORWARD, FFTW_ESTIMATE,
&local_ni, &local_i_start, &local_no, &local_o_start);
data = fftw_alloc_complex(alloc_local);
dataOut = fftw_alloc_complex(alloc_local);
/* create plan */
planForw = fftw_mpi_plan_dft_1d(N0, data, dataOut, MPI_COMM_WORLD,
FFTW_FORWARD, FFTW_ESTIMATE);
/* initialize data to some function my_function(x,y) */
for (i = 0; i < local_ni; ++i)
{
data[i][0] = rand() / (double)RAND_MAX;
data[i][1] = rand() / (double)RAND_MAX;
}
if (index == 0){
startwtime = MPI_Wtime();

}

fftw_execute(planForw);
if (index == 0){
endwtime = MPI_Wtime();
printf("wall clock time = %f\n",
endwtime - startwtime);

}

fftw_destroy_plan(planForw);
MPI_Finalize();
}
</source>
[http://www.fftw.org/download.html Скачав] библиотеку и установив ее на рабочий компьютер, можно поэкспериментировать, используя вышеописанный исходный код. При этом, на стадии компиляции необходимо указывать директорию, где находятся заголовочные файлы и директорию, где находятся библиотечные файлы. Пример: mpicxx name.cpp -I/path/to/include/files -L/path/to/lib/files -lfftw3_mpi -lfftw3 -lm. Для версии 2.1.4 описание на русском языке приводится [https://parallel.ru/cluster/fftw.html здесь].

Остальные реализации:
*[http://www.gnu.org/software/gsl/ GSL - GNU Scientific Library]
*[https://developer.nvidia.com/cufft cuFFT]
*[http://www-03.ibm.com/systems/power/software/essl/ Engineering and Scientific Subroutine Library (ESSL) and Parallel ESSL]
=Литература=
[1] Бахвалов Н. С., Жидков Н. П., Кобельков. Г. М. — 6-е изд. — М. : БИНОМ. Лаборатория знаний

[2] Г. Нуссбаумер. Быстрое преобразование Фурье и алгоритмы вычисления сверток

[3] А.О. Лапаев Параллельное вычисление дискретного преобразования Фурье полинома в простом поле

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

2016-11-16T10:46:47Z

IgorS: /* Замечания к статье */

=== Замечания к статье ===

* содержание не соответствуют шаблону описания алгоритма--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 15:21, 25 октября 2016 (MSK)
* не указан конкретный вклад каждого автора--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 15:21, 25 октября 2016 (MSK)
* п.п. 1.9 не раскрыт--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 15:21, 25 октября 2016 (MSK)
* п.п. 2.4 не заполнен--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 13:46, 16 ноября 2016 (MSK)

== Замечания к статье "Быстрое преобразование Фурье" ==

* Раздел про общее описание алгоритма слишком большой и нарезан на много частей. Было бы лучше написать статью про саму задачу преобразования Фурье, где и упоминались бы в частности области применения, а также разные алгоритмы с краткими описаниями (а впоследствии со ссылками на статьи с полным описанием) [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:56, 11 ноября 2016 (MSK)
* При упоминании рекурсивного решения задачи следует сказать о глубине рекурсии [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:56, 11 ноября 2016 (MSK)

Участник:Victoria Stepanischeva/Быстрое преобразование Фурье (FFT)

2016-11-16T10:46:12Z

IgorS:

Авторы:

* [[Участник:Victoria_Stepanischeva|Степанищева В.С.]], группа 601 (Общее описание алгоритма, Вычислителное ядро алгоритма, Макроструктура алгоритма, Информационный граф, Ресурс параллелизма алгоритма)
* [[Участник:Igor_Munkin|Мунькин И.А.]], группа 601 (Математическое описание алгоритма, Схема реализации последовательного алгоритма, Последовательная сложность алгоритма, Входные и выходные данные алгоритма, Свойства алгоритма, Существующие реализации алгоритма)

{{algorithm
| name = Быстрое преобразования Фурье
| serial_complexity = <math>O(N \; log \, N)</math>
| input_data = <math>N</math>
| output_data = <math>N</math>
| pf_height = <math>O(log \,N)</math>
| pf_width = <math>N</math>
}}

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

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

Алгоритм '''быстрого преобразования Фурье''', включая его рекурсивную
реализацию, был использован
[https://en.wikipedia.org/wiki/Carl_Friedrich_Gauss Карлом Фридрихом Гауссом]
еще в 1805 году для интерполяции траекторий астероидов, однако эта работа не
получила широкого признания. Алгоритм быстрого преобразования Фурье обрел свою
популярность благодаря работе
[https://en.wikipedia.org/wiki/James_Cooley James Cooley], работающего в то
время в [https://en.wikipedia.org/wiki/IBM IBM], и
[https://en.wikipedia.org/wiki/John_Tukey John Tukey], параллельно принимающего
участие в разработках [https://en.wikipedia.org/wiki/Bell_Labs Bell Labs] и
работающего в
[https://en.wikipedia.org/wiki/Princeton_University Принстонском университетe].
В их статье, изданной в 1965 году, они представили подробное описание алгоритма
и его программной реализации.

====Разновидности алгоритма быстрого преобразования Фурье====
Помимо традиционного и наиболее распространенного алгоритма
[https://en.wikipedia.org/wiki/Cooley%E2%80%93Tukey_FFT_algorithm Cooley-Tukey]
существует также несколько других часто используемых реализаций алгоритма
быстрого преобразования Фурье.

=====PFA-алгоритм=====
Алгоритм [https://en.wikipedia.org/wiki/Prime-factor_FFT_algorithm prime-factor]
(PFA), также называемый алгоритмом Good-Thomas, представляет собой алгоритм
быстрого преобразования Фурье, который представляет дискретное преобразование
Фурье размера <math>N = N_1 \cdot N_2</math> в виде двумерного
<math>N_1 \times N_2</math> дискретного преобразования Фурье, при условии, что
<math>N_1</math> и <math>N_2</math> - взаимно простые числа. Представленные
преобразования меньшего размера могут быть вычислены либо рекурсивным
применением PFA либо используя какой-либо иной метод быстрого преобразования
Фурье.

=====Алгоритм Bluestein=====
Алгоритм
[https://en.wikipedia.org/wiki/Chirp_Z-transform#Bluestein.27s_algorithm Bluestein],
обычно называемый <math>\mathcal{Z}</math>-чирп алгоритмом, представляет собой
алгоритм быстрого преобразования Фурье, который вычисляет дискретное
преобразование Фурье различных размеров с помощью представления оного в виде
линейной свертки. Другой алгоритм быстрого преобразования Фурье, использующий
свойства простых чисел, алгоритм
[https://en.wikipedia.org/wiki/Rader%27s_FFT_algorithm Rader], также вычисляет
дискретное преобразование Фурье в виде свертки.

====Приложения быстрого преобразования Фурье====

Алгоритм быстрого преобразования Фурье имеет множество областей приложения,
таких как:
* Обработка изображений
* Цифровое сжатие
* Численное интегрирование
* Быстрые методы решения уравнения Пуассона
* Спектральные методы решения обыкновенных дифференциальных уравнений

Рассмотрим подробнее те приложения, с которыми мы наиболее часто сталкиваемся
в повседневной жизни.

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

Частотная фильтрация является более общим механизмом фильтрации, чем
пространственная. Все пространственные фильтры можно реализовать с помощью
частотных. Частотные фильтры выполняют фильтрацию изображений в частотной
области. Для этого с помощью преобразования Фурье происходит получение спектра
изображения. После применения фильтра к спектру изображения выполняется обратное
преобразование Фурье и получается отфильтрованное изображение.

Простота фильтрации в частотной области заключается в простой интерпретации
частот:
* низкие частоты - плавное изменение яркости изображения
* высокие частоты - быстрое изменение яркости изображения (границы объектов)
За счет изменения значений определенных частот можно добиться размытия
изображения, повышение резкости и др.

=====Цифровое сжатие=====
Одним из первых форматов файла-контейнера для хранения записи оцифрованного
аудипотока является формат WAV. Этот формат чаще всего используется в качестве
оболочки для несжатого звука. При таком кодировании в WAV-файле хранится полная
информация об исходном звуке, оцифрованном и проквантованном с некоторой
частотой, например 44 кГц. Этой информации абсолютно достаточно для
воспроизведения всех частот исходного сигнала, меньших половины частоты
квантования (по [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BE%D1%80%D0%B5%D0%BC%D0%B0_%D0%9A%D0%BE%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D0%B8%D0%BA%D0%BE%D0%B2%D0%B0 теореме Котельникова] ). При этом одна
минута записи занимает около 15 Мб, поэтому в настоящее время очень популярным
стал формат кодирования MPEG Layer-3 со сжатием.

При сжатии кодеком MPEG Layer-3 исходный звуковой сигнал разбивается на
фрагменты, длительностью по 50 миллисекунд, каждый из которых анализируется
отдельно. При анализе фрагмент раскладывается на гармоники по методу Фурье, из
которых в соответствии с теорией восприятия звука человеческим ухом
выбрасываются те гармоники, которые человек хуже воспринимает на фоне остальных:
* более тихие гармоники на фоне более громких
* звуки, замаскированные вследствие инертности слуха (так, например, если за очень громким хлопком, с задержкой в долю секунды, пойдет какой-то иной кратковременный сигнал, то его слышно не будет)

При воспроизведении файла закодированного MPEG Layer-3 производится обратное
преобразование, при котором оставшиеся гармоники вновь преобразуются в звуковую
волну. Поскольку часть информации об исходном сигнале была удалена, звук
получается не совпадающий с исходным. Одной из основных характеристик качества
аудио потока является битрейт.

''Битрейт'' - это объем информации на каждую секунду записи:
* чем он меньше, тем меньший размер имеют файлы с одинаковой по времени длине
* чем он меньше, тем большее количество "лишних" гармоник приходится удалять

===Математическое описание алгоритма===
Пусть задан вектор действительных чисел
<math>\left(f_1, f_2, f_3, \dots, f_{N-1} \right)</math>

Дискретное преобразование Фурье определено следующим образом

<math>
F_k = \sum_{n = 0}^{N - 1}\, f_n\, e^{\left(\frac{i2\pi kn}{N}\right)}
</math>

Обозначим <math>W_N = e^{\left(\frac{i2\pi}{N}\right)}</math> - <math>N</math>-ый
корень единицы. Таким образом <math>(W_N)^N = 1</math>. Несложные математические
преобразования приводят формулу дискретного преобразования Фурье к следующему
виду

<math>
F_k = \sum_{n = 0}^{N - 1}\, f_n\, W_n^{-nk}
</math>

Таким образом, алгоритм вычисления дискретного преобразования Фурье состоит из
2 шагов:
# Вычисление поворотных коэффициентов <math>W_n^{-nk},\; n,k = 0, 1, \dots, N-1</math>
# Вычисление коэффициентов Фурье <math>F_k,\; k = 0, 1, \dots, N-1</math>

В основе концепции быстрого преобразования Фурье лежит идея отдельного расчета четных и
нечетных коэффициентов с использованием векторов меньшего размера. Разобъем дискретное
преобразование Фурье следующим образом

<math>
F_k = \sum_{n = 0}^{N - 1}\, f_n\, W_{N}^{-nk}
= \sum_{n = 0}^{N/2 - 1}\, g_n\, W_{N/2}^{-nk}
+ \sum_{n = 0}^{N/2 - 1}\, h_n\, W_{N/2}^{-nk}
</math>

Следовательно, четные и нечетные коэффициенты Фурье могут быть записаны в
следующем виде:

<math>
F_{2k} = \sum_{n = 0}^{N/2 - 1}\, \underbrace{
\left(f_n + f_{n + N/2}\right)
}_{g_n} \, W_{N/2}^{-nk}
</math>

<math>
F_{2k+1} = \sum_{n = 0}^{N/2 - 1}\, \underbrace{
\left((f_n + f_{n + N/2}) W^{-n}\right)
}_{h_n} \, W_{N/2}^{-nk}
</math>

Таким образом, вычисление дискретного преобразования Фурье от <math>N</math>
коэффициентов сводится к вычислению 2 дискретных преобразований Фурье от
<math>N/2</math> коэффициентов. Применяя данную идею рекурсивно, получаем
алгоритм быстрого преобразования Фурье.

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

[[File:Stepmoon_buttefly.png|left|200px]]
В случае размера входных данных равному <math>N = 2^M</math> вычислительным
ядром алгоритма являются так называемые "бабочки". В элементарном случае
"бабочка" является двухточечным преобразованием.

<math>
g_n = f_n + f_{n + N/2}
</math>

<math>
h_n = \left(f_n - f_{n + N/2}\right)\, W^{-n}
</math>

===Макроструктура алгоритма===
Описываемый алгоритм работает по принципу
[https://en.wikipedia.org/wiki/Divide_and_conquer_algorithms "разделяй и властвуй"].

Рассмотрим общую структуру для входных данных размера <math>N = N1 \cdot N2</math>
# Исходное множество точек разбивается на <math>N2</math> равных подмножеств размером <math>N1</math>.
# Над каждым из полученных множеств выполняется быстрое преобразование Фурье. Для его вычисления над каждым из подмножеств рассматриваемого множества снова выполняется деление на равные части. Такое разбиение продолжается до тех пор, пока количество элементов, над которыми необходимо выполнить быстрое преобразование Фурье, не будет равно одному.
# После этого выполняется объединение всех промежуточных результатов. Полученные на предыдущем шаге множества объединяются за линейное время.

Ниже представлена схема алгоритма Cooley-Tukey для <math>N = 2^M</math>

[[File:Stepmoon_macro.png|center|800px]]

===Схема реализации последовательного алгоритма===
Ниже представлен прототип реализации для <math>N = 2^M</math>.
<source lang=perl>
use Math::Complex;

sub fft {
my $input = shift;
return $input if @{ $input } == 1;
my @w = map {
my $theta = 2 * pi * $_ / @{ $input };
Math::Complex->make(cos($theta), sin($theta));
} (0 .. $#input);
my $odd = fft([ map { $input->[2 * $_ + 1] }, (0 .. @{ $input } / 2 - 1) ]);
my $even = fft([ map { $input->[2 * $_] }, (0 .. @{ $input } / 2 - 1) ]);
return [ map {
$even->[$_ % @{ $even }] + $w[$_] * $odd->[$_ % @{ $odd }];
} (0 .. $#input) ];
};
</source>

===Последовательная сложность алгоритма===
Если считать только главные члены выражений для последовательной сложности алгоритма, то простой алгоритм Cooley-Tukey может быть выполнен за <math>N\, log\, N</math> операций. Таким образом, простой алгоритм Cooley-Tukey относится к линейно-логарифмическому классу по последовательной сложности.

===Информационный граф===
Ниже представлен информационный граф для простого алгоритма Cooley-Tukey для <math>N = 8</math>, <math>\;h</math> - операция сложения двух комплексных чисел, <math>g</math> - операция вычитания двух комплексных чисел и умножения результата вычитания на комплексное число (поворотный множитель). В последнем столбце операций умножения не производится.

[[File:Stepmoon_Info_graph.png|center|500px]]

===Ресурс параллелизма алгоритма===
Простой алгоритм Cooley-Tukey имеет критический путь, состоящий из
<math>log\, N</math> операций сложения и вычитания и <math>log\, N</math>
операций комплексного умножения (основание логарифма зависит от выбранного на
каждом шаге алгоритма разбиения). Следовательно, простой алгоритм быстрого
преобразования Фурье в общем случае может быть отнесен к логарифмическому классу
по параллельной сложности.

===Входные и выходные данные алгоритма===
'''Входные данные:''' измеренные значения сигнала в дискретных временных точках с номерами <math>0 \dots N</math>: <math>f \in \mathbb{R}^N</math>.

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

'''Выходные данные:''' вектор компонент спектра исходного сигнала: <math>F \in \mathbb{C}^N</math>.

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

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

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

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

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

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

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

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

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

===Существующие реализации алгоритма===
Наиболее популярной библиотекой, содержащей реализацию быстрого преобразования
Фурье, является [http://fftw.org/ FFTW], изначально разработанная сотрудниками
[https://en.wikipedia.org/wiki/Massachusetts_Institute_of_Technology MIT]
Matteo Frigo и Steven G. Johnson. На сегодняшний день исходный код библиотеки
распространяется под свободной лицензией
[https://en.wikipedia.org/wiki/GNU_General_Public_License#Version_2 GNU General Public Licence v2]
с помощью сервиса [https://github.com/FFTW/fftw3 Github], тем самым давая
возможность сообществу принимать участие в разработке. Несмотря на то, что сама
библиотека [http://fftw.org/faq/section2.html#whynotfortran написана на языке C]
существуют интерфейсы для работы с ней используя такие языки программирования
как Fortran, C++ и другиe.

Для разбиения преобразований, размеры которых являются составным числом, на
меньшие используется одна из многочисленных реализаций алгоритма
[https://en.wikipedia.org/wiki/Cooley%E2%80%93Tukey_FFT_algorithm Cooley-Tukey]
(в зависимости от разложения на простые множители и паттернов доступа к памяти).
В свою очередь для преобразований, размеры которых являются простыми числом
используется либо алгоритм
[https://en.wikipedia.org/wiki/Rader%27s_FFT_algorithm Raider], либо алгоритм
[https://en.wikipedia.org/wiki/Chirp_Z-transform#Bluestein.27s_algorithm Bluestein].
Библиотека признана самой быстрой реализацией быстрого преобразования Фурье,
гарантируя на любых объемах входных данных сложность
<math>O \left(n\; log\, n \right)</math>. Существует реализация FFTW и с
поддержкой [https://en.wikipedia.org/wiki/Message_Passing_Interface MPI],
позволяющая работать с данными не помещающимися в память. Однако перегруппировка
данных приводит к оверхеду, которого трудно избежать при in-place вычислении
преобразований различных размеров.

==Литература==
[1] L. Rabiner, B. Gold, ''"Theory and application of digital signal processing"'' // Prentice Hall, New Jersey, 1975.

[2] Бахвалов Н.С., Жидков Н.П., Кобельков Г.М. ''"Численные методы"'' // БИНОМ. Лаборатория знаний, Москва, 2008.

[3] M. Frigo, S. G. Johnson ''"FFTW Documentation"'' // [http://fftw.org/fftw3_doc/ fftw.org]

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

2016-11-16T10:45:25Z

IgorS:

== Замечания к статье ==

* п.п. 2.4-2.6 не соответствуют содержанию описания алгоритма--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 15:10, 25 октября 2016 (MSK)
* не указаны авторы статьи и их вклад--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 15:10, 25 октября 2016 (MSK)
** Автор один, я (Тимохин Иван, 603 гр. ВМК МГУ) --[[Участник:Timokhinivan|Timokhinivan]] ([[Обсуждение участника:Timokhinivan|обсуждение]]) 14:50, 27 октября 2016 (MSK)
*** Так укажите себя, чтобы не было таких вопросов--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:41, 31 октября 2016 (MSK).
* в п.п. 2.4 следует добавить исходный код программы и описание компьютерной платформы.--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 13:45, 16 ноября 2016 (MSK)

== Замечания к статье "Быстрое преобразование Фурье" ==

* В общем описании алгоритма нужны слова именно про алгоритм: следует рассказать идею быстрого преобразования, с минимумом формул [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:46, 11 ноября 2016 (MSK)
* Не вполне понятны слова "первообразный корень из 1 степени N" [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:46, 11 ноября 2016 (MSK)
* В последней формуле раздела 1.2 индексы k и l, кажется, должны идти через запятую. Если там рассматривается их произведение, следует уточнить, какие значения принимает каждый из них [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:46, 11 ноября 2016 (MSK)
* Раздел 1.2.3 - понятие "порядок преобразования" нуждается в пояснении [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:46, 11 ноября 2016 (MSK)
* Не хватает слов о глубине рекурсии [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:46, 11 ноября 2016 (MSK)

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

2016-11-16T10:45:15Z

IgorS:

Участник:Timokhinivan/Быстрое преобразование Фурье

2016-11-16T10:43:43Z

IgorS:

{{algorithm
| name = Быстрое преобразование Фурье
| serial_complexity = <math>O(N \log N)</math>
| pf_height = <math>O(\log N)</math>
| pf_width = <math>O(N)</math>
| input_data = <math>N</math>
| output_data = <math>N</math>
}}

Автор описания: [[U:Timokhinivan|Тимохин И.В.]], ВМК МГУ.

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

=== Общее описание алгоритма ===
В общем случае многомерное преобразование Фурье соответствует умножению на матрицу преобразования по каждой из координат, что для массива данных <math>N_1\times N_2 \times \cdots \times N_m</math> означает выполнение <math>\sum_{i=1}^m \prod_{k\neq i} N_k</math> одномерных преобразований. Ключевым наблюдением, приводящим к быстрому алгоримту для вычисления преобразования, является возможность свести (с некоторыми оговорками) одномерное преобразование к двумерному, которое для <math>N = mn</math> требует <math>m + n</math> рекурсивных вызовов, что, при применении такого метода на всех уровнях рекурсии, даёт общую сложность алгоритма <math>O(N \log N)</math>.

=== Математическое описание алгоритма ===
Преобразование Фурье задаётся следующей формулой:
:<math>
Y_k = \sum_{l = 0}^{N-1} X_l \epsilon^{kl}_N,\qquad k = \overline{0,N-1}
</math>
где <math>\epsilon_N = e^{-\frac{2i\pi}{N}}</math> — первообразный корень
из 1 степени <math>N</math> (т.е. <math>\epsilon_N</math> является корнем из 1 степени <math>N</math>, но не является корнем никакой меньшей степени). Число <math>N</math> при этом называется порядком преобразования.

Таким образом, преобразование Фурье является линейным и задаётся
матрицей <math>F = \left\{ \epsilon^{kl}_N \right\}_{k,l = 0}^{N-1}</math>.

==== Многомерное преобразование Фурье ====
Естественным обобщением описанного одномерного преобразования Фурье является многомерный вариант:
:<math>
Y(l_1,\ldots,l_d) = \sum_{k_1 = 0}^{N_1-1} \cdots \sum_{k_d = 0}^{N_d-1} X(k_1,\ldots,k_d) \prod_{j=1}^{d} \epsilon_{N_j}^{l_j k_j}
</math>

Многомерное преобразование Фурье эквивалентно последовательному выполнению одномерных преобразований по каждому измерению; при использовании для этого рекурсивного алгоритма, общая сложность вычислений также составляет <math>O(N\log N)</math>, <math>N = \prod_{j=1}^d N_j</math>.

==== Сведение к (почти) двумерному преобразованию (алгоритм Кули-Тьюки) ====

Если <math>N</math> — составное, т.е. <math>N = mn</math>, то возможно
существенно сократить вычислительные расходы за счёт сведения к
двумерному преобразованию Фурье. А именно, положим <math>X(l_1, l_2)
= X_{l_1 n + l_2}</math>, <math> Y(k_1, k_2) = Y_{k_1 m + k_2}</math>,
где <math>l_1, k_2 = \overline{0, m-1}</math>, <math>l_2, k_1 =
\overline{0, n-1}</math>.

В этом случае<ref name="bachv">Н.С. Бахвалов, Н.П. Жидков, Г.М. Кобельков, ''Численные методы'', 2003 г., ISBN: 5-94774-060-5</ref>
:<math>
\begin{align}
Y(k_1, k_2) &=& \sum_{l_2=0}^{n-1} (\epsilon^{k_2 l_2}_N \hat{X}(k_2, l_2)) \epsilon^{k_1 l_2}_n \\
\hat{X}(k_2, l_2) &=& \sum_{l_1=0}^{m-1} X(l_1, l_2) \epsilon^{k_2 l_1}_m
\end{align}
</math>

Это даёт следующий алгоритм вычисления преобразования:

# Записываем исходный вектор в матрицу <math>m\times n</math> по строкам.
# Применяем к каждому столбцу преобразование Фурье.
# Умножаем элемент в позиции <math>(i,j)</math> на <math>\epsilon^{ij}_N</math>.
# Применяем к каждой строке преобразование Фурье.
# Результат записан в получившейся матрице по столбцам.

Данный алгоритм уже даёт существенный выигрыш по сравнению с обычным
умножением матрицы на вектор: <math> O(m^2 n + n^2 m) </math> против
<math>O(m^2 n^2)</math>. Однако наилучших результатов можно добиться,
если применять этот алгоритм рекурсивно на этапах 2 и 4.

Так, если <math>N = \prod_{i=1}^{K} p_i</math>, то целесообразно
на каждом уровне рекурсии «отщеплять» одно <math>p_i</math> (уровней рекурсии при этом будет <math>K \sim \log N</math>). В этом
случае задача сводится к вычислению <math> \prod_{i\neq j} p_i </math>
преобразований Фурье порядка <math>p_j</math> для всех
<math>j</math>. При небольших <math>p_i</math> (например, 2), это
можно проделывать «в лоб».

==== Преобразование Фурье с большим простым порядком (алгоритм Радера) ====

В случае, если порядок преобразования простой, но ещё слишком большой, чтобы вычислять его непосредственно, задача усложняется. Алгоритм в этом случае такой:

# <math> Y_0 = \sum_{l=0}^{N-1} X_l</math> вычисляется непосредственно.
# Любым способом вычисляется <math>g</math> — первообразный корень мультипликативной группы поля <math>\mathbb{Z}_{N}</math>.
# <math> Y_{g^{N-p} \bmod N} = X_0 + \sum_{q=0}^{N-2} X_{g^q \bmod N} \epsilon_N^{g^{q-p}\bmod N} </math>.

Последнее выражение представляет собой свёртку и вычисляется с помощью всё того же преобразования Фурье. В принципе, это можно проделывать непосредственно, поскольку порядок свёртки <math>N - 1</math> уже составной (по меньшей мере чётный), но, поскольку свёртка, в отличие от самого преобразования Фурье, допускает увеличение порядка, имеет смысл воспользоваться этим и выбрать порядок с небольшими простыми множителями.

Таким образом, поскольку при правильной реализации подавляющее большинство рекурсивных вызовов будет использовать алгоритм Кули-Тьюки, в дальнейшем будет рассматриваться именно он.

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

На каждом уровне рекурсии наиболее дорогостоящими этапами являются
рекурсивные вызовы преобразования Фурье: они требуют в сумме
<math>O(mn (\log m + \log n))</math> операций против
<math>O(mn)</math> для умножения на поправочные коэффициенты (шаг 3).

То же верно и для алгоритма в целом в случае <math>N = \prod_{i=1}^{K} p_i</math>;
а именно, суммарно наибольшие вычислительные затраты связаны с
вычислением преобразований Фурье порядка <math>p_i</math>.

=== Макроструктура алгоритма ===
Фактически, макроструктура алгоритма уже описана в разделе
математического описания. На каждом уровне рекурсии, алгоритм состоит
из

# <math>n</math> рекурсивных вызовов алгоритма.
# Умножение всех элементов рабочего вектора на поправочные коэффициенты.
# Ещё <math>m</math> рекурсивных вызовов.

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

Псевдокод (для метода Кули-Тьюки):
<nowiki>fft(X, N)
begin
(m, n) = factor(N)

if (n == 1) // Предполагается, что n <= m
direct_fft(X, N) // Через умножение на матрицу

// 1
transpose(X, m, n) //Транспонирует X как матрицу m x n, хранящуюся по строкам

// 2
do i = 0, n - 1
fft(X(i * m : (i + 1) * m - 1), m)

// 3
do i = 0, n - 1
do j = 0, m - 1
X(i * m + j) *= eps(i * j, N)

// 4
transpose(X, n, m)

// 5
do j = 0, m - 1
fft(X(j * n : (j + 1) * n - 1), n)

// 6
transpose(X, m, n)
end</nowiki>

Здесь <code>eps</code> может как вычислять соответствующие коэффициенты, так и брать их из заранее заготовленной таблицы. Последний способ требует увеличения затрат по памяти, но позволяет существенно сэкономить на вычислениях, а потому является предпочтительным.

Кроме того, шаги 3 и 4 можно переставлять произвольным образом (с очевидными изменениями в шаге 3).

Особо следует отметить, что если порядок элементов в выходном массиве не важен, шаг 6 можно пропустить.

Так, например, если преобразование Фурье используется для вычисления свёртки векторов, то конкретный порядок элементов в их образах Фурье совершенно не важен, лишь бы он был одинаков для обоих векторов. В этом случае в прямом преобразовании можно опустить шаг 6, а в обратном — 1.

Если необходимо учитывать случай большого простого <math>N</math> (что может и не требоваться, в зависимости от задачи), то в первом условном операторе следует дополнительно проверить величину <math>N</math> и, если <math>N</math> большое, переключиться на алгоритм Радера.

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

Непосредственно из описания алгоритма получаем, что если сложность
вычисления преобразования Фурье обозначить <math>f_N</math>, то
<math>f_{mn} = n f_{m} + m f_{n} + mn</math>.

Если <math>N = \prod_{i=1}^K p_i</math>, и на каждом шаге
«отщеплять» от него одно <math>p_i</math>, а преобразование Фурье для
<math>p_i</math> вычислять «в лоб», то общее количество операций
составит <math>O\left(N\sum_{i=1}^K p_i\right)</math>.

В частности, если <math>p_i \leq P</math>, то <math>K \leq \log_P N</math>
и для сложности получаем <math>O(NP\log_P N)</math>. Полагая
<math>P</math> фиксированным, получаем заявленную сложность <math>O(N \log N)</math>.

=== Информационный граф ===
[[Файл:FourierRecursiveGraph.svg|center|thumb|600px|'''Рисунок 1.''' Информационный граф алгоритма Кули-Тьюки для <math>N = 15</math>. Исходные данные обозначены фиолетовым, результат — красным. Преобразования Фурье для <math>m = 5</math> и <math>n = 3</math> представлены как «чёрные ящики». Умножение на поворотные коэффициенты представлено оранжевыми узлами.]]

Каждый уровень рекурсивного вызова состоит из трёх этапов: рекурсивный вызов по столбцам, умножение на поправочные коэффициенты и рекурсивного вызова по строкам. Таким образом для высоты ЯПФ имеем
:<math>
h(mn) = 1 + h(m) + h(n)
</math>

Для «элементарных» БПФ высота ЯПФ будет та же, что и для [[Умножение плотной матрицы на вектор|умножения матрицы на вектор]].

Таким образом, с учётом разложения <math>N</math>, <math>h(N) = O\left(\sum_{i=1}^K p_i\right) = O(P \log_P N) = O(\log N)</math>.

=== Ресурс параллелизма алгоритма ===
Поскольку все рекурсивные вызовы преобразования Фурье на каждом из этапов совершенно
независимы, кажется естественным распределить их по доступным
вычислительным узлам. Умножение на поворотные коэффициенты при этом и вовсе выполняется независимо
на каждом элементе рабочего вектора, и может быть беспрепятственно
присоединёно к любому из этапов.

При этом, в отличие от традиционной реализации, в которой на каждом этапе один из множителей берётся
малым, при параллельной реализации целесообразно взять и
<math>m</math> и <math>n</math> по возможности близкими к кратным
доступному количеству вычислительных узлов, поскольку в этом случае
возможно равномерно распределить работу между ними и реализовать весь
алгоритм всего с одной внутренней пересылкой.

=== Входные и выходные данные алгоритма ===
В общем случае на входе и на выходе имеются комплексные векторы
порядка <math>N</math>. Однако в частных случаях, возможны более компактные представления для параметров и результатов.

Для описания этих случаев нам понадобится матрица
:<math>
Q = \begin{bmatrix}
1 & & & & & \\
& & & & & 1 \\
& & & & 1 & \\
& & & \cdots & & \\
& & 1 & & & \\
& 1 & & & &
\end{bmatrix}
</math>

# Если <math>X</math> — вещественный, то <math>Y = Q\bar{Y}</math>.
# Если <math>X</math> — чисто мнимый, то <math>Y = -Q\bar{Y}</math>.
# Если <math>X = Q\bar{X}</math>, то <math>Y</math> — вещественный.
# Если <math>X = -Q\bar{X}</math>, то <math>Y</math> — чисто мнимый.

В каждом случае, <math>X</math> и <math>Y</math> требуют для своего хранения в два раза меньше памяти, чем в общем случае.

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

=== Свойства алгоритма ===
Обозначая матрицу преобразования <math>F</math>, имеем<ref name="voevodtyrt">В.В. Воеводин, Е.Е. Тыртышников, ''Вычислительные процессы с теплицевыми матрицами'', Москва, «Наука», 1987 г.</ref>:

# <math>F = F^T</math>
# <math>F^{-1} = \tfrac{1}{N} F^*</math>
# <math>F^* = QF </math>

Свойство 2 представляет особый интерес, поскольку позволяет вычислять обратное преобразование Фурье по тем же алгоритмам, что и прямое, поскольку <math>F^*</math> представляет собой матрицу того же вида, что и <math>F</math>, но с <math>\bar{\epsilon}</math> вместо <math>\epsilon</math>. В сущности, свойство 3 позволяет свести задачу к исходной непосредственно, но ценой дополнительных пересылок.

Кроме того, из второго свойства следует
:<math>
\|F x\|_2 = \sqrt{N} \|x\|_2
</math>
что свидетельствует о численной устойчивости алгоритма.

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

При реализации последовательной версии алгоритма (а равно и параллельной, поскольку на определённом уровне рекурсии алгоритм всё равно будет выполняться на каждом узле независимо) стоит иметь ввиду несколько вещей:

==== Поворотные коэффициенты ====

Как уже упоминалось, поворотные коэффициенты имеет смысл вычислить заранее и хранить в специальном массиве. Отдельное внимание при этом стоит обратить на передачу этого массива в рекурсивные вызовы.

В самом деле, поскольку <math>\epsilon^{l}_{n} = \epsilon^{lm}_{mn} = \epsilon^{lm}_{N}</math>, все необходимые рекурсивному вызову значения поворотных коэффициентов уже имеются в используемом в текущем вызове массиве, а потому его достаточно подготовить один раз на весь алгоритм.

==== Нерекурсивный случай ====

На нижнем уровне рекурсии преобразование Фурье вычисляется путём умножения на матрицу. Поскольку этот алгоритм, вообще говоря, более пригоден для векторизации, чем рекурсивная реализация, имеет смысл не разбивать <math>N</math> на ''совсем'' мелкие множители (<math>p_i \equiv 2</math> в алгоритме Кули-Тьюки) а останавливаться на преобразованиях несколько большего порядка; конкретный уровень зависит от конкретной реализации и архитектуры и должен быть установлен экспериментально.

==== Пересылки ====

Теоретически, возможна реализация алгоритма совсем без пересылок, если предполагать, что алгоритм оперирует «разреженным» вектором, элементы которого расположены с некоторым шагом по памяти. Однако ценой такой экономии будет существенно худшая локальность обращений к данным в рекурсивных вызовах. По-видимому, выбор нужно опять-таки осуществлять экспериментально.

Эти соображения в равной степени относятся как к рабочему массиву, так и к массиву поворотных коэффициентов.

==== Предварительные вычисления ====

''Многие'' используемые в алгоритме данные зависят только от порядка преобразования — массив поворотных коэффициентов, факторизация <math>N</math>, <math>g</math> в алгоритме Радера, конкретная задаваемая им перестановка и оптимальный порядок свёртки там же. Вычисление некоторых из них сопоставимо по сложности со всем остальным алгоритмом. Имея это ввиду, если планируется вычисление нескольких преобразований Фурье одного порядка, имеет смысл подготовить все эти данные заранее.

==== Численная устойчивость ====

Поскольку все преобразования в алгоритме являются, с точностью до константы <math>\leq \sqrt{N}</math>, унитарными, катастрофического роста ошибок округления не предвидится, а потому все вычисления возможно проводить с целевой точностью.

=== Локальность данных и вычислений ===
[[Файл:IT_FFTMemaccess.png|center|thumb|800px|Рисунок 2. Профиль обращений в память простого алгоритма Кули-Тьюки с <math>p = (2, 2, 3, 5, 2)</math>. Сверху вниз: вспомогательная память для прямого умножения матрицы на вектор, память для хранения поворотных коэффициентов, рабочий вектор. Реализация не использует транспонирования векторов в явном виде.]]

Как видно, алгоритм в целом обладает невысокой локальностью, что связано с его структурой (множество рекурсивных шагов, каждый из которых охватывает существенную часть рабочего вектора) и организацией доступа к поворотным коэффициентам. Некоторого улучшения локальности можно добиться, если транспонировать рабочую «матрицу» в памяти, но это либо требует дополнительной памяти, либо, если транспонировать «на месте», существенно усложняет алгоритм.

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

В случае составного <math>N</math> с ''достаточно'' большими делителями, наиболее очевидным и простым вариантом является распределение по процессорам рекурсивных вызовов алгоритма Кули-Тьюки. В этом случае на весь алгоритм приходится только три пересылки, но зато они проходят по схеме «все-со-всеми» (транспонирование матрицы) и не могут выполняться параллельно с вычислениями.

Отдельно заметим, что, как уже упоминалось, первой либо последней группы пересылок можно избежать, если порядок элементов результата не важен.

Если <math>N</math> простое либо один из множителей в <math>N = mn</math> всегда мал, ситуация усложняется. В этом случае придётся применять алгоритм Радера на межпроцессорном уровне, что связано с более сложной схемой пересылок и большим их количеством (т.к. приходится осуществлять преобразование Фурье дважды: прямое и обратное).

В связи с этим, некоторые существующие реализации (например, Intel® MKL) просто не поддерживают этот случай. Впрочем, некоторые реализации не поддерживают большие простые делители ''вовсе''.

=== Масштабируемость алгоритма и его реализации ===
Хотя, как уже было указано, алгоритм поддаётся реализации с относительно небольшим числом пересылок, следует отметить, что вычислительна нагрузка на отдельные вычислительные ядра невелика и сопоставима с объёмом пересылок. При этом сами пересылки достаточно объёмны (весь рабочий вектор), нелокальны (все-со-всеми), и не могут проводиться одновременно с вычислениями. По этим причинам, ожидать от алгоритма хорошей масштабируемости не приходится, несмотря на «хорошие» свойства информационного графа. Это и подтверждается экспериментом:

[[Файл:TIFFTEfficiency.png|center|thumb|800px|Рисунок 3. Эффективность распараллеливания быстрого преобразования Фурье, выраженная как отношение времени работы на одном процессоре к произведению времени работы на <math>n</math> процессорах на <math>n</math>. <math>N</math> — порядок преобразования.]]

При этом, однако, умеренного ускорения всё же удаётся добиться:
[[Файл:TIFFTSpeedup.png|center|thumb|800px|Рисунок 4. Ускорение, получаемое при распараллеливании преобразования Фурье. Обозначения те же, что и на рис. 3]]

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

При измерениях использовалась реализация алгоритма, имеющаяся в библиотеке Intel® MKL.

=== Динамические характеристики и особенности реализации алгоритма ===
Как уже отмечалось выше, алгоритм существенно нелокален и плохо поддаётся распараллеливанию, а также обладает достаточно сложной структурой (почти весь состоит из рекурсивных вызовов). В связи с этими обстоятельствами, рассчитывать на эффективное использование системных ресурсов не приходится.

=== Выводы для классов архитектур ===
Как уже было указано, эффективность параллельной реализации крайне низкая, что связано с заложенными с саму структуру алгоритма глобальными пересылками, так что существенно повлиять на эту ситуацию без кардинальных изменений в алгоритме не представляется возможным. При работе на системе с распределённой памятью лучше всего по возможности избегать параллельного преобразования Фурье вовсе, используя по возможности параллелизм в других частях задачи.

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

Алгоритм быстрого преобразования Фурье относится к базовым алгоритмам вычислительной математики, а потому его реализации существуют во многих библиотеках. Перечислим некоторые из них:

* [//software.intel.com/en-us/intel-mkl Intel® Math Kernel Library] — содержит в том числе и версию для распределённых систем. Имеет интерфейсы для C, C++ и Fortran.
* [http://www.fftw.org FFTW] — содержит распределённую реализацию начиная с версии 3.3. Имеет интерфейсы для C и Fortran.
* [//www.gnu.org/software/gsl GNU Scientific Library] — имеет интерфейс для C.
* [//developer.nvidia.com/cufft cuFFT] — реализация алгоритма для GPU от NVIDIA.
* [http://gpuopen.com/compute-product/clfft clFFT] — реализация алгоритма на OpenCL для CPU и GPU. Поддерживает только <math>N = 2^p 3^q 5^r 7^s</math>
* [http://www.ibm.com/systems/power/software/essl IBM® Engineering and Scientific Subroutine Library] — для процессоров IBM® POWER™, имеет интерфейсы для C, C++ и Fortran, существует версия для многопроцессорных систем.

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

Обсуждение участника:Chachba.A

2016-11-16T10:41:13Z

IgorS:

== Замечания к статье ==

* п.п. 1.8, 1.9 не раскрыты--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:57, 25 октября 2016 (MSK)
** исправлено
* не указан конкретный вклад каждого автора--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:57, 25 октября 2016 (MSK)
** исправлено
* в п.п. 2.4 следует добавить описание компьютерной платформы, текст исследуемой программы.--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 13:41, 16 ноября 2016 (MSK)

== Замечания к статье "Быстрое дискретное преобразование Фурье" ==

* Перенесите пожалуйста статью в личное пространство [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:31, 11 ноября 2016 (MSK)
** а как это сделать? У нас нет прав на это, похоже
* Раздел 1.1 - в самом первом абзаце стоит вставить обозначения двух фунций - f и f с крышкой, чтобы было ясно, что куда отображается. [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:31, 11 ноября 2016 (MSK)
** Done
* В общее описание алгоритма нужно вставить слова именно об алгоритме, а не только о математической задаче. В чем быстрота, за счет чего она достигается и т.д. Тут, в отличие от математического описания, не стоит увлекаться формулами. [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:31, 11 ноября 2016 (MSK)
** Done
* Раздел 1.2 - существует обозначение части формулы через эпсилон, однако в следующей формуле он не встречается, странно. [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:31, 11 ноября 2016 (MSK)
** Done
* Нужно пояснение, что происходит, когда N не представимо в виде произведения: применим ли алгоритм и в каких изменениях он нуждается. [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:31, 11 ноября 2016 (MSK)
** Done
* Нет данных о глубине рекурсии, написать об этом явно, скорее всего, в разделе "вычислительное ядро алгоритма". [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:31, 11 ноября 2016 (MSK)
** Done

Быстрое дискретное преобразование Фурье (БПФ)

2016-11-16T10:37:48Z

IgorS:

Авторы: [[Участник:Chachba.A|Чачба А.Н.]], [[Участник:Weasel|Костоев Р.С.]]

[[Участник:Chachba.A|Чачба А.Н.]] заполнил половину всех заполненных пунктов (а именно 1.1, 1.2, 1.6, 1.8, 1.9) и построил информационный граф алгоритма, [[Участник:Weasel|Костоев Р.С.]] написал программу и провел серию запусков на суперкомпьютере и заполнил вторую половину пунктов. Оба после заполнения исправляли найденные ошибки во всех пунктах.

{{algorithm
| name = Быстрое преобразование Фурье (БПФ)
| serial_complexity = <math>O(N \log N)</math>
| pf_height = <math>O(\log N)</math>
| pf_width = <math>O(N)</math>
| input_data = <math>N</math>
| output_data = <math>N</math>
}}

= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==
Преобразование Фурье - взаимно однозначное отображение одной функции <math>f</math> вещественной переменной, называемой таргетным сигналом, с другой функцией <math>\hat{f}</math> вещественной переменной, называемой образом Фурье или спектром исходной функции по формуле:

:<math>
\hat{f}(\omega)=\frac{1}{\sqrt{2\pi}}\int\limits_{-\infty}^{\infty}f(x)e^{-ix\omega}\,dx
</math>
Дискретное преобразование Фурье, в свою очередь, есть аналог непрерывного преобразования Фурье, но для дискретного сигнала содержащего <math>N</math> отсчетов.
Широко применяется в цифровой обработке сигналов, теории вероятностей, криптографии и акустике.
Преобразование Фурье обратимо, причем обратное преобразование имеет практически ту же форму, что и прямое.
Преобразование Фурье имеет сложность <math>O(N^2)</math>, но существует быстрый вариант преобразование Фурье со сложностью <math>O(N\log{N})</math>.
Такая скорость достигается благодаря применению схемы "разделяй и властвуй". Общий вид преобразования позволяет разделить массив на несколько частей таким образом, что, применяя преобразование Фурье к отдельным его частям и объединяя специальным образом результаты (при помощи поворотных множителей и повторного применения преобразования), получать на выходе образ исходного вектора. Но благодаря разделению массива исходного размера на части суммарная асимптотическая сложность алгоритма уменьшается.

== Математическое описание алгоритма ==
Пусть исходный сигнал имеет значения <math>x_n,\quad n = 0,\dots,N-1</math>, тогда дискретное прямое преобразование Фурье (ДПФ) имеет вид:
:<math>
X_k = \sum_{n=0}^{N-1}x_ne^{-\frac{2\pi i}{N}kn},\quad k = 0, \dots, N-1
</math>
Обозначим <math> \varepsilon_{N} = e^{-\frac{2\pi i}{N}}</math>, тогда ДПФ можно перезаписать в матричной форме:
:<math>
\bar X = A\bar x
</math>
где матрица <math>A = \{\varepsilon_{N}^{(i - 1)(j - 1)}\}_{i,j=1}^{N}</math>
== Вычислительное ядро алгоритма ==
Пусть, для простоты <math> N = km</math>, тогда рекурсивная реализация преобразования Фурье, за счет <math>{k}</math> рекурсий на первом этапе и <math>m</math> на последнем этапе, имеет суммарную сложность <math>O(Nk + Nm + km) = O(N(k + m))</math>.

В случае, например <math>N = 2^n</math> сложность БПФ составляет <math>O(N\log{N})</math>.

В общем же случае, когда <math>N = \prod_{i=1}^np_i</math> сложность БПФ составляет <math> O(N(\sum_{i=1}^np_i))</math>. Так как рекурсия применяется каждый раз при отщеплении одного множителя, то можно заключить, что глубина рекурсии алгоритма составляет <math>O(n)</math>, где <math>n</math>-число множителей в факторизации <math>N</math>.

В свою очередь, если число <math>N</math> не факторизуется в произведение простых множителей (то есть <math>N</math> - простое число), то данный алгоритм не применим. На замену ему приходит алгоритм Радера, имеющий худшую асимптотику, нежели обычный БПФ, но лучшую чем <math>O(N^2)</math>. Также алгоритм Радера потребует дополнительного взаимодействия процессоров, что приведет к ухудшению эффективности.

== Макроструктура алгоритма ==
Макроструктура БПФ для случая <math>N = km</math> описывается рекурсивно:
# <math>k</math> независимых преобразований векторов меньшей размерности <math>m</math>
#Умножение элементов на поворотные коэффициенты (<math>N</math> умножений)
# <math>m</math> обратных преобразований векторов размерностей <math>k</math>

== Схема реализации последовательного алгоритма ==
Рекурсивный метод для случая <math>N = 2^k</math>, без оптимизации на C++:
<nowiki>#include <vector>
#include <complex>

using namespace std;

typedef complex<double> cd;
typedef vector<cd> vcd;

vcd fft(const vcd &as) {
int n = as.size();
if (n == 1) return vcd(1, as[0]);

vcd w(n); // Calculate roots
for (int i = 0; i < n; i++) {
double alpha = 2 * M_PI * i / n;
w[i] = cd(cos(alpha), sin(alpha));
}

vcd A(n / 2), B(n / 2);
for (int i = 0; i < n / 2; i++) {
A[i] = as[i * 2];
B[i] = as[i * 2 + 1];
}
vcd Av = fft(A);
vcd Bv = fft(B);
vcd res(n);
for (int i = 0; i < n; i++)
res[i] = Av[i % (n / 2)] +
w[i] * Bv[i % (n / 2)];
return res;
}
</nowiki>
В последовательном варианте можно бороться за улучшение константы сложности, предподсчитав значения соответствующих коэффициентов.

== Последовательная сложность алгоритма ==
Алгоритм состоит из трех этапов, следовательно если <math>N = \prod_{i = 1}^np_i</math>, то общая сложность составляет порядка <math>O(N\sum_{i=1}^np_i)</math> операций.

Пусть существует некоторое фиксированное число <math>P</math>, такое что:
:<math>
p_i \leq P \quad \forall i = 1...n,
</math>
тогда, учитывая, что <math>n \leq \log_{P}{N}</math>, сложность алгоритма можно записать в виде <math>O(N\log{N})</math>.

== Информационный граф ==
[[Файл:FourierGraph2.png|center|thumb|640px|'''Рисунок 1.''' Информационный граф преобразования Кули-Тьюки для <math>N = km = 25, k = 5, m = 5</math>. Желтые вершины - умножение на поворотные множители.]]

== Ресурс параллелизма алгоритма ==
В силу независимости всех рекурсивных вызовов и того факта, что путь максимальной длины в графе (так называемый критический путь) имеет порядок <math>O(\log{N})</math>, можно утверждать, что параллельная сложность алгоритма составит <math>O(\log{N})</math>.

''Замечание'': формально основание логарифма на каждом рекурсивном шаге зависит от множителя в факторизации <math>N</math>, потому использована О-символика.

При условии ограниченности количества доступных вычислительных узлов рекомендуется выбирать множители в разложении числа $N$ близкими к числу доступных узлов, таким образом доступные ресурсы будут использованы максимально эффективно.

Итого алгоритм относится к логарифмическому классу алгоритмов по параллельной сложности.

== Входные и выходные данные алгоритма ==
'''Входные данные''':
Чаще всего для обработки сигналов в качестве входных данных для БПФ подается вектор размерности <math>N</math> вещественных элементов. Но БПФ работает и для случая элементов над комплексным полем. Таким образом, например, можно экономить на количестве применений БПФ в некоторой конкретной задаче путем приведения двух векторов вещественных чисел к одному вектору комплексных чисел с вещественной частью равной первому вектору и комплексной частью равной второму вектору:
<math>x, y</math> - исходные сигналы. Обозначим <math>z = x + iy</math>, а <math>F(k, x)</math> - это <math>k</math>-ый коэффициент образа Фурье вектора <math>x</math>. Тогда:

:<math>F(k, x) = \frac{F(k, z) + F(k, \bar z)}{2}</math>
:<math>F(k, y) = -i\frac{F(k, z) - F(k, \bar z)}{2}</math>

Учитывая, что <math>F(k, \bar z) = \overline{F(N - k, z)}</math>, получаем:

:<math>F(k, x) = \frac{F(k, z) + \overline{F(N-k, z)}}{2}</math>
:<math>F(k, y) = -i\frac{F(k, z) - \overline{F(N-k,z)}}{2}</math>

Такой способ позволяет приблизительно в два раза уменьшить количество вычислений.

'''Выходные данные''':
Вектор размерности <math>N</math> комплексных чисел - спектр исходного сигнала.

== Свойства алгоритма ==
Матрица Вандермонда преобразования <math>A = \{e^{-\frac{2\pi i}{N}(i - 1)(j - 1)}\}_{i,j=1}^{N}</math> такая, что:
:<math>
A^{-1} = \frac{1}{N}A^*
</math>
Таким образом обратное преобразование Фурье с точностью до нормирующего множителя и сопряжения элементов матрицы совпадает с прямым.

= ЧАСТЬ. Программная реализация алгоритма =

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

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

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

== Масштабируемость алгоритма и его реализации ==
[[Файл:Time.PNG|center|thumb|640px|'''Рисунок 2.''' Время выполнения параллельной реализации БПФ в секундах. Size - число элементов массива. Р - число использованных процессоров.]]

[[Файл:Efff.PNG|center|thumb|640px|'''Рисунок 3.''' Эффективность параллельной реализации БПФ. Size - число элементов массива. Р - число использованных процессоров. Эффективность в пределах от 0 до 1.]]

Как видно из графика, эффективность параллельной реализации резко падает с ростом количества используемых процессоров, связано это с увеличением количества накладных расходов.

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

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

== Существующие реализации алгоритма ==
* Самая популярная библиотека для работы с преобразованиями Фурье это [http://www.fftw.org FFTW]
* Реализация от Intel в рамках [//software.intel.com/en-us/intel-mkl Math Kernel Library]
* Реализация ДПФ на графических картах от NVidia - [//developer.nvidia.com/cufft cuFFT]

= Литература =
* Бахвалов Н. С., Жидков Н. П., Кобельков. Г. М. — 6-е изд. — М. : БИНОМ. Лаборатория знаний, 2008. — 636 с.
* Описание алгоритма на Википедии: [https://ru.wikipedia.org/wiki/%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%BE%D0%B5_%D0%BF%D1%80%D0%B5%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%A4%D1%83%D1%80%D1%8C%D0%B5 Быстрое преобразование Фурье]
* Материалы лекций по "Алгоритмам и структурам данных" Школы Анализа Данных Яндекса

Обсуждение участника:Ivanov.kir.m

2016-11-16T10:36:06Z

IgorS:

== Замечания к статье ==

=== Неправильная структура статьи ===
* привести в соответствие 1 и 2 часть описания--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:31, 25 октября 2016 (MSK)
** Выполнено
* «рекурсивное описание» вынести в подпункт к основному пункту содержания--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:31, 25 октября 2016 (MSK)
** Выполнено

=== Отсутствующие части ===
* отсутствуют п.п. 2.2, 2.3, 2.5, 2.6--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:31, 25 октября 2016 (MSK)
** Согласно постановке первого домашнего задания по курсу Суперкомпьютерное моделирование и технологии ([http://parallel.ru/ss16 Сайт курса]) пункты 2.1, 2.2, 2.3, 2.5, 2.6 по общей структуре статьи (см. [http://algowiki-project.org/ru/%D0%A1%D1%82%D1%80%D1%83%D0%BA%D1%82%D1%83%D1%80%D0%B0_%D0%BE%D0%BF%D0%B8%D1%81%D0%B0%D0%BD%D0%B8%D1%8F_%D1%81%D0%B2%D0%BE%D0%B9%D1%81%D1%82%D0%B2_%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC%D0%BE%D0%B2 Структура описания свойств алгоритмов]) являются необязательными к заполнению (см. [http://parallel.ru/sites/default/files/info/education/superk-modelir-1-2016.pdf Первая лекция по курсу СкМиТ] слайд 62)
* отсутствует вклад каждого автора--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:31, 25 октября 2016 (MSK)
** Указали в шапке статьи

=== Замечания по тексту ===
* п.п. 1.9 и 1.10 (в нумерации автора) не раскрыты--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:31, 25 октября 2016 (MSK)
** Исправлено
* в п.п. 2.4 следует добавить описание компьютерной платформы--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 13:35, 16 ноября 2016 (MSK)

== Замечания к статье Быстрое дискретное преобразование Фурье ==

* В разделе "Общее описание алгоритма" следует вставить именно описание алгоритма. Потому что смысл алгоритма проясняется только в следующем разделе, а желательно иметь его общее (с минимумом формул) описание во введении [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:12, 11 ноября 2016 (MSK)
** Сделали
* Стоит добавить слова о том, что происходит, когда размер массива не представим в виде произведения - можно ли тогда применять алгоритм, и если да, то какие изменения следует сделать [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:12, 11 ноября 2016 (MSK)
** Сделали
* Не вполне понятна логика использования курсива и полужирного начертания [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:12, 11 ноября 2016 (MSK)
** Сделали
* Не хватает данных о глубине рекурсии при использовании алгоритма [[Участник:Kronberg|Kronberg]] ([[Обсуждение участника:Kronberg|обсуждение]]) 13:12, 11 ноября 2016 (MSK)
** Сделали

Участник:Ivanov.kir.m/Быстрое дискретное преобразование Фурье

2016-11-16T10:32:55Z

IgorS:

{{algorithm
| name = Алгоритм одномерного преобразования Фурье для действительных чисел
| serial_complexity = <math>O (N \log N)</math>
| pf_height = <math>O (\log N)</math>
| pf_width = <math>N</math>
| input_data = <math>N</math> действительных чисел
| output_data = <math>\lfloor N/2 \rfloor+1</math> комплексных чисел
}}
Авторы описания [[Участник:Ivanov.kir.m | К.М.Иванов]], [[Участник:Pumpkin | А.C.Сапин]] Вклад каждого участника равномерный, поскольку каждый пункт вычитывался и исправлялся обоими участниками. При сильном приближении можно сказать,что больший вклад [[Участник:Ivanov.kir.m | К.М.Иванов]] внес в заполнение теоретической части, а [[Участник:Pumpkin | А.C.Сапин]] в заполнение практической части.

'''Быстрое преобразование Фурье (БПФ, FFT)''' — алгоритм быстрого вычисления дискретного преобразования Фурье (ДПФ). То есть, алгоритм вычисления за количество действий, меньшее чем <math>O(N^{2})</math>, требуемых для прямого (по формуле) вычисления ДПФ. Иногда под БПФ понимается один из быстрых алгоритмов, называемый алгоритмом прореживания по частоте/времени или алгоритмом по основанию 2, имеющий сложность <math>O(N\log(N))</math>. Cуществует несколько различных алгоритмов для вычисления ДПФ считающимся быстрым преобразование Фурье:
* Алгоритм Кули-Тьюки [https://en.wikipedia.org/wiki/Cooley%E2%80%93Tukey_FFT_algorithm]
* Алгоритм Гуда-Томаса [https://en.wikipedia.org/wiki/Prime-factor_FFT_algorithm]
* Алгоритм Бруна [https://en.wikipedia.org/wiki/Bruun%27s_FFT_algorithm]
* Алгоритм Блюштейна [https://en.wikipedia.org/wiki/Chirp_Z-transform#Bluestein.27s_algorithm]
= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==
'''Быстрое дискретное преобразование Фурье''' (''БПФ'') - популярный в современном мире математический метод преобразования вектора/матрицы комплексных/действительных чисел - ''сигнала'' - в вектор/матрицу комплексных чисел - ''спектр''. С математической точки зрения преобразование сигнала <math>s</math> (как функции по времени <math>t</math>) в спектр <math>\hat{s}</math> описывается формулой
:<math>
\hat{s}(\omega)=\frac{1}{\sqrt{2\pi}}\int\limits_{-\infty}^{\infty}s(t)e^{-it\omega}\,dt
</math>

В отличии от своего классического аналога БПФ имеет сложность <math>O(N\log{N})</math>, а не <math>O(N^2)</math>, это достигается благодаря разделению исходного вектора на несколько частей, так чтобы применив к этим частям БПФ и объединив результаты путем умножения на поворотные множители и дополнительного БПФ, можно было получить преобразование Фурье исходного вектора - принцип "разделяй и властвуй".

Область применения данного метода простирается от обработки аудио информации до собственно спектрального анализа.
Поскольку в общем случае алгоритм БПФ применим к произвольным векторам чисел, выделяют отдельные подзадачи, для которых можно ввести дополнительную оптимизацию. Одной из таких подзадач является быстрое преобразование Фурье вектора действительных чисел, которому и посвящена данная статья. В качестве тестируемой реализации был выбран алгоритм Кули-Тьюки в библиотеке FFTW, написанной на языке C.

'''Замечание''': Поскольку общие описание алгоритма БПФ весьма сложно, в некоторых пунктах данная статья будет ссылаться на простой случай - алгоритм Кули-Тьюки быстрого преобразование Фурье для векторов ''с размерностью равной степени двойки''. Отличительной особенностью данного алгоритма является то, что он обходится без использования специфических приемов, использующихся именно для степеней четверки, восьмерки и т.п. Однако благодаря тому, что на вход данному алгоритму подается вектор чисто вещественных чисел, выходной вектор удовлетворяет ''эрмитовой избыточности'' (''Hermitian redundancy'') , т.е. <math>out[i]</math> является сопряженным с <math>out[n-i]</math>. Это обстоятельство позволяет достичь роста скорости и снижения затрат памяти примерно в 2 раза по сравнению с ''комплексным'' аналогом алгоритма.

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

Входные данные: вектор действительных чисел <math>x = (x_1,x_2,...,x_N)</math>.

Выходные данные: вектор комплексных чисел <math>X = (X_1,X_2,...,X_N)</math>.

Дискретное преобразование Фурье задается следующей формулой:

<math>X_k = \sum_{n=0}^{N-1} x_n e^{-\frac{2\pi i}{N} nk}, k = \overline{0,N-1}</math>

В простейшем случае(для степеней двойки) алгоритм Кули-Тьюки рассчитывает ДПФ для четных <math>(x_{2m}=x_0, x_2, \ldots, x_{N-2})</math> и нечетных элементов отдельно <math>(x_{2m+1}=x_1, x_3, \ldots, x_{N-1})</math>. Затем результаты рассчетов объединяются для получения ДПФ всей последовательности:

<math>
\begin{matrix} X_k & =
& \sum \limits_{m=0}^{N/2-1} x_{2m}e^{-\frac{2\pi i}{N} (2m)k} + \sum \limits_{m=0}^{N/2-1} x_{2m+1} e^{-\frac{2\pi i}{N} (2m+1)k}
\end{matrix}
</math>

Таким образом, получается рекурсивный алгоритм, работающий по принципу [https://ru.wikipedia.org/wiki/%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_(%D0%B8%D0%BD%D1%84%D0%BE%D1%80%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B0) разделяй и влавствуй].

=== Рекурсивное описание ===
Алгоритм:
# Входной вектор <math>a = (a_0,a_2,...,a_{N-1})</math> преобразуется в матрицу <math>A</math> размера <math>n_1 \times n_2 </math>, где <math>N=n_1 \cdot n_2</math> и <math>n_1 < n_2</math>
<math> A = \begin{pmatrix}
a_0 & a_1 & \cdots & a_{n_1-1} \\
a_{n_1} & a_{n_1+1} & \cdots & a_{2n_1-1} \\
\vdots & \vdots & \ddots & \vdots \\
a_{(n_2-1)\cdot n_1} & a_{(n_2-1)\cdot n_1+1} & \cdots & a_{n_2\cdot n_1-1}
\end{pmatrix} </math>
# К каждой строке полученной матрицы применяется быстрое дискретное преобразование Фурье (БПФ) порядка <math>n_1</math>
# Каждый элемент полученный после применения БПФ умножается на ''поворотные множители'' <math>exp (2 \pi i(m-1)(j-1)/N)</math>, где <math>m</math> - номер строки, а <math>j</math> - номер столбца
# Полученная после шагов 1-2 матрица <math>A</math> транспонируется
# К каждой строке матрицы <math>A^T</math> применяется БПФ порядка <math>n_2</math>

Так как алгоритм реализует принцип "разделяй и властвуй" глубина рекурсии составляет <math>O (\log N)</math> от числа входных элементов.

'''Замечание:''' Как правило все ''поворотные множители'' вычисляются заранее и хранятся в специальном массиве.

'''Замечание:''' В общем случае <math>N</math> разбивается на <math>n_1 \cdot n_2</math> так, чтобы <math>n_1</math> и <math>n_2</math> сами не являлись простыми числами и разлагались на множители не являющиеся простыми числами.

'''Замечание:''' В случае простого <math>N</math> оно дополняется(как правило единицией) до непростого числа. В процессе слияния добавленные значения отбрасываются.

== Вычислительное ядро алгоритма ==
В случае размерности входа равной степени двойки, вычислительным ядром алгоритма является так называемая, "''бабочка''". В простейшем случае "''бабочка''" представляет из себя двухточечное преобразование. Рассмотрим этот случай:

На вход алгоритму подается двухэлементный вектор ‒ <math> v = (v[0], v[1]) </math>. Тогда для вычисления будут происходить по следующим формулам:

<math>V[0] = W_2^0 v[0] + W_2^0 v[1] = v[0] + W_2^0 v[1] </math>

<math>V[1] = W_2^0 v[0] + W_2^1 v[1] = v[0] + W_2^1 v[1] </math>

Данный процесс удобно изобразить с помощью следующей схемы:

[[file:Fftbutterfly.png | Рис. 1. "''Бабочка''" для двумерного входа ]]

Для 4-х элеметного вектора <math>v=(v[0],v[1],v[2],v[3])</math>, алгоритм строится похожим образом. Сначала создаются простейшие "''бабочки''", а потом их результаты соединяются с противоположеной "бабочкой":

<math>V[0]=v[0]+W_2^0 v[2]+W_4^0(v[1]+W_2^0 v[3])</math>

<math>V[1]=v[0]-W_2^0 v[2]+W_4^1(v[1]-W_2^0 v[3])</math>

<math>V[2]=v[0]+W_2^0 v[2]-W_4^0(v[1]+W_2^0 v[3])</math>

<math>V[3]=v[0]-W_2^0 v[2]-W_4^1(v[1]-W_2^0 v[3])</math>

Схема в таком случае будет выглядеть следующим образом:

[[file:Fftbutterfly4.png| Рис. 2. "''Бабочка''" для четырёхмерного входа ]]

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

== Макроструктура алгоритма ==
Для исходного вектора <math>a = (a_1,a_2,...,a_N)</math> размерности <math>N = n_1 \cdot n_2</math>, <math>n_1 < n_2</math> БПФ представляется как:
#<math>n_2</math> БПФ порядка <math>n_1</math>
#<math>n_1 \cdot n_2</math> умножение комплексных чисел
#<math>n_1</math> БПФ порядка <math>n_2</math>

== Схема реализации последовательного алгоритма ==
Схема организации состоит в том, что на каждом шаге <math>i</math> для выполнения "''бабочки''" все элементы разбиваются на <math>n_{i_1}</math> векторов по <math>n_{i_2}</math> элементов, причем <math>n_{i_1} \cdot n_{i_2} = n_i</math>, где <math>n_i</math> длина входного вектора на текущем шаге <math>i</math>. В случае если такое разбиение невозможно, по причине того что <math>n_i</math> простое число, исходный вектор на текущем шаге дополняется элементом. В зависимости от номера шага, разница координат для каждой пары элементов увеличивается соразмерно разбиению <math>(n_{i_1},n_{i_2})</math>.
При этом результат суммы записывается в элемент с меньшим номером, а результат вычитания с последующим умножением - в элемент с большим.

== Последовательная сложность алгоритма ==
Быстрое дискретное преобразование Фурье выполнимо за <math>O(N(n_1+\cdots+n_m))</math> действий при <math>N=n_1n_2\cdots n_m</math> (в простом случае, при <math>N=2^m</math> необходимо <math>O(N\log_2(N))</math> действий). Дискретное преобразование Фурье преобразует вектор <math>a = (a_0, \dots, a_{N-1})</math> в вектор комплексных чисел <math>b = (b_0, \dots, b_{N-1})</math>, такой, что <math>b_i=\sum_{j=0}^{N-1}a_j\varepsilon^{ij}</math>, где <math>\varepsilon^n=1</math> и <math>\varepsilon^k\neq 1</math> при <math>0<k<N</math>.

Основной шаг алгоритма состоит в сведении задачи для <math>N</math> чисел к задаче для <math>n_1=N/n_2</math> числам, где <math>n_2</math> — делитель <math>N</math>.

Пусть мы уже умеем решать задачу для <math>N/n_2</math> чисел. Применим преобразование Фурье к векторам <math>a_i,a_{n_2+i}, \dots, a_{n_2(n_1-1)+i}</math> для <math>i=0,1,\dots,n_2-1</math>. Покажем теперь, что за <math>O(Np)</math> действий можно решить исходную задачу. Заметим, что <math>b_i=\sum_{j=0}^{n_2-1} \varepsilon^{ij} \left(\sum_{k=0}^{n_1-1}a_{kn_2+j}\varepsilon^{kin_2}\right)</math>.
Выражения в скобках нам уже известны — это <math>(i\mod p)</math>-тое число после преобразования Фурье <math>j</math>-го вектора. Таким образом, для вычисления каждого <math>b_i</math> нужно <math>O(n_2)</math> действий, а для вычисления всех <math>b_i</math> всего <math>O(Nn_2)</math> действий, что и требовалось.

В общем случае:

Пусть <math>4N>2^k\ge2N</math>. Заметим, что тогда <math>b_i=\varepsilon^{-i^2/2}\sum_{j=0}^{N-1}\varepsilon^{(i+j)^2/2}\varepsilon^{-j^2/2}a_j</math>. Обозначим <math>\bar{a}_i=\varepsilon^{-i^2/2}a_i</math>, <math>\bar{b}_i=\varepsilon^{i^2/2}b_i</math>, <math>c_i=\varepsilon^{(2N-2-i)^2/2}</math>. Тогда <math>\bar{b}_i=\sum_{j=0}^{2N-2-i}\bar{a}_jc_{2N-2-i-j}</math>, если положить <math>\bar{a}_i=0</math> при <math>i\ge N</math>.

Таким образом задача сведена к вычислению ''свёртки'', а это можно сделать с помощью трёх преобразований Фурье для <math>2^k</math> элементов. Выполняем прямое преобразование Фурье для <math>(\bar{a_0}, \cdots, \bar{a}_{2^k-1})</math> и <math>(c_1,\cdots,c_{2^k-1})</math>, перемножаем поэлементно результаты и выполняем обратное преобразование Фурье.

Вычисления всех <math>\bar{a}_i</math> и <math>c_i</math> требуют <math>O(N)</math> действий, три преобразования Фурье требуют <math>O(N\log(N))</math> действий, перемножение результатов преобразований Фурье требует <math>O(N)</math> действий, вычисление всех <math>b_i</math> зная значения свертки требует <math>O(N)</math> действий. Итого для дискретного преобразования Фурье требуется <math>O(N\log(N))</math> действий для любого <math>N</math>.

== Информационный граф ==
[[Файл:InfoGraph Ivanov Sapin.png |center|thumb|800px| Информационный граф алгоритма Кули-Тьюки для <math>N = 21</math>. Исходные данные обозначены зеленым, результат — синим. Преобразования Фурье для <math>n_1 = 7</math> и <math>n_2 = 3 \text{ } (N = n_1 \cdot n_2)</math> представлены как «чёрные ящики». Умножение на поворотные коэффициенты (множители) представлено коричневыми ромбами.]]
Как видно из рисунка, размер этого графа линейно-логарифмический, а формулы дуг имеют экспоненциальные компоненты.

== Ресурс параллелизма алгоритма ==
Если считать только главные члены выражений, то простой алгоритм Кули-Тьюки имеет критический путь, состоящий из <math>log(N)</math> операций комплексного сложения/вычитания и <math>log(N)</math> операций комплексного умножения (основание <math>log</math> целиком зависит от выбранного на каждом шаге алгоритма разбиения). Здесь стоит отметить, что все рекурсивные вызовы БПФ на каждом шаге выполняются независимо, это приводит к тому, что их можно распределить по доступным вычислительным узлам. Аналогичная ситуация обстоит и с умножением на поворотные множетели, что позволяет независимо присоединять его к любому шагу. Таким образом алгоритм БПФ имеет высокий ресурс параллелизма, а алгоритм БПФ в общем случае может быть отнесён к ''логарифмическому'' классу по параллельной сложности.

Кроме того, параллелизм БПФ можно увеличить, если брать <math>n_1</math> и <math>n_2</math> по возможности близкими к кратным доступному количеству вычислительных узлов (а не брать просто один из множителей близким к нулю, как в традиционной реализации), это позволит равномерно распределить работу между вычислительными узлами, что сильно повысит эффективность алгоритма благодаря лишь одной внутренней пересылке данных.

== Входные и выходные данные алгоритма ==
'''Входные данные:''' вектор действительных/комплексных чисел <math>a = (a_1,a_2,...,a_N)</math>.

'''Выходные данные:''' вектор комплексных чисел <math>b = (b_1,b_2,...,b_{\lfloor N/2 \rfloor+1})</math>.

Есть несколько ситуаций, при которых количество потребляемой памяти для хранения входного вектора <math>a</math> и выходного вектора <math>b</math> тможет быть снижено вдвое:
# Если <math>a</math> — вектор действительных чисел, тогда <math>b = E\bar{b}</math>;
# Если <math>a</math> — вектор чисто-мнимых чисел, тогда <math>b = -E\bar{b}</math>;
# Если <math>a = E\bar{a}</math>, тогда <math>b</math> — вектор действительных чисел;
# Если <math>a = -E\bar{b}</math>, то <math>b</math> — вектор чисто-мнимых чисел.

Где матрица <math>E</math>:
:<math>
E = \begin{bmatrix}
1 & 0 & 0 & \cdots & 0 & 0 \\
0 & 0 & 0 & \cdots & 0 & 1 \\
0 & 0 & 0 & \cdots & 1 & 0 \\
0 & 0 & 0 & \ddots & 0 & 0 \\
0 & 0 & 1 & \cdots & 0 & 0 \\
0 & 1 & 0 & \cdots & 0 & 0
\end{bmatrix}
</math>

== Свойства алгоритма ==
Таким образом в общем у алгоритма БПФ в случае неограниченных ресурсов:
*последовательная сложность - ''линейно-логарифмическая''
*параллельная сложность - ''логарифмическая''.

При этом алгоритм полностью детерминирован.

= ЧАСТЬ. Программная реализация алгоритма =
В качестве тестируемой реализации была выбрана библиотека FFTW, а именно функция, выполняющая БПФ одномерного вектора действительных чисел.
== Особенности последовательной реализации алгоритма ==
Простейший вариант алгоритма для степеней двойки на языке C:
<source lang="C++">
#include <stdio.h>
#include <math.h>
#include <complex.h>

typedef double complex cplx;

void _fft(cplx *buf, cplx *out, int n, int step)
{
if (step < n) {
_fft(out, buf, n, step * 2); //рекурсивный рассчет
_fft(out + step, buf + step, n, step * 2);

for (int i = 0; i < n; i += 2 * step) {
cplx t = cexp(-I * PI * i / n) * out[i + step];
buf[i / 2] = out[i] + t;
buf[(i + n)/2] = out[i] - t;
}
}
}

void fft(cplx *buf, int n)
{
cplx out[n];
for (int i = 0; i < n; i++) out[i] = buf[i];

_fft(buf, out, n, 1);
}
</source>

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

Масштабируемость алгоритма проверялась с помощью тестовой программы расположенной по [https://github.com/alesapin/parallel_fftw ссылке]. Для эксперимента использовались:
* Компилятор mpicc
* Библиотека OpenMPI версии 1.68
* Библиотека FFTW 3.3.5
Алгоритм тестировался на входных векторах размера <math>2^{15}</math> до <math>2^{26}</math>. При этом использовались от 8 до 128 процессоров с шагом степени двойки.

[[File:Fftw time good cr.png |center|thumb|800px| Замеры времени работы параллельной реализации FFTW для входного вектора действительных чисел. По оси Data Size указано <math>N</math> -- число входных элементов. По оси Procs Num указано <math>p</math> -- число задействованных процессоров. По оси Elapsed Time -- время затраченное на выполненине алгоритма в секундах.]]

[[File:Fftw efficency good cr.png |center|thumb|800px| Эффективность параллельной реализации FFTW для входного вектора действительных чисел. По оси Data Size указано <math>N</math> -- число входных элементов. По оси Procs Num указано <math>p</math> -- число задействованных процессоров. По оси Effeciency -- эффективность алгоритма в процентах.]]

Из графиков можно сделать следующие выводы:
* Значительное увеличение числа процессоров не дает значимого уменьшения времени исполнения, что отражено и на графике эффективности. Это означает, что время, в основном, расходуется на пересылки данных, а не на рассчет.
* При большом количестве элементов и маленьком числе процессоров наблюдается сверхлинейное ускорение, что связано с маленьким число пересылок и активным использованием кеша.

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [http://www.fftw.org/ FFTW], разработанная Матео Фриго и Стивеном Джонсоном в Массачусетском технологическом институте. Для преобразования небольших объемов данных используется алгоритм [https://en.wikipedia.org/wiki/Cooley%E2%80%93Tukey_FFT_algorithm Кули - Тьюки], в случае входа больших размеров используется алгоритм [https://en.wikipedia.org/wiki/Rader%27s_FFT_algorithm Радера] или [https://en.wikipedia.org/wiki/Chirp_Z-transform#Bluestein.27s_algorithm Блюштейна]. Библиотека считается самой быстрой реализацией БПФ и на входах любых размеров и размерностей сохраняет ассимптотическую сложность <math>O(N\cdot log(N))</math>. Также, существует версия FFTW с поддержкой [http://www.fftw.org/doc/Distributed_002dmemory-FFTW-with-MPI.html#Distributed_002dmemory-FFTW-with-MPI MPI], которая позволяет с объемами данных не умещающимися в память.

FFTW изначально написана на языке C, однако имеет API для нескольких языков, в том числе Fortran и Ada. Открытая версия библиотеки распространяется под лицензией [https://en.wikipedia.org/wiki/GNU_General_Public_License GNU General Public License]. Также существует реализация для коммерческого использования распространяемая под лицензией [https://en.wikipedia.org/wiki/MIT MIT].

Существует несколько реализаций алгоритма, для рассчета на GPU:
* [https://developer.nvidia.com/cufft cuFFT] для рассчета на графических ускорителях от NVIDIA.
* [http://gpuopen.com/compute-product/clfft/ clFFT] для рассчета на GPU и CPU.

= Литература =
[1] Википедия [Электронный ресурс]. Тема: Быстрое преобразование Фурье – Электрон. дан. – URL [https://ru.wikipedia.org/wiki/%D0%91%D1%8B%D1%81%D1%82%D1%80%D0%BE%D0%B5_%D0%BF%D1%80%D0%B5%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%A4%D1%83%D1%80%D1%8C%D0%B5 Быстрое преобразование Фурье] (дата обращения 17.09.2016)

[2] Бахвалов Н. С., Жидков Н. П., Кобельков. Г. М. — 6-е изд. — М. : БИНОМ. Лаборатория знаний, 2008. — 636 с.
[[en:Fast Discrete Fourier Transform]]

[3] FFTW [Электронный ресурс]. Тема: One-Dimensional DFTs of Real Data – Электрон. дан. – URL [http://www.fftw.org/doc/One_002dDimensional-DFTs-of-Real-Data.html#One_002dDimensional-DFTs-of-Real-Data One-Dimensional DFTs of Real Data] (последняя дата обращения 14.19.2016)

[4] FFTW [Электронный ресурс]. – Электрон. дан. – URL [http://www.fftw.org/ FFTW Lib] (последняя дата обращения 14.19.2016)

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

2016-11-16T10:30:28Z

IgorS:

== Замечания к статье ==

* отсутствует описание вклада каждого автора--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:53, 26 октября 2016 (MSK)
** +--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:52, 2 ноября 2016 (MSK)

* п.п. 1.7 не соответствует рисунку информационного графа--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:53, 26 октября 2016 (MSK)

* п.п. 1.8 и 1.9 не раскрыт--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:53, 26 октября 2016 (MSK)
* п. 2.4 не заполнен--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 13:30, 16 ноября 2016 (MSK)

===Пример правильно оформленной работы===

* http://algowiki-project.org/ru/Разложение_Холецкого_(метод_квадратного_корня)

== Второй этап проверки ==

=== Итерация 1 ===

Начальные замечания и вопросы (возможно будут появляться новые, пишите, пожалуйста, комментарии по ходу исправлений и ответы):

* Исправить ошибки в формулах в разделе 1.2
* Как решение векового уравнения относится к макроструктуре алгоритма (раздел 1.4)
* Исправлялся ли информационный граф? То, что имеется сейчас не соответствует инструкции (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)
Граф нужно кардинально переработать.
* Раздел 1.8 необзодимо написать намного более подробно.
* Откуда получены значения параллельной сложности алгоритма в разделе 1.10?

Участник:Vika3410/Метод Разделяй и властвуй

2016-11-16T10:29:34Z

IgorS:

Авторы статьи: [[Участник: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)
{{algorithm
| name = Метод "Разделяй и властвуй" вычисления собственных значений и векторов трёхдиагональной матрицы
| serial_complexity = <math> c\frac{4}{3}n^{3} </math>
| parallel_complexity = <math> O(n^{2.3}) </math>

крайне редко: <math> O(n^{2}) </math>
| pf_width =
| input_data = <math> 2n - 1 </math>
| output_data = <math> n + n^2 </math>
}}

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

== Общее описание алгоритма ==
'''Метод разделяй и властвуй вычисления собственных значений и векторов трёхдиагональной матрицы''' - является наиболее быстрым из существующих методов вычисления всех собственных значений и собственных векторов трехдиагональной матрицы, начиная с порядка n, который примерно равен 26. (Точное значение этого порогового порядка в конкретном случае зависит от компьютера.)

Численно устойчивая реализация данного метода весьма не тривиальна, так как не смотря на то, что впервые метод был предложен в 1981 г., "правильный" способ реализации метода был найден лишь в 1992 г. Этот способ был воплощен при помощи LAPACK-программ ssyevd (для плотных матриц) и sstevd (для трехдиагональных матриц). В этих программах стратегия "разделяй-и-влавствуй" используется для матриц порядка выше 25.

Для матриц порядка ниже 25 (или в тех случаях, когда требуются только собственные значения) автоматически происходит переход к методу QR-итерации.

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

:<math>
L = \begin{bmatrix}
a_{1} & b_{1}&&&&& \\
b_{1} & \ddots & \ddots \\
& \ddots & a_{m-1} & b_{m-1} \\
&& b_{m-1} & a_{m} & b_{m} \\
&&& b_{m} & a_{m+1} & b_{m+1} \\
&&&& b_{m+1} & \ddots \\
&&&&&& \ddots & b_{n-1} \\
&&&&&& b_{n-1} & a_{n} \\
\end{bmatrix}
= \begin{bmatrix}
a_{1} & b_{1} &&&&& \\
b_{1} & \ddots & \ddots \\
& \ddots & a_{m-1} & b_{m-1} \\
&& b_{m-1} & a_{m} - b_{m} \\
&&&& a_{m+1} - b_{m} & b_{m+1} \\
&&&& b_{m+1} & \ddots \\
&&&&&& \ddots & b_{n-1} \\
&&&&&& b_{n-1} & a_{n} \\
\end{bmatrix} +
</math>

<math>
+ \begin{bmatrix}
&&&&&&& \\
&&&&&&& \\
&&&b_{m} & b_{m} \\
&&&b_{m} & b_{m} \\
&&&&&&& \\
&&&&&&& \\
\end{bmatrix}

= \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}

\equiv \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T}
</math>

В предположении, что известны спектральные разложения матриц <math>T_{1}</math> и <math>T_{2}</math>:
<math>T_{i}=Q_{i} \Lambda_{i} Q_{i}^{T} </math>. На самом деле, они будут вычисляться рекурсивно тем же самым алгоритмом.

Можно установить связь между собственными значениями матрицы Т и собственными значениями матриц
<math>T_{1}</math> и <math>T_{2}</math>. Получается:

<math>
T = \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T}
= \begin{bmatrix} Q_{1} \Lambda_{1} Q_{1}^{T} & 0 \\ 0 & Q_{2} L_{2} Q_{2}^{T}\end{bmatrix} + b_{m}vv^{T}
= \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}
</math>,

где <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>.
Следовательно, <math>T</math> имеет такие же собственные значения, что и подобная ей матрица <math>D + \rho uu^{T}</math>,
где <math>D = \begin{bmatrix} L_{1} & 0 \\ 0 & L_{2}\end{bmatrix}</math> - диагональная матрица,
<math>\rho = b_{m}</math> - число, а <math>u</math> - вектор.
В дальнейшем предполагаем, не ограничивая общности, что диагональные элементы <math>d_{1}, \ldots, d_{n}</math> матрицы <math>D</math> упорядочены по не возрастанию: <math>d_{n} <= \ldots <=d_{1}</math>.

Для того, чтобы найти собственные значения матрицы <math>D + \rho uu^{T}</math>, потребуется вычислить её характеристический многочлен, считая пока матрицу <math>D - \lambda I</math> невырожденной.
Тогда получаем
<math>det(D + \rho uu^{T} - \lambda I) = det((D - \lambda I)(I + \rho (D- \lambda I)^{-1} uu^{T}))</math>.

Так как <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. Определитель такой матрицы не сложно вычислить.

''Лемма 1.'' Справедливо равенство <math>det(I + xy^{T}) = 1 + y^{T}x</math>, где <math>x</math> и <math>y</math> - векторы.

Следовательно, получаем
<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> ,

т.е. собственные значения матрицы <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>).

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

По рисунку можно заметить, что прямая <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> флопов.
Для собственных векторов матрицы <math>D + \rho uu^{T}</math> мы легко можем получить явные выражения.

''Лемма 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> флопов.

Доказательство.
<math>(D + \rho uu^{T})[(D - \alpha I)^{-1}u] =

(D - \alpha I + \alpha I + \rho uu^{T})(D - \alpha I)^{-1}u =

u + \alpha (D - \alpha I)^{-1}u + u[\rho u^{T}(D - \alpha I)^{-1}u]= </math>

<math> = u + \alpha(D - \alpha I)^{-1}u - u = \alpha [(D - \alpha I)^{-1}u]</math>,

поскольку

<math> \rho u^{T}(D - \alpha I)^{-1}u + 1 = f(\alpha) = 0 </math>.

Что и требовалось доказать.

Получается, что для вычисления по этой простой формуле всех <math>n</math> собственных векторов потребуется <math>O(n^{2})</math> флопов. К сожалению, данная формула не обеспечивает нам численной устойчивости, так как для двух очень близких значений <math>\alpha_{i}</math> может давать неортогональные приближенные собственные векторы <math>u_{i}</math>. Учёным потребовалось целое десятилетие для того, чтобы найти устойчивую альтернативу исходному описанию алгоритма. Подробнее детали будут обсуждаться ниже в данном разделе.

Алгоритм является рекурсивным.

До сих пор полагалось, что все <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> достаточно мало.

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

== Вычислительное ядро алгоритма ==
Вычислительным ядром последовательной схемы решения будет являться вычисление матрицы <math>Q</math> собственных векторов при помощи умножения матрицы <math>Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}</math> на матрицу <math>Q^{'}</math>. Эта операция имеет сложность <math>cn^{3}</math> о чём будет говориться ниже, в разделе [[#Последовательная сложность алгоритма]] .

Данной операции предшествует вычисление собственных значений и векторов матрицы <math> D + \rho uu^{T}</math>.

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

Далее пойдет речь о решении '''векового уравнения''', которое является одной из основных частей алгоритма.

Предположим, что некоторое <math>u_{i}</math>, хотя и мало, все же недостаточно мало для того, чтобы была зарегистрирована дефляция. В этом случае применение метода Ньютона к решению векового уравнения встречается с затруднениями. Вспомним, что пересчет приближённого решения <math>u_{j}</math> уравнения <math>f(\lambda) = 0</math> в методе Ньютона основан на следующих положениях:

1. Вблизи точки <math>\lambda = \lambda_{j}</math> функция <math>f(\lambda)</math> аппроксимируется линейной функцией <math>l(\lambda)</math>; график есть прямая линия, касающаяся графика функции <math>f(\lambda)</math> при <math>\lambda = \lambda_{j}</math>.

2. В качестве <math>\lambda_{j+1}</math> берётся нуль этого линейного приближения, т.е. <math>l(\lambda_{j+1})=0</math>.

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

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

Чтобы найти выход из этого положения, можно модифицировать метод Ньютона следующим образом: раз <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>, также имеющую эти полюсы, т.е. функцию вида
<math>h(\lambda)= \frac{c_{1}}{d_{i}-\lambda} + \frac{c_{2}}{d_{i+1}-\lambda} + c_{3}</math>

Константы <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>, поскольку сводится к эквивалентному квадратному уравнению
<math>c_{1}(d_{i+1}-\lambda)+c_{2}(d_{i}-\lambda)+c_{3}(d_{i}-\lambda)(d_{i+1}-\lambda)=0</math>

Пусть <math>\lambda_{j}</math> - приближённое значение корня. определим <math>c_{1},c_{2}</math> и <math>c_{3}</math> так, чтобы
<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>
для <math>\lambda</math> в окрестности <math>\lambda_{j}</math>. Заметим, что
<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>.

Если <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>, такие, что функция
<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> (*)

Это означает, что гипербола, являющаяся графиком функции <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>.

Подобным же образом выбираем <math>c_{2}</math> и <math>\hat{c_{2}}</math> так, чтобы функция
<math>h_{2}(\lambda) \equiv \hat{c_{2}} + \frac{c_{2}}{d_{i+1}-\lambda}</math> удовлетворяла условиям
<math>h_{2}(\lambda_{j}) = \psi_{2}(\lambda_{j})</math> и <math>h_{2}^{'}(\lambda_{j})=\psi_{2}^{'}(\lambda_{j})</math>

Наконец, полагаем
<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>.

== Схема реализации последовательного алгоритма ==
Рассмотрим каким именно образом происходит вычисление собственных значений и собственных векторов симметричной трехдиагональной матрицы при помощи стратегии "разделяй и властвуй":

''proc dc_eig''<math>(T,Q,\Lambda)...</math> по входной матрице <math>T</math> вычисляются выходные матрицы <math>Q</math> и <math>\Lambda</math>, такие, что <math>T = Q\Lambda Q^{T}</math>

В случае, '''если''' <math>T</math> - матрица размера <math>1</math> x <math>1</math> :

1. Присвоить выходным параметрам значения <math> Q = 1, \Lambda = T</math>

'''Иначе''':

1. Представить <math>T</math> в виде <math> T = \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T} </math>

2. ''call dc_eig''<math>(T_{1},Q_{1},\Lambda_{1})</math>

3. ''call dc_eig''<math>(T_{2},Q_{2},\Lambda_{2})</math>

4. Построить <math>D+\rho uu^{T}</math> по <math> \Lambda_{1},\Lambda_{2}, Q_{1}, Q_{2}</math>

5. Найти матрицу собственных значений <math>\Lambda</math>

6. Найти матрицу собственных векторов <math>Q^{'}</math> для матрицы <math>D+\rho uu^{T}</math>

7. Построить матрицу собственных векторов <math>Q</math> для матрицы <math>T</math> : <math> Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}* Q^{'} </math>

8. Присвоить выходным параметрам значения <math>Q</math> и <math>\Lambda</math>

'''endif'''

== Последовательная сложность алгоритма ==
Рассмотрим сложность алгоритма. Пусть <math>t(n)</math> - число флопов, которое потребуется при обработке матрицы размера <math> n *
n</math> процедурой ''dc_eig''. В таком случае

<math> t(n) = 2t(n/2) </math> два рекурсивных обращения к ''dc_eig''<math>(T_{i},Q_{i},\Lambda_{i})</math>
<math> +O(n^{2})</math> вычисление собственных значений матрицы <math>D+\rho uu^{T}</math>
<math> +O(n^{2})</math> вычисление собственных векторов матрицы <math>D+\rho uu^{T}</math>
<math> +c*n^{3}</math> вычисление матрицы <math>Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}*Q^{'}</math>

Если <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>

На практике константа <math>c</math> обычно оказывается гораздо меньше 1, так как матрица <math>Q^{'}</math> весьма разрежена вследствие явления, которое называется дефляцией, и которое было описано выше.

== Информационный граф ==
На рисунке 3 изображена структура алгоритма.
[[File:Сергеев 5.jpg|thumb|center|left|1000px|Рис. 3. Дерево алгоритма "Разделяй и властвуй"]]

== Ресурс параллелизма алгоритма ==
Данная структура алгоритма позволяет выполнять рекурсивный вызов функций для двух подматриц исходной матрицы как последовательно, так и параллельно.
При последовательной реализации алгоритма вызов функций производится по очереди - сначала для одной подматрицы, затем для другой. При параллельной реализации алгоритма данные функции могут отрабатывать одновременно.
Поскольку функции являются рекурсивными, их параллельный вызов даст значительный выигрыш во времени.
При размерности матрицы больше 3 параллельная реализация позволяет сократить количество этапов работы алгоритма больше, чем в два раза.

== Входные и выходные данные алгоритма ==
'''Входные данные''': трёхдиагональная симметрическая матрица, описанная в разделе [[#Математическое описание алгоритма]].

'''Объём входных данных''': <math> 2n - 1 </math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы).

'''Выходные данные''': матрица собственных значений размера <math> 1 * n </math> и матрица собственных векторов размера <math> n * n </math>

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

== Свойства алгоритма ==
Данный алгоритм является самым быстрым алгоритмом среди существующих: Разделяй и властвуй, QR, Бисекция и обратная итерация.

'''Последовательная сложность данного алгоритма:''' <math> t = c\frac{4}{3}n^{3} </math>

'''Параллельная сложность алгоритма (за счет дефляции):''' <math> O(n^{2.3})</math>; в крайне редких случаях: <math> O(n^{2}) </math>.

'''Особенности алгоритма:'''

1. Дефляция ([[#Дефляция]])

2. Адаптированный метод Ньютона ([[#Макроструктура алгоритма]])

= Программная реализация алгоритма =
Вторая часть описания алгоритмов в рамках AlgoWiki рассматривает все составные части процесса их реализации. Рассматривается как последовательная реализация алгоритма, так и параллельная. Описывается взаимосвязь свойств программ, реализующих алгоритм, и особенностей архитектуры компьютера, на которой они выполняются. Исследуется работа с памятью, локальность данных и вычислений, описывается масштабируемость и эффективность параллельных программ, производительность компьютеров, достигаемая на данной программе. Обсуждаются особенности реализации для разных классов архитектур компьютеров, приводятся ссылки на реализации в существующих библиотеках.

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

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

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

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

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

== Существующие реализации алгоритма ==
Единственный найденный пример реализации описан в [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).

= Литература =
[1] Дж. Деммель, "Вычислительная линейная алгебра"

[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"]

[3] [https://en.wikipedia.org/wiki/Divide-and-conquer_eigenvalue_algorithm Алгоритм "Разделяй и властвуй" - Wikipedia]

[[en:Description of algorithm properties and structure]]

Обсуждение участника:Роман Землянский

2016-11-16T10:27:16Z

IgorS:

== Замечания к статье ==

* п. 1.1 "...собственные векторы трехдиагональной матриц," заменить на "...собственные векторы трехдиагональной матрицы,"--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:48, 26 октября 2016 (MSK)
* п. 1.7 приведенный рисунок не является рисунком информационного графа--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:48, 26 октября 2016 (MSK)
* п. 1.8, 1.9 оценка не произведена--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 14:48, 26 октября 2016 (MSK)
* п. 2.4 не заполнен--[[Участник:IgorS|IgorS]] ([[Обсуждение участника:IgorS|обсуждение]]) 13:26, 16 ноября 2016 (MSK)

== Второй этап проверки ==

=== Итерация 1 ===

Начальные замечания и комментарии (возможно будут появляться новые, пишите, пожалуйста, комментарии по ходу исправлений и ответы):

* Исправить ошибки в формулах в разделе 1.2
* Исправить ошибку в разделе 1.9
* Раздел 2.7 - как это не найдены реализации, если в пункте 1.1 они указаны?
* По информационному графу не видно, что дерево может быть большей высоты, нужно бы это как-то отразить. И не совсем очевидно, как Divide переходит в Conquer. Нужно постараться, чтобы граф был более информативен и без чтения остальных разделов.

Участник:Timokhinivan/Быстрое преобразование Фурье

2016-11-07T12:13:32Z

IgorS:

{{Assignment|IgorS}}
{{algorithm
| name = Быстрое преобразование Фурье
| serial_complexity = <math>O(N \log N)</math>
| pf_height = <math>O(\log N)</math>
| pf_width = <math>O(N)</math>
| input_data = <math>N</math>
| output_data = <math>N</math>
}}

Автор описания: [[U:Timokhinivan|Тимохин И.В.]], ВМК МГУ.

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

=== Общее описание алгоритма ===
Преобразование Фурье переводит сигнал в его спектр и обратно, и широко
применяется в самых различных областях вычислительной математики —
собственно спектральный анализ, сжатие данных, вычисление свёрток и
т.д. В связи с этим, особый интерес представляют быстры алгоритмы для
вычисления этого преобразование. На сегодняшний день, наилучшие из
них имеют сложность <math>O(n \log n)</math>.

=== Математическое описание алгоритма ===
Преобразование Фурье задаётся следующей формулой:
:<math>
Y_k = \sum_{l = 0}^{N-1} X_l \epsilon^{kl}_N,\qquad k = \overline{0,N-1}
</math>
где <math>\epsilon_N = e^{-\frac{2i\pi}{N}}</math> — первообразный корень
из 1 степени <math>N</math>.

Таким образом, преобразование Фурье является линейным и задаётся
матрицей <math>F = \left\{ \epsilon^{kl}_N \right\}_{k\,l = 0}^{N-1}</math>.

==== Многомерное преобразование Фурье ====
Естественным обобщением описанного одномерного преобразования Фурье является многомерный вариант:
:<math>
Y(l_1,\ldots,l_d) = \sum_{k_1 = 0}^{N_1-1} \cdots \sum_{k_d = 0}^{N_d-1} X(k_1,\ldots,k_d) \prod_{j=1}^{d} \epsilon_{N_j}^{l_j k_j}
</math>

Многомерное преобразование Фурье эквивалентно последовательному выполнению одномерных преобразований по каждому измерению; при использовании для этого рекурсивного алгоритма, общая сложность вычислений также составляет <math>O(N\log N)</math>, <math>N = \prod_{j=1}^d N_j</math>.

==== Сведение к (почти) двумерному преобразованию (алгоритм Кули-Тьюки) ====

Если <math>N</math> — составное, т.е. <math>N = mn</math>, то возможно
существенно сократить вычислительные расходы за счёт сведения к
двумерному преобразованию Фурье. А именно, положим <math>X(l_1, l_2)
= X_{l_1 n + l_2}</math>, <math> Y(k_1, k_2) = Y_{k_1 m + k_2}</math>,
где <math>l_1, k_2 = \overline{0, m-1}</math>, <math>l_2, k_1 =
\overline{0, n-1}</math>.

В этом случае<ref name="bachv">Н.С. Бахвалов, Н.П. Жидков, Г.М. Кобельков, ''Численные методы'', 2003 г., ISBN: 5-94774-060-5</ref>
:<math>
\begin{align}
Y(k_1, k_2) &=& \sum_{l_2=0}^{n-1} (\epsilon^{k_2 l_2}_N \hat{X}(k_2, l_2)) \epsilon^{k_1 l_2}_n \\
\hat{X}(k_2, l_2) &=& \sum_{l_1=0}^{m-1} X(l_1, l_2) \epsilon^{k_2 l_1}_m
\end{align}
</math>

Это даёт следующий алгоритм вычисления преобразования:

# Записываем исходный вектор в матрицу <math>m\times n</math> по строкам.
# Применяем к каждому столбцу преобразование Фурье.
# Умножаем элемент в позиции <math>(i,j)</math> на <math>\epsilon^{ij}_N</math>.
# Применяем к каждой строке преобразование Фурье.
# Результат записан в получившейся матрице по столбцам.

Данный алгоритм уже даёт существенный выигрыш по сравнению с обычным
умножением матрицы на вектор: <math> O(m^2 n + n^2 m) </math> против
<math>O(m^2 n^2)</math>. Однако наилучших результатов можно добиться,
если применять этот алгоритм рекурсивно на этапах 2 и 4.

Так, если <math>N = \prod_{i=1}^{K} p_i</math>, то целесообразно
на каждом уровне рекурсии «отщеплять» одно <math>p_i</math>. В этом
случае задача сводится к вычислению <math> \prod_{i\neq j} p_i </math>
преобразований Фурье порядка <math>p_j</math> для всех
<math>j</math>. При небольших <math>p_i</math> (например, 2), это
можно проделывать «в лоб».

==== Преобразование Фурье с большим простым порядком (алгоритм Радера) ====

В случае, если порядок преобразования простой, но ещё слишком большой, чтобы вычислять его непосредственно, задача усложняется. Алгоритм в этом случае такой:

# <math> Y_0 = \sum_{l=0}^{N-1} X_l</math> вычисляется непосредственно.
# Любым способом вычисляется <math>g</math> — первообразный корень мультипликативной группы поля <math>\mathbb{Z}_{N}</math>.
# <math> Y_{g^{N-p} \bmod N} = X_0 + \sum_{q=0}^{N-2} X_{g^q \bmod N} \epsilon_N^{g^{q-p}\bmod N} </math>.

Последнее выражение представляет собой свёртку и вычисляется с помощью всё того же преобразования Фурье. В принципе, это можно проделывать непосредственно, поскольку порядок свёртки <math>N - 1</math> уже составной (по меньшей мере чётный), но, поскольку свёртка, в отличие от самого преобразования Фурье, допускает увеличение порядка, имеет смысл воспользоваться этим и выбрать порядок с небольшими простыми множителями.

Таким образом, поскольку при правильной реализации подавляющее большинство рекурсивных вызовов будет использовать алгоритм Кули-Тьюки, в дальнейшем будет рассматриваться именно он.

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

На каждом уровне рекурсии наиболее дорогостоящими этапами являются
рекурсивные вызовы преобразования Фурье: они требуют в сумме
<math>O(mn (\log m + \log n))</math> операций против
<math>O(mn)</math> для умножения на поправочные коэффициенты (шаг 3).

То же верно и для алгоритма в целом в случае <math>N = \prod_{i=1}^{K} p_i</math>;
а именно, суммарно наибольшие вычислительные затраты связаны с
вычислением преобразований Фурье порядка <math>p_i</math>.

=== Макроструктура алгоритма ===
Фактически, макроструктура алгоритма уже описана в разделе
математического описания. На каждом уровне рекурсии, алгоритм состоит
из

# <math>n</math> рекурсивных вызовов алгоритма.
# Умножение всех элементов рабочего вектора на поправочные коэффициенты.
# Ещё <math>m</math> рекурсивных вызовов.

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

Псевдокод (для метода Кули-Тьюки):
<nowiki>fft(X, N)
begin
(m, n) = factor(N)

if (n == 1) // Предполагается, что n <= m
direct_fft(X, N) // Через умножение на матрицу

// 1
transpose(X, m, n) //Транспонирует X как матрицу m x n, хранящуюся по строкам

// 2
do i = 0, n - 1
fft(X(i * m : (i + 1) * m - 1), m)

// 3
do i = 0, n - 1
do j = 0, m - 1
X(i * m + j) *= eps(i * j, N)

// 4
transpose(X, n, m)

// 5
do j = 0, m - 1
fft(X(j * n : (j + 1) * n - 1), n)

// 6
transpose(X, m, n)
end</nowiki>

Здесь <code>eps</code> может как вычислять соответствующие коэффициенты, так и брать их из заранее заготовленной таблицы. Последний способ требует увеличения затрат по памяти, но позволяет существенно сэкономить на вычислениях, а потому является предпочтительным.

Кроме того, шаги 3 и 4 можно переставлять произвольным образом (с очевидными изменениями в шаге 3).

Особо следует отметить, что если порядок элементов в выходном массиве не важен, шаг 6 можно пропустить.

Так, например, если преобразование Фурье используется для вычисления свёртки векторов, то конкретный порядок элементов в их образах Фурье совершенно не важен, лишь бы он был одинаков для обоих векторов. В этом случае в прямом преобразовании можно опустить шаг 6, а в обратном — 1.

Если необходимо учитывать случай большого простого <math>N</math> (что может и не требоваться, в зависимости от задачи), то в первом условном операторе следует дополнительно проверить величину <math>N</math> и, если <math>N</math> большое, переключиться на алгоритм Радера.

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

Непосредственно из описания алгоритма получаем, что если сложность
вычисления преобразования Фурье обозначить <math>f_N</math>, то
<math>f_{mn} = n f_{m} + m f_{n} + mn</math>.

Если <math>N = \prod_{i=1}^K p_i</math>, и на каждом шаге
«отщеплять» от него одно <math>p_i</math>, а преобразование Фурье для
<math>p_i</math> вычислять «в лоб», то общее количество операций
составит <math>O\left(N\sum_{i=1}^K p_i\right)</math>.

В частности, если <math>p_i \leq P</math>, то <math>K \leq \log_P N</math>
и для сложности получаем <math>O(NP\log_P N)</math>. Полагая
<math>P</math> фиксированным, получаем заявленную сложность <math>O(N \log N)</math>.

=== Информационный граф ===
[[Файл:FourierRecursiveGraph.svg|center|thumb|600px|'''Рисунок 1.''' Информационный граф алгоритма Кули-Тьюки для <math>N = 15</math>. Исходные данные обозначены фиолетовым, результат — красным. Преобразования Фурье для <math>m = 5</math> и <math>n = 3</math> представлены как «чёрные ящики». Умножение на поворотные коэффициенты представлено оранжевыми узлами.]]

Каждый уровень рекурсивного вызова состоит из трёх этапов: рекурсивный вызов по столбцам, умножение на поправочные коэффициенты и рекурсивного вызова по строкам. Таким образом для высоты ЯПФ имеем
:<math>
h(mn) = 1 + h(m) + h(n)
</math>

Для «элементарных» БПФ высота ЯПФ будет та же, что и для [[Умножение плотной матрицы на вектор|умножения матрицы на вектор]].

Таким образом, с учётом разложения <math>N</math>, <math>h(N) = O\left(\sum_{i=1}^K p_i\right) = O(P \log_P N) = O(\log N)</math>.

=== Ресурс параллелизма алгоритма ===
Поскольку все рекурсивные вызовы преобразования Фурье на каждом из этапов совершенно
независимы, кажется естественным распределить их по доступным
вычислительным узлам. Умножение на поворотные коэффициенты при этом и вовсе выполняется независимо
на каждом элементе рабочего вектора, и может быть беспрепятственно
присоединёно к любому из этапов.

При этом, в отличие от традиционной реализации, в которой на каждом этапе один из множителей берётся
малым, при параллельной реализации целесообразно взять и
<math>m</math> и <math>n</math> по возможности близкими к кратным
доступному количеству вычислительных узлов, поскольку в этом случае
возможно равномерно распределить работу между ними и реализовать весь
алгоритм всего с одной внутренней пересылкой.

=== Входные и выходные данные алгоритма ===
В общем случае на входе и на выходе имеются комплексные векторы
порядка <math>N</math>. Однако в частных случаях, возможны более компактные представления для параметров и результатов.

Для описания этих случаев нам понадобится матрица
:<math>
Q = \begin{bmatrix}
1 & & & & & \\
& & & & & 1 \\
& & & & 1 & \\
& & & \cdots & & \\
& & 1 & & & \\
& 1 & & & &
\end{bmatrix}
</math>

# Если <math>X</math> — вещественный, то <math>Y = Q\bar{Y}</math>.
# Если <math>X</math> — чисто мнимый, то <math>Y = -Q\bar{Y}</math>.
# Если <math>X = Q\bar{X}</math>, то <math>Y</math> — вещественный.
# Если <math>X = -Q\bar{X}</math>, то <math>Y</math> — чисто мнимый.

В каждом случае, <math>X</math> и <math>Y</math> требуют для своего хранения в два раза меньше памяти, чем в общем случае.

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

=== Свойства алгоритма ===
Обозначая матрицу преобразования <math>F</math>, имеем<ref name="voevodtyrt">В.В. Воеводин, Е.Е. Тыртышников, ''Вычислительные процессы с теплицевыми матрицами'', Москва, «Наука», 1987 г.</ref>:

# <math>F = F^T</math>
# <math>F^{-1} = \tfrac{1}{N} F^*</math>
# <math>F^* = QF </math>

Свойство 2 представляет особый интерес, поскольку позволяет вычислять обратное преобразование Фурье по тем же алгоритмам, что и прямое, поскольку <math>F^*</math> представляет собой матрицу того же вида, что и <math>F</math>, но с <math>\bar{\epsilon}</math> вместо <math>\epsilon</math>. В сущности, свойство 3 позволяет свести задачу к исходной непосредственно, но ценой дополнительных пересылок.

Кроме того, из второго свойства следует
:<math>
\|F x\|_2 = \sqrt{N} \|x\|_2
</math>
что свидетельствует о численной устойчивости алгоритма.

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

При реализации последовательной версии алгоритма (а равно и параллельной, поскольку на определённом уровне рекурсии алгоритм всё равно будет выполняться на каждом узле независимо) стоит иметь ввиду несколько вещей:

==== Поворотные коэффициенты ====

Как уже упоминалось, поворотные коэффициенты имеет смысл вычислить заранее и хранить в специальном массиве. Отдельное внимание при этом стоит обратить на передачу этого массива в рекурсивные вызовы.

В самом деле, поскольку <math>\epsilon^{l}_{n} = \epsilon^{lm}_{mn} = \epsilon^{lm}_{N}</math>, все необходимые рекурсивному вызову значения поворотных коэффициентов уже имеются в используемом в текущем вызове массиве, а потому его достаточно подготовить один раз на весь алгоритм.

==== Нерекурсивный случай ====

На нижнем уровне рекурсии преобразование Фурье вычисляется путём умножения на матрицу. Поскольку этот алгоритм, вообще говоря, более пригоден для векторизации, чем рекурсивная реализация, имеет смысл не разбивать <math>N</math> на ''совсем'' мелкие множители (<math>p_i \equiv 2</math> в алгоритме Кули-Тьюки) а останавливаться на преобразованиях несколько большего порядка; конкретный уровень зависит от конкретной реализации и архитектуры и должен быть установлен экспериментально.

==== Пересылки ====

Теоретически, возможна реализация алгоритма совсем без пересылок, если предполагать, что алгоритм оперирует «разреженным» вектором, элементы которого расположены с некоторым шагом по памяти. Однако ценой такой экономии будет существенно худшая локальность обращений к данным в рекурсивных вызовах. По-видимому, выбор нужно опять-таки осуществлять экспериментально.

Эти соображения в равной степени относятся как к рабочему массиву, так и к массиву поворотных коэффициентов.

==== Предварительные вычисления ====

''Многие'' используемые в алгоритме данные зависят только от порядка преобразования — массив поворотных коэффициентов, факторизация <math>N</math>, <math>g</math> в алгоритме Радера, конкретная задаваемая им перестановка и оптимальный порядок свёртки там же. Вычисление некоторых из них сопоставимо по сложности со всем остальным алгоритмом. Имея это ввиду, если планируется вычисление нескольких преобразований Фурье одного порядка, имеет смысл подготовить все эти данные заранее.

==== Численная устойчивость ====

Поскольку все преобразования в алгоритме являются, с точностью до константы <math>\leq \sqrt{N}</math>, унитарными, катастрофического роста ошибок округления не предвидится, а потому все вычисления возможно проводить с целевой точностью.

=== Локальность данных и вычислений ===
[[Файл:IT_FFTMemaccess.png|center|thumb|800px|Рисунок 2. Профиль обращений в память простого алгоритма Кули-Тьюки с <math>p = (2, 2, 3, 5, 2)</math>. Сверху вниз: вспомогательная память для прямого умножения матрицы на вектор, память для хранения поворотных коэффициентов, рабочий вектор. Реализация не использует транспонирования векторов в явном виде.]]

Как видно, алгоритм в целом обладает невысокой локальностью, что связано с его структурой (множество рекурсивных шагов, каждый из которых охватывает существенную часть рабочего вектора) и организацией доступа к поворотным коэффициентам. Некоторого улучшения локальности можно добиться, если транспонировать рабочую «матрицу» в памяти, но это либо требует дополнительной памяти, либо, если транспонировать «на месте», существенно усложняет алгоритм.

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

В случае составного <math>N</math> с ''достаточно'' большими делителями, наиболее очевидным и простым вариантом является распределение по процессорам рекурсивных вызовов алгоритма Кули-Тьюки. В этом случае на весь алгоритм приходится только три пересылки, но зато они проходят по схеме «все-со-всеми» (транспонирование матрицы) и не могут выполняться параллельно с вычислениями.

Отдельно заметим, что, как уже упоминалось, первой либо последней группы пересылок можно избежать, если порядок элементов результата не важен.

Если <math>N</math> простое либо один из множителей в <math>N = mn</math> всегда мал, ситуация усложняется. В этом случае придётся применять алгоритм Радера на межпроцессорном уровне, что связано с более сложной схемой пересылок и большим их количеством (т.к. приходится осуществлять преобразование Фурье дважды: прямое и обратное).

В связи с этим, некоторые существующие реализации (например, Intel® MKL) просто не поддерживают этот случай. Впрочем, некоторые реализации не поддерживают большие простые делители ''вовсе''.

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

Алгоритм быстрого преобразования Фурье относится к базовым алгоритмам вычислительной математики, а потому его реализации существуют во многих библиотеках. Перечислим некоторые из них:

* [//software.intel.com/en-us/intel-mkl Intel® Math Kernel Library] — содержит в том числе и версию для распределённых систем. Имеет интерфейсы для C, C++ и Fortran.
* [http://www.fftw.org FFTW] — содержит распределённую реализацию начиная с версии 3.3. Имеет интерфейсы для C и Fortran.
* [//www.gnu.org/software/gsl GNU Scientific Library] — имеет интерфейс для C.
* [//developer.nvidia.com/cufft cuFFT] — реализация алгоритма для GPU от NVIDIA.
* [http://gpuopen.com/compute-product/clfft clFFT] — реализация алгоритма на OpenCL для CPU и GPU. Поддерживает только <math>N = 2^p 3^q 5^r 7^s</math>
* [http://www.ibm.com/systems/power/software/essl IBM® Engineering and Scientific Subroutine Library] — для процессоров IBM® POWER™, имеет интерфейсы для C, C++ и Fortran, существует версия для многопроцессорных систем.

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

Участник:Vika3410/Метод Разделяй и властвуй

2016-11-03T13:30:43Z

IgorS:

{{Assignment|IgorS}}
Авторы статьи: [[Участник: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)
{{algorithm
| name = Метод "Разделяй и властвуй" вычисления собственных значений и векторов трёхдиагональной матрицы
| serial_complexity = <math> c\frac{4}{3}n^{3} </math>
| parallel_complexity = <math> O(n^{2.3}) </math>

крайне редко: <math> O(n^{2}) </math>
| pf_width =
| input_data = <math> 2n - 1 </math>
| output_data = <math> n + n^2 </math>
}}

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

== Общее описание алгоритма ==
'''Метод разделяй и властвуй вычисления собственных значений и векторов трёхдиагональной матрицы''' - является наиболее быстрым из существующих методов вычисления всех собственных значений и собственных векторов трехдиагональной матрицы, начиная с порядка n, который примерно равен 26. (Точное значение этого порогового порядка в конкретном случае зависит от компьютера.)

Численно устойчивая реализация данного метода весьма не тривиальна, так как не смотря на то, что впервые метод был предложен в 1981 г., "правильный" способ реализации метода был найден лишь в 1992 г. Этот способ был воплощен при помощи LAPACK-программ ssyevd (для плотных матриц) и sstevd (для трехдиагональных матриц). В этих программах стратегия "разделяй-и-влавствуй" используется для матриц порядка выше 25.

Для матриц порядка ниже 25 (или в тех случаях, когда требуются только собственные значения) автоматически происходит переход к методу QR-итерации.

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

:<math>
L = \begin{bmatrix}
a_{1} & b_{1}&&&&& \\
b_{1} & \ddots & \ddots \\
& \ddots & a_{m-1} & b_{m-1} \\
&& b_{m-1} & a_{m} & b_{m} \\
&&& b_{m} & a_{m+1} & b_{m+1} \\
&&&& b_{m+1} & \ddots \\
&&&&&& \ddots & b_{n-1} \\
&&&&&& b_{n-1} & a_{n} \\
\end{bmatrix}
= \begin{bmatrix}
a_{1} & b_{1} &&&&& \\
b_{1} & \ddots & \ddots \\
& \ddots & a_{m-1} & b_{m-1} \\
&& b_{m-1} & a_{m} - b_{m} \\
&&&& a_{m+1} - b_{m} & b_{m+1} \\
&&&& b_{m+1} & \ddots \\
&&&&&& \ddots & b_{n-1} \\
&&&&&& b_{n-1} & a_{n} \\
\end{bmatrix} +
</math>

<math>
+ \begin{bmatrix}
&&&&&&& \\
&&&&&&& \\
&&&b_{m} & b_{m} \\
&&&b_{m} & b_{m} \\
&&&&&&& \\
&&&&&&& \\
\end{bmatrix}

= \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}

\equiv \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T}
</math>

В предположении, что известны спектральные разложения матриц <math>T_{1}</math> и <math>T_{2}</math>:
<math>T_{i}=Q_{i} \Lambda_{i} Q_{i}^{T} </math>. На самом деле, они будут вычисляться рекурсивно тем же самым алгоритмом.

Можно установить связь между собственными значениями матрицы Т и собственными значениями матриц
<math>T_{1}</math> и <math>T_{2}</math>. Получается:

<math>
T = \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T}
= \begin{bmatrix} Q_{1} \Lambda_{1} Q_{1}^{T} & 0 \\ 0 & Q_{2} L_{2} Q_{2}^{T}\end{bmatrix} + b_{m}vv^{T}
= \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}
</math>,

где <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>.
Следовательно, <math>T</math> имеет такие же собственные значения, что и подобная ей матрица <math>D + \rho uu^{T}</math>,
где <math>D = \begin{bmatrix} L_{1} & 0 \\ 0 & L_{2}\end{bmatrix}</math> - диагональная матрица,
<math>\rho = b_{m}</math> - число, а <math>u</math> - вектор.
В дальнейшем предполагаем, не ограничивая общности, что диагональные элементы <math>d_{1}, \ldots, d_{n}</math> матрицы <math>D</math> упорядочены по не возрастанию: <math>d_{n} <= \ldots <=d_{1}</math>.

Для того, чтобы найти собственные значения матрицы <math>D + \rho uu^{T}</math>, потребуется вычислить её характеристический многочлен, считая пока матрицу <math>D - \lambda I</math> невырожденной.
Тогда получаем
<math>det(D + \rho uu^{T} - \lambda I) = det((D - \lambda I)(I + \rho (D- \lambda I)^{-1} uu^{T}))</math>.

Так как <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. Определитель такой матрицы не сложно вычислить.

''Лемма 1.'' Справедливо равенство <math>det(I + xy^{T}) = 1 + y^{T}x</math>, где <math>x</math> и <math>y</math> - векторы.

Следовательно, получаем
<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> ,

т.е. собственные значения матрицы <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>).

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

По рисунку можно заметить, что прямая <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> флопов.
Для собственных векторов матрицы <math>D + \rho uu^{T}</math> мы легко можем получить явные выражения.

''Лемма 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> флопов.

Доказательство.
<math>(D + \rho uu^{T})[(D - \alpha I)^{-1}u] =

(D - \alpha I + \alpha I + \rho uu^{T})(D - \alpha I)^{-1}u =

u + \alpha (D - \alpha I)^{-1}u + u[\rho u^{T}(D - \alpha I)^{-1}u]= </math>

<math> = u + \alpha(D - \alpha I)^{-1}u - u = \alpha [(D - \alpha I)^{-1}u]</math>,

поскольку

<math> \rho u^{T}(D - \alpha I)^{-1}u + 1 = f(\alpha) = 0 </math>.

Что и требовалось доказать.

Получается, что для вычисления по этой простой формуле всех <math>n</math> собственных векторов потребуется <math>O(n^{2})</math> флопов. К сожалению, данная формула не обеспечивает нам численной устойчивости, так как для двух очень близких значений <math>\alpha_{i}</math> может давать неортогональные приближенные собственные векторы <math>u_{i}</math>. Учёным потребовалось целое десятилетие для того, чтобы найти устойчивую альтернативу исходному описанию алгоритма. Подробнее детали будут обсуждаться ниже в данном разделе.

Алгоритм является рекурсивным.

До сих пор полагалось, что все <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> достаточно мало.

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

== Вычислительное ядро алгоритма ==
Вычислительным ядром последовательной схемы решения будет являться вычисление матрицы <math>Q</math> собственных векторов при помощи умножения матрицы <math>Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}</math> на матрицу <math>Q^{'}</math>. Эта операция имеет сложность <math>cn^{3}</math> о чём будет говориться ниже, в разделе [[#Последовательная сложность алгоритма]] .

Данной операции предшествует вычисление собственных значений и векторов матрицы <math> D + \rho uu^{T}</math>.

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

Далее пойдет речь о решении '''векового уравнения''', которое является одной из основных частей алгоритма.

Предположим, что некоторое <math>u_{i}</math>, хотя и мало, все же недостаточно мало для того, чтобы была зарегистрирована дефляция. В этом случае применение метода Ньютона к решению векового уравнения встречается с затруднениями. Вспомним, что пересчет приближённого решения <math>u_{j}</math> уравнения <math>f(\lambda) = 0</math> в методе Ньютона основан на следующих положениях:

1. Вблизи точки <math>\lambda = \lambda_{j}</math> функция <math>f(\lambda)</math> аппроксимируется линейной функцией <math>l(\lambda)</math>; график есть прямая линия, касающаяся графика функции <math>f(\lambda)</math> при <math>\lambda = \lambda_{j}</math>.

2. В качестве <math>\lambda_{j+1}</math> берётся нуль этого линейного приближения, т.е. <math>l(\lambda_{j+1})=0</math>.

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

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

Чтобы найти выход из этого положения, можно модифицировать метод Ньютона следующим образом: раз <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>, также имеющую эти полюсы, т.е. функцию вида
<math>h(\lambda)= \frac{c_{1}}{d_{i}-\lambda} + \frac{c_{2}}{d_{i+1}-\lambda} + c_{3}</math>

Константы <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>, поскольку сводится к эквивалентному квадратному уравнению
<math>c_{1}(d_{i+1}-\lambda)+c_{2}(d_{i}-\lambda)+c_{3}(d_{i}-\lambda)(d_{i+1}-\lambda)=0</math>

Пусть <math>\lambda_{j}</math> - приближённое значение корня. определим <math>c_{1},c_{2}</math> и <math>c_{3}</math> так, чтобы
<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>
для <math>\lambda</math> в окрестности <math>\lambda_{j}</math>. Заметим, что
<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>.

Если <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>, такие, что функция
<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> (*)

Это означает, что гипербола, являющаяся графиком функции <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>.

Подобным же образом выбираем <math>c_{2}</math> и <math>\hat{c_{2}}</math> так, чтобы функция
<math>h_{2}(\lambda) \equiv \hat{c_{2}} + \frac{c_{2}}{d_{i+1}-\lambda}</math> удовлетворяла условиям
<math>h_{2}(\lambda_{j}) = \psi_{2}(\lambda_{j})</math> и <math>h_{2}^{'}(\lambda_{j})=\psi_{2}^{'}(\lambda_{j})</math>

Наконец, полагаем
<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>.

== Схема реализации последовательного алгоритма ==
Рассмотрим каким именно образом происходит вычисление собственных значений и собственных векторов симметричной трехдиагональной матрицы при помощи стратегии "разделяй и властвуй":

''proc dc_eig''<math>(T,Q,\Lambda)...</math> по входной матрице <math>T</math> вычисляются выходные матрицы <math>Q</math> и <math>\Lambda</math>, такие, что <math>T = Q\Lambda Q^{T}</math>

В случае, '''если''' <math>T</math> - матрица размера <math>1</math> x <math>1</math> :

1. Присвоить выходным параметрам значения <math> Q = 1, \Lambda = T</math>

'''Иначе''':

1. Представить <math>T</math> в виде <math> T = \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T} </math>

2. ''call dc_eig''<math>(T_{1},Q_{1},\Lambda_{1})</math>

3. ''call dc_eig''<math>(T_{2},Q_{2},\Lambda_{2})</math>

4. Построить <math>D+\rho uu^{T}</math> по <math> \Lambda_{1},\Lambda_{2}, Q_{1}, Q_{2}</math>

5. Найти матрицу собственных значений <math>\Lambda</math>

6. Найти матрицу собственных векторов <math>Q^{'}</math> для матрицы <math>D+\rho uu^{T}</math>

7. Построить матрицу собственных векторов <math>Q</math> для матрицы <math>T</math> : <math> Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}* Q^{'} </math>

8. Присвоить выходным параметрам значения <math>Q</math> и <math>\Lambda</math>

'''endif'''

== Последовательная сложность алгоритма ==
Рассмотрим сложность алгоритма. Пусть <math>t(n)</math> - число флопов, которое потребуется при обработке матрицы размера <math> n *
n</math> процедурой ''dc_eig''. В таком случае

<math> t(n) = 2t(n/2) </math> два рекурсивных обращения к ''dc_eig''<math>(T_{i},Q_{i},\Lambda_{i})</math>
<math> +O(n^{2})</math> вычисление собственных значений матрицы <math>D+\rho uu^{T}</math>
<math> +O(n^{2})</math> вычисление собственных векторов матрицы <math>D+\rho uu^{T}</math>
<math> +c*n^{3}</math> вычисление матрицы <math>Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}*Q^{'}</math>

Если <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>

На практике константа <math>c</math> обычно оказывается гораздо меньше 1, так как матрица <math>Q^{'}</math> весьма разрежена вследствие явления, которое называется дефляцией, и которое было описано выше.

== Информационный граф ==
На рисунке 3 изображена структура алгоритма.
[[File:Сергеев 5.jpg|thumb|center|left|1000px|Рис. 3. Дерево алгоритма "Разделяй и властвуй"]]

== Ресурс параллелизма алгоритма ==
Данная структура алгоритма позволяет выполнять рекурсивный вызов функций для двух подматриц исходной матрицы как последовательно, так и параллельно.
При последовательной реализации алгоритма вызов функций производится по очереди - сначала для одной подматрицы, затем для другой. При параллельной реализации алгоритма данные функции могут отрабатывать одновременно.
Поскольку функции являются рекурсивными, их параллельный вызов даст значительный выигрыш во времени.
При размерности матрицы больше 3 параллельная реализация позволяет сократить количество этапов работы алгоритма больше, чем в два раза.

== Входные и выходные данные алгоритма ==
'''Входные данные''': трёхдиагональная симметрическая матрица, описанная в разделе [[#Математическое описание алгоритма]].

'''Объём входных данных''': <math> 2n - 1 </math> (в силу симметричности достаточно хранить только диагональ и над/поддиагональные элементы).

'''Выходные данные''': матрица собственных значений размера <math> 1 * n </math> и матрица собственных векторов размера <math> n * n </math>

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

== Свойства алгоритма ==
Данный алгоритм является самым быстрым алгоритмом среди существующих: Разделяй и властвуй, QR, Бисекция и обратная итерация.

'''Последовательная сложность данного алгоритма:''' <math> t = c\frac{4}{3}n^{3} </math>

'''Параллельная сложность алгоритма (за счет дефляции):''' <math> O(n^{2.3})</math>; в крайне редких случаях: <math> O(n^{2}) </math>.

'''Особенности алгоритма:'''

1. Дефляция ([[#Дефляция]])

2. Адаптированный метод Ньютона ([[#Макроструктура алгоритма]])

= Программная реализация алгоритма =
Вторая часть описания алгоритмов в рамках AlgoWiki рассматривает все составные части процесса их реализации. Рассматривается как последовательная реализация алгоритма, так и параллельная. Описывается взаимосвязь свойств программ, реализующих алгоритм, и особенностей архитектуры компьютера, на которой они выполняются. Исследуется работа с памятью, локальность данных и вычислений, описывается масштабируемость и эффективность параллельных программ, производительность компьютеров, достигаемая на данной программе. Обсуждаются особенности реализации для разных классов архитектур компьютеров, приводятся ссылки на реализации в существующих библиотеках.

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

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

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

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

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

== Существующие реализации алгоритма ==
Единственный найденный пример реализации описан в [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).

= Литература =
[1] Дж. Деммель, "Вычислительная линейная алгебра"

[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"]

[3] [https://en.wikipedia.org/wiki/Divide-and-conquer_eigenvalue_algorithm Алгоритм "Разделяй и властвуй" - Wikipedia]

[[en:Description of algorithm properties and structure]]

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

2016-11-02T11:52:28Z

IgorS:

Участник:Vika3410/Метод Разделяй и властвуй

2016-11-02T11:46:02Z

IgorS:

Авторы статьи: [[Участник:NikoSergAlex|Сергеев Никита]] (группа 614) (1.1, 1.2, 1.5, 1.6, 1.7, 1.9, 1.10), [[Участница:Vika3410|Стрельцова Виктория]] (группа 614) (1.2, 1.3, 1.4, 1.6, 1.7, 1.8, 1.10)
{{algorithm
| name = Метод "Разделяй и властвуй" вычисления собственных значений и векторов трёхдиагональной матрицы
| serial_complexity = <math> c\frac{4}{3}n^{3} </math>
| parallel_complexity = <math> O(n^{2.3}) </math>

крайне редко: <math> O(n^{2}) </math>
| pf_width =
| input_data = трёхдиагональная матрица
| output_data = матрица собственных значений и матрица собственных векторов исходной матрицы
}}

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

== Общее описание алгоритма ==
'''Метод разделяй и властвуй вычисления собственных значений и векторов трёхдиагональной матрицы''' - является наиболее быстрым из существующих методов вычисления всех собственных значений и собственных векторов трехдиагональной матрицы, начиная с порядка n, который примерно равен 26. (Точное значение этого порогового порядка в конкретном случае зависит от компьютера.)

Численно устойчивая реализация данного метода весьма не тривиальна, так как не смотря на то, что впервые метод был предложен в 1981 г., "правильный" способ реализации метода был найден лишь в 1992 г. Этот способ был воплощен при помощи LAPACK-программ ssyevd (для плотных матриц) и sstevd (для трехдиагональных матриц). В этих программах стратегия "разделяй-и-влавствуй" используется для матриц порядка выше 25.

Для матриц порядка ниже 25 (или в тех случаях, когда требуются только собственные значения) автоматически происходит переход к методу QR-итерации.

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

:<math>
L = \begin{bmatrix}
a_{1} & b_{1}&&&&& \\
b_{1} & \ddots & \ddots \\
& \ddots & a_{m-1} & b_{m-1} \\
&& b_{m-1} & a_{m} & b_{m} \\
&&& b_{m} & a_{m+1} & b_{m+1} \\
&&&& b_{m+1} & \ddots \\
&&&&&& \ddots & b_{n-1} \\
&&&&&& b_{n-1} & a_{n} \\
\end{bmatrix}
= \begin{bmatrix}
a_{1} & b_{1} &&&&& \\
b_{1} & \ddots & \ddots \\
& \ddots & a_{m-1} & b_{m-1} \\
&& b_{m-1} & a_{m} - b_{m} \\
&&&& a_{m+1} - b_{m} & b_{m+1} \\
&&&& b_{m+1} & \ddots \\
&&&&&& \ddots & b_{n-1} \\
&&&&&& b_{n-1} & a_{n} \\
\end{bmatrix} +
</math>

<math>
+ \begin{bmatrix}
&&&&&&& \\
&&&&&&& \\
&&&b_{m} & b_{m} \\
&&&b_{m} & b_{m} \\
&&&&&&& \\
&&&&&&& \\
\end{bmatrix}

= \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}

\equiv \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T}
</math>

В предположении, что известны спектральные разложения матриц <math>T_{1}</math> и <math>T_{2}</math>:
<math>T_{i}=Q_{i} \Lambda_{i} Q_{i}^{T} </math>. На самом деле, они будут вычисляться рекурсивно тем же самым алгоритмом.

Можно установить связь между собственными значениями матрицы Т и собственными значениями матриц
<math>T_{1}</math> и <math>T_{2}</math>. Получается:

<math>
T = \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T}
= \begin{bmatrix} Q_{1} \Lambda_{1} Q_{1}^{T} & 0 \\ 0 & Q_{2} L_{2} Q_{2}^{T}\end{bmatrix} + b_{m}vv^{T}
= \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}
</math>,

где <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>.
Следовательно, <math>T</math> имеет такие же собственные значения, что и подобная ей матрица <math>D + \rho uu^{T}</math>,
где <math>D = \begin{bmatrix} L_{1} & 0 \\ 0 & L_{2}\end{bmatrix}</math> - диагональная матрица,
<math>\rho = b_{m}</math> - число, а <math>u</math> - вектор.
В дальнейшем предполагаем, не ограничивая общности, что диагональные элементы <math>d_{1}, \ldots, d_{n}</math> матрицы <math>D</math> упорядочены по не возрастанию: <math>d_{n} <= \ldots <=d_{1}</math>.

Для того, чтобы найти собственные значения матрицы <math>D + \rho uu^{T}</math>, потребуется вычислить её характеристический многочлен, считая пока матрицу <math>D - \lambda I</math> невырожденной.
Тогда получаем
<math>det(D + \rho uu^{T} - \lambda I) = det((D - \lambda I)(I + \rho (D- \lambda I)^{-1} uu^{T}))</math>.

Так как <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. Определитель такой матрицы не сложно вычислить.

''Лемма 1.'' Справедливо равенство <math>det(I + xy^{T}) = 1 + y^{T}x</math>, где <math>x</math> и <math>y</math> - векторы.

Следовательно, получаем
<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> ,

т.е. собственные значения матрицы <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>).

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

По рисунку можно заметить, что прямая <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> флопов.
Для собственных векторов матрицы <math>D + \rho uu^{T}</math> мы легко можем получить явные выражения.

''Лемма 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> флопов.

Доказательство.
<math>(D + \rho uu^{T})[(D - \alpha I)^{-1}u] =

(D - \alpha I + \alpha I + \rho uu^{T})(D - \alpha I)^{-1}u =

u + \alpha (D - \alpha I)^{-1}u + u[\rho u^{T}(D - \alpha I)^{-1}u]= </math>

<math> = u + \alpha(D - \alpha I)^{-1}u - u = \alpha [(D - \alpha I)^{-1}u]</math>,

поскольку

<math> \rho u^{T}(D - \alpha I)^{-1}u + 1 = f(\alpha) = 0 </math>.

Что и требовалось доказать.

Получается, что для вычисления по этой простой формуле всех <math>n</math> собственных векторов потребуется <math>O(n^{2})</math> флопов. К сожалению, данная формула не обеспечивает нам численной устойчивости, так как для двух очень близких значений <math>\alpha_{i}</math> может давать неортогональные приближенные собственные векторы <math>u_{i}</math>. Учёным потребовалось целое десятилетие для того, чтобы найти устойчивую альтернативу исходному описанию алгоритма. Подробнее детали будут обсуждаться ниже в данном разделе.

Алгоритм является рекурсивным.

До сих пор полагалось, что все <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> достаточно мало.

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

== Вычислительное ядро алгоритма ==
Вычислительным ядром последовательной схемы решения будет являться вычисление матрицы <math>Q</math> собственных векторов при помощи умножения матрицы <math>Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}</math> на матрицу <math>Q^{'}</math>. Эта операция имеет сложность <math>cn^{3}</math> о чём будет говориться ниже, в разделе [[#Последовательная сложность алгоритма]] .

Данной операции предшествует вычисление собственных значений и векторов матрицы <math> D + \rho uu^{T}</math>.

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

Далее пойдет речь о решении '''векового уравнения''', которое является одной из основных частей алгоритма.

Предположим, что некоторое <math>u_{i}</math>, хотя и мало, все же недостаточно мало для того, чтобы была зарегистрирована дефляция. В этом случае применение метода Ньютона к решению векового уравнения встречается с затруднениями. Вспомним, что пересчет приближённого решения <math>u_{j}</math> уравнения <math>f(\lambda) = 0</math> в методе Ньютона основан на следующих положениях:

1. Вблизи точки <math>\lambda = \lambda_{j}</math> функция <math>f(\lambda)</math> аппроксимируется линейной функцией <math>l(\lambda)</math>; график есть прямая линия, касающаяся графика функции <math>f(\lambda)</math> при <math>\lambda = \lambda_{j}</math>.

2. В качестве <math>\lambda_{j+1}</math> берётся нуль этого линейного приближения, т.е. <math>l(\lambda_{j+1})=0</math>.

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

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

Чтобы найти выход из этого положения, можно модифицировать метод Ньютона следующим образом: раз <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>, также имеющую эти полюсы, т.е. функцию вида
<math>h(\lambda)= \frac{c_{1}}{d_{i}-\lambda} + \frac{c_{2}}{d_{i+1}-\lambda} + c_{3}</math>

Константы <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>, поскольку сводится к эквивалентному квадратному уравнению
<math>c_{1}(d_{i+1}-\lambda)+c_{2}(d_{i}-\lambda)+c_{3}(d_{i}-\lambda)(d_{i+1}-\lambda)=0</math>

Пусть <math>\lambda_{j}</math> - приближённое значение корня. определим <math>c_{1},c_{2}</math> и <math>c_{3}</math> так, чтобы
<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>
для <math>\lambda</math> в окрестности <math>\lambda_{j}</math>. Заметим, что
<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>.

Если <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>, такие, что функция
<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> (*)

Это означает, что гипербола, являющаяся графиком функции <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>.

Подобным же образом выбираем <math>c_{2}</math> и <math>\hat{c_{2}}</math> так, чтобы функция
<math>h_{2}(\lambda) \equiv \hat{c_{2}} + \frac{c_{2}}{d_{i+1}-\lambda}</math> удовлетворяла условиям
<math>h_{2}(\lambda_{j}) = \psi_{2}(\lambda_{j})</math> и <math>h_{2}^{'}(\lambda_{j})=\psi_{2}^{'}(\lambda_{j})</math>

Наконец, полагаем
<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>.

== Схема реализации последовательного алгоритма ==
Рассмотрим каким именно образом происходит вычисление собственных значений и собственных векторов симметричной трехдиагональной матрицы при помощи стратегии "разделяй и властвуй":

''proc dc_eig''<math>(T,Q,\Lambda)...</math> по входной матрице <math>T</math> вычисляются выходные матрицы <math>Q</math> и <math>\Lambda</math>, такие, что <math>T = Q\Lambda Q^{T}</math>

В случае, '''если''' <math>T</math> - матрица размера <math>1</math> x <math>1</math> :

1. Присвоить выходным параметрам значения <math> Q = 1, \Lambda = T</math>

'''Иначе''':

1. Представить <math>T</math> в виде <math> T = \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T} </math>

2. ''call dc_eig''<math>(T_{1},Q_{1},\Lambda_{1})</math>

3. ''call dc_eig''<math>(T_{2},Q_{2},\Lambda_{2})</math>

4. Построить <math>D+\rho uu^{T}</math> по <math> \Lambda_{1},\Lambda_{2}, Q_{1}, Q_{2}</math>

5. Найти матрицу собственных значений <math>\Lambda</math>

6. Найти матрицу собственных векторов <math>Q^{'}</math> для матрицы <math>D+\rho uu^{T}</math>

7. Построить матрицу собственных векторов <math>Q</math> для матрицы <math>T</math> : <math> Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}* Q^{'} </math>

8. Присвоить выходным параметрам значения <math>Q</math> и <math>\Lambda</math>

'''endif'''

== Последовательная сложность алгоритма ==
Рассмотрим сложность алгоритма. Пусть <math>t(n)</math> - число флопов, которое потребуется при обработке матрицы размера <math> n *
n</math> процедурой ''dc_eig''. В таком случае

<math> t(n) = 2t(n/2) </math> два рекурсивных обращения к ''dc_eig''<math>(T_{i},Q_{i},\Lambda_{i})</math>
<math> +O(n^{2})</math> вычисление собственных значений матрицы <math>D+\rho uu^{T}</math>
<math> +O(n^{2})</math> вычисление собственных векторов матрицы <math>D+\rho uu^{T}</math>
<math> +c*n^{3}</math> вычисление матрицы <math>Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}*Q^{'}</math>

Если <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>

На практике константа <math>c</math> обычно оказывается гораздо меньше 1, так как матрица <math>Q^{'}</math> весьма разрежена вследствие явления, которое называется дефляцией, и которое было описано выше.

== Информационный граф ==
На рисунке 3 изображена структура всего алгоритма, на рисунке 4 подробно описана одна из ячеек структуры.
[[File:Сергеев 3.jpg|thumb|center|left|800px|Рис. 3. Дерево алгоритма "Разделяй и властвуй"]]

[[File:Сергеев 4.jpg|thumb|center|1200px|Рис. 4. Детальное описание одного блока алгоритма]]

== Ресурс параллелизма алгоритма ==
На информационном графе алгоритма имеются два параллельных блока вызова рекурсивных функций ''dc_eig'' для вычисления собственных значений и для векторов матриц <math>T_{1}</math> и <math>T_{2}</math> - это единственная часть алгоритма, сводящаяся к параллелизму. При реализации алгоритма без параллелизма функции ''dc_eig'' должны отрабатывать последовательно - сначала со входными параметрами <math>T_{1}, Q_{1}, \Lambda_{1}</math>, затем - <math>T_{2}, Q_{2}, \Lambda_{2}</math>.

== Входные и выходные данные алгоритма ==
Входным параметром алгоритма является трёхдиагональная матрица, описанная в разделе [[#Математическое описание алгоритма]]

Выходными параметрами алгоритма являются матрица собственных значений и матрица собственных векторов исходной матрицы

== Свойства алгоритма ==
Данный алгоритм является самым быстрым алгоритмом среди существующих: Разделяй и властвуй, QR, Бисекция и обратная итерация.

Последовательная сложность данного алгоритма: <math> t = c\frac{4}{3}n^{3} </math>

Параллельная сложность алгоритма (за счет дефляции): <math> O(n^{2.3})</math>; в крайне редких случаях: <math> O(n^{2}) </math> ( [3] стр. 8).

Особенности алгоритма:

1. Дефляция ([[#Дефляция]])

2. Адаптированный метод Ньютона ([[#Макроструктура алгоритма]])

= Программная реализация алгоритма =
Вторая часть описания алгоритмов в рамках AlgoWiki рассматривает все составные части процесса их реализации. Рассматривается как последовательная реализация алгоритма, так и параллельная. Описывается взаимосвязь свойств программ, реализующих алгоритм, и особенностей архитектуры компьютера, на которой они выполняются. Исследуется работа с памятью, локальность данных и вычислений, описывается масштабируемость и эффективность параллельных программ, производительность компьютеров, достигаемая на данной программе. Обсуждаются особенности реализации для разных классов архитектур компьютеров, приводятся ссылки на реализации в существующих библиотеках.

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

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

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

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

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

== Существующие реализации алгоритма ==
Единственный найденный пример реализации описан в [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).

= Литература =
[1] Дж. Деммель, "Вычислительная линейная алгебра"

[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"]

[3] [https://en.wikipedia.org/wiki/Divide-and-conquer_eigenvalue_algorithm Алгоритм "Разделяй и властвуй" - Wikipedia]

[[en:Description of algorithm properties and structure]]

Участник:Роман Землянский/Zavolskov/Zemlyanskiy

2016-11-02T08:16:42Z

IgorS:

{{Assignment|IgorS}}

'''Метод «разделяй и властвуй» вычисления собственных значений и векторов симметричной трехдиагональной матрицы'''

Авторы статьи:

'''Завольсков Владислав'''

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

[[#Макроструктура алгоритма]]

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

[[#Информационный граф]]

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

'''Землянский Роман'''

[[#Общее описание алгоритма]]

[[#Математическое описание алгоритма]]

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

[[#Ресурс параллелизма алгоритма]]

[[#Входные и выходные данные алгоритма]]

[[#Свойства алгоритма]]

614 группа

= ЧАСТЬ. Свойства и структура алгоритмов =
== Общее описание алгоритма ==
'''Метод разделяй и властвуй вычисления собственных значений и векторов трёхдиагональной матрицы''' - это наиболее быстрый из существующих методов, если нужны все собственные значения и собственные векторы трехдиагональной матрицы, начиная с порядка n, примерно равного 26. (Точное значение этого порогового порядка зависит от компьютера.) Его численно устойчивая реализация весьма не тривиальна. В самом деле, хотя впервые метод был предложен еще в 1981 г., "правильный" способ его реализации был найден лишь в 1992 г. Этот способ воплощен LAPACK-программами ssyevd (для плотных матриц) и sstevd (для трехдиагональных матриц). В них стратегия "разделяй-и-влавствуй" используется для матриц порядка, большего чем 25. Для матриц меньшего порядка (или если нужны только собственные значения) происходит автоматический переход к QR-итерации.

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

:<math>
L = \begin{bmatrix}
a_{1} & b_{1}&&&&& \\
b_{1} & \ddots & \ddots \\
& \ddots & a_{m-1} & b_{m-1} \\
&& b_{m-1} & a_{m} & b_{m} \\
&&& b_{m} & a_{m+1} & b_{m+1} \\
&&&& b_{m+1} & \ddots \\
&&&&&& \ddots & b_{n-1} \\
&&&&&& b_{n-1} & a_{n} \\
\end{bmatrix}
= \begin{bmatrix}
a_{1} & b_{1} &&&&& \\
b_{1} & \ddots & \ddots \\
& \ddots & a_{m-1} & b_{m-1} \\
&& b_{m-1} & a_{m} - b_{m} \\
&&&& a_{m+1} - b_{m} & b_{m+1} \\
&&&& b_{m+1} & \ddots \\
&&&&&& \ddots & b_{n-1} \\
&&&&&& b_{n-1} & a_{n} \\
\end{bmatrix} +
</math>

<math>
+ \begin{bmatrix}
&&&&& \\
&&b_{m} & b_{m} \\
&&b_{m} & b_{m} \\
&&&&& \\
\end{bmatrix}

= \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}

\equiv \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T}
</math>

Предположим, что нам известны спектральные разложения матриц <math>T_{1}</math> и <math> T_{2} </math>:
<math> T_{i} = Q_{i} \Lambda_{i} Q_{i}^{T} </math>. В действительности, они будут рекурсивно вычисляться тем же самым алгоритмом. Установим связь между собственными значениями матрицы Т и собственными значениями матриц
<math>T_{1}</math> и <math>T_{2}</math>. Имеем:

<math>
T = \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T}
= \begin{bmatrix} Q_{1} \Lambda_{1} Q_{1}^{T} & 0 \\ 0 & Q_{2} L_{2} Q_{2}^{T}\end{bmatrix} + b_{m}vv^{T}
= \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}
</math>,

где

<math>
u = \begin{bmatrix} Q_{1}^{T} & 0 \\ 0 & Q_{2}^{T}\end{bmatrix}v
</math>

так как <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>.

Следовательно, <math>T</math> имеет те же собственные значения, что и пдобная ей матрица <math>D + \rho uu^{T}</math>,
где <math>D = \begin{bmatrix} L_{1} & 0 \\ 0 & L_{2}\end{bmatrix}</math> - диагональная матрица,
<math>\rho = b_{m}</math> - число, а <math>u</math> - вектор.

Будем предполагать, не ограничивая общности, что диагональные элементы <math>d_{1}, \ldots, d_{n}</math> матрицы <math>D</math> упорядочены по убыванию: <math>d_{n} <= \ldots <=d_{1}</math>.

Чтобы найти собственные значения матрицы <math>D + \rho uu^{T}</math>, вычислим её характеристический многочлен, считая пока матрицу <math>D - \lambda I</math> невырожденной.
Тогда

<math>det(D + \rho uu^{T} - \lambda I) = det((D - \lambda I)(I + \rho (D- \lambda I)^{-1} uu^{T}))</math>.

Поскольку <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. Определитель такой матрицы легко вычислить.

'''Лемма 1.''' Справедливо равенство <math>det(I + xy^{T}) = 1 + y^{T}x</math>, где <math>x</math> и <math>y</math> - векторы.

Таким образом,

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

т.е. собственные значения матрицы <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>).

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

Можно видеть, что прямая <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> флопов.
Для собственных векторов матрицы <math>D + \rho uu^{T}</math> мы легко можем получить явные выражения.

'''Лемма 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> флопов.

Доказательство.

<math>(D + \rho uu^{T})[(D - \alpha I)^{-1}u] = (D - \alpha I + \alpha I + \rho uu^{T})(D - \alpha I)^{-1}u</math>

<math>=u + \alpha (D - \alpha I)^{-1}u + u[\rho u^{T}(D - \alpha I)^{-1}u] </math>

<math>=u + \alpha(D - \alpha I)^{-1}u - u</math>

поскольку <math> \rho u^{T}(D - \alpha I)^{-1}u + 1 = f(\alpha) = 0 </math>

<math>=\alpha [(D - \alpha I)^{-1}u]</math>, что и требовалось.

Для вычисления по этой простой формуле всех <math>n</math> собственных векторов требуется <math>O(n^{2})</math> флопов. К сожалению, формула не обеспечивает численной устойчивости, так как для двух очень близких значений <math>\alpha_{i}</math> может давать неортогональные приближенные собственные векторы <math>u_{i}</math>. Потребовалось целое десятилетие для того, чтобы найти устойчивую альтернативу исходному описанию алгоритма. Снова детали будут обсуждаться позднее в данном разделе.

Алгоритм является рекурсивным.

=== Дефляция ===

До сих пор полагалось, что все <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> достаточно мало.

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

== Вычислительное ядро алгоритма ==
Вычислительным ядром последовательной схемы решения является вычисление матрицы <math>Q</math> собственных векторов путём умножения матрицы <math>Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}</math> на матрицу <math>Q^{'}</math> Данная операция имеет сложность <math>cn^{3}</math> о чём и говорится в разделе [[#Последовательная сложность алгоритма]] .
Ей предшествует вычисление собственных значений и векторов матрицы <math> D + \rho uu^{T}</math>

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

[[File:DivideAndConquerTree.png|thumb|center|left|800px|Рис. 2. Дерево алгоритма "Разделяй и властвуй"]]

[[File:InfoGraph.jpg|thumb|center|1200px|Рис. 3. Детальное описание одного блока алгоритма]]

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

Предположим, что некоторое <math>u_{i}</math>, хотя и мало, все же недостаточно мало для того, чтобы была зарегистрирована дефляция. В этом случае применение метода Ньютона к решению векового уравнения встречается с затруднениями. Вспомним, что пересчет приближённого решения <math>u_{j}</math> уравнения <math>f(\lambda) = 0</math> в методе Ньютона основан на следующих положениях:

1. Вблизи точки <math>\lambda = \lambda_{j}</math> функция <math>f(\lambda)</math> аппроксимируется линейной функцией <math>l(\lambda)</math>; график есть прямая линия, касающаяся графика функции <math>f(\lambda)</math> при <math>\lambda = \lambda_{j}</math>.

2. В качестве <math>\lambda_{j+1}</math> берётся нуль этого линейного приближения, т.е. <math>l(\lambda_{j+1})=0</math>.

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

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

Чтобы найти выход из этого положения, можно модифицировать метод Ньютона следующим образом: раз <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>, также имеющую эти полюсы, т.е. функцию вида
<math>h(\lambda)= \frac{c_{1}}{d_{i}-\lambda} + \frac{c_{2}}{d_{i+1}-\lambda} + c_{3}</math>

Константы <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>, поскольку сводится к эквивалентному квадратному уравнению
<math>c_{1}(d_{i+1}-\lambda)+c_{2}(d_{i}-\lambda)+c_{3}(d_{i}-\lambda)(d_{i+1}-\lambda)=0</math>

Пусть <math>\lambda_{j}</math> - приближённое значение корня. определим <math>c_{1},c_{2}</math> и <math>c_{3}</math> так, чтобы
<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>

для <math>\lambda</math> в окрестности <math>\lambda_{j}</math>. Заметим, что

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

Если <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>, такие, что функция

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

Это означает, что гипербола, являющаяся графиком функции <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>

Подобным же образом выбираем <math>c_{2}</math> и <math>\hat{c_{2}}</math> так, чтобы функция

<math>h_{2}(\lambda) \equiv \hat{c_{2}} + \frac{c_{2}}{d_{i+1}-\lambda}</math>

Удовлетворяла условиям

<math>h_{2}(\lambda_{j}) = \psi_{2}(\lambda_{j})</math> и <math>h_{2}^{'}(\lambda_{j})=\psi_{2}^{'}(\lambda_{j})</math> (2)

Наконец, полагаем

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

<math>\equiv c_{3} + \frac{c_{1}}{d_{i}-\lambda} + \frac{c_{2}}{d_{i+1}-\lambda}</math>.

== Схема реализации последовательного алгоритма ==
''Вычисление собственных значений и собственных векторов симметричной трехдиагональной матрицы посредством стратегии "разделяй и властвуй"'':

''proc dc_eig''<math>(T,Q,\Lambda)...</math> по входной матрице <math>T</math> вычисляются выходные матрицы <math>Q</math> и <math>\Lambda</math>, такие, что <math>T = Q\Lambda Q^{T}</math>

'''Если <math>T</math> - матрица размера <math>1</math> x <math>1</math>'''

1. Присвоить выходным параметрам значения <math> Q = 1, \Lambda = T</math>

'''Иначе'''

1. Представить <math>T</math> в виде <math> T = \begin{bmatrix} T_{1} & 0 \\ 0 & T_{2}\end{bmatrix} + b_{m}vv^{T} </math>

2. ''call dc_eig''<math>(T_{1},Q_{1},\Lambda_{1})</math>

3. ''call dc_eig''<math>(T_{2},Q_{2},\Lambda_{2})</math>

4. Построить <math>D+\rho uu^{T}</math> по <math> \Lambda_{1},\Lambda_{2}, Q_{1}, Q_{2}</math>

5. Найти матрицу собственных значений <math>\Lambda</math>

6. Найти матрицу собственных векторов <math>Q^{'}</math> для матрицы <math>D+\rho uu^{T}</math>

7. Построить матрицу собственных векторов <math>Q</math> для матрицы <math>T</math> : <math> Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}* Q^{'} </math>

8. Присвоить выходным параметрам значения <math>Q</math> и <math>\Lambda</math>

'''endif'''

== Последовательная сложность алгоритма ==
Проанализируем сложность алгоритма. Пусть <math>t(n)</math> - число флопов при обработке матрицы размера <math> n x n</math> процедурой ''dc_eig''. Тогда

<math> t(n) = 2t(n/2) </math> два рекурсивных обращения к ''dc_eig''<math>(T_{i},Q_{i},\Lambda_{i})</math>

<math> +O(n^{2})</math> вычисление собственных значений матрицы <math>D+\rho uu^{T}</math>

<math> +O(n^{2})</math> вычисление собственных векторов матрицы <math>D+\rho uu^{T}</math>

<math> +c*n^{3}</math> вычисление матрицы <math>Q = \begin{bmatrix} Q_{1} & 0 \\ 0 & Q_{2}\end{bmatrix}*Q^{'}</math>

Если <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>

На практике константа <math>c</math> обычно гораздо меньше 1, потому что матрица <math>Q^{'}</math> весьма разрежена вследствие явления, называемого дефляцией.

== Информационный граф ==
В данном разделе представлен информационный граф алгоритма: на рисунке 5 изображена часть алгоритма, в которой происходит деление - "Divide", а на рисунке 6 описана часть "Conquer".

[[File:Divide.jpg|thumb|center|left|800px|Рис. 5. Информационный граф алгоритма "Разделяй и властвуй" - шаг Divide]]

[[File:ConquerPart.jpg|thumb|center|1200px|Рис. 6. Информационный граф алгоритма "Разделяй и властвуй" - шаг Conquer. Qk*k - матрица собственных значений размерности k. Lk*k - матрица собственных векторов размерности k.]]

Операции:

<math>D</math> - операция Divide разделения матрицы <math> T </math> на матрицы <math>T_{1}</math> и <math>T_{2}</math>

Индексы - размерность

<math>S_{k}</math> - операция Conquer сбора матрицы <math> D </math>

<math> L_{k} </math> - операция поиска собственных значений

<math> S^{'} </math> - операция поиска собственных векторов матрицы <math> Q^{'} </math>

<math> S </math> - операция поиска собственных векторов матрицы <math> Q </math>

== Ресурс параллелизма алгоритма ==
Рассмотрев информационный граф алгоритма, можно заметить, что в структуре имеется два параллельных блока - вызов рекурсивных функций ''dc_eig'' для вычисления собственных значений и векторов матриц <math>T_{1}</math> и <math>T_{2}</math> - это единственная часть алгоритма, в которой мы прибегаем к параллелизму.

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

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

В случае реализации без параллелизма, функции ''dc_eig'' отрабатывают последовательно - сначала со входными параметрами <math>T_{1}, Q_{1}, \Lambda_{1}</math>, затем - <math>T_{2}, Q_{2}, \Lambda_{2}</math>.

Таким образом, благодаря параллелизму высота алгоритма параллельного составляет <math>log_{2}(n)</math>, когда как при последовательной реализации высота алгоритма равна сумме геометрической прогрессии <math>1+2+4+8+...+2^{n-1} = 2^{n} - 1</math>, что значительно сокращает число итераций алгоритма.

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

На вход алгоритму подаётся трёхдиагональная симметричная матрица:

<math>
L = \begin{bmatrix}
a_{1} & b_{1}&&&&& \\
b_{1} & \ddots & \ddots \\
& \ddots & a_{m-1} & b_{m-1} \\
&& b_{m-1} & a_{m} & b_{m} \\
&&& b_{m} & a_{m+1} & b_{m+1} \\
&&&& b_{m+1} & \ddots \\
&&&&&& \ddots & b_{n-1} \\
&&&&&& b_{n-1} & a_{n} \\
\end{bmatrix}
</math>

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

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

'''Выходные данные:'''

На выходе мы получаем вектор собственных значений длины <math> n </math> и <math> n </math> собственных векторов длины <math> n </math> , соответствующих собственным значениям исходной матрицы.

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

<math> n + n^{2} = n(n + 1) </math>

== Свойства алгоритма ==
Описанный в данной статье алгоритм является самым быстрым алгоритмом, среди существующих: QR / Бисекция и обратная итерация / Разделяй и властвуй.

Последовательная сложность алгоритма: <math> t = c\frac{4}{3}n^{3} </math>

Параллельная сложность алгоритма (в силу использования дефляции): <math> O(n^{2.3})</math> или в самых редких случаях <math> O(n^{2}) </math> (см. [3] стр. 8).

Особенности алгоритма:

1. Использование дефляции ([[#Дефляция]])

2. Использование адаптированного метода Ньютона ([[#Макроструктура алгоритма]])

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

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

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

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

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

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

== Существующие реализации алгоритма ==
Большого количества реализаций данного алгоритма найдено не было: единственный пример описан на страницах 7, 19 и 20 в [http://www.netlib.org/lapack/lawnspdf/lawn132.pdf этой статье], которая указана в списке литературы.

= Литература =
[1] Дж. Деммель, «Вычислительная линейная алгебра» //С. 230-235

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

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

[4] [https://en.wikipedia.org/wiki/Divide-and-conquer_eigenvalue_algorithm Алгоритм "Разделяй и властвуй" - Wikipedia]

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

[[en:Description of algorithm properties and structure]]

Участник:Kanast74/Алгоритм кластеризации, основанный на минимальном покрывающем дереве

2016-11-01T07:20:57Z

IgorS:

{{Assignment|IgorS}}
Статью подготовила: [[Участник:kanast74|Дмитриева Анастасия Владимировна]].

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

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

Кластеризация - это задача статистического анализа, состоящая в разбиении множества объектов на группы, называемые кластерами, внутри которых объекты обладают одними и теми же свойствами (чаще всего, это означает близость относительно заданной метрики). Основное отличие от задачи классификации состоит в том, что группы заранее не заданы и определяются в процессе работы алгоритма.

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

Пусть на начальном этапе решения задачи имеются набор тестовых примеров <math>X=\{x_1...x_n\}</math>, а также функция расстояния между ними <math>r(e)</math>. Отметим, что метрика, в которой вычисляются расстояния между объектами, выбирается исходя из требований задачи; наиболее распространенные - это Евклидово расстояние, квадрат Евклидова расстояния, манхэттенская метрика, расстояние Чебышева и степенное расстояние. Далее необходимо применить один из алгоритмов кластеризации, которые можно разделить на две категории: иерархические, состоящие в последовательном поиске кластеров из уже найденных кластеров, а также неиерархические, цель которых состоит в минимизации некоторой целевой функции. К последней группе относятся такие алгоритмы, как алгоритм k-средних, алгоритм EM, нечеткие алгоритмы, а также алгоритмы теории графов, к категории которых относится алгоритм, описываемый в данной статье.

Рассмотрим алгоритм кластеризации на k кластеров, основанный на построении минимального остовного дерева (MST) и который состоит в следующем:

# По исходным данным строится взвешенный неориентированный граф: каждый объект представляется в виде вершины графа, а вес ребра, связывающего две вершины, есть расстояние между объектами в выбранной заранее метрике
# Для полученного графа строится минимальное остовное дерево, то есть дерево, содержащее все вершины графа и имеющее минимальный суммарный вес своих ребер
# Удаляется k-1 ребро минимального остовного дерева с максимальным весом
# Получаются k компонент связности, которые интерпретируются как кластеры

Для построения минимального остовного дерева могут быть использованы различные алгоритмы, среди которых наиболее распространены:

# Алгоритм Крускала
# Алгоритм Борувки
# Алгоритм Прима

Отметим, что в рамках проведенного исследования использовался алгоритм Крускала<nowiki>, наиболее подробно изучить который можно, пройдя по ссылке [</nowiki>[https://algowiki-project.org/ru/Алгоритм_Крускала Алгоритм Крускала]], поэтому в данной статье его описание не приводится.

=== Математическое описание алгоритма ===
С математической точки зрения задачу кластеризации можно рассматривать как минимизацию среднего внутрикластерного расстояния <math> \frac{\sum_{i<j, c(x_i)=c(x_j)} r(x_i,x_j)}{\sum_{i<j, c(x_i)=c(x_j)} 1} \to min </math> с одной стороны и максимизации межкластерного расстояния <math> \frac{\sum_{i<j, c(x_i)\neq c(x_j)} r(x_i,x_j)}{\sum_{i<j, c(x_i) \neq c(x_j)} 1} \to max </math> с другой стороны, где <math>c(x)</math> - кластер, к которому принадлежит объект <math>x</math>.

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

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

Вычислительным ядром описываемого алгоритма является построение минимального остовного дерева. В случае, если программа предполагается быть распараллеленной, то операция построения MST будет производиться в отдельности в каждом процессе. Как уже было отмечено, в данном исследовании для построения MST использовался алгоритм Крускала, который будет работать наиболее эффективно, если веса ребер исходного графа отсортированы, поэтому сортировка - это еще одна операция, которая должна быть включена в вычислительное ядро, что предполагает выбранная ревлизация алгоритма. Поэтому в дальнейшем мы не будем разделять сортировку и поиск минимального остовного дерева, предполагая, что они объеденены в единый эффективный алгоритм.

Дадим некоторую справку касательно адгоритма поиска MST, фигурирующего в данном исследовании. Алгоритм Крускала — алгоритм построения минимального остовного дерева взвешенного связного неориентированного графа. Алгоритм впервые описан Джозефом Крускалом в 1956 году.

Алгоритм Крускала находит безопасное ребро для добавления в растущий лес путем поиска ребра <math>(u, v)</math> с минимальным весом среди всех ребер, соединяющих два дерева в лесу. Обозначим два дерева, соединяемые ребром <math>(u, v) </math>, как <math>C_1</math> и <math>C_2</math>. <math>(u, v)</math> — безопасное для <math>C_1</math> ребро. Алгоритм Крускала является жадным, поскольку на каждом шаге он добавляет к лесу ребро с минимально возможным весом.

=== Макроструктура алгоритма ===
# Построение графа путем задания списков ребер. В общем случае, когда задано некоторое множество объектов, для построения графа может быть использован алгоритм, позволяющий рассчитать расстояние от каждого объекта до каждого за <math>O(n^2)</math> операций, где <math>n</math> число объектов (вообще говоря, данная операция требует <math>O(E)</math> операций, где <math>E</math> - число ребер в графе, но в нашем случае число ребер подразумевается равным <math>E=\frac{D (n(n-1))}{2}</math>, <math>D</math> - плотность графа). Однако в рамках данного исследования для тестирования алгоритма использовалась такая технология построения графов, когда в качестве веса каждого ребра назначается некоторое произвольное число из заданного промежутка (например, от 1 до 1000), что также требует <math>O(n^2)</math>
# Построение минимального остовного дерева на основании полученного ранее графа, для чего может быть использован один из известных и наиболее распространенных алгоритмов (алгоритм Крускала, алгоритм Борувки или алгоритм Прима). Рассмотрим, например, алгоритм Крускала. На начальном этапе имеется граф, состоящий из вершин - объектов исходной выборки и не содержащий ребер, следовательно, каждая из вершин изначально представляет собой компоненту связности и даже дерево. Алгоритм состоит в выборе на каждом шаге ребра с минимальным весом и добавлении его в дерево, если оно соединяет два дерева. Алгоритм будет работать максимально эффективно, если изначально ребра графа, полученного на первом шаге будут отсортированы (например, по возрастанию).
# Для получения <math>k</math> кластеров необходимо удалить из получившегося минимального остовного дерева <math>k-1</math> ребро с максимальным весом. В частности, в случае, если на предыдущем шаге мы пользовались алгоритмом Крускала для построения MST, ребра получившегося дерева отсортированы по возрастанию, значит для удаления указанных выше ребер потребуется лишь <math>O(1)</math> операций
# Наконец, необходимо правильно интерпретировать результат работы алгоритма и перечислить вершины, принадлежащие полученным кластерам; на выполнение данного шага может потребоваться различное число операций в зависимости от формата выходных данных программы: например, в данной реализации выходные данные, как будет сказано в дальнейшем, представлены в виде списка ребер, формирующий итоговый минимальный остовный лес, следовательно в общем случае на его обработку потребуется <math>O(V)</math> операций

==== Используемые обозначения и структуры данных ====

Обозначим в качестве <math>G=(V,E)</math> граф, содержащий <math>V</math> вершин и <math>E</math> ребер. Для построения минимального остовного дерева для данного графа используются три операции [2], опишем здесь каждую из них:

# операция MakeSet(<math>v</math>) генерирует дерево (множество) для вершины графа <math>v</math>, являющейся корнем искомого дерева
# операция Find(<math>v</math>) определяет, которому из деревьев принадлежит интересующая вершина <math>v</math>. Условимся, что данная операция возвращает ту вершину, которая является корнем искомого дерева
# операция Union(<math>u, v</math>) объединяет два множества (два дерева, содержащих соответствующие вершины) под одним корнем

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

Приведем здесь псевдокод основной части алгоритма - а именно построения локального минимального остовного дерева при помощи алгоритма Крускала.

Kruskal ( G=(V,E) ):

1. mst = ∅;

2. сортировать E по возрастанию;

3. для каждой вершины v из множества вершин V:

4. MakeSet(v);

5. для каждого ребра e = (u, v) из множества ребер E:

6. if Find(u) ≠ Find(v):

7. mst = mst ∪ { (u,v) };

8. Union(u, v);

9. return mst;

=== Последовательная сложность алгоритма ===
Сперва оценим последовательную сложность составных частей алгоритма.

0. O(E): Формирование графа

1. O(1): Инициализация пустого множества.

2. O(Elog(E)): сортировка ребер из множества E.

3. O(V): Инициализация одноточечного множества для каждой вершины из V.

4. ▲ MakeSet за O(1).

5. O(Elog(V)): Операции Union и Find для каждого ребра из E.

6. ▲ Find за O(1).

7. ▲ Присоединение элемента за O(1).

8. ▲ Union за O(log(V)).

9. O(1): Удаление k-1 ребра для получения k компонент связности

10. O(V): Перечисление вершин, входящих в соответствующие кластеры

11. O(1): Return.

Таким образом, с учетом того, что, получаем:

<math>T( G = (V, E) ) = O(1) + O(E\log(E)) + O(V) + O(E\log(V)) + O(E) = O(E\log(E)) + O(E\log(V)) = O(E\log(V)) + O(E\log(V))</math>

Итак, оценка сложности алгоритма есть <math>T( G = (V, E) ) = O(E\log(V)) + O(\log(V))</math>

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

[[file:Clustering kruskal.png|thumb|center|1400px|Рисунок 1. Информационный граф алгоритма]]

По структуре информационного графа можно сделать вывод что высота канонической ярусно-параллельной формы [1] есть <math>\log{p}</math>, где <math>p</math> число процессов.

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

Описанный алгоритм позволяет произвести распараллеливание, источник которого будет описан в данном пункте. Прежде всего, необходимо отметить, что данный алгоритм допускает преобразование в гибридную параллельную версию, а именно версию с использованием технологий MPI и OpenMP.

Тем не менее, прежде всего следует установить справедливость свойства используемого алгоритма поиска MST, позволяющего произвести его распараллеливание [3]:

'''Ассоциативность по рёбрам'''. Пусть <math>MSF(E)</math> – минимальный остовный лес графа с рёбрами <math>E</math>. Тогда
:<math>
MSF(E_1 \cup E_2 \cup \dots \cup E_k) = MSF(MSF(E_1) \cup MSF(E_2) \cup \dots \cup MSF(E_k)).
</math>

В том случае, когда все объекты заранее известны, и между ними можно рассчитать все попарные расстояния, первый шаг - построение графа - позволяет произвести распараллеливание при помощи обеих вышеуказанных технологий, а именно: разделить объекты между процессами при помощи MPI, а внутри каждой из полученных групп будем рассчитывать попарные расстояния параллельно на нескольких ядрах, использовав технологию OpenMP. Однако в данном исследовании кластеризуемые объекты предполагались заранее неизвестными, так как попарные расстояния между объектами задаются случайным образом, а это означает, что произвести распараллеливание этого шага, которое бы дало хотя бы небольшое ускорение (уменьшение времени работы), не получится.

Если все же объекты заранее были известны, можно сохранить полученную на предыдущем этапе группировку их на отдельные процессы и внутри каждого произвести сортировку расстояний между объектами по возрастанию при помощи алгоритма QSort с использованием технологии OpenMP (в противном случае параллельная структура алгоритма поддерживается начиная с этого шага).

Далее внутри каждой группы объектов (каждый процесс в отдельности) строим минимальное остовное дерево, в конце шага деревья объединяются в одно - общее MST для всех объектов, поддерживая при этом отсортированность расстояний по возрастанию.

Наконец, будем удалять необходимое количество ребер глобального остовного дерева для того, чтобы получить требуемое количество кластеров - компонент связности графа.

==== Стратегии распараллеливания ====
Необходимо отметить, что несмотря на всю простоту идеи распараллеливания алгоритма, описанную выше, существует несколько стратегий реализовать ее на практике. При этом, как будет показано далее, указанные стратегии дают различные приросты в производительности. Перечислим некоторые из них:

# первая стратегия, наиболее очевидная, состоит в том, чтобы в самом начале главный процесс считывает данные о ребрах и распределяет считанную информацию между остальными процессами, не имеющим доступа к файлу с исходными данными. Далее каждый из процессов рассчитывает локальное минимальное остовное дерево и передает его обратно главному процессу, который объединяет деревья в одно, глобальное
# вторая стратегия во многом напоминает первую, но основное различие между ними состоит в том, что во втором случае файл с исходными данными не разделяется между процессами, а является доступным для каждого из них в полном объеме. Таким образом, каждый процесс способен считать данные о ребрах, за которые они отвечают, самостоятельно, что значительно снижает объем коммуникации между процессами. Также еще одно улучшение состоит в том, что теперь главный процесс не простаивает во время работы остальных, а, как и остальные, рассчитывает локальное минимальное остовное дерево
# наконец, третья стратегия состоит в том, чтобы оптимизировать процесс слияния локальных минимальных остовных деревьев. Предлагается сделать так, чтобы не только главный процесс занимался слиянием, но каждый процесс участвует в процессе слияния. Для того, чтобы добиться максимальной эффективности будем предполагать, что число процессов <math>p=2^n,n>1</math>. В этом случае потребуется <math>\log{p}</math> шагов, чтобы выполнить слияние. На каждом шаге половина активных процессов пересылает свое локальное дерево процессу с меньшим номером на единицу, а другая половина занимается приемом и слиянием. Таким образом, через <math> \log{p} </math> шагов главный процесс, который имеет номер 0, будет иметь в своем распоряжении глобальное минимальное остовное дерево.

==== Способы разделения графа ====

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

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

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

По исходным данным формируется граф <math>G = (V, E)</math>, являющийся неориентированным, взвешенным, связным и не имеющим кратных ребер. Пусть полученный граф содержит <math> |V|</math> вершин и <math>|E|</math> ребер. Предполагая, что каждый объект можно сравнить с каждым, можно считать, что получаемый граф является полным, а значит число ребер может быть оценено следующим образом: <math>|E|=\frac{|V|(|V|-1)}{2} \le \frac{|V|^2}{2}-\frac{|V|}{2} \Rightarrow O(E)=O(V^2)</math>

Обозначим в виде <math>w(u,v)</math> вес ребра, соединяющего вершины <math>u</math> и <math>v</math>. Тогда граф может быть задан в виде списка ребер, а именно списка троек: <math>(u,v,w(u,v))</math>, что является более удобным представлением графа для реализации многих алгоритмов по сравнению с матрицей смежности. Помимо этого, данный способ помогает сэкономить память. Недостатков указанного подхода является только то, что установить, с какими вершинами связана интересующая вершина, а также вес соответствующих ребер является весьма затруднительно. Однако для решения поставленной задачи нам это и не потребуется.

Формат выходных данных аналогичный

=== Свойства алгоритма ===
==== Вычислительная мощность ====
Оценим вычислительную мощность алгоритма в том случае, когда для его реализации используется <math>p</math> процессов. Предположим, что алгоритм реализован при помощи первой стратегии (см. выше) и применяется к графу <math>G = (V, E)</math>, тогда:

* Ввод данных: <math>\frac{|E|}{p}</math> - в среднем столько ребер содержит получаемый каждым процессом связный подграф
* Вывод данных: <math>\frac{|V| - 1}{p}</math> - каждый из процессов должен вывести посчитанное локальное минимальное дерево, которое содержит указанное количество ребер, так как остальные ребра, изначально входившие в состав подграфа, не будут входит в локальное MST
* Вычисление: для вычисления локального MST каждому из процессов требуется <math>\frac{|E|}{p} \log{\frac{|V|}{p}}</math> операций

Таким образом, искомое соотношение может быть записано в следующем виде: <math>\frac{\frac{|E|}{p} \log{\frac{|V|}{p}}}{\frac{|E|}{p} + \frac{|V| - 1}{p}} = \frac{|E| \log{\frac{|V|}{p}}}{|E|+|V|-1}</math>

На основании полученной формулы можно сделать несколько выводов:

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

==== Оценка прироста в производительности ====
===== Закон Амдала =====

В данном рзеделе будет производиться оценка прироста производительности параллельного алгоритма по сравнению с последовательным. Наиболее простой способ оценить прирост производительности – использовать закон Амдала, который гласит, что прирост может быть оценен следующим образом: <math> S_p \le \frac{1}{f+\frac{1-f}{p}}</math>,

где <math>f</math> – часть алгоритма, которая не может быть распараллелена, <math>p</math> – число процессов.

В наиболее тривиальном случае (первая стратегия распараллеливания) распараллеливанию не подлежит считывание входных данных и их разделение между процессами, а также объединение локальных MST в одно. Поэтому сложность последовательной части программы может быть оценена следующим образом: <math>2O(V^2)+O(V^2 \log{V})</math>. Распараллеливанию подлежит инициализация подграфов при помощи операции MakeSet за <math>O(V)</math>, сортировка ребер по возрастанию внутри каждой группы за <math>O(V^2 \log{V})</math>, а также построение локальных минимальных остовных деревьев за аналогичное время. Поэтому сложность параллельной части алгоритма может быть оценена так: <math>O(V)+2 O(V^2 \log{V})</math>. Таким образом, вычислив отношение сложностей частей программы, получаем, что <math>f=0.44</math>. Устремим число процессов <math>p</math> к бесконечности и получим, что максимальное ускорение, которое можно получить путем распараллеливания алгоритма есть <math>2.27</math>. К сожалению, данная оценка не является точной. Для того, чтобы оценить прирост производительности более качественно, произведем анализ временных диаграмм программы.

===== Анализ временных диаграмм =====

Обозначим за <math>t_d</math> – время, которое требуется для того, чтобы разделить граф на подграфы, <math>t_p</math> – суммарное время вычислений, <math>t_b</math> – время обратной пересылки локально полученных результатов, <math>t_l</math> – задержка одной пересылки. Причем можно убедиться в том, что <math>t_p > t_d > t_b > t_l</math>, также известно, что время выполнения последовательного кода <math>t_{serial} = t_p</math>.

[[Файл:FirstStrategy.PNG|thumb|center|400px|Рисунок 2. Первая стратегия распараллеливания вычислительного ядра алгоритма]]
Произведем анализ первой (наивной) стратегии распараллеливания программы. На временной диаграмме жирным обозначен критический путь, время выполнения которого может быть вычислено по формуле (см: [2]):
<math>t_{paralel} = 4 t_l + t_d + \frac{t_p}{3} + \frac{t_b}{3}</math>

Тогда максимальное ускорение для одного процесса есть: <math>speedup=\frac{t_{serial}}{t_{parallel}} = \frac{t_p}{4 t_l + t_d + \frac{t_p}{3} + \frac{t_b}{3}}</math>

А в случае n процессов: <math>speedup = \frac{n}{1+\frac{n (n+1) t_l + n t_d + t_b}{t_p}}</math>

[[Файл:SecondStrategy.PNG|thumb|center|400px|Рисунок 3. Вторая стратегия распараллеливания вычислительного ядра алгоритма]]
Теперь проанализируем вторую стратегию, основная задача которой – уменьшить объем коммуникаций между процессами за счет того, что файл с исходными данными теперь доступен всем процессам. Помимо этого введем в рассмотрение новую величину <math>t_i</math> – время, требующееся на инициализацию множеств вершин. Тогда для одного процесса <math>t_{parallel} = t_i + \frac{t_p}{4} + t_l + 3 \frac{t_b}{4}</math>, а максимальное ускорение в случае n процессов есть: <math>speedup= \frac{t_{serial}}{t_{parallel}} = \frac{4}{1+\frac{4 t_i + 4 t_l + 3 t_b}{t_p}}</math>

[[Файл:ThirdStrategy.PNG|thumb|center|400px|Рисунок 4. Третья стратегия распараллеливания вычислительного ядра алгоритма]]
Наконец, проанализируем третью стратегию, основная цель которой – оптимизировать процесс слияния локальных минимальных остовных деревьев, а также привлечь все активные процессы (включая главный) к процессу построения локального MST. В этом случае время выполнения параллельной части программы с использованием лишь одного процесса: <math> t_{parallel}=t_i + \frac{t_p}{4} + t_l + 2 \frac{t_b}{4}</math>, а суммарное ускорение в общем случае: <math>speedup=\frac{t_{serial}}{t_{parallel}} = \frac{n}{1+\frac{n t_i + n t_l + \log_2{n} t_b}{t_p}}</math>

На рисунке 5 приведены графики, отражающие зависимость получаемых возможных ускорений в зависимости от числа задействованных процессов, посчитанные с использованием четырех различных подходов.
[[Файл:Comparison.PNG|thumb|center|400px|Рисунок 5. Сравнение стратегий распараллеливания]]

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===

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

# первая стратегия, наиболее очевидная, состоит в том, чтобы в самом начале главный процесс считал данные о ребрах и распределил считанную информацию между остальными процессами, причем каждый из них не имеет доступа к файлу с данными. Далее каждый из процессов рассчитывает локальное минимальное остовное дерево и передает его обратно главному процессу, который объединяет деревья в одно, глобальное
# вторая стратегия во многом напоминает первую, но основное различие между ними состоит в том, что во втором случае файл с исходными данными не разделяется между процессами, а является доступным для каждого из них в полном объеме. Таким образом, каждый процесс способен считать данные о ребрах, за которые они отвечают, самостоятельно, что значительно снижает объем коммуникации между процессами. Также еще одно улучшение состоит в том, что теперь главный процесс не простаивает во время работы остальных, а, как и остальные, рассчитывает локальное минимальное остовное дерево
# наконец, третья стратегия состоит в том, чтобы оптимизировать процесс слияния локальных минимальных остовных деревьев. Предлагается сделать так, чтобы не только главный процесс занимался слиянием, но каждый процесс участвует в процессе слияния. Для того, чтобы добиться максимальной эффективности будем предполагать, что число процессов <math>p=2^n,n>1</math>. В этом случае потребуется <math>\log{p}</math> шагов, чтобы выполнить слияние. На каждом шаге половина активных процессов пересылает свое локальное дерево процессу с меньшим номером на единицу, а другая половина занимается приемом и слиянием. Таким образом, через шагов главный процесс, который имеет номер 0, будет иметь в своем распоряжении глобальное минимальное остовное дерево.

=== Масштабируемость алгоритма и его реализации ===
[[file:Total.png|thumb|center|400px|Рисунок 6. График зависимости времени вычисления от размера задачи и числа процессов (с учетом времени ввода-вывода)]]
[[file:Wo_io.png|thumb|center|400px|Рисунок 7. График зависимости времени вычисления от размера задачи и числа процессов (без учета времени ввода-вывода)]]

На графиках видно, как с увеличением объема вычислительных ресурсов происходит прирост в производительности. Данный эффект происходит до некоторых пор, после чего накладные расходы на коммуникацию между процессами нивелируют его. При дальнейшем увеличении числа процессов время решения задачи заметно увеличивается, однако, ввиду длинных очередей на суперкомпьютере Ломоносов данные с числом процессов <math> \ge 256</math> получить не удалось

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма [3]===
* C++: [http://www.boost.org/libs/graph/doc/ Boost Graph Library] (функция <code>[http://www.boost.org/libs/graph/doc/kruskal_min_spanning_tree.html kruskal_min_spanning_tree]</code>).
* C++, MPI: [http://www.boost.org/libs/graph_parallel/doc/html/index.html Parallel Boost Graph Library]
** функция <code>[http://www.boost.org/libs/graph_parallel/doc/html/dehne_gotz_min_spanning_tree.html#merge-local-minimum-spanning-trees merge_local_minimum_spanning_trees]</code> реализует алгоритм Крускала;
** функции <code>[http://www.boost.org/libs/graph_parallel/doc/html/dehne_gotz_min_spanning_tree.html#dense-boruvka-minimum-spanning-tree dense_boruvka_minimum_spanning_tree]</code>, <code>[http://www.boost.org/libs/graph_parallel/doc/html/dehne_gotz_min_spanning_tree.html#boruvka-then-merge boruvka_then_merge]</code>, <code>[http://www.boost.org/libs/graph_parallel/doc/html/dehne_gotz_min_spanning_tree.html#boruvka-mixed-merge boruvka_mixed_merge]</code> сочетают [[алгоритм Борувки]] и алгоритм Крускала.
* Python: [https://networkx.github.io NetworkX] (функция <code>[http://networkx.github.io/documentation/networkx-1.9.1/reference/generated/networkx.algorithms.mst.minimum_spanning_tree.html minimum_spanning_tree]</code>).
* Java: [http://jgrapht.org JGraphT] (класс <code>[http://jgrapht.org/javadoc/org/jgrapht/alg/KruskalMinimumSpanningTree.html KruskalMinimumSpanningTree]</code>).

= Литература =
[1] Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.

[2] http://www.gpiskas.com/pdf/kruskal_mpi.pdf (дата обращения: 02.10.2016)

[3] https://algowiki-project.org/ru/Алгоритм_Крускала

Участник:Лукьянова Анна/Алгоритм кластеризации с использованием представлений2

2016-11-01T07:14:32Z

IgorS:

{{Assignment|IgorS}}

Основные авторы описания: [[U:Лукьянова Анна|А.Я. Лукьянова]]

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

===Понятие кластеризации===

Кластеризация (или кластерный анализ) — это задача разбиения множества объектов на группы, называемые кластерами. Внутри каждой группы должны оказаться «похожие» объекты, а объекты разных группы должны быть как можно более отличны. Главное отличие кластеризации от классификации состоит в том, что перечень групп четко не задан и определяется в процессе работы алгоритма.

Применение кластерного анализа в общем виде сводится к следующим этапам:

#Отбор выборки объектов для кластеризации.
#Определение множества переменных, по которым будут оцениваться объекты в выборке. При необходимости – нормализация значений переменных.
#Вычисление значений меры сходства между объектами.
#Применение метода кластерного анализа для создания групп сходных объектов (кластеров).
#Представление результатов анализа.

Классификация алгоритмов

'''Методы по способу обработки данных:'''

''Иерархические методы:''
*Агломеративные методы AGNES (Agglomerative Nesting):
*Дивизимные методы DIANA (Divisive Analysis):

''Неиерархические методы.''
*Итеративные

'''Методы по способу анализа данных:'''

*Четкие;

*Нечеткие.

'''Методы по количеству применений алгоритмов кластеризации:'''

*С одноэтапной кластеризацией;

*С многоэтапной кластеризацией.

'''Методы по возможности расширения объема обрабатываемых данных:'''

*Масштабируемые;

*Немасштабируемые

'''Методы по времени выполнения кластеризации:'''

*Потоковые (on-line);

*Не потоковые (off-line).

===CURE===

Алгоритм '''CURE (Clustering Using REpresentatives)''' выполняет иерархическую кластеризацию с использованием набора определяющих точек для определения объекта в кластер. Относится к алгомеративным методам.

Эта группа методов характеризуется последовательным объединением исходных элементов и соответствующим уменьшением числа кластеров.

Назначение: кластеризация очень больших наборов числовых данных.

Ограничения: эффективен для данных низкой размерности, работает только на числовых данных.

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

Недостатки: есть необходимость в задании пороговых значений и количества кластеров.

Описание алгоритма :

[[file:Page1.png|thumb|center|1400px|Рисунок 1: Обзор CURE ]]

'''Шаг 1:''' Построение дерева кластеров, состоящего из каждой строки входного набора данных.

'''Шаг 2:''' Формирование «кучи» в оперативной памяти, расчет расстояния до ближайшего кластера (строки данных) для каждого кластера. При формировании кучи кластеры сортируются по возрастанию дистанции от кластера до ближайшего кластера. Расстояние между кластерами определяется по двум ближайшим элементам из соседних кластеров. Для определения расстояния между кластерами используются «манхеттенская», «евклидова» метрики или похожие на них функции.

''Метрика Евклида:'' <math>\rho(p,k) = \sqrt{\sum_{i=1}^n (p_{i} - k_{i})^2}</math>

''«Манхеттенская» метрика:'' <math>\rho(p,k) =\sum_{i=1}^n |p_{i} - k_{i}|</math>

'''Шаг 3:''' Слияние ближних кластеров в один кластер. Новый кластер получает все точки входящих в него входных данных. Расчет расстояния до остальных кластеров для новообразованного кластера. Для расчета расстояния кластеры делятся на две группы: первая группа – кластеры, у которых ближайшими кластерами считаются кластеры, входящие в новообразованный кластер, остальные кластеры – вторая группа. И при этом для кластеров из первой группы, если расстояние до новообразованного кластера меньше чем до предыдущего ближайшего кластера, то ближайший кластер меняется на новообразованный кластер. В противном случае ищется новый ближайший кластер, но при этом не берутся кластеры, расстояния до которых больше, чем до новообразованного кластера. Для кластеров второй группы выполняется следующее: если расстояние до новообразованного кластера ближе, чем предыдущий ближайший кластер, то ближайший кластер меняется. В противном случае ничего не происходит.

'''Шаг 4:''' Переход на шаг 3, если не получено требуемое количество кластеров.

Выбранные точки сдвигаются на следующем шаге на <math>\alpha</math> к центроиду кластера. Алгоритм становится основанным на методе поиска центроида при <math>\alpha = 1</math>, и основанным на всех точках кластера при <math>\alpha = 0</math>.

[[Файл:Factor_a.png|400px|thumb|center| Рисунок 2: Чувствительность алгоритма к параметру <math>\alpha </math>.]]

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

Прежде всего, алгоритм использует случайное разбиение выборки из <math> n </math> элементов на <math> p </math> частей, которые могут поместиться в память отдельной машины кластера. Затем во время первого прохода алгоритм уменьшает число кластеров в каждой подвыборке до <math> \frac{n}{pq} </math>, где <math> q \geq 1 </math> – некоторая константа. Для последующего шага на вход кластеризации подаются только представительные точки <math>c</math> кластеров, полученных на предыдущем этапе. В ходе второго прохода алгоритма кластеризации остаются представительные точки для заданного количества кластеров. Алгоритм использует представительные точки, как метки, задающие форму и размер кластера.

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

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

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

Основную часть метода составляют разбиение случайной выборки строк на <math>k</math> кластеров и нахождение точек-представителей для каждого кластера.

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

Псевдокод

Input : A set of points S

Output : ''k'' clusters

* For every cluster u (each input point), in u.mean and u.rep store the mean of the points in the cluster and a set of ''c'' representative points of the cluster (initially ''c'' = 1 since each cluster has one data point). Also u.closest stores the cluster closest to u.
* All the input points are inserted into a k-d tree T
* Treat each input point as separate cluster, compute u.closest for each u and then insert each cluster into the heap Q. (clusters are arranged in increasing order of distances between u and u.closest).
* While size(Q) > ''k''
* Remove the top element of Q(say u) and merge it with its closest cluster u.closest(say v) and compute the new representative points for the merged cluster w.
* Remove u and v from T and Q.
* For all the clusters x in Q, update x.closest and relocate x
* insert w into Q
* repeat

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

Являясь представителем иерархических алгоритмов кластеризации, имеет сложность <math> O(n^2 log(n)) </math> и <math> O(n^2) </math> для признаковых пространств малой размерности

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

В начале работы алгоритма все объекты являются отдельными кластерами. На первом шаге наиболее похожие объекты объединяются в кластер. На последующих шагах объединение продолжается до тех пор, пока все объекты не будут составлять один кластер.

[[Файл:Metod.png|400px|thumb|center| Рисунок 3: Дендрограмма агломеративных методов]]

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

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

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

'''Входные данные:''' набор данных <math> S </math> , количество кластеров <math>k</math>, число точек представителей <math>c</math>, параметр <math>\alpha</math>, параметр <math>\gamma</math>, <math>m</math> число точек для кластеризации, <math>n</math> размерность.

Параметр <math>\alpha</math> для сжатия точек представления к центру кластера. В оригинальной статье авторы показывают что <math>\alpha</math> от <math>0.2</math> до <math>0.7</math> помогает хорошо выявлять несферические кластеры и подавлять редкие выбросы.

[[Файл:Factor_a.png|400px|thumb|center| Рисунок 2: Чувствительность алгоритма к параметру <math>\alpha </math>.]]

Параметр <math>\gamma</math> задаёт какая часть от <math>m</math> точек будет использована при случайной выборке точек на шаге 2.

Число точек представителей выбирается в зависимости от данных. Если возможно появление кластеров сложной формы, то точек должно быть больше, чтобы выявить их форму. В оригинальной статье авторы показывают что уже при <math>c</math> равном <math>10</math> достигается неплохая эффективность.

[[Файл:Param_c.png|400px|thumb|center| Рисунок 4: Результат работы алгоритка в зависимости от количесва представлений <math>c</math>.]]

Из рисунка видно, что при меньших значениях <math>c</math> качество работы алгоритма ухудшается

'''Выходные данные:''' требуемое количество <math> k </math> крастеров

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

* является масштабируемым алгоритмом

* неважна форма кластера и размер

*работает только на числовых данных

= ЧАСТЬ. Программная реализация алгоритма =

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

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

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

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

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

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

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

Последовательная реализация CURE-алгоритма для кластеризации для Python/C++ представлена в пакете: [https://github.com/annoviko/pyclustering pyclustering].

Также существует параллельная реализация алгоритма, описанная в сборнике [4]. Алгоритм предложенный в статье использует массив данных состоящий из размеров кластера, его центроида и репрезентативных точек, а при объединении кластеров информацию о новом кластере просто записывают в строчку предыдущего. Также для каждого кластера требуется считать индекс и расстояние до ближайшего кластера. Именно их поиск авторы статьи и предлагают распараллелить.

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

[1] Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.

[2] Theodoridis, Sergios; Koutroumbas, Konstantinos (2006). Pattern recognition. Academic Press. pp. 572–574. ISBN 978-0-12-369531-4.

[3] Guha, Sudipto; Rastogi, Rajeev; Shim, Kyuseok (2001). "CURE: An Efficient Clustering Algorithm for Large Databases" (PDF). Information Systems. 26 (1): 35–58. doi:10.1016/S0306-4379(01)00008-4

[4] Panagiotis E. Hadjidoukas, Laurent Amsaleg. OpenMP Shared Memory Parallel Programming.
Volume 4315 of the series Lecture Notes in Computer Science pp 289-299
Parallelization of a Hierarchical Data Clustering Algorithm Using OpenMP

Участник:Vagabond/Алгоритм быстрого дискретного пребразования Фурье

2016-11-01T07:10:22Z

IgorS:

{{Assignment|IgorS}}
'''Автор''': Данилишин А.Р.
= ЧАСТЬ. Свойства и структура алгоритмов =

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

Главная идея БПФ состоит в сокращении многочисленных повторов сложения и умножения, которые выполняются в ДПФ (повторяющиеся множители: <math>e^{\frac{-2kpi\pi}{n}}</math> Например при условии, что <math>(pk)mod(n)=const</math>, при всех <math>k=\overline{0,n-1}</math> и <math>p=\overline{0,n-1}</math>

Напомним формулу ДПФ:

<math> y_{p}=\sum_{k=0}^{n-1}x_{k}e^{\frac{-2kpi\pi}{n}}, p=\overline{0,n-1}</math>

За счет использования данного факта, происходит значительное сокращение количества вычислительных операций. В данной статье используется алгоритм Cooley – Tukey, который предполагает собой разбиение исходного множества входных сигналов на два равных подмножества. При этом множество входных сигналов должно быть степенью двойки. Далее операция деления множества продолжается для образовавшихся подмножеств, и так далее. В результате над каждым из полученных подмножеств выполняется БПФ. Данные вычисления можно выполнять независимо друг от друга. Этот факт используется для реализации параллельной версии алгоритма. В общем алгоритм Cooley – Tukey строится из двух основных шагов:

* Преобразование входного массива данных (бит-реверсирование).
* Вычисление БПФ.
Приведем более детальное описание БПФ (математическое описание):
*Пусть <math>e^{\frac{-2kpi\pi}{n}}</math> = <math>\omega _{n}^{kp}</math>.
*Разобьем исходный сигнал <math>x(n)</math> на два подмножества, с четными <math>x_{1}(2n)</math> и нечетными <math>x_{2}(2n+1)</math> номерами.
Тогда получаем: <math>y_{p}=\sum_{k=0}^{n-1}x_{k}\omega _{n}^{kp}= \sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega _{n}^{2kp}+\sum_{k=0}^{\frac{n}{2}-1}x_{2k+1}\omega _{n}^{(2k+1)p}</math>.

Выпишем два свойства омеги:
*<math>\omega_{\frac{n}{2}}=e^{2(\frac{-2i\pi}{n})}=\omega_{n}^{2}</math>
*<math>\omega_{n}^{\frac{n}{2}}=e^{\frac{-2ni\pi}{2n}}=e^{-i\pi}=-1</math>
Воспользуемся первым: <math>y_{p}= \sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega _{n}^{2kp}+\omega_{n}^{p}\sum_{k=0}^{\frac{n}{2}-1}x_{2k+1}\omega _{n}^{2kp}=\sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega _{\frac{n}{2}}^{kp}+\omega_{n}^{p}\sum_{k=0}^{\frac{n}{2}-1}x_{2k+1}\omega _{\frac{n}{2}}^{kp}</math>. Или, если обозначить <math>y_{1}(p)=\sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega _{\frac{n}{2}}^{kp}</math>, а <math>y_{2}(p)=\sum_{k=0}^{\frac{n}{2}-1}x_{2k+1}\omega _{\frac{n}{2}}^{kp}</math>, то получим формулу для вычисления координат изображения БПФ при <math>p=\overline{0...n/2}</math>: <math>y_(p)=y_{1}(p)+\omega_{n}^{p}y_{2}(p)</math>.

Заметим, что <math>y(p); y_{1}(p); y_{2}(p)</math> обладают свойством периодичности, с периодом <math>\frac{n}{2}</math>. Покажем это для <math>y_{1}(p)</math> : <math>y_{1}(p+\frac{n}{2})=\sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega_{\frac{n}{2}}^{k(p+\frac{n}{2})}=\sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega_{\frac{n}{2}}^{kp}\omega_{\frac{n}{2}}^{\frac{kn}{2}}=\sum_{k=0}^{\frac{n}{2}-1}x_{2k}\omega_{\frac{n}{2}}^{kp}</math>

Так как: <math>\omega_{\frac{n}{2}}^{\frac{kn}{2}}=e^{\frac{-4kni\pi}{2n}}=e^{-2ki\pi}=1</math>

Далее необходимо определить <math>y(p)</math> при <math>p\geq \frac{n}{2}</math>. Теперь воспользуемся свойством периодичности обнаруженными нами ранее: <math>y(p+\frac{n}{2})=y_{1}(p+\frac{n}{2})+\omega_{n}^{(p+\frac{n}{2})}y_{2}(p+\frac{n}{2})</math>. Воспользуемся вторым свойством омеги: <math>y(p)=y_{1}(p)-\omega_{n}^{p}y_{2}(p)</math>.

В конечном итоге мы пришли к конечной формуле для первого этапа вычисления БПФ. Дальнейшие этапы делят подмножества полученные на предыдущим этапе вычисления БПФ.

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

'''Бит-реверсирование'''

Бит-реверсирование – это преобразование двоичного числа путем изменения порядка следования бит в нем на противоположный. Бит-реверсирование применимо только к индексам элементов массива и предназначено для изменения порядка следования этих элементов, при этом значения самих элементов не изменяются. Так, к примеру, четырехмерный вектор <math>(x_{0},x_{1},x_{2},x_{3})</math> изменится на <math>(x_{0},x_{2},x_{1},x_{3})</math>. Данная процедура необходима для разделения исходного сигнала на элементы подмножеств с четными и нечетными номерами, которые необходимы для вычисления <math>y_{1}(p)</math> и <math>y_{2}(p)</math>.

'''Вычисление БПФ'''

После выполнения этапа бит-реверсирования выполняются вычисления проиллюстрированные ''на рисунке 2'' в разделе [[#Информационный граф|Информационный граф]]. Рисунок 2 приведен для случая четырехмерного входного сигнала. Он предполагает совершение двух этапов. В общем же количество этапов равно <math>log_{2}n</math>. Каждый этап содержит в себе вычисление одной и той же операции "бабочки". Где на вход подаются два числа <math>a</math> и <math>b</math>, на выходе же получаются <math>a+bU</math> и <math>a-bU</math>. Где <math>U</math>- это ''коэффициент поворота''. Общая формула для коэффициента поворота: <math>e^{\frac{-ji\pi}{k}}</math>. Где <math>k</math>- размер шага "бабочки", <math>j</math>- номер итерации вычислений над группой элементов, размером <math>2k</math> <math>(0\leq j < k )</math>.

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

Из двух вышеописанных этапов БПФ, бит-реверсирование является самым быстровыполнимым. Поэтому вычислительное ядро алгоритма будет лежать именно во втором этапе. А именно, им будет являться вычисление "бабочек". Количество этапов выполнения БПФ, как описывалось выше, равно <math>log_{2}n</math>. Учитывая количество этапов, размерность входного сигнала и идею деления на подмножества, всего "бабочек" получается <math>\frac{nlog_{2}n}{2}</math>. При этом операция умножения выполняется <math>\frac{n}{2}</math> раз. Это связано с тем, что результаты вычисления "бабочки" <math>a+bU</math> и <math>a-bU</math>.

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

Из всего вышесказанного заключаем, что макроструктуру алгоритма легче всего описать при помощи рекурсии:
*<math>\frac{n}{2}</math> преобразований Фурье порядка 2
*умножение <math>\frac{n}{2}</math> пар комплексных чисел
*<math>n</math> комплексных сложений
*снова преобразование Фурье

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

Программный код (описан на языке С++) строится из ряда функций:
*бит-реверсирование
*инициализация размерности входного сигнала
*инициализация входного сигнала (при помощи генератора случайных чисел)
*процесс очистки памяти
*выполнение операции "бабочка"
*выполнение БПФ
*функция вывода результата (для тестирования)
----
'''главный программный код БПФ:'''
<source lang="С++">
int main()
{
complex<double> *inputSignal = NULL;
complex<double> *outputSignal = NULL;
int size = 0;
cout << "FFT. Serial version." << endl;
ProcessInitialization(inputSignal, outputSignal, size);
bit(inputSignal, outputSignal, size);
SerialFFTCalculation(outputSignal, size);
PrintSignal(outputSignal, size); //в случае тестирования
ProcessTermination(inputSignal, outputSignal);
cin.get();
}
</source>
----
=== функция бит-реверсирования ===
<source lang="С++">
void bit(complex<double> inputSignal[], complex<double> *outputSignal, int size)
{ // процесс бит-реверсирования
int j = 0, i = 0;
while (i < size)
{
if (j > i)
{
outputSignal[i] = inputSignal[j];
outputSignal[j] = inputSignal[i];
}
else
if (j == i)
outputSignal[i] = inputSignal[i];

int m = size >> 1;
while ((m >= 1) && (j >= m))
{
j -= m;
m = m >> 1;
}
j += m;
i++;
}
}
</source>
=== инициализация размерности входного сигнала ===
<source lang="С++">
void ProcessInitialization(complex<double>* &inputSignal, complex<double>* &outputSignal, int &size)
{
// инициализация размера входного сигнала
do
{
cout << "Enter the input signal length: ";
cin >> size;
if (size < 4)
cout << "Input signal length should be >= 4" << endl;
else
{
int tmpSize = size;
while (tmpSize != 1)
{
if (tmpSize % 2 != 0)
{
cout << "Input signal length should be powers of two" << endl;
size = -1;
break;
}
tmpSize /= 2;
}
}
}
while (size < 4);
cout << "Input signal length = " << size << endl;
inputSignal = new complex<double>[size];
outputSignal = new complex<double>[size];
DummyDataInitialization(inputSignal, size);
}
</source>
=== инициализация входного сигнала ===
<source lang="С++">
void DummyDataInitialization(complex<double>* mas, int size)
{
for (int i = 0; i < size; i++)
{
mas[i] = int(rand() % 100);
}
}
</source>
=== процесс очистки памяти ===
<source lang="С++">
void ProcessTermination(complex<double>* &inputSignal, complex<double>* &outputSignal)
{
//очистка памяти
delete[] inputSignal;
inputSignal = NULL;
delete[] outputSignal;
outputSignal = NULL;
}
</source>
=== выполнение операции "бабочка" ===
<source lang="С++">
void Butterfly(complex<double> *signal, complex<double> &u,int offset, int butterflySize)
{
complex<double> tem = signal[offset + butterflySize] * u;
signal[offset + butterflySize] = signal[offset] - tem;
signal[offset] += tem;
}
</source>
=== выполнение БПФ ===
<source lang="С++">
void SerialFFTCalculation(complex<double> *signal, int size)
{
int m = 0;
for (int tmp_size = size; tmp_size > 1; tmp_size /= 2, m++);
for (int p = 0; p < m; p++)
{
int butterflyOffset = 1 << (p + 1);
int butterflySize = butterflyOffset >> 1;
double coeff = M_PI / butterflySize;

for (int i = 0; i < size / butterflyOffset; i++)
for (int j = 0; j < butterflySize; j++)
Butterfly(signal,complex<double>(cos(-j*coeff),sin(-j*coeff)),j+i*butterflyOffset,butterflySize);
}
}
</source>
=== функция вывода результата (для тестирования) ===
<source lang="С++">
void PrintSignal(complex<double> *signal, int size)
{
cout << "Result signal" << endl;
for (int i = 0; i < size; i++)
cout << signal[i] << endl;
}
</source>
== Последовательная сложность алгоритма ==
Рассмотренный алгоритм Cooley – Tukey выполняется за <math>nlog_{2}n</math> операций комплексного сложения и <math>\frac{n}{2}log_{2}n</math> операций комплексного умножения. Таким образом последовательная сложность алгоритма является '''линейно-логарифмической'''.
== Информационный граф ==
[[file:Граф.jpg|center|thumb|800px|Рисунок 1. Алгоритм Cooley – Tukey для n=4, при предварительно сделанном бит-реверсировании]]
== Ресурс параллелизма алгоритма ==
[[file:Парал.jpg|center|thumb|800px|Рисунок 2. Распараллеливание алгоритма Cooley – Tukey для n=8]]
Рисунок 2 получен из информационного графа, главной идеей которого является процедура деления множеств полученных на предыдущем шаге на два равных по мощности подмножества и применение к ним БПФ. То есть процесс вычисления распределяется между <math>\frac{n}{2}</math> процессорами. И так как при последовательной реализации алгоритма было <math>\frac{n}{2}\log_{2}n</math> операций комплексного умножения и <math>n\log_{2}n</math> комплексного сложения/вычитания. Получается, что при параллельной реализации алгоритма мы будем иметь <math>\log_{2}n</math> операций комплексного умножения и <math>2\log_{2}n</math> комплексного сложения/вычитания. При этом, если используется функция HT(Hyper threading), то параллельная сложность быстрого преобразования Фурье (базовый алгоритм Кули-Тьюки) для векторов с длиной, равной степени двойки составляет <math>\log_{2}n</math>.
== Входные и выходные данные алгоритма ==
*'''Вещественное ДФП'''
**входные данные:
***вектор <math>\overline{a}=(a_{1},a_{2},...,a_{N})</math>, где <math>a_{i}\in \mathbb{R}</math>
***размерность: <math>N</math> точек
**выходные данные:
***вектор <math>\overline{b}=(b_{1},b_{2},...,b_{N})</math>, где <math>b_{i}\in \mathbb{C}</math>
***размерность: <math>2N</math> точек
*'''Комплексное ДФП'''
**входные данные:
***вектор <math>\overline{a}=(a_{1},a_{2},...,a_{N})</math>, где <math>a_{i}\in \mathbb{C}</math>
***размерность: <math>2N</math> точек
**выходные данные:
***вектор <math>\overline{b}=(b_{1},b_{2},...,b_{N})</math>, где <math>b_{i}\in \mathbb{C}</math>
***размерность: <math>2N</math> точек
== Свойства алгоритма ==
*Соотношение последовательной и параллельной сложности является ''линейным''. Это хорошо видно из пункта [[#Ресурс параллелизма алгоритма|ресурс параллелизма алгоритма]].
*Вычислительная мощность алгоритма является ''логарифмической''.
*Устойчивость.
**Рассмотрим вопрос об устойчивости поближе. Так как БПФ отличается от ДПФ простым лишь сокращением одинаковых операций, то вопрос устойчивости можно рассматривать на примере ДПФ. Так, к примеру, возьмем формулу ДПФ и добавим возмущение: <math> y_{p}=\sum_{k=0}^{n-1}(x_{k}+\varepsilon )e^{\frac{-2*\pi*k*p*i}{n}}, p=\overline{0,n-1}</math>. После чего преобразуем ее: <math>y_{p}=\sum_{k=0}^{n-1}x_{k}e^{\frac{-2*\pi*k*p*i}{n}}+\varepsilon\sum_{k=0}^{n-1} e^{\frac{-2*\pi*k*p*i}{n}}</math> и оценим вторую сумму, которая является геометрической прогрессией со знаменателем <math>q=e^{\frac{-2*\pi*p*i}{n}}</math>. Таким образом оцениваемая сумма будет равняться: <math>\varepsilon\frac{1-e^{\frac{-2*\pi*p*i*(n-1))}{n}}}{1-e^{\frac{-2*\pi*p*i}{n}}}</math>. При достаточно больших размерностях входного сигнала данное выражение сводится к: <math>\varepsilon (1-e^{-2*\pi*p*i})</math>. В тригонометрической форме данного выражения: <math>\varepsilon (cos(\frac{2*\pi*p*(n-1)}{n})-i*sin(\frac{2*\pi*p*(n-1)}{n}))</math> видно, что принимая во внимание целочисленность индексов <math>p</math> получается 0. Таким образом, мы можем говорить об устойчивости алгоритма в целом, и абсолютной устойчивости алгоритма в асимптотике.
*исходя из информационного графа, можно сделать вывод о сбалансированности алгоритма.
*алгоритм полностью детерминирован.
*Степень исхода вершины информационного графа не превышает двух.
= ЧАСТЬ. Программная реализация алгоритма =
== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
[[file:масш.jpg|center|thumb|1000px|Рисунок 3. Параллельная реализация алгоритма. Изменение эффективности(%)в зависимости от числа процессоров и размера области.]]
Как описывалось выше, каждый процессор получает достаточно низкий объем работы, что приводит к неэффективному распараллеливанию алгоритма (высокие затраты на передачу данных между процессорами по сравнению с вычислениями на них). Поэтому необходимо находить оптимальное количество процессоров для каждой отдельно взятой задачи. В данном примере, при размерности входного сигнала менее 262144, оптимальное количество процессоров составляет 1. При размерности 262144-4194304 оптимум достигался при 8 процессорах. И при размерности более 4194304- 16 процессоров. Вычисления проводились на суперкомпьютере «Ломоносов».
== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Самой распространенной и известной реализацией дискретного БПФ является библиотека [http://www.fftw.org/ FFTW], разработанная Маттео Фриго и Стивеном Г. Джонсоном в Массачусетском технологическом институте. Данная библиотека существует для языков C и FORTRAN и позволяет производить вычисления в одном или нескольких измерениях. Входной сигнал может быть как действительным так и комплексным, а его размерность не обязательно должна быть степенью двойки. На данный момент последняя версия FFTW 3.3.5. Другие особенности библиотеки:
*Скорость. (Поддержка SSE / SSE2 / Altivec, начиная с версии 3.0. Версия 3.3.1 поддерживает AVX и ARM Neon.)
*Параллельные вычисления (OpenMP, MPI).
*[http://www.fftw.org/fftw3_doc/ Документация] в форматах HTML, PDF.
*Данное программное обеспечение является свободным и распространяется по лицензии GNU (General Public License).
Здесь приводится пример реализации прямого БПФ для комплексных данных входного сигнала на языке C++.
<source lang="С++">
#include <fftw3-mpi.h>
# include <stdlib.h>
# include <stdio.h>
#include <sys/stat.h>
#include <fcntl.h>
# include <time.h>
#include <math.h>

int main(int argc, char **argv)
{
const ptrdiff_t N0 = 4194304;
fftw_plan planForw;
fftw_complex *data, *dataOut;
ptrdiff_t alloc_local, local_ni, local_i_start, i, j, local_no, local_o_start;
int index, size;
double startwtime, endwtime;
MPI_Init(&argc, &argv);
fftw_mpi_init();
MPI_Comm_rank(MPI_COMM_WORLD, &index);
MPI_Comm_size(MPI_COMM_WORLD, &size);

/* get local data size and allocate */
alloc_local = fftw_mpi_local_size_1d(N0, MPI_COMM_WORLD, FFTW_FORWARD, FFTW_ESTIMATE,
&local_ni, &local_i_start, &local_no, &local_o_start);
data = fftw_alloc_complex(alloc_local);
dataOut = fftw_alloc_complex(alloc_local);
/* create plan */
planForw = fftw_mpi_plan_dft_1d(N0, data, dataOut, MPI_COMM_WORLD,
FFTW_FORWARD, FFTW_ESTIMATE);
/* initialize data to some function my_function(x,y) */
for (i = 0; i < local_ni; ++i)
{
data[i][0] = rand() / (double)RAND_MAX;
data[i][1] = rand() / (double)RAND_MAX;
}
if (index == 0){
startwtime = MPI_Wtime();

}

fftw_execute(planForw);
if (index == 0){
endwtime = MPI_Wtime();
printf("wall clock time = %f\n",
endwtime - startwtime);

}

fftw_destroy_plan(planForw);
MPI_Finalize();
}
</source>
[http://www.fftw.org/download.html Скачав] библиотеку и установив ее на рабочий компьютер, можно поэкспериментировать, используя вышеописанный исходный код. При этом, на стадии компиляции необходимо указывать директорию, где находятся заголовочные файлы и директорию, где находятся библиотечные файлы. Пример: mpicxx name.cpp -I/path/to/include/files -L/path/to/lib/files -lfftw3_mpi -lfftw3 -lm. Для версии 2.1.4 описание на русском языке приводится [https://parallel.ru/cluster/fftw.html здесь].

Остальные реализации:
*[http://www.gnu.org/software/gsl/ GSL - GNU Scientific Library]
*[https://developer.nvidia.com/cufft cuFFT]
*[http://www-03.ibm.com/systems/power/software/essl/ Engineering and Scientific Subroutine Library (ESSL) and Parallel ESSL]
=Литература=
[1] Бахвалов Н. С., Жидков Н. П., Кобельков. Г. М. — 6-е изд. — М. : БИНОМ. Лаборатория знаний

[2] Г. Нуссбаумер. Быстрое преобразование Фурье и алгоритмы вычисления сверток

[3] А.О. Лапаев Параллельное вычисление дискретного преобразования Фурье полинома в простом поле