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

Участник:Бугаков Юрий/Построение матрицы Адамара произвольной размерности

2016-11-20T18:50:46Z

Бугаков Юрий: /* Масштабируемость алгоритма и его реализации */

{{Assignment|Sleo}}
Авторы: [[U:Бугаков Юрий|Бугаков Юрий]] (613 группа), Кужамалиев Ернур (601 группа).

Бугаков Юрий:

* Пункты 1.1, 1.2, 1.9, 1.10, 2.1, 2.7;
* Совместное обсуждение и работа над всей статьей в целом с другим автором.

Кужамалиев Ернур:

* Пункты 1.3, 1.4, 1.5, 1.6, 1.7 (рисунки авториские), 1.8;
* Совместное обсуждение и работа над всей статьей в целом с другим автором.
{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O( \left[ \frac{n}{4}\right]\,2^{2n})</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(2^{2n})</math>
| input_data = <math>1</math>
| output_data = <math>2^{2n}</math>
}}

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

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

Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.

Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие

:<math> H_m\,H_m^T = m\,E_m </math>

Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны [1]. Также, можно увидеть из определения, что m четно и
:<math>
H_{2m} =
\begin{pmatrix}
H_{m} & H_{m}\\
H_{m} & -H_{m}\end{pmatrix}
</math>

С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).

Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 (например [2],[3] и [4]). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара следующим образом:

'''Матрица Адамара ''H''''n'' - это матрица размера 2''n'' × 2''n'', для которой справедливо равенство'''

:<math>H_n = H_{1} \otimes H_{n-1}</math>,

:<math>\begin{align}
H_1 = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>,
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''

Представим некоторые частные примеры матриц Адамара:

:<math>
H_0 = +1,
</math>

:<math>
H_1 = \frac{1}{\sqrt2}
\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
</math>,

:<math>
H_2 = \frac{1}{2}
\begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>,

:<math>
H_3 = \frac{1}{2^{\frac{3}{2}}}
\begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>.

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

Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> можно вычислить поэлементно ([3], [4]):

:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,

где ''k''''j'' и ''l''''j'' коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):

: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math>

и
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.

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

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

Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.

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

Основную часть метода составляют вычисления значений степени -1 для каждого элемента:

: <math>\sum_{j=0}^n k_j l_j</math>.

Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.

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

Последовательность исполнения метода следующая:

1. Побитовое умножение <math>k\&l</math>;

2. Вычисление количества единиц двоичной записи;

3. Определение знака элемента по степени.

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

Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма <math> T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}. </math>

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

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

*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный.

[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]

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

Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:
* <math>N^2</math> вычислений побитового умножения,
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,
* <math>N^2</math> для определения знака значения элемента.

Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна <math>O(2^{2n})</math>.

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

'''Входные данные''': натуральное число <math> n \in \N </math> - размерность матрицы Адамара <math>H_n</math>.

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

'''Выходные данные''': матрица Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> (элементы <math>h_{ij}</math>).

'''Объём выходных данных''': <math>2^{2n}</math>, где <math> n </math> - размерность матрицы Адамара. Стоит заметить, что в силу симметричности или самого определения матрицы Адамара, достаточно хранить не все элементы матрицы, а только их часть.

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

* Соотношение последовательной и параллельной сложности:
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом: <math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.

Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.

Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.
:<math>\frac{T(n)}{T(n,P)}=P</math>.
То есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;

* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right)</math>;

* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размера 2''n'' × 2''n'');

* Степень исхода вершины информационного графа равна 1;

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

=ЧАСТЬ Программная реализация алгоритма =

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

В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:

<source lang="C">
void adamar(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2); // h - нормализующий множитель
N = pow(2,n);

for(i=0;i<N;++i)
{
for(j=0;j<N;++j)
{
ij = i & j;
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij
if(l%2==0) H[i][j] = h;
else H[i][j] = -h;
}
}
}
</source>

Также существует рекурсивная реализация метода построения матрицы Адамара

<source lang="C">
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель
{
if(n==1) H[i][j] = h;
else
{
adamar(H, N/2, i, j, h);
adamar(H, N/2, i, N/2+j, h);
adamar(H, N/2, N/2+i, j, h);
adamar(H, N/2, N/2+i, N/2+j, -h);
}
}
</source>

Или эквивалентный безрекурсивный вариант:

<source lang="C">
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2);
N = pow(2,n);
k=2;
H[0][0] = h;

while(k<=N)
{
for (i=0; i<k; ++i)
{
for (j=0; j<k; ++j)
{
if (i<k/2 && j<k/2)
{
}
else
{
if(i>=k/2 && j>=k/2)
{
H[i][j] = -(H[i-k/2][j-k/2]);
}
else
{
if (i>j)
{
H[i][j] = H[i-k/2][j];
}
else
{
H[i][j] = H[i][j-k/2];
}
}
}
}
}

k=k*2;
}
}
</source>

Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у распараллелинной adamar_not_recursion (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).

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

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

== Масштабируемость алгоритма и его реализации ==
Исследование проводилось на суперкомпьютере "Blue Gene".

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

* число процессоров [1, 2, 4, 8,..., 1024] ;
* размер матрицы [2, 4, 8,..., 2048].

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

* минимальная эффективность реализации 0.0121%;
* максимальная эффективность реализации 3.3003%.

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

[[file:Prois1.jpg|thumb|center|700px|Рис.5 Изменение производительности в зависимости от числа процессоров и размера матрицы.]]
[[file:Effec1.jpg|thumb|center|700px|Рис.5 Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]

Построим оценки масштабируемости выбранной реализации:
* При увеличении числа процессов производительность на рассмотренной области изменений параметров запуска увеличивается практически линейно. В следствии этого эффективность реализации, как видно по графику, перестает изменяться при увеличении числа процессоров и равна примерно 1,7%.
* При увеличении размера матрицы производительность на рассмотренной области изменений параметров запуска увеличивается логарифмически. Это связанно с тем, что количество операций зависит от количества единиц после бинарного произведения. Поэтому наиболее влияет порядок степени <math>n</math> размера матрицы <math>N=2^{n}</math>. При увеличении размера матрицы эффективность также увеличивается, но скорость возрастания уменьшается.
По двум направлениям: При рассмотрении увеличения как вычислительной сложности, так и числа процессов на всей рассмотренной области значений эффективность увеличивается, однако скорость увеличения эффективности небольшая.

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

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

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

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave].

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH].

= Литература =
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.

[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]

[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

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

[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)

Участник:Бугаков Юрий/Построение матрицы Адамара произвольной размерности

2016-11-20T18:48:26Z

Бугаков Юрий: /* Масштабируемость алгоритма и его реализации */

{{Assignment|Sleo}}
Авторы: [[U:Бугаков Юрий|Бугаков Юрий]] (613 группа), Кужамалиев Ернур (601 группа).

Бугаков Юрий:

* Пункты 1.1, 1.2, 1.9, 1.10, 2.1, 2.7;
* Совместное обсуждение и работа над всей статьей в целом с другим автором.

Кужамалиев Ернур:

* Пункты 1.3, 1.4, 1.5, 1.6, 1.7 (рисунки авториские), 1.8;
* Совместное обсуждение и работа над всей статьей в целом с другим автором.
{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O( \left[ \frac{n}{4}\right]\,2^{2n})</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(2^{2n})</math>
| input_data = <math>1</math>
| output_data = <math>2^{2n}</math>
}}

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

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

Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.

Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие

:<math> H_m\,H_m^T = m\,E_m </math>

Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны [1]. Также, можно увидеть из определения, что m четно и
:<math>
H_{2m} =
\begin{pmatrix}
H_{m} & H_{m}\\
H_{m} & -H_{m}\end{pmatrix}
</math>

С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).

Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 (например [2],[3] и [4]). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара следующим образом:

'''Матрица Адамара ''H''''n'' - это матрица размера 2''n'' × 2''n'', для которой справедливо равенство'''

:<math>H_n = H_{1} \otimes H_{n-1}</math>,

:<math>\begin{align}
H_1 = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>,
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''

Представим некоторые частные примеры матриц Адамара:

:<math>
H_0 = +1,
</math>

:<math>
H_1 = \frac{1}{\sqrt2}
\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
</math>,

:<math>
H_2 = \frac{1}{2}
\begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>,

:<math>
H_3 = \frac{1}{2^{\frac{3}{2}}}
\begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>.

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

Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> можно вычислить поэлементно ([3], [4]):

:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,

где ''k''''j'' и ''l''''j'' коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):

: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math>

и
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.

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

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

Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.

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

Основную часть метода составляют вычисления значений степени -1 для каждого элемента:

: <math>\sum_{j=0}^n k_j l_j</math>.

Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.

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

Последовательность исполнения метода следующая:

1. Побитовое умножение <math>k\&l</math>;

2. Вычисление количества единиц двоичной записи;

3. Определение знака элемента по степени.

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

Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма <math> T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}. </math>

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

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

*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный.

[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]

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

Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:
* <math>N^2</math> вычислений побитового умножения,
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,
* <math>N^2</math> для определения знака значения элемента.

Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна <math>O(2^{2n})</math>.

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

'''Входные данные''': натуральное число <math> n \in \N </math> - размерность матрицы Адамара <math>H_n</math>.

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

'''Выходные данные''': матрица Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> (элементы <math>h_{ij}</math>).

'''Объём выходных данных''': <math>2^{2n}</math>, где <math> n </math> - размерность матрицы Адамара. Стоит заметить, что в силу симметричности или самого определения матрицы Адамара, достаточно хранить не все элементы матрицы, а только их часть.

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

* Соотношение последовательной и параллельной сложности:
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом: <math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.

Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.

Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.
:<math>\frac{T(n)}{T(n,P)}=P</math>.
То есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;

* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right)</math>;

* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размера 2''n'' × 2''n'');

* Степень исхода вершины информационного графа равна 1;

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

=ЧАСТЬ Программная реализация алгоритма =

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

В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:

<source lang="C">
void adamar(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2); // h - нормализующий множитель
N = pow(2,n);

for(i=0;i<N;++i)
{
for(j=0;j<N;++j)
{
ij = i & j;
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij
if(l%2==0) H[i][j] = h;
else H[i][j] = -h;
}
}
}
</source>

Также существует рекурсивная реализация метода построения матрицы Адамара

<source lang="C">
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель
{
if(n==1) H[i][j] = h;
else
{
adamar(H, N/2, i, j, h);
adamar(H, N/2, i, N/2+j, h);
adamar(H, N/2, N/2+i, j, h);
adamar(H, N/2, N/2+i, N/2+j, -h);
}
}
</source>

Или эквивалентный безрекурсивный вариант:

<source lang="C">
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2);
N = pow(2,n);
k=2;
H[0][0] = h;

while(k<=N)
{
for (i=0; i<k; ++i)
{
for (j=0; j<k; ++j)
{
if (i<k/2 && j<k/2)
{
}
else
{
if(i>=k/2 && j>=k/2)
{
H[i][j] = -(H[i-k/2][j-k/2]);
}
else
{
if (i>j)
{
H[i][j] = H[i-k/2][j];
}
else
{
H[i][j] = H[i][j-k/2];
}
}
}
}
}

k=k*2;
}
}
</source>

Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у распараллелинной adamar_not_recursion (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).

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

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

== Масштабируемость алгоритма и его реализации ==
Исследование проводилось на суперкомпьютере "Blue Gene".

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

* число процессоров [1, 2, 4, 8,..., 1024] ;
* размер матрицы [2, 4, 8,..., 2048].

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

* минимальная эффективность реализации 0.0121%;
* максимальная эффективность реализации 3.3003%.

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

[[file:Prois1.jpg|thumb|center|700px|Рис.5 Изменение производительности в зависимости от числа процессоров и размера матрицы.]]
[[file:Effec1.jpg|thumb|center|700px|Рис.5 Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]

Построим оценки масштабируемости выбранной реализации:
* При увеличении числа процессов производительность на рассмотренной области изменений параметров запуска увеличивается практически линейно. В следствии этого эффективность реализации, как видно по графику, перестает изменяться при увеличении числа процессоров и равна примерно 1,7%.
* При увеличении размера матрицы производительность на рассмотренной области изменений параметров запуска увеличивается логарифмически. Это связанно с тем, что количество операций зависит от количества единиц после бинарного произведения. Поэтому наиболее влияет порядок степени <math>n</math> размера матрицы <math>N=2^{n}</math>. При увеличении размера матрицы эффективность также увеличивается. Это подтверждает предположение о том, что размер задачи влияет на эффективность выполнения приложения. Оценка показывает, что с ростом размера задачи эффективность на рассмотренной области значений параметров запуска увеличивается незначительно.
По двум направлениям: При рассмотрении увеличения как вычислительной сложности, так и числа процессов на всей рассмотренной области значений эффективность увеличивается, однако скорость увеличения эффективности небольшая.

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

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

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

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave].

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH].

= Литература =
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.

[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]

[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

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

[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)

Участник:Бугаков Юрий/Построение матрицы Адамара произвольной размерности

2016-11-20T18:38:51Z

Бугаков Юрий: /* Масштабируемость алгоритма и его реализации */

{{Assignment|Sleo}}
Авторы: [[U:Бугаков Юрий|Бугаков Юрий]] (613 группа), Кужамалиев Ернур (601 группа).

Бугаков Юрий:

* Пункты 1.1, 1.2, 1.9, 1.10, 2.1, 2.7;
* Совместное обсуждение и работа над всей статьей в целом с другим автором.

Кужамалиев Ернур:

* Пункты 1.3, 1.4, 1.5, 1.6, 1.7 (рисунки авториские), 1.8;
* Совместное обсуждение и работа над всей статьей в целом с другим автором.
{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O( \left[ \frac{n}{4}\right]\,2^{2n})</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(2^{2n})</math>
| input_data = <math>1</math>
| output_data = <math>2^{2n}</math>
}}

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

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

Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.

Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие

:<math> H_m\,H_m^T = m\,E_m </math>

Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны [1]. Также, можно увидеть из определения, что m четно и
:<math>
H_{2m} =
\begin{pmatrix}
H_{m} & H_{m}\\
H_{m} & -H_{m}\end{pmatrix}
</math>

С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).

Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 (например [2],[3] и [4]). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара следующим образом:

'''Матрица Адамара ''H''''n'' - это матрица размера 2''n'' × 2''n'', для которой справедливо равенство'''

:<math>H_n = H_{1} \otimes H_{n-1}</math>,

:<math>\begin{align}
H_1 = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>,
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''

Представим некоторые частные примеры матриц Адамара:

:<math>
H_0 = +1,
</math>

:<math>
H_1 = \frac{1}{\sqrt2}
\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
</math>,

:<math>
H_2 = \frac{1}{2}
\begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>,

:<math>
H_3 = \frac{1}{2^{\frac{3}{2}}}
\begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>.

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

Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> можно вычислить поэлементно ([3], [4]):

:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,

где ''k''''j'' и ''l''''j'' коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):

: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math>

и
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.

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

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

Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.

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

Основную часть метода составляют вычисления значений степени -1 для каждого элемента:

: <math>\sum_{j=0}^n k_j l_j</math>.

Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.

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

Последовательность исполнения метода следующая:

1. Побитовое умножение <math>k\&l</math>;

2. Вычисление количества единиц двоичной записи;

3. Определение знака элемента по степени.

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

Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма <math> T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}. </math>

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

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

*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный.

[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]

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

Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:
* <math>N^2</math> вычислений побитового умножения,
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,
* <math>N^2</math> для определения знака значения элемента.

Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна <math>O(2^{2n})</math>.

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

'''Входные данные''': натуральное число <math> n \in \N </math> - размерность матрицы Адамара <math>H_n</math>.

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

'''Выходные данные''': матрица Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> (элементы <math>h_{ij}</math>).

'''Объём выходных данных''': <math>2^{2n}</math>, где <math> n </math> - размерность матрицы Адамара. Стоит заметить, что в силу симметричности или самого определения матрицы Адамара, достаточно хранить не все элементы матрицы, а только их часть.

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

* Соотношение последовательной и параллельной сложности:
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом: <math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.

Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.

Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.
:<math>\frac{T(n)}{T(n,P)}=P</math>.
То есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;

* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right)</math>;

* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размера 2''n'' × 2''n'');

* Степень исхода вершины информационного графа равна 1;

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

=ЧАСТЬ Программная реализация алгоритма =

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

В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:

<source lang="C">
void adamar(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2); // h - нормализующий множитель
N = pow(2,n);

for(i=0;i<N;++i)
{
for(j=0;j<N;++j)
{
ij = i & j;
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij
if(l%2==0) H[i][j] = h;
else H[i][j] = -h;
}
}
}
</source>

Также существует рекурсивная реализация метода построения матрицы Адамара

<source lang="C">
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель
{
if(n==1) H[i][j] = h;
else
{
adamar(H, N/2, i, j, h);
adamar(H, N/2, i, N/2+j, h);
adamar(H, N/2, N/2+i, j, h);
adamar(H, N/2, N/2+i, N/2+j, -h);
}
}
</source>

Или эквивалентный безрекурсивный вариант:

<source lang="C">
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2);
N = pow(2,n);
k=2;
H[0][0] = h;

while(k<=N)
{
for (i=0; i<k; ++i)
{
for (j=0; j<k; ++j)
{
if (i<k/2 && j<k/2)
{
}
else
{
if(i>=k/2 && j>=k/2)
{
H[i][j] = -(H[i-k/2][j-k/2]);
}
else
{
if (i>j)
{
H[i][j] = H[i-k/2][j];
}
else
{
H[i][j] = H[i][j-k/2];
}
}
}
}
}

k=k*2;
}
}
</source>

Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у распараллелинной adamar_not_recursion (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).

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

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

== Масштабируемость алгоритма и его реализации ==
Исследование проводилось на суперкомпьютере "Blue Gene".

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

* число процессоров [1, 2, 4, 8,..., 1024] ;
* размер матрицы [2, 4, 8,..., 2048].

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

* минимальная эффективность реализации 0.0121%;
* максимальная эффективность реализации 3.3003%.

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

[[file:Prois1.jpg|thumb|center|700px|Рис.5 Изменение производительности в зависимости от числа процессоров и размера матрицы.]]
[[file:Effec1.jpg|thumb|center|700px|Рис.5 Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]

Построим оценки масштабируемости выбранной реализации:
* При увеличении числа процессов производительность на рассмотренной области изменений параметров запуска увеличивается практически линейно. В следствии этого эффективность реализации, как видно по графику, перестает изменяться при увеличении числа процессоров и равна примерно 1,7%.
* При увеличении размера матрицы производительность на рассмотренной области изменений параметров запуска увеличивается логарифмически. Это связанно с тем, что количество операций зависит от количества единиц после бинарного произведения. Поэтому наиболее влияет порядок степени <math>n</math> размера матрицы <math>N</math>. Эффективность возрастает тем быстрее, чем большее число процессов используется для выполнения. Это подтверждает предположение о том, что размер задачи сильно влияет на эффективность выполнения приложения. Оценка показывает, что с ростом размера задачи эффективность на рассмотренной области значений параметров запуска сильно увеличивается. Также, учитывая разницу максимальной и минимальной эффективности в 2,5%, можно сделать вывод, что рост эффективности при увеличении размера задачи наблюдается на большей части рассмотренной области значений.
По двум направлениям: 0,000403. При рассмотрении увеличения как вычислительной сложности, так и числа процессов на всей рассмотренной области значений эффективность увеличивается, однако скорость увеличения эффективности небольшая. В совокупности с тем фактом, что разница между максимальной и минимальной эффективностью на рассмотренной области значений параметров небольшая, эффективность с увеличением масштабов возрастает, но медленно и с небольшими перепадами.

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

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

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

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave].

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH].

= Литература =
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.

[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]

[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

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

[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)

Участник:Бугаков Юрий/Построение матрицы Адамара произвольной размерности

2016-11-20T18:37:31Z

Бугаков Юрий: /* Масштабируемость алгоритма и его реализации */

{{Assignment|Sleo}}
Авторы: [[U:Бугаков Юрий|Бугаков Юрий]] (613 группа), Кужамалиев Ернур (601 группа).

Бугаков Юрий:

* Пункты 1.1, 1.2, 1.9, 1.10, 2.1, 2.7;
* Совместное обсуждение и работа над всей статьей в целом с другим автором.

Кужамалиев Ернур:

* Пункты 1.3, 1.4, 1.5, 1.6, 1.7 (рисунки авториские), 1.8;
* Совместное обсуждение и работа над всей статьей в целом с другим автором.
{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O( \left[ \frac{n}{4}\right]\,2^{2n})</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(2^{2n})</math>
| input_data = <math>1</math>
| output_data = <math>2^{2n}</math>
}}

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

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

Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.

Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие

:<math> H_m\,H_m^T = m\,E_m </math>

Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны [1]. Также, можно увидеть из определения, что m четно и
:<math>
H_{2m} =
\begin{pmatrix}
H_{m} & H_{m}\\
H_{m} & -H_{m}\end{pmatrix}
</math>

С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).

Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 (например [2],[3] и [4]). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара следующим образом:

'''Матрица Адамара ''H''''n'' - это матрица размера 2''n'' × 2''n'', для которой справедливо равенство'''

:<math>H_n = H_{1} \otimes H_{n-1}</math>,

:<math>\begin{align}
H_1 = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>,
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''

Представим некоторые частные примеры матриц Адамара:

:<math>
H_0 = +1,
</math>

:<math>
H_1 = \frac{1}{\sqrt2}
\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
</math>,

:<math>
H_2 = \frac{1}{2}
\begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>,

:<math>
H_3 = \frac{1}{2^{\frac{3}{2}}}
\begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>.

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

Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> можно вычислить поэлементно ([3], [4]):

:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,

где ''k''''j'' и ''l''''j'' коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):

: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math>

и
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.

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

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

Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.

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

Основную часть метода составляют вычисления значений степени -1 для каждого элемента:

: <math>\sum_{j=0}^n k_j l_j</math>.

Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.

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

Последовательность исполнения метода следующая:

1. Побитовое умножение <math>k\&l</math>;

2. Вычисление количества единиц двоичной записи;

3. Определение знака элемента по степени.

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

Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма <math> T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}. </math>

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

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

*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный.

[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]

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

Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:
* <math>N^2</math> вычислений побитового умножения,
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,
* <math>N^2</math> для определения знака значения элемента.

Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна <math>O(2^{2n})</math>.

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

'''Входные данные''': натуральное число <math> n \in \N </math> - размерность матрицы Адамара <math>H_n</math>.

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

'''Выходные данные''': матрица Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> (элементы <math>h_{ij}</math>).

'''Объём выходных данных''': <math>2^{2n}</math>, где <math> n </math> - размерность матрицы Адамара. Стоит заметить, что в силу симметричности или самого определения матрицы Адамара, достаточно хранить не все элементы матрицы, а только их часть.

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

* Соотношение последовательной и параллельной сложности:
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом: <math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.

Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.

Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.
:<math>\frac{T(n)}{T(n,P)}=P</math>.
То есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;

* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right)</math>;

* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размера 2''n'' × 2''n'');

* Степень исхода вершины информационного графа равна 1;

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

=ЧАСТЬ Программная реализация алгоритма =

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

В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:

<source lang="C">
void adamar(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2); // h - нормализующий множитель
N = pow(2,n);

for(i=0;i<N;++i)
{
for(j=0;j<N;++j)
{
ij = i & j;
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij
if(l%2==0) H[i][j] = h;
else H[i][j] = -h;
}
}
}
</source>

Также существует рекурсивная реализация метода построения матрицы Адамара

<source lang="C">
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель
{
if(n==1) H[i][j] = h;
else
{
adamar(H, N/2, i, j, h);
adamar(H, N/2, i, N/2+j, h);
adamar(H, N/2, N/2+i, j, h);
adamar(H, N/2, N/2+i, N/2+j, -h);
}
}
</source>

Или эквивалентный безрекурсивный вариант:

<source lang="C">
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2);
N = pow(2,n);
k=2;
H[0][0] = h;

while(k<=N)
{
for (i=0; i<k; ++i)
{
for (j=0; j<k; ++j)
{
if (i<k/2 && j<k/2)
{
}
else
{
if(i>=k/2 && j>=k/2)
{
H[i][j] = -(H[i-k/2][j-k/2]);
}
else
{
if (i>j)
{
H[i][j] = H[i-k/2][j];
}
else
{
H[i][j] = H[i][j-k/2];
}
}
}
}
}

k=k*2;
}
}
</source>

Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у распараллелинной adamar_not_recursion (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).

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

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

== Масштабируемость алгоритма и его реализации ==
Исследование проводилось на суперкомпьютере "Blue Gene".

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

* число процессоров [1, 2, 4, 8,..., 1024] ;
* размер матрицы [2, 4, 8,..., 2048].

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

* минимальная эффективность реализации 0.0121%;
* максимальная эффективность реализации 3.3003%.

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

[[file:Prois1.jpg|thumb|center|700px|Рис.5 Изменение производительности в зависимости от числа процессоров и размера матрицы.]]
[[file:Effec1.jpg|thumb|center|700px|Рис.5 Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]

Построим оценки масштабируемости выбранной реализации:
* При увеличении числа процессов производительность на рассмотренной области изменений параметров запуска увеличивается практически линейно. В следствии этого эффективность реализации, как видно по графику, перестает изменяться при увеличении числа процессоров и равна примерно 1,7%.
* При увеличении размера матрицы производительность на рассмотренной области изменений параметров запуска увеличивается логарифмически. Это связанно с тем, что количество операций зависит от количества единиц после бинарного произведения. Поэтому наиболее влияет порядок n степени размера матрицы. Эффективность возрастает тем быстрее, чем большее число процессов используется для выполнения. Это подтверждает предположение о том, что размер задачи сильно влияет на эффективность выполнения приложения. Оценка показывает, что с ростом размера задачи эффективность на рассмотренной области значений параметров запуска сильно увеличивается. Также, учитывая разницу максимальной и минимальной эффективности в 2,5%, можно сделать вывод, что рост эффективности при увеличении размера задачи наблюдается на большей части рассмотренной области значений.
По двум направлениям: 0,000403. При рассмотрении увеличения как вычислительной сложности, так и числа процессов на всей рассмотренной области значений эффективность увеличивается, однако скорость увеличения эффективности небольшая. В совокупности с тем фактом, что разница между максимальной и минимальной эффективностью на рассмотренной области значений параметров небольшая, эффективность с увеличением масштабов возрастает, но медленно и с небольшими перепадами.

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

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

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

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave].

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH].

= Литература =
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.

[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]

[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

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

[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)

Участник:Бугаков Юрий/Построение матрицы Адамара произвольной размерности

2016-11-20T18:15:04Z

Бугаков Юрий: /* Масштабируемость алгоритма и его реализации */

{{Assignment|Sleo}}
Авторы: [[U:Бугаков Юрий|Бугаков Юрий]] (613 группа), Кужамалиев Ернур (601 группа).

Бугаков Юрий:

* Пункты 1.1, 1.2, 1.9, 1.10, 2.1, 2.7;
* Совместное обсуждение и работа над всей статьей в целом с другим автором.

Кужамалиев Ернур:

* Пункты 1.3, 1.4, 1.5, 1.6, 1.7 (рисунки авториские), 1.8;
* Совместное обсуждение и работа над всей статьей в целом с другим автором.
{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O( \left[ \frac{n}{4}\right]\,2^{2n})</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(2^{2n})</math>
| input_data = <math>1</math>
| output_data = <math>2^{2n}</math>
}}

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

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

Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.

Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие

:<math> H_m\,H_m^T = m\,E_m </math>

Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны [1]. Также, можно увидеть из определения, что m четно и
:<math>
H_{2m} =
\begin{pmatrix}
H_{m} & H_{m}\\
H_{m} & -H_{m}\end{pmatrix}
</math>

С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).

Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 (например [2],[3] и [4]). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара следующим образом:

'''Матрица Адамара ''H''''n'' - это матрица размера 2''n'' × 2''n'', для которой справедливо равенство'''

:<math>H_n = H_{1} \otimes H_{n-1}</math>,

:<math>\begin{align}
H_1 = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>,
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''

Представим некоторые частные примеры матриц Адамара:

:<math>
H_0 = +1,
</math>

:<math>
H_1 = \frac{1}{\sqrt2}
\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
</math>,

:<math>
H_2 = \frac{1}{2}
\begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>,

:<math>
H_3 = \frac{1}{2^{\frac{3}{2}}}
\begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>.

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

Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> можно вычислить поэлементно ([3], [4]):

:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,

где ''k''''j'' и ''l''''j'' коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):

: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math>

и
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.

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

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

Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.

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

Основную часть метода составляют вычисления значений степени -1 для каждого элемента:

: <math>\sum_{j=0}^n k_j l_j</math>.

Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.

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

Последовательность исполнения метода следующая:

1. Побитовое умножение <math>k\&l</math>;

2. Вычисление количества единиц двоичной записи;

3. Определение знака элемента по степени.

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

Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма <math> T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}. </math>

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

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

*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный.

[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]

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

Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:
* <math>N^2</math> вычислений побитового умножения,
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,
* <math>N^2</math> для определения знака значения элемента.

Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна <math>O(2^{2n})</math>.

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

'''Входные данные''': натуральное число <math> n \in \N </math> - размерность матрицы Адамара <math>H_n</math>.

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

'''Выходные данные''': матрица Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> (элементы <math>h_{ij}</math>).

'''Объём выходных данных''': <math>2^{2n}</math>, где <math> n </math> - размерность матрицы Адамара. Стоит заметить, что в силу симметричности или самого определения матрицы Адамара, достаточно хранить не все элементы матрицы, а только их часть.

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

* Соотношение последовательной и параллельной сложности:
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом: <math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.

Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.

Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.
:<math>\frac{T(n)}{T(n,P)}=P</math>.
То есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;

* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right)</math>;

* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размера 2''n'' × 2''n'');

* Степень исхода вершины информационного графа равна 1;

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

=ЧАСТЬ Программная реализация алгоритма =

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

В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:

<source lang="C">
void adamar(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2); // h - нормализующий множитель
N = pow(2,n);

for(i=0;i<N;++i)
{
for(j=0;j<N;++j)
{
ij = i & j;
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij
if(l%2==0) H[i][j] = h;
else H[i][j] = -h;
}
}
}
</source>

Также существует рекурсивная реализация метода построения матрицы Адамара

<source lang="C">
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель
{
if(n==1) H[i][j] = h;
else
{
adamar(H, N/2, i, j, h);
adamar(H, N/2, i, N/2+j, h);
adamar(H, N/2, N/2+i, j, h);
adamar(H, N/2, N/2+i, N/2+j, -h);
}
}
</source>

Или эквивалентный безрекурсивный вариант:

<source lang="C">
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2);
N = pow(2,n);
k=2;
H[0][0] = h;

while(k<=N)
{
for (i=0; i<k; ++i)
{
for (j=0; j<k; ++j)
{
if (i<k/2 && j<k/2)
{
}
else
{
if(i>=k/2 && j>=k/2)
{
H[i][j] = -(H[i-k/2][j-k/2]);
}
else
{
if (i>j)
{
H[i][j] = H[i-k/2][j];
}
else
{
H[i][j] = H[i][j-k/2];
}
}
}
}
}

k=k*2;
}
}
</source>

Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у распараллелинной adamar_not_recursion (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).

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

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

