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

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

2016-11-15T19:22:38Z

Pumpkin: /* Общее описание алгоритма */

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

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

Масштабируемость алгоритма проверялась с помощью тестовой программы расположенной по [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)

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

2016-11-15T19:21:46Z

Pumpkin: /* Последовательная сложность алгоритма */

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

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

Масштабируемость алгоритма проверялась с помощью тестовой программы расположенной по [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)

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

2016-11-15T19:18:40Z

Pumpkin: /* Рекурсивное описание */

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

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

Масштабируемость алгоритма проверялась с помощью тестовой программы расположенной по [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)

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

2016-11-15T19:12:32Z

Pumpkin: /* Общее описание алгоритма */

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

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

2016-11-15T19:11:09Z

Pumpkin: /* Общее описание алгоритма */

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

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

2016-11-15T19:03:50Z

Pumpkin: /* Математическое описание алгоритма */

{{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]
= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==
'''Быстрое дискретное преобразование Фурье''' (''БПФ'') - популярный в современном мире математический метод преобразования вектора/матрицы комплексных/действительных чисел - ''сигнала'' - в вектор/матрицу комплексных чисел - ''спектр''. Область применения данного метода простирается от обработки аудио информации до собственно спектрального анализа.
Поскольку в общем случае алгоритм БПФ применим к произвольным векторам чисел, выделяют отдельные подзадачи, для которых можно ввести дополнительную оптимизацию. Одной из таких подзадач является быстрое '''преобразование Фурье вектора действительных чисел''', которому и посвящена данная статья. В качестве тестируемой реализации был выбран '''алгоритм Кули-Тьюки''' в библиотеке 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> 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)

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

2016-10-30T13:10:36Z

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