== Масштабируемость алгоритма и его реализации ==
Исследование проводилось на суперкомпьютере "Blue Gene".

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

* число процессоров [1, 2, 4, 8,..., 1024] ;
* размер матрицы [2, 4, 8,..., 2048].

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

* минимальная эффективность реализации 0.0121%;
* максимальная эффективность реализации 3.3003%.

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

[[file:Prois1.jpg|thumb|center|700px|Рис.5 Изменение производительности в зависимости от числа процессоров и размера матрицы.]]
[[file:Effec1.jpg|thumb|center|700px|Рис.5 Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]

Построим оценки масштабируемости выбранной реализации:
* При увеличении числа процессов эффективность на рассмотренной области изменений параметров запуска уменьшается, однако в целом уменьшение не очень быстрое. Малая интенсивность изменения объясняется крайне низкой общей эффективностью работы приложения с максимумом в 2,65%, и значение эффективности на рассмотренной области значений быстро доходит до десятых долей процента. Это свидетельствует о том, что на большей части области значений нет интенсивного снижения эффективности. Это объясняется также тем, что с ростом вычислительной сложности падение эффективности становится не таким быстрым. Уменьшение эффективности на рассмотренной области работы параллельной программы объясняется быстрым ростом накладных расходов на организацию параллельного выполнения. С ростом вычислительной сложности задачи эффективность снижается так же быстро, но при больших значениях числа процессов. Это подтверждает предположение о том, что накладные расходы начинают сильно превалировать над вычислениями.
По размеру задачи: 0,06017. При увеличении размера задачи эффективность возрастает. Эффективность возрастает тем быстрее, чем большее число процессов используется для выполнения. Это подтверждает предположение о том, что размер задачи сильно влияет на эффективность выполнения приложения. Оценка показывает, что с ростом размера задачи эффективность на рассмотренной области значений параметров запуска сильно увеличивается. Также, учитывая разницу максимальной и минимальной эффективности в 2,5%, можно сделать вывод, что рост эффективности при увеличении размера задачи наблюдается на большей части рассмотренной области значений.
По двум направлениям: 0,000403. При рассмотрении увеличения как вычислительной сложности, так и числа процессов на всей рассмотренной области значений эффективность увеличивается, однако скорость увеличения эффективности небольшая. В совокупности с тем фактом, что разница между максимальной и минимальной эффективностью на рассмотренной области значений параметров небольшая, эффективность с увеличением масштабов возрастает, но медленно и с небольшими перепадами.

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

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

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

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave].

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH].

= Литература =
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.

[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]

[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

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

[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)

Участник:Бугаков Юрий/Построение матрицы Адамара произвольной размерности

2016-11-20T18:03:50Z

Бугаков Юрий: /* Масштабируемость алгоритма и его реализации */

{{Assignment|Sleo}}
Авторы: [[U:Бугаков Юрий|Бугаков Юрий]] (613 группа), Кужамалиев Ернур (601 группа).

Бугаков Юрий:

* Пункты 1.1, 1.2, 1.9, 1.10, 2.1, 2.7;
* Совместное обсуждение и работа над всей статьей в целом с другим автором.

Кужамалиев Ернур:

* Пункты 1.3, 1.4, 1.5, 1.6, 1.7 (рисунки авториские), 1.8;
* Совместное обсуждение и работа над всей статьей в целом с другим автором.
{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O( \left[ \frac{n}{4}\right]\,2^{2n})</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(2^{2n})</math>
| input_data = <math>1</math>
| output_data = <math>2^{2n}</math>
}}

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

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

Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.

Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие

:<math> H_m\,H_m^T = m\,E_m </math>

Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны [1]. Также, можно увидеть из определения, что m четно и
:<math>
H_{2m} =
\begin{pmatrix}
H_{m} & H_{m}\\
H_{m} & -H_{m}\end{pmatrix}
</math>

С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).

Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 (например [2],[3] и [4]). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара следующим образом:

'''Матрица Адамара ''H''''n'' - это матрица размера 2''n'' × 2''n'', для которой справедливо равенство'''

:<math>H_n = H_{1} \otimes H_{n-1}</math>,

:<math>\begin{align}
H_1 = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>,
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''

Представим некоторые частные примеры матриц Адамара:

:<math>
H_0 = +1,
</math>

:<math>
H_1 = \frac{1}{\sqrt2}
\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
</math>,

:<math>
H_2 = \frac{1}{2}
\begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>,

:<math>
H_3 = \frac{1}{2^{\frac{3}{2}}}
\begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>.

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

Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> можно вычислить поэлементно ([3], [4]):

:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,

где ''k''''j'' и ''l''''j'' коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):

: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math>

и
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.

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

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

Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.

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

Основную часть метода составляют вычисления значений степени -1 для каждого элемента:

: <math>\sum_{j=0}^n k_j l_j</math>.

Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.

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

Последовательность исполнения метода следующая:

1. Побитовое умножение <math>k\&l</math>;

2. Вычисление количества единиц двоичной записи;

3. Определение знака элемента по степени.

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

Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма <math> T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}. </math>

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

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

*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный.

[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]

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

Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:
* <math>N^2</math> вычислений побитового умножения,
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,
* <math>N^2</math> для определения знака значения элемента.

Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна <math>O(2^{2n})</math>.

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

'''Входные данные''': натуральное число <math> n \in \N </math> - размерность матрицы Адамара <math>H_n</math>.

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

'''Выходные данные''': матрица Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> (элементы <math>h_{ij}</math>).

'''Объём выходных данных''': <math>2^{2n}</math>, где <math> n </math> - размерность матрицы Адамара. Стоит заметить, что в силу симметричности или самого определения матрицы Адамара, достаточно хранить не все элементы матрицы, а только их часть.

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

* Соотношение последовательной и параллельной сложности:
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом: <math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.

Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.

Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.
:<math>\frac{T(n)}{T(n,P)}=P</math>.
То есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;

* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right)</math>;

* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размера 2''n'' × 2''n'');

* Степень исхода вершины информационного графа равна 1;

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

=ЧАСТЬ Программная реализация алгоритма =

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

В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:

<source lang="C">
void adamar(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2); // h - нормализующий множитель
N = pow(2,n);

for(i=0;i<N;++i)
{
for(j=0;j<N;++j)
{
ij = i & j;
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij
if(l%2==0) H[i][j] = h;
else H[i][j] = -h;
}
}
}
</source>

Также существует рекурсивная реализация метода построения матрицы Адамара

<source lang="C">
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель
{
if(n==1) H[i][j] = h;
else
{
adamar(H, N/2, i, j, h);
adamar(H, N/2, i, N/2+j, h);
adamar(H, N/2, N/2+i, j, h);
adamar(H, N/2, N/2+i, N/2+j, -h);
}
}
</source>

Или эквивалентный безрекурсивный вариант:

<source lang="C">
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2);
N = pow(2,n);
k=2;
H[0][0] = h;

while(k<=N)
{
for (i=0; i<k; ++i)
{
for (j=0; j<k; ++j)
{
if (i<k/2 && j<k/2)
{
}
else
{
if(i>=k/2 && j>=k/2)
{
H[i][j] = -(H[i-k/2][j-k/2]);
}
else
{
if (i>j)
{
H[i][j] = H[i-k/2][j];
}
else
{
H[i][j] = H[i][j-k/2];
}
}
}
}
}

k=k*2;
}
}
</source>

Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у распараллелинной adamar_not_recursion (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).

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

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

== Масштабируемость алгоритма и его реализации ==
Исследование проводилось на суперкомпьютере "Blue Gene".

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

* число процессоров [1, 2, 4, 8,..., 1024] ;
* размер матрицы [2, 4, 8,..., 2048].

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

* минимальная эффективность реализации 0.0121%;
* максимальная эффективность реализации 3.3003%.

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

[[file:Prois.jpg|thumb|center|700px|Рис.5 Изменение производительности в зависимости от числа процессоров и размера матрицы.]]
[[file:Effec.jpg|thumb|center|700px|Рис.5 Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]

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

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

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

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave].

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH].

= Литература =
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.

[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]

[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

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

[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)

Участник:Бугаков Юрий/Построение матрицы Адамара произвольной размерности

2016-11-20T18:03:23Z

Бугаков Юрий: /* Масштабируемость алгоритма и его реализации */

{{Assignment|Sleo}}
Авторы: [[U:Бугаков Юрий|Бугаков Юрий]] (613 группа), Кужамалиев Ернур (601 группа).

Бугаков Юрий:

* Пункты 1.1, 1.2, 1.9, 1.10, 2.1, 2.7;
* Совместное обсуждение и работа над всей статьей в целом с другим автором.

Кужамалиев Ернур:

* Пункты 1.3, 1.4, 1.5, 1.6, 1.7 (рисунки авториские), 1.8;
* Совместное обсуждение и работа над всей статьей в целом с другим автором.
{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O( \left[ \frac{n}{4}\right]\,2^{2n})</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(2^{2n})</math>
| input_data = <math>1</math>
| output_data = <math>2^{2n}</math>
}}

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

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

Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.

Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие

:<math> H_m\,H_m^T = m\,E_m </math>

Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны [1]. Также, можно увидеть из определения, что m четно и
:<math>
H_{2m} =
\begin{pmatrix}
H_{m} & H_{m}\\
H_{m} & -H_{m}\end{pmatrix}
</math>

С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).

Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 (например [2],[3] и [4]). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара следующим образом:

'''Матрица Адамара ''H''''n'' - это матрица размера 2''n'' × 2''n'', для которой справедливо равенство'''

:<math>H_n = H_{1} \otimes H_{n-1}</math>,

:<math>\begin{align}
H_1 = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>,
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''

Представим некоторые частные примеры матриц Адамара:

:<math>
H_0 = +1,
</math>

:<math>
H_1 = \frac{1}{\sqrt2}
\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
</math>,

:<math>
H_2 = \frac{1}{2}
\begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>,

:<math>
H_3 = \frac{1}{2^{\frac{3}{2}}}
\begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>.

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

Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> можно вычислить поэлементно ([3], [4]):

:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,

где ''k''''j'' и ''l''''j'' коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):

: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math>

и
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.

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

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

Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.

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

Основную часть метода составляют вычисления значений степени -1 для каждого элемента:

: <math>\sum_{j=0}^n k_j l_j</math>.

Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.

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

Последовательность исполнения метода следующая:

1. Побитовое умножение <math>k\&l</math>;

2. Вычисление количества единиц двоичной записи;

3. Определение знака элемента по степени.

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

Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма <math> T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}. </math>

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

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

*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный.

[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]

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

Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:
* <math>N^2</math> вычислений побитового умножения,
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,
* <math>N^2</math> для определения знака значения элемента.

Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна <math>O(2^{2n})</math>.

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

'''Входные данные''': натуральное число <math> n \in \N </math> - размерность матрицы Адамара <math>H_n</math>.

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

'''Выходные данные''': матрица Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> (элементы <math>h_{ij}</math>).

'''Объём выходных данных''': <math>2^{2n}</math>, где <math> n </math> - размерность матрицы Адамара. Стоит заметить, что в силу симметричности или самого определения матрицы Адамара, достаточно хранить не все элементы матрицы, а только их часть.

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

* Соотношение последовательной и параллельной сложности:
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом: <math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.

Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.

Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.
:<math>\frac{T(n)}{T(n,P)}=P</math>.
То есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;

* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right)</math>;

* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размера 2''n'' × 2''n'');

* Степень исхода вершины информационного графа равна 1;

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

=ЧАСТЬ Программная реализация алгоритма =

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

В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:

<source lang="C">
void adamar(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2); // h - нормализующий множитель
N = pow(2,n);

for(i=0;i<N;++i)
{
for(j=0;j<N;++j)
{
ij = i & j;
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij
if(l%2==0) H[i][j] = h;
else H[i][j] = -h;
}
}
}
</source>

Также существует рекурсивная реализация метода построения матрицы Адамара

<source lang="C">
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель
{
if(n==1) H[i][j] = h;
else
{
adamar(H, N/2, i, j, h);
adamar(H, N/2, i, N/2+j, h);
adamar(H, N/2, N/2+i, j, h);
adamar(H, N/2, N/2+i, N/2+j, -h);
}
}
</source>

Или эквивалентный безрекурсивный вариант:

<source lang="C">
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2);
N = pow(2,n);
k=2;
H[0][0] = h;

while(k<=N)
{
for (i=0; i<k; ++i)
{
for (j=0; j<k; ++j)
{
if (i<k/2 && j<k/2)
{
}
else
{
if(i>=k/2 && j>=k/2)
{
H[i][j] = -(H[i-k/2][j-k/2]);
}
else
{
if (i>j)
{
H[i][j] = H[i-k/2][j];
}
else
{
H[i][j] = H[i][j-k/2];
}
}
}
}
}

k=k*2;
}
}
</source>

Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у распараллелинной adamar_not_recursion (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).

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

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

== Масштабируемость алгоритма и его реализации ==
Исследование проводилось на суперкомпьютере "Blue Gene".

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

* число процессоров [1, 2, 4, 8,..., 1024] ;
* размер матрицы [2, 4, 8,..., 2048].

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

* минимальная эффективность реализации 0.0121%;
* максимальная эффективность реализации 3.3003%.

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

[[file:Pr.jpg|thumb|center|700px|Рис.5 Изменение производительности в зависимости от числа процессоров и размера матрицы.]]
[[file:Ef.jpg|thumb|center|700px|Рис.5 Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]

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

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

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

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave].

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH].

= Литература =
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.

[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]

[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

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

[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)

Участник:Бугаков Юрий/Построение матрицы Адамара произвольной размерности

2016-11-20T18:02:23Z

Бугаков Юрий: /* Масштабируемость алгоритма и его реализации */

{{Assignment|Sleo}}
Авторы: [[U:Бугаков Юрий|Бугаков Юрий]] (613 группа), Кужамалиев Ернур (601 группа).

Бугаков Юрий:

* Пункты 1.1, 1.2, 1.9, 1.10, 2.1, 2.7;
* Совместное обсуждение и работа над всей статьей в целом с другим автором.

Кужамалиев Ернур:

* Пункты 1.3, 1.4, 1.5, 1.6, 1.7 (рисунки авториские), 1.8;
* Совместное обсуждение и работа над всей статьей в целом с другим автором.
{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O( \left[ \frac{n}{4}\right]\,2^{2n})</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(2^{2n})</math>
| input_data = <math>1</math>
| output_data = <math>2^{2n}</math>
}}

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

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

Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.

Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие

:<math> H_m\,H_m^T = m\,E_m </math>

Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны [1]. Также, можно увидеть из определения, что m четно и
:<math>
H_{2m} =
\begin{pmatrix}
H_{m} & H_{m}\\
H_{m} & -H_{m}\end{pmatrix}
</math>

С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).

Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 (например [2],[3] и [4]). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара следующим образом:

'''Матрица Адамара ''H''''n'' - это матрица размера 2''n'' × 2''n'', для которой справедливо равенство'''

:<math>H_n = H_{1} \otimes H_{n-1}</math>,

:<math>\begin{align}
H_1 = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>,
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''

Представим некоторые частные примеры матриц Адамара:

:<math>
H_0 = +1,
</math>

:<math>
H_1 = \frac{1}{\sqrt2}
\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
</math>,

:<math>
H_2 = \frac{1}{2}
\begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>,

:<math>
H_3 = \frac{1}{2^{\frac{3}{2}}}
\begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>.

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

Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> можно вычислить поэлементно ([3], [4]):

:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,

где ''k''''j'' и ''l''''j'' коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):

: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math>

и
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.

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

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

Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.

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

Основную часть метода составляют вычисления значений степени -1 для каждого элемента:

: <math>\sum_{j=0}^n k_j l_j</math>.

Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.

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

Последовательность исполнения метода следующая:

1. Побитовое умножение <math>k\&l</math>;

2. Вычисление количества единиц двоичной записи;

3. Определение знака элемента по степени.

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

Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма <math> T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}. </math>

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

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

*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный.

[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]

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

Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:
* <math>N^2</math> вычислений побитового умножения,
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,
* <math>N^2</math> для определения знака значения элемента.

Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна <math>O(2^{2n})</math>.

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

'''Входные данные''': натуральное число <math> n \in \N </math> - размерность матрицы Адамара <math>H_n</math>.

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

'''Выходные данные''': матрица Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> (элементы <math>h_{ij}</math>).

'''Объём выходных данных''': <math>2^{2n}</math>, где <math> n </math> - размерность матрицы Адамара. Стоит заметить, что в силу симметричности или самого определения матрицы Адамара, достаточно хранить не все элементы матрицы, а только их часть.

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

* Соотношение последовательной и параллельной сложности:
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом: <math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.

Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.

Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.
:<math>\frac{T(n)}{T(n,P)}=P</math>.
То есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;

* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right)</math>;

* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размера 2''n'' × 2''n'');

* Степень исхода вершины информационного графа равна 1;

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

=ЧАСТЬ Программная реализация алгоритма =

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

В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:

<source lang="C">
void adamar(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2); // h - нормализующий множитель
N = pow(2,n);

for(i=0;i<N;++i)
{
for(j=0;j<N;++j)
{
ij = i & j;
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij
if(l%2==0) H[i][j] = h;
else H[i][j] = -h;
}
}
}
</source>

Также существует рекурсивная реализация метода построения матрицы Адамара

<source lang="C">
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель
{
if(n==1) H[i][j] = h;
else
{
adamar(H, N/2, i, j, h);
adamar(H, N/2, i, N/2+j, h);
adamar(H, N/2, N/2+i, j, h);
adamar(H, N/2, N/2+i, N/2+j, -h);
}
}
</source>

Или эквивалентный безрекурсивный вариант:

<source lang="C">
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2);
N = pow(2,n);
k=2;
H[0][0] = h;

while(k<=N)
{
for (i=0; i<k; ++i)
{
for (j=0; j<k; ++j)
{
if (i<k/2 && j<k/2)
{
}
else
{
if(i>=k/2 && j>=k/2)
{
H[i][j] = -(H[i-k/2][j-k/2]);
}
else
{
if (i>j)
{
H[i][j] = H[i-k/2][j];
}
else
{
H[i][j] = H[i][j-k/2];
}
}
}
}
}

k=k*2;
}
}
</source>

Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у распараллелинной adamar_not_recursion (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).

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

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

== Масштабируемость алгоритма и его реализации ==
Исследование проводилось на суперкомпьютере "Blue Gene".

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

* число процессоров [1, 2, 4, 8,..., 1024] ;
* размер матрицы [2, 4, 8,..., 2048].

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

* минимальная эффективность реализации 0.0121%;
* максимальная эффективность реализации 3.3003%.

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

[[file:Pr.png|thumb|center|700px|Рис.5 Изменение производительности в зависимости от числа процессоров и размера матрицы.]]
[[file:Ef.png|thumb|center|700px|Рис.5 Изменение эффективности в зависимости от числа процессоров и размера матрицы.]]

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

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

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

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave].

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH].

= Литература =
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.

[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]

[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

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

[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)

Участник:Бугаков Юрий/Построение матрицы Адамара произвольной размерности

2016-11-20T18:00:34Z

Бугаков Юрий: /* Масштабируемость алгоритма и его реализации */

{{Assignment|Sleo}}
Авторы: [[U:Бугаков Юрий|Бугаков Юрий]] (613 группа), Кужамалиев Ернур (601 группа).

Бугаков Юрий:

* Пункты 1.1, 1.2, 1.9, 1.10, 2.1, 2.7;
* Совместное обсуждение и работа над всей статьей в целом с другим автором.

Кужамалиев Ернур:

* Пункты 1.3, 1.4, 1.5, 1.6, 1.7 (рисунки авториские), 1.8;
* Совместное обсуждение и работа над всей статьей в целом с другим автором.
{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O( \left[ \frac{n}{4}\right]\,2^{2n})</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(2^{2n})</math>
| input_data = <math>1</math>
| output_data = <math>2^{2n}</math>
}}

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

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

Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.

Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие

:<math> H_m\,H_m^T = m\,E_m </math>

Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны [1]. Также, можно увидеть из определения, что m четно и
:<math>
H_{2m} =
\begin{pmatrix}
H_{m} & H_{m}\\
H_{m} & -H_{m}\end{pmatrix}
</math>

С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).

Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 (например [2],[3] и [4]). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара следующим образом:

'''Матрица Адамара ''H''''n'' - это матрица размера 2''n'' × 2''n'', для которой справедливо равенство'''

:<math>H_n = H_{1} \otimes H_{n-1}</math>,

:<math>\begin{align}
H_1 = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>,
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''

Представим некоторые частные примеры матриц Адамара:

:<math>
H_0 = +1,
</math>

:<math>
H_1 = \frac{1}{\sqrt2}
\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
</math>,

:<math>
H_2 = \frac{1}{2}
\begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>,

:<math>
H_3 = \frac{1}{2^{\frac{3}{2}}}
\begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>.

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

Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> можно вычислить поэлементно ([3], [4]):

:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,

где ''k''''j'' и ''l''''j'' коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):

: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math>

и
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.

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

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

Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.

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

Основную часть метода составляют вычисления значений степени -1 для каждого элемента:

: <math>\sum_{j=0}^n k_j l_j</math>.

Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.

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

Последовательность исполнения метода следующая:

1. Побитовое умножение <math>k\&l</math>;

2. Вычисление количества единиц двоичной записи;

3. Определение знака элемента по степени.

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

Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма <math> T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}. </math>

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

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

*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный.

[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]

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

Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:
* <math>N^2</math> вычислений побитового умножения,
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,
* <math>N^2</math> для определения знака значения элемента.

Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна <math>O(2^{2n})</math>.

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

'''Входные данные''': натуральное число <math> n \in \N </math> - размерность матрицы Адамара <math>H_n</math>.

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

'''Выходные данные''': матрица Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> (элементы <math>h_{ij}</math>).

'''Объём выходных данных''': <math>2^{2n}</math>, где <math> n </math> - размерность матрицы Адамара. Стоит заметить, что в силу симметричности или самого определения матрицы Адамара, достаточно хранить не все элементы матрицы, а только их часть.

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

* Соотношение последовательной и параллельной сложности:
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом: <math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.

Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.

Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.
:<math>\frac{T(n)}{T(n,P)}=P</math>.
То есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;

* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right)</math>;

* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размера 2''n'' × 2''n'');

* Степень исхода вершины информационного графа равна 1;

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

=ЧАСТЬ Программная реализация алгоритма =

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

В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:

<source lang="C">
void adamar(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2); // h - нормализующий множитель
N = pow(2,n);

for(i=0;i<N;++i)
{
for(j=0;j<N;++j)
{
ij = i & j;
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij
if(l%2==0) H[i][j] = h;
else H[i][j] = -h;
}
}
}
</source>

Также существует рекурсивная реализация метода построения матрицы Адамара

<source lang="C">
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель
{
if(n==1) H[i][j] = h;
else
{
adamar(H, N/2, i, j, h);
adamar(H, N/2, i, N/2+j, h);
adamar(H, N/2, N/2+i, j, h);
adamar(H, N/2, N/2+i, N/2+j, -h);
}
}
</source>

Или эквивалентный безрекурсивный вариант:

<source lang="C">
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2);
N = pow(2,n);
k=2;
H[0][0] = h;

while(k<=N)
{
for (i=0; i<k; ++i)
{
for (j=0; j<k; ++j)
{
if (i<k/2 && j<k/2)
{
}
else
{
if(i>=k/2 && j>=k/2)
{
H[i][j] = -(H[i-k/2][j-k/2]);
}
else
{
if (i>j)
{
H[i][j] = H[i-k/2][j];
}
else
{
H[i][j] = H[i][j-k/2];
}
}
}
}
}

k=k*2;
}
}
</source>

Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у распараллелинной adamar_not_recursion (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).

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

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

== Масштабируемость алгоритма и его реализации ==
Исследование проводилось на суперкомпьютере "Blue Gene".

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

* число процессоров [1, 2, 4, 8,..., 1024] ;
* размер матрицы [2, 4, 8,..., 2048].

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

* минимальная эффективность реализации 0.0121%;
* максимальная эффективность реализации 3.3003%.

На следующих рисунках приведены графики производительности и эффективности выбранной реализации построение матрицы Адамара в зависимости от изменяемых параметров запуска.
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

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

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

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

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

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

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

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave].

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH].

= Литература =
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.

[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]

[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

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

[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)

Участник:Бугаков Юрий/Построение матрицы Адамара произвольной размерности

2016-11-20T17:59:57Z

Бугаков Юрий: /* Масштабируемость алгоритма и его реализации */

{{Assignment|Sleo}}
Авторы: [[U:Бугаков Юрий|Бугаков Юрий]] (613 группа), Кужамалиев Ернур (601 группа).

Бугаков Юрий:

* Пункты 1.1, 1.2, 1.9, 1.10, 2.1, 2.7;
* Совместное обсуждение и работа над всей статьей в целом с другим автором.

Кужамалиев Ернур:

* Пункты 1.3, 1.4, 1.5, 1.6, 1.7 (рисунки авториские), 1.8;
* Совместное обсуждение и работа над всей статьей в целом с другим автором.
{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O( \left[ \frac{n}{4}\right]\,2^{2n})</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(2^{2n})</math>
| input_data = <math>1</math>
| output_data = <math>2^{2n}</math>
}}

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

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

Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.

Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие

:<math> H_m\,H_m^T = m\,E_m </math>

Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны [1]. Также, можно увидеть из определения, что m четно и
:<math>
H_{2m} =
\begin{pmatrix}
H_{m} & H_{m}\\
H_{m} & -H_{m}\end{pmatrix}
</math>

С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).

Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 (например [2],[3] и [4]). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара следующим образом:

'''Матрица Адамара ''H''''n'' - это матрица размера 2''n'' × 2''n'', для которой справедливо равенство'''

:<math>H_n = H_{1} \otimes H_{n-1}</math>,

:<math>\begin{align}
H_1 = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>,
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''

Представим некоторые частные примеры матриц Адамара:

:<math>
H_0 = +1,
</math>

:<math>
H_1 = \frac{1}{\sqrt2}
\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
</math>,

:<math>
H_2 = \frac{1}{2}
\begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>,

:<math>
H_3 = \frac{1}{2^{\frac{3}{2}}}
\begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>.

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

Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> можно вычислить поэлементно ([3], [4]):

:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,

где ''k''''j'' и ''l''''j'' коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):

: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math>

и
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.

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

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

Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.

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

Основную часть метода составляют вычисления значений степени -1 для каждого элемента:

: <math>\sum_{j=0}^n k_j l_j</math>.

Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.

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

Последовательность исполнения метода следующая:

1. Побитовое умножение <math>k\&l</math>;

2. Вычисление количества единиц двоичной записи;

3. Определение знака элемента по степени.

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

Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма <math> T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}. </math>

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

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

*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный.

[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]

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

Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:
* <math>N^2</math> вычислений побитового умножения,
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,
* <math>N^2</math> для определения знака значения элемента.

Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна <math>O(2^{2n})</math>.

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

'''Входные данные''': натуральное число <math> n \in \N </math> - размерность матрицы Адамара <math>H_n</math>.

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

'''Выходные данные''': матрица Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> (элементы <math>h_{ij}</math>).

'''Объём выходных данных''': <math>2^{2n}</math>, где <math> n </math> - размерность матрицы Адамара. Стоит заметить, что в силу симметричности или самого определения матрицы Адамара, достаточно хранить не все элементы матрицы, а только их часть.

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

* Соотношение последовательной и параллельной сложности:
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом: <math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.

Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.

Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.
:<math>\frac{T(n)}{T(n,P)}=P</math>.
То есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;

* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right)</math>;

* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размера 2''n'' × 2''n'');

* Степень исхода вершины информационного графа равна 1;

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

=ЧАСТЬ Программная реализация алгоритма =

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

В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:

<source lang="C">
void adamar(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2); // h - нормализующий множитель
N = pow(2,n);

for(i=0;i<N;++i)
{
for(j=0;j<N;++j)
{
ij = i & j;
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij
if(l%2==0) H[i][j] = h;
else H[i][j] = -h;
}
}
}
</source>

Также существует рекурсивная реализация метода построения матрицы Адамара

<source lang="C">
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель
{
if(n==1) H[i][j] = h;
else
{
adamar(H, N/2, i, j, h);
adamar(H, N/2, i, N/2+j, h);
adamar(H, N/2, N/2+i, j, h);
adamar(H, N/2, N/2+i, N/2+j, -h);
}
}
</source>

Или эквивалентный безрекурсивный вариант:

<source lang="C">
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2);
N = pow(2,n);
k=2;
H[0][0] = h;

while(k<=N)
{
for (i=0; i<k; ++i)
{
for (j=0; j<k; ++j)
{
if (i<k/2 && j<k/2)
{
}
else
{
if(i>=k/2 && j>=k/2)
{
H[i][j] = -(H[i-k/2][j-k/2]);
}
else
{
if (i>j)
{
H[i][j] = H[i-k/2][j];
}
else
{
H[i][j] = H[i][j-k/2];
}
}
}
}
}

k=k*2;
}
}
</source>

Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у распараллелинной adamar_not_recursion (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).

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

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

== Масштабируемость алгоритма и его реализации ==
Исследование проводилось на суперкомпьютере "Blue Gene".

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

* число процессоров [1, 2, 4, 8,..., 1024] ;
* размер матрицы [2, 4, 8,..., 2048].

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

* минимальная эффективность реализации 0.0121%;
* максимальная эффективность реализации 3.3003%.

На следующих рисунках приведены графики производительности и эффективности выбранной реализации разложения Холецкого в зависимости от изменяемых параметров запуска.
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

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

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

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

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

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

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

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave].

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH].

= Литература =
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.

[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]

[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

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

[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)

Участник:Бугаков Юрий/Построение матрицы Адамара произвольной размерности

2016-10-28T09:49:54Z

Бугаков Юрий: /* Свойства алгоритма */

{{Assignment}}

Авторы: Бугаков Юрий (613 группа), Кужамалиев Ернур (601 группа).

Бугаков Юрий:

* Пункты 1.1, 1.2, 1.9, 1.10, 2.1, 2.7;
* Совместное обсуждение и работа над всей статьей в целом с другим автором.

Кужамалиев Ернур:

* Пункты 1.3, 1.4, 1.5, 1.6, 1.7 (рисунки авториские), 1.8;
* Совместное обсуждение и работа над всей статьей в целом с другим автором.

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O( \left[ \frac{n}{4}\right]\,2^{2n})</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(2^{2n})</math>
| input_data = <math>1</math>
| output_data = <math>2^{2n}</math>
}}

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

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

Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.

Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие

:<math> H_m\,H_m^T = m\,E_m </math>

Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны [1]. Также, можно увидеть из определения, что m четно и
:<math>
H_{2m} =
\begin{pmatrix}
H_{m} & H_{m}\\
H_{m} & -H_{m}\end{pmatrix}
</math>

С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).

Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 (например [2],[3] и [4]). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара следующим образом:

'''Матрица Адамара ''H''''n'' - это матрица размера 2''n'' × 2''n'', для которой справедливо равенство'''

:<math>H_n = H_{1} \otimes H_{n-1}</math>,

:<math>\begin{align}
H_1 = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>,
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''

Представим некоторые частные примеры матриц Адамара:

:<math>
H_0 = +1,
</math>

:<math>
H_1 = \frac{1}{\sqrt2}
\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
</math>,

:<math>
H_2 = \frac{1}{2}
\begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>,

:<math>
H_3 = \frac{1}{2^{\frac{3}{2}}}
\begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>.

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

Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> можно вычислить поэлементно ([3], [4]):

:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,

где ''k''''j'' и ''l''''j'' коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):

: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math>

и
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.

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

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

Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.

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

Основную часть метода составляют вычисления значений степени -1 для каждого элемента:

: <math>\sum_{j=0}^n k_j l_j</math>.

Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.

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

Последовательность исполнения метода следующая:

1. Побитовое умножение <math>k\&l</math>;

2. Вычисление количества единиц двоичной записи;

3. Определение знака элемента по степени.

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

Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма <math> T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}. </math>

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

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

*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный.

[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]

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

Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:
* <math>N^2</math> вычислений побитового умножения,
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,
* <math>N^2</math> для определения знака значения элемента.

Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна <math>O(2^{2n})</math>.

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

'''Входные данные''': натуральное число <math> n \in \N </math> - размерность матрицы Адамара <math>H_n</math>.

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

'''Выходные данные''': матрица Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> (элементы <math>h_{ij}</math>).

'''Объём выходных данных''': <math>2^{2n}</math>, где <math> n </math> - размерность матрицы Адамара. Стоит заметить, что в силу симметричности или самого определения матрицы Адамара, достаточно хранить не все элементы матрицы, а только их часть.

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

* Соотношение последовательной и параллельной сложности:
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом: <math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.

Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.

Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.
:<math>\frac{T(n)}{T(n,P)}=P</math>.
То есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;

* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right)</math>;

* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размера 2''n'' × 2''n'');

* Степень исхода вершины информационного графа равна 1;

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

=ЧАСТЬ Программная реализация алгоритма =

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

В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:

<source lang="C">
void adamar(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2); // h - нормализующий множитель
N = pow(2,n);

for(i=0;i<N;++i)
{
for(j=0;j<N;++j)
{
ij = i & j;
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij
if(l%2==0) H[i][j] = h;
else H[i][j] = -h;
}
}
}
</source>

Также существует рекурсивная реализация метода построения матрицы Адамара

<source lang="C">
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель
{
if(n==1) H[i][j] = h;
else
{
adamar(H, N/2, i, j, h);
adamar(H, N/2, i, N/2+j, h);
adamar(H, N/2, N/2+i, j, h);
adamar(H, N/2, N/2+i, N/2+j, -h);
}
}
</source>

Или эквивалентный безрекурсивный вариант:

<source lang="C">
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2);
N = pow(2,n);
k=2;
H[0][0] = h;

while(k<=N)
{
for (i=0; i<k; ++i)
{
for (j=0; j<k; ++j)
{
if (i<k/2 && j<k/2)
{
}
else
{
if(i>=k/2 && j>=k/2)
{
H[i][j] = -(H[i-k/2][j-k/2]);
}
else
{
if (i>j)
{
H[i][j] = H[i-k/2][j];
}
else
{
H[i][j] = H[i][j-k/2];
}
}
}
}
}

k=k*2;
}
}
</source>

Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у распараллелинной adamar_not_recursion (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).

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

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

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

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

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

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

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

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

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

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave].

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH].

= Литература =
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.

[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]

[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

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

[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)

Участник:Бугаков Юрий/Построение матрицы Адамара произвольной размерности

2016-10-28T09:48:16Z

Бугаков Юрий:

{{Assignment}}

Авторы: Бугаков Юрий (613 группа), Кужамалиев Ернур (601 группа).

Бугаков Юрий:

* Пункты 1.1, 1.2, 1.9, 1.10, 2.1, 2.7;
* Совместное обсуждение и работа над всей статьей в целом с другим автором.

Кужамалиев Ернур:

* Пункты 1.3, 1.4, 1.5, 1.6, 1.7 (рисунки авториские), 1.8;
* Совместное обсуждение и работа над всей статьей в целом с другим автором.

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O( \left[ \frac{n}{4}\right]\,2^{2n})</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(2^{2n})</math>
| input_data = <math>1</math>
| output_data = <math>2^{2n}</math>
}}

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

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

Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.

Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие

:<math> H_m\,H_m^T = m\,E_m </math>

Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны [1]. Также, можно увидеть из определения, что m четно и
:<math>
H_{2m} =
\begin{pmatrix}
H_{m} & H_{m}\\
H_{m} & -H_{m}\end{pmatrix}
</math>

С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).

Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 (например [2],[3] и [4]). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара следующим образом:

'''Матрица Адамара ''H''''n'' - это матрица размера 2''n'' × 2''n'', для которой справедливо равенство'''

:<math>H_n = H_{1} \otimes H_{n-1}</math>,

:<math>\begin{align}
H_1 = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>,
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''

Представим некоторые частные примеры матриц Адамара:

:<math>
H_0 = +1,
</math>

:<math>
H_1 = \frac{1}{\sqrt2}
\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
</math>,

:<math>
H_2 = \frac{1}{2}
\begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>,

:<math>
H_3 = \frac{1}{2^{\frac{3}{2}}}
\begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>.

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

Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> можно вычислить поэлементно ([3], [4]):

:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,

где ''k''''j'' и ''l''''j'' коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):

: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math>

и
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.

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

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

Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.

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

Основную часть метода составляют вычисления значений степени -1 для каждого элемента:

: <math>\sum_{j=0}^n k_j l_j</math>.

Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.

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

Последовательность исполнения метода следующая:

1. Побитовое умножение <math>k\&l</math>;

2. Вычисление количества единиц двоичной записи;

3. Определение знака элемента по степени.

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

Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма <math> T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}. </math>

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

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

*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный.

[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]

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

Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:
* <math>N^2</math> вычислений побитового умножения,
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,
* <math>N^2</math> для определения знака значения элемента.

Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна <math>O(2^{2n})</math>.

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

'''Входные данные''': натуральное число <math> n \in \N </math> - размерность матрицы Адамара <math>H_n</math>.

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

'''Выходные данные''': матрица Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> (элементы <math>h_{ij}</math>).

'''Объём выходных данных''': <math>2^{2n}</math>, где <math> n </math> - размерность матрицы Адамара. Стоит заметить, что в силу симметричности или самого определения матрицы Адамара, достаточно хранить не все элементы матрицы, а только их часть.

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

* Соотношение последовательной и параллельной сложности:
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом: <math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.

Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.

Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.
:<math>\frac{T(n)}{T(n,P)}=P</math>.
то есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;

* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right)</math>;

* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размера 2''n'' × 2''n'');

* Степень исхода вершины информационного графа равна 1;

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

=ЧАСТЬ Программная реализация алгоритма =

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

В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:

<source lang="C">
void adamar(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2); // h - нормализующий множитель
N = pow(2,n);

for(i=0;i<N;++i)
{
for(j=0;j<N;++j)
{
ij = i & j;
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij
if(l%2==0) H[i][j] = h;
else H[i][j] = -h;
}
}
}
</source>

Также существует рекурсивная реализация метода построения матрицы Адамара

<source lang="C">
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель
{
if(n==1) H[i][j] = h;
else
{
adamar(H, N/2, i, j, h);
adamar(H, N/2, i, N/2+j, h);
adamar(H, N/2, N/2+i, j, h);
adamar(H, N/2, N/2+i, N/2+j, -h);
}
}
</source>

Или эквивалентный безрекурсивный вариант:

<source lang="C">
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2);
N = pow(2,n);
k=2;
H[0][0] = h;

while(k<=N)
{
for (i=0; i<k; ++i)
{
for (j=0; j<k; ++j)
{
if (i<k/2 && j<k/2)
{
}
else
{
if(i>=k/2 && j>=k/2)
{
H[i][j] = -(H[i-k/2][j-k/2]);
}
else
{
if (i>j)
{
H[i][j] = H[i-k/2][j];
}
else
{
H[i][j] = H[i][j-k/2];
}
}
}
}
}

k=k*2;
}
}
</source>

Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у распараллелинной adamar_not_recursion (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).

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

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

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

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

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

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

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

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

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

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave].

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH].

= Литература =
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.

[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]

[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

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

[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)

Участник:Бугаков Юрий/Построение матрицы Адамара произвольной размерности

2016-10-27T19:12:58Z

Бугаков Юрий: /* Входные и выходные данные алгоритма */

{{Assignment}}

Авторы: Бугаков Юрий (613 группа), Кужамалиев Ернур (601 группа).

Бугаков Юрий:

* Пункты 1.1, 1.2, 1.9, 1.10, 2.1, 2.7;
* Совместное обсуждение и работа (подредактирование) над всей статьей в целом с другим автором.

Кужамалиев Ернур:

* Пункты 1.3, 1.4, 1.5, 1.6, 1.7 (рисунки авториские), 1.8;
* Совместное обсуждение и работа (подредактирование) над всей статьей в целом с другим автором.

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O( \left[ \frac{n}{4}\right]\,2^{2n})</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(2^{2n})</math>
| input_data = <math>1</math>
| output_data = <math>2^{2n}</math>
}}

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

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

Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.

Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие

:<math> H_m\,H_m^T = m\,E_m </math>

Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны [1]. Также, можно увидеть из определения, что m четно и
:<math>
H_{2m} =
\begin{pmatrix}
H_{m} & H_{m}\\
H_{m} & -H_{m}\end{pmatrix}
</math>

С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).

Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 (например [2],[3] и [4]). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара следующим образом:

'''Матрица Адамара ''H''''n'' - это матрица размера 2''n'' × 2''n'', для которой справедливо равенство'''

:<math>H_n = H_{1} \otimes H_{n-1}</math>,

:<math>\begin{align}
H_1 = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>,
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''

Представим некоторые частные примеры матриц Адамара:

:<math>
H_0 = +1,
</math>

:<math>
H_1 = \frac{1}{\sqrt2}
\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
</math>,

:<math>
H_2 = \frac{1}{2}
\begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>,

:<math>
H_3 = \frac{1}{2^{\frac{3}{2}}}
\begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>.

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

Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> можно вычислить поэлементно ([3], [4]):

:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,

где ''k''''j'' и ''l''''j'' коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):

: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math>

и
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.

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

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

Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.

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

Основную часть метода составляют вычисления значений степени -1 для каждого элемента:

: <math>\sum_{j=0}^n k_j l_j</math>.

Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.

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

Последовательность исполнения метода следующая:

1. Побитовое умножение <math>k\&l</math>;

2. Вычисление количества единиц двоичной записи;

3. Определение знака элемента по степени.

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

Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма <math> T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}. </math>

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

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

*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный.

[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]

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

Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:
* <math>N^2</math> вычислений побитового умножения,
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,
* <math>N^2</math> для определения знака значения элемента.

Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна <math>O(2^{2n})</math>.

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

'''Входные данные''': натуральное число <math> n \in \N </math> - размерность матрицы Адамара <math>H_n</math>.

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

'''Выходные данные''': матрица Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> (элементы <math>h_{ij}</math>).

'''Объём выходных данных''': <math>2^{2n}</math>, где <math> n </math> - размерность матрицы Адамара. Стоит заметить, что в силу симметричности или самого определения матрицы Адамара, достаточно хранить не все элементы матрицы, а только их часть.

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

* Соотношение последовательной и параллельной сложности:
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом: <math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.

Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.

Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.
:<math>\frac{T(n)}{T(n,P)}=P</math>.
то есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;

* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right)</math>;

* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размера 2''n'' × 2''n'');

* Степень исхода вершины информационного графа равна 1;

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

=ЧАСТЬ Программная реализация алгоритма =

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

В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:

<source lang="C">
void adamar(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2); // h - нормализующий множитель
N = pow(2,n);

for(i=0;i<N;++i)
{
for(j=0;j<N;++j)
{
ij = i & j;
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij
if(l%2==0) H[i][j] = h;
else H[i][j] = -h;
}
}
}
</source>

Также существует рекурсивная реализация метода построения матрицы Адамара

<source lang="C">
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель
{
if(n==1) H[i][j] = h;
else
{
adamar(H, N/2, i, j, h);
adamar(H, N/2, i, N/2+j, h);
adamar(H, N/2, N/2+i, j, h);
adamar(H, N/2, N/2+i, N/2+j, -h);
}
}
</source>

Или эквивалентный безрекурсивный вариант:

<source lang="C">
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2);
N = pow(2,n);
k=2;
H[0][0] = h;

while(k<=N)
{
for (i=0; i<k; ++i)
{
for (j=0; j<k; ++j)
{
if (i<k/2 && j<k/2)
{
}
else
{
if(i>=k/2 && j>=k/2)
{
H[i][j] = -(H[i-k/2][j-k/2]);
}
else
{
if (i>j)
{
H[i][j] = H[i-k/2][j];
}
else
{
H[i][j] = H[i][j-k/2];
}
}
}
}
}

k=k*2;
}
}
</source>

Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у распараллелинной adamar_not_recursion (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).

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

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

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

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

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

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

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

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

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

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave].

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH].

= Литература =
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.

[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]

[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

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

[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)

Участник:Бугаков Юрий/Построение матрицы Адамара произвольной размерности

2016-10-27T19:11:26Z

Бугаков Юрий: /* Входные и выходные данные алгоритма */

{{Assignment}}

Авторы: Бугаков Юрий (613 группа), Кужамалиев Ернур (601 группа).

Бугаков Юрий:

* Пункты 1.1, 1.2, 1.9, 1.10, 2.1, 2.7;
* Совместное обсуждение и работа (подредактирование) над всей статьей в целом с другим автором.

Кужамалиев Ернур:

* Пункты 1.3, 1.4, 1.5, 1.6, 1.7 (рисунки авториские), 1.8;
* Совместное обсуждение и работа (подредактирование) над всей статьей в целом с другим автором.

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O( \left[ \frac{n}{4}\right]\,2^{2n})</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(2^{2n})</math>
| input_data = <math>1</math>
| output_data = <math>2^{2n}</math>
}}

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

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

Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.

Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие

:<math> H_m\,H_m^T = m\,E_m </math>

Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны [1]. Также, можно увидеть из определения, что m четно и
:<math>
H_{2m} =
\begin{pmatrix}
H_{m} & H_{m}\\
H_{m} & -H_{m}\end{pmatrix}
</math>

С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).

Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 (например [2],[3] и [4]). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара следующим образом:

'''Матрица Адамара ''H''''n'' - это матрица размера 2''n'' × 2''n'', для которой справедливо равенство'''

:<math>H_n = H_{1} \otimes H_{n-1}</math>,

:<math>\begin{align}
H_1 = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>,
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''

Представим некоторые частные примеры матриц Адамара:

:<math>
H_0 = +1,
</math>

:<math>
H_1 = \frac{1}{\sqrt2}
\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
</math>,

:<math>
H_2 = \frac{1}{2}
\begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>,

:<math>
H_3 = \frac{1}{2^{\frac{3}{2}}}
\begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>.

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

Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> можно вычислить поэлементно ([3], [4]):

:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,

где ''k''''j'' и ''l''''j'' коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):

: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math>

и
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.

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

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

Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.

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

Основную часть метода составляют вычисления значений степени -1 для каждого элемента:

: <math>\sum_{j=0}^n k_j l_j</math>.

Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.

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

Последовательность исполнения метода следующая:

1. Побитовое умножение <math>k\&l</math>;

2. Вычисление количества единиц двоичной записи;

3. Определение знака элемента по степени.

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

Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма <math> T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}. </math>

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

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

*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный.

[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]

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

Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:
* <math>N^2</math> вычислений побитового умножения,
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,
* <math>N^2</math> для определения знака значения элемента.

Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна <math>O(2^{2n})</math>.

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

'''Входные данные''': натуральное число <math> n \in \N </math> - размерность матрицы Адамара <math>H_n</math>.

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

'''Выходные данные''': матрица Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> (элементы <math>h_{ij}</math>).

'''Объём выходных данных''': <math>2^{2n}</math>, где <math> n </math> - размерность матрицы Адамара. Стоит заметить, что в силу определения или симметричности матрицы Адамара, достаточно хранить не все элементы матрицы, а только их часть.

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

* Соотношение последовательной и параллельной сложности:
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом: <math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.

Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.

Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.
:<math>\frac{T(n)}{T(n,P)}=P</math>.
то есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;

* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right)</math>;

* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размера 2''n'' × 2''n'');

* Степень исхода вершины информационного графа равна 1;

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

=ЧАСТЬ Программная реализация алгоритма =

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

В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:

<source lang="C">
void adamar(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2); // h - нормализующий множитель
N = pow(2,n);

for(i=0;i<N;++i)
{
for(j=0;j<N;++j)
{
ij = i & j;
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij
if(l%2==0) H[i][j] = h;
else H[i][j] = -h;
}
}
}
</source>

Также существует рекурсивная реализация метода построения матрицы Адамара

<source lang="C">
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель
{
if(n==1) H[i][j] = h;
else
{
adamar(H, N/2, i, j, h);
adamar(H, N/2, i, N/2+j, h);
adamar(H, N/2, N/2+i, j, h);
adamar(H, N/2, N/2+i, N/2+j, -h);
}
}
</source>

Или эквивалентный безрекурсивный вариант:

<source lang="C">
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2);
N = pow(2,n);
k=2;
H[0][0] = h;

while(k<=N)
{
for (i=0; i<k; ++i)
{
for (j=0; j<k; ++j)
{
if (i<k/2 && j<k/2)
{
}
else
{
if(i>=k/2 && j>=k/2)
{
H[i][j] = -(H[i-k/2][j-k/2]);
}
else
{
if (i>j)
{
H[i][j] = H[i-k/2][j];
}
else
{
H[i][j] = H[i][j-k/2];
}
}
}
}
}

k=k*2;
}
}
</source>

Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у распараллелинной adamar_not_recursion (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).

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

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

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

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

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

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

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

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

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

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave].

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH].

= Литература =
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.

[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]

[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

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

[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)

Участник:Бугаков Юрий/Построение матрицы Адамара произвольной размерности

2016-10-27T19:05:44Z

Бугаков Юрий:

{{Assignment}}

Авторы: Бугаков Юрий (613 группа), Кужамалиев Ернур (601 группа).

Бугаков Юрий:

* Пункты 1.1, 1.2, 1.9, 1.10, 2.1, 2.7;
* Совместное обсуждение и работа (подредактирование) над всей статьей в целом с другим автором.

Кужамалиев Ернур:

* Пункты 1.3, 1.4, 1.5, 1.6, 1.7 (рисунки авториские), 1.8;
* Совместное обсуждение и работа (подредактирование) над всей статьей в целом с другим автором.

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O( \left[ \frac{n}{4}\right]\,2^{2n})</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(2^{2n})</math>
| input_data = <math>1</math>
| output_data = <math>2^{2n}</math>
}}

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

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

Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.

Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие

:<math> H_m\,H_m^T = m\,E_m </math>

Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны [1]. Также, можно увидеть из определения, что m четно и
:<math>
H_{2m} =
\begin{pmatrix}
H_{m} & H_{m}\\
H_{m} & -H_{m}\end{pmatrix}
</math>

С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).

Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 (например [2],[3] и [4]). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара следующим образом:

'''Матрица Адамара ''H''''n'' - это матрица размера 2''n'' × 2''n'', для которой справедливо равенство'''

:<math>H_n = H_{1} \otimes H_{n-1}</math>,

:<math>\begin{align}
H_1 = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>,
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''

Представим некоторые частные примеры матриц Адамара:

:<math>
H_0 = +1,
</math>

:<math>
H_1 = \frac{1}{\sqrt2}
\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
</math>,

:<math>
H_2 = \frac{1}{2}
\begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>,

:<math>
H_3 = \frac{1}{2^{\frac{3}{2}}}
\begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>.

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

Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> можно вычислить поэлементно ([3], [4]):

:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,

где ''k''''j'' и ''l''''j'' коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):

: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math>

и
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.

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

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

Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.

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

Основную часть метода составляют вычисления значений степени -1 для каждого элемента:

: <math>\sum_{j=0}^n k_j l_j</math>.

Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.

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

Последовательность исполнения метода следующая:

1. Побитовое умножение <math>k\&l</math>;

2. Вычисление количества единиц двоичной записи;

3. Определение знака элемента по степени.

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

Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма <math> T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}. </math>

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

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

*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный.

[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]

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

Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:
* <math>N^2</math> вычислений побитового умножения,
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,
* <math>N^2</math> для определения знака значения элемента.

Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна <math>O(2^{2n})</math>.

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

'''Входные данные''': натуральное число <math> n \in \N </math> - размерность матрицы Адамара <math>H_n</math>.

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

'''Выходные данные''': матрица Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> (элементы <math>h_{ij}</math>).

'''Объём выходных данных''': <math>2^{2n}</math>, где <math> n </math> - размерность матрицы Адамара. Стоит заметить, что в силу определения или симметричности матрицы Адамара, достаточно хранить не все элементы матрицы.

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

* Соотношение последовательной и параллельной сложности:
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом: <math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.

Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.

Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.
:<math>\frac{T(n)}{T(n,P)}=P</math>.
то есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;

* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right)</math>;

* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размера 2''n'' × 2''n'');

* Степень исхода вершины информационного графа равна 1;

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

=ЧАСТЬ Программная реализация алгоритма =

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

В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:

<source lang="C">
void adamar(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2); // h - нормализующий множитель
N = pow(2,n);

for(i=0;i<N;++i)
{
for(j=0;j<N;++j)
{
ij = i & j;
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij
if(l%2==0) H[i][j] = h;
else H[i][j] = -h;
}
}
}
</source>

Также существует рекурсивная реализация метода построения матрицы Адамара

<source lang="C">
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель
{
if(n==1) H[i][j] = h;
else
{
adamar(H, N/2, i, j, h);
adamar(H, N/2, i, N/2+j, h);
adamar(H, N/2, N/2+i, j, h);
adamar(H, N/2, N/2+i, N/2+j, -h);
}
}
</source>

Или эквивалентный безрекурсивный вариант:

<source lang="C">
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2);
N = pow(2,n);
k=2;
H[0][0] = h;

while(k<=N)
{
for (i=0; i<k; ++i)
{
for (j=0; j<k; ++j)
{
if (i<k/2 && j<k/2)
{
}
else
{
if(i>=k/2 && j>=k/2)
{
H[i][j] = -(H[i-k/2][j-k/2]);
}
else
{
if (i>j)
{
H[i][j] = H[i-k/2][j];
}
else
{
H[i][j] = H[i][j-k/2];
}
}
}
}
}

k=k*2;
}
}
</source>

Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у распараллелинной adamar_not_recursion (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).

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

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

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

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

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

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

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

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

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

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave].

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH].

= Литература =
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.

[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]

[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

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

[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)

Обсуждение участника:Бугаков Юрий

2016-10-27T14:21:37Z

Бугаков Юрий:

Замечания к оформлению статьи:

1. в первой строке указать авторов и их вклад в статью.

2. в пункте 1.6 перенесите Т(n) в одну строку с концом предложения.

3. в пункте 1.9 указать чему соответствуют разные входные и выходные данные. Иначе непонятно будет человеку, который первый раз на сайте.

4. в пункте 2.7 убрать многоточия или заменить их на другие реализации

Участник:Бугаков Юрий/Построение матрицы Адамара произвольной размерности

2016-10-27T14:20:27Z

Бугаков Юрий: /* Входные и выходные данные алгоритма */

Авторы: Бугаков Юрий (613 группа), Кужамалиев Ернур (601 группа).

Бугаков Юрий:

* Пункты 1.1, 1.2, 1.9, 1.10, 2.1, 2.7;
* Совместное обсуждение и работа (подредактирование) над всей статьей в целом с другим автором.

Кужамалиев Ернур:

* Пункты 1.3, 1.4, 1.5, 1.6, 1.7 (рисунки авториские), 1.8;
* Совместное обсуждение и работа (подредактирование) над всей статьей в целом с другим автором.

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O( \left[ \frac{n}{4}\right]\,2^{2n})</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(2^{2n})</math>
| input_data = <math>1</math>
| output_data = <math>2^{2n}</math>
}}

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

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

Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.

Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие

:<math> H_m\,H_m^T = m\,E_m </math>

Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны [1]. Также, можно увидеть из определения, что m четно и
:<math>
H_{2m} =
\begin{pmatrix}
H_{m} & H_{m}\\
H_{m} & -H_{m}\end{pmatrix}
</math>

С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).

Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 (например [2],[3] и [4]). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара следующим образом:

'''Матрица Адамара ''H''''n'' - это матрица размера 2''n'' × 2''n'', для которой справедливо равенство'''

:<math>H_n = H_{1} \otimes H_{n-1}</math>,

:<math>\begin{align}
H_1 = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>,
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''

Представим некоторые частные примеры матриц Адамара:

:<math>
H_0 = +1,
</math>

:<math>
H_1 = \frac{1}{\sqrt2}
\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
</math>,

:<math>
H_2 = \frac{1}{2}
\begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>,

:<math>
H_3 = \frac{1}{2^{\frac{3}{2}}}
\begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>.

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

Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> можно вычислить поэлементно ([3], [4]):

:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,

где ''k''''j'' и ''l''''j'' коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):

: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math>

и
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.

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

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

Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.

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

Основную часть метода составляют вычисления значений степени -1 для каждого элемента:

: <math>\sum_{j=0}^n k_j l_j</math>.

Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.

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

Последовательность исполнения метода следующая:

1. Побитовое умножение <math>k\&l</math>;

2. Вычисление количества единиц двоичной записи;

3. Определение знака элемента по степени.

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

Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма <math> T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}. </math>

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

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

*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный.

[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]

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

Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:
* <math>N^2</math> вычислений побитового умножения,
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,
* <math>N^2</math> для определения знака значения элемента.

Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна <math>O(2^{2n})</math>.

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

'''Входные данные''': натуральное число <math> n \in \N </math> - размерность матрицы Адамара <math>H_n</math>.

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

'''Выходные данные''': матрица Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> (элементы <math>h_{ij}</math>).

'''Объём выходных данных''': <math>2^{2n}</math>, где <math> n </math> - размерность матрицы Адамара. Стоит заметить, что в силу определения или симметричности матрицы Адамара, достаточно хранить не все элементы матрицы.

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

* Соотношение последовательной и параллельной сложности:
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом: <math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.

Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.

Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.
:<math>\frac{T(n)}{T(n,P)}=P</math>.
то есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;

* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right)</math>;

* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размера 2''n'' × 2''n'');

* Степень исхода вершины информационного графа равна 1;

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

=ЧАСТЬ Программная реализация алгоритма =

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

В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:

<source lang="C">
void adamar(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2); // h - нормализующий множитель
N = pow(2,n);

for(i=0;i<N;++i)
{
for(j=0;j<N;++j)
{
ij = i & j;
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij
if(l%2==0) H[i][j] = h;
else H[i][j] = -h;
}
}
}
</source>

Также существует рекурсивная реализация метода построения матрицы Адамара

<source lang="C">
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель
{
if(n==1) H[i][j] = h;
else
{
adamar(H, N/2, i, j, h);
adamar(H, N/2, i, N/2+j, h);
adamar(H, N/2, N/2+i, j, h);
adamar(H, N/2, N/2+i, N/2+j, -h);
}
}
</source>

Или эквивалентный безрекурсивный вариант:

<source lang="C">
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2);
N = pow(2,n);
k=2;
H[0][0] = h;

while(k<=N)
{
for (i=0; i<k; ++i)
{
for (j=0; j<k; ++j)
{
if (i<k/2 && j<k/2)
{
}
else
{
if(i>=k/2 && j>=k/2)
{
H[i][j] = -(H[i-k/2][j-k/2]);
}
else
{
if (i>j)
{
H[i][j] = H[i-k/2][j];
}
else
{
H[i][j] = H[i][j-k/2];
}
}
}
}
}

k=k*2;
}
}
</source>

Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у распараллелинной adamar_not_recursion (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).

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

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

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

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

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

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

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

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

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

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave].

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH].

= Литература =
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.

[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]

[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

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

[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)

Обсуждение участника:Бугаков Юрий

2016-10-27T14:04:20Z

Бугаков Юрий:

Участник:Бугаков Юрий/Построение матрицы Адамара произвольной размерности

2016-10-27T14:02:46Z

Бугаков Юрий:

Авторы: Бугаков Юрий (613 группа), Кужамалиев Ернур (601 группа).

Бугаков Юрий:

* Пункты 1.1, 1.2, 1.9, 1.10, 2.1, 2.7;
* Совместное обсуждение и работа (подредактирование) над всей статьей в целом с другим автором.

Кужамалиев Ернур:

* Пункты 1.3, 1.4, 1.5, 1.6, 1.7 (рисунки авториские), 1.8;
* Совместное обсуждение и работа (подредактирование) над всей статьей в целом с другим автором.

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O( \left[ \frac{n}{4}\right]\,2^{2n})</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(2^{2n})</math>
| input_data = <math>1</math>
| output_data = <math>2^{2n}</math>
}}

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

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

Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.

Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие

:<math> H_m\,H_m^T = m\,E_m </math>

Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны [1]. Также, можно увидеть из определения, что m четно и
:<math>
H_{2m} =
\begin{pmatrix}
H_{m} & H_{m}\\
H_{m} & -H_{m}\end{pmatrix}
</math>

С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).

Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 (например [2],[3] и [4]). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара следующим образом:

'''Матрица Адамара ''H''''n'' - это матрица размера 2''n'' × 2''n'', для которой справедливо равенство'''

:<math>H_n = H_{1} \otimes H_{n-1}</math>,

:<math>\begin{align}
H_1 = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>,
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''

Представим некоторые частные примеры матриц Адамара:

:<math>
H_0 = +1,
</math>

:<math>
H_1 = \frac{1}{\sqrt2}
\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
</math>,

:<math>
H_2 = \frac{1}{2}
\begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>,

:<math>
H_3 = \frac{1}{2^{\frac{3}{2}}}
\begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>.

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

Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> можно вычислить поэлементно ([3], [4]):

:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,

где ''k''''j'' и ''l''''j'' коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):

: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math>

и
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.

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

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

Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.

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

Основную часть метода составляют вычисления значений степени -1 для каждого элемента:

: <math>\sum_{j=0}^n k_j l_j</math>.

Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.

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

Последовательность исполнения метода следующая:

1. Побитовое умножение <math>k\&l</math>;

2. Вычисление количества единиц двоичной записи;

3. Определение знака элемента по степени.

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

Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма <math> T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}. </math>

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

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

*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный.

[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]

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

Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:
* <math>N^2</math> вычислений побитового умножения,
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,
* <math>N^2</math> для определения знака значения элемента.

Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна <math>O(2^{2n})</math>.

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

'''Входные данные''': n - размерность матрицы <math>H_n</math>.

'''Объём входных данных''': 1 (число n).

'''Выходные данные''': матрица Адамара <math>H_n</math> размера <math>2^n\times 2^n</math>.

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

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

* Соотношение последовательной и параллельной сложности:
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом: <math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.

Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.

Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.
:<math>\frac{T(n)}{T(n,P)}=P</math>.
то есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;

* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right)</math>;

* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размера 2''n'' × 2''n'');

* Степень исхода вершины информационного графа равна 1;

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

=ЧАСТЬ Программная реализация алгоритма =

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

В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:

<source lang="C">
void adamar(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2); // h - нормализующий множитель
N = pow(2,n);

for(i=0;i<N;++i)
{
for(j=0;j<N;++j)
{
ij = i & j;
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij
if(l%2==0) H[i][j] = h;
else H[i][j] = -h;
}
}
}
</source>