{{Assignment}}
{{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]
= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==
'''Быстрое дискретное преобразование Фурье''' (''БПФ'') - популярный в современном мире математический метод преобразования вектора/матрицы комплексных/действительных чисел ('''''сигнала''''') в вектор/матрицу комплексных чисел, т.н. '''''спектр'''''. Область применения данного метода простирается от обработки аудио информации до собственно спектрального анализа.
Поскольку в общем случае алгоритм БПФ применим к произвольным векторам чисел, выделяют отдельные подзадачи, для которых можно ввести ''дополнительную оптимизацию''. Одной из таких подзадач является быстрое преобразование Фурье вектора '''''действительных''''' чисел, которому и посвящена данная статья. В качестве тестируемой реализации был выбран '''алгоритм Кули-Тьюки''' в библиотеке '''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> 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)

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

2016-10-30T12:06:50Z

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

{{Assignment}}
{{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]
= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==
'''Быстрое дискретное преобразование Фурье''' (''БПФ'') - популярный в современном мире математический метод преобразования вектора/матрицы комплексных/действительных чисел ('''''сигнала''''') в вектор/матрицу комплексных чисел, т.н. '''''спектр'''''. Область применения данного метода простирается от обработки аудио информации до собственно спектрального анализа.
Поскольку в общем случае алгоритм БПФ применим к произвольным векторам чисел, выделяют отдельные подзадачи, для которых можно ввести ''дополнительную оптимизацию''. Одной из таких подзадач является быстрое преобразование Фурье вектора '''''действительных''''' чисел, которому и посвящена данная статья. В качестве тестируемой реализации был выбран '''алгоритм Кули-Тьюки''' в библиотеке '''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> 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^{10}</math> до <math>2^{29}</math>. При этом использовались от 8 до 128 процессоров с шагом степени двойки.
[[File:Parallel good crop 2.png |center|thumb|800px| Параллельная реализация библиотеки FFTW для преобразования вектора действительный чисел. Изменение времени работы алгоритма в зависимости от числа процессоров и размера входного вектора. По оси Data Size указано <math>N</math>. На данном графике показано время работы алгоритма без учета пересылок данных.]]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [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)

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

2016-10-30T12:02:42Z

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

{{Assignment}}
{{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]
= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==
'''Быстрое дискретное преобразование Фурье''' (''БПФ'') - популярный в современном мире математический метод преобразования вектора/матрицы комплексных/действительных чисел ('''''сигнала''''') в вектор/матрицу комплексных чисел, т.н. '''''спектр'''''. Область применения данного метода простирается от обработки аудио информации до собственно спектрального анализа.
Поскольку в общем случае алгоритм БПФ применим к произвольным векторам чисел, выделяют отдельные подзадачи, для которых можно ввести ''дополнительную оптимизацию''. Одной из таких подзадач является быстрое преобразование Фурье вектора '''''действительных''''' чисел, которому и посвящена данная статья. В качестве тестируемой реализации был выбран '''алгоритм Кули-Тьюки''' в библиотеке '''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> 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^{10}</math> до <math>2^{24}</math>. При этом использовались от 8 до 128 процессоров с шагом степени двойки.
[[File:Parallel good crop 2.png |center|thumb|800px| Параллельная реализация алгоритма Кули-Тьюки для преобразования вектора действительный чисел. Изменение времени работы алгоритма в зависимости от числа процессоров и размера входного вектора. По оси Data Size указано <math>N</math>. На данном графике показано время работы алгоритма без учета пересылок данных.]]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [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)

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

2016-10-29T19:45:18Z

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

{{Assignment}}
{{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]
= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==
'''Быстрое дискретное преобразование Фурье''' (''БПФ'') - популярный в современном мире математический метод преобразования вектора/матрицы комплексных/действительных чисел ('''''сигнала''''') в вектор/матрицу комплексных чисел, т.н. '''''спектр'''''. Область применения данного метода простирается от обработки аудио информации до собственно спектрального анализа.
Поскольку в общем случае алгоритм БПФ применим к произвольным векторам чисел, выделяют отдельные подзадачи, для которых можно ввести ''дополнительную оптимизацию''. Одной из таких подзадач является быстрое преобразование Фурье вектора '''''действительных''''' чисел, которому и посвящена данная статья. В качестве тестируемой реализации был выбран '''алгоритм Кули-Тьюки''' в библиотеке '''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> 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^{10}</math> до <math>2^{24}</math>. При этом использовались от 8 до 128 процессоров с шагом степени двойки.
[[File:Parallel good crop 2.png |center|thumb|800px| Параллельная реализация алгоритма Кули-Тьюки для преобразования вектора действительный чисел. Изменение времени работы алгоритма в зависимости от числа процессоров и размера входного вектора. По оси Data Size указано <math>N</math>, размер входного вектора <math>2^N</math>]]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [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)

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

2016-10-29T19:44:57Z

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

{{Assignment}}
{{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]
= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==
'''Быстрое дискретное преобразование Фурье''' (''БПФ'') - популярный в современном мире математический метод преобразования вектора/матрицы комплексных/действительных чисел ('''''сигнала''''') в вектор/матрицу комплексных чисел, т.н. '''''спектр'''''. Область применения данного метода простирается от обработки аудио информации до собственно спектрального анализа.
Поскольку в общем случае алгоритм БПФ применим к произвольным векторам чисел, выделяют отдельные подзадачи, для которых можно ввести ''дополнительную оптимизацию''. Одной из таких подзадач является быстрое преобразование Фурье вектора '''''действительных''''' чисел, которому и посвящена данная статья. В качестве тестируемой реализации был выбран '''алгоритм Кули-Тьюки''' в библиотеке '''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> 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^10</math> до <math>2^24</math>. При этом использовались от 8 до 128 процессоров с шагом степени двойки.
[[File:Parallel good crop 2.png |center|thumb|800px| Параллельная реализация алгоритма Кули-Тьюки для преобразования вектора действительный чисел. Изменение времени работы алгоритма в зависимости от числа процессоров и размера входного вектора. По оси Data Size указано <math>N</math>, размер входного вектора <math>2^N</math>]]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [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)

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

2016-10-29T15:27:14Z

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

{{Assignment}}
{{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]
= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==
'''Быстрое дискретное преобразование Фурье''' (''БПФ'') - популярный в современном мире математический метод преобразования вектора/матрицы комплексных/действительных чисел ('''''сигнала''''') в вектор/матрицу комплексных чисел, т.н. '''''спектр'''''. Область применения данного метода простирается от обработки аудио информации до собственно спектрального анализа.
Поскольку в общем случае алгоритм БПФ применим к произвольным векторам чисел, выделяют отдельные подзадачи, для которых можно ввести ''дополнительную оптимизацию''. Одной из таких подзадач является быстрое преобразование Фурье вектора '''''действительных''''' чисел, которому и посвящена данная статья. В качестве тестируемой реализации был выбран '''алгоритм Кули-Тьюки''' в библиотеке '''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> 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 ссылке]. Проводились замеры времени работы алгоритма, а также эффективности.

[[File:Parallel good crop.png |center|thumb|800px| Описание...]]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [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)

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

2016-10-29T15:23:21Z

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

{{Assignment}}
{{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]
= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==
'''Быстрое дискретное преобразование Фурье''' (''БПФ'') - популярный в современном мире математический метод преобразования вектора/матрицы комплексных/действительных чисел ('''''сигнала''''') в вектор/матрицу комплексных чисел, т.н. '''''спектр'''''. Область применения данного метода простирается от обработки аудио информации до собственно спектрального анализа.
Поскольку в общем случае алгоритм БПФ применим к произвольным векторам чисел, выделяют отдельные подзадачи, для которых можно ввести ''дополнительную оптимизацию''. Одной из таких подзадач является быстрое преобразование Фурье вектора '''''действительных''''' чисел, которому и посвящена данная статья. В качестве тестируемой реализации был выбран '''алгоритм Кули-Тьюки''' в библиотеке '''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> 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 ссылке]. Проводились замеры времени работы алгоритма, а также эффективности.

[[File:Parallel good crop.png |center|thumb|800px|]]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [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)

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

2016-10-29T15:22:16Z

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

{{Assignment}}
{{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]
= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==
'''Быстрое дискретное преобразование Фурье''' (''БПФ'') - популярный в современном мире математический метод преобразования вектора/матрицы комплексных/действительных чисел ('''''сигнала''''') в вектор/матрицу комплексных чисел, т.н. '''''спектр'''''. Область применения данного метода простирается от обработки аудио информации до собственно спектрального анализа.
Поскольку в общем случае алгоритм БПФ применим к произвольным векторам чисел, выделяют отдельные подзадачи, для которых можно ввести ''дополнительную оптимизацию''. Одной из таких подзадач является быстрое преобразование Фурье вектора '''''действительных''''' чисел, которому и посвящена данная статья. В качестве тестируемой реализации был выбран '''алгоритм Кули-Тьюки''' в библиотеке '''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> 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 ссылке]. Проводились замеры времени работы алгоритма, а также эффективности.

[[Файл:Parallel good.png |center|thumb|800px|]]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [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)

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

2016-10-29T15:19:32Z

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

{{Assignment}}
{{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]
= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==
'''Быстрое дискретное преобразование Фурье''' (''БПФ'') - популярный в современном мире математический метод преобразования вектора/матрицы комплексных/действительных чисел ('''''сигнала''''') в вектор/матрицу комплексных чисел, т.н. '''''спектр'''''. Область применения данного метода простирается от обработки аудио информации до собственно спектрального анализа.
Поскольку в общем случае алгоритм БПФ применим к произвольным векторам чисел, выделяют отдельные подзадачи, для которых можно ввести ''дополнительную оптимизацию''. Одной из таких подзадач является быстрое преобразование Фурье вектора '''''действительных''''' чисел, которому и посвящена данная статья. В качестве тестируемой реализации был выбран '''алгоритм Кули-Тьюки''' в библиотеке '''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> 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 ссылке]. Проводились замеры времени работы алгоритма, а также эффективности.

[[Файл:Parallel good.png | 1000px]]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [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)

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

2016-10-29T15:18:54Z

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

{{Assignment}}
{{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]
= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==
'''Быстрое дискретное преобразование Фурье''' (''БПФ'') - популярный в современном мире математический метод преобразования вектора/матрицы комплексных/действительных чисел ('''''сигнала''''') в вектор/матрицу комплексных чисел, т.н. '''''спектр'''''. Область применения данного метода простирается от обработки аудио информации до собственно спектрального анализа.
Поскольку в общем случае алгоритм БПФ применим к произвольным векторам чисел, выделяют отдельные подзадачи, для которых можно ввести ''дополнительную оптимизацию''. Одной из таких подзадач является быстрое преобразование Фурье вектора '''''действительных''''' чисел, которому и посвящена данная статья. В качестве тестируемой реализации был выбран '''алгоритм Кули-Тьюки''' в библиотеке '''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> 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 ссылке]. Проводились замеры времени работы алгоритма, а также эффективности.

[Файл:Parallel good.png]

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [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)

Файл:Parallel good.png

2016-10-29T15:17:48Z

Pumpkin:

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

2016-10-26T08:57:42Z

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

{{Assignment}}
{{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]
= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==
'''Быстрое дискретное преобразование Фурье''' (''БПФ'') - популярный в современном мире математический метод преобразования вектора/матрицы комплексных/действительных чисел ('''''сигнала''''') в вектор/матрицу комплексных чисел, т.н. '''''спектр'''''. Область применения данного метода простирается от обработки аудио информации до собственно спектрального анализа.
Поскольку в общем случае алгоритм БПФ применим к произвольным векторам чисел, выделяют отдельные подзадачи, для которых можно ввести ''дополнительную оптимизацию''. Одной из таких подзадач является быстрое преобразование Фурье вектора '''''действительных''''' чисел, которому и посвящена данная статья. В качестве тестируемой реализации был выбран '''алгоритм Кули-Тьюки''' в библиотеке '''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> 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 ссылке]. Проводились замеры времени работы алгоритма, а также эффективности.
''
'''Замечание:''''' Согласно постановке первого домашнего задание по курсу Суперкомпьютерное моделирование и технологии ([http://parallel.ru/ss16]) срок сдачи данного пункта отложен до 1'''5 ноября 2016 года'''

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [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)

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

2016-10-26T08:57:08Z

Pumpkin: /* Отсутствующие части */

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

=== Неправильная структура статьи ===
* привести в соответствие 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)
** Исправлено

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

2016-10-26T08:56:29Z

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

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

=== Неправильная структура статьи ===
* привести в соответствие 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)
** Исправлено

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

2016-10-26T08:54:23Z

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

{{Assignment}}
{{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]
= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==
'''Быстрое дискретное преобразование Фурье''' (''БПФ'') - популярный в современном мире математический метод преобразования вектора/матрицы комплексных/действительных чисел ('''''сигнала''''') в вектор/матрицу комплексных чисел, т.н. '''''спектр'''''. Область применения данного метода простирается от обработки аудио информации до собственно спектрального анализа.
Поскольку в общем случае алгоритм БПФ применим к произвольным векторам чисел, выделяют отдельные подзадачи, для которых можно ввести ''дополнительную оптимизацию''. Одной из таких подзадач является быстрое преобразование Фурье вектора '''''действительных''''' чисел, которому и посвящена данная статья. В качестве тестируемой реализации был выбран '''алгоритм Кули-Тьюки''' в библиотеке '''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> 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 ссылке]. Проводились замеры времени работы алгоритма, а также эффективности.
''
'''Замечание:''''' Согласно постановки первого домашнего задание по курсу Суперкомпьютерное моделирование и технологии ([http://parallel.ru/ss16]) срок сдачи данного пункта отложен до 1'''5 ноября 2016 года'''

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [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)

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

2016-10-26T08:53:55Z

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

{{Assignment}}
{{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]
= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==
'''Быстрое дискретное преобразование Фурье''' (''БПФ'') - популярный в современном мире математический метод преобразования вектора/матрицы комплексных/действительных чисел ('''''сигнала''''') в вектор/матрицу комплексных чисел, т.н. '''''спектр'''''. Область применения данного метода простирается от обработки аудио информации до собственно спектрального анализа.
Поскольку в общем случае алгоритм БПФ применим к произвольным векторам чисел, выделяют отдельные подзадачи, для которых можно ввести ''дополнительную оптимизацию''. Одной из таких подзадач является быстрое преобразование Фурье вектора '''''действительных''''' чисел, которому и посвящена данная статья. В качестве тестируемой реализации был выбран '''алгоритм Кули-Тьюки''' в библиотеке '''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> 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 ссылке]. Проводились замеры времени работы алгоритма, а также эффективности.
''
'''Замечание:''''' Согласно постановки первого домашнего задание по курсу Суперкомпьютерное моделирование и технологии ([http://parallel.ru/ss16]) срок сдачи данного пункта отложен до 1'''5 ноября 2016 года'''

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [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)

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

2016-10-26T08:49:47Z

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

{{Assignment}}
{{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]
= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==
'''Быстрое дискретное преобразование Фурье''' (''БПФ'') - популярный в современном мире математический метод преобразования вектора/матрицы комплексных/действительных чисел ('''''сигнала''''') в вектор/матрицу комплексных чисел, т.н. '''''спектр'''''. Область применения данного метода простирается от обработки аудио информации до собственно спектрального анализа.
Поскольку в общем случае алгоритм БПФ применим к произвольным векторам чисел, выделяют отдельные подзадачи, для которых можно ввести ''дополнительную оптимизацию''. Одной из таких подзадач является быстрое преобразование Фурье вектора '''''действительных''''' чисел, которому и посвящена данная статья. В качестве тестируемой реализации был выбран '''алгоритм Кули-Тьюки''' в библиотеке '''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> 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 ссылке]. Проводились замеры времени работы алгоритма, а также эффективности.
''
'''Замечание:''''' Согласно постановки первого домашнего задание по курсу Суперкомпьютерное моделирование и технологии ([http://parallel.ru/ss16]) срок сдачи данного пункта отложен до 1'''5 ноября 2016 года'''

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [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)

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

2016-10-26T08:48:40Z

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

{{Assignment}}
{{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]
= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==
'''Быстрое дискретное преобразование Фурье''' (''БПФ'') - популярный в современном мире математический метод преобразования вектора/матрицы комплексных/действительных чисел ('''''сигнала''''') в вектор/матрицу комплексных чисел, т.н. '''''спектр'''''. Область применения данного метода простирается от обработки аудио информации до собственно спектрального анализа.
Поскольку в общем случае алгоритм БПФ применим к произвольным векторам чисел, выделяют отдельные подзадачи, для которых можно ввести ''дополнительную оптимизацию''. Одной из таких подзадач является быстрое преобразование Фурье вектора '''''действительных''''' чисел, которому и посвящена данная статья. В качестве тестируемой реализации был выбран '''алгоритм Кули-Тьюки''' в библиотеке '''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> 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>Y = -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 ссылке]. Проводились замеры времени работы алгоритма, а также эффективности.
''
'''Замечание:''''' Согласно постановки первого домашнего задание по курсу Суперкомпьютерное моделирование и технологии ([http://parallel.ru/ss16]) срок сдачи данного пункта отложен до 1'''5 ноября 2016 года'''

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [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)

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

2016-10-26T08:47:59Z

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

{{Assignment}}
{{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]
= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==
'''Быстрое дискретное преобразование Фурье''' (''БПФ'') - популярный в современном мире математический метод преобразования вектора/матрицы комплексных/действительных чисел ('''''сигнала''''') в вектор/матрицу комплексных чисел, т.н. '''''спектр'''''. Область применения данного метода простирается от обработки аудио информации до собственно спектрального анализа.
Поскольку в общем случае алгоритм БПФ применим к произвольным векторам чисел, выделяют отдельные подзадачи, для которых можно ввести ''дополнительную оптимизацию''. Одной из таких подзадач является быстрое преобразование Фурье вектора '''''действительных''''' чисел, которому и посвящена данная статья. В качестве тестируемой реализации был выбран '''алгоритм Кули-Тьюки''' в библиотеке '''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> 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>Y = -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 ссылке]. Проводились замеры времени работы алгоритма, а также эффективности.
''
'''Замечание:''''' Согласно постановки первого домашнего задание по курсу Суперкомпьютерное моделирование и технологии ([http://parallel.ru/ss16]) срок сдачи данного пункта отложен до 1'''5 ноября 2016 года'''

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [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)

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

2016-10-26T08:47:25Z

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

{{Assignment}}
{{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]
= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==
'''Быстрое дискретное преобразование Фурье''' (''БПФ'') - популярный в современном мире математический метод преобразования вектора/матрицы комплексных/действительных чисел ('''''сигнала''''') в вектор/матрицу комплексных чисел, т.н. '''''спектр'''''. Область применения данного метода простирается от обработки аудио информации до собственно спектрального анализа.
Поскольку в общем случае алгоритм БПФ применим к произвольным векторам чисел, выделяют отдельные подзадачи, для которых можно ввести ''дополнительную оптимизацию''. Одной из таких подзадач является быстрое преобразование Фурье вектора '''''действительных''''' чисел, которому и посвящена данная статья. В качестве тестируемой реализации был выбран '''алгоритм Кули-Тьюки''' в библиотеке '''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> 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>Y = -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 ссылке]. Проводились замеры времени работы алгоритма, а также эффективности.
''
'''Замечание:''''' Согласно постановки первого домашнего задание по курсу Суперкомпьютерное моделирование и технологии ([http://parallel.ru/ss16]) срок сдачи данного пункта отложен до 1'''5 ноября 2016 года'''

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [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)

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

2016-10-26T08:46:31Z

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

{{Assignment}}
{{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]
= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==
'''Быстрое дискретное преобразование Фурье''' (''БПФ'') - популярный в современном мире математический метод преобразования вектора/матрицы комплексных/действительных чисел ('''''сигнала''''') в вектор/матрицу комплексных чисел, т.н. '''''спектр'''''. Область применения данного метода простирается от обработки аудио информации до собственно спектрального анализа.
Поскольку в общем случае алгоритм БПФ применим к произвольным векторам чисел, выделяют отдельные подзадачи, для которых можно ввести ''дополнительную оптимизацию''. Одной из таких подзадач является быстрое преобразование Фурье вектора '''''действительных''''' чисел, которому и посвящена данная статья. В качестве тестируемой реализации был выбран '''алгоритм Кули-Тьюки''' в библиотеке '''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> 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>Y = -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 ссылке]. Проводились замеры времени работы алгоритма, а также эффективности.
''
'''Замечание:''''' Согласно постановки первого домашнего задание по курсу Суперкомпьютерное моделирование и технологии ([http://parallel.ru/ss16]) срок сдачи данного пункта отложен до 1'''5 ноября 2016 года'''

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [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)

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

2016-10-26T08:35:36Z

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

{{Assignment}}
{{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]
= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==
'''Быстрое дискретное преобразование Фурье''' (''БПФ'') - популярный в современном мире математический метод преобразования вектора/матрицы комплексных/действительных чисел ('''''сигнала''''') в вектор/матрицу комплексных чисел, т.н. '''''спектр'''''. Область применения данного метода простирается от обработки аудио информации до собственно спектрального анализа.
Поскольку в общем случае алгоритм БПФ применим к произвольным векторам чисел, выделяют отдельные подзадачи, для которых можно ввести ''дополнительную оптимизацию''. Одной из таких подзадач является быстрое преобразование Фурье вектора '''''действительных''''' чисел, которому и посвящена данная статья. В качестве тестируемой реализации был выбран '''алгоритм Кули-Тьюки''' в библиотеке '''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> 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>Y = -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 & & 0 & 1 \\
0 & 0 & 0 & & 1 & 0 \\
0 & 0 & 0 & \cdots & 0 & 0 \\
0 & 0 & 1 & & 0 & 0 \\
0 & 1 & 0 & & 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 ссылке]. Проводились замеры времени работы алгоритма, а также эффективности.
''
'''Замечание:''''' Согласно постановки первого домашнего задание по курсу Суперкомпьютерное моделирование и технологии ([http://parallel.ru/ss16]) срок сдачи данного пункта отложен до 1'''5 ноября 2016 года'''

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [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)

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

2016-10-14T16:58:29Z

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

{{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.Сапин]]

'''Быстрое преобразование Фурье (БПФ, 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]
= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==
'''Быстрое дискретное преобразование Фурье''' (''БПФ'') - популярный в современном мире математический метод преобразования вектора/матрицы комплексных/действительных чисел ('''''сигнала''''') в вектор/матрицу комплексных чисел, т.н. '''''спектр'''''. Область применения данного метода простирается от обработки аудио информации до собственно спектрального анализа.
Поскольку в общем случае алгоритм БПФ применим к произвольным векторам чисел, выделяют отдельные подзадачи, для которых можно ввести ''дополнительную оптимизацию''. Одной из таких подзадач является быстрое преобразование Фурье вектора '''''действительных''''' чисел, которому и посвящена данная статья. В качестве тестируемой реализации был выбран '''алгоритм Кули-Тьюки''' в библиотеке '''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> 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>a = (a_1,a_2,...,a_N)</math>.

Выходные данные: вектор комплексных чисел <math>b = (b_1,b_2,...,b_{\lfloor N/2 \rfloor+1})</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 ссылке]. Проводились замеры времени работы алгоритма, а также эффективности.

== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [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]]

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

2016-10-12T20:15:34Z

Pumpkin: /* Математическое описание алгоритма */

{{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.Сапин]]

'''Быстрое преобразование Фурье (БПФ, 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]
= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==
'''Быстрое дискретное преобразование Фурье''' (''БПФ'') - популярный в современном мире математический метод преобразования вектора/матрицы комплексных/действительных чисел ('''''сигнала''''') в вектор/матрицу комплексных чисел, т.н. '''''спектр'''''. Область применения данного метода простирается от обработки аудио информации до собственно спектрального анализа.
Поскольку в общем случае алгоритм БПФ применим к произвольным векторам чисел, выделяют отдельные подзадачи, для которых можно ввести ''дополнительную оптимизацию''. Одной из таких подзадач является быстрое преобразование Фурье вектора '''''действительных''''' чисел, которому и посвящена данная статья. В качестве тестируемой реализации был выбран '''алгоритм Кули-Тьюки''' в библиотеке 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> 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>a = (a_1,a_2,...,a_N)</math>.

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

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

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

== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [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)

[[en:Fast Discrete Fourier Transform]]

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

2016-10-12T20:15:02Z

Pumpkin: /* Математическое описание алгоритма */

{{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.Сапин]]

'''Быстрое преобразование Фурье (БПФ, 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]
= ЧАСТЬ. Свойства и структура алгоритмов =

== Общее описание алгоритма ==
'''Быстрое дискретное преобразование Фурье''' (''БПФ'') - популярный в современном мире математический метод преобразования вектора/матрицы комплексных/действительных чисел ('''''сигнала''''') в вектор/матрицу комплексных чисел, т.н. '''''спектр'''''. Область применения данного метода простирается от обработки аудио информации до собственно спектрального анализа.
Поскольку в общем случае алгоритм БПФ применим к произвольным векторам чисел, выделяют отдельные подзадачи, для которых можно ввести ''дополнительную оптимизацию''. Одной из таких подзадач является быстрое преобразование Фурье вектора '''''действительных''''' чисел, которому и посвящена данная статья. В качестве тестируемой реализации был выбран '''алгоритм Кули-Тьюки''' в библиотеке 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_{\lfloor N/2 \rfloor+1})</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> 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>a = (a_1,a_2,...,a_N)</math>.

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

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

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

== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [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)

[[en:Fast Discrete Fourier Transform]]

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

2016-10-12T20:14:34Z

Pumpkin: /* Математическое описание алгоритма */

{{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.Сапин]]

'''Быстрое преобразование Фурье (БПФ, 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]
= ЧАСТЬ. Свойства и структура алгоритмов =

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

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

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

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

Выходные данные: вектор комплексных чисел <math>b = (X_1,X_2,...,X_{\lfloor N/2 \rfloor+1})</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> 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>a = (a_1,a_2,...,a_N)</math>.

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

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

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

== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [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)

[[en:Fast Discrete Fourier Transform]]

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

2016-10-12T20:09:19Z

Pumpkin:

{{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.Сапин]]

'''Быстрое преобразование Фурье (БПФ, 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]
= ЧАСТЬ. Свойства и структура алгоритмов =

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

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

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

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

<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_1,a_2,...,a_N)</math>.

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

== Рекурсивное описание ==
Алгоритм:
# Входной вектор <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> 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>a = (a_1,a_2,...,a_N)</math>.

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

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

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

== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [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)

[[en:Fast Discrete Fourier Transform]]

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

2016-10-12T20:04:45Z

Pumpkin: /* Математическое описание алгоритма */

{{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.Сапин]]

'''Быстрое преобразование Фурье (БПФ, 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]
= ЧАСТЬ. Свойства и структура алгоритмов =

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

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

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

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

<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_1,a_2,...,a_N)</math>.

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

== Рекурсивное описание ==
Алгоритм:
# Входной вектор <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> 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>a = (a_1,a_2,...,a_N)</math>.

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

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

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

== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [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)

[[en:Fast Discrete Fourier Transform]]

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

2016-10-12T19:45:07Z

Pumpkin: /* Математическое описание алгоритма */

{{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.Сапин]]

'''Быстрое преобразование Фурье (БПФ, 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]
= ЧАСТЬ. Свойства и структура алгоритмов =

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

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

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

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

<math>X_k = \sum_{n=0}^{N-1} x_n e^{-\frac{2\pi i}{N} nk}, k = \overline{0,N-1}</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 = (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> 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>a = (a_1,a_2,...,a_N)</math>.

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

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

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

== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [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)

[[en:Fast Discrete Fourier Transform]]

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

2016-10-11T20:54:02Z

Pumpkin: /* Последовательная сложность алгоритма */

{{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.Сапин]]

'''Быстрое преобразование Фурье (БПФ, 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]
= ЧАСТЬ. Свойства и структура алгоритмов =

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

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

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

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

'''''Замечание:''''' В простейшем случае '''алгоритм Кули-Тьюки''' применяется к векторам '''размерности степени двойки''', поэтому на практике вектора иной размерности часто '''дополнять''' до ближайшей степени двойки. Такой подход делает '''алгоритм Кули-Тьюки''' не самым эффективным алгоритмом БПФ, поскольку дополнение до степени двойки может сильно усложнить задачу.

== Рекурсивное описание ==
Алгоритм:
# Входной вектор <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> 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>.

== Информационный граф ==
[[Файл:Radix2.jpg |center|thumb|600px| Информационный граф для 16-ти точечного быстрого преобразования Фурье. ]]
Как видно из рисунка, размер этого графа линейно-логарифмический, а формулы дуг имеют экспоненциальные компоненты.

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

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

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

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

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

== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [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)

[[en:Fast Discrete Fourier Transform]]

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

2016-10-11T20:49:53Z

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

{{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.Сапин]]

'''Быстрое преобразование Фурье (БПФ, 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]
= ЧАСТЬ. Свойства и структура алгоритмов =

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

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

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

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

'''''Замечание:''''' В простейшем случае '''алгоритм Кули-Тьюки''' применяется к векторам '''размерности степени двойки''', поэтому на практике вектора иной размерности часто '''дополнять''' до ближайшей степени двойки. Такой подход делает '''алгоритм Кули-Тьюки''' не самым эффективным алгоритмом БПФ, поскольку дополнение до степени двойки может сильно усложнить задачу.

== Рекурсивное описание ==
Алгоритм:
# Входной вектор <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> 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} (\sum_{k=0}^{n_1-1}a_{kn_2+j}\varepsilon^{kin_2})</math>.
Выражения в скобках нам уже известны — это <math>(i\pmod 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>.

== Информационный граф ==
[[Файл:Radix2.jpg |center|thumb|600px| Информационный граф для 16-ти точечного быстрого преобразования Фурье. ]]
Как видно из рисунка, размер этого графа линейно-логарифмический, а формулы дуг имеют экспоненциальные компоненты.

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

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

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

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

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

== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [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)

[[en:Fast Discrete Fourier Transform]]

Участник:Pumpkin

2016-10-11T20:34:11Z

Pumpkin: Полностью удалено содержимое страницы

Участник:Pumpkin

2016-10-11T20:33:51Z

Pumpkin: Новая страница: «Сапин Александр Сергеевич.»

Сапин Александр Сергеевич.

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

2016-10-11T20:33:02Z

Pumpkin:

{{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.Сапин]]

'''Быстрое преобразование Фурье (БПФ, 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]
= ЧАСТЬ. Свойства и структура алгоритмов =

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

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

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

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

'''''Замечание:''''' В простейшем случае '''алгоритм Кули-Тьюки''' применяется к векторам '''размерности степени двойки''', поэтому на практике вектора иной размерности часто '''дополнять''' до ближайшей степени двойки. Такой подход делает '''алгоритм Кули-Тьюки''' не самым эффективным алгоритмом БПФ, поскольку дополнение до степени двойки может сильно усложнить задачу.

== Рекурсивное описание ==
Алгоритм:
# Входной вектор <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> 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} (\sum_{k=0}^{n_1-1}a_{kn_2+j}\varepsilon^{kin_2})</math>.
Выражения в скобках нам уже известны — это <math>(i\pmod 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>.

== Информационный граф ==
[[Файл:Graph fourier.png |center|thumb|600px| Информационный граф для БПФ где n1=6, n2=6. В левой части выполняется построчное преобразование входного массива, а в правой поколоночное методом перемножения матриц. ]]

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

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

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

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

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

== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [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)

[[en:Fast Discrete Fourier Transform]]

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

2016-10-11T20:27:23Z

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

{{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> комплексных чисел
}}
'''Быстрое преобразование Фурье (БПФ, 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]
= ЧАСТЬ. Свойства и структура алгоритмов =

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

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

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

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

'''''Замечание:''''' В простейшем случае '''алгоритм Кули-Тьюки''' применяется к векторам '''размерности степени двойки''', поэтому на практике вектора иной размерности часто '''дополнять''' до ближайшей степени двойки. Такой подход делает '''алгоритм Кули-Тьюки''' не самым эффективным алгоритмом БПФ, поскольку дополнение до степени двойки может сильно усложнить задачу.

== Рекурсивное описание ==
Алгоритм:
# Входной вектор <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> 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} (\sum_{k=0}^{n_1-1}a_{kn_2+j}\varepsilon^{kin_2})</math>.
Выражения в скобках нам уже известны — это <math>(i\pmod 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>.

== Информационный граф ==
[[Файл:Graph fourier.png |center|thumb|600px| Информационный граф для БПФ где n1=6, n2=6. В левой части выполняется построчное преобразование входного массива, а в правой поколоночное методом перемножения матриц. ]]

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

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

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

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

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

== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [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)

[[en:Fast Discrete Fourier Transform]]

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

2016-10-11T20:27:10Z

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

{{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> комплексных чисел
}}
'''Быстрое преобразование Фурье (БПФ, 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]
= ЧАСТЬ. Свойства и структура алгоритмов =

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

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

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

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

'''''Замечание:''''' В простейшем случае '''алгоритм Кули-Тьюки''' применяется к векторам '''размерности степени двойки''', поэтому на практике вектора иной размерности часто '''дополнять''' до ближайшей степени двойки. Такой подход делает '''алгоритм Кули-Тьюки''' не самым эффективным алгоритмом БПФ, поскольку дополнение до степени двойки может сильно усложнить задачу.

== Рекурсивное описание ==
Алгоритм:
# Входной вектор <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> 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} (\sum_{k=0}^{n_1-1}a_{kn_2+j}\varepsilon^{kin_2})</math>.
Выражения в скобках нам уже известны — это <math>(i\pmod 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>.

== Информационный граф ==
[[Файл:Graph fourier.png |center|thumb|600px| Информационный граф для БПФ где n1=6, n2=6. В левой части выполняется построчное преобразование входного массива, а в правой поколоночное методом перемножения матриц. ]]

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

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

Выходные данные: вектор комплексных чисел <math>b = (b_1,b_2,...,b_{\lfloor N/2 \rfloor+1})</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/tree/master ссылке]. Проводились замеры времени работы алгоритма, а также эффективности.

== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [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)

[[en:Fast Discrete Fourier Transform]]

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

2016-10-11T20:26:44Z

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

{{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> комплексных чисел
}}
'''Быстрое преобразование Фурье (БПФ, 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]
= ЧАСТЬ. Свойства и структура алгоритмов =

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

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

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

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

'''''Замечание:''''' В простейшем случае '''алгоритм Кули-Тьюки''' применяется к векторам '''размерности степени двойки''', поэтому на практике вектора иной размерности часто '''дополнять''' до ближайшей степени двойки. Такой подход делает '''алгоритм Кули-Тьюки''' не самым эффективным алгоритмом БПФ, поскольку дополнение до степени двойки может сильно усложнить задачу.

== Рекурсивное описание ==
Алгоритм:
# Входной вектор <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> 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} (\sum_{k=0}^{n_1-1}a_{kn_2+j}\varepsilon^{kin_2})</math>.
Выражения в скобках нам уже известны — это <math>(i\pmod 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>.

== Информационный граф ==
[[Файл:Graph fourier.png |center|thumb|600px| Информационный граф для БПФ где n1=6, n2=6. В левой части выполняется построчное преобразование входного массива, а в правой поколоночное методом перемножения матриц. ]]

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

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

Выходные данные: вектор комплексных чисел <math>b = (b_1,b_2,...,b_{\lfloor N/2 \rfloor+1})</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/tree/master ссылке]. Проводились замеры времени работы алгоритма, а также эффективности.

== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [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)

[[en:Fast Discrete Fourier Transform]]

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

2016-10-11T20:04:32Z

Pumpkin: /* ЧАСТЬ. Программная реализация алгоритма */

{{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> комплексных чисел
}}
'''Быстрое преобразование Фурье (БПФ, 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]
= ЧАСТЬ. Свойства и структура алгоритмов =

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

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

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

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

'''''Замечание:''''' В простейшем случае '''алгоритм Кули-Тьюки''' применяется к векторам '''размерности степени двойки''', поэтому на практике вектора иной размерности часто '''дополнять''' до ближайшей степени двойки. Такой подход делает '''алгоритм Кули-Тьюки''' не самым эффективным алгоритмом БПФ, поскольку дополнение до степени двойки может сильно усложнить задачу.

== Рекурсивное описание ==
Алгоритм:
# Входной вектор <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> 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} (\sum_{k=0}^{n_1-1}a_{kn_2+j}\varepsilon^{kin_2})</math>.
Выражения в скобках нам уже известны — это <math>(i\pmod 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>.

== Информационный граф ==
[[Файл:Graph fourier.png |center|thumb|600px| Информационный граф для БПФ где n1=6, n2=6. В левой части выполняется построчное преобразование входного массива, а в правой поколоночное методом перемножения матриц. ]]

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

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

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

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

== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [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)

[[en:Fast Discrete Fourier Transform]]

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

2016-10-11T20:04:00Z

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

{{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> комплексных чисел
}}
'''Быстрое преобразование Фурье (БПФ, 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]
= ЧАСТЬ. Свойства и структура алгоритмов =

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

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

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

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

'''''Замечание:''''' В простейшем случае '''алгоритм Кули-Тьюки''' применяется к векторам '''размерности степени двойки''', поэтому на практике вектора иной размерности часто '''дополнять''' до ближайшей степени двойки. Такой подход делает '''алгоритм Кули-Тьюки''' не самым эффективным алгоритмом БПФ, поскольку дополнение до степени двойки может сильно усложнить задачу.

== Рекурсивное описание ==
Алгоритм:
# Входной вектор <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> 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} (\sum_{k=0}^{n_1-1}a_{kn_2+j}\varepsilon^{kin_2})</math>.
Выражения в скобках нам уже известны — это <math>(i\pmod 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>.

== Информационный граф ==
[[Файл:Graph fourier.png |center|thumb|600px| Информационный граф для БПФ где n1=6, n2=6. В левой части выполняется построчное преобразование входного массива, а в правой поколоночное методом перемножения матриц. ]]

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

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

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

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

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

= ЧАСТЬ. Программная реализация алгоритма =
В качестве тестируемой реализации была выбрана библиотека FFTW, а именно функция, выполняющая БПФ одномерного вектора действительных чисел.

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

== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [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)

[[en:Fast Discrete Fourier Transform]]

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

2016-10-11T19:55:08Z

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

{{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> комплексных чисел
}}
'''Быстрое преобразование Фурье (БПФ, 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]
= ЧАСТЬ. Свойства и структура алгоритмов =

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

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

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

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

'''''Замечание:''''' В простейшем случае '''алгоритм Кули-Тьюки''' применяется к векторам '''размерности степени двойки''', поэтому на практике вектора иной размерности часто '''дополнять''' до ближайшей степени двойки. Такой подход делает '''алгоритм Кули-Тьюки''' не самым эффективным алгоритмом БПФ, поскольку дополнение до степени двойки может сильно усложнить задачу.

== Рекурсивное описание ==
Алгоритм:
# Входной вектор <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> 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>.
При этом результат суммы записывается в элемент с меньшим номером, а результат вычитания с последующим умножением - в элемент с большим.

Простейший вариант алгоритма для степеней двойки на языке 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>

== Последовательная сложность алгоритма ==
Быстрое дискретное преобразование Фурье выполнимо за <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} (\sum_{k=0}^{n_1-1}a_{kn_2+j}\varepsilon^{kin_2})</math>.
Выражения в скобках нам уже известны — это <math>(i\pmod 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>.

== Информационный граф ==
[[Файл:Graph fourier.png |center|thumb|600px| Информационный граф для БПФ где n1=6, n2=6. В левой части выполняется построчное преобразование входного массива, а в правой поколоночное методом перемножения матриц. ]]

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

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

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

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

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

= ЧАСТЬ. Программная реализация алгоритма =
В качестве тестируемой реализации была выбрана библиотека FFTW, а именно функция, выполняющая БПФ одномерного вектора действительных чисел.

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

== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [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)

[[en:Fast Discrete Fourier Transform]]

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

2016-10-11T19:54:01Z

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

{{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> комплексных чисел
}}
'''Быстрое преобразование Фурье (БПФ, 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]
= ЧАСТЬ. Свойства и структура алгоритмов =

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

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

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

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

'''''Замечание:''''' В простейшем случае '''алгоритм Кули-Тьюки''' применяется к векторам '''размерности степени двойки''', поэтому на практике вектора иной размерности часто '''дополнять''' до ближайшей степени двойки. Такой подход делает '''алгоритм Кули-Тьюки''' не самым эффективным алгоритмом БПФ, поскольку дополнение до степени двойки может сильно усложнить задачу.

== Рекурсивное описание ==
Алгоритм:
# Входной вектор <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> 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>.
При этом результат суммы записывается в элемент с меньшим номером, а результат вычитания с последующим умножением - в элемент с большим.

Простейший вариант алгоритма для степеней двойки на языке 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>

== Последовательная сложность алгоритма ==
Быстрое дискретное преобразование Фурье выполнимо за <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} (\sum_{k=0}^{n_1-1}a_{kn_2+j}\varepsilon^{kin_2})</math>.
Выражения в скобках нам уже известны — это <math>(i\pmod 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>.

== Информационный граф ==
[[Файл:Graph fourier.png |center|thumb|600px| Информационный граф для БПФ где n1=6, n2=6. В левой части выполняется построчное преобразование входного массива, а в правой поколоночное методом перемножения матриц. ]]

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

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

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

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

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

= ЧАСТЬ. Программная реализация алгоритма =
В качестве тестируемой реализации была выбрана библиотека FFTW, а именно функция, выполняющая БПФ одномерного вектора действительных чисел.

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

== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [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)

[[en:Fast Discrete Fourier Transform]]

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

2016-10-11T19:52:25Z

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

{{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> комплексных чисел
}}
'''Быстрое преобразование Фурье (БПФ, 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]
= ЧАСТЬ. Свойства и структура алгоритмов =

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

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

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

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

'''''Замечание:''''' В простейшем случае '''алгоритм Кули-Тьюки''' применяется к векторам '''размерности степени двойки''', поэтому на практике вектора иной размерности часто '''дополнять''' до ближайшей степени двойки. Такой подход делает '''алгоритм Кули-Тьюки''' не самым эффективным алгоритмом БПФ, поскольку дополнение до степени двойки может сильно усложнить задачу.

== Рекурсивное описание ==
Алгоритм:
# Входной вектор <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> 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>.
При этом результат суммы записывается в элемент с меньшим номером, а результат вычитания с последующим умножением - в элемент с большим.

Простейший вариант алгоритма для степеней двойки на языке 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>

== Последовательная сложность алгоритма ==
Быстрое дискретное преобразование Фурье выполнимо за <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} (\sum_{k=0}^{n_1-1}a_{kn_2+j}\varepsilon^{kin_2})</math>.
Выражения в скобках нам уже известны — это <math>(i\pmod 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>.

== Информационный граф ==
[[Файл:Graph fourier.png |center|thumb|600px| Информационный граф для БПФ где n1=6, n2=6. В левой части выполняется построчное преобразование входного массива, а в правой поколоночное методом перемножения матриц. ]]

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

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

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

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

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

= ЧАСТЬ. Программная реализация алгоритма =
В качестве тестируемой реализации была выбрана библиотека FFTW, а именно функция, выполняющая БПФ одномерного вектора действительных чисел.

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

== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [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)

[[en:Fast Discrete Fourier Transform]]

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

2016-10-11T19:51:20Z

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

{{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> комплексных чисел
}}
'''Быстрое преобразование Фурье (БПФ, 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]
= ЧАСТЬ. Свойства и структура алгоритмов =

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

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

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

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

'''''Замечание:''''' В простейшем случае '''алгоритм Кули-Тьюки''' применяется к векторам '''размерности степени двойки''', поэтому на практике вектора иной размерности часто '''дополнять''' до ближайшей степени двойки. Такой подход делает '''алгоритм Кули-Тьюки''' не самым эффективным алгоритмом БПФ, поскольку дополнение до степени двойки может сильно усложнить задачу.

== Рекурсивное описание ==
Алгоритм:
# Входной вектор <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> 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>.
При этом результат суммы записывается в элемент с меньшим номером, а результат вычитания с последующим умножением - в элемент с большим.

Простейший вариант алгоритма для степеней двойки на языке 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>

== Последовательная сложность алгоритма ==
Быстрое дискретное преобразование Фурье выполнимо за <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} (\sum_{k=0}^{n_1-1}a_{kn_2+j}\varepsilon^{kin_2})</math>.
Выражения в скобках нам уже известны — это <math>(i\pmod 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>.

== Информационный граф ==
[[Файл:Graph fourier.png |center|thumb|600px| Информационный граф для БПФ где n1=6, n2=6. В левой части выполняется построчное преобразование входного массива, а в правой поколоночное методом перемножения матриц. ]]

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

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

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

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

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

= ЧАСТЬ. Программная реализация алгоритма =
В качестве тестируемой реализации была выбрана библиотека FFTW, а именно функция, выполняющая БПФ одномерного вектора действительных чисел.

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

== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [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)

[[en:Fast Discrete Fourier Transform]]

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

2016-10-11T19:47:47Z

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

{{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> комплексных чисел
}}
'''Быстрое преобразование Фурье (БПФ, 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]
= ЧАСТЬ. Свойства и структура алгоритмов =

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

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

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

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

'''''Замечание:''''' В простейшем случае '''алгоритм Кули-Тьюки''' применяется к векторам '''размерности степени двойки''', поэтому на практике вектора иной размерности часто '''дополнять''' до ближайшей степени двойки. Такой подход делает '''алгоритм Кули-Тьюки''' не самым эффективным алгоритмом БПФ, поскольку дополнение до степени двойки может сильно усложнить задачу.

== Рекурсивное описание ==
Алгоритм:
# Входной вектор <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> 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>.
При этом результат суммы записывается в элемент с меньшим номером, а результат вычитания с последующим умножением - в элемент с большим.

Простейший вариант алгоритма для степеней двойки:
<syntaxhighlight lang="С">
#include <stdio.h>
#include <math.h>
#include <complex.h>

double PI;
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);
}
</syntaxhighlight>

== Последовательная сложность алгоритма ==
Быстрое дискретное преобразование Фурье выполнимо за <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} (\sum_{k=0}^{n_1-1}a_{kn_2+j}\varepsilon^{kin_2})</math>.
Выражения в скобках нам уже известны — это <math>(i\pmod 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>.

== Информационный граф ==
[[Файл:Graph fourier.png |center|thumb|600px| Информационный граф для БПФ где n1=6, n2=6. В левой части выполняется построчное преобразование входного массива, а в правой поколоночное методом перемножения матриц. ]]

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

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

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

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

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

= ЧАСТЬ. Программная реализация алгоритма =
В качестве тестируемой реализации была выбрана библиотека FFTW, а именно функция, выполняющая БПФ одномерного вектора действительных чисел.

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

== Существующие реализации алгоритма ==
Наиболее известной библиотекой для выполнения различных вариантов быстрого преобразования Фурье является [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)

[[en:Fast Discrete Fourier Transform]]