Также существует рекурсивная реализация метода построения матрицы Адамара

<source lang="C">
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель
{
if(n==1) H[i][j] = h;
else
{
adamar(H, N/2, i, j, h);
adamar(H, N/2, i, N/2+j, h);
adamar(H, N/2, N/2+i, j, h);
adamar(H, N/2, N/2+i, N/2+j, -h);
}
}
</source>

Или эквивалентный безрекурсивный вариант:

<source lang="C">
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2);
N = pow(2,n);
k=2;
H[0][0] = h;

while(k<=N)
{
for (i=0; i<k; ++i)
{
for (j=0; j<k; ++j)
{
if (i<k/2 && j<k/2)
{
}
else
{
if(i>=k/2 && j>=k/2)
{
H[i][j] = -(H[i-k/2][j-k/2]);
}
else
{
if (i>j)
{
H[i][j] = H[i-k/2][j];
}
else
{
H[i][j] = H[i][j-k/2];
}
}
}
}
}

k=k*2;
}
}
</source>

Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у распараллелинной adamar_not_recursion (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).

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

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

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

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

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

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

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

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

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

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave].

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH].

= Литература =
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.

[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]

[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

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

[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)

Участник:Бугаков Юрий/Построение матрицы Адамара произвольной размерности

2016-10-27T14:02:10Z

Бугаков Юрий:

Авторы: Бугаков Юрий (613 группа), Кужамалиев Ернур (601 группа).

Бугаков Юрий:

* Пункты 1.1, 1.2, 1.9, 1.10, 2.1, 2.7;
* Совместное обсуждение и работа (подредактирование) над всей статьей в целом с другим автором.

Кужамалиев Ернур

* Пункты 1.3, 1.4, 1.5, 1.6, 1.7 (рисунки авториские), 1.8;
* Совместное обсуждение и работа (подредактирование) над всей статьей в целом с другим автором.

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O( \left[ \frac{n}{4}\right]\,2^{2n})</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(2^{2n})</math>
| input_data = <math>1</math>
| output_data = <math>2^{2n}</math>
}}

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

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

Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.

Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие

:<math> H_m\,H_m^T = m\,E_m </math>

Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны [1]. Также, можно увидеть из определения, что m четно и
:<math>
H_{2m} =
\begin{pmatrix}
H_{m} & H_{m}\\
H_{m} & -H_{m}\end{pmatrix}
</math>

С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).

Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 (например [2],[3] и [4]). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара следующим образом:

'''Матрица Адамара ''H''''n'' - это матрица размера 2''n'' × 2''n'', для которой справедливо равенство'''

:<math>H_n = H_{1} \otimes H_{n-1}</math>,

:<math>\begin{align}
H_1 = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>,
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''

Представим некоторые частные примеры матриц Адамара:

:<math>
H_0 = +1,
</math>

:<math>
H_1 = \frac{1}{\sqrt2}
\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
</math>,

:<math>
H_2 = \frac{1}{2}
\begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>,

:<math>
H_3 = \frac{1}{2^{\frac{3}{2}}}
\begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>.

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

Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> можно вычислить поэлементно ([3], [4]):

:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,

где ''k''''j'' и ''l''''j'' коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):

: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math>

и
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.

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

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

Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.

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

Основную часть метода составляют вычисления значений степени -1 для каждого элемента:

: <math>\sum_{j=0}^n k_j l_j</math>.

Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.

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

Последовательность исполнения метода следующая:

1. Побитовое умножение <math>k\&l</math>;

2. Вычисление количества единиц двоичной записи;

3. Определение знака элемента по степени.

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

Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма <math> T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}. </math>

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

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

*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный.

[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]

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

Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:
* <math>N^2</math> вычислений побитового умножения,
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,
* <math>N^2</math> для определения знака значения элемента.

Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна <math>O(2^{2n})</math>.

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

'''Входные данные''': n - размерность матрицы <math>H_n</math>.

'''Объём входных данных''': 1 (число n).

'''Выходные данные''': матрица Адамара <math>H_n</math> размера <math>2^n\times 2^n</math>.

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

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

* Соотношение последовательной и параллельной сложности:
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом: <math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.

Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.

Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.
:<math>\frac{T(n)}{T(n,P)}=P</math>.
то есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;

* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right)</math>;

* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размера 2''n'' × 2''n'');

* Степень исхода вершины информационного графа равна 1;

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

=ЧАСТЬ Программная реализация алгоритма =

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

В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:

<source lang="C">
void adamar(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2); // h - нормализующий множитель
N = pow(2,n);

for(i=0;i<N;++i)
{
for(j=0;j<N;++j)
{
ij = i & j;
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij
if(l%2==0) H[i][j] = h;
else H[i][j] = -h;
}
}
}
</source>

Также существует рекурсивная реализация метода построения матрицы Адамара

<source lang="C">
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель
{
if(n==1) H[i][j] = h;
else
{
adamar(H, N/2, i, j, h);
adamar(H, N/2, i, N/2+j, h);
adamar(H, N/2, N/2+i, j, h);
adamar(H, N/2, N/2+i, N/2+j, -h);
}
}
</source>

Или эквивалентный безрекурсивный вариант:

<source lang="C">
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2);
N = pow(2,n);
k=2;
H[0][0] = h;

while(k<=N)
{
for (i=0; i<k; ++i)
{
for (j=0; j<k; ++j)
{
if (i<k/2 && j<k/2)
{
}
else
{
if(i>=k/2 && j>=k/2)
{
H[i][j] = -(H[i-k/2][j-k/2]);
}
else
{
if (i>j)
{
H[i][j] = H[i-k/2][j];
}
else
{
H[i][j] = H[i][j-k/2];
}
}
}
}
}

k=k*2;
}
}
</source>

Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у распараллелинной adamar_not_recursion (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).

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

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

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

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

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

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

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

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

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

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave].

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH].

= Литература =
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.

[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]

[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

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

[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)

Участник:Бугаков Юрий/Построение матрицы Адамара произвольной размерности

2016-10-27T14:01:09Z

Бугаков Юрий:

Авторы: Бугаков Юрий (613 группа), Кужамалиев Ернур (601 группа).

Бугаков Юрий:

* Пункты 1.1, 1.2, 1.10, 2.1, 2.7;
* Совместное обсуждение и работа (подредактирование) над всей статьей в целом с другим автором.

Кужамалиев Ернур

* Пункты 1.3, 1.4, 1.5, 1.6, 1.7 (рисунки авториские), 1.8, 1.9;
* Совместное обсуждение и работа (подредактирование) над всей статьей в целом с другим автором.

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O( \left[ \frac{n}{4}\right]\,2^{2n})</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(2^{2n})</math>
| input_data = <math>1</math>
| output_data = <math>2^{2n}</math>
}}

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

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

Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.

Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие

:<math> H_m\,H_m^T = m\,E_m </math>

Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны [1]. Также, можно увидеть из определения, что m четно и
:<math>
H_{2m} =
\begin{pmatrix}
H_{m} & H_{m}\\
H_{m} & -H_{m}\end{pmatrix}
</math>

С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).

Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 (например [2],[3] и [4]). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара следующим образом:

'''Матрица Адамара ''H''''n'' - это матрица размера 2''n'' × 2''n'', для которой справедливо равенство'''

:<math>H_n = H_{1} \otimes H_{n-1}</math>,

:<math>\begin{align}
H_1 = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>,
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''

Представим некоторые частные примеры матриц Адамара:

:<math>
H_0 = +1,
</math>

:<math>
H_1 = \frac{1}{\sqrt2}
\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
</math>,

:<math>
H_2 = \frac{1}{2}
\begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>,

:<math>
H_3 = \frac{1}{2^{\frac{3}{2}}}
\begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>.

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

Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> можно вычислить поэлементно ([3], [4]):

:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,

где ''k''''j'' и ''l''''j'' коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):

: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math>

и
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.

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

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

Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.

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

Основную часть метода составляют вычисления значений степени -1 для каждого элемента:

: <math>\sum_{j=0}^n k_j l_j</math>.

Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.

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

Последовательность исполнения метода следующая:

1. Побитовое умножение <math>k\&l</math>;

2. Вычисление количества единиц двоичной записи;

3. Определение знака элемента по степени.

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

Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма <math> T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}. </math>

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

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

*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный.

[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]

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

Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:
* <math>N^2</math> вычислений побитового умножения,
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,
* <math>N^2</math> для определения знака значения элемента.

Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна <math>O(2^{2n})</math>.

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

'''Входные данные''': n - размерность матрицы <math>H_n</math>.

'''Объём входных данных''': 1 (число n).

'''Выходные данные''': матрица Адамара <math>H_n</math> размера <math>2^n\times 2^n</math>.

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

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

* Соотношение последовательной и параллельной сложности:
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом: <math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.

Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.

Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.
:<math>\frac{T(n)}{T(n,P)}=P</math>.
то есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;

* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right)</math>;

* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размера 2''n'' × 2''n'');

* Степень исхода вершины информационного графа равна 1;

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

=ЧАСТЬ Программная реализация алгоритма =

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

В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:

<source lang="C">
void adamar(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2); // h - нормализующий множитель
N = pow(2,n);

for(i=0;i<N;++i)
{
for(j=0;j<N;++j)
{
ij = i & j;
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij
if(l%2==0) H[i][j] = h;
else H[i][j] = -h;
}
}
}
</source>

Также существует рекурсивная реализация метода построения матрицы Адамара

<source lang="C">
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель
{
if(n==1) H[i][j] = h;
else
{
adamar(H, N/2, i, j, h);
adamar(H, N/2, i, N/2+j, h);
adamar(H, N/2, N/2+i, j, h);
adamar(H, N/2, N/2+i, N/2+j, -h);
}
}
</source>

Или эквивалентный безрекурсивный вариант:

<source lang="C">
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2);
N = pow(2,n);
k=2;
H[0][0] = h;

while(k<=N)
{
for (i=0; i<k; ++i)
{
for (j=0; j<k; ++j)
{
if (i<k/2 && j<k/2)
{
}
else
{
if(i>=k/2 && j>=k/2)
{
H[i][j] = -(H[i-k/2][j-k/2]);
}
else
{
if (i>j)
{
H[i][j] = H[i-k/2][j];
}
else
{
H[i][j] = H[i][j-k/2];
}
}
}
}
}

k=k*2;
}
}
</source>

Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у распараллелинной adamar_not_recursion (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).

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

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

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

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

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

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

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

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

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

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave].

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH].

= Литература =
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.

[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]

[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

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

[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)

Участник:Бугаков Юрий/Построение матрицы Адамара произвольной размерности

2016-10-27T14:00:40Z

Бугаков Юрий:

Авторы: Бугаков Юрий (613 группа), Кужамалиев Ернур (601 группа).

Бугаков Юрий:

* Пункты 1.1, 1.2, 1.10, 2.1, 2.7;
* Совместное обсуждения и работа (подредактирование) над всей статьей в целом с другим автором.

Кужамалиев Ернур

* Пункты 1.3, 1.4, 1.5, 1.6, 1.7 (рисунки авториские), 1.8, 1.9;
* Совместное обсуждения и работа (подредактирование) над всей статьей в целом с другим автором.

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O( \left[ \frac{n}{4}\right]\,2^{2n})</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(2^{2n})</math>
| input_data = <math>1</math>
| output_data = <math>2^{2n}</math>
}}

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

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

Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.

Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие

:<math> H_m\,H_m^T = m\,E_m </math>

Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны [1]. Также, можно увидеть из определения, что m четно и
:<math>
H_{2m} =
\begin{pmatrix}
H_{m} & H_{m}\\
H_{m} & -H_{m}\end{pmatrix}
</math>

С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).

Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 (например [2],[3] и [4]). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара следующим образом:

'''Матрица Адамара ''H''''n'' - это матрица размера 2''n'' × 2''n'', для которой справедливо равенство'''

:<math>H_n = H_{1} \otimes H_{n-1}</math>,

:<math>\begin{align}
H_1 = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>,
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''

Представим некоторые частные примеры матриц Адамара:

:<math>
H_0 = +1,
</math>

:<math>
H_1 = \frac{1}{\sqrt2}
\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
</math>,

:<math>
H_2 = \frac{1}{2}
\begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>,

:<math>
H_3 = \frac{1}{2^{\frac{3}{2}}}
\begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>.

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

Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> можно вычислить поэлементно ([3], [4]):

:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,

где ''k''''j'' и ''l''''j'' коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):

: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math>

и
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.

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

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

Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.

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

Основную часть метода составляют вычисления значений степени -1 для каждого элемента:

: <math>\sum_{j=0}^n k_j l_j</math>.

Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.

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

Последовательность исполнения метода следующая:

1. Побитовое умножение <math>k\&l</math>;

2. Вычисление количества единиц двоичной записи;

3. Определение знака элемента по степени.

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

Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма <math> T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}. </math>

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

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

*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный.

[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]

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

Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:
* <math>N^2</math> вычислений побитового умножения,
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,
* <math>N^2</math> для определения знака значения элемента.

Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна <math>O(2^{2n})</math>.

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

'''Входные данные''': n - размерность матрицы <math>H_n</math>.

'''Объём входных данных''': 1 (число n).

'''Выходные данные''': матрица Адамара <math>H_n</math> размера <math>2^n\times 2^n</math>.

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

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

* Соотношение последовательной и параллельной сложности:
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом: <math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.

Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.

Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.
:<math>\frac{T(n)}{T(n,P)}=P</math>.
то есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;

* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right)</math>;

* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размера 2''n'' × 2''n'');

* Степень исхода вершины информационного графа равна 1;

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

=ЧАСТЬ Программная реализация алгоритма =

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

В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:

<source lang="C">
void adamar(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2); // h - нормализующий множитель
N = pow(2,n);

for(i=0;i<N;++i)
{
for(j=0;j<N;++j)
{
ij = i & j;
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij
if(l%2==0) H[i][j] = h;
else H[i][j] = -h;
}
}
}
</source>

Также существует рекурсивная реализация метода построения матрицы Адамара

<source lang="C">
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель
{
if(n==1) H[i][j] = h;
else
{
adamar(H, N/2, i, j, h);
adamar(H, N/2, i, N/2+j, h);
adamar(H, N/2, N/2+i, j, h);
adamar(H, N/2, N/2+i, N/2+j, -h);
}
}
</source>

Или эквивалентный безрекурсивный вариант:

<source lang="C">
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2);
N = pow(2,n);
k=2;
H[0][0] = h;

while(k<=N)
{
for (i=0; i<k; ++i)
{
for (j=0; j<k; ++j)
{
if (i<k/2 && j<k/2)
{
}
else
{
if(i>=k/2 && j>=k/2)
{
H[i][j] = -(H[i-k/2][j-k/2]);
}
else
{
if (i>j)
{
H[i][j] = H[i-k/2][j];
}
else
{
H[i][j] = H[i][j-k/2];
}
}
}
}
}

k=k*2;
}
}
</source>

Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у распараллелинной adamar_not_recursion (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).

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

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

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

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

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

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

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

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

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

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave].

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH].

= Литература =
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.

[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]

[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

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

[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)

Участник:Бугаков Юрий/Построение матрицы Адамара произвольной размерности

2016-10-27T13:41:40Z

Бугаков Юрий: /* Последовательная сложность алгоритма */

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O( \left[ \frac{n}{4}\right]\,2^{2n})</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(2^{2n})</math>
| input_data = <math>1</math>
| output_data = <math>2^{2n}</math>
}}

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

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

Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.

Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие

:<math> H_m\,H_m^T = m\,E_m </math>

Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны [1]. Также, можно увидеть из определения, что m четно и
:<math>
H_{2m} =
\begin{pmatrix}
H_{m} & H_{m}\\
H_{m} & -H_{m}\end{pmatrix}
</math>

С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).

Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 (например [2],[3] и [4]). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара следующим образом:

'''Матрица Адамара ''H''''n'' - это матрица размера 2''n'' × 2''n'', для которой справедливо равенство'''

:<math>H_n = H_{1} \otimes H_{n-1}</math>,

:<math>\begin{align}
H_1 = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>,
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''

Представим некоторые частные примеры матриц Адамара:

:<math>
H_0 = +1,
</math>

:<math>
H_1 = \frac{1}{\sqrt2}
\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
</math>,

:<math>
H_2 = \frac{1}{2}
\begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>,

:<math>
H_3 = \frac{1}{2^{\frac{3}{2}}}
\begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>.

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

Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> можно вычислить поэлементно ([3], [4]):

:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,

где ''k''''j'' и ''l''''j'' коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):

: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math>

и
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.

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

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

Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.

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

Основную часть метода составляют вычисления значений степени -1 для каждого элемента:

: <math>\sum_{j=0}^n k_j l_j</math>.

Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.

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

Последовательность исполнения метода следующая:

1. Побитовое умножение <math>k\&l</math>;

2. Вычисление количества единиц двоичной записи;

3. Определение знака элемента по степени.

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

Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма <math> T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}. </math>

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

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

*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный.

[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]

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

Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:
* <math>N^2</math> вычислений побитового умножения,
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,
* <math>N^2</math> для определения знака значения элемента.

Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна <math>O(2^{2n})</math>.

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

'''Входные данные''': n - размерность матрицы <math>H_n</math>.

'''Объём входных данных''': 1 (число n).

'''Выходные данные''': матрица Адамара <math>H_n</math> размера <math>2^n\times 2^n</math>.

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

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

* Соотношение последовательной и параллельной сложности:
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом: <math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.

Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.

Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.
:<math>\frac{T(n)}{T(n,P)}=P</math>.
то есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;

* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right)</math>;

* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размера 2''n'' × 2''n'');

* Степень исхода вершины информационного графа равна 1;

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

=ЧАСТЬ Программная реализация алгоритма =

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

В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:

<source lang="C">
void adamar(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2); // h - нормализующий множитель
N = pow(2,n);

for(i=0;i<N;++i)
{
for(j=0;j<N;++j)
{
ij = i & j;
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij
if(l%2==0) H[i][j] = h;
else H[i][j] = -h;
}
}
}
</source>

Также существует рекурсивная реализация метода построения матрицы Адамара

<source lang="C">
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель
{
if(n==1) H[i][j] = h;
else
{
adamar(H, N/2, i, j, h);
adamar(H, N/2, i, N/2+j, h);
adamar(H, N/2, N/2+i, j, h);
adamar(H, N/2, N/2+i, N/2+j, -h);
}
}
</source>

Или эквивалентный безрекурсивный вариант:

<source lang="C">
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2);
N = pow(2,n);
k=2;
H[0][0] = h;

while(k<=N)
{
for (i=0; i<k; ++i)
{
for (j=0; j<k; ++j)
{
if (i<k/2 && j<k/2)
{
}
else
{
if(i>=k/2 && j>=k/2)
{
H[i][j] = -(H[i-k/2][j-k/2]);
}
else
{
if (i>j)
{
H[i][j] = H[i-k/2][j];
}
else
{
H[i][j] = H[i][j-k/2];
}
}
}
}
}

k=k*2;
}
}
</source>

Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у распараллелинной adamar_not_recursion (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).

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

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

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

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

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

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

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

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

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

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave].

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH].

= Литература =
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.

[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]

[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

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

[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)

Участник:Бугаков Юрий/Построение матрицы Адамара произвольной размерности

2016-10-27T13:40:43Z

Бугаков Юрий: /* Свойства алгоритма */

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O( \left[ \frac{n}{4}\right]\,2^{2n})</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(2^{2n})</math>
| input_data = <math>1</math>
| output_data = <math>2^{2n}</math>
}}

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

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

Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.

Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие

:<math> H_m\,H_m^T = m\,E_m </math>

Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны [1]. Также, можно увидеть из определения, что m четно и
:<math>
H_{2m} =
\begin{pmatrix}
H_{m} & H_{m}\\
H_{m} & -H_{m}\end{pmatrix}
</math>

С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).

Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 (например [2],[3] и [4]). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара следующим образом:

'''Матрица Адамара ''H''''n'' - это матрица размера 2''n'' × 2''n'', для которой справедливо равенство'''

:<math>H_n = H_{1} \otimes H_{n-1}</math>,

:<math>\begin{align}
H_1 = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>,
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''

Представим некоторые частные примеры матриц Адамара:

:<math>
H_0 = +1,
</math>

:<math>
H_1 = \frac{1}{\sqrt2}
\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
</math>,

:<math>
H_2 = \frac{1}{2}
\begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>,

:<math>
H_3 = \frac{1}{2^{\frac{3}{2}}}
\begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>.

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

Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> можно вычислить поэлементно ([3], [4]):

:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,

где ''k''''j'' и ''l''''j'' коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):

: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math>

и
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.

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

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

Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.

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

Основную часть метода составляют вычисления значений степени -1 для каждого элемента:

: <math>\sum_{j=0}^n k_j l_j</math>.

Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.

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

Последовательность исполнения метода следующая:

1. Побитовое умножение <math>k\&l</math>;

2. Вычисление количества единиц двоичной записи;

3. Определение знака элемента по степени.

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

Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма

:<math>
T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}.
</math>

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

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

*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный.

[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]

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

Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:
* <math>N^2</math> вычислений побитового умножения,
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,
* <math>N^2</math> для определения знака значения элемента.

Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна <math>O(2^{2n})</math>.

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

'''Входные данные''': n - размерность матрицы <math>H_n</math>.

'''Объём входных данных''': 1 (число n).

'''Выходные данные''': матрица Адамара <math>H_n</math> размера <math>2^n\times 2^n</math>.

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

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

* Соотношение последовательной и параллельной сложности:
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом: <math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.

Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.

Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.
:<math>\frac{T(n)}{T(n,P)}=P</math>.
то есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;

* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right)</math>;

* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размера 2''n'' × 2''n'');

* Степень исхода вершины информационного графа равна 1;

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

=ЧАСТЬ Программная реализация алгоритма =

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

В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:

<source lang="C">
void adamar(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2); // h - нормализующий множитель
N = pow(2,n);

for(i=0;i<N;++i)
{
for(j=0;j<N;++j)
{
ij = i & j;
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij
if(l%2==0) H[i][j] = h;
else H[i][j] = -h;
}
}
}
</source>

Также существует рекурсивная реализация метода построения матрицы Адамара

<source lang="C">
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель
{
if(n==1) H[i][j] = h;
else
{
adamar(H, N/2, i, j, h);
adamar(H, N/2, i, N/2+j, h);
adamar(H, N/2, N/2+i, j, h);
adamar(H, N/2, N/2+i, N/2+j, -h);
}
}
</source>

Или эквивалентный безрекурсивный вариант:

<source lang="C">
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2);
N = pow(2,n);
k=2;
H[0][0] = h;

while(k<=N)
{
for (i=0; i<k; ++i)
{
for (j=0; j<k; ++j)
{
if (i<k/2 && j<k/2)
{
}
else
{
if(i>=k/2 && j>=k/2)
{
H[i][j] = -(H[i-k/2][j-k/2]);
}
else
{
if (i>j)
{
H[i][j] = H[i-k/2][j];
}
else
{
H[i][j] = H[i][j-k/2];
}
}
}
}
}

k=k*2;
}
}
</source>

Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у распараллелинной adamar_not_recursion (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).

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

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

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

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

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

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

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

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

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

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave].

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH].

= Литература =
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.

[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]

[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

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

[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)

Участник:Бугаков Юрий/Построение матрицы Адамара произвольной размерности

2016-10-27T13:38:42Z

Бугаков Юрий: /* Существующие реализации алгоритма */

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O( \left[ \frac{n}{4}\right]\,2^{2n})</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(2^{2n})</math>
| input_data = <math>1</math>
| output_data = <math>2^{2n}</math>
}}

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

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

Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.

Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие

:<math> H_m\,H_m^T = m\,E_m </math>

Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны [1]. Также, можно увидеть из определения, что m четно и
:<math>
H_{2m} =
\begin{pmatrix}
H_{m} & H_{m}\\
H_{m} & -H_{m}\end{pmatrix}
</math>

С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).

Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 (например [2],[3] и [4]). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара следующим образом:

'''Матрица Адамара ''H''''n'' - это матрица размера 2''n'' × 2''n'', для которой справедливо равенство'''

:<math>H_n = H_{1} \otimes H_{n-1}</math>,

:<math>\begin{align}
H_1 = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>,
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''

Представим некоторые частные примеры матриц Адамара:

:<math>
H_0 = +1,
</math>

:<math>
H_1 = \frac{1}{\sqrt2}
\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
</math>,

:<math>
H_2 = \frac{1}{2}
\begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>,

:<math>
H_3 = \frac{1}{2^{\frac{3}{2}}}
\begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>.

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

Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> можно вычислить поэлементно ([3], [4]):

:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,

где ''k''''j'' и ''l''''j'' коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):

: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math>

и
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.

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

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

Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.

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

Основную часть метода составляют вычисления значений степени -1 для каждого элемента:

: <math>\sum_{j=0}^n k_j l_j</math>.

Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.

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

Последовательность исполнения метода следующая:

1. Побитовое умножение <math>k\&l</math>;

2. Вычисление количества единиц двоичной записи;

3. Определение знака элемента по степени.

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

Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма

:<math>
T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}.
</math>

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

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

*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный.

[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]

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

Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:
* <math>N^2</math> вычислений побитового умножения,
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,
* <math>N^2</math> для определения знака значения элемента.

Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна <math>O(2^{2n})</math>.

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

'''Входные данные''': n - размерность матрицы <math>H_n</math>.

'''Объём входных данных''': 1 (число n).

'''Выходные данные''': матрица Адамара <math>H_n</math> размера <math>2^n\times 2^n</math>.

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

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

* Соотношение последовательной и параллельной сложности:
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом:

:<math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.

Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.

Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.
:<math>\frac{T(n)}{T(n,P)}=P</math>.
то есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;

* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right)</math>;

* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размера 2''n'' × 2''n'');

* Степень исхода вершины информационного графа равна 1;

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

=ЧАСТЬ Программная реализация алгоритма =

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

В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:

<source lang="C">
void adamar(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2); // h - нормализующий множитель
N = pow(2,n);

for(i=0;i<N;++i)
{
for(j=0;j<N;++j)
{
ij = i & j;
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij
if(l%2==0) H[i][j] = h;
else H[i][j] = -h;
}
}
}
</source>

Также существует рекурсивная реализация метода построения матрицы Адамара

<source lang="C">
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель
{
if(n==1) H[i][j] = h;
else
{
adamar(H, N/2, i, j, h);
adamar(H, N/2, i, N/2+j, h);
adamar(H, N/2, N/2+i, j, h);
adamar(H, N/2, N/2+i, N/2+j, -h);
}
}
</source>

Или эквивалентный безрекурсивный вариант:

<source lang="C">
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2);
N = pow(2,n);
k=2;
H[0][0] = h;

while(k<=N)
{
for (i=0; i<k; ++i)
{
for (j=0; j<k; ++j)
{
if (i<k/2 && j<k/2)
{
}
else
{
if(i>=k/2 && j>=k/2)
{
H[i][j] = -(H[i-k/2][j-k/2]);
}
else
{
if (i>j)
{
H[i][j] = H[i-k/2][j];
}
else
{
H[i][j] = H[i][j-k/2];
}
}
}
}
}

k=k*2;
}
}
</source>

Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у распараллелинной adamar_not_recursion (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).

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

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

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

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

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

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

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

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

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

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave].

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH].

= Литература =
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.

[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]

[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

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

[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)

Участник:Бугаков Юрий/Построение матрицы Адамара произвольной размерности

2016-10-20T17:41:26Z

Бугаков Юрий: /* Ресурс параллелизма алгоритма */

{{Assignment}}

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O( \left[ \frac{n}{4}\right]\,2^{2n})</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(2^{2n})</math>
| input_data = <math>1</math>
| output_data = <math>2^{2n}</math>
}}

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

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

Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.

Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие

:<math> H_m\,H_m^T = m\,E_m </math>

Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны [1]. Также, можно увидеть из определения, что m четно и
:<math>
H_{2m} =
\begin{pmatrix}
H_{m} & H_{m}\\
H_{m} & -H_{m}\end{pmatrix}
</math>

С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).

Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 (например [2],[3] и [4]). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара следующим образом:

'''Матрица Адамара ''H''''n'' - это матрица размера 2''n'' × 2''n'', для которой справедливо равенство'''

:<math>H_n = H_{1} \otimes H_{n-1}</math>,

:<math>\begin{align}
H_1 = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>,
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''

Представим некоторые частные примеры матриц Адамара:

:<math>
H_0 = +1,
</math>

:<math>
H_1 = \frac{1}{\sqrt2}
\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
</math>,

:<math>
H_2 = \frac{1}{2}
\begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>,

:<math>
H_3 = \frac{1}{2^{\frac{3}{2}}}
\begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>.

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

Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> можно вычислить поэлементно ([3], [4]):

:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,

где ''k''''j'' и ''l''''j'' коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):

: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math>

и
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.

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

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

Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.

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

Основную часть метода составляют вычисления значений степени -1 для каждого элемента:

: <math>\sum_{j=0}^n k_j l_j</math>.

Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.

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

Последовательность исполнения метода следующая:

1. Побитовое умножение <math>k\&l</math>;

2. Вычисление количества единиц двоичной записи;

3. Определение знака элемента по степени.

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

Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма

:<math>
T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}.
</math>

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

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

*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный.

[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]

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

Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:
* <math>N^2</math> вычислений побитового умножения,
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,
* <math>N^2</math> для определения знака значения элемента.

Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна <math>O(2^{2n})</math>.

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

'''Входные данные''': n - размерность матрицы <math>H_n</math>.

'''Объём входных данных''': 1 (число n).

'''Выходные данные''': матрица Адамара <math>H_n</math> размера <math>2^n\times 2^n</math>.

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

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

* Соотношение последовательной и параллельной сложности:
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом:

:<math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.

Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.

Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.
:<math>\frac{T(n)}{T(n,P)}=P</math>.
то есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;

* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right)</math>;

* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размера 2''n'' × 2''n'');

* Степень исхода вершины информационного графа равна 1;

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

=ЧАСТЬ Программная реализация алгоритма =

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

В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:

<source lang="C">
void adamar(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2); // h - нормализующий множитель
N = pow(2,n);

for(i=0;i<N;++i)
{
for(j=0;j<N;++j)
{
ij = i & j;
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij
if(l%2==0) H[i][j] = h;
else H[i][j] = -h;
}
}
}
</source>

Также существует рекурсивная реализация метода построения матрицы Адамара

<source lang="C">
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель
{
if(n==1) H[i][j] = h;
else
{
adamar(H, N/2, i, j, h);
adamar(H, N/2, i, N/2+j, h);
adamar(H, N/2, N/2+i, j, h);
adamar(H, N/2, N/2+i, N/2+j, -h);
}
}
</source>

Или эквивалентный безрекурсивный вариант:

<source lang="C">
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2);
N = pow(2,n);
k=2;
H[0][0] = h;

while(k<=N)
{
for (i=0; i<k; ++i)
{
for (j=0; j<k; ++j)
{
if (i<k/2 && j<k/2)
{
}
else
{
if(i>=k/2 && j>=k/2)
{
H[i][j] = -(H[i-k/2][j-k/2]);
}
else
{
if (i>j)
{
H[i][j] = H[i-k/2][j];
}
else
{
H[i][j] = H[i][j-k/2];
}
}
}
}
}

k=k*2;
}
}
</source>

Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у распараллелинной adamar_not_recursion (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).

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

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

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

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

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

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

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

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

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

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave];
# ...

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH];
# ...

= Литература =
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.

[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]

[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

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

[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)

Участник:Бугаков Юрий/Построение матрицы Адамара произвольной размерности

2016-10-20T17:40:33Z

Бугаков Юрий: /* Математическое описание алгоритма */

{{Assignment}}

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O( \left[ \frac{n}{4}\right]\,2^{2n})</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(2^{2n})</math>
| input_data = <math>1</math>
| output_data = <math>2^{2n}</math>
}}

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

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

Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.

Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие

:<math> H_m\,H_m^T = m\,E_m </math>

Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны [1]. Также, можно увидеть из определения, что m четно и
:<math>
H_{2m} =
\begin{pmatrix}
H_{m} & H_{m}\\
H_{m} & -H_{m}\end{pmatrix}
</math>

С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).

Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 (например [2],[3] и [4]). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара следующим образом:

'''Матрица Адамара ''H''''n'' - это матрица размера 2''n'' × 2''n'', для которой справедливо равенство'''

:<math>H_n = H_{1} \otimes H_{n-1}</math>,

:<math>\begin{align}
H_1 = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>,
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''

Представим некоторые частные примеры матриц Адамара:

:<math>
H_0 = +1,
</math>

:<math>
H_1 = \frac{1}{\sqrt2}
\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
</math>,

:<math>
H_2 = \frac{1}{2}
\begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>,

:<math>
H_3 = \frac{1}{2^{\frac{3}{2}}}
\begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>.

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

Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math> размера <math>2^n\times 2^n</math> можно вычислить поэлементно ([3], [4]):

:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,

где ''k''''j'' и ''l''''j'' коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):

: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math>

и
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.

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

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

Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.

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

Основную часть метода составляют вычисления значений степени -1 для каждого элемента:

: <math>\sum_{j=0}^n k_j l_j</math>.

Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.

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

Последовательность исполнения метода следующая:

1. Побитовое умножение <math>k\&l</math>;

2. Вычисление количества единиц двоичной записи;

3. Определение знака элемента по степени.

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

Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма

:<math>
T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}.
</math>

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

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

*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный.

[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]

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

Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:
* <math>N^2</math> вычислений побитового умножения,
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,
* <math>N^2</math> для определения знака значения элемента.

Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна <math>O(n^2)</math>.

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

'''Входные данные''': n - размерность матрицы <math>H_n</math>.

'''Объём входных данных''': 1 (число n).

'''Выходные данные''': матрица Адамара <math>H_n</math> размера <math>2^n\times 2^n</math>.

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

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

* Соотношение последовательной и параллельной сложности:
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом:

:<math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.

Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.

Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.
:<math>\frac{T(n)}{T(n,P)}=P</math>.
то есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;

* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right)</math>;

* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размера 2''n'' × 2''n'');

* Степень исхода вершины информационного графа равна 1;

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

=ЧАСТЬ Программная реализация алгоритма =

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

В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:

<source lang="C">
void adamar(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2); // h - нормализующий множитель
N = pow(2,n);

for(i=0;i<N;++i)
{
for(j=0;j<N;++j)
{
ij = i & j;
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij
if(l%2==0) H[i][j] = h;
else H[i][j] = -h;
}
}
}
</source>

Также существует рекурсивная реализация метода построения матрицы Адамара

<source lang="C">
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель
{
if(n==1) H[i][j] = h;
else
{
adamar(H, N/2, i, j, h);
adamar(H, N/2, i, N/2+j, h);
adamar(H, N/2, N/2+i, j, h);
adamar(H, N/2, N/2+i, N/2+j, -h);
}
}
</source>

Или эквивалентный безрекурсивный вариант:

<source lang="C">
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2);
N = pow(2,n);
k=2;
H[0][0] = h;

while(k<=N)
{
for (i=0; i<k; ++i)
{
for (j=0; j<k; ++j)
{
if (i<k/2 && j<k/2)
{
}
else
{
if(i>=k/2 && j>=k/2)
{
H[i][j] = -(H[i-k/2][j-k/2]);
}
else
{
if (i>j)
{
H[i][j] = H[i-k/2][j];
}
else
{
H[i][j] = H[i][j-k/2];
}
}
}
}
}

k=k*2;
}
}
</source>

Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у распараллелинной adamar_not_recursion (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).

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

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

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

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

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

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

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

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

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

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave];
# ...

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH];
# ...

= Литература =
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.

[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]

[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

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

[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)

Участник:Бугаков Юрий/Построение матрицы Адамара произвольной размерности

2016-10-20T17:39:50Z

Бугаков Юрий: /* Особенности реализации последовательного алгоритма */

{{Assignment}}

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O( \left[ \frac{n}{4}\right]\,2^{2n})</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(2^{2n})</math>
| input_data = <math>1</math>
| output_data = <math>2^{2n}</math>
}}

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

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

Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.

Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие

:<math> H_m\,H_m^T = m\,E_m </math>

Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны [1]. Также, можно увидеть из определения, что m четно и
:<math>
H_{2m} =
\begin{pmatrix}
H_{m} & H_{m}\\
H_{m} & -H_{m}\end{pmatrix}
</math>

С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).

Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 (например [2],[3] и [4]). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара следующим образом:

'''Матрица Адамара ''H''''n'' - это матрица размера 2''n'' × 2''n'', для которой справедливо равенство'''

:<math>H_n = H_{1} \otimes H_{n-1}</math>,

:<math>\begin{align}
H_1 = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>,
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''

Представим некоторые частные примеры матриц Адамара:

:<math>
H_0 = +1,
</math>

:<math>
H_1 = \frac{1}{\sqrt2}
\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
</math>,

:<math>
H_2 = \frac{1}{2}
\begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>,

:<math>
H_3 = \frac{1}{2^{\frac{3}{2}}}
\begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>.

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

Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math>, размерностью <math>2^n\times 2^n</math> можно вычислить поэлементно ([3], [4]):

:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,

где ''k''''j'' и ''l''''j'' коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):

: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math>

и
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.

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

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

Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.

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

Основную часть метода составляют вычисления значений степени -1 для каждого элемента:

: <math>\sum_{j=0}^n k_j l_j</math>.

Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.

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

Последовательность исполнения метода следующая:

1. Побитовое умножение <math>k\&l</math>;

2. Вычисление количества единиц двоичной записи;

3. Определение знака элемента по степени.

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

Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма

:<math>
T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}.
</math>

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

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

*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный.

[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]

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

Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:
* <math>N^2</math> вычислений побитового умножения,
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,
* <math>N^2</math> для определения знака значения элемента.

Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна <math>O(n^2)</math>.

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

'''Входные данные''': n - размерность матрицы <math>H_n</math>.

'''Объём входных данных''': 1 (число n).

'''Выходные данные''': матрица Адамара <math>H_n</math> размера <math>2^n\times 2^n</math>.

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

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

* Соотношение последовательной и параллельной сложности:
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом:

:<math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.

Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.

Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.
:<math>\frac{T(n)}{T(n,P)}=P</math>.
то есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;

* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right)</math>;

* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размера 2''n'' × 2''n'');

* Степень исхода вершины информационного графа равна 1;

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

=ЧАСТЬ Программная реализация алгоритма =

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

В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:

<source lang="C">
void adamar(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2); // h - нормализующий множитель
N = pow(2,n);

for(i=0;i<N;++i)
{
for(j=0;j<N;++j)
{
ij = i & j;
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij
if(l%2==0) H[i][j] = h;
else H[i][j] = -h;
}
}
}
</source>

Также существует рекурсивная реализация метода построения матрицы Адамара

<source lang="C">
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель
{
if(n==1) H[i][j] = h;
else
{
adamar(H, N/2, i, j, h);
adamar(H, N/2, i, N/2+j, h);
adamar(H, N/2, N/2+i, j, h);
adamar(H, N/2, N/2+i, N/2+j, -h);
}
}
</source>

Или эквивалентный безрекурсивный вариант:

<source lang="C">
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2);
N = pow(2,n);
k=2;
H[0][0] = h;

while(k<=N)
{
for (i=0; i<k; ++i)
{
for (j=0; j<k; ++j)
{
if (i<k/2 && j<k/2)
{
}
else
{
if(i>=k/2 && j>=k/2)
{
H[i][j] = -(H[i-k/2][j-k/2]);
}
else
{
if (i>j)
{
H[i][j] = H[i-k/2][j];
}
else
{
H[i][j] = H[i][j-k/2];
}
}
}
}
}

k=k*2;
}
}
</source>

Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у распараллелинной adamar_not_recursion (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).

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

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

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

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

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

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

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

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

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

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave];
# ...

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH];
# ...

= Литература =
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.

[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]

[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

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

[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)

Участник:Бугаков Юрий/Построение матрицы Адамара произвольной размерности

2016-10-20T17:38:00Z

Бугаков Юрий: /* Особенности реализации последовательного алгоритма */

{{Assignment}}

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O( \left[ \frac{n}{4}\right]\,2^{2n})</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(2^{2n})</math>
| input_data = <math>1</math>
| output_data = <math>2^{2n}</math>
}}

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

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

Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.

Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие

:<math> H_m\,H_m^T = m\,E_m </math>

Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны [1]. Также, можно увидеть из определения, что m четно и
:<math>
H_{2m} =
\begin{pmatrix}
H_{m} & H_{m}\\
H_{m} & -H_{m}\end{pmatrix}
</math>

С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).

Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 (например [2],[3] и [4]). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара следующим образом:

'''Матрица Адамара ''H''''n'' - это матрица размера 2''n'' × 2''n'', для которой справедливо равенство'''

:<math>H_n = H_{1} \otimes H_{n-1}</math>,

:<math>\begin{align}
H_1 = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>,
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''

Представим некоторые частные примеры матриц Адамара:

:<math>
H_0 = +1,
</math>

:<math>
H_1 = \frac{1}{\sqrt2}
\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
</math>,

:<math>
H_2 = \frac{1}{2}
\begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>,

:<math>
H_3 = \frac{1}{2^{\frac{3}{2}}}
\begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>.

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

Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math>, размерностью <math>2^n\times 2^n</math> можно вычислить поэлементно ([3], [4]):

:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,

где ''k''''j'' и ''l''''j'' коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):

: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math>

и
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.

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

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

Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.

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

Основную часть метода составляют вычисления значений степени -1 для каждого элемента:

: <math>\sum_{j=0}^n k_j l_j</math>.

Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.

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

Последовательность исполнения метода следующая:

1. Побитовое умножение <math>k\&l</math>;

2. Вычисление количества единиц двоичной записи;

3. Определение знака элемента по степени.

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

Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма

:<math>
T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}.
</math>

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

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

*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный.

[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]

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

Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:
* <math>N^2</math> вычислений побитового умножения,
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,
* <math>N^2</math> для определения знака значения элемента.

Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна <math>O(n^2)</math>.

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

'''Входные данные''': n - размерность матрицы <math>H_n</math>.

'''Объём входных данных''': 1 (число n).

'''Выходные данные''': матрица Адамара <math>H_n</math> размера <math>2^n\times 2^n</math>.

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

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

* Соотношение последовательной и параллельной сложности:
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом:

:<math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.

Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.

Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.
:<math>\frac{T(n)}{T(n,P)}=P</math>.
то есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;

* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right)</math>;

* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размера 2''n'' × 2''n'');

* Степень исхода вершины информационного графа равна 1;

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

=ЧАСТЬ Программная реализация алгоритма =

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

В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:

<source lang="C">
void adamar(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2); // h - нормализующий множитель
N = pow(2,n);

for(i=0;i<N;++i)
{
for(j=0;j<N;++j)
{
ij = i & j;
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij
if(l%2==0) H[i][j] = h;
else H[i][j] = -h;
}
}
}
</source>

Также существует рекурсивная реализация метода построения матрицы Адамара

<source lang="C">
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель
{
if(n==1) H[i][j] = h;
else
{
adamar(H, N/2, i, j, h);
adamar(H, N/2, i, N/2+j, h);
adamar(H, N/2, N/2+i, j, h);
adamar(H, N/2, N/2+i, N/2+j, -h);
}
}
</source>

Или эквивалентный безрекурсивный вариант:

<source lang="C">
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2);
N = pow(2,n);
k=2;
H[0][0] = h;

while(k<=N)
{
for (i=0; i<k; ++i)
{
for (j=0; j<k; ++j)
{
if (i<k/2 && j<k/2)
{
}
else
{
if(i>=k/2 && j>=k/2)
{
H[i][j] = -(H[i-k/2][j-k/2]);
}
else
{
if (i>j)
{
H[i][j] = H[i-k/2][j];
}
else
{
H[i][j] = H[i][j-k/2];
}
}
}
}
}

k=k*2;
}
}
</source>

Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у распараллеливанной adamar_not_recursion (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).

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

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

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

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

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

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

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

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

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

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave];
# ...

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH];
# ...

= Литература =
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.

[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]

[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

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

[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)

Участник:Бугаков Юрий/Построение матрицы Адамара произвольной размерности

2016-10-20T17:37:12Z

Бугаков Юрий: /* Свойства алгоритма */

{{Assignment}}

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O( \left[ \frac{n}{4}\right]\,2^{2n})</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(2^{2n})</math>
| input_data = <math>1</math>
| output_data = <math>2^{2n}</math>
}}

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

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

Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.

Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие

:<math> H_m\,H_m^T = m\,E_m </math>

Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны [1]. Также, можно увидеть из определения, что m четно и
:<math>
H_{2m} =
\begin{pmatrix}
H_{m} & H_{m}\\
H_{m} & -H_{m}\end{pmatrix}
</math>

С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).

Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 (например [2],[3] и [4]). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара следующим образом:

'''Матрица Адамара ''H''''n'' - это матрица размера 2''n'' × 2''n'', для которой справедливо равенство'''

:<math>H_n = H_{1} \otimes H_{n-1}</math>,

:<math>\begin{align}
H_1 = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>,
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''

Представим некоторые частные примеры матриц Адамара:

:<math>
H_0 = +1,
</math>

:<math>
H_1 = \frac{1}{\sqrt2}
\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
</math>,

:<math>
H_2 = \frac{1}{2}
\begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>,

:<math>
H_3 = \frac{1}{2^{\frac{3}{2}}}
\begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>.

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

Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math>, размерностью <math>2^n\times 2^n</math> можно вычислить поэлементно ([3], [4]):

:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,

где ''k''''j'' и ''l''''j'' коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):

: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math>

и
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.

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

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

Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.

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

Основную часть метода составляют вычисления значений степени -1 для каждого элемента:

: <math>\sum_{j=0}^n k_j l_j</math>.

Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.

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

Последовательность исполнения метода следующая:

1. Побитовое умножение <math>k\&l</math>;

2. Вычисление количества единиц двоичной записи;

3. Определение знака элемента по степени.

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

Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма

:<math>
T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}.
</math>

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

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

*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный.

[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]

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

Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:
* <math>N^2</math> вычислений побитового умножения,
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,
* <math>N^2</math> для определения знака значения элемента.

Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна <math>O(n^2)</math>.

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

'''Входные данные''': n - размерность матрицы <math>H_n</math>.

'''Объём входных данных''': 1 (число n).

'''Выходные данные''': матрица Адамара <math>H_n</math> размера <math>2^n\times 2^n</math>.

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

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

* Соотношение последовательной и параллельной сложности:
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом:

:<math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.

Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.

Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.
:<math>\frac{T(n)}{T(n,P)}=P</math>.
то есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;

* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right)</math>;

* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размера 2''n'' × 2''n'');

* Степень исхода вершины информационного графа равна 1;

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

=ЧАСТЬ Программная реализация алгоритма =

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

В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:

<source lang="C">
void adamar(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2); // h - нормализующий множитель
N = pow(2,n);

for(i=0;i<N;++i)
{
for(j=0;j<N;++j)
{
ij = i & j;
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij
if(l%2==0) H[i][j] = h;
else H[i][j] = -h;
}
}
}
</source>

Также существует рекурсивная реализация метода генерации матрицы Адамара

<source lang="C">
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель
{
if(n==1) H[i][j] = h;
else
{
adamar(H, N/2, i, j, h);
adamar(H, N/2, i, N/2+j, h);
adamar(H, N/2, N/2+i, j, h);
adamar(H, N/2, N/2+i, N/2+j, -h);
}
}
</source>

Или эквивалентный безрекурсивный вариант:

<source lang="C">
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2);
N = pow(2,n);
k=2;
H[0][0] = h;

while(k<=N)
{
for (i=0; i<k; ++i)
{
for (j=0; j<k; ++j)
{
if (i<k/2 && j<k/2)
{
}
else
{
if(i>=k/2 && j>=k/2)
{
H[i][j] = -(H[i-k/2][j-k/2]);
}
else
{
if (i>j)
{
H[i][j] = H[i-k/2][j];
}
else
{
H[i][j] = H[i][j-k/2];
}
}
}
}
}

k=k*2;
}
}
</source>

Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у распараллеливанной adamar_not_recursion (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).

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

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

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

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

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

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

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

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

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

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave];
# ...

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH];
# ...

= Литература =
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.

[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]

[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

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

[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)

Участник:Бугаков Юрий/Построение матрицы Адамара произвольной размерности

2016-10-20T17:35:22Z

Бугаков Юрий: /* Входные и выходные данные алгоритма */

{{Assignment}}

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O( \left[ \frac{n}{4}\right]\,2^{2n})</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(2^{2n})</math>
| input_data = <math>1</math>
| output_data = <math>2^{2n}</math>
}}

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

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

Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.

Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие

:<math> H_m\,H_m^T = m\,E_m </math>

Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны [1]. Также, можно увидеть из определения, что m четно и
:<math>
H_{2m} =
\begin{pmatrix}
H_{m} & H_{m}\\
H_{m} & -H_{m}\end{pmatrix}
</math>

С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).

Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 (например [2],[3] и [4]). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара следующим образом:

'''Матрица Адамара ''H''''n'' - это матрица размера 2''n'' × 2''n'', для которой справедливо равенство'''

:<math>H_n = H_{1} \otimes H_{n-1}</math>,

:<math>\begin{align}
H_1 = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>,
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''

Представим некоторые частные примеры матриц Адамара:

:<math>
H_0 = +1,
</math>

:<math>
H_1 = \frac{1}{\sqrt2}
\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
</math>,

:<math>
H_2 = \frac{1}{2}
\begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>,

:<math>
H_3 = \frac{1}{2^{\frac{3}{2}}}
\begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>.

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

Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math>, размерностью <math>2^n\times 2^n</math> можно вычислить поэлементно ([3], [4]):

:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,

где ''k''''j'' и ''l''''j'' коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):

: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math>

и
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.

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

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

Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.

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

Основную часть метода составляют вычисления значений степени -1 для каждого элемента:

: <math>\sum_{j=0}^n k_j l_j</math>.

Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.

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

Последовательность исполнения метода следующая:

1. Побитовое умножение <math>k\&l</math>;

2. Вычисление количества единиц двоичной записи;

3. Определение знака элемента по степени.

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

Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма

:<math>
T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}.
</math>

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

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

*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный.

[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]

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

Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:
* <math>N^2</math> вычислений побитового умножения,
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,
* <math>N^2</math> для определения знака значения элемента.

Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна <math>O(n^2)</math>.

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

'''Входные данные''': n - размерность матрицы <math>H_n</math>.

'''Объём входных данных''': 1 (число n).

'''Выходные данные''': матрица Адамара <math>H_n</math> размера <math>2^n\times 2^n</math>.

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

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

* Соотношение последовательной и параллельной сложности:
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом:

:<math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.

Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.

Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.
:<math>\frac{T(n)}{T(n,P)}=P</math>.
то есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;

* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right)</math>;

* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размерности 2''n'' × 2''n'');

* Степень исхода вершины информационного графа равна 1;

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

=ЧАСТЬ Программная реализация алгоритма =

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

В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:

<source lang="C">
void adamar(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2); // h - нормализующий множитель
N = pow(2,n);

for(i=0;i<N;++i)
{
for(j=0;j<N;++j)
{
ij = i & j;
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij
if(l%2==0) H[i][j] = h;
else H[i][j] = -h;
}
}
}
</source>

Также существует рекурсивная реализация метода генерации матрицы Адамара

<source lang="C">
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель
{
if(n==1) H[i][j] = h;
else
{
adamar(H, N/2, i, j, h);
adamar(H, N/2, i, N/2+j, h);
adamar(H, N/2, N/2+i, j, h);
adamar(H, N/2, N/2+i, N/2+j, -h);
}
}
</source>

Или эквивалентный безрекурсивный вариант:

<source lang="C">
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2);
N = pow(2,n);
k=2;
H[0][0] = h;

while(k<=N)
{
for (i=0; i<k; ++i)
{
for (j=0; j<k; ++j)
{
if (i<k/2 && j<k/2)
{
}
else
{
if(i>=k/2 && j>=k/2)
{
H[i][j] = -(H[i-k/2][j-k/2]);
}
else
{
if (i>j)
{
H[i][j] = H[i-k/2][j];
}
else
{
H[i][j] = H[i][j-k/2];
}
}
}
}
}

k=k*2;
}
}
</source>

Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у распараллеливанной adamar_not_recursion (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).

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

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

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

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

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

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

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

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

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

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave];
# ...

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH];
# ...

= Литература =
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.

[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]

[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

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

[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)

Участник:Бугаков Юрий/Построение матрицы Адамара произвольной размерности

2016-10-20T17:35:00Z

Бугаков Юрий: /* Ресурс параллелизма алгоритма */

{{Assignment}}

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O( \left[ \frac{n}{4}\right]\,2^{2n})</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(2^{2n})</math>
| input_data = <math>1</math>
| output_data = <math>2^{2n}</math>
}}

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

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

Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.

Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие

:<math> H_m\,H_m^T = m\,E_m </math>

Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны [1]. Также, можно увидеть из определения, что m четно и
:<math>
H_{2m} =
\begin{pmatrix}
H_{m} & H_{m}\\
H_{m} & -H_{m}\end{pmatrix}
</math>

С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).

Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 (например [2],[3] и [4]). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара следующим образом:

'''Матрица Адамара ''H''''n'' - это матрица размера 2''n'' × 2''n'', для которой справедливо равенство'''

:<math>H_n = H_{1} \otimes H_{n-1}</math>,

:<math>\begin{align}
H_1 = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>,
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''

Представим некоторые частные примеры матриц Адамара:

:<math>
H_0 = +1,
</math>

:<math>
H_1 = \frac{1}{\sqrt2}
\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
</math>,

:<math>
H_2 = \frac{1}{2}
\begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>,

:<math>
H_3 = \frac{1}{2^{\frac{3}{2}}}
\begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>.

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

Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math>, размерностью <math>2^n\times 2^n</math> можно вычислить поэлементно ([3], [4]):

:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,

где ''k''''j'' и ''l''''j'' коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):

: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math>

и
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.

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

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

Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.

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

Основную часть метода составляют вычисления значений степени -1 для каждого элемента:

: <math>\sum_{j=0}^n k_j l_j</math>.

Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.

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

Последовательность исполнения метода следующая:

1. Побитовое умножение <math>k\&l</math>;

2. Вычисление количества единиц двоичной записи;

3. Определение знака элемента по степени.

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

Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма

:<math>
T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}.
</math>

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

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

*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный.

[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]

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

Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:
* <math>N^2</math> вычислений побитового умножения,
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,
* <math>N^2</math> для определения знака значения элемента.

Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна <math>O(n^2)</math>.

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

'''Входные данные''': n - размерность матрицы <math>H_n</math>.

'''Объём входных данных''': 1 (число n).

'''Выходные данные''': матрица Адамара <math>H_n</math> размерностью <math>2^n\times 2^n</math>.

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

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

* Соотношение последовательной и параллельной сложности:
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом:

:<math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.

Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.

Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.
:<math>\frac{T(n)}{T(n,P)}=P</math>.
то есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;

* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right)</math>;

* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размерности 2''n'' × 2''n'');

* Степень исхода вершины информационного графа равна 1;

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

=ЧАСТЬ Программная реализация алгоритма =

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

В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:

<source lang="C">
void adamar(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2); // h - нормализующий множитель
N = pow(2,n);

for(i=0;i<N;++i)
{
for(j=0;j<N;++j)
{
ij = i & j;
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij
if(l%2==0) H[i][j] = h;
else H[i][j] = -h;
}
}
}
</source>

Также существует рекурсивная реализация метода генерации матрицы Адамара

<source lang="C">
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель
{
if(n==1) H[i][j] = h;
else
{
adamar(H, N/2, i, j, h);
adamar(H, N/2, i, N/2+j, h);
adamar(H, N/2, N/2+i, j, h);
adamar(H, N/2, N/2+i, N/2+j, -h);
}
}
</source>

Или эквивалентный безрекурсивный вариант:

<source lang="C">
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2);
N = pow(2,n);
k=2;
H[0][0] = h;

while(k<=N)
{
for (i=0; i<k; ++i)
{
for (j=0; j<k; ++j)
{
if (i<k/2 && j<k/2)
{
}
else
{
if(i>=k/2 && j>=k/2)
{
H[i][j] = -(H[i-k/2][j-k/2]);
}
else
{
if (i>j)
{
H[i][j] = H[i-k/2][j];
}
else
{
H[i][j] = H[i][j-k/2];
}
}
}
}
}

k=k*2;
}
}
</source>

Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у распараллеливанной adamar_not_recursion (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).

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

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

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

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

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

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

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

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

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

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave];
# ...

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH];
# ...

= Литература =
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.

[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]

[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

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

[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)

Участник:Бугаков Юрий/Построение матрицы Адамара произвольной размерности

2016-10-20T17:30:27Z

Бугаков Юрий:

{{Assignment}}

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O( \left[ \frac{n}{4}\right]\,2^{2n})</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(2^{2n})</math>
| input_data = <math>1</math>
| output_data = <math>2^{2n}</math>
}}

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

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

Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.

Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие

:<math> H_m\,H_m^T = m\,E_m </math>

Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны [1]. Также, можно увидеть из определения, что m четно и
:<math>
H_{2m} =
\begin{pmatrix}
H_{m} & H_{m}\\
H_{m} & -H_{m}\end{pmatrix}
</math>

С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).

Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 (например [2],[3] и [4]). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара следующим образом:

'''Матрица Адамара ''H''''n'' - это матрица размера 2''n'' × 2''n'', для которой справедливо равенство'''

:<math>H_n = H_{1} \otimes H_{n-1}</math>,

:<math>\begin{align}
H_1 = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>,
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''

Представим некоторые частные примеры матриц Адамара:

:<math>
H_0 = +1,
</math>

:<math>
H_1 = \frac{1}{\sqrt2}
\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
</math>,

:<math>
H_2 = \frac{1}{2}
\begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>,

:<math>
H_3 = \frac{1}{2^{\frac{3}{2}}}
\begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>.

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

Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math>, размерностью <math>2^n\times 2^n</math> можно вычислить поэлементно ([3], [4]):

:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,

где ''k''''j'' и ''l''''j'' коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):

: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math>

и
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.

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

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

Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.

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

Основную часть метода составляют вычисления значений степени -1 для каждого элемента:

: <math>\sum_{j=0}^n k_j l_j</math>.

Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.

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

Последовательность исполнения метода следующая:

1. Побитовое умножение <math>k\&l</math>;

2. Вычисление количества единиц двоичной записи;

3. Определение знака элемента по степени.

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

Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма

:<math>
T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}.
</math>

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

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

*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный.

[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]

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

Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:
* <math>N^2</math> вычислений побитового умножения,
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,
* <math>N^2</math> для определения знака значения элемента.

Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна O(n^2).

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

'''Входные данные''': n - размерность матрицы <math>H_n</math>.

'''Объём входных данных''': 1 (число n).

'''Выходные данные''': матрица Адамара <math>H_n</math> размерностью <math>2^n\times 2^n</math>.

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

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

* Соотношение последовательной и параллельной сложности:
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом:

:<math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.

Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.

Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.
:<math>\frac{T(n)}{T(n,P)}=P</math>.
то есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;

* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right)</math>;

* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размерности 2''n'' × 2''n'');

* Степень исхода вершины информационного графа равна 1;

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

=ЧАСТЬ Программная реализация алгоритма =

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

В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:

<source lang="C">
void adamar(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2); // h - нормализующий множитель
N = pow(2,n);

for(i=0;i<N;++i)
{
for(j=0;j<N;++j)
{
ij = i & j;
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij
if(l%2==0) H[i][j] = h;
else H[i][j] = -h;
}
}
}
</source>

Также существует рекурсивная реализация метода генерации матрицы Адамара

<source lang="C">
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель
{
if(n==1) H[i][j] = h;
else
{
adamar(H, N/2, i, j, h);
adamar(H, N/2, i, N/2+j, h);
adamar(H, N/2, N/2+i, j, h);
adamar(H, N/2, N/2+i, N/2+j, -h);
}
}
</source>

Или эквивалентный безрекурсивный вариант:

<source lang="C">
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2);
N = pow(2,n);
k=2;
H[0][0] = h;

while(k<=N)
{
for (i=0; i<k; ++i)
{
for (j=0; j<k; ++j)
{
if (i<k/2 && j<k/2)
{
}
else
{
if(i>=k/2 && j>=k/2)
{
H[i][j] = -(H[i-k/2][j-k/2]);
}
else
{
if (i>j)
{
H[i][j] = H[i-k/2][j];
}
else
{
H[i][j] = H[i][j-k/2];
}
}
}
}
}

k=k*2;
}
}
</source>

Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у распараллеливанной adamar_not_recursion (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).

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

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

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

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

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

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

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

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

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

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave];
# ...

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH];
# ...

= Литература =
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.

[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]

[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

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

[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)

Участник:Бугаков Юрий/Построение матрицы Адамара произвольной размерности

2016-10-20T17:28:48Z

Бугаков Юрий:

{{Assignment}}

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O(\frac{n}{4}\right]^{2n})</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(2^{2n})</math>
| input_data = <math>1</math>
| output_data = <math>2^{2n}</math>
}}

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

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

Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.

Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие

:<math> H_m\,H_m^T = m\,E_m </math>

Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны [1]. Также, можно увидеть из определения, что m четно и
:<math>
H_{2m} =
\begin{pmatrix}
H_{m} & H_{m}\\
H_{m} & -H_{m}\end{pmatrix}
</math>

С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).

Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 (например [2],[3] и [4]). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара следующим образом:

'''Матрица Адамара ''H''''n'' - это матрица размера 2''n'' × 2''n'', для которой справедливо равенство'''

:<math>H_n = H_{1} \otimes H_{n-1}</math>,

:<math>\begin{align}
H_1 = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>,
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''

Представим некоторые частные примеры матриц Адамара:

:<math>
H_0 = +1,
</math>

:<math>
H_1 = \frac{1}{\sqrt2}
\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
</math>,

:<math>
H_2 = \frac{1}{2}
\begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>,

:<math>
H_3 = \frac{1}{2^{\frac{3}{2}}}
\begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>.

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

Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math>, размерностью <math>2^n\times 2^n</math> можно вычислить поэлементно ([3], [4]):

:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,

где ''k''''j'' и ''l''''j'' коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):

: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math>

и
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.

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

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

Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.

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

Основную часть метода составляют вычисления значений степени -1 для каждого элемента:

: <math>\sum_{j=0}^n k_j l_j</math>.

Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.

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

Последовательность исполнения метода следующая:

1. Побитовое умножение <math>k\&l</math>;

2. Вычисление количества единиц двоичной записи;

3. Определение знака элемента по степени.

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

Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма

:<math>
T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}.
</math>

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

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

*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный.

[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]

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

Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:
* <math>N^2</math> вычислений побитового умножения,
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,
* <math>N^2</math> для определения знака значения элемента.

Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна O(n^2).

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

'''Входные данные''': n - размерность матрицы <math>H_n</math>.

'''Объём входных данных''': 1 (число n).

'''Выходные данные''': матрица Адамара <math>H_n</math> размерностью <math>2^n\times 2^n</math>.

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

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

* Соотношение последовательной и параллельной сложности:
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом:

:<math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.

Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.

Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.
:<math>\frac{T(n)}{T(n,P)}=P</math>.
то есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;

* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right)</math>;

* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размерности 2''n'' × 2''n'');

* Степень исхода вершины информационного графа равна 1;

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

=ЧАСТЬ Программная реализация алгоритма =

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

В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:

<source lang="C">
void adamar(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2); // h - нормализующий множитель
N = pow(2,n);

for(i=0;i<N;++i)
{
for(j=0;j<N;++j)
{
ij = i & j;
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij
if(l%2==0) H[i][j] = h;
else H[i][j] = -h;
}
}
}
</source>

Также существует рекурсивная реализация метода генерации матрицы Адамара

<source lang="C">
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель
{
if(n==1) H[i][j] = h;
else
{
adamar(H, N/2, i, j, h);
adamar(H, N/2, i, N/2+j, h);
adamar(H, N/2, N/2+i, j, h);
adamar(H, N/2, N/2+i, N/2+j, -h);
}
}
</source>

Или эквивалентный безрекурсивный вариант:

<source lang="C">
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2);
N = pow(2,n);
k=2;
H[0][0] = h;

while(k<=N)
{
for (i=0; i<k; ++i)
{
for (j=0; j<k; ++j)
{
if (i<k/2 && j<k/2)
{
}
else
{
if(i>=k/2 && j>=k/2)
{
H[i][j] = -(H[i-k/2][j-k/2]);
}
else
{
if (i>j)
{
H[i][j] = H[i-k/2][j];
}
else
{
H[i][j] = H[i][j-k/2];
}
}
}
}
}

k=k*2;
}
}
</source>

Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у распараллеливанной adamar_not_recursion (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).

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

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

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

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

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

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

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

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

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

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave];
# ...

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH];
# ...

= Литература =
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.

[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]

[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

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

[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)

Участник:Бугаков Юрий/Построение матрицы Адамара произвольной размерности

2016-10-20T17:27:38Z

Бугаков Юрий:

{{Assignment}}

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O(m2^{2m})</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(2^{2n})</math>
| input_data = <math>1</math>
| output_data = <math>2^{2n}</math>
}}

{{Assignment}}

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

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

Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.

Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие

:<math> H_m\,H_m^T = m\,E_m </math>

Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны [1]. Также, можно увидеть из определения, что m четно и
:<math>
H_{2m} =
\begin{pmatrix}
H_{m} & H_{m}\\
H_{m} & -H_{m}\end{pmatrix}
</math>

С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).

Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 (например [2],[3] и [4]). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара следующим образом:

'''Матрица Адамара ''H''''n'' - это матрица размера 2''n'' × 2''n'', для которой справедливо равенство'''

:<math>H_n = H_{1} \otimes H_{n-1}</math>,

:<math>\begin{align}
H_1 = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>,
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''

Представим некоторые частные примеры матриц Адамара:

:<math>
H_0 = +1,
</math>

:<math>
H_1 = \frac{1}{\sqrt2}
\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
</math>,

:<math>
H_2 = \frac{1}{2}
\begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>,

:<math>
H_3 = \frac{1}{2^{\frac{3}{2}}}
\begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>.

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

Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math>, размерностью <math>2^n\times 2^n</math> можно вычислить поэлементно ([3], [4]):

:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,

где ''k''''j'' и ''l''''j'' коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):

: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math>

и
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.

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

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

Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.

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

Основную часть метода составляют вычисления значений степени -1 для каждого элемента:

: <math>\sum_{j=0}^n k_j l_j</math>.

Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.

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

Последовательность исполнения метода следующая:

1. Побитовое умножение <math>k\&l</math>;

2. Вычисление количества единиц двоичной записи;

3. Определение знака элемента по степени.

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

Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма

:<math>
T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}.
</math>

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

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

*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный.

[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]

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

Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:
* <math>N^2</math> вычислений побитового умножения,
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,
* <math>N^2</math> для определения знака значения элемента.

Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна O(n^2).

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

'''Входные данные''': n - размерность матрицы <math>H_n</math>.

'''Объём входных данных''': 1 (число n).

'''Выходные данные''': матрица Адамара <math>H_n</math> размерностью <math>2^n\times 2^n</math>.

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

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

* Соотношение последовательной и параллельной сложности:
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом:

:<math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.

Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.

Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.
:<math>\frac{T(n)}{T(n,P)}=P</math>.
то есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;

* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right)</math>;

* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размерности 2''n'' × 2''n'');

* Степень исхода вершины информационного графа равна 1;

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

=ЧАСТЬ Программная реализация алгоритма =

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

В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:

<source lang="C">
void adamar(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2); // h - нормализующий множитель
N = pow(2,n);

for(i=0;i<N;++i)
{
for(j=0;j<N;++j)
{
ij = i & j;
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij
if(l%2==0) H[i][j] = h;
else H[i][j] = -h;
}
}
}
</source>

Также существует рекурсивная реализация метода генерации матрицы Адамара

<source lang="C">
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель
{
if(n==1) H[i][j] = h;
else
{
adamar(H, N/2, i, j, h);
adamar(H, N/2, i, N/2+j, h);
adamar(H, N/2, N/2+i, j, h);
adamar(H, N/2, N/2+i, N/2+j, -h);
}
}
</source>

Или эквивалентный безрекурсивный вариант:

<source lang="C">
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2);
N = pow(2,n);
k=2;
H[0][0] = h;

while(k<=N)
{
for (i=0; i<k; ++i)
{
for (j=0; j<k; ++j)
{
if (i<k/2 && j<k/2)
{
}
else
{
if(i>=k/2 && j>=k/2)
{
H[i][j] = -(H[i-k/2][j-k/2]);
}
else
{
if (i>j)
{
H[i][j] = H[i-k/2][j];
}
else
{
H[i][j] = H[i][j-k/2];
}
}
}
}
}

k=k*2;
}
}
</source>

Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у распараллеливанной adamar_not_recursion (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).

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

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

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

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

Ключевой момент данного раздела заключается в том, чтобы показать ''реальные параметры масштабируемости программы'' для данного алгоритма на различных вычислительных платформах в зависимости от числа процессоров и размера задачи [4]. При этом важно подобрать такое соотношение между числом процессоров и размером задачи, чтобы отразить все характерные точки в поведении параллельной программы, в частности, достижение максимальной производительности, а также тонкие эффекты, возникающие, например, из-за блочной структуры алгоритма или иерархии памяти.

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

== Динамические характеристики и эффективность реализации алгоритма ==

== Выводы для классов архитектур ==

== Существующие реализации алгоритма ==

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave];
# ...

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH];
# ...

= Литература =
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.

[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]

[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

[5] Воеводин В.В.. Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.

[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)

Участник:Бугаков Юрий/Построение матрицы Адамара произвольной размерности

2016-10-20T17:24:33Z

Бугаков Юрий: /* Особенности реализации последовательного алгоритма */

{{Assignment}}

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.

Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие

:<math> H_m\,H_m^T = m\,E_m </math>

Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны [1]. Также, можно увидеть из определения, что m четно и
:<math>
H_{2m} =
\begin{pmatrix}
H_{m} & H_{m}\\
H_{m} & -H_{m}\end{pmatrix}
</math>

С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).

Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 (например [2],[3] и [4]). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара следующим образом:

'''Матрица Адамара ''H''''n'' - это матрица размера 2''n'' × 2''n'', для которой справедливо равенство'''

:<math>H_n = H_{1} \otimes H_{n-1}</math>,

:<math>\begin{align}
H_1 = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>,
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''

Представим некоторые частные примеры матриц Адамара:

:<math>
H_0 = +1,
</math>

:<math>
H_1 = \frac{1}{\sqrt2}
\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
</math>,

:<math>
H_2 = \frac{1}{2}
\begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>,

:<math>
H_3 = \frac{1}{2^{\frac{3}{2}}}
\begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>.

=== Математическое описание алгоритма ===

Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math>, размерностью <math>2^n\times 2^n</math> можно вычислить поэлементно ([3], [4]):

:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,

где ''k''''j'' и ''l''''j'' коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):

: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math>

и
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.

Помимо этой формулы чаще всего используется заполнение по определению. В связи с трудностями распараллеливания и постоянного выделения памяти при каждом шаге рекурсивного вызова этого метода, был выбран предыдущий способ вычисления.

=== Вычислительное ядро алгоритма ===

Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.

=== Макроструктура алгоритма ===

Основную часть метода составляют вычисления значений степени -1 для каждого элемента:

: <math>\sum_{j=0}^n k_j l_j</math>.

Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.

=== Схема реализации последовательного алгоритма ===

Последовательность исполнения метода следующая:

1. Побитовое умножение <math>k\&l</math>;

2. Вычисление количества единиц двоичной записи;

3. Определение знака элемента по степени.

=== Последовательная сложность алгоритма ===

Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма

:<math>
T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}.
</math>

=== Информационный граф ===

На рисунке ниже изображен информационный граф алгоритма.

*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный.

[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]

=== Ресурс параллелизма алгоритма ===

Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:
* <math>N^2</math> вычислений побитового умножения,
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,
* <math>N^2</math> для определения знака значения элемента.

Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна O(n^2).

=== Входные и выходные данные алгоритма ===

'''Входные данные''': n - размерность матрицы <math>H_n</math>.

'''Объём входных данных''': 1 (число n).

'''Выходные данные''': матрица Адамара <math>H_n</math> размерностью <math>2^n\times 2^n</math>.

'''Объём выходных данных''': <math>2^{2n}</math>.

=== Свойства алгоритма ===

* Соотношение последовательной и параллельной сложности:
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом:

:<math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.

Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.

Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.
:<math>\frac{T(n)}{T(n,P)}=P</math>.
то есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;

* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right)</math>;

* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размерности 2''n'' × 2''n'');

* Степень исхода вершины информационного графа равна 1;

* Алгоритм построения матрицы Адамара является ''сбалансированным''. Так как количество вершин на разных процессорах одинаково, то алгоритм является сбалансированным по числу операций на каждом процессоре.

=ЧАСТЬ Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==

В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:

<source lang="C">
void adamar(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2); // h - нормализующий множитель
N = pow(2,n);

for(i=0;i<N;++i)
{
for(j=0;j<N;++j)
{
ij = i & j;
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij
if(l%2==0) H[i][j] = h;
else H[i][j] = -h;
}
}
}
</source>

Также существует рекурсивная реализация метода генерации матрицы Адамара

<source lang="C">
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель
{
if(n==1) H[i][j] = h;
else
{
adamar(H, N/2, i, j, h);
adamar(H, N/2, i, N/2+j, h);
adamar(H, N/2, N/2+i, j, h);
adamar(H, N/2, N/2+i, N/2+j, -h);
}
}
</source>

Или эквивалентный безрекурсивный вариант:

<source lang="C">
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2);
N = pow(2,n);
k=2;
H[0][0] = h;

while(k<=N)
{
for (i=0; i<k; ++i)
{
for (j=0; j<k; ++j)
{
if (i<k/2 && j<k/2)
{
}
else
{
if(i>=k/2 && j>=k/2)
{
H[i][j] = -(H[i-k/2][j-k/2]);
}
else
{
if (i>j)
{
H[i][j] = H[i-k/2][j];
}
else
{
H[i][j] = H[i][j-k/2];
}
}
}
}
}

k=k*2;
}
}
</source>

Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у распараллеливанной adamar_not_recursion (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).

== Локальность данных и вычислений ==

== Возможные способы и особенности параллельной реализации алгоритма ==

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

Масштабируемость алгоритма определяет свойства самого алгоритма безотносительно конкретных особенностей используемого компьютера. Она показывает, насколько параллельные свойства алгоритма позволяют использовать возможности растущего числа процессорных элементов. Масштабируемость параллельных программ определяется как относительно конкретного компьютера, так и относительно используемой технологии программирования, и в этом случае она показывает, насколько может вырасти реальная производительность данного компьютера на данной программе, записанной с помощью данной технологии программирования, при использовании бóльших вычислительных ресурсов (ядер, процессоров, вычислительных узлов).

Ключевой момент данного раздела заключается в том, чтобы показать ''реальные параметры масштабируемости программы'' для данного алгоритма на различных вычислительных платформах в зависимости от числа процессоров и размера задачи [4]. При этом важно подобрать такое соотношение между числом процессоров и размером задачи, чтобы отразить все характерные точки в поведении параллельной программы, в частности, достижение максимальной производительности, а также тонкие эффекты, возникающие, например, из-за блочной структуры алгоритма или иерархии памяти.

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

== Динамические характеристики и эффективность реализации алгоритма ==

== Выводы для классов архитектур ==

== Существующие реализации алгоритма ==

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave];
# ...

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH];
# ...

= Литература =
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.

[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]

[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

[5] Воеводин В.В.. Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.

[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)

Участник:Бугаков Юрий/Построение матрицы Адамара произвольной размерности

2016-10-20T17:22:22Z

Бугаков Юрий: /* Свойства алгоритма */

{{Assignment}}

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.

Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие

:<math> H_m\,H_m^T = m\,E_m </math>

Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны [1]. Также, можно увидеть из определения, что m четно и
:<math>
H_{2m} =
\begin{pmatrix}
H_{m} & H_{m}\\
H_{m} & -H_{m}\end{pmatrix}
</math>

С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).

Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 (например [2],[3] и [4]). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара следующим образом:

'''Матрица Адамара ''H''''n'' - это матрица размера 2''n'' × 2''n'', для которой справедливо равенство'''

:<math>H_n = H_{1} \otimes H_{n-1}</math>,

:<math>\begin{align}
H_1 = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>,
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''

Представим некоторые частные примеры матриц Адамара:

:<math>
H_0 = +1,
</math>

:<math>
H_1 = \frac{1}{\sqrt2}
\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
</math>,

:<math>
H_2 = \frac{1}{2}
\begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>,

:<math>
H_3 = \frac{1}{2^{\frac{3}{2}}}
\begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>.

=== Математическое описание алгоритма ===

Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math>, размерностью <math>2^n\times 2^n</math> можно вычислить поэлементно ([3], [4]):

:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,

где ''k''''j'' и ''l''''j'' коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):

: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math>

и
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.

Помимо этой формулы чаще всего используется заполнение по определению. В связи с трудностями распараллеливания и постоянного выделения памяти при каждом шаге рекурсивного вызова этого метода, был выбран предыдущий способ вычисления.

=== Вычислительное ядро алгоритма ===

Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.

=== Макроструктура алгоритма ===

Основную часть метода составляют вычисления значений степени -1 для каждого элемента:

: <math>\sum_{j=0}^n k_j l_j</math>.

Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.

=== Схема реализации последовательного алгоритма ===

Последовательность исполнения метода следующая:

1. Побитовое умножение <math>k\&l</math>;

2. Вычисление количества единиц двоичной записи;

3. Определение знака элемента по степени.

=== Последовательная сложность алгоритма ===

Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма

:<math>
T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}.
</math>

=== Информационный граф ===

На рисунке ниже изображен информационный граф алгоритма.

*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный.

[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]

=== Ресурс параллелизма алгоритма ===

Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:
* <math>N^2</math> вычислений побитового умножения,
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,
* <math>N^2</math> для определения знака значения элемента.

Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна O(n^2).

=== Входные и выходные данные алгоритма ===

'''Входные данные''': n - размерность матрицы <math>H_n</math>.

'''Объём входных данных''': 1 (число n).

'''Выходные данные''': матрица Адамара <math>H_n</math> размерностью <math>2^n\times 2^n</math>.

'''Объём выходных данных''': <math>2^{2n}</math>.

=== Свойства алгоритма ===

* Соотношение последовательной и параллельной сложности:
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом:

:<math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.

Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.

Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.
:<math>\frac{T(n)}{T(n,P)}=P</math>.
то есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;

* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right)</math>;

* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размерности 2''n'' × 2''n'');

* Степень исхода вершины информационного графа равна 1;

* Алгоритм построения матрицы Адамара является ''сбалансированным''. Так как количество вершин на разных процессорах одинаково, то алгоритм является сбалансированным по числу операций на каждом процессоре.

=ЧАСТЬ Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==

В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:

<source lang="C">
void adamar(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2); // h - нормализующий множитель
N = pow(2,n);

for(i=0;i<N;++i)
{
for(j=0;j<N;++j)
{
ij = i & j;
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij
if(l%2==0) H[i][j] = h;
else H[i][j] = -h;
}
}
}
</source>

Также существует рекурсивная реализация метода генерации матрицы Адамара

<source lang="C">
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель
{
if(n==1) H[i][j] = h;
else
{
adamar(H, N/2, i, j, h);
adamar(H, N/2, i, N/2+j, h);
adamar(H, N/2, N/2+i, j, h);
adamar(H, N/2, N/2+i, N/2+j, -h);
}
}
</source>

Или эквивалентный безрекурсивный вариант:

<source lang="C">
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2);
N = pow(2,n);
k=2;
H[0][0] = h;

while(k<=N)
{
for (i=0; i<k; ++i)
{
for (j=0; j<k; ++j)
{
if (i<k/2 && j<k/2)
{
}
else
{
if(i>=k/2 && j>=k/2)
{
H[i][j] = -(H[i-k/2][j-k/2]);
}
else
{
if (i>j)
{
H[i][j] = H[i-k/2][j];
}
else
{
H[i][j] = H[i][j-k/2];
}
}
}
}
}

k=k*2;
}
}
</source>

Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у последовательной (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).

== Локальность данных и вычислений ==

== Возможные способы и особенности параллельной реализации алгоритма ==

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

Масштабируемость алгоритма определяет свойства самого алгоритма безотносительно конкретных особенностей используемого компьютера. Она показывает, насколько параллельные свойства алгоритма позволяют использовать возможности растущего числа процессорных элементов. Масштабируемость параллельных программ определяется как относительно конкретного компьютера, так и относительно используемой технологии программирования, и в этом случае она показывает, насколько может вырасти реальная производительность данного компьютера на данной программе, записанной с помощью данной технологии программирования, при использовании бóльших вычислительных ресурсов (ядер, процессоров, вычислительных узлов).

Ключевой момент данного раздела заключается в том, чтобы показать ''реальные параметры масштабируемости программы'' для данного алгоритма на различных вычислительных платформах в зависимости от числа процессоров и размера задачи [4]. При этом важно подобрать такое соотношение между числом процессоров и размером задачи, чтобы отразить все характерные точки в поведении параллельной программы, в частности, достижение максимальной производительности, а также тонкие эффекты, возникающие, например, из-за блочной структуры алгоритма или иерархии памяти.

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

== Динамические характеристики и эффективность реализации алгоритма ==

== Выводы для классов архитектур ==

== Существующие реализации алгоритма ==

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave];
# ...

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH];
# ...

= Литература =
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.

[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]

[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

[5] Воеводин В.В.. Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.

[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)

Участник:Бугаков Юрий/Построение матрицы Адамара произвольной размерности

2016-10-20T17:22:01Z

Бугаков Юрий: /* Общее описание алгоритма */

{{Assignment}}

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.

Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие

:<math> H_m\,H_m^T = m\,E_m </math>

Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны [1]. Также, можно увидеть из определения, что m четно и
:<math>
H_{2m} =
\begin{pmatrix}
H_{m} & H_{m}\\
H_{m} & -H_{m}\end{pmatrix}
</math>

С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).

Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 (например [2],[3] и [4]). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара следующим образом:

'''Матрица Адамара ''H''''n'' - это матрица размера 2''n'' × 2''n'', для которой справедливо равенство'''

:<math>H_n = H_{1} \otimes H_{n-1}</math>,

:<math>\begin{align}
H_1 = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>,
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''

Представим некоторые частные примеры матриц Адамара:

:<math>
H_0 = +1,
</math>

:<math>
H_1 = \frac{1}{\sqrt2}
\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
</math>,

:<math>
H_2 = \frac{1}{2}
\begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>,

:<math>
H_3 = \frac{1}{2^{\frac{3}{2}}}
\begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>.

=== Математическое описание алгоритма ===

Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math>, размерностью <math>2^n\times 2^n</math> можно вычислить поэлементно ([3], [4]):

:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,

где ''k''''j'' и ''l''''j'' коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):

: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math>

и
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.

Помимо этой формулы чаще всего используется заполнение по определению. В связи с трудностями распараллеливания и постоянного выделения памяти при каждом шаге рекурсивного вызова этого метода, был выбран предыдущий способ вычисления.

=== Вычислительное ядро алгоритма ===

Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.

=== Макроструктура алгоритма ===

Основную часть метода составляют вычисления значений степени -1 для каждого элемента:

: <math>\sum_{j=0}^n k_j l_j</math>.

Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.

=== Схема реализации последовательного алгоритма ===

Последовательность исполнения метода следующая:

1. Побитовое умножение <math>k\&l</math>;

2. Вычисление количества единиц двоичной записи;

3. Определение знака элемента по степени.

=== Последовательная сложность алгоритма ===

Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма

:<math>
T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}.
</math>

=== Информационный граф ===

На рисунке ниже изображен информационный граф алгоритма.

*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный.

[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]

=== Ресурс параллелизма алгоритма ===

Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:
* <math>N^2</math> вычислений побитового умножения,
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,
* <math>N^2</math> для определения знака значения элемента.

Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна O(n^2).

=== Входные и выходные данные алгоритма ===

'''Входные данные''': n - размерность матрицы <math>H_n</math>.

'''Объём входных данных''': 1 (число n).

'''Выходные данные''': матрица Адамара <math>H_n</math> размерностью <math>2^n\times 2^n</math>.

'''Объём выходных данных''': <math>2^{2n}</math>.

=== Свойства алгоритма ===

* Соотношение последовательной и параллельной сложности:
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом:

:<math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.

Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.

Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.
:<math>\frac{T(n)}{T(n,p)}=P</math>.
то есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;

* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right)</math>;

* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размерности 2''n'' × 2''n'');

* Степень исхода вершины информационного графа равна 1;

* Алгоритм построения матрицы Адамара является ''сбалансированным''. Так как количество вершин на разных процессорах одинаково, то алгоритм является сбалансированным по числу операций на каждом процессоре.

=ЧАСТЬ Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==

В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:

<source lang="C">
void adamar(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2); // h - нормализующий множитель
N = pow(2,n);

for(i=0;i<N;++i)
{
for(j=0;j<N;++j)
{
ij = i & j;
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij
if(l%2==0) H[i][j] = h;
else H[i][j] = -h;
}
}
}
</source>

Также существует рекурсивная реализация метода генерации матрицы Адамара

<source lang="C">
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель
{
if(n==1) H[i][j] = h;
else
{
adamar(H, N/2, i, j, h);
adamar(H, N/2, i, N/2+j, h);
adamar(H, N/2, N/2+i, j, h);
adamar(H, N/2, N/2+i, N/2+j, -h);
}
}
</source>

Или эквивалентный безрекурсивный вариант:

<source lang="C">
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2);
N = pow(2,n);
k=2;
H[0][0] = h;

while(k<=N)
{
for (i=0; i<k; ++i)
{
for (j=0; j<k; ++j)
{
if (i<k/2 && j<k/2)
{
}
else
{
if(i>=k/2 && j>=k/2)
{
H[i][j] = -(H[i-k/2][j-k/2]);
}
else
{
if (i>j)
{
H[i][j] = H[i-k/2][j];
}
else
{
H[i][j] = H[i][j-k/2];
}
}
}
}
}

k=k*2;
}
}
</source>

Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у последовательной (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).

== Локальность данных и вычислений ==

== Возможные способы и особенности параллельной реализации алгоритма ==

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

Масштабируемость алгоритма определяет свойства самого алгоритма безотносительно конкретных особенностей используемого компьютера. Она показывает, насколько параллельные свойства алгоритма позволяют использовать возможности растущего числа процессорных элементов. Масштабируемость параллельных программ определяется как относительно конкретного компьютера, так и относительно используемой технологии программирования, и в этом случае она показывает, насколько может вырасти реальная производительность данного компьютера на данной программе, записанной с помощью данной технологии программирования, при использовании бóльших вычислительных ресурсов (ядер, процессоров, вычислительных узлов).

Ключевой момент данного раздела заключается в том, чтобы показать ''реальные параметры масштабируемости программы'' для данного алгоритма на различных вычислительных платформах в зависимости от числа процессоров и размера задачи [4]. При этом важно подобрать такое соотношение между числом процессоров и размером задачи, чтобы отразить все характерные точки в поведении параллельной программы, в частности, достижение максимальной производительности, а также тонкие эффекты, возникающие, например, из-за блочной структуры алгоритма или иерархии памяти.

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

== Динамические характеристики и эффективность реализации алгоритма ==

== Выводы для классов архитектур ==

== Существующие реализации алгоритма ==

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave];
# ...

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH];
# ...

= Литература =
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.

[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]

[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

[5] Воеводин В.В.. Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.

[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)

Участник:Бугаков Юрий/Построение матрицы Адамара произвольной размерности

2016-10-15T20:45:18Z

Бугаков Юрий: /* Свойства алгоритма */

{{Assignment}}

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.

Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие

:<math> H_m\,H_m^T = m\,E_m </math>

Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны [1]. Также, можно увидеть из определения, что m четно и
:<math>
H_{2m} =
\begin{pmatrix}
H_{m} & H_{m}\\
H_{m} & -H_{m}\end{pmatrix}
</math>

С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).

Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 (например [2],[3] и [4]). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара будет следующим образом:

'''Матрица Адамара ''H''''n'' - это матрица размера 2''n'' × 2''n'', для которой справедливо равенство'''

:<math>H_n = H_{1} \otimes H_{n-1}</math>,

:<math>\begin{align}
H_1 = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>,
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''

Представим некоторые частные примеры матриц Адамара:

:<math>
H_0 = +1,
</math>

:<math>
H_1 = \frac{1}{\sqrt2}
\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
</math>,

:<math>
H_2 = \frac{1}{2}
\begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>,

:<math>
H_3 = \frac{1}{2^{\frac{3}{2}}}
\begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>.

=== Математическое описание алгоритма ===

Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math>, размерностью <math>2^n\times 2^n</math> можно вычислить поэлементно ([3], [4]):

:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,

где ''k''''j'' и ''l''''j'' коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):

: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math>

и
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.

Помимо этой формулы чаще всего используется заполнение по определению. В связи с трудностями распараллеливания и постоянного выделения памяти при каждом шаге рекурсивного вызова этого метода, был выбран предыдущий способ вычисления.

=== Вычислительное ядро алгоритма ===

Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.

=== Макроструктура алгоритма ===

Основную часть метода составляют вычисления значений степени -1 для каждого элемента:

: <math>\sum_{j=0}^n k_j l_j</math>.

Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.

=== Схема реализации последовательного алгоритма ===

Последовательность исполнения метода следующая:

1. Побитовое умножение <math>k\&l</math>;

2. Вычисление количества единиц двоичной записи;

3. Определение знака элемента по степени.

=== Последовательная сложность алгоритма ===

Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма

:<math>
T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}.
</math>

=== Информационный граф ===

На рисунке ниже изображен информационный граф алгоритма.

*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный.

[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]

=== Ресурс параллелизма алгоритма ===

Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:
* <math>N^2</math> вычислений побитового умножения,
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,
* <math>N^2</math> для определения знака значения элемента.

Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна O(n^2).

=== Входные и выходные данные алгоритма ===

'''Входные данные''': n - размерность матрицы <math>H_n</math>.

'''Объём входных данных''': 1 (число n).

'''Выходные данные''': матрица Адамара <math>H_n</math> размерностью <math>2^n\times 2^n</math>.

'''Объём выходных данных''': <math>2^{2n}</math>.

=== Свойства алгоритма ===

* Соотношение последовательной и параллельной сложности:
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом:

:<math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.

Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.

Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.
:<math>\frac{T(n)}{T(n,p)}=P</math>.
то есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;

* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right)</math>;

* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размерности 2''n'' × 2''n'');

* Степень исхода вершины информационного графа равна 1;

* Алгоритм построения матрицы Адамара является ''сбалансированным''. Так как количество вершин на разных процессорах одинаково, то алгоритм является сбалансированным по числу операций на каждом процессоре.

=ЧАСТЬ Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==

В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:

<source lang="C">
void adamar(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2); // h - нормализующий множитель
N = pow(2,n);

for(i=0;i<N;++i)
{
for(j=0;j<N;++j)
{
ij = i & j;
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij
if(l%2==0) H[i][j] = h;
else H[i][j] = -h;
}
}
}
</source>

Также существует рекурсивная реализация метода генерации матрицы Адамара

<source lang="C">
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель
{
if(n==1) H[i][j] = h;
else
{
adamar(H, N/2, i, j, h);
adamar(H, N/2, i, N/2+j, h);
adamar(H, N/2, N/2+i, j, h);
adamar(H, N/2, N/2+i, N/2+j, -h);
}
}
</source>

Или эквивалентный безрекурсивный вариант:

<source lang="C">
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2);
N = pow(2,n);
k=2;
H[0][0] = h;

while(k<=N)
{
for (i=0; i<k; ++i)
{
for (j=0; j<k; ++j)
{
if (i<k/2 && j<k/2)
{
}
else
{
if(i>=k/2 && j>=k/2)
{
H[i][j] = -(H[i-k/2][j-k/2]);
}
else
{
if (i>j)
{
H[i][j] = H[i-k/2][j];
}
else
{
H[i][j] = H[i][j-k/2];
}
}
}
}
}

k=k*2;
}
}
</source>

Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у последовательной (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).

== Локальность данных и вычислений ==

== Возможные способы и особенности параллельной реализации алгоритма ==

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

Масштабируемость алгоритма определяет свойства самого алгоритма безотносительно конкретных особенностей используемого компьютера. Она показывает, насколько параллельные свойства алгоритма позволяют использовать возможности растущего числа процессорных элементов. Масштабируемость параллельных программ определяется как относительно конкретного компьютера, так и относительно используемой технологии программирования, и в этом случае она показывает, насколько может вырасти реальная производительность данного компьютера на данной программе, записанной с помощью данной технологии программирования, при использовании бóльших вычислительных ресурсов (ядер, процессоров, вычислительных узлов).

Ключевой момент данного раздела заключается в том, чтобы показать ''реальные параметры масштабируемости программы'' для данного алгоритма на различных вычислительных платформах в зависимости от числа процессоров и размера задачи [4]. При этом важно подобрать такое соотношение между числом процессоров и размером задачи, чтобы отразить все характерные точки в поведении параллельной программы, в частности, достижение максимальной производительности, а также тонкие эффекты, возникающие, например, из-за блочной структуры алгоритма или иерархии памяти.

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

== Динамические характеристики и эффективность реализации алгоритма ==

== Выводы для классов архитектур ==

== Существующие реализации алгоритма ==

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave];
# ...

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH];
# ...

= Литература =
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.

[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]

[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

[5] Воеводин В.В.. Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.

[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)

Участник:Бугаков Юрий/Построение матрицы Адамара произвольной размерности

2016-10-15T19:56:07Z

Бугаков Юрий: /* Общее описание алгоритма */

{{Assignment}}

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.

Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие

:<math> H_m\,H_m^T = m\,E_m </math>

Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны [1]. Также, можно увидеть из определения, что m четно и
:<math>
H_{2m} =
\begin{pmatrix}
H_{m} & H_{m}\\
H_{m} & -H_{m}\end{pmatrix}
</math>

С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).

Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 (например [2],[3] и [4]). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара будет следующим образом:

'''Матрица Адамара ''H''''n'' - это матрица размера 2''n'' × 2''n'', для которой справедливо равенство'''

:<math>H_n = H_{1} \otimes H_{n-1}</math>,

:<math>\begin{align}
H_1 = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>,
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''

Представим некоторые частные примеры матриц Адамара:

:<math>
H_0 = +1,
</math>

:<math>
H_1 = \frac{1}{\sqrt2}
\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
</math>,

:<math>
H_2 = \frac{1}{2}
\begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>,

:<math>
H_3 = \frac{1}{2^{\frac{3}{2}}}
\begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>.

=== Математическое описание алгоритма ===

Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math>, размерностью <math>2^n\times 2^n</math> можно вычислить поэлементно ([3], [4]):

:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,

где ''k''''j'' и ''l''''j'' коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):

: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math>

и
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.

Помимо этой формулы чаще всего используется заполнение по определению. В связи с трудностями распараллеливания и постоянного выделения памяти при каждом шаге рекурсивного вызова этого метода, был выбран предыдущий способ вычисления.

=== Вычислительное ядро алгоритма ===

Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.

=== Макроструктура алгоритма ===

Основную часть метода составляют вычисления значений степени -1 для каждого элемента:

: <math>\sum_{j=0}^n k_j l_j</math>.

Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.

=== Схема реализации последовательного алгоритма ===

Последовательность исполнения метода следующая:

1. Побитовое умножение <math>k\&l</math>;

2. Вычисление количества единиц двоичной записи;

3. Определение знака элемента по степени.

=== Последовательная сложность алгоритма ===

Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма

:<math>
T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}.
</math>

=== Информационный граф ===

На рисунке ниже изображен информационный граф алгоритма.

*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный.

[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]

=== Ресурс параллелизма алгоритма ===

Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:
* <math>N^2</math> вычислений побитового умножения,
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,
* <math>N^2</math> для определения знака значения элемента.

Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна O(n^2).

=== Входные и выходные данные алгоритма ===

'''Входные данные''': n - размерность матрицы <math>H_n</math>.

'''Объём входных данных''': 1 (число n).

'''Выходные данные''': матрица Адамара <math>H_n</math> размерностью <math>2^n\times 2^n</math>.

'''Объём выходных данных''': <math>2^{2n}</math>.

=== Свойства алгоритма ===

* Соотношение последовательной и параллельной сложности:
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом:

:<math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.

Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.

Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.
:<math>\frac{T(n)}{T(n,p)}=P</math>.
то есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;

* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right).</math>;

* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размерности 2''n'' × 2''n'');

* Степень исхода вершины информационного графа равна 1;

* Алгоритм построения матрицы Адамара является ''сбалансированным''. Так как количество вершин на разных процессорах одинаково, то алгоритм является сбалансированным по числу операций на каждом процессоре.

=ЧАСТЬ Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==

В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:

<source lang="C">
void adamar(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2); // h - нормализующий множитель
N = pow(2,n);

for(i=0;i<N;++i)
{
for(j=0;j<N;++j)
{
ij = i & j;
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij
if(l%2==0) H[i][j] = h;
else H[i][j] = -h;
}
}
}
</source>

Также существует рекурсивная реализация метода генерации матрицы Адамара

<source lang="C">
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель
{
if(n==1) H[i][j] = h;
else
{
adamar(H, N/2, i, j, h);
adamar(H, N/2, i, N/2+j, h);
adamar(H, N/2, N/2+i, j, h);
adamar(H, N/2, N/2+i, N/2+j, -h);
}
}
</source>

Или эквивалентный безрекурсивный вариант:

<source lang="C">
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2);
N = pow(2,n);
k=2;
H[0][0] = h;

while(k<=N)
{
for (i=0; i<k; ++i)
{
for (j=0; j<k; ++j)
{
if (i<k/2 && j<k/2)
{
}
else
{
if(i>=k/2 && j>=k/2)
{
H[i][j] = -(H[i-k/2][j-k/2]);
}
else
{
if (i>j)
{
H[i][j] = H[i-k/2][j];
}
else
{
H[i][j] = H[i][j-k/2];
}
}
}
}
}

k=k*2;
}
}
</source>

Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у последовательной (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).

== Локальность данных и вычислений ==

== Возможные способы и особенности параллельной реализации алгоритма ==

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

Масштабируемость алгоритма определяет свойства самого алгоритма безотносительно конкретных особенностей используемого компьютера. Она показывает, насколько параллельные свойства алгоритма позволяют использовать возможности растущего числа процессорных элементов. Масштабируемость параллельных программ определяется как относительно конкретного компьютера, так и относительно используемой технологии программирования, и в этом случае она показывает, насколько может вырасти реальная производительность данного компьютера на данной программе, записанной с помощью данной технологии программирования, при использовании бóльших вычислительных ресурсов (ядер, процессоров, вычислительных узлов).

Ключевой момент данного раздела заключается в том, чтобы показать ''реальные параметры масштабируемости программы'' для данного алгоритма на различных вычислительных платформах в зависимости от числа процессоров и размера задачи [4]. При этом важно подобрать такое соотношение между числом процессоров и размером задачи, чтобы отразить все характерные точки в поведении параллельной программы, в частности, достижение максимальной производительности, а также тонкие эффекты, возникающие, например, из-за блочной структуры алгоритма или иерархии памяти.

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

== Динамические характеристики и эффективность реализации алгоритма ==

== Выводы для классов архитектур ==

== Существующие реализации алгоритма ==

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave];
# ...

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH];
# ...

= Литература =
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.

[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]

[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

[5] Воеводин В.В.. Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.

[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)

Участник:Бугаков Юрий/Построение матрицы Адамара произвольной размерности

2016-10-15T19:54:59Z

Бугаков Юрий: /* Общее описание алгоритма */

{{Assignment}}

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.

Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие

:<math> H_m\,H_m^T = m\,E_m </math>

Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны [1]. Также, можно увидеть из определения, что m четно и
:<math>
H_{2m} =
\begin{pmatrix}
H_{m} & H_{m}\\
H_{m} & -H_{m}\end{pmatrix}
</math>

С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).

Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 (например [2],[3] и [4]). В дальнейшем будут рассматриваться только такие случаи. Переопределение матрицы Адамара будет выглядеть следующим образом:

'''Матрица Адамара ''H''''n'' - это матрица размера 2''n'' × 2''n'', для которой справедливо равенство'''

:<math>H_n = H_{1} \otimes H_{n-1}</math>,

:<math>\begin{align}
H_1 = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>,
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''

Представим некоторые частные примеры матриц Адамара:

:<math>
H_0 = +1,
</math>

:<math>
H_1 = \frac{1}{\sqrt2}
\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
</math>,

:<math>
H_2 = \frac{1}{2}
\begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>,

:<math>
H_3 = \frac{1}{2^{\frac{3}{2}}}
\begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>.

=== Математическое описание алгоритма ===

Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math>, размерностью <math>2^n\times 2^n</math> можно вычислить поэлементно ([3], [4]):

:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,

где ''k''''j'' и ''l''''j'' коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):

: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math>

и
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.

Помимо этой формулы чаще всего используется заполнение по определению. В связи с трудностями распараллеливания и постоянного выделения памяти при каждом шаге рекурсивного вызова этого метода, был выбран предыдущий способ вычисления.

=== Вычислительное ядро алгоритма ===

Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.

=== Макроструктура алгоритма ===

Основную часть метода составляют вычисления значений степени -1 для каждого элемента:

: <math>\sum_{j=0}^n k_j l_j</math>.

Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.

=== Схема реализации последовательного алгоритма ===

Последовательность исполнения метода следующая:

1. Побитовое умножение <math>k\&l</math>;

2. Вычисление количества единиц двоичной записи;

3. Определение знака элемента по степени.

=== Последовательная сложность алгоритма ===

Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма

:<math>
T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}.
</math>

=== Информационный граф ===

На рисунке ниже изображен информационный граф алгоритма.

*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный.

[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]

=== Ресурс параллелизма алгоритма ===

Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:
* <math>N^2</math> вычислений побитового умножения,
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,
* <math>N^2</math> для определения знака значения элемента.

Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна O(n^2).

=== Входные и выходные данные алгоритма ===

'''Входные данные''': n - размерность матрицы <math>H_n</math>.

'''Объём входных данных''': 1 (число n).

'''Выходные данные''': матрица Адамара <math>H_n</math> размерностью <math>2^n\times 2^n</math>.

'''Объём выходных данных''': <math>2^{2n}</math>.

=== Свойства алгоритма ===

* Соотношение последовательной и параллельной сложности:
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом:

:<math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.

Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.

Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.
:<math>\frac{T(n)}{T(n,p)}=P</math>.
то есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;

* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right).</math>;

* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размерности 2''n'' × 2''n'');

* Степень исхода вершины информационного графа равна 1;

* Алгоритм построения матрицы Адамара является ''сбалансированным''. Так как количество вершин на разных процессорах одинаково, то алгоритм является сбалансированным по числу операций на каждом процессоре.

=ЧАСТЬ Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==

В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:

<source lang="C">
void adamar(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2); // h - нормализующий множитель
N = pow(2,n);

for(i=0;i<N;++i)
{
for(j=0;j<N;++j)
{
ij = i & j;
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij
if(l%2==0) H[i][j] = h;
else H[i][j] = -h;
}
}
}
</source>

Также существует рекурсивная реализация метода генерации матрицы Адамара

<source lang="C">
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель
{
if(n==1) H[i][j] = h;
else
{
adamar(H, N/2, i, j, h);
adamar(H, N/2, i, N/2+j, h);
adamar(H, N/2, N/2+i, j, h);
adamar(H, N/2, N/2+i, N/2+j, -h);
}
}
</source>

Или эквивалентный безрекурсивный вариант:

<source lang="C">
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2);
N = pow(2,n);
k=2;
H[0][0] = h;

while(k<=N)
{
for (i=0; i<k; ++i)
{
for (j=0; j<k; ++j)
{
if (i<k/2 && j<k/2)
{
}
else
{
if(i>=k/2 && j>=k/2)
{
H[i][j] = -(H[i-k/2][j-k/2]);
}
else
{
if (i>j)
{
H[i][j] = H[i-k/2][j];
}
else
{
H[i][j] = H[i][j-k/2];
}
}
}
}
}

k=k*2;
}
}
</source>

Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у последовательной (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).

== Локальность данных и вычислений ==

== Возможные способы и особенности параллельной реализации алгоритма ==

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

Масштабируемость алгоритма определяет свойства самого алгоритма безотносительно конкретных особенностей используемого компьютера. Она показывает, насколько параллельные свойства алгоритма позволяют использовать возможности растущего числа процессорных элементов. Масштабируемость параллельных программ определяется как относительно конкретного компьютера, так и относительно используемой технологии программирования, и в этом случае она показывает, насколько может вырасти реальная производительность данного компьютера на данной программе, записанной с помощью данной технологии программирования, при использовании бóльших вычислительных ресурсов (ядер, процессоров, вычислительных узлов).

Ключевой момент данного раздела заключается в том, чтобы показать ''реальные параметры масштабируемости программы'' для данного алгоритма на различных вычислительных платформах в зависимости от числа процессоров и размера задачи [4]. При этом важно подобрать такое соотношение между числом процессоров и размером задачи, чтобы отразить все характерные точки в поведении параллельной программы, в частности, достижение максимальной производительности, а также тонкие эффекты, возникающие, например, из-за блочной структуры алгоритма или иерархии памяти.

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

== Динамические характеристики и эффективность реализации алгоритма ==

== Выводы для классов архитектур ==

== Существующие реализации алгоритма ==

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave];
# ...

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH];
# ...

= Литература =
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.

[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]

[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

[5] Воеводин В.В.. Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.

[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)

Участник:Бугаков Юрий/Построение матрицы Адамара произвольной размерности

2016-10-15T19:53:16Z

Бугаков Юрий: /* Общее описание алгоритма */

{{Assignment}}

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.

Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие

:<math> H_m\,H_m^T = m\,E_m </math>

Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны [1]. Также, можно увидеть из определения, что m четно и
:<math>
H_{2m} =
\begin{pmatrix}
H_{m} & H_{m}\\
H_{m} & -H_{m}\end{pmatrix}
</math>

С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).

Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 (например [2],[3] и [4]). В дальнейшем будут рассматриваться только такие случаи. Переопределим матрицу Адамара следующим образом:

'''Матрица Адамара ''H''''n'' - это матрица размера 2''n'' × 2''n'', для которой справедливо равенство'''

:<math>H_n = H_{1} \otimes H_{n-1}</math>,

:<math>\begin{align}
H_1 = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>,
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''

Представим некоторые частные примеры матриц Адамара:

:<math>
H_0 = +1,
</math>

:<math>
H_1 = \frac{1}{\sqrt2}
\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
</math>,

:<math>
H_2 = \frac{1}{2}
\begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>,

:<math>
H_3 = \frac{1}{2^{\frac{3}{2}}}
\begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>.

=== Математическое описание алгоритма ===

Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math>, размерностью <math>2^n\times 2^n</math> можно вычислить поэлементно ([3], [4]):

:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,

где ''k''''j'' и ''l''''j'' коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):

: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math>

и
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.

Помимо этой формулы чаще всего используется заполнение по определению. В связи с трудностями распараллеливания и постоянного выделения памяти при каждом шаге рекурсивного вызова этого метода, был выбран предыдущий способ вычисления.

=== Вычислительное ядро алгоритма ===

Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.

=== Макроструктура алгоритма ===

Основную часть метода составляют вычисления значений степени -1 для каждого элемента:

: <math>\sum_{j=0}^n k_j l_j</math>.

Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.

=== Схема реализации последовательного алгоритма ===

Последовательность исполнения метода следующая:

1. Побитовое умножение <math>k\&l</math>;

2. Вычисление количества единиц двоичной записи;

3. Определение знака элемента по степени.

=== Последовательная сложность алгоритма ===

Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма

:<math>
T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}.
</math>

=== Информационный граф ===

На рисунке ниже изображен информационный граф алгоритма.

*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный.

[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]

=== Ресурс параллелизма алгоритма ===

Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:
* <math>N^2</math> вычислений побитового умножения,
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,
* <math>N^2</math> для определения знака значения элемента.

Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна O(n^2).

=== Входные и выходные данные алгоритма ===

'''Входные данные''': n - размерность матрицы <math>H_n</math>.

'''Объём входных данных''': 1 (число n).

'''Выходные данные''': матрица Адамара <math>H_n</math> размерностью <math>2^n\times 2^n</math>.

'''Объём выходных данных''': <math>2^{2n}</math>.

=== Свойства алгоритма ===

* Соотношение последовательной и параллельной сложности:
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом:

:<math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.

Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.

Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.
:<math>\frac{T(n)}{T(n,p)}=P</math>.
то есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;

* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right).</math>;

* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размерности 2''n'' × 2''n'');

* Степень исхода вершины информационного графа равна 1;

* Алгоритм построения матрицы Адамара является ''сбалансированным''. Так как количество вершин на разных процессорах одинаково, то алгоритм является сбалансированным по числу операций на каждом процессоре.

=ЧАСТЬ Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==

В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:

<source lang="C">
void adamar(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2); // h - нормализующий множитель
N = pow(2,n);

for(i=0;i<N;++i)
{
for(j=0;j<N;++j)
{
ij = i & j;
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij
if(l%2==0) H[i][j] = h;
else H[i][j] = -h;
}
}
}
</source>

Также существует рекурсивная реализация метода генерации матрицы Адамара

<source lang="C">
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель
{
if(n==1) H[i][j] = h;
else
{
adamar(H, N/2, i, j, h);
adamar(H, N/2, i, N/2+j, h);
adamar(H, N/2, N/2+i, j, h);
adamar(H, N/2, N/2+i, N/2+j, -h);
}
}
</source>

Или эквивалентный безрекурсивный вариант:

<source lang="C">
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2);
N = pow(2,n);
k=2;
H[0][0] = h;

while(k<=N)
{
for (i=0; i<k; ++i)
{
for (j=0; j<k; ++j)
{
if (i<k/2 && j<k/2)
{
}
else
{
if(i>=k/2 && j>=k/2)
{
H[i][j] = -(H[i-k/2][j-k/2]);
}
else
{
if (i>j)
{
H[i][j] = H[i-k/2][j];
}
else
{
H[i][j] = H[i][j-k/2];
}
}
}
}
}

k=k*2;
}
}
</source>

Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у последовательной (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).

== Локальность данных и вычислений ==

== Возможные способы и особенности параллельной реализации алгоритма ==

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

Масштабируемость алгоритма определяет свойства самого алгоритма безотносительно конкретных особенностей используемого компьютера. Она показывает, насколько параллельные свойства алгоритма позволяют использовать возможности растущего числа процессорных элементов. Масштабируемость параллельных программ определяется как относительно конкретного компьютера, так и относительно используемой технологии программирования, и в этом случае она показывает, насколько может вырасти реальная производительность данного компьютера на данной программе, записанной с помощью данной технологии программирования, при использовании бóльших вычислительных ресурсов (ядер, процессоров, вычислительных узлов).

Ключевой момент данного раздела заключается в том, чтобы показать ''реальные параметры масштабируемости программы'' для данного алгоритма на различных вычислительных платформах в зависимости от числа процессоров и размера задачи [4]. При этом важно подобрать такое соотношение между числом процессоров и размером задачи, чтобы отразить все характерные точки в поведении параллельной программы, в частности, достижение максимальной производительности, а также тонкие эффекты, возникающие, например, из-за блочной структуры алгоритма или иерархии памяти.

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

== Динамические характеристики и эффективность реализации алгоритма ==

== Выводы для классов архитектур ==

== Существующие реализации алгоритма ==

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave];
# ...

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH];
# ...

= Литература =
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.

[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]

[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

[5] Воеводин В.В.. Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.

[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)

Участник:Бугаков Юрий/Построение матрицы Адамара произвольной размерности

2016-10-15T19:48:25Z

Бугаков Юрий:

{{Assignment}}

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.

Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие

:<math> H_m\,H_m^T = m\,E_m </math>

Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны [1]. Также, можно увидеть из определения, что m четно и
:<math>
H_{2m} =
\begin{pmatrix}
H_{m} & H_{m}\\
H_{m} & -H_{m}\end{pmatrix}
</math>

С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).

Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 (например [2],[3] и [4]). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара следующим образом:

'''Матрица Адамара ''H''''n'' - это матрица размера 2''n'' × 2''n'', для которой справедливо равенство'''

:<math>H_n = H_{1} \otimes H_{n-1}</math>,

:<math>\begin{align}
H_1 = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>,
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''

Представим некоторые частные примеры матриц Адамара:

:<math>
H_0 = +1,
</math>

:<math>
H_1 = \frac{1}{\sqrt2}
\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
</math>,

:<math>
H_2 = \frac{1}{2}
\begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>,

:<math>
H_3 = \frac{1}{2^{\frac{3}{2}}}
\begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>.

=== Математическое описание алгоритма ===

Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math>, размерностью <math>2^n\times 2^n</math> можно вычислить поэлементно ([3], [4]):

:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,

где ''k''''j'' и ''l''''j'' коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):

: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math>

и
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.

Помимо этой формулы чаще всего используется заполнение по определению. В связи с трудностями распараллеливания и постоянного выделения памяти при каждом шаге рекурсивного вызова этого метода, был выбран предыдущий способ вычисления.

=== Вычислительное ядро алгоритма ===

Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.

=== Макроструктура алгоритма ===

Основную часть метода составляют вычисления значений степени -1 для каждого элемента:

: <math>\sum_{j=0}^n k_j l_j</math>.

Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.

=== Схема реализации последовательного алгоритма ===

Последовательность исполнения метода следующая:

1. Побитовое умножение <math>k\&l</math>;

2. Вычисление количества единиц двоичной записи;

3. Определение знака элемента по степени.

=== Последовательная сложность алгоритма ===

Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма

:<math>
T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}.
</math>

=== Информационный граф ===

На рисунке ниже изображен информационный граф алгоритма.

*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный.

[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]

=== Ресурс параллелизма алгоритма ===

Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:
* <math>N^2</math> вычислений побитового умножения,
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,
* <math>N^2</math> для определения знака значения элемента.

Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна O(n^2).

=== Входные и выходные данные алгоритма ===

'''Входные данные''': n - размерность матрицы <math>H_n</math>.

'''Объём входных данных''': 1 (число n).

'''Выходные данные''': матрица Адамара <math>H_n</math> размерностью <math>2^n\times 2^n</math>.

'''Объём выходных данных''': <math>2^{2n}</math>.

=== Свойства алгоритма ===

* Соотношение последовательной и параллельной сложности:
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом:

:<math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.

Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.

Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.
:<math>\frac{T(n)}{T(n,p)}=P</math>.
то есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;

* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right).</math>;

* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размерности 2''n'' × 2''n'');

* Степень исхода вершины информационного графа равна 1;

* Алгоритм построения матрицы Адамара является ''сбалансированным''. Так как количество вершин на разных процессорах одинаково, то алгоритм является сбалансированным по числу операций на каждом процессоре.

=ЧАСТЬ Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==

В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:

<source lang="C">
void adamar(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2); // h - нормализующий множитель
N = pow(2,n);

for(i=0;i<N;++i)
{
for(j=0;j<N;++j)
{
ij = i & j;
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij
if(l%2==0) H[i][j] = h;
else H[i][j] = -h;
}
}
}
</source>

Также существует рекурсивная реализация метода генерации матрицы Адамара

<source lang="C">
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель
{
if(n==1) H[i][j] = h;
else
{
adamar(H, N/2, i, j, h);
adamar(H, N/2, i, N/2+j, h);
adamar(H, N/2, N/2+i, j, h);
adamar(H, N/2, N/2+i, N/2+j, -h);
}
}
</source>

Или эквивалентный безрекурсивный вариант:

<source lang="C">
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2);
N = pow(2,n);
k=2;
H[0][0] = h;

while(k<=N)
{
for (i=0; i<k; ++i)
{
for (j=0; j<k; ++j)
{
if (i<k/2 && j<k/2)
{
}
else
{
if(i>=k/2 && j>=k/2)
{
H[i][j] = -(H[i-k/2][j-k/2]);
}
else
{
if (i>j)
{
H[i][j] = H[i-k/2][j];
}
else
{
H[i][j] = H[i][j-k/2];
}
}
}
}
}

k=k*2;
}
}
</source>

Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у последовательной (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).

== Локальность данных и вычислений ==

== Возможные способы и особенности параллельной реализации алгоритма ==

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

Масштабируемость алгоритма определяет свойства самого алгоритма безотносительно конкретных особенностей используемого компьютера. Она показывает, насколько параллельные свойства алгоритма позволяют использовать возможности растущего числа процессорных элементов. Масштабируемость параллельных программ определяется как относительно конкретного компьютера, так и относительно используемой технологии программирования, и в этом случае она показывает, насколько может вырасти реальная производительность данного компьютера на данной программе, записанной с помощью данной технологии программирования, при использовании бóльших вычислительных ресурсов (ядер, процессоров, вычислительных узлов).

Ключевой момент данного раздела заключается в том, чтобы показать ''реальные параметры масштабируемости программы'' для данного алгоритма на различных вычислительных платформах в зависимости от числа процессоров и размера задачи [4]. При этом важно подобрать такое соотношение между числом процессоров и размером задачи, чтобы отразить все характерные точки в поведении параллельной программы, в частности, достижение максимальной производительности, а также тонкие эффекты, возникающие, например, из-за блочной структуры алгоритма или иерархии памяти.

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

== Динамические характеристики и эффективность реализации алгоритма ==

== Выводы для классов архитектур ==

== Существующие реализации алгоритма ==

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave];
# ...

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH];
# ...

= Литература =
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.

[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]

[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

[5] Воеводин В.В.. Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.

[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)

Обсуждение участника:Lineprinter

2016-10-15T19:46:45Z

Бугаков Юрий:

== Перенос ==
Статья: [[Кластеризация сетями Кохонена]]
Выполняют: [[Участник:Kravtsovkirill| Кравцов Кирилл]] и [[Участник:Emaksimov| Максимов Егор]]

Статья: [[Нахождение собственных чисел квадратной матрицы методом QR разложения (2)]]
Выполняют: Баев Олег и Шевелев Александр

Статья: [[Стабилизированный метод биспоряженных градиентов (BiCGSTAB)]]
Выполняют: Гаврилов Алексей и Новиков Александр

Статья: [[Участники: Бобошко А., Юмакаева А./Решение начальной задачи Коши для системы ОДУ методом Рунге-Кутта 4-го порядка]];
Выполняют: Бобошко Алексей и Юмакаева Алина

Статья: [[Алгоритм кластеризации, основанный на сетях Кохоннена]];
Выполняют: Логвиненко Александра и Адиев Тохтар

Статья: [[Ортогонализация Грама-Шмидта]];
Выполняют: [[Участник:KibAndrey| Кибанов Андрей]] и Аджиева Татьяна

Статья: [[Самоорганизующиеся карты Кохонена]];
Выполняет: [[Участник:Anton goy| Гой Антон]]

Статья:[[ЕМ-алгоритм_(Тематическое_моделирование)]];
Выполняют: Мурат Апишев и Андрей Заночкин

Статья:[[Алгоритм_Ланцоша_с_полной_переортогонализацией]];
Выполняет:[[Участник:Sfedotov| Федотов С.А.]]

Статья: [[Алгоритм_k-средних]]
Выполняют: [[Участник:Error2407|Богомазов Евгений]], [[Участник:Илья_Егоров|Егоров Илья]]

Статья: [[Алгоритм k-means]]
Выполняют: [[Участник:Бротиковская Данута|Данута Бротиковская]] и [[Участник:DennZo1993|Денис Зобнин]]

Статья: [[Нечеткий_алгоритм_С_средних]]
Выполняют: [[Участник:Demon smd|Д.А.Гуськов]], [[Участник:marina abramenkova|М.А.Абраменкова]]

Статья: [[Решение_задачи_Коши_для_системы_ОДУ_методом_Рунге-Кутты_4_порядка]];
Выполняют: [[Участник:Алимов_Дамир_Алиевич|Алимов Дамир]] и [[Участник:Anlesnichiy|Антон Лесничий]]

Статья: [[Строгий_алгоритм_С_средних_(Hard_C-Means,_HCM)]];
Выполняют: [[Участник:Светлана_Лукьяненко|Лукьяненко Светлана]] и [[Участник:Юрий_Комаров|Комаров Юрий]]

Статья: [[Алгоритм кластеризации, основанный на минимальном остовном дереве]];
Выполняет: [[Участник:Astandrik | Стандрик Антон Сергеевич]]

Статья: [[Умножение разреженной матрицы на вектор]];
Выполняет: [[Участник:Lexaloris | Новоселов Алексей]], Выполняет: [[Участник:kochet|П.А. Кочетков]]

Статья: [[Нахождение_собственных_чисел_квадратной_матрицы_методом_QR_разложения_(3)|Нахождение собственных чисел квадратной матрицы методом QR разложения (3)]];
Выполняют: [[Участник:Смирнова_Александра|Смирнова А.С.]], [[Участник:Александра_Киямова|Киямова А.]]

Статья: [[Метод_Якоби_вычисления_сингулярных_чисел_и_векторов]];
Выполняют: [[Участница:Почернина_Елена| Почернина Елена]] и [[Участница:Светлана|Костюкова Светлана]]

Статья: [[Метод_Ньютона_для_решения_систем_нелинейных_уравнений(2)]];
Выполняют: [[Участник:Oleggium|Гирняк О.Р.]], [[Участник:Dimx19|Васильков Д.А.]]

Статья: [[Алгоритм_кластеризации_с_использованием_представлений]];
Выполняют: [[Участник:Cookie|Шатков С.А.]], [[Участница:JuliaA|Антохина Ю.А.]]

Статья: [[Быстрое_преобразование_Фурье_(FFT)|Быстрое преобразование Фурье (FFT)]];
Выполняют: [[Участник:Victoria_Stepanischeva|Степанищева Виктория]] и [[Участник:Igor_Munkin|Мунькин Игорь]]

Статья: [[Быстрое_дискретное_преобразование_Фурье|Быстрое_дискретное_преобразование_Фурье]];
Выполняют: [[Участник:ivanov.kir.m | К.М.Иванов]], [[Участник:Pumpkin | А.C.Сапин]]

Статья:[[Алгоритм_k_средних]]
Выполняют: [[Участник:Parkhomenko|Пархоменко Павел]], [[Участник:ivan.mashonskiy|Машонский Иван]]

Статья:[[EM-алгоритм_кластеризации]]
Выполняет: [[Участник:Noite|Зинченко Дмитрий]]

Статья:[[Алгоритм_k_means]]
Выполняют: [[Участник:IanaV| Валуйская Яна]], [[Участник:GlotovES| Глотов Евгений]]

Статья: [[Метод Якоби вычисления собственных значений симметричной матрицы ЗП |Метод Якоби вычисления собственных значений симметричной матрицы ЗП]];
Выполняют: [[Участник:Зиновьев Владимир|Зиновьев В.С.]], [[Участник:Пронин Андрей|Пронин А.М.]]

Статья:[[Алгоритм_кластеризации,_основанный_на_минимальном_покрывающем_дереве]]
Выполняет: [[Участник:Kanast74|Дмитриева Анастасия]]

Статья:[[Нахождение_собственных_чисел_квадратной_матрицы_методом_QR_разложения_(4)]]
Выполняют: [[Участник:F-morozov|Морозов Ф. В.]], [[Участник:Nataliya|Пащенко Н. Ф.]]

Статья:[[Хранение_ненулевых_элементов_разреженных_матриц._Умножение_разреженной_матрицы_на_вектор]];
Выполняют: [[Участник:Trrufina|Третьякова Р.М.]] и [[Участник:Екатерина_Буторина|Буторина Е.В.]]

Статья: [[Алгоритм_кластеризации_с_использованием_представлений2]];
Выполняет: [[Участник:Лукьянова Анна|Лукьянова А.Я.]]

Статья: [[Метод Якоби вычисления собственных значений симметричной матрицы]];
Выполняют: [[Участник: Galkina|Галкина А.С.]], [[Участник: Игорь|Плахов И.А.]]

Статья: [[Метод рекурсивной координатной бисекции]];
Выполняют: [[Участник: Obirvalger|Гордеев Михаил]], [[Участник: KolmakovEA|Колмаков Евгений]]

Статья: [[Итерационный метод решения системы линейных алгебраических уравнений GMRES (обобщенный метод минимальных невязок)]];
Выполняют: [[Участник: Эльвира Ахиярова|Ахиярова Эльвира]]

Статья: [[Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор]];
Выполняют: [[Участник: Janyell|Сычева Евгения]], [[Участник: Ahahalin|Хахалин Анатолий]]

Статья: [[Построение матрицы Адамара произвольного размера]];
Выполняют: [[Участник: Бугаков Юрий|Бугаков Юрий]], Кужамалиев Ернур

Статья: [[Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки (1)]]
Выполняют: [[Участница:Sannikovats| Санникова Татьяна Сергеевна]], [[Участник:Plukshin| Лукшин Петр Андреевич]]

Статья: [[Алгоритм кластеризации, основанный на построении каркаса]];
Выполняют: [[Участник:SenderovichNikita| Сендерович Никита]]

Статья: [[Алгоритм кластеризации, основанный на максимизации ожидания]];
Выполняют: Готман Мария, Лукашкина Юлия

Статья: [[Partitioning_Around_Medoids_(PAM)]]
Выполняют: [[Участник:Avasilenko|А.Э.Василенко]], [[Участник:Anastasia|А.В.Тузикова]]

Статья: [[Нечеткий алгоритм С-средних (Fuzzy C-means)]]
Выполняют: [[Участник:Nikmedoed|Н.А. Муромцев]], [[Участник:illusive_mike|М.С. Дворецкий]]

Статья: [[Нечеткий алгоритм C средних]]
Выполняют: [[Участник:Gkhazeeva|Гелана Хазеева]], [[Участник:Yushin|Павел Юшин]]

Статья: [[Плотностный алгоритм кластеризации DBSCAN]]
Выполняют: [[Участник:Elena777mc|Малахова Е.С.]], [[Участник:Жаннат_Сагиолданова|Сагиолданова Ж.]]

Статья: [[Кластеризация Partitioning Around Medoids (PAM)]]
Выполняют:[[ Участник:Тодуа Антон| Тодуа Антон]], [[Участник:Гусева Юлия| Гусева Юлия]]

Статья: [[Участник:Бугаков Юрий (613 группа), Кужамалиев Ернур (601 группа)/Построение матрицы Адамара произвольной размерности]]
Выполняют:[[ Участник:Бугаков Юрий| Бугаков Юрий]], [[Участник:Кужамалиев Ернур| Кужамалиев Ернур]]

Участник:Бугаков Юрий/Построение матрицы Адамара произвольного размера

2016-10-15T19:40:04Z

Бугаков Юрий: Бугаков Юрий переименовал страницу Участника: Бугаков Юрий, Кужамалиев Ернур/Построение матрицы Адамара произвольного размера в [[Обс…

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.

Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие

:<math> H_m\,H_m^T = m\,E_m </math>

Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны [1]. Также, можно увидеть из определения, что m четно и
:<math>
H_{2m} =
\begin{pmatrix}
H_{m} & H_{m}\\
H_{m} & -H_{m}\end{pmatrix}
</math>

С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).

Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 (например [2],[3] и [4]). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара следующим образом:

'''Матрица Адамара ''H''''n'' - это матрица размера 2''n'' × 2''n'', для которой справедливо равенство'''

:<math>H_n = H_{1} \otimes H_{n-1}</math>,

:<math>\begin{align}
H_1 = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>,
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''

Представим некоторые частные примеры матриц Адамара:

:<math>
H_0 = +1,
</math>

:<math>
H_1 = \frac{1}{\sqrt2}
\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
</math>,

:<math>
H_2 = \frac{1}{2}
\begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>,

:<math>
H_3 = \frac{1}{2^{\frac{3}{2}}}
\begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>.

=== Математическое описание алгоритма ===

Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math>, размерностью <math>2^n\times 2^n</math> можно вычислить поэлементно ([3], [4]):

:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,

где ''k''''j'' и ''l''''j'' коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):

: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math>

и
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.

Помимо этой формулы чаще всего используется заполнение по определению. В связи с трудностями распараллеливания и постоянного выделения памяти при каждом шаге рекурсивного вызова этого метода, был выбран предыдущий способ вычисления.

=== Вычислительное ядро алгоритма ===

Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.

=== Макроструктура алгоритма ===

Основную часть метода составляют вычисления значений степени -1 для каждого элемента:

: <math>\sum_{j=0}^n k_j l_j</math>.

Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.

=== Схема реализации последовательного алгоритма ===

Последовательность исполнения метода следующая:

1. Побитовое умножение <math>k\&l</math>;

2. Вычисление количества единиц двоичной записи;

3. Определение знака элемента по степени.

=== Последовательная сложность алгоритма ===

Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма

:<math>
T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}.
</math>

=== Информационный граф ===

На рисунке ниже изображен информационный граф алгоритма.

*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный.

[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]

=== Ресурс параллелизма алгоритма ===

Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:
* <math>N^2</math> вычислений побитового умножения,
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,
* <math>N^2</math> для определения знака значения элемента.

Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна O(n^2).

=== Входные и выходные данные алгоритма ===

'''Входные данные''': n - размерность матрицы <math>H_n</math>.

'''Объём входных данных''': 1 (число n).

'''Выходные данные''': матрица Адамара <math>H_n</math> размерностью <math>2^n\times 2^n</math>.

'''Объём выходных данных''': <math>2^{2n}</math>.

=== Свойства алгоритма ===

* Соотношение последовательной и параллельной сложности:
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом:

:<math>T(n,P)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.

Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.

Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.
:<math>\frac{T(n)}{T(n,p)}=P</math>.
то есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;

* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right).</math>;

* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размерности 2''n'' × 2''n'');

* Степень исхода вершины информационного графа равна 1;

* Алгоритм построения матрицы Адамара является ''сбалансированным''. Так как количество вершин на разных процессорах одинаково, то алгоритм является сбалансированным по числу операций на каждом процессоре.

=ЧАСТЬ Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==

В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:

<source lang="C">
void adamar(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2); // h - нормализующий множитель
N = pow(2,n);

for(i=0;i<N;++i)
{
for(j=0;j<N;++j)
{
ij = i & j;
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij
if(l%2==0) H[i][j] = h;
else H[i][j] = -h;
}
}
}
</source>

Также существует рекурсивная реализация метода генерации матрицы Адамара

<source lang="C">
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель
{
if(n==1) H[i][j] = h;
else
{
adamar(H, N/2, i, j, h);
adamar(H, N/2, i, N/2+j, h);
adamar(H, N/2, N/2+i, j, h);
adamar(H, N/2, N/2+i, N/2+j, -h);
}
}
</source>

Или эквивалентный безрекурсивный вариант:

<source lang="C">
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2);
N = pow(2,n);
k=2;
H[0][0] = h;

while(k<=N)
{
for (i=0; i<k; ++i)
{
for (j=0; j<k; ++j)
{
if (i<k/2 && j<k/2)
{
}
else
{
if(i>=k/2 && j>=k/2)
{
H[i][j] = -(H[i-k/2][j-k/2]);
}
else
{
if (i>j)
{
H[i][j] = H[i-k/2][j];
}
else
{
H[i][j] = H[i][j-k/2];
}
}
}
}
}

k=k*2;
}
}
</source>

Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у последовательной (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).

== Локальность данных и вычислений ==

== Возможные способы и особенности параллельной реализации алгоритма ==

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

Масштабируемость алгоритма определяет свойства самого алгоритма безотносительно конкретных особенностей используемого компьютера. Она показывает, насколько параллельные свойства алгоритма позволяют использовать возможности растущего числа процессорных элементов. Масштабируемость параллельных программ определяется как относительно конкретного компьютера, так и относительно используемой технологии программирования, и в этом случае она показывает, насколько может вырасти реальная производительность данного компьютера на данной программе, записанной с помощью данной технологии программирования, при использовании бóльших вычислительных ресурсов (ядер, процессоров, вычислительных узлов).

Ключевой момент данного раздела заключается в том, чтобы показать ''реальные параметры масштабируемости программы'' для данного алгоритма на различных вычислительных платформах в зависимости от числа процессоров и размера задачи [4]. При этом важно подобрать такое соотношение между числом процессоров и размером задачи, чтобы отразить все характерные точки в поведении параллельной программы, в частности, достижение максимальной производительности, а также тонкие эффекты, возникающие, например, из-за блочной структуры алгоритма или иерархии памяти.

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

== Динамические характеристики и эффективность реализации алгоритма ==

== Выводы для классов архитектур ==

== Существующие реализации алгоритма ==

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave];
# ...

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH];
# ...

= Литература =
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.

[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]

[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

[5] Воеводин В.В.. Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.

[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)

Участник:Бугаков Юрий/Построение матрицы Адамара произвольной размерности

2016-10-15T19:39:29Z

Бугаков Юрий:

Участник:Бугаков Юрий/Построение матрицы Адамара произвольного размера

2016-10-15T19:37:40Z

Бугаков Юрий: Бугаков Юрий переименовал страницу Построение матрицы Адамара произвольного размера в [[Участника: Бугаков Юрий, Кужамалиев Ернур/Пос…

Участник:Бугаков Юрий/Построение матрицы Адамара произвольного размера

2016-10-15T19:33:14Z

Бугаков Юрий: /* Свойства алгоритма */

Участник:Бугаков Юрий/Построение матрицы Адамара произвольного размера

2016-10-15T19:32:12Z

Бугаков Юрий: /* Свойства алгоритма */

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.

Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие

:<math> H_m\,H_m^T = m\,E_m </math>

Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны [1]. Также, можно увидеть из определения, что m четно и
:<math>
H_{2m} =
\begin{pmatrix}
H_{m} & H_{m}\\
H_{m} & -H_{m}\end{pmatrix}
</math>

С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).

Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 (например [2],[3] и [4]). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара следующим образом:

'''Матрица Адамара ''H''''n'' - это матрица размера 2''n'' × 2''n'', для которой справедливо равенство'''

:<math>H_n = H_{1} \otimes H_{n-1}</math>,

:<math>\begin{align}
H_1 = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>,
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''

Представим некоторые частные примеры матриц Адамара:

:<math>
H_0 = +1,
</math>

:<math>
H_1 = \frac{1}{\sqrt2}
\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
</math>,

:<math>
H_2 = \frac{1}{2}
\begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>,

:<math>
H_3 = \frac{1}{2^{\frac{3}{2}}}
\begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>.

=== Математическое описание алгоритма ===

Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math>, размерностью <math>2^n\times 2^n</math> можно вычислить поэлементно ([3], [4]):

:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,

где ''k''''j'' и ''l''''j'' коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):

: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math>

и
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.

Помимо этой формулы чаще всего используется заполнение по определению. В связи с трудностями распараллеливания и постоянного выделения памяти при каждом шаге рекурсивного вызова этого метода, был выбран предыдущий способ вычисления.

=== Вычислительное ядро алгоритма ===

Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.

=== Макроструктура алгоритма ===

Основную часть метода составляют вычисления значений степени -1 для каждого элемента:

: <math>\sum_{j=0}^n k_j l_j</math>.

Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.

=== Схема реализации последовательного алгоритма ===

Последовательность исполнения метода следующая:

1. Побитовое умножение <math>k\&l</math>;

2. Вычисление количества единиц двоичной записи;

3. Определение знака элемента по степени.

=== Последовательная сложность алгоритма ===

Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма

:<math>
T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}.
</math>

=== Информационный граф ===

На рисунке ниже изображен информационный граф алгоритма.

*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный.

[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]

=== Ресурс параллелизма алгоритма ===

Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:
* <math>N^2</math> вычислений побитового умножения,
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,
* <math>N^2</math> для определения знака значения элемента.

Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна O(n^2).

=== Входные и выходные данные алгоритма ===

'''Входные данные''': n - размерность матрицы <math>H_n</math>.

'''Объём входных данных''': 1 (число n).

'''Выходные данные''': матрица Адамара <math>H_n</math> размерностью <math>2^n\times 2^n</math>.

'''Объём выходных данных''': <math>2^{2n}</math>.

=== Свойства алгоритма ===

* Соотношение последовательной и параллельной сложности:
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом:

:<math>T(n,p)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.

Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.

Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.
:<math>\frac{T(n)}{T(n,p)}=P</math>.
то есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>;

* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right).</math>;

* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размерности 2''n'' × 2''n'');

* Степень исхода вершины информационного графа равна 1;

* Алгоритм построения матрицы Адамара является ''сбалансированным''. Так как количество вершин на разных процессорах одинаково, то алгоритм является сбалансированным по числу операций на каждом процессоре.

=ЧАСТЬ Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==

В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:

<source lang="C">
void adamar(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2); // h - нормализующий множитель
N = pow(2,n);

for(i=0;i<N;++i)
{
for(j=0;j<N;++j)
{
ij = i & j;
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij
if(l%2==0) H[i][j] = h;
else H[i][j] = -h;
}
}
}
</source>

Также существует рекурсивная реализация метода генерации матрицы Адамара

<source lang="C">
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель
{
if(n==1) H[i][j] = h;
else
{
adamar(H, N/2, i, j, h);
adamar(H, N/2, i, N/2+j, h);
adamar(H, N/2, N/2+i, j, h);
adamar(H, N/2, N/2+i, N/2+j, -h);
}
}
</source>

Или эквивалентный безрекурсивный вариант:

<source lang="C">
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2);
N = pow(2,n);
k=2;
H[0][0] = h;

while(k<=N)
{
for (i=0; i<k; ++i)
{
for (j=0; j<k; ++j)
{
if (i<k/2 && j<k/2)
{
}
else
{
if(i>=k/2 && j>=k/2)
{
H[i][j] = -(H[i-k/2][j-k/2]);
}
else
{
if (i>j)
{
H[i][j] = H[i-k/2][j];
}
else
{
H[i][j] = H[i][j-k/2];
}
}
}
}
}

k=k*2;
}
}
</source>

Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у последовательной (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).

== Локальность данных и вычислений ==

== Возможные способы и особенности параллельной реализации алгоритма ==

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

Масштабируемость алгоритма определяет свойства самого алгоритма безотносительно конкретных особенностей используемого компьютера. Она показывает, насколько параллельные свойства алгоритма позволяют использовать возможности растущего числа процессорных элементов. Масштабируемость параллельных программ определяется как относительно конкретного компьютера, так и относительно используемой технологии программирования, и в этом случае она показывает, насколько может вырасти реальная производительность данного компьютера на данной программе, записанной с помощью данной технологии программирования, при использовании бóльших вычислительных ресурсов (ядер, процессоров, вычислительных узлов).

Ключевой момент данного раздела заключается в том, чтобы показать ''реальные параметры масштабируемости программы'' для данного алгоритма на различных вычислительных платформах в зависимости от числа процессоров и размера задачи [4]. При этом важно подобрать такое соотношение между числом процессоров и размером задачи, чтобы отразить все характерные точки в поведении параллельной программы, в частности, достижение максимальной производительности, а также тонкие эффекты, возникающие, например, из-за блочной структуры алгоритма или иерархии памяти.

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

== Динамические характеристики и эффективность реализации алгоритма ==

== Выводы для классов архитектур ==

== Существующие реализации алгоритма ==

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave];
# ...

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH];
# ...

= Литература =
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.

[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]

[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

[5] Воеводин В.В.. Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.

[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)

Участник:Бугаков Юрий/Построение матрицы Адамара произвольного размера

2016-10-15T19:30:59Z

Бугаков Юрий: /* Свойства алгоритма */

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Важную роль в алгебре и комбинаторике играют матрицы Адамара, которые впервые были введены в математический обиход в конце прошлого века одним из крупнейших французских математиков [https://ru.wikipedia.org/wiki/%D0%90%D0%B4%D0%B0%D0%BC%D0%B0%D1%80,_%D0%96%D0%B0%D0%BA Жаком Адамаром (1865-1963)]. Их применение в науке и технике посвящены тысячи публикаций. Они предоставляют эффективные возможности для организации хранения, обработки и передачи информации.

Квадратная матрица Н порядка ''m'' с элементами ±1 называется матрицей Адамара, если выполняется условие

:<math> H_m\,H_m^T = m\,E_m </math>

Нетрудно заметить, что различные строки матрицы Адамара попарно ортогональны [1]. Также, можно увидеть из определения, что m четно и
:<math>
H_{2m} =
\begin{pmatrix}
H_{m} & H_{m}\\
H_{m} & -H_{m}\end{pmatrix}
</math>

С матрицами Адамара связан ряд нерешенных проблем, одна из которых состоит в следующем. Мы уже видели, что порядок ''m'' матрицы Адамара при ''m'' ≥ 3 может быть лишь четным. Более того, при ''m'' ≥ 4 порядок обязан делиться на 4. До сих пор остается открытым вопрос: для любого ли ''m'', кратного 4, существует матрица Адамара порядка m? Неизвестно, в частности, существует ли матрица Адамара порядка 268 (это наименьший порядок, кратный 4, для которого матрица Адамара еще не построена).

Часто матрицу Адамара нормализуют и рассматривают размерности степени 2 (например [2],[3] и [4]). В дальнейшем будем рассматривать только такие случаи. Переопределим матрицу Адамара следующим образом:

'''Матрица Адамара ''H''''n'' - это матрица размера 2''n'' × 2''n'', для которой справедливо равенство'''

:<math>H_n = H_{1} \otimes H_{n-1}</math>,

:<math>\begin{align}
H_1 = \frac{1}{\sqrt2}
&\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
\end{align}</math>,
'''где <math> \otimes </math> представляет собой [https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BD%D0%B7%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5 тензорное произведение].'''

Представим некоторые частные примеры матриц Адамара:

:<math>
H_0 = +1,
</math>

:<math>
H_1 = \frac{1}{\sqrt2}
\begin{pmatrix}\begin{array}{rr}
1 & 1\\
1 & -1
\end{array}\end{pmatrix}
</math>,

:<math>
H_2 = \frac{1}{2}
\begin{pmatrix}\begin{array}{rrrr}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1
\end{array}\end{pmatrix}
</math>,

:<math>
H_3 = \frac{1}{2^{\frac{3}{2}}}
\begin{pmatrix}\begin{array}{rrrrrrrr}
1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\
1 & -1 & 1 & -1 & 1 & -1 & 1 & -1\\
1 & 1 & -1 & -1 & 1 & 1 & -1 & -1\\
1 & -1 & -1 & 1 & 1 & -1 & -1 & 1\\
1 & 1 & 1 & -1 & -1 & -1 & -1 & -1\\
1 & -1 & 1 & 1 & -1 & 1 & -1 & 1\\
1 & 1 & -1 & 1 & -1 & -1 & 1 & 1\\
1 & -1 & -1 & -1 & -1 & 1 & 1 & -1\\
\end{array}\end{pmatrix}
</math>.

=== Математическое описание алгоритма ===

Основой алгоритма является тот факт, что любую матрицу Адамара <math>H_n</math>, размерностью <math>2^n\times 2^n</math> можно вычислить поэлементно ([3], [4]):

:<math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>,

где ''k''''j'' и ''l''''j'' коэффициенты двоичного разложения чисел ''k'' и ''l'' (1 или 0):

: <math>k = \sum^{n}_{i=0} {k_i 2^i} = k_{n} 2^{n} + k_{n-1} 2^{n-1} + \cdots + k_1 2 + k_0</math>

и
: <math>l = \sum^{n}_{i=0} {l_i 2^i} = l_{n} 2^{n} + l_{n-1} 2^{n-1} + \cdots + l_1 2 + l_0</math>.

Помимо этой формулы чаще всего используется заполнение по определению. В связи с трудностями распараллеливания и постоянного выделения памяти при каждом шаге рекурсивного вызова этого метода, был выбран предыдущий способ вычисления.

=== Вычислительное ядро алгоритма ===

Вычислительное ядро составляют вычисления элементов матрицы <math>h_{k,l} = \frac{1}{2^\frac{n}{2}} (-1)^{\sum_j k_j l_j}</math>.

=== Макроструктура алгоритма ===

Основную часть метода составляют вычисления значений степени -1 для каждого элемента:

: <math>\sum_{j=0}^n k_j l_j</math>.

Как видно по формуле, получаемое значение равна количеству единиц в двоичной записи результата побитового умножения ''k'' и ''l''. Существует эффективный метод вычисления количества единиц , сложность которого равна ''m'' операций вычитания и ''m'' операций побитового умножения, где ''m''-искомое количество единиц.

=== Схема реализации последовательного алгоритма ===

Последовательность исполнения метода следующая:

1. Побитовое умножение <math>k\&l</math>;

2. Вычисление количества единиц двоичной записи;

3. Определение знака элемента по степени.

=== Последовательная сложность алгоритма ===

Для построения матрицы Адамара порядка <math>N=2^n</math> в первом шаге потребуется <math>N^2</math> побитовых умножений ''k&l''.
Во втором шаге, как говорилось выше, сложность метода вычисления количества единиц числа в двоичном представлении равна удвоенному количеству единиц. В наихудшем случае сложность равна <math>2log_2N</math>, при ''k=l=N-1'', а в наилучшем 0. Для нахождения степени всех элементов матрицы потребуются <math> 2N^2\left[\frac{log_2N}{4}\right]</math> операций. В третьем шаге для определения знака потребуется <math>N^2</math> операций, то есть сложность алгоритма

:<math>
T(n) = 2\,(1+\left[\frac{n}{4}\right])\,2^{2n}.
</math>

=== Информационный граф ===

На рисунке ниже изображен информационный граф алгоритма.

*<math>k\&l</math> - операция побитового умножения, где <math>k</math> и <math>l</math> соответствующие координаты элемента <math>h_{kl}</math>;
* OP - вычисление количества единиц числа в двоичной системе. Состоит из последовательного применения операций вычитания и побитового умножения;
* SGN - определение знака соответствующего элемента. Если результат предыдущего шага четное, то знак положительный, иначе отрицательный.

[[file:Hadamar.png|thumb|center|1400px|Рисунок 1. Граф алгоритма.]]
[[file:OP3.png|thumb|center|1400px|Рисунок 2. Граф OP.]]

=== Ресурс параллелизма алгоритма ===

Для построения матрицы порядка <math>N=2^n</math> требуется последовательно выполнить следующие шаги:
* <math>N^2</math> вычислений побитового умножения,
* для каждого элемента от <math>2</math> до <math>2n</math> операций вычитания и побитового умножения, в зависимости от результата предыдущего шага,
* <math>N^2</math> для определения знака значения элемента.

Таким образом для построения необходимы лишь простые операции вычитания и побитового умножения выполняемые с целыми положительными числами. Стоит заметить что вычисления для каждого элемента не зависят друг от друга. Также можно воспользоваться либо симметричностью матрицы Адамара либо закономерностью областей показанная в пункте 1.1.
Таким образом, основной вклад в высотe ЯПФ вносит операция вычисления количества единиц. Ширина ЯПФ будет равна O(n^2).

=== Входные и выходные данные алгоритма ===

'''Входные данные''': n - размерность матрицы <math>H_n</math>.

'''Объём входных данных''': 1 (число n).

'''Выходные данные''': матрица Адамара <math>H_n</math> размерностью <math>2^n\times 2^n</math>.

'''Объём выходных данных''': <math>2^{2n}</math>.

=== Свойства алгоритма ===

* Соотношение последовательной и параллельной сложности:
Одним из трудных мест параллельной реализации является правильный выбор количества процессов. Рассматривается некоторое фиксированное число процессов <math>P\in \mathbb{N}</math>. Считается, что каждый процесс ''P'' обрабатывает не более чем <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> элементов. Тогда качественная формула может быть записана таким образом:

:<math>T(n,p)=2\,(1+\left[ \frac{n}{4} \right])\,\frac{2^{2n}}{P}</math>.

Неравенство <math>\left[\frac{2^{2n}}{P}\right]\geq 1</math> можно переписать, как <math>log_2\,\sqrt{P}\leq n</math>.

Легко увидеть, что минимум функции ''T(n,P)'' будет при максимально возможном ''P'' : <math>log_2\,\sqrt{P}\leq n</math>. Такое ''P'' будет оптимальным числом процессов для алгоритма. В частности, для <math>P=2^p,\,p\in\mathbb{N}</math> оптимальное <math>P = 2^{2n}</math>.
:<math>\frac{T(n)}{T(n,p)}=P</math>.
то есть, отношение последовательной и параллельной сложности будет ''линейно'' зависеть от <math>P</math>.

* ''Вычислительная мощность'' алгоритма построения матрицы Адамара, как отношение числа операций к суммарному объему входных и выходных данных:
:<math>\,\frac{2^{2n}(2+[\frac{n}{4}])}{1+2^{2n}}\left( \sim [\frac{n}{4}],\,n\to+\infty \right).</math>;

* Алгоритм построения матрицы Адамара является ''не детерминированным'', так как число операций меняется в зависимости от входных данных (числа n, которое формирует матрицу размерности 2''n'' × 2''n'');

* Степень исхода вершины информационного графа равна 1;

* Алгоритм построения матрицы Адамара является ''сбалансированным''. Так как количество вершин на разных процессорах одинаково, то алгоритм является сбалансированным по числу операций на каждом процессоре.

=ЧАСТЬ Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==

В простейшем варианте генерацию матрицы Адамара для нашего алгоритма можно записать так:

<source lang="C">
void adamar(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2); // h - нормализующий множитель
N = pow(2,n);

for(i=0;i<N;++i)
{
for(j=0;j<N;++j)
{
ij = i & j;
for (l=0;ij;++l) ij&=ij-1; // l - количество единиц бинарного представления ij
if(l%2==0) H[i][j] = h;
else H[i][j] = -h;
}
}
}
</source>

Также существует рекурсивная реализация метода генерации матрицы Адамара

<source lang="C">
void adamar_recursion(int** H, int N, int i, int j, int h) // h - нормализующий множитель
{
if(n==1) H[i][j] = h;
else
{
adamar(H, N/2, i, j, h);
adamar(H, N/2, i, N/2+j, h);
adamar(H, N/2, N/2+i, j, h);
adamar(H, N/2, N/2+i, N/2+j, -h);
}
}
</source>

Или эквивалентный безрекурсивный вариант:

<source lang="C">
void adamar_not_recursion(int** H, int n) // N = 2^n - размерность матрицы
{
int i,j,N;
float h;
h = pow(1/2,n/2);
N = pow(2,n);
k=2;
H[0][0] = h;

while(k<=N)
{
for (i=0; i<k; ++i)
{
for (j=0; j<k; ++j)
{
if (i<k/2 && j<k/2)
{
}
else
{
if(i>=k/2 && j>=k/2)
{
H[i][j] = -(H[i-k/2][j-k/2]);
}
else
{
if (i>j)
{
H[i][j] = H[i-k/2][j];
}
else
{
H[i][j] = H[i][j-k/2];
}
}
}
}
}

k=k*2;
}
}
</source>

Для данного случая, рекурсия является менее эффективной для генерации матрицы Адамара ([https://habrahabr.ru/post/256351/ Хабрахабр. О бедной рекурсии замолвите слово, или всё, что вы не знали и не хотите о ней знать.]). С точки зрения последовательной реализации, генерация матрицы Адамара с помощью adamar_not_recursion будет выигрывать у adamar, так как adamar_not_recursion будет выполнять меньшее количество операций. С точки зрения параллельной реализации adamar имеет 100% парализацию и при определенных условиях будет выигрывать по времени у последовательной (пусть в adamar и будет выполняться большее количество операций, но они являются [https://ru.wikipedia.org/wiki/%D0%91%D0%B8%D1%82%D0%BE%D0%B2%D1%8B%D0%B5_%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8 битовыми операциями]).

== Локальность данных и вычислений ==

== Возможные способы и особенности параллельной реализации алгоритма ==

== Масштабируемость алгоритма и его реализации ==
Задача данного раздела - показать пределы [[глоссарий#Масштабируемость|''масштабируемости'']] алгоритма на различных платформах. Очень важный раздел. Нужно выделить, описать и оценить влияние точек барьерной синхронизации, глобальных операций, операций сборки/разборки данных, привести оценки или провести исследование [[глоссарий#Сильная масштабируемость|''сильной'']] и [[глоссарий#Слабая масштабируемость|''слабой'']] масштабируемости алгоритма и его реализаций.

Масштабируемость алгоритма определяет свойства самого алгоритма безотносительно конкретных особенностей используемого компьютера. Она показывает, насколько параллельные свойства алгоритма позволяют использовать возможности растущего числа процессорных элементов. Масштабируемость параллельных программ определяется как относительно конкретного компьютера, так и относительно используемой технологии программирования, и в этом случае она показывает, насколько может вырасти реальная производительность данного компьютера на данной программе, записанной с помощью данной технологии программирования, при использовании бóльших вычислительных ресурсов (ядер, процессоров, вычислительных узлов).

Ключевой момент данного раздела заключается в том, чтобы показать ''реальные параметры масштабируемости программы'' для данного алгоритма на различных вычислительных платформах в зависимости от числа процессоров и размера задачи [4]. При этом важно подобрать такое соотношение между числом процессоров и размером задачи, чтобы отразить все характерные точки в поведении параллельной программы, в частности, достижение максимальной производительности, а также тонкие эффекты, возникающие, например, из-за блочной структуры алгоритма или иерархии памяти.

На рис.5. показана масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи. На графике хорошо видны области с большей производительностью, отвечающие уровням кэш-памяти.
[[file:Масштабируемость перемножения матриц производительность.png|thumb|center|700px|Рис.5 Масштабируемость классического алгоритма умножения плотных матриц в зависимости от числа процессоров и размера задачи]]

== Динамические характеристики и эффективность реализации алгоритма ==

== Выводы для классов архитектур ==

== Существующие реализации алгоритма ==

Примеры вычислительных пакетов, содержащих функции генерации матриц Адамара:

# [http://www.exponenta.ru/soft/matlab/potemkin/book2/chapter5/hadamard.asp MATLAB];
# [https://reference.wolfram.com/language/ref/HadamardMatrix.html WOLFRAM];
# [http://pydoc.net/Python/rogues/0.3.0/rogues.matrices.hadamard/ Python];
# [http://www.obihiro.ac.jp/~suzukim/masuda/octave/html3/octave_97.html Octave];
# ...

Стоит отметить, что во многих вычислительных пакетах встроена операция тензорного произведения матриц, которая позволяет строить матрицу Адамара по определению. Этот факт позволяет использовать матрицу Адамара в этих вычислительных пакетах:
# [https://ru.wikipedia.org/wiki/Maple MAPLE];
# [https://ru.wikipedia.org/wiki/Mathcad MATCATH];
# ...

= Литература =
[1] Мак-Вильямс Ф.Дж., Слоэн Н.Дж.А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — 744 с.

[2] Кронберг, Ю.И. Ожигов, А.Ю. Чернявский — Алгебраический аппарат квантовой информатики 2

[3] Kunz H.O.. On the Equivalence Between One-Dimensional Discrete Walsh-Hadamard and Multidimensional Discrete Fourier Transforms. IEEE Transactions on Computers. 28 (3): 267–8. [https://en.wikipedia.org/wiki/Digital_object_identifier doi]:[http://ieeexplore.ieee.org/document/1675334/ 10.1109/TC.1979.1675334]

[4] Википедия – свободная энциклопедия [Электронный ресурс]. - https://en.wikipedia.org/wiki/Hadamard_transform. - (дата обращения: 15.10.2016).

[5] Воеводин В.В.. Воеводин Вл.В. Параллельные вычисления. - СПб.: БХВ-Петербург, 2002. - 608 с.

[6] Воронцов К.В.. Математические методы обучения по прецедентам (теория обучения машин)