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

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

2016-12-16T21:36:39Z

Nikita:

Замечания к оформлению:

1. Пункт 1.7 что обозначают серые вершины на графе?

2. в пункте 1.9 указать чему соответствуют разные входные и выходные данные. Иначе непонятно будет человеку, который первый раз на сайте.

3. Ссылки на литературу внутри текста статьи не нашел.

'''Второй этап проверки:'''
Добавляйте сюда ответы на вопросы и ход исправлений.
Возможно появление дополнительных замечаний.

1. Думаю, описание метода Пейли разумнее переместить в раздел "Математическое описание"

2. В математическом описании желательно хотя бы минимально кратко обосновать корректность (что достаточно проверить (p-1)/2 квадратов, и что матрица будет состоять только из элементов +1 и -1).

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

4. Информационный граф неправилен. У вас, скорее, отражена макроструктура. Алгоритм довольно прост, поэтому необходимо построить граф по всем правилам, где выход операции переходит строго на вход следующей операции. Разумно будет взять конкретный пример n=4. Лучше построить граф, как с данными, так и без них. Представленный граф тоже можно будет оставить для наглядности. Его основная проблема в том, что не видно, как функция построения итоговой матрицы обращается к элементам residual, что может быть важным для каких-либо архитектур.

5. (22.11) с учетом ошибки и в параллельном коде, эксперимент в пункте 2.4. нужно провести заново.

'''Исправления по второму этапу:'''

На данный момент были исправлены все замечания. Скажите, пожалуйста, будут ли применяться штрафы в период правки замечаний?
''Ответ:'' нет, если, как в вашем случае, происходит просто исправление, штрафов не будет. Но лучше всё же не тянуть, т.к. могут возникнуть новые комментарии.

Участник:Nikita/Построение матрицы Адамара

2016-12-16T21:36:07Z

Nikita:

{{Assignment}}
{{Assignment|Sleo}}

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O(n^2)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>1</math>
| output_data = <math>n^2</math>
}}

Авторы статьи: [[Участник:Nikita|Иванов Н.В.]] (1.1,1.7,1.9,1.10,2.4,2.7), [[Участник:Tsyganov Nikita|Цыганов Н.И.]] (1.2,1.3,1.4,1.5,1.6,1.7,1.8,2.4).

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

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

Матрицы Адамара были введены в математический обиход в конце прошлого века и играют важную роль в алгебре и комбинаторике. Они находят широкое применение в теории кодирования (коды, исправляющие ошибки), теории планирования многофакторных экспериментов (блок-схемы) и других областях математики.<ref name="rt">http://cyberleninka.ru/article/n/matritsy-adamara-nechetnogo-poryadka.pdf</ref> Сравнительно недавно (в 1960 г.) было замечено, что эти матрицы могут быть использованы для построения кодов с большим кодовым расстоянием.

'''''Матрицей Адамара порядка n''''' называется <math>n*n</math> матрица <math>H</math>, элементами которой являются +1 и −1 такая, что <math>H H^T = n E_n</math>,
где <math>E_n</math> - единичная матрица размера n.

Матрица Адамара обладает следующими ''свойствами'':
* Различные строки матрицы ортогональны
* Скалярное произведение любой строки саму на себя равно n
* Умножение любой строки или столбца на -1 переводит H в другую матрицу Адамара
* Если все элементы первой строки и первого столбца равны +1, то матрица Адамара называется нормализованной

Ниже показаны примеры нормализованных матриц Адамара порядка 1,2 и 4, причем нормализованность матриц сохраняется при перестановке любых строк и столбцов, кроме первых:

<math>H_1 = (1)</math>
<math>,
H_2 =
\begin{pmatrix}
1 & 1\\
1 & -1\end{pmatrix}
</math>,
<math>,
H_4 =
\begin{pmatrix}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1\end{pmatrix}
</math>

Предполагается, что существуют матрицы Адамара порядка 1, 2 и всех порядков n, кратных 4, хотя это до сих пор еще не было доказано. Нет универсального алгоритма построения матрицы Адамара произвольного размера, но известно большое число методов для различных частных случаев, и наименьший порядок, для которого матрица Адамара еще не построена, равен 268 (на 1977 г.). <ref name="rt2">Мак-Вильямс Ф. Дж., Слоэн Н. Дж. А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — c. 52-57</ref> Мы приведем метод построения Пейли, который важен для теории кодирования.

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

Для решения поставленной задачи будем использовать метод Пейли.
Это построение дает матрицы Адамара любого порядка <math>n=p+1</math>, кратного 4, где p-простое число.

'''Определение.''' Пусть p-простое число. Ненулевые квадраты чисел, приведенные по модулю p, называются квадратичными вычетами по модулю p или просто вычетами по модулю p.

Чтобы найти все вычеты по модулю p, достаточно рассмотреть квадраты чисел от <math>1^2</math> до <math>(p-1)^2</math>. Но если учесть, что <math>(p-a)^2 </math> <math>mod </math> <math> p = (-a)^2 </math> <math> mod </math> <math> p = a^2 </math> <math>mod</math> <math> p</math>, то достаточно рассмотреть лишь числа <math>1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod </math> <math>p</math> .

Функция <math>X(i)</math>, называемая символом Лежандра, определяется на целых числах следующим образом:
* <math>X(i)=0</math>, если i кратно p;
* <math>X(i)=1</math>, если остаток от деления i на p является квадратным вычетом по модулю p;
* <math>X(i)=-1</math>, если остаток от деления i на p является невычетом.

Теперь мы построим матрицу Джекобстола <math>Q=(q_{ij})</math>. Она представляет собой <math>(p*p)</math>-матрицу, строки и столбцы которой пронумерованы числами 0,1,..., p-1, а элементы <math>q_{ij}=X(j-i)</math>.

Пусть теперь <math>
H =
\begin{pmatrix}
1 & 1\\
1^T & Q-I\end{pmatrix}
</math>.

Все элементы главной диагонали этой матрицы, кроме элемента <math>h_{00}</math>, равны <math>X(0)-1=-1</math>. Нетрудно заметить, что данная матрица состоит только лишь из элементов 1 и -1.

Доказано, что такая матрица <math>H</math> представляет собой нормализованную матрицу Адамара порядка p+1, которую называют матрицей типа Пейли.<ref name="rt3">http://tc.nsu.ru/uploads/codingtheory.pdf</ref>

Исходные данные алгоритма - это порядок генерируемой матрицы Адамара <math>n</math>, удовлетворяющее следующим свойствам:

* <math>n>0</math>;

* <math>n</math> делится на 4;

* <math>n-1</math> - простое число.

Вспомогательные данные:

* Число <math>p=n-1</math>;
* Вектор квадратичных вычетов (по модулю <math>p</math>) <math>R</math> (элементы <math>r_i</math>) размера <math>2p</math>. В этом векторе индексация идёт с нуля.

Вычисляемые данные:

* Матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>) размера <math>n \times n</math>. Индексация строчек и столбцов идёт с нуля.

Алгоритм:
:1. Строится вектор квадратичных вычетов <math>R</math>.
:: Первые <math>p</math> элементов вектора <math>R</math> (<math>i=0,1,...,p-1</math>) определяются следующим образом:
::: <math>r_i=1</math>, если <math>i \in \{1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod</math> <math> p\}</math>, <math>i=0,1,...,p-1</math>, то есть если <math>i</math> является квадратичным вычетом по модулю <math>p</math>;
::: <math>r_i=-1</math>, иначе.
::Вторые <math>p</math> элементов (<math>i=p,1,...,2p-1</math>) являются копией первых <math>p</math> элементов:
:::<math>r_i=r_{i-p}, i=p,1,...,2p-1.</math>
:2. Строится матрица Адамара <math>H</math>.
::Элементы матрицы Адамара <math>H</math> находятся следующим образом:
::: <math>h_{0j}=1, j=0,1, ... ,n-1;</math>
::: <math>h_{i0}=1, i=1,2, ... ,n-1;</math>
::: <math>h_{ij}=r_{j-i+p}, i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

Вычислительное ядро алгоритма состоит из <math>(n-1) \times (n-1)</math> операций присваивания следующего вида:

:<math>h_{ij}=r_{j-i+p},</math> <math> i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

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

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

Приведем процедуру на языке С++, реализующую описанный алгоритм. На вход процедуре подается порядок матрицы <math>n</math> и ссылка на заполняемую матрицу <math>result</math>. Считаем, что <math>n</math> положительно, делится на <math>4</math>, <math>n-1</math> - простое число, а размер матрицы <math>result</math> равен <math>n \times n</math>.

<source lang="C">
void buildHadamardMatrix(int n, vector< vector<int> > & result)
{
// 1) matrix size changing
result.resize(n);
for (int i=0; i<n; i++) {
result[i].resize(n);
}

// 2) residue array building
int p=n-1;
vector<int> residues;
residues.resize(2*p);
for (int i=0; i<p; i++) {
residues[i] = -1;
}
for (int i=1; i<= (p-1)/2; i++) {
residues[i*i % p] = 1;
}
for (int i=p; i<2*p; i++) {
residues[i] = residues[i-p];
}
// 3) Paley matrix building
// first line filling
for (int j=0; j<n; j++) {
result[0][j] = 1;
}
// first column filling
for (int i=1; i<n; i++) {
result[i][0] = 1;
}
// others
for (int i=1; i<n; i++) {
for (int j=1; j<n; j++) {
result[i][j] = residues[j-i+p];
}
}
}
</source>

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

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

Основными операциями алгоритма являются:

* <math>\frac{n}{2}-2</math> операций умножения;
* <math>\frac{n}{2}-2</math> операций взятия остатка;
* <math>n^2+\frac{5}{2}n-3</math> операций присваивания.

Из чего следует, что алгоритм имеет квадратичную последовательную сложность.

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

Информационный граф алгоритма можно представить в виде четырёх последовательных блоков. Первый блок содержит <math>n-1</math> параллельных ветвей, второй блок - <math>\frac{n}{2}-1</math> параллельных ветвей, третий - <math>n-1</math> и четвёртый - <math>n^2</math>.

[[Файл:i_graph2.png|600px|thumb|center]]

Каждая вершина из <math>A_1-A_{n-1}</math>, <math>C_1-C_{n-1}</math>, <math>D_1-D_{n^2}</math> соответствует операции присваивания, каждая вершина из <math>B_1-B_{\frac{n}{2}-1}</math> соответствует трём последовательным операциям: умножения, взятия остатка по модулю и присваивания, а вершины, окрашенные серым, представляют собой промежуточные точки синхронизации.

[[Файл:i_graph3.jpg|600px|thumb|center|Информационный граф для n=4.]]
На рисунке приведен информационный граф алгоритма для случая n=4. Вершины графа соответствуют следующим строчкам кода:

a. residues[i] = -1;

b. residues[i*i%p] = 1;

c. residues[i] = residues[i-p];

d. result[0][j] = 1;

e. result[i][0] = 1;

f. result[i][j] = residues[i-j+p];

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

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

* <math>n-1</math> операций присваивания;
* <math>\frac{n}{2}-1</math> участков, состоящих из трёх операций: умножения, взятия остатка и присваивания;
* <math>n-1</math> операций присваивания;
* <math>n^2</math> операций присваивания.

Из этого можно сделать вывод, что высота ярусно-параллельной формы информационного графа равняется 6 (присваивание, умножение, взятие остатка, присваивание, присваивание, присваивание). Ширина ярусно-параллельной формы равняется <math>n^2</math>, что означает, что при использовании <math>n^2</math> процессоров матрица Адамара будет строиться за 6 операций.

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

'''Входные данные:''' число <math>n</math> - порядок матрицы Адамара <math>H_n</math>. Дополнительные ограничения на <math>n</math>:
* <math>n</math> - натуральное;
* <math>n</math> делится на 4;
* <math>n-1</math> - простое.
'''Объем входных данных:''' 1 (число <math>n</math>).

'''Выходные данные:''' построенная матрица Адамара <math>H_n</math> (её элементы <math>h_{ij}</math>).

'''Объем выходных данных:''' <math>n^2</math> (количество элементов матрицы Адамара размера <math>n*n</math>).

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

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

Вычислительная мощность алгоритма является постоянной (<math>O(1)</math>).

Алгоритм является полностью детерминированным.

Для вершин <math>A_1-A_{n-1}</math>, <math>B_1-B_{\frac{n}{2}-1}</math>, <math>C_1-C_{n-1}</math> информационного графа степени исхода являются линейными, что означает, что при возможности на этапе реализации необходимо позаботиться об эффективном доступе к элементам массива "<math>residues</math>".

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

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

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

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

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

Исследование масштабируемости параллельной реализации алгоритма построения матрицы Адамара проводилось на суперкомпьютере «Ломоносов». Для этого была исследована собственная реализация алгоритма с использованием средств MPI. В ходе исследования было произведено множество запусков программы с различными значениями параметра <math>n</math> (размер матрицы Адамара) и числом процессоров.

Набор и границы значений изменяемых параметров запуска реализации алгоритма:
*число процессоров (p): [2,64] с шагом 2;
*размер матрицы: простые числа в диапазоне [4,10000].

В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:
*минимальная эффективность реализации 0.0000036% при n=4, p=2;
*максимальная эффективность реализации 0.333426% при n=948, p=2.

Ниже представлены графики времени работы, производительности и эффективности данной реализации алгоритма построения матрицы Адамара в зависимости от изменяемых параметров запуска.
[[Файл:time_graph1.png|500px|thumb|center|Время работы параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]
[[Файл:perform_graph1.png|500px|thumb|center|Изменение производительности параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]
[[Файл:efficiency_graph1.png|500px|thumb|center|Эффективность работы параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]

[https://github.com/snikersman/Hadamard Исследованная параллельная реализация на языке C++]

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

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

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

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

Алгоритм построения матрицы Адамара реализован в различных математических пакетах и библиотеках:
* [https://www.mathworks.com/help/matlab/ref/hadamard.html?requestedDomain=www.mathworks.com MATLAB] (вносятся дополнительные ограничения, когда n, или n/12, или n/20 являются степенями по основанию 2)
* [http://r-survey.r-forge.r-project.org/survey/html/hadamard.html R]
* [https://reference.wolframcloud.com/cloudplatform/ref/HadamardMatrix.html Wolfram Mathematica]
* [http://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.linalg.hadamard.html SciPy для Python]

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

Участник:Nikita/Построение матрицы Адамара

2016-12-16T21:25:13Z

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

{{Assignment|Sleo}}

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O(n^2)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>1</math>
| output_data = <math>n^2</math>
}}

Авторы статьи: [[Участник:Nikita|Иванов Н.В.]] (1.1,1.7,1.9,1.10,2.4,2.7), [[Участник:Tsyganov Nikita|Цыганов Н.И.]] (1.2,1.3,1.4,1.5,1.6,1.7,1.8,2.4).

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

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

Матрицы Адамара были введены в математический обиход в конце прошлого века и играют важную роль в алгебре и комбинаторике. Они находят широкое применение в теории кодирования (коды, исправляющие ошибки), теории планирования многофакторных экспериментов (блок-схемы) и других областях математики.<ref name="rt">http://cyberleninka.ru/article/n/matritsy-adamara-nechetnogo-poryadka.pdf</ref> Сравнительно недавно (в 1960 г.) было замечено, что эти матрицы могут быть использованы для построения кодов с большим кодовым расстоянием.

'''''Матрицей Адамара порядка n''''' называется <math>n*n</math> матрица <math>H</math>, элементами которой являются +1 и −1 такая, что <math>H H^T = n E_n</math>,
где <math>E_n</math> - единичная матрица размера n.

Матрица Адамара обладает следующими ''свойствами'':
* Различные строки матрицы ортогональны
* Скалярное произведение любой строки саму на себя равно n
* Умножение любой строки или столбца на -1 переводит H в другую матрицу Адамара
* Если все элементы первой строки и первого столбца равны +1, то матрица Адамара называется нормализованной

Ниже показаны примеры нормализованных матриц Адамара порядка 1,2 и 4, причем нормализованность матриц сохраняется при перестановке любых строк и столбцов, кроме первых:

<math>H_1 = (1)</math>
<math>,
H_2 =
\begin{pmatrix}
1 & 1\\
1 & -1\end{pmatrix}
</math>,
<math>,
H_4 =
\begin{pmatrix}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1\end{pmatrix}
</math>

Предполагается, что существуют матрицы Адамара порядка 1, 2 и всех порядков n, кратных 4, хотя это до сих пор еще не было доказано. Нет универсального алгоритма построения матрицы Адамара произвольного размера, но известно большое число методов для различных частных случаев, и наименьший порядок, для которого матрица Адамара еще не построена, равен 268 (на 1977 г.). <ref name="rt2">Мак-Вильямс Ф. Дж., Слоэн Н. Дж. А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — c. 52-57</ref> Мы приведем метод построения Пейли, который важен для теории кодирования.

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

Для решения поставленной задачи будем использовать метод Пейли.
Это построение дает матрицы Адамара любого порядка <math>n=p+1</math>, кратного 4, где p-простое число.

'''Определение.''' Пусть p-простое число. Ненулевые квадраты чисел, приведенные по модулю p, называются квадратичными вычетами по модулю p или просто вычетами по модулю p.

Чтобы найти все вычеты по модулю p, достаточно рассмотреть квадраты чисел от <math>1^2</math> до <math>(p-1)^2</math>. Но если учесть, что <math>(p-a)^2 </math> <math>mod </math> <math> p = (-a)^2 </math> <math> mod </math> <math> p = a^2 </math> <math>mod</math> <math> p</math>, то достаточно рассмотреть лишь числа <math>1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod </math> <math>p</math> .

Функция <math>X(i)</math>, называемая символом Лежандра, определяется на целых числах следующим образом:
* <math>X(i)=0</math>, если i кратно p;
* <math>X(i)=1</math>, если остаток от деления i на p является квадратным вычетом по модулю p;
* <math>X(i)=-1</math>, если остаток от деления i на p является невычетом.

Теперь мы построим матрицу Джекобстола <math>Q=(q_{ij})</math>. Она представляет собой <math>(p*p)</math>-матрицу, строки и столбцы которой пронумерованы числами 0,1,..., p-1, а элементы <math>q_{ij}=X(j-i)</math>.

Пусть теперь <math>
H =
\begin{pmatrix}
1 & 1\\
1^T & Q-I\end{pmatrix}
</math>.

Все элементы главной диагонали этой матрицы, кроме элемента <math>h_{00}</math>, равны <math>X(0)-1=-1</math>. Нетрудно заметить, что данная матрица состоит только лишь из элементов 1 и -1.

Доказано, что такая матрица <math>H</math> представляет собой нормализованную матрицу Адамара порядка p+1, которую называют матрицей типа Пейли.<ref name="rt3">http://tc.nsu.ru/uploads/codingtheory.pdf</ref>

Исходные данные алгоритма - это порядок генерируемой матрицы Адамара <math>n</math>, удовлетворяющее следующим свойствам:

* <math>n>0</math>;

* <math>n</math> делится на 4;

* <math>n-1</math> - простое число.

Вспомогательные данные:

* Число <math>p=n-1</math>;
* Вектор квадратичных вычетов (по модулю <math>p</math>) <math>R</math> (элементы <math>r_i</math>) размера <math>2p</math>. В этом векторе индексация идёт с нуля.

Вычисляемые данные:

* Матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>) размера <math>n \times n</math>. Индексация строчек и столбцов идёт с нуля.

Алгоритм:
:1. Строится вектор квадратичных вычетов <math>R</math>.
:: Первые <math>p</math> элементов вектора <math>R</math> (<math>i=0,1,...,p-1</math>) определяются следующим образом:
::: <math>r_i=1</math>, если <math>i \in \{1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod</math> <math> p\}</math>, <math>i=0,1,...,p-1</math>, то есть если <math>i</math> является квадратичным вычетом по модулю <math>p</math>;
::: <math>r_i=-1</math>, иначе.
::Вторые <math>p</math> элементов (<math>i=p,1,...,2p-1</math>) являются копией первых <math>p</math> элементов:
:::<math>r_i=r_{i-p}, i=p,1,...,2p-1.</math>
:2. Строится матрица Адамара <math>H</math>.
::Элементы матрицы Адамара <math>H</math> находятся следующим образом:
::: <math>h_{0j}=1, j=0,1, ... ,n-1;</math>
::: <math>h_{i0}=1, i=1,2, ... ,n-1;</math>
::: <math>h_{ij}=r_{j-i+p}, i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

Вычислительное ядро алгоритма состоит из <math>(n-1) \times (n-1)</math> операций присваивания следующего вида:

:<math>h_{ij}=r_{j-i+p},</math> <math> i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

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

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

Приведем процедуру на языке С++, реализующую описанный алгоритм. На вход процедуре подается порядок матрицы <math>n</math> и ссылка на заполняемую матрицу <math>result</math>. Считаем, что <math>n</math> положительно, делится на <math>4</math>, <math>n-1</math> - простое число, а размер матрицы <math>result</math> равен <math>n \times n</math>.

<source lang="C">
void buildHadamardMatrix(int n, vector< vector<int> > & result)
{
// 1) matrix size changing
result.resize(n);
for (int i=0; i<n; i++) {
result[i].resize(n);
}

// 2) residue array building
int p=n-1;
vector<int> residues;
residues.resize(2*p);
for (int i=0; i<p; i++) {
residues[i] = -1;
}
for (int i=1; i<= (p-1)/2; i++) {
residues[i*i % p] = 1;
}
for (int i=p; i<2*p; i++) {
residues[i] = residues[i-p];
}
// 3) Paley matrix building
// first line filling
for (int j=0; j<n; j++) {
result[0][j] = 1;
}
// first column filling
for (int i=1; i<n; i++) {
result[i][0] = 1;
}
// others
for (int i=1; i<n; i++) {
for (int j=1; j<n; j++) {
result[i][j] = residues[j-i+p];
}
}
}
</source>

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

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

Основными операциями алгоритма являются:

* <math>\frac{n}{2}-2</math> операций умножения;
* <math>\frac{n}{2}-2</math> операций взятия остатка;
* <math>n^2+\frac{5}{2}n-3</math> операций присваивания.

Из чего следует, что алгоритм имеет квадратичную последовательную сложность.

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

Информационный граф алгоритма можно представить в виде четырёх последовательных блоков. Первый блок содержит <math>n-1</math> параллельных ветвей, второй блок - <math>\frac{n}{2}-1</math> параллельных ветвей, третий - <math>n-1</math> и четвёртый - <math>n^2</math>.

[[Файл:i_graph2.png|600px|thumb|center]]

Каждая вершина из <math>A_1-A_{n-1}</math>, <math>C_1-C_{n-1}</math>, <math>D_1-D_{n^2}</math> соответствует операции присваивания, каждая вершина из <math>B_1-B_{\frac{n}{2}-1}</math> соответствует трём последовательным операциям: умножения, взятия остатка по модулю и присваивания, а вершины, окрашенные серым, представляют собой промежуточные точки синхронизации.

[[Файл:i_graph3.jpg|600px|thumb|center|Информационный граф для n=4.]]

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

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

* <math>n-1</math> операций присваивания;
* <math>\frac{n}{2}-1</math> участков, состоящих из трёх операций: умножения, взятия остатка и присваивания;
* <math>n-1</math> операций присваивания;
* <math>n^2</math> операций присваивания.

Из этого можно сделать вывод, что высота ярусно-параллельной формы информационного графа равняется 6 (присваивание, умножение, взятие остатка, присваивание, присваивание, присваивание). Ширина ярусно-параллельной формы равняется <math>n^2</math>, что означает, что при использовании <math>n^2</math> процессоров матрица Адамара будет строиться за 6 операций.

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

'''Входные данные:''' число <math>n</math> - порядок матрицы Адамара <math>H_n</math>. Дополнительные ограничения на <math>n</math>:
* <math>n</math> - натуральное;
* <math>n</math> делится на 4;
* <math>n-1</math> - простое.
'''Объем входных данных:''' 1 (число <math>n</math>).

'''Выходные данные:''' построенная матрица Адамара <math>H_n</math> (её элементы <math>h_{ij}</math>).

'''Объем выходных данных:''' <math>n^2</math> (количество элементов матрицы Адамара размера <math>n*n</math>).

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

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

Вычислительная мощность алгоритма является постоянной (<math>O(1)</math>).

Алгоритм является полностью детерминированным.

Для вершин <math>A_1-A_{n-1}</math>, <math>B_1-B_{\frac{n}{2}-1}</math>, <math>C_1-C_{n-1}</math> информационного графа степени исхода являются линейными, что означает, что при возможности на этапе реализации необходимо позаботиться об эффективном доступе к элементам массива "<math>residues</math>".

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

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

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

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

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

Исследование масштабируемости параллельной реализации алгоритма построения матрицы Адамара проводилось на суперкомпьютере «Ломоносов». Для этого была исследована собственная реализация алгоритма с использованием средств MPI. В ходе исследования было произведено множество запусков программы с различными значениями параметра <math>n</math> (размер матрицы Адамара) и числом процессоров.

Набор и границы значений изменяемых параметров запуска реализации алгоритма:
*число процессоров (p): [2,64] с шагом 2;
*размер матрицы: простые числа в диапазоне [4,10000].

В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:
*минимальная эффективность реализации 0.0000036% при n=4, p=2;
*максимальная эффективность реализации 0.333426% при n=948, p=2.

Ниже представлены графики времени работы, производительности и эффективности данной реализации алгоритма построения матрицы Адамара в зависимости от изменяемых параметров запуска.
[[Файл:time_graph1.png|500px|thumb|center|Время работы параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]
[[Файл:perform_graph1.png|500px|thumb|center|Изменение производительности параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]
[[Файл:efficiency_graph1.png|500px|thumb|center|Эффективность работы параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]

[https://github.com/snikersman/Hadamard Исследованная параллельная реализация на языке C++]

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

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

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

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

Алгоритм построения матрицы Адамара реализован в различных математических пакетах и библиотеках:
* [https://www.mathworks.com/help/matlab/ref/hadamard.html?requestedDomain=www.mathworks.com MATLAB] (вносятся дополнительные ограничения, когда n, или n/12, или n/20 являются степенями по основанию 2)
* [http://r-survey.r-forge.r-project.org/survey/html/hadamard.html R]
* [https://reference.wolframcloud.com/cloudplatform/ref/HadamardMatrix.html Wolfram Mathematica]
* [http://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.linalg.hadamard.html SciPy для Python]

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

Участник:Nikita/Построение матрицы Адамара

2016-12-16T21:24:03Z

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

{{Assignment|Sleo}}

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O(n^2)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>1</math>
| output_data = <math>n^2</math>
}}

Авторы статьи: [[Участник:Nikita|Иванов Н.В.]] (1.1,1.7,1.9,1.10,2.4,2.7), [[Участник:Tsyganov Nikita|Цыганов Н.И.]] (1.2,1.3,1.4,1.5,1.6,1.7,1.8,2.4).

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

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

Матрицы Адамара были введены в математический обиход в конце прошлого века и играют важную роль в алгебре и комбинаторике. Они находят широкое применение в теории кодирования (коды, исправляющие ошибки), теории планирования многофакторных экспериментов (блок-схемы) и других областях математики.<ref name="rt">http://cyberleninka.ru/article/n/matritsy-adamara-nechetnogo-poryadka.pdf</ref> Сравнительно недавно (в 1960 г.) было замечено, что эти матрицы могут быть использованы для построения кодов с большим кодовым расстоянием.

'''''Матрицей Адамара порядка n''''' называется <math>n*n</math> матрица <math>H</math>, элементами которой являются +1 и −1 такая, что <math>H H^T = n E_n</math>,
где <math>E_n</math> - единичная матрица размера n.

Матрица Адамара обладает следующими ''свойствами'':
* Различные строки матрицы ортогональны
* Скалярное произведение любой строки саму на себя равно n
* Умножение любой строки или столбца на -1 переводит H в другую матрицу Адамара
* Если все элементы первой строки и первого столбца равны +1, то матрица Адамара называется нормализованной

Ниже показаны примеры нормализованных матриц Адамара порядка 1,2 и 4, причем нормализованность матриц сохраняется при перестановке любых строк и столбцов, кроме первых:

<math>H_1 = (1)</math>
<math>,
H_2 =
\begin{pmatrix}
1 & 1\\
1 & -1\end{pmatrix}
</math>,
<math>,
H_4 =
\begin{pmatrix}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1\end{pmatrix}
</math>

Предполагается, что существуют матрицы Адамара порядка 1, 2 и всех порядков n, кратных 4, хотя это до сих пор еще не было доказано. Нет универсального алгоритма построения матрицы Адамара произвольного размера, но известно большое число методов для различных частных случаев, и наименьший порядок, для которого матрица Адамара еще не построена, равен 268 (на 1977 г.). <ref name="rt2">Мак-Вильямс Ф. Дж., Слоэн Н. Дж. А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — c. 52-57</ref> Мы приведем метод построения Пейли, который важен для теории кодирования.

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

Для решения поставленной задачи будем использовать метод Пейли.
Это построение дает матрицы Адамара любого порядка <math>n=p+1</math>, кратного 4, где p-простое число.

'''Определение.''' Пусть p-простое число. Ненулевые квадраты чисел, приведенные по модулю p, называются квадратичными вычетами по модулю p или просто вычетами по модулю p.

Чтобы найти все вычеты по модулю p, достаточно рассмотреть квадраты чисел от <math>1^2</math> до <math>(p-1)^2</math>. Но если учесть, что <math>(p-a)^2 </math> <math>mod </math> <math> p = (-a)^2 </math> <math> mod </math> <math> p = a^2 </math> <math>mod</math> <math> p</math>, то достаточно рассмотреть лишь числа <math>1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod </math> <math>p</math> .

Функция <math>X(i)</math>, называемая символом Лежандра, определяется на целых числах следующим образом:
* <math>X(i)=0</math>, если i кратно p;
* <math>X(i)=1</math>, если остаток от деления i на p является квадратным вычетом по модулю p;
* <math>X(i)=-1</math>, если остаток от деления i на p является невычетом.

Теперь мы построим матрицу Джекобстола <math>Q=(q_{ij})</math>. Она представляет собой <math>(p*p)</math>-матрицу, строки и столбцы которой пронумерованы числами 0,1,..., p-1, а элементы <math>q_{ij}=X(j-i)</math>.

Пусть теперь <math>
H =
\begin{pmatrix}
1 & 1\\
1^T & Q-I\end{pmatrix}
</math>.

Все элементы главной диагонали этой матрицы, кроме элемента <math>h_{00}</math>, равны <math>X(0)-1=-1</math>. Нетрудно заметить, что данная матрица состоит только лишь из элементов 1 и -1.

Доказано, что такая матрица <math>H</math> представляет собой нормализованную матрицу Адамара порядка p+1, которую называют матрицей типа Пейли.<ref name="rt3">http://tc.nsu.ru/uploads/codingtheory.pdf</ref>

Исходные данные алгоритма - это порядок генерируемой матрицы Адамара <math>n</math>, удовлетворяющее следующим свойствам:

* <math>n>0</math>;

* <math>n</math> делится на 4;

* <math>n-1</math> - простое число.

Вспомогательные данные:

* Число <math>p=n-1</math>;
* Вектор квадратичных вычетов (по модулю <math>p</math>) <math>R</math> (элементы <math>r_i</math>) размера <math>2p</math>. В этом векторе индексация идёт с нуля.

Вычисляемые данные:

* Матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>) размера <math>n \times n</math>. Индексация строчек и столбцов идёт с нуля.

Алгоритм:
:1. Строится вектор квадратичных вычетов <math>R</math>.
:: Первые <math>p</math> элементов вектора <math>R</math> (<math>i=0,1,...,p-1</math>) определяются следующим образом:
::: <math>r_i=1</math>, если <math>i \in \{1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod</math> <math> p\}</math>, <math>i=0,1,...,p-1</math>, то есть если <math>i</math> является квадратичным вычетом по модулю <math>p</math>;
::: <math>r_i=-1</math>, иначе.
::Вторые <math>p</math> элементов (<math>i=p,1,...,2p-1</math>) являются копией первых <math>p</math> элементов:
:::<math>r_i=r_{i-p}, i=p,1,...,2p-1.</math>
:2. Строится матрица Адамара <math>H</math>.
::Элементы матрицы Адамара <math>H</math> находятся следующим образом:
::: <math>h_{0j}=1, j=0,1, ... ,n-1;</math>
::: <math>h_{i0}=1, i=1,2, ... ,n-1;</math>
::: <math>h_{ij}=r_{j-i+p}, i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

Вычислительное ядро алгоритма состоит из <math>(n-1) \times (n-1)</math> операций присваивания следующего вида:

:<math>h_{ij}=r_{j-i+p},</math> <math> i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

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

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

Приведем процедуру на языке С++, реализующую описанный алгоритм. На вход процедуре подается порядок матрицы <math>n</math> и ссылка на заполняемую матрицу <math>result</math>. Считаем, что <math>n</math> положительно, делится на <math>4</math>, <math>n-1</math> - простое число, а размер матрицы <math>result</math> равен <math>n \times n</math>.

<source lang="C">
void buildHadamardMatrix(int n, vector< vector<int> > & result)
{
// 1) matrix size changing
result.resize(n);
for (int i=0; i<n; i++) {
result[i].resize(n);
}

// 2) residue array building
int p=n-1;
vector<int> residues;
residues.resize(2*p);
for (int i=0; i<p; i++) {
residues[i] = -1;
}
for (int i=1; i<= (p-1)/2; i++) {
residues[i*i % p] = 1;
}
for (int i=p; i<2*p; i++) {
residues[i] = residues[i-p];
}
// 3) Paley matrix building
// first line filling
for (int j=0; j<n; j++) {
result[0][j] = 1;
}
// first column filling
for (int i=1; i<n; i++) {
result[i][0] = 1;
}
// others
for (int i=1; i<n; i++) {
for (int j=1; j<n; j++) {
result[i][j] = residues[j-i+p];
}
}
}
</source>

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

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

Основными операциями алгоритма являются:

* <math>\frac{n}{2}-2</math> операций умножения;
* <math>\frac{n}{2}-2</math> операций взятия остатка;
* <math>n^2+\frac{5}{2}n-3</math> операций присваивания.

Из чего следует, что алгоритм имеет квадратичную последовательную сложность.

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

Информационный граф алгоритма можно представить в виде четырёх последовательных блоков. Первый блок содержит <math>n-1</math> параллельных ветвей, второй блок - <math>\frac{n}{2}-1</math> параллельных ветвей, третий - <math>n-1</math> и четвёртый - <math>n^2</math>.

[[Файл:i_graph2.png]]

Каждая вершина из <math>A_1-A_{n-1}</math>, <math>C_1-C_{n-1}</math>, <math>D_1-D_{n^2}</math> соответствует операции присваивания, каждая вершина из <math>B_1-B_{\frac{n}{2}-1}</math> соответствует трём последовательным операциям: умножения, взятия остатка по модулю и присваивания, а вершины, окрашенные серым, представляют собой промежуточные точки синхронизации.

[[Файл:i_graph3.jpg|600px|thumb|center|Информационный граф для n=4.]]

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

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

* <math>n-1</math> операций присваивания;
* <math>\frac{n}{2}-1</math> участков, состоящих из трёх операций: умножения, взятия остатка и присваивания;
* <math>n-1</math> операций присваивания;
* <math>n^2</math> операций присваивания.

Из этого можно сделать вывод, что высота ярусно-параллельной формы информационного графа равняется 6 (присваивание, умножение, взятие остатка, присваивание, присваивание, присваивание). Ширина ярусно-параллельной формы равняется <math>n^2</math>, что означает, что при использовании <math>n^2</math> процессоров матрица Адамара будет строиться за 6 операций.

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

'''Входные данные:''' число <math>n</math> - порядок матрицы Адамара <math>H_n</math>. Дополнительные ограничения на <math>n</math>:
* <math>n</math> - натуральное;
* <math>n</math> делится на 4;
* <math>n-1</math> - простое.
'''Объем входных данных:''' 1 (число <math>n</math>).

'''Выходные данные:''' построенная матрица Адамара <math>H_n</math> (её элементы <math>h_{ij}</math>).

'''Объем выходных данных:''' <math>n^2</math> (количество элементов матрицы Адамара размера <math>n*n</math>).

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

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

Вычислительная мощность алгоритма является постоянной (<math>O(1)</math>).

Алгоритм является полностью детерминированным.

Для вершин <math>A_1-A_{n-1}</math>, <math>B_1-B_{\frac{n}{2}-1}</math>, <math>C_1-C_{n-1}</math> информационного графа степени исхода являются линейными, что означает, что при возможности на этапе реализации необходимо позаботиться об эффективном доступе к элементам массива "<math>residues</math>".

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

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

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

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

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

Исследование масштабируемости параллельной реализации алгоритма построения матрицы Адамара проводилось на суперкомпьютере «Ломоносов». Для этого была исследована собственная реализация алгоритма с использованием средств MPI. В ходе исследования было произведено множество запусков программы с различными значениями параметра <math>n</math> (размер матрицы Адамара) и числом процессоров.

Набор и границы значений изменяемых параметров запуска реализации алгоритма:
*число процессоров (p): [2,64] с шагом 2;
*размер матрицы: простые числа в диапазоне [4,10000].

В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:
*минимальная эффективность реализации 0.0000036% при n=4, p=2;
*максимальная эффективность реализации 0.333426% при n=948, p=2.

Ниже представлены графики времени работы, производительности и эффективности данной реализации алгоритма построения матрицы Адамара в зависимости от изменяемых параметров запуска.
[[Файл:time_graph1.png|500px|thumb|center|Время работы параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]
[[Файл:perform_graph1.png|500px|thumb|center|Изменение производительности параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]
[[Файл:efficiency_graph1.png|500px|thumb|center|Эффективность работы параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]

[https://github.com/snikersman/Hadamard Исследованная параллельная реализация на языке C++]

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

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

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

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

Алгоритм построения матрицы Адамара реализован в различных математических пакетах и библиотеках:
* [https://www.mathworks.com/help/matlab/ref/hadamard.html?requestedDomain=www.mathworks.com MATLAB] (вносятся дополнительные ограничения, когда n, или n/12, или n/20 являются степенями по основанию 2)
* [http://r-survey.r-forge.r-project.org/survey/html/hadamard.html R]
* [https://reference.wolframcloud.com/cloudplatform/ref/HadamardMatrix.html Wolfram Mathematica]
* [http://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.linalg.hadamard.html SciPy для Python]

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

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

2016-11-23T22:45:55Z

Nikita:

Замечания к оформлению:

1. Пункт 1.7 что обозначают серые вершины на графе?

2. в пункте 1.9 указать чему соответствуют разные входные и выходные данные. Иначе непонятно будет человеку, который первый раз на сайте.

3. Ссылки на литературу внутри текста статьи не нашел.

'''Второй этап проверки:'''
Добавляйте сюда ответы на вопросы и ход исправлений.
Возможно появление дополнительных замечаний.

1. Думаю, описание метода Пейли разумнее переместить в раздел "Математическое описание"

2. В математическом описании желательно хотя бы минимально кратко обосновать корректность (что достаточно проверить (p-1)/2 квадратов, и что матрица будет состоять только из элементов +1 и -1).

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

4. Информационный граф неправилен. У вас, скорее, отражена макроструктура. Алгоритм довольно прост, поэтому необходимо построить граф по всем правилам, где выход операции переходит строго на вход следующей операции. Разумно будет взять конкретный пример n=4. Лучше построить граф, как с данными, так и без них. Представленный граф тоже можно будет оставить для наглядности. Его основная проблема в том, что не видно, как функция построения итоговой матрицы обращается к элементам residual, что может быть важным для каких-либо архитектур.

5. (22.11) с учетом ошибки и в параллельном коде, эксперимент в пункте 2.4. нужно провести заново.

'''Исправления по второму этапу:'''

На данный момент были исправлены все замечания, кроме пункта 4. Скажите, пожалуйста, будут ли применяться штрафы в период правки замечаний?

Участник:Nikita/Построение матрицы Адамара

2016-11-23T22:40:36Z

Nikita:

{{Assignment}}



{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O(n^2)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>1</math>
| output_data = <math>n^2</math>
}}

Авторы статьи: [[Участник:Nikita|Иванов Н.В.]] (1.1,1.7,1.9,1.10,2.4,2.7), [[Участник:Tsyganov Nikita|Цыганов Н.И.]] (1.2,1.3,1.4,1.5,1.6,1.7,1.8,2.4).

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

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

Матрицы Адамара были введены в математический обиход в конце прошлого века и играют важную роль в алгебре и комбинаторике. Они находят широкое применение в теории кодирования (коды, исправляющие ошибки), теории планирования многофакторных экспериментов (блок-схемы) и других областях математики.<ref name="rt">http://cyberleninka.ru/article/n/matritsy-adamara-nechetnogo-poryadka.pdf</ref> Сравнительно недавно (в 1960 г.) было замечено, что эти матрицы могут быть использованы для построения кодов с большим кодовым расстоянием.

'''''Матрицей Адамара порядка n''''' называется <math>n*n</math> матрица <math>H</math>, элементами которой являются +1 и −1 такая, что <math>H H^T = n E_n</math>,
где <math>E_n</math> - единичная матрица размера n.

Матрица Адамара обладает следующими ''свойствами'':
* Различные строки матрицы ортогональны
* Скалярное произведение любой строки саму на себя равно n
* Умножение любой строки или столбца на -1 переводит H в другую матрицу Адамара
* Если все элементы первой строки и первого столбца равны +1, то матрица Адамара называется нормализованной

Ниже показаны примеры нормализованных матриц Адамара порядка 1,2 и 4, причем нормализованность матриц сохраняется при перестановке любых строк и столбцов, кроме первых:

<math>H_1 = (1)</math>
<math>,
H_2 =
\begin{pmatrix}
1 & 1\\
1 & -1\end{pmatrix}
</math>,
<math>,
H_4 =
\begin{pmatrix}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1\end{pmatrix}
</math>

Предполагается, что существуют матрицы Адамара порядка 1, 2 и всех порядков n, кратных 4, хотя это до сих пор еще не было доказано. Нет универсального алгоритма построения матрицы Адамара произвольного размера, но известно большое число методов для различных частных случаев, и наименьший порядок, для которого матрица Адамара еще не построена, равен 268 (на 1977 г.). <ref name="rt2">Мак-Вильямс Ф. Дж., Слоэн Н. Дж. А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — c. 52-57</ref> Мы приведем метод построения Пейли, который важен для теории кодирования.

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

Для решения поставленной задачи будем использовать метод Пейли.
Это построение дает матрицы Адамара любого порядка <math>n=p+1</math>, кратного 4, где p-простое число.

'''Определение.''' Пусть p-простое число. Ненулевые квадраты чисел, приведенные по модулю p, называются квадратичными вычетами по модулю p или просто вычетами по модулю p.

Чтобы найти все вычеты по модулю p, достаточно рассмотреть квадраты чисел от <math>1^2</math> до <math>(p-1)^2</math>. Но если учесть, что <math>(p-a)^2 </math> <math>mod </math> <math> p = (-a)^2 </math> <math> mod </math> <math> p = a^2 </math> <math>mod</math> <math> p</math>, то достаточно рассмотреть лишь числа <math>1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod </math> <math>p</math> .

Функция <math>X(i)</math>, называемая символом Лежандра, определяется на целых числах следующим образом:
* <math>X(i)=0</math>, если i кратно p;
* <math>X(i)=1</math>, если остаток от деления i на p является квадратным вычетом по модулю p;
* <math>X(i)=-1</math>, если остаток от деления i на p является невычетом.

Теперь мы построим матрицу Джекобстола <math>Q=(q_{ij})</math>. Она представляет собой <math>(p*p)</math>-матрицу, строки и столбцы которой пронумерованы числами 0,1,..., p-1, а элементы <math>q_{ij}=X(j-i)</math>.

Пусть теперь <math>
H =
\begin{pmatrix}
1 & 1\\
1^T & Q-I\end{pmatrix}
</math>.

Все элементы главной диагонали этой матрицы, кроме элемента <math>h_{00}</math>, равны <math>X(0)-1=-1</math>. Нетрудно заметить, что данная матрица состоит только лишь из элементов 1 и -1.

Доказано, что такая матрица <math>H</math> представляет собой нормализованную матрицу Адамара порядка p+1, которую называют матрицей типа Пейли.<ref name="rt3">http://tc.nsu.ru/uploads/codingtheory.pdf</ref>

Исходные данные алгоритма - это порядок генерируемой матрицы Адамара <math>n</math>, удовлетворяющее следующим свойствам:

* <math>n>0</math>;

* <math>n</math> делится на 4;

* <math>n-1</math> - простое число.

Вспомогательные данные:

* Число <math>p=n-1</math>;
* Вектор квадратичных вычетов (по модулю <math>p</math>) <math>R</math> (элементы <math>r_i</math>) размера <math>2p</math>. В этом векторе индексация идёт с нуля.

Вычисляемые данные:

* Матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>) размера <math>n \times n</math>. Индексация строчек и столбцов идёт с нуля.

Алгоритм:
:1. Строится вектор квадратичных вычетов <math>R</math>.
:: Первые <math>p</math> элементов вектора <math>R</math> (<math>i=0,1,...,p-1</math>) определяются следующим образом:
::: <math>r_i=1</math>, если <math>i \in \{1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod</math> <math> p\}</math>, <math>i=0,1,...,p-1</math>, то есть если <math>i</math> является квадратичным вычетом по модулю <math>p</math>;
::: <math>r_i=-1</math>, иначе.
::Вторые <math>p</math> элементов (<math>i=p,1,...,2p-1</math>) являются копией первых <math>p</math> элементов:
:::<math>r_i=r_{i-p}, i=p,1,...,2p-1.</math>
:2. Строится матрица Адамара <math>H</math>.
::Элементы матрицы Адамара <math>H</math> находятся следующим образом:
::: <math>h_{0j}=1, j=0,1, ... ,n-1;</math>
::: <math>h_{i0}=1, i=1,2, ... ,n-1;</math>
::: <math>h_{ij}=r_{j-i+p}, i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

Вычислительное ядро алгоритма состоит из <math>(n-1) \times (n-1)</math> операций присваивания следующего вида:

:<math>h_{ij}=r_{j-i+p},</math> <math> i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

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

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

Приведем процедуру на языке С++, реализующую описанный алгоритм. На вход процедуре подается порядок матрицы <math>n</math> и ссылка на заполняемую матрицу <math>result</math>. Считаем, что <math>n</math> положительно, делится на <math>4</math>, <math>n-1</math> - простое число, а размер матрицы <math>result</math> равен <math>n \times n</math>.

<source lang="C">
void buildHadamardMatrix(int n, vector< vector<int> > & result)
{
// 1) matrix size changing
result.resize(n);
for (int i=0; i<n; i++) {
result[i].resize(n);
}

// 2) residue array building
int p=n-1;
vector<int> residues;
residues.resize(2*p);
for (int i=0; i<p; i++) {
residues[i] = -1;
}
for (int i=1; i<= (p-1)/2; i++) {
residues[i*i % p] = 1;
}
for (int i=p; i<2*p; i++) {
residues[i] = residues[i-p];
}
// 3) Paley matrix building
// first line filling
for (int j=0; j<n; j++) {
result[0][j] = 1;
}
// first column filling
for (int i=1; i<n; i++) {
result[i][0] = 1;
}
// others
for (int i=1; i<n; i++) {
for (int j=1; j<n; j++) {
result[i][j] = residues[j-i+p];
}
}
}
</source>

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

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

Основными операциями алгоритма являются:

* <math>\frac{n}{2}-2</math> операций умножения;
* <math>\frac{n}{2}-2</math> операций взятия остатка;
* <math>n^2+\frac{5}{2}n-3</math> операций присваивания.

Из чего следует, что алгоритм имеет квадратичную последовательную сложность.

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

Информационный граф алгоритма можно представить в виде четырёх последовательных блоков. Первый блок содержит <math>n-1</math> параллельных ветвей, второй блок - <math>\frac{n}{2}-1</math> параллельных ветвей, третий - <math>n-1</math> и четвёртый - <math>n^2</math>.

[[Файл:i_graph2.png]]

Каждая вершина из <math>A_1-A_{n-1}</math>, <math>C_1-C_{n-1}</math>, <math>D_1-D_{n^2}</math> соответствует операции присваивания, каждая вершина из <math>B_1-B_{\frac{n}{2}-1}</math> соответствует трём последовательным операциям: умножения, взятия остатка по модулю и присваивания, а вершины, окрашенные серым, представляют собой промежуточные точки синхронизации.

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

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

* <math>n-1</math> операций присваивания;
* <math>\frac{n}{2}-1</math> участков, состоящих из трёх операций: умножения, взятия остатка и присваивания;
* <math>n-1</math> операций присваивания;
* <math>n^2</math> операций присваивания.

Из этого можно сделать вывод, что высота ярусно-параллельной формы информационного графа равняется 6 (присваивание, умножение, взятие остатка, присваивание, присваивание, присваивание). Ширина ярусно-параллельной формы равняется <math>n^2</math>, что означает, что при использовании <math>n^2</math> процессоров матрица Адамара будет строиться за 6 операций.

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

'''Входные данные:''' число <math>n</math> - порядок матрицы Адамара <math>H_n</math>. Дополнительные ограничения на <math>n</math>:
* <math>n</math> - натуральное;
* <math>n</math> делится на 4;
* <math>n-1</math> - простое.
'''Объем входных данных:''' 1 (число <math>n</math>).

'''Выходные данные:''' построенная матрица Адамара <math>H_n</math> (её элементы <math>h_{ij}</math>).

'''Объем выходных данных:''' <math>n^2</math> (количество элементов матрицы Адамара размера <math>n*n</math>).

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

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

Вычислительная мощность алгоритма является постоянной (<math>O(1)</math>).

Алгоритм является полностью детерминированным.

Для вершин <math>A_1-A_{n-1}</math>, <math>B_1-B_{\frac{n}{2}-1}</math>, <math>C_1-C_{n-1}</math> информационного графа степени исхода являются линейными, что означает, что при возможности на этапе реализации необходимо позаботиться об эффективном доступе к элементам массива "<math>residues</math>".

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

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

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

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

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

Исследование масштабируемости параллельной реализации алгоритма построения матрицы Адамара проводилось на суперкомпьютере «Ломоносов». Для этого была исследована собственная реализация алгоритма с использованием средств MPI. В ходе исследования было произведено множество запусков программы с различными значениями параметра <math>n</math> (размер матрицы Адамара) и числом процессоров.

Набор и границы значений изменяемых параметров запуска реализации алгоритма:
*число процессоров (p): [2,64] с шагом 2;
*размер матрицы: простые числа в диапазоне [4,10000].

В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:
*минимальная эффективность реализации 0.0000036% при n=4, p=2;
*максимальная эффективность реализации 0.333426% при n=948, p=2.

Ниже представлены графики времени работы, производительности и эффективности данной реализации алгоритма построения матрицы Адамара в зависимости от изменяемых параметров запуска.
[[Файл:time_graph1.png|500px|thumb|center|Время работы параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]
[[Файл:perform_graph1.png|500px|thumb|center|Изменение производительности параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]
[[Файл:efficiency_graph1.png|500px|thumb|center|Эффективность работы параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]

[https://github.com/snikersman/Hadamard Исследованная параллельная реализация на языке C++]

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

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

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

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

Алгоритм построения матрицы Адамара реализован в различных математических пакетах и библиотеках:
* [https://www.mathworks.com/help/matlab/ref/hadamard.html?requestedDomain=www.mathworks.com MATLAB] (вносятся дополнительные ограничения, когда n, или n/12, или n/20 являются степенями по основанию 2)
* [http://r-survey.r-forge.r-project.org/survey/html/hadamard.html R]
* [https://reference.wolframcloud.com/cloudplatform/ref/HadamardMatrix.html Wolfram Mathematica]
* [http://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.linalg.hadamard.html SciPy для Python]

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

Участник:Nikita/Построение матрицы Адамара

2016-11-23T20:26:01Z

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

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O(n^2)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>1</math>
| output_data = <math>n^2</math>
}}

Авторы статьи: [[Участник:Nikita|Иванов Н.В.]] (1.1,1.7,1.9,1.10,2.4,2.7), [[Участник:Tsyganov Nikita|Цыганов Н.И.]] (1.2,1.3,1.4,1.5,1.6,1.7,1.8,2.4).

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

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

Матрицы Адамара были введены в математический обиход в конце прошлого века и играют важную роль в алгебре и комбинаторике. Они находят широкое применение в теории кодирования (коды, исправляющие ошибки), теории планирования многофакторных экспериментов (блок-схемы) и других областях математики.<ref name="rt">http://cyberleninka.ru/article/n/matritsy-adamara-nechetnogo-poryadka.pdf</ref> Сравнительно недавно (в 1960 г.) было замечено, что эти матрицы могут быть использованы для построения кодов с большим кодовым расстоянием.

'''''Матрицей Адамара порядка n''''' называется <math>n*n</math> матрица <math>H</math>, элементами которой являются +1 и −1 такая, что <math>H H^T = n E_n</math>,
где <math>E_n</math> - единичная матрица размера n.

Матрица Адамара обладает следующими ''свойствами'':
* Различные строки матрицы ортогональны
* Скалярное произведение любой строки саму на себя равно n
* Умножение любой строки или столбца на -1 переводит H в другую матрицу Адамара
* Если все элементы первой строки и первого столбца равны +1, то матрица Адамара называется нормализованной

Ниже показаны примеры нормализованных матриц Адамара порядка 1,2 и 4, причем нормализованность матриц сохраняется при перестановке любых строк и столбцов, кроме первых:

<math>H_1 = (1)</math>
<math>,
H_2 =
\begin{pmatrix}
1 & 1\\
1 & -1\end{pmatrix}
</math>,
<math>,
H_4 =
\begin{pmatrix}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1\end{pmatrix}
</math>

Предполагается, что существуют матрицы Адамара порядка 1, 2 и всех порядков n, кратных 4, хотя это до сих пор еще не было доказано. Нет универсального алгоритма построения матрицы Адамара произвольного размера, но известно большое число методов для различных частных случаев, и наименьший порядок, для которого матрица Адамара еще не построена, равен 268 (на 1977 г.). <ref name="rt2">Мак-Вильямс Ф. Дж., Слоэн Н. Дж. А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — c. 52-57</ref> Мы приведем метод построения Пейли, который важен для теории кодирования.

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

Для решения поставленной задачи будем использовать метод Пейли.
Это построение дает матрицы Адамара любого порядка <math>n=p+1</math>, кратного 4, где p-простое число.

'''Определение.''' Пусть p-простое число. Ненулевые квадраты чисел, приведенные по модулю p, называются квадратичными вычетами по модулю p или просто вычетами по модулю p.

Чтобы найти все вычеты по модулю p, достаточно рассмотреть квадраты чисел от <math>1^2</math> до <math>(p-1)^2</math>. Но если учесть, что <math>(p-a)^2 </math> <math>mod </math> <math> p = (-a)^2 </math> <math> mod </math> <math> p = a^2 </math> <math>mod</math> <math> p</math>, то достаточно рассмотреть лишь числа <math>1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod </math> <math>p</math> .

Функция <math>X(i)</math>, называемая символом Лежандра, определяется на целых числах следующим образом:
* <math>X(i)=0</math>, если i кратно p;
* <math>X(i)=1</math>, если остаток от деления i на p является квадратным вычетом по модулю p;
* <math>X(i)=-1</math>, если остаток от деления i на p является невычетом.

Теперь мы построим матрицу Джекобстола <math>Q=(q_{ij})</math>. Она представляет собой <math>(p*p)</math>-матрицу, строки и столбцы которой пронумерованы числами 0,1,..., p-1, а элементы <math>q_{ij}=X(j-i)</math>.

Пусть теперь <math>
H =
\begin{pmatrix}
1 & 1\\
1^T & Q-I\end{pmatrix}
</math>.

Все элементы главной диагонали этой матрицы, кроме элемента <math>h_{00}</math>, равны <math>X(0)-1=-1</math>. Нетрудно заметить, что данная матрица состоит только лишь из элементов 1 и -1.

Доказано, что такая матрица <math>H</math> представляет собой нормализованную матрицу Адамара порядка p+1, которую называют матрицей типа Пейли.<ref name="rt3">http://tc.nsu.ru/uploads/codingtheory.pdf</ref>

Исходные данные алгоритма - это порядок генерируемой матрицы Адамара <math>n</math>, удовлетворяющее следующим свойствам:

* <math>n>0</math>;

* <math>n</math> делится на 4;

* <math>n-1</math> - простое число.

Вспомогательные данные:

* Число <math>p=n-1</math>;
* Вектор квадратичных вычетов (по модулю <math>p</math>) <math>R</math> (элементы <math>r_i</math>) размера <math>2p</math>. В этом векторе индексация идёт с нуля.

Вычисляемые данные:

* Матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>) размера <math>n \times n</math>. Индексация строчек и столбцов идёт с нуля.

Алгоритм:
:1. Строится вектор квадратичных вычетов <math>R</math>.
:: Первые <math>p</math> элементов вектора <math>R</math> (<math>i=0,1,...,p-1</math>) определяются следующим образом:
::: <math>r_i=1</math>, если <math>i \in \{1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod</math> <math> p\}</math>, <math>i=0,1,...,p-1</math>, то есть если <math>i</math> является квадратичным вычетом по модулю <math>p</math>;
::: <math>r_i=-1</math>, иначе.
::Вторые <math>p</math> элементов (<math>i=p,1,...,2p-1</math>) являются копией первых <math>p</math> элементов:
:::<math>r_i=r_{i-p}, i=p,1,...,2p-1.</math>
:2. Строится матрица Адамара <math>H</math>.
::Элементы матрицы Адамара <math>H</math> находятся следующим образом:
::: <math>h_{0j}=1, j=0,1, ... ,n-1;</math>
::: <math>h_{i0}=1, i=1,2, ... ,n-1;</math>
::: <math>h_{ij}=r_{j-i+p}, i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

Вычислительное ядро алгоритма состоит из <math>(n-1) \times (n-1)</math> операций присваивания следующего вида:

:<math>h_{ij}=r_{j-i+p},</math> <math> i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

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

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

Приведем процедуру на языке С++, реализующую описанный алгоритм. На вход процедуре подается порядок матрицы <math>n</math> и ссылка на заполняемую матрицу <math>result</math>. Считаем, что <math>n</math> положительно, делится на <math>4</math>, <math>n-1</math> - простое число, а размер матрицы <math>result</math> равен <math>n \times n</math>.

<source lang="C">
void buildHadamardMatrix(int n, vector< vector<int> > & result)
{
// 1) matrix size changing
result.resize(n);
for (int i=0; i<n; i++) {
result[i].resize(n);
}

// 2) residue array building
int p=n-1;
vector<int> residues;
residues.resize(2*p);
for (int i=0; i<p; i++) {
residues[i] = -1;
}
for (int i=1; i<= (p-1)/2; i++) {
residues[i*i % p] = 1;
}
for (int i=p; i<2*p; i++) {
residues[i] = residues[i-p];
}
// 3) Paley matrix building
// first line filling
for (int j=0; j<n; j++) {
result[0][j] = 1;
}
// first column filling
for (int i=1; i<n; i++) {
result[i][0] = 1;
}
// others
for (int i=1; i<n; i++) {
for (int j=1; j<n; j++) {
result[i][j] = residues[j-i+p];
}
}
}
</source>

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

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

Основными операциями алгоритма являются:

* <math>\frac{n}{2}-2</math> операций умножения;
* <math>\frac{n}{2}-2</math> операций взятия остатка;
* <math>n^2+\frac{5}{2}n-3</math> операций присваивания.

Из чего следует, что алгоритм имеет квадратичную последовательную сложность.

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

Информационный граф алгоритма можно представить в виде четырёх последовательных блоков. Первый блок содержит <math>n-1</math> параллельных ветвей, второй блок - <math>\frac{n}{2}-1</math> параллельных ветвей, третий - <math>n-1</math> и четвёртый - <math>n^2</math>.

[[Файл:i_graph2.png]]

Каждая вершина из <math>A_1-A_{n-1}</math>, <math>C_1-C_{n-1}</math>, <math>D_1-D_{n^2}</math> соответствует операции присваивания, каждая вершина из <math>B_1-B_{\frac{n}{2}-1}</math> соответствует трём последовательным операциям: умножения, взятия остатка по модулю и присваивания, а вершины, окрашенные серым, представляют собой промежуточные точки синхронизации.

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

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

* <math>n-1</math> операций присваивания;
* <math>\frac{n}{2}-1</math> участков, состоящих из трёх операций: умножения, взятия остатка и присваивания;
* <math>n-1</math> операций присваивания;
* <math>n^2</math> операций присваивания.

Из этого можно сделать вывод, что высота ярусно-параллельной формы информационного графа равняется 6 (присваивание, умножение, взятие остатка, присваивание, присваивание, присваивание). Ширина ярусно-параллельной формы равняется <math>n^2</math>, что означает, что при использовании <math>n^2</math> процессоров матрица Адамара будет строиться за 6 операций.

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

'''Входные данные:''' число <math>n</math> - порядок матрицы Адамара <math>H_n</math>. Дополнительные ограничения на <math>n</math>:
* <math>n</math> - натуральное;
* <math>n</math> делится на 4;
* <math>n-1</math> - простое.
'''Объем входных данных:''' 1 (число <math>n</math>).

'''Выходные данные:''' построенная матрица Адамара <math>H_n</math> (её элементы <math>h_{ij}</math>).

'''Объем выходных данных:''' <math>n^2</math> (количество элементов матрицы Адамара размера <math>n*n</math>).

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

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

Вычислительная мощность алгоритма является постоянной (<math>O(1)</math>).

Алгоритм является полностью детерминированным.

Для вершин <math>A_1-A_{n-1}</math>, <math>B_1-B_{\frac{n}{2}-1}</math>, <math>C_1-C_{n-1}</math> информационного графа степени исхода являются линейными, что означает, что при возможности на этапе реализации необходимо позаботиться об эффективном доступе к элементам массива "<math>residues</math>".

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

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

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

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

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

Исследование масштабируемости параллельной реализации алгоритма построения матрицы Адамара проводилось на суперкомпьютере «Ломоносов». Для этого была исследована собственная реализация алгоритма с использованием средств MPI. В ходе исследования было произведено множество запусков программы с различными значениями параметра <math>n</math> (размер матрицы Адамара) и числом процессоров.

Набор и границы значений изменяемых параметров запуска реализации алгоритма:
*число процессоров (p): [2,64] с шагом 2;
*размер матрицы: простые числа в диапазоне [4,10000].

В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:
*минимальная эффективность реализации 0.0000036% при n=4, p=2;
*максимальная эффективность реализации 0.333426% при n=948, p=2.

Ниже представлены графики времени работы, производительности и эффективности данной реализации алгоритма построения матрицы Адамара в зависимости от изменяемых параметров запуска.
[[Файл:time_graph1.png|500px|thumb|center|Время работы параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]
[[Файл:perform_graph1.png|500px|thumb|center|Изменение производительности параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]
[[Файл:efficiency_graph1.png|500px|thumb|center|Эффективность работы параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]

[https://github.com/snikersman/Hadamard Исследованная параллельная реализация на языке C++]

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

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

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

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

Алгоритм построения матрицы Адамара реализован в различных математических пакетах и библиотеках:
* [https://www.mathworks.com/help/matlab/ref/hadamard.html?requestedDomain=www.mathworks.com MATLAB] (вносятся дополнительные ограничения, когда n, или n/12, или n/20 являются степенями по основанию 2)
* [http://r-survey.r-forge.r-project.org/survey/html/hadamard.html R]
* [https://reference.wolframcloud.com/cloudplatform/ref/HadamardMatrix.html Wolfram Mathematica]
* [http://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.linalg.hadamard.html SciPy для Python]

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

Участник:Nikita/Построение матрицы Адамара

2016-11-23T20:25:33Z

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

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O(n^2)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>1</math>
| output_data = <math>n^2</math>
}}

Авторы статьи: [[Участник:Nikita|Иванов Н.В.]] (1.1,1.7,1.9,1.10,2.4,2.7), [[Участник:Tsyganov Nikita|Цыганов Н.И.]] (1.2,1.3,1.4,1.5,1.6,1.7,1.8,2.4).

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

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

Матрицы Адамара были введены в математический обиход в конце прошлого века и играют важную роль в алгебре и комбинаторике. Они находят широкое применение в теории кодирования (коды, исправляющие ошибки), теории планирования многофакторных экспериментов (блок-схемы) и других областях математики.<ref name="rt">http://cyberleninka.ru/article/n/matritsy-adamara-nechetnogo-poryadka.pdf</ref> Сравнительно недавно (в 1960 г.) было замечено, что эти матрицы могут быть использованы для построения кодов с большим кодовым расстоянием.

'''''Матрицей Адамара порядка n''''' называется <math>n*n</math> матрица <math>H</math>, элементами которой являются +1 и −1 такая, что <math>H H^T = n E_n</math>,
где <math>E_n</math> - единичная матрица размера n.

Матрица Адамара обладает следующими ''свойствами'':
* Различные строки матрицы ортогональны
* Скалярное произведение любой строки саму на себя равно n
* Умножение любой строки или столбца на -1 переводит H в другую матрицу Адамара
* Если все элементы первой строки и первого столбца равны +1, то матрица Адамара называется нормализованной

Ниже показаны примеры нормализованных матриц Адамара порядка 1,2 и 4, причем нормализованность матриц сохраняется при перестановке любых строк и столбцов, кроме первых:

<math>H_1 = (1)</math>
<math>,
H_2 =
\begin{pmatrix}
1 & 1\\
1 & -1\end{pmatrix}
</math>,
<math>,
H_4 =
\begin{pmatrix}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1\end{pmatrix}
</math>

Предполагается, что существуют матрицы Адамара порядка 1, 2 и всех порядков n, кратных 4, хотя это до сих пор еще не было доказано. Нет универсального алгоритма построения матрицы Адамара произвольного размера, но известно большое число методов для различных частных случаев, и наименьший порядок, для которого матрица Адамара еще не построена, равен 268 (на 1977 г.). <ref name="rt2">Мак-Вильямс Ф. Дж., Слоэн Н. Дж. А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — c. 52-57</ref> Мы приведем метод построения Пейли, который важен для теории кодирования.

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

Для решения поставленной задачи будем использовать метод Пейли.
Это построение дает матрицы Адамара любого порядка <math>n=p+1</math>, кратного 4, где p-простое число.

'''Определение.''' Пусть p-простое число. Ненулевые квадраты чисел, приведенные по модулю p, называются квадратичными вычетами по модулю p или просто вычетами по модулю p.

Чтобы найти все вычеты по модулю p, достаточно рассмотреть квадраты чисел от <math>1^2</math> до <math>(p-1)^2</math>. Но если учесть, что <math>(p-a)^2 </math> <math>mod </math> <math> p = (-a)^2 </math> <math> mod </math> <math> p = a^2 </math> <math>mod</math> <math> p</math>, то достаточно рассмотреть лишь числа <math>1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod </math> <math>p</math> .

Функция <math>X(i)</math>, называемая символом Лежандра, определяется на целых числах следующим образом:
* <math>X(i)=0</math>, если i кратно p;
* <math>X(i)=1</math>, если остаток от деления i на p является квадратным вычетом по модулю p;
* <math>X(i)=-1</math>, если остаток от деления i на p является невычетом.

Теперь мы построим матрицу Джекобстола <math>Q=(q_{ij})</math>. Она представляет собой <math>(p*p)</math>-матрицу, строки и столбцы которой пронумерованы числами 0,1,..., p-1, а элементы <math>q_{ij}=X(j-i)</math>.

Пусть теперь <math>
H =
\begin{pmatrix}
1 & 1\\
1^T & Q-I\end{pmatrix}
</math>.

Все элементы главной диагонали этой матрицы, кроме элемента <math>h_{00}</math>, равны <math>X(0)-1=-1</math>. Нетрудно заметить, что данная матрица состоит только лишь из элементов 1 и -1.

Доказано, что такая матрица <math>H</math> представляет собой нормализованную матрицу Адамара порядка p+1, которую называют матрицей типа Пейли.<ref name="rt3">http://tc.nsu.ru/uploads/codingtheory.pdf</ref>

Исходные данные алгоритма - это порядок генерируемой матрицы Адамара <math>n</math>, удовлетворяющее следующим свойствам:

* <math>n>0</math>;

* <math>n</math> делится на 4;

* <math>n-1</math> - простое число.

Вспомогательные данные:

* Число <math>p=n-1</math>;
* Вектор квадратичных вычетов (по модулю <math>p</math>) <math>R</math> (элементы <math>r_i</math>) размера <math>2p</math>. В этом векторе индексация идёт с нуля.

Вычисляемые данные:

* Матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>) размера <math>n \times n</math>. Индексация строчек и столбцов идёт с нуля.

Алгоритм:
:1. Строится вектор квадратичных вычетов <math>R</math>.
:: Первые <math>p</math> элементов вектора <math>R</math> (<math>i=0,1,...,p-1</math>) определяются следующим образом:
::: <math>r_i=1</math>, если <math>i \in \{1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod</math> <math> p\}</math>, <math>i=0,1,...,p-1</math>, то есть если <math>i</math> является квадратичным вычетом по модулю <math>p</math>;
::: <math>r_i=-1</math>, иначе.
::Вторые <math>p</math> элементов (<math>i=p,1,...,2p-1</math>) являются копией первых <math>p</math> элементов:
:::<math>r_i=r_{i-p}, i=p,1,...,2p-1.</math>
:2. Строится матрица Адамара <math>H</math>.
::Элементы матрицы Адамара <math>H</math> находятся следующим образом:
::: <math>h_{0j}=1, j=0,1, ... ,n-1;</math>
::: <math>h_{i0}=1, i=1,2, ... ,n-1;</math>
::: <math>h_{ij}=r_{j-i+p}, i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

Вычислительное ядро алгоритма состоит из <math>(n-1) \times (n-1)</math> операций присваивания следующего вида:

:<math>h_{ij}=r_{j-i+p},</math> <math> i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

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

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

Приведем процедуру на языке С++, реализующую описанный алгоритм. На вход процедуре подается порядок матрицы <math>n</math> и ссылка на заполняемую матрицу <math>result</math>. Считаем, что <math>n</math> положительно, делится на <math>4</math>, <math>n-1</math> - простое число, а размер матрицы <math>result</math> равен <math>n \times n</math>.

<source lang="C">
void buildHadamardMatrix(int n, vector< vector<int> > & result)
{
// 1) matrix size changing
result.resize(n);
for (int i=0; i<n; i++) {
result[i].resize(n);
}

// 2) residue array building
int p=n-1;
vector<int> residues;
residues.resize(2*p);
for (int i=0; i<p; i++) {
residues[i] = -1;
}
for (int i=1; i<= (p-1)/2; i++) {
residues[i*i % p] = 1;
}
for (int i=p; i<2*p; i++) {
residues[i] = residues[i-p];
}
// 3) Paley matrix building
// first line filling
for (int j=0; j<n; j++) {
result[0][j] = 1;
}
// first column filling
for (int i=1; i<n; i++) {
result[i][0] = 1;
}
// others
for (int i=1; i<n; i++) {
for (int j=1; j<n; j++) {
result[i][j] = residues[j-i+p];
}
}
}
</source>

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

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

Основными операциями алгоритма являются:

* <math>\frac{n}{2}-2</math> операций умножения;
* <math>\frac{n}{2}-2</math> операций взятия остатка;
* <math>n^2+\frac{5}{2}n-3</math> операций присваивания.

Из чего следует, что алгоритм имеет квадратичную последовательную сложность.

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

Информационный граф алгоритма можно представить в виде четырёх последовательных блоков. Первый блок содержит <math>n-1</math> параллельных ветвей, второй блок - <math>\frac{n}{2}-1</math> параллельных ветвей, третий - <math>n-1</math> и четвёртый - <math>n^2</math>.

[[Файл:i_graph2.png]]

Каждая вершина из <math>A_1-A_{n-1}</math>, <math>C_1-C_{n-1}</math>, <math>D_1-D_{n^2}</math> соответствует операции присваивания, каждая вершина из <math>B_1-B_{\frac{n}{2}-1}</math> соответствует трём последовательным операциям: умножения, взятия остатка по модулю и присваивания, а вершины, окрашенные серым, представляют собой промежуточные точки синхронизации.

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

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

* <math>n-1</math> операций присваивания;
* <math>\frac{n}{2}-1</math> участков, состоящих из трёх операций: умножения, взятия остатка и присваивания;
* <math>n-1</math> операций присваивания;
* <math>n^2</math> операций присваивания.

Из этого можно сделать вывод, что высота ярусно-параллельной формы информационного графа равняется 6 (присваивание, умножение, взятие остатка, присваивание, присваивание, присваивание). Ширина ярусно-параллельной формы равняется <math>n^2</math>, что означает, что при использовании <math>n^2</math> процессоров матрица Адамара будет строиться за 6 операций.

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

'''Входные данные:''' число <math>n</math> - порядок матрицы Адамара <math>H_n</math>. Дополнительные ограничения на <math>n</math>:
* <math>n</math> - натуральное;
* <math>n</math> делится на 4;
* <math>n-1</math> - простое.
'''Объем входных данных:''' 1 (число <math>n</math>).

'''Выходные данные:''' построенная матрица Адамара <math>H_n</math> (её элементы <math>h_{ij}</math>).

'''Объем выходных данных:''' <math>n^2</math> (количество элементов матрицы Адамара размера <math>n*n</math>).

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

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

Вычислительная мощность алгоритма является постоянной (<math>O(1)</math>).

Алгоритм является полностью детерминированным.

Для вершин <math>A_1-A_{n-1}</math>, <math>B_1-B_{\frac{n}{2}-1}</math>, <math>C_1-C_{n-1}</math> информационного графа степени исхода являются линейными, что означает, что при возможности на этапе реализации необходимо позаботиться об эффективном доступе к элементам массива "<math>residues</math>".

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

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

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

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

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

Исследование масштабируемости параллельной реализации алгоритма построения матрицы Адамара проводилось на суперкомпьютере «Ломоносов». Для этого была исследована собственная реализация алгоритма с использованием средств MPI. В ходе исследования было произведено множество запусков программы с различными значениями параметра <math>n</math> (размер матрицы Адамара) и числом процессоров.

Набор и границы значений изменяемых параметров запуска реализации алгоритма:
*число процессоров (p): [2,64] с шагом 2;
*размер матрицы: простые числа в диапазоне [4,10000].

В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:
*минимальная эффективность реализации 0.0000036% при n=4, p=2;
*максимальная эффективность реализации 0.333426% при n=948, p=2.

Ниже представлены графики времени работы, производительности и эффективности данной реализации алгоритма построения матрицы Адамара в зависимости от изменяемых параметров запуска.
[[Файл:time_graph.png|500px|thumb|center|Время работы параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]
[[Файл:perform_graph.png|500px|thumb|center|Изменение производительности параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]
[[Файл:efficiency_graph.png|500px|thumb|center|Эффективность работы параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]

[https://github.com/snikersman/Hadamard Исследованная параллельная реализация на языке C++]

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

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

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

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

Алгоритм построения матрицы Адамара реализован в различных математических пакетах и библиотеках:
* [https://www.mathworks.com/help/matlab/ref/hadamard.html?requestedDomain=www.mathworks.com MATLAB] (вносятся дополнительные ограничения, когда n, или n/12, или n/20 являются степенями по основанию 2)
* [http://r-survey.r-forge.r-project.org/survey/html/hadamard.html R]
* [https://reference.wolframcloud.com/cloudplatform/ref/HadamardMatrix.html Wolfram Mathematica]
* [http://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.linalg.hadamard.html SciPy для Python]

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

Участник:Nikita/Построение матрицы Адамара

2016-11-23T20:09:57Z

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

Участник:Nikita/Построение матрицы Адамара

2016-11-19T20:58:15Z

Nikita:

{{Assignment}}

{{Assignment|Sleo}}
{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O(n^2)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>1</math>
| output_data = <math>n^2</math>
}}

Авторы статьи: [[Участник:Nikita|Иванов Н.В.]] (1.1,1.7,1.9,1.10,2.4,2.7), [[Участник:Tsyganov Nikita|Цыганов Н.И.]] (1.2,1.3,1.4,1.5,1.6,1.7,1.8,2.4).

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

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

Матрицы Адамара были введены в математический обиход в конце прошлого века и играют важную роль в алгебре и комбинаторике. Они находят широкое применение в теории кодирования (коды, исправляющие ошибки), теории планирования многофакторных экспериментов (блок-схемы) и других областях математики.<ref name="rt">http://cyberleninka.ru/article/n/matritsy-adamara-nechetnogo-poryadka.pdf</ref> Сравнительно недавно (в 1960 г.) было замечено, что эти матрицы могут быть использованы для построения кодов с большим кодовым расстоянием.

'''''Матрицей Адамара порядка n''''' называется <math>n*n</math> матрица <math>H</math>, элементами которой являются +1 и −1 такая, что <math>H H^T = n E_n</math>,
где <math>E_n</math> - единичная матрица размера n.

Матрица Адамара обладает следующими ''свойствами'':
* Различные строки матрицы ортогональны
* Скалярное произведение любой строки саму на себя равно n
* Умножение любой строки или столбца на -1 переводит H в другую матрицу Адамара
* Если все элементы первой строки и первого столбца равны +1, то матрица Адамара называется нормализованной

Ниже показаны примеры нормализованных матриц Адамара порядка 1,2 и 4, причем нормализованность матриц сохраняется при перестановке любых строк и столбцов, кроме первых:

<math>H_1 = (1)</math>
<math>,
H_2 =
\begin{pmatrix}
1 & 1\\
1 & -1\end{pmatrix}
</math>,
<math>,
H_4 =
\begin{pmatrix}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1\end{pmatrix}
</math>

Предполагается, что существуют матрицы Адамара порядка 1, 2 и всех порядков n, кратных 4, хотя это до сих пор еще не было доказано. Нет универсального алгоритма построения матрицы Адамара произвольного размера, но известно большое число методов для различных частных случаев, и наименьший порядок, для которого матрица Адамара еще не построена, равен 268 (на 1977 г.). <ref name="rt2">Мак-Вильямс Ф. Дж., Слоэн Н. Дж. А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — c. 52-57</ref> Мы приведем метод построения Пейли, который важен для теории кодирования.

====Метод Пейли====
Это построение дает матрицы Адамара любого порядка <math>n=p+1</math>, кратного 4, где p-простое число.

'''Определение.''' Пусть p-простое число. Ненулевые квадраты чисел, приведенные по модулю p, называются квадратичными вычетами по модулю p или просто вычетами по модулю p.

Функция <math>X(i)</math>, называемая символом Лежандра, определяется на целых числах следующим образом:
* <math>X(i)=0</math>, если i кратно p;
* <math>X(i)=1</math>, если остаток от деления i на p является квадратным вычетом по модулю p;
* <math>X(i)=-1</math>, если остаток от деления i на p является невычетом.

Теперь мы построим матрицу Джекобстола <math>Q=(q_{ij})</math>. Она представляет собой <math>(p*p)</math>-матрицу, строки и столбцы которой пронумерованы числами 0,1,..., p-1, а элементы <math>q_{ij}=X(j-i)</math>.

Пусть теперь <math>
H =
\begin{pmatrix}
1 & 1\\
1^T & Q-I\end{pmatrix}
</math>.

Доказано, что такая матрица <math>H</math> представляет собой нормализованную матрицу Адамара порядка p+1, которую называют матрицей типа Пейли.<ref name="rt3">http://tc.nsu.ru/uploads/codingtheory.pdf</ref>

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

Исходные данные - это порядок генерируемой матрицы Адамара <math>n</math>, удовлетворяющее следующим свойствам:

* <math>n>0</math>;

* <math>n</math> делится на 4;

* <math>n-1</math> - простое число.

Вспомогательные данные:

* Число <math>p=n-1</math>;
* Вектор квадратичных вычетов (по модулю <math>p</math>) <math>R</math> (элементы <math>r_i</math>) размера <math>2p</math>. В этом векторе индексация идёт с нуля.

Вычисляемые данные:

* Матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>) размера <math>n \times n</math>. Индексация строчек и столбцов идёт с нуля.

Алгоритм:
:1. Строится вектор квадратичных вычетов <math>R</math>.
:: Первые <math>p</math> элементов вектора <math>R</math> (<math>i=0,1,...,p-1</math>) определяются следующим образом:
::: <math>r_i=1</math>, если <math>i \in \{1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod</math> <math> p\}</math>, <math>i=0,1,...,p-1</math>, то есть если <math>i</math> является квадратичным вычетом по модулю <math>p</math>;
::: <math>r_i=-1</math>, иначе.
::Вторые <math>p</math> элементов (<math>i=p,1,...,2p-1</math>) являются копией первых <math>p</math> элементов:
:::<math>r_i=r_{i-p}, i=p,1,...,2p-1.</math>
:2. Строится матрица Адамара <math>H</math>.
::Элементы матрицы Адамара <math>H</math> находятся следующим образом:
::: <math>h_{0j}=1, j=0,1, ... ,n-1;</math>
::: <math>h_{i0}=1, i=1,2, ... ,n-1;</math>
::: <math>h_{ij}=r_{j-i+p}, i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

Вычислительное ядро алгоритма состоит из <math>(n-1) \times (n-1)</math> операций присваивания следующего вида:

:<math>h_{ij}=r_{j-i+p},</math> <math> i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

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

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

Приведем процедуру на языке С++, реализующую описанный алгоритм. На вход процедуре подается порядок матрицы <math>n</math> и ссылка на заполняемую матрицу <math>result</math>. Считаем, что <math>n</math> положительно, делится на <math>4</math>, <math>n-1</math> - простое число, а размер матрицы <math>result</math> равен <math>n \times n</math>.

<source lang="C">
void buildHadamardMatrix(int n, vector<vector<int>> & result)
{
// 1) Считаем вычеты по модулю p=n-1 и создаем вспомогательный массив вычетов residues
// Достаточно посчитать значения (1^2 mod p), (2^2 mod p), ... , (((p-1)/2)^2 mod p) - эти значениями и будут являться вычетами.
// Строим массив residues размера 2*p, в котором первые p элементов заполняются по следующей схеме: 1, если индекс элемента - вычет, -1 - иначе.
// Вторая половина массива получается дублированием первой половины
int p=n-1;
vector<int> residues;
residues.resize(2*p);
// Заполняем массив
for (int i=0; i<p; i++) {
residue[i] = -1;
}
for (int i=1; i<= (p-1)/2; i++) {
residue[i^2 % p] = 1;
}
for (int i=p; i<2*p; i++) {
residue[i] = residue[i-p];
}

// 2) Построение матрицы Адамара
// Заполнение первой строки 1-цами
for (int j=0; j<n; j++) {
result[0][j] = 1;
}
// Заполнение первого столбца 1-цами
for (int i=1; i<n; i++) {
result[i][0] = 1;
}
// Заполнение оставшейся части матрицы с использованием вспомогательного массива вычетов residues
for (int i=1; i<n; i++) {
for (int j=1; j<n; j++) {
result[i][j] = residues[j-i+p];
}
}
}
</source>

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

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

Основными операциями алгоритма являются:

* <math>\frac{n}{2}-2</math> операций умножения;
* <math>\frac{n}{2}-2</math> операций взятия остатка;
* <math>n^2+\frac{5}{2}n-3</math> операций присваивания.

Из чего следует, что алгоритм имеет квадратичную последовательную сложность.

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

Информационный граф алгоритма можно представить в виде четырёх последовательных блоков. Первый блок содержит <math>n-1</math> параллельных ветвей, второй блок - <math>\frac{n}{2}-1</math> параллельных ветвей, третий - <math>n-1</math> и четвёртый - <math>n^2</math>.

[[Файл:i_graph2.png]]

Каждая вершина из <math>A_1-A_{n-1}</math>, <math>C_1-C_{n-1}</math>, <math>D_1-D_{n^2}</math> соответствует операции присваивания, каждая вершина из <math>B_1-B_{\frac{n}{2}-1}</math> соответствует трём последовательным операциям: умножения, взятия остатка по модулю и присваивания, а вершины, окрашенные серым, представляют собой промежуточные точки синхронизации.

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

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

* <math>n-1</math> операций присваивания;
* <math>\frac{n}{2}-1</math> участков, состоящих из трёх операций: умножения, взятия остатка и присваивания;
* <math>n-1</math> операций присваивания;
* <math>n^2</math> операций присваивания.

Из этого можно сделать вывод, что высота ярусно-параллельной формы информационного графа равняется 6 (присваивание, умножение, взятие остатка, присваивание, присваивание, присваивание). Ширина ярусно-параллельной формы равняется <math>n^2</math>, что означает, что при использовании <math>n^2</math> процессоров матрица Адамара будет строиться за 6 операций.

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

'''Входные данные:''' число <math>n</math> - порядок матрицы Адамара <math>H_n</math>. Дополнительные ограничения на <math>n</math>:
* <math>n</math> - натуральное;
* <math>n</math> делится на 4;
* <math>n-1</math> - простое.
'''Объем входных данных:''' 1 (число <math>n</math>).

'''Выходные данные:''' построенная матрица Адамара <math>H_n</math> (её элементы <math>h_{ij}</math>).

'''Объем выходных данных:''' <math>n^2</math> (количество элементов матрицы Адамара размера <math>n*n</math>).

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

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

Вычислительная мощность алгоритма является постоянной (<math>O(1)</math>).

Алгоритм является полностью детерминированным.

Для вершин <math>A_1-A_{n-1}</math>, <math>B_1-B_{\frac{n}{2}-1}</math>, <math>C_1-C_{n-1}</math> информационного графа степени исхода являются линейными, что означает, что при возможности на этапе реализации необходимо позаботиться об эффективном доступе к элементам массива "<math>residues</math>".

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

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

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

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

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

Исследование масштабируемости параллельной реализации алгоритма построения матрицы Адамара проводилось на суперкомпьютере «Ломоносов». Для этого была исследована собственная реализация алгоритма с использованием средств MPI. В ходе исследования было произведено множество запусков программы с различными значениями параметра <math>n</math> (размер матрицы Адамара) и числом процессоров.

Набор и границы значений изменяемых параметров запуска реализации алгоритма:
*число процессоров (p): [2,64] с шагом 2;
*размер матрицы: простые числа в диапазоне [4,10000].

В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:
*минимальная эффективность реализации 0.0000029% при n=4, p=2;
*максимальная эффективность реализации 0.323409% при n=908, p=2.

Ниже представлены графики времени работы, производительности и эффективности данной реализации алгоритма построения матрицы Адамара в зависимости от изменяемых параметров запуска.
[[Файл:time_graph.png|500px|thumb|center|Время работы параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]
[[Файл:perform_graph.png|500px|thumb|center|Изменение производительности параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]
[[Файл:efficiency_graph.png|500px|thumb|center|Эффективность работы параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]

[https://github.com/snikersman/Hadamard Исследованная параллельная реализация на языке C++]

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

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

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

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

Алгоритм построения матрицы Адамара реализован в различных математических пакетах и библиотеках:
* [https://www.mathworks.com/help/matlab/ref/hadamard.html?requestedDomain=www.mathworks.com MATLAB] (вносятся дополнительные ограничения, когда n, или n/12, или n/20 являются степенями по основанию 2)
* [http://r-survey.r-forge.r-project.org/survey/html/hadamard.html R]
* [https://reference.wolframcloud.com/cloudplatform/ref/HadamardMatrix.html Wolfram Mathematica]
* [http://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.linalg.hadamard.html SciPy для Python]

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

Участник:Nikita/Построение матрицы Адамара

2016-11-19T20:39:41Z

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

{{Assignment|Sleo}}
{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O(n^2)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>1</math>
| output_data = <math>n^2</math>
}}

Авторы статьи: [[Участник:Nikita|Иванов Н.В.]] (1.1,1.7,1.9,1.10,2.7), [[Участник:Tsyganov Nikita|Цыганов Н.И.]] (1.2,1.3,1.4,1.5,1.6,1.7,1.8).

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

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

Матрицы Адамара были введены в математический обиход в конце прошлого века и играют важную роль в алгебре и комбинаторике. Они находят широкое применение в теории кодирования (коды, исправляющие ошибки), теории планирования многофакторных экспериментов (блок-схемы) и других областях математики.<ref name="rt">http://cyberleninka.ru/article/n/matritsy-adamara-nechetnogo-poryadka.pdf</ref> Сравнительно недавно (в 1960 г.) было замечено, что эти матрицы могут быть использованы для построения кодов с большим кодовым расстоянием.

'''''Матрицей Адамара порядка n''''' называется <math>n*n</math> матрица <math>H</math>, элементами которой являются +1 и −1 такая, что <math>H H^T = n E_n</math>,
где <math>E_n</math> - единичная матрица размера n.

Матрица Адамара обладает следующими ''свойствами'':
* Различные строки матрицы ортогональны
* Скалярное произведение любой строки саму на себя равно n
* Умножение любой строки или столбца на -1 переводит H в другую матрицу Адамара
* Если все элементы первой строки и первого столбца равны +1, то матрица Адамара называется нормализованной

Ниже показаны примеры нормализованных матриц Адамара порядка 1,2 и 4, причем нормализованность матриц сохраняется при перестановке любых строк и столбцов, кроме первых:

<math>H_1 = (1)</math>
<math>,
H_2 =
\begin{pmatrix}
1 & 1\\
1 & -1\end{pmatrix}
</math>,
<math>,
H_4 =
\begin{pmatrix}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1\end{pmatrix}
</math>

Предполагается, что существуют матрицы Адамара порядка 1, 2 и всех порядков n, кратных 4, хотя это до сих пор еще не было доказано. Нет универсального алгоритма построения матрицы Адамара произвольного размера, но известно большое число методов для различных частных случаев, и наименьший порядок, для которого матрица Адамара еще не построена, равен 268 (на 1977 г.). <ref name="rt2">Мак-Вильямс Ф. Дж., Слоэн Н. Дж. А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — c. 52-57</ref> Мы приведем метод построения Пейли, который важен для теории кодирования.

====Метод Пейли====
Это построение дает матрицы Адамара любого порядка <math>n=p+1</math>, кратного 4, где p-простое число.

'''Определение.''' Пусть p-простое число. Ненулевые квадраты чисел, приведенные по модулю p, называются квадратичными вычетами по модулю p или просто вычетами по модулю p.

Функция <math>X(i)</math>, называемая символом Лежандра, определяется на целых числах следующим образом:
* <math>X(i)=0</math>, если i кратно p;
* <math>X(i)=1</math>, если остаток от деления i на p является квадратным вычетом по модулю p;
* <math>X(i)=-1</math>, если остаток от деления i на p является невычетом.

Теперь мы построим матрицу Джекобстола <math>Q=(q_{ij})</math>. Она представляет собой <math>(p*p)</math>-матрицу, строки и столбцы которой пронумерованы числами 0,1,..., p-1, а элементы <math>q_{ij}=X(j-i)</math>.

Пусть теперь <math>
H =
\begin{pmatrix}
1 & 1\\
1^T & Q-I\end{pmatrix}
</math>.

Доказано, что такая матрица <math>H</math> представляет собой нормализованную матрицу Адамара порядка p+1, которую называют матрицей типа Пейли.<ref name="rt3">http://tc.nsu.ru/uploads/codingtheory.pdf</ref>

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

Исходные данные - это порядок генерируемой матрицы Адамара <math>n</math>, удовлетворяющее следующим свойствам:

* <math>n>0</math>;

* <math>n</math> делится на 4;

* <math>n-1</math> - простое число.

Вспомогательные данные:

* Число <math>p=n-1</math>;
* Вектор квадратичных вычетов (по модулю <math>p</math>) <math>R</math> (элементы <math>r_i</math>) размера <math>2p</math>. В этом векторе индексация идёт с нуля.

Вычисляемые данные:

* Матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>) размера <math>n \times n</math>. Индексация строчек и столбцов идёт с нуля.

Алгоритм:
:1. Строится вектор квадратичных вычетов <math>R</math>.
:: Первые <math>p</math> элементов вектора <math>R</math> (<math>i=0,1,...,p-1</math>) определяются следующим образом:
::: <math>r_i=1</math>, если <math>i \in \{1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod</math> <math> p\}</math>, <math>i=0,1,...,p-1</math>, то есть если <math>i</math> является квадратичным вычетом по модулю <math>p</math>;
::: <math>r_i=-1</math>, иначе.
::Вторые <math>p</math> элементов (<math>i=p,1,...,2p-1</math>) являются копией первых <math>p</math> элементов:
:::<math>r_i=r_{i-p}, i=p,1,...,2p-1.</math>
:2. Строится матрица Адамара <math>H</math>.
::Элементы матрицы Адамара <math>H</math> находятся следующим образом:
::: <math>h_{0j}=1, j=0,1, ... ,n-1;</math>
::: <math>h_{i0}=1, i=1,2, ... ,n-1;</math>
::: <math>h_{ij}=r_{j-i+p}, i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

Вычислительное ядро алгоритма состоит из <math>(n-1) \times (n-1)</math> операций присваивания следующего вида:

:<math>h_{ij}=r_{j-i+p},</math> <math> i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

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

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

Приведем процедуру на языке С++, реализующую описанный алгоритм. На вход процедуре подается порядок матрицы <math>n</math> и ссылка на заполняемую матрицу <math>result</math>. Считаем, что <math>n</math> положительно, делится на <math>4</math>, <math>n-1</math> - простое число, а размер матрицы <math>result</math> равен <math>n \times n</math>.

<source lang="C">
void buildHadamardMatrix(int n, vector<vector<int>> & result)
{
// 1) Считаем вычеты по модулю p=n-1 и создаем вспомогательный массив вычетов residues
// Достаточно посчитать значения (1^2 mod p), (2^2 mod p), ... , (((p-1)/2)^2 mod p) - эти значениями и будут являться вычетами.
// Строим массив residues размера 2*p, в котором первые p элементов заполняются по следующей схеме: 1, если индекс элемента - вычет, -1 - иначе.
// Вторая половина массива получается дублированием первой половины
int p=n-1;
vector<int> residues;
residues.resize(2*p);
// Заполняем массив
for (int i=0; i<p; i++) {
residue[i] = -1;
}
for (int i=1; i<= (p-1)/2; i++) {
residue[i^2 % p] = 1;
}
for (int i=p; i<2*p; i++) {
residue[i] = residue[i-p];
}

// 2) Построение матрицы Адамара
// Заполнение первой строки 1-цами
for (int j=0; j<n; j++) {
result[0][j] = 1;
}
// Заполнение первого столбца 1-цами
for (int i=1; i<n; i++) {
result[i][0] = 1;
}
// Заполнение оставшейся части матрицы с использованием вспомогательного массива вычетов residues
for (int i=1; i<n; i++) {
for (int j=1; j<n; j++) {
result[i][j] = residues[j-i+p];
}
}
}
</source>

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

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

Основными операциями алгоритма являются:

* <math>\frac{n}{2}-2</math> операций умножения;
* <math>\frac{n}{2}-2</math> операций взятия остатка;
* <math>n^2+\frac{5}{2}n-3</math> операций присваивания.

Из чего следует, что алгоритм имеет квадратичную последовательную сложность.

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

Информационный граф алгоритма можно представить в виде четырёх последовательных блоков. Первый блок содержит <math>n-1</math> параллельных ветвей, второй блок - <math>\frac{n}{2}-1</math> параллельных ветвей, третий - <math>n-1</math> и четвёртый - <math>n^2</math>.

[[Файл:i_graph2.png]]

Каждая вершина из <math>A_1-A_{n-1}</math>, <math>C_1-C_{n-1}</math>, <math>D_1-D_{n^2}</math> соответствует операции присваивания, каждая вершина из <math>B_1-B_{\frac{n}{2}-1}</math> соответствует трём последовательным операциям: умножения, взятия остатка по модулю и присваивания, а вершины, окрашенные серым, представляют собой промежуточные точки синхронизации.

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

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

* <math>n-1</math> операций присваивания;
* <math>\frac{n}{2}-1</math> участков, состоящих из трёх операций: умножения, взятия остатка и присваивания;
* <math>n-1</math> операций присваивания;
* <math>n^2</math> операций присваивания.

Из этого можно сделать вывод, что высота ярусно-параллельной формы информационного графа равняется 6 (присваивание, умножение, взятие остатка, присваивание, присваивание, присваивание). Ширина ярусно-параллельной формы равняется <math>n^2</math>, что означает, что при использовании <math>n^2</math> процессоров матрица Адамара будет строиться за 6 операций.

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

'''Входные данные:''' число <math>n</math> - порядок матрицы Адамара <math>H_n</math>. Дополнительные ограничения на <math>n</math>:
* <math>n</math> - натуральное;
* <math>n</math> делится на 4;
* <math>n-1</math> - простое.
'''Объем входных данных:''' 1 (число <math>n</math>).

'''Выходные данные:''' построенная матрица Адамара <math>H_n</math> (её элементы <math>h_{ij}</math>).

'''Объем выходных данных:''' <math>n^2</math> (количество элементов матрицы Адамара размера <math>n*n</math>).

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

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

Вычислительная мощность алгоритма является постоянной (<math>O(1)</math>).

Алгоритм является полностью детерминированным.

Для вершин <math>A_1-A_{n-1}</math>, <math>B_1-B_{\frac{n}{2}-1}</math>, <math>C_1-C_{n-1}</math> информационного графа степени исхода являются линейными, что означает, что при возможности на этапе реализации необходимо позаботиться об эффективном доступе к элементам массива "<math>residues</math>".

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

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

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

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

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

Исследование масштабируемости параллельной реализации алгоритма построения матрицы Адамара проводилось на суперкомпьютере «Ломоносов». Для этого была исследована собственная реализация алгоритма с использованием средств MPI. В ходе исследования было произведено множество запусков программы с различными значениями параметра <math>n</math> (размер матрицы Адамара) и числом процессоров.

Набор и границы значений изменяемых параметров запуска реализации алгоритма:
*число процессоров (p): [2,64] с шагом 2;
*размер матрицы: простые числа в диапазоне [4,10000].

В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:
*минимальная эффективность реализации 0.0000029% при n=4, p=2;
*максимальная эффективность реализации 0.323409% при n=908, p=2.

Ниже представлены графики времени работы, производительности и эффективности данной реализации алгоритма построения матрицы Адамара в зависимости от изменяемых параметров запуска.
[[Файл:time_graph.png|500px|thumb|center|Время работы параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]
[[Файл:perform_graph.png|500px|thumb|center|Изменение производительности параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]
[[Файл:efficiency_graph.png|500px|thumb|center|Эффективность работы параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]

[https://github.com/snikersman/Hadamard Исследованная параллельная реализация на языке C++]

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

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

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

Алгоритм построения матрицы Адамара реализован в различных математических пакетах и библиотеках:
* [https://www.mathworks.com/help/matlab/ref/hadamard.html?requestedDomain=www.mathworks.com MATLAB] (вносятся дополнительные ограничения, когда n, или n/12, или n/20 являются степенями по основанию 2)
* [http://r-survey.r-forge.r-project.org/survey/html/hadamard.html R]
* [https://reference.wolframcloud.com/cloudplatform/ref/HadamardMatrix.html Wolfram Mathematica]
* [http://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.linalg.hadamard.html SciPy для Python]

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

Участник:Nikita/Построение матрицы Адамара

2016-11-19T20:00:57Z

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

{{Assignment|Sleo}}
{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O(n^2)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>1</math>
| output_data = <math>n^2</math>
}}

Авторы статьи: [[Участник:Nikita|Иванов Н.В.]] (1.1,1.7,1.9,1.10,2.7), [[Участник:Tsyganov Nikita|Цыганов Н.И.]] (1.2,1.3,1.4,1.5,1.6,1.7,1.8).

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

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

Матрицы Адамара были введены в математический обиход в конце прошлого века и играют важную роль в алгебре и комбинаторике. Они находят широкое применение в теории кодирования (коды, исправляющие ошибки), теории планирования многофакторных экспериментов (блок-схемы) и других областях математики.<ref name="rt">http://cyberleninka.ru/article/n/matritsy-adamara-nechetnogo-poryadka.pdf</ref> Сравнительно недавно (в 1960 г.) было замечено, что эти матрицы могут быть использованы для построения кодов с большим кодовым расстоянием.

'''''Матрицей Адамара порядка n''''' называется <math>n*n</math> матрица <math>H</math>, элементами которой являются +1 и −1 такая, что <math>H H^T = n E_n</math>,
где <math>E_n</math> - единичная матрица размера n.

Матрица Адамара обладает следующими ''свойствами'':
* Различные строки матрицы ортогональны
* Скалярное произведение любой строки саму на себя равно n
* Умножение любой строки или столбца на -1 переводит H в другую матрицу Адамара
* Если все элементы первой строки и первого столбца равны +1, то матрица Адамара называется нормализованной

Ниже показаны примеры нормализованных матриц Адамара порядка 1,2 и 4, причем нормализованность матриц сохраняется при перестановке любых строк и столбцов, кроме первых:

<math>H_1 = (1)</math>
<math>,
H_2 =
\begin{pmatrix}
1 & 1\\
1 & -1\end{pmatrix}
</math>,
<math>,
H_4 =
\begin{pmatrix}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1\end{pmatrix}
</math>

Предполагается, что существуют матрицы Адамара порядка 1, 2 и всех порядков n, кратных 4, хотя это до сих пор еще не было доказано. Нет универсального алгоритма построения матрицы Адамара произвольного размера, но известно большое число методов для различных частных случаев, и наименьший порядок, для которого матрица Адамара еще не построена, равен 268 (на 1977 г.). <ref name="rt2">Мак-Вильямс Ф. Дж., Слоэн Н. Дж. А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — c. 52-57</ref> Мы приведем метод построения Пейли, который важен для теории кодирования.

====Метод Пейли====
Это построение дает матрицы Адамара любого порядка <math>n=p+1</math>, кратного 4, где p-простое число.

'''Определение.''' Пусть p-простое число. Ненулевые квадраты чисел, приведенные по модулю p, называются квадратичными вычетами по модулю p или просто вычетами по модулю p.

Функция <math>X(i)</math>, называемая символом Лежандра, определяется на целых числах следующим образом:
* <math>X(i)=0</math>, если i кратно p;
* <math>X(i)=1</math>, если остаток от деления i на p является квадратным вычетом по модулю p;
* <math>X(i)=-1</math>, если остаток от деления i на p является невычетом.

Теперь мы построим матрицу Джекобстола <math>Q=(q_{ij})</math>. Она представляет собой <math>(p*p)</math>-матрицу, строки и столбцы которой пронумерованы числами 0,1,..., p-1, а элементы <math>q_{ij}=X(j-i)</math>.

Пусть теперь <math>
H =
\begin{pmatrix}
1 & 1\\
1^T & Q-I\end{pmatrix}
</math>.

Доказано, что такая матрица <math>H</math> представляет собой нормализованную матрицу Адамара порядка p+1, которую называют матрицей типа Пейли.<ref name="rt3">http://tc.nsu.ru/uploads/codingtheory.pdf</ref>

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

Исходные данные - это порядок генерируемой матрицы Адамара <math>n</math>, удовлетворяющее следующим свойствам:

* <math>n>0</math>;

* <math>n</math> делится на 4;

* <math>n-1</math> - простое число.

Вспомогательные данные:

* Число <math>p=n-1</math>;
* Вектор квадратичных вычетов (по модулю <math>p</math>) <math>R</math> (элементы <math>r_i</math>) размера <math>2p</math>. В этом векторе индексация идёт с нуля.

Вычисляемые данные:

* Матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>) размера <math>n \times n</math>. Индексация строчек и столбцов идёт с нуля.

Алгоритм:
:1. Строится вектор квадратичных вычетов <math>R</math>.
:: Первые <math>p</math> элементов вектора <math>R</math> (<math>i=0,1,...,p-1</math>) определяются следующим образом:
::: <math>r_i=1</math>, если <math>i \in \{1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod</math> <math> p\}</math>, <math>i=0,1,...,p-1</math>, то есть если <math>i</math> является квадратичным вычетом по модулю <math>p</math>;
::: <math>r_i=-1</math>, иначе.
::Вторые <math>p</math> элементов (<math>i=p,1,...,2p-1</math>) являются копией первых <math>p</math> элементов:
:::<math>r_i=r_{i-p}, i=p,1,...,2p-1.</math>
:2. Строится матрица Адамара <math>H</math>.
::Элементы матрицы Адамара <math>H</math> находятся следующим образом:
::: <math>h_{0j}=1, j=0,1, ... ,n-1;</math>
::: <math>h_{i0}=1, i=1,2, ... ,n-1;</math>
::: <math>h_{ij}=r_{j-i+p}, i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

Вычислительное ядро алгоритма состоит из <math>(n-1) \times (n-1)</math> операций присваивания следующего вида:

:<math>h_{ij}=r_{j-i+p},</math> <math> i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

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

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

Приведем процедуру на языке С++, реализующую описанный алгоритм. На вход процедуре подается порядок матрицы <math>n</math> и ссылка на заполняемую матрицу <math>result</math>. Считаем, что <math>n</math> положительно, делится на <math>4</math>, <math>n-1</math> - простое число, а размер матрицы <math>result</math> равен <math>n \times n</math>.

<source lang="C">
void buildHadamardMatrix(int n, vector<vector<int>> & result)
{
// 1) Считаем вычеты по модулю p=n-1 и создаем вспомогательный массив вычетов residues
// Достаточно посчитать значения (1^2 mod p), (2^2 mod p), ... , (((p-1)/2)^2 mod p) - эти значениями и будут являться вычетами.
// Строим массив residues размера 2*p, в котором первые p элементов заполняются по следующей схеме: 1, если индекс элемента - вычет, -1 - иначе.
// Вторая половина массива получается дублированием первой половины
int p=n-1;
vector<int> residues;
residues.resize(2*p);
// Заполняем массив
for (int i=0; i<p; i++) {
residue[i] = -1;
}
for (int i=1; i<= (p-1)/2; i++) {
residue[i^2 % p] = 1;
}
for (int i=p; i<2*p; i++) {
residue[i] = residue[i-p];
}

// 2) Построение матрицы Адамара
// Заполнение первой строки 1-цами
for (int j=0; j<n; j++) {
result[0][j] = 1;
}
// Заполнение первого столбца 1-цами
for (int i=1; i<n; i++) {
result[i][0] = 1;
}
// Заполнение оставшейся части матрицы с использованием вспомогательного массива вычетов residues
for (int i=1; i<n; i++) {
for (int j=1; j<n; j++) {
result[i][j] = residues[j-i+p];
}
}
}
</source>

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

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

Основными операциями алгоритма являются:

* <math>\frac{n}{2}-2</math> операций умножения;
* <math>\frac{n}{2}-2</math> операций взятия остатка;
* <math>n^2+\frac{5}{2}n-3</math> операций присваивания.

Из чего следует, что алгоритм имеет квадратичную последовательную сложность.

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

Информационный граф алгоритма можно представить в виде четырёх последовательных блоков. Первый блок содержит <math>n-1</math> параллельных ветвей, второй блок - <math>\frac{n}{2}-1</math> параллельных ветвей, третий - <math>n-1</math> и четвёртый - <math>n^2</math>.

[[Файл:i_graph2.png]]

Каждая вершина из <math>A_1-A_{n-1}</math>, <math>C_1-C_{n-1}</math>, <math>D_1-D_{n^2}</math> соответствует операции присваивания, каждая вершина из <math>B_1-B_{\frac{n}{2}-1}</math> соответствует трём последовательным операциям: умножения, взятия остатка по модулю и присваивания, а вершины, окрашенные серым, представляют собой промежуточные точки синхронизации.

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

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

* <math>n-1</math> операций присваивания;
* <math>\frac{n}{2}-1</math> участков, состоящих из трёх операций: умножения, взятия остатка и присваивания;
* <math>n-1</math> операций присваивания;
* <math>n^2</math> операций присваивания.

Из этого можно сделать вывод, что высота ярусно-параллельной формы информационного графа равняется 6 (присваивание, умножение, взятие остатка, присваивание, присваивание, присваивание). Ширина ярусно-параллельной формы равняется <math>n^2</math>, что означает, что при использовании <math>n^2</math> процессоров матрица Адамара будет строиться за 6 операций.

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

'''Входные данные:''' число <math>n</math> - порядок матрицы Адамара <math>H_n</math>. Дополнительные ограничения на <math>n</math>:
* <math>n</math> - натуральное;
* <math>n</math> делится на 4;
* <math>n-1</math> - простое.
'''Объем входных данных:''' 1 (число <math>n</math>).

'''Выходные данные:''' построенная матрица Адамара <math>H_n</math> (её элементы <math>h_{ij}</math>).

'''Объем выходных данных:''' <math>n^2</math> (количество элементов матрицы Адамара размера <math>n*n</math>).

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

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

Вычислительная мощность алгоритма является постоянной (<math>O(1)</math>).

Алгоритм является полностью детерминированным.

Для вершин <math>A_1-A_{n-1}</math>, <math>B_1-B_{\frac{n}{2}-1}</math>, <math>C_1-C_{n-1}</math> информационного графа степени исхода являются линейными, что означает, что при возможности на этапе реализации необходимо позаботиться об эффективном доступе к элементам массива "<math>residues</math>".

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

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

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

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

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

Исследование масштабируемости параллельной реализации алгоритма построения матрицы Адамара проводилось на суперкомпьютере «Ломоносов». Для этого была исследована собственная реализация алгоритма с использованием средств MPI. В ходе исследования было произведено множество запусков программы с различными значениями параметра <math>n</math> (размер матрицы Адамара) и числом процессоров.

Набор и границы значений изменяемых параметров запуска реализации алгоритма:
*число процессоров (p): [2,64] с шагом 2;
*размер матрицы: простые числа в диапазоне [4,10000].

В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:
*минимальная эффективность реализации 0.0000029% при n=4, p=2;
*максимальная эффективность реализации 0.323409% при n=908, p=2.

Ниже представлены графики времени работы, производительности и эффективности данной реализации алгоритма построения матрицы Адамара в зависимости от изменяемых параметров запуска.
[[Файл:time_graph.png|500px|thumb|center|Время работы параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]
[[Файл:perform_graph.png|500px|thumb|center|Изменение производительности параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]
[[Файл:efficiency_graph.png|500px|thumb|center|Эффективность работы параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]

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

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

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

Алгоритм построения матрицы Адамара реализован в различных математических пакетах и библиотеках:
* [https://www.mathworks.com/help/matlab/ref/hadamard.html?requestedDomain=www.mathworks.com MATLAB] (вносятся дополнительные ограничения, когда n, или n/12, или n/20 являются степенями по основанию 2)
* [http://r-survey.r-forge.r-project.org/survey/html/hadamard.html R]
* [https://reference.wolframcloud.com/cloudplatform/ref/HadamardMatrix.html Wolfram Mathematica]
* [http://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.linalg.hadamard.html SciPy для Python]

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

Участник:Nikita/Построение матрицы Адамара

2016-11-19T19:59:29Z

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

{{Assignment|Sleo}}
{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O(n^2)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>1</math>
| output_data = <math>n^2</math>
}}

Авторы статьи: [[Участник:Nikita|Иванов Н.В.]] (1.1,1.7,1.9,1.10,2.7), [[Участник:Tsyganov Nikita|Цыганов Н.И.]] (1.2,1.3,1.4,1.5,1.6,1.7,1.8).

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

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

Матрицы Адамара были введены в математический обиход в конце прошлого века и играют важную роль в алгебре и комбинаторике. Они находят широкое применение в теории кодирования (коды, исправляющие ошибки), теории планирования многофакторных экспериментов (блок-схемы) и других областях математики.<ref name="rt">http://cyberleninka.ru/article/n/matritsy-adamara-nechetnogo-poryadka.pdf</ref> Сравнительно недавно (в 1960 г.) было замечено, что эти матрицы могут быть использованы для построения кодов с большим кодовым расстоянием.

'''''Матрицей Адамара порядка n''''' называется <math>n*n</math> матрица <math>H</math>, элементами которой являются +1 и −1 такая, что <math>H H^T = n E_n</math>,
где <math>E_n</math> - единичная матрица размера n.

Матрица Адамара обладает следующими ''свойствами'':
* Различные строки матрицы ортогональны
* Скалярное произведение любой строки саму на себя равно n
* Умножение любой строки или столбца на -1 переводит H в другую матрицу Адамара
* Если все элементы первой строки и первого столбца равны +1, то матрица Адамара называется нормализованной

Ниже показаны примеры нормализованных матриц Адамара порядка 1,2 и 4, причем нормализованность матриц сохраняется при перестановке любых строк и столбцов, кроме первых:

<math>H_1 = (1)</math>
<math>,
H_2 =
\begin{pmatrix}
1 & 1\\
1 & -1\end{pmatrix}
</math>,
<math>,
H_4 =
\begin{pmatrix}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1\end{pmatrix}
</math>

Предполагается, что существуют матрицы Адамара порядка 1, 2 и всех порядков n, кратных 4, хотя это до сих пор еще не было доказано. Нет универсального алгоритма построения матрицы Адамара произвольного размера, но известно большое число методов для различных частных случаев, и наименьший порядок, для которого матрица Адамара еще не построена, равен 268 (на 1977 г.). <ref name="rt2">Мак-Вильямс Ф. Дж., Слоэн Н. Дж. А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — c. 52-57</ref> Мы приведем метод построения Пейли, который важен для теории кодирования.

====Метод Пейли====
Это построение дает матрицы Адамара любого порядка <math>n=p+1</math>, кратного 4, где p-простое число.

'''Определение.''' Пусть p-простое число. Ненулевые квадраты чисел, приведенные по модулю p, называются квадратичными вычетами по модулю p или просто вычетами по модулю p.

Функция <math>X(i)</math>, называемая символом Лежандра, определяется на целых числах следующим образом:
* <math>X(i)=0</math>, если i кратно p;
* <math>X(i)=1</math>, если остаток от деления i на p является квадратным вычетом по модулю p;
* <math>X(i)=-1</math>, если остаток от деления i на p является невычетом.

Теперь мы построим матрицу Джекобстола <math>Q=(q_{ij})</math>. Она представляет собой <math>(p*p)</math>-матрицу, строки и столбцы которой пронумерованы числами 0,1,..., p-1, а элементы <math>q_{ij}=X(j-i)</math>.

Пусть теперь <math>
H =
\begin{pmatrix}
1 & 1\\
1^T & Q-I\end{pmatrix}
</math>.

Доказано, что такая матрица <math>H</math> представляет собой нормализованную матрицу Адамара порядка p+1, которую называют матрицей типа Пейли.<ref name="rt3">http://tc.nsu.ru/uploads/codingtheory.pdf</ref>

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

Исходные данные - это порядок генерируемой матрицы Адамара <math>n</math>, удовлетворяющее следующим свойствам:

* <math>n>0</math>;

* <math>n</math> делится на 4;

* <math>n-1</math> - простое число.

Вспомогательные данные:

* Число <math>p=n-1</math>;
* Вектор квадратичных вычетов (по модулю <math>p</math>) <math>R</math> (элементы <math>r_i</math>) размера <math>2p</math>. В этом векторе индексация идёт с нуля.

Вычисляемые данные:

* Матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>) размера <math>n \times n</math>. Индексация строчек и столбцов идёт с нуля.

Алгоритм:
:1. Строится вектор квадратичных вычетов <math>R</math>.
:: Первые <math>p</math> элементов вектора <math>R</math> (<math>i=0,1,...,p-1</math>) определяются следующим образом:
::: <math>r_i=1</math>, если <math>i \in \{1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod</math> <math> p\}</math>, <math>i=0,1,...,p-1</math>, то есть если <math>i</math> является квадратичным вычетом по модулю <math>p</math>;
::: <math>r_i=-1</math>, иначе.
::Вторые <math>p</math> элементов (<math>i=p,1,...,2p-1</math>) являются копией первых <math>p</math> элементов:
:::<math>r_i=r_{i-p}, i=p,1,...,2p-1.</math>
:2. Строится матрица Адамара <math>H</math>.
::Элементы матрицы Адамара <math>H</math> находятся следующим образом:
::: <math>h_{0j}=1, j=0,1, ... ,n-1;</math>
::: <math>h_{i0}=1, i=1,2, ... ,n-1;</math>
::: <math>h_{ij}=r_{j-i+p}, i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

Вычислительное ядро алгоритма состоит из <math>(n-1) \times (n-1)</math> операций присваивания следующего вида:

:<math>h_{ij}=r_{j-i+p},</math> <math> i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

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

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

Приведем процедуру на языке С++, реализующую описанный алгоритм. На вход процедуре подается порядок матрицы <math>n</math> и ссылка на заполняемую матрицу <math>result</math>. Считаем, что <math>n</math> положительно, делится на <math>4</math>, <math>n-1</math> - простое число, а размер матрицы <math>result</math> равен <math>n \times n</math>.

<source lang="C">
void buildHadamardMatrix(int n, vector<vector<int>> & result)
{
// 1) Считаем вычеты по модулю p=n-1 и создаем вспомогательный массив вычетов residues
// Достаточно посчитать значения (1^2 mod p), (2^2 mod p), ... , (((p-1)/2)^2 mod p) - эти значениями и будут являться вычетами.
// Строим массив residues размера 2*p, в котором первые p элементов заполняются по следующей схеме: 1, если индекс элемента - вычет, -1 - иначе.
// Вторая половина массива получается дублированием первой половины
int p=n-1;
vector<int> residues;
residues.resize(2*p);
// Заполняем массив
for (int i=0; i<p; i++) {
residue[i] = -1;
}
for (int i=1; i<= (p-1)/2; i++) {
residue[i^2 % p] = 1;
}
for (int i=p; i<2*p; i++) {
residue[i] = residue[i-p];
}

// 2) Построение матрицы Адамара
// Заполнение первой строки 1-цами
for (int j=0; j<n; j++) {
result[0][j] = 1;
}
// Заполнение первого столбца 1-цами
for (int i=1; i<n; i++) {
result[i][0] = 1;
}
// Заполнение оставшейся части матрицы с использованием вспомогательного массива вычетов residues
for (int i=1; i<n; i++) {
for (int j=1; j<n; j++) {
result[i][j] = residues[j-i+p];
}
}
}
</source>

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

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

Основными операциями алгоритма являются:

* <math>\frac{n}{2}-2</math> операций умножения;
* <math>\frac{n}{2}-2</math> операций взятия остатка;
* <math>n^2+\frac{5}{2}n-3</math> операций присваивания.

Из чего следует, что алгоритм имеет квадратичную последовательную сложность.

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

Информационный граф алгоритма можно представить в виде четырёх последовательных блоков. Первый блок содержит <math>n-1</math> параллельных ветвей, второй блок - <math>\frac{n}{2}-1</math> параллельных ветвей, третий - <math>n-1</math> и четвёртый - <math>n^2</math>.

[[Файл:i_graph2.png]]

Каждая вершина из <math>A_1-A_{n-1}</math>, <math>C_1-C_{n-1}</math>, <math>D_1-D_{n^2}</math> соответствует операции присваивания, каждая вершина из <math>B_1-B_{\frac{n}{2}-1}</math> соответствует трём последовательным операциям: умножения, взятия остатка по модулю и присваивания, а вершины, окрашенные серым, представляют собой промежуточные точки синхронизации.

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

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

* <math>n-1</math> операций присваивания;
* <math>\frac{n}{2}-1</math> участков, состоящих из трёх операций: умножения, взятия остатка и присваивания;
* <math>n-1</math> операций присваивания;
* <math>n^2</math> операций присваивания.

Из этого можно сделать вывод, что высота ярусно-параллельной формы информационного графа равняется 6 (присваивание, умножение, взятие остатка, присваивание, присваивание, присваивание). Ширина ярусно-параллельной формы равняется <math>n^2</math>, что означает, что при использовании <math>n^2</math> процессоров матрица Адамара будет строиться за 6 операций.

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

'''Входные данные:''' число <math>n</math> - порядок матрицы Адамара <math>H_n</math>. Дополнительные ограничения на <math>n</math>:
* <math>n</math> - натуральное;
* <math>n</math> делится на 4;
* <math>n-1</math> - простое.
'''Объем входных данных:''' 1 (число <math>n</math>).

'''Выходные данные:''' построенная матрица Адамара <math>H_n</math> (её элементы <math>h_{ij}</math>).

'''Объем выходных данных:''' <math>n^2</math> (количество элементов матрицы Адамара размера <math>n*n</math>).

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

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

Вычислительная мощность алгоритма является постоянной (<math>O(1)</math>).

Алгоритм является полностью детерминированным.

Для вершин <math>A_1-A_{n-1}</math>, <math>B_1-B_{\frac{n}{2}-1}</math>, <math>C_1-C_{n-1}</math> информационного графа степени исхода являются линейными, что означает, что при возможности на этапе реализации необходимо позаботиться об эффективном доступе к элементам массива "<math>residues</math>".

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

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

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

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

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

Исследование масштабируемости параллельной реализации алгоритма построения матрицы Адамара проводилось на суперкомпьютере «Ломоносов». Для этого была исследована собственная реализация алгоритма с использованием средств MPI. В ходе исследования было произведено множество запусков программы с различными значениями параметра <math>n</math> (размер матрицы Адамара) и числом процессоров.

Набор и границы значений изменяемых параметров запуска реализации алгоритма:
*число процессоров (p): [2,64] с шагом 2;
*размер матрицы: простые числа в диапазоне [4,10000].

В результате проведённых экспериментов был получен следующий диапазон эффективности реализации алгоритма:
*минимальная эффективность реализации 0.0000029% при n=4, p=2;
*максимальная эффективность реализации 0.323409% при n=908, p=2.

Ниже представлены графики производительности и эффективности данной реализации алгоритма построения матрицы Адамара в зависимости от изменяемых параметров запуска.
[[Файл:time_graph.png|500px|thumb|center|Время работы параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]
[[Файл:perform_graph.png|500px|thumb|center|Изменение производительности параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]
[[Файл:efficiency_graph.png|500px|thumb|center|Эффективность работы параллельного алгоритма в зависимости от размерности системы и числа процессоров.]]

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

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

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

Алгоритм построения матрицы Адамара реализован в различных математических пакетах и библиотеках:
* [https://www.mathworks.com/help/matlab/ref/hadamard.html?requestedDomain=www.mathworks.com MATLAB] (вносятся дополнительные ограничения, когда n, или n/12, или n/20 являются степенями по основанию 2)
* [http://r-survey.r-forge.r-project.org/survey/html/hadamard.html R]
* [https://reference.wolframcloud.com/cloudplatform/ref/HadamardMatrix.html Wolfram Mathematica]
* [http://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.linalg.hadamard.html SciPy для Python]

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

Участник:Nikita/Построение матрицы Адамара

2016-10-30T18:41:39Z

Nikita:

{{Assignment}}

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O(n^2)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>1</math>
| output_data = <math>n^2</math>
}}

Авторы статьи: [[Участник:Nikita|Иванов Н.В.]] (1.1,1.7,1.9,1.10,2.7), [[Участник:Tsyganov Nikita|Цыганов Н.И.]] (1.2,1.3,1.4,1.5,1.6,1.7,1.8).

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

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

Матрицы Адамара были введены в математический обиход в конце прошлого века и играют важную роль в алгебре и комбинаторике. Они находят широкое применение в теории кодирования (коды, исправляющие ошибки), теории планирования многофакторных экспериментов (блок-схемы) и других областях математики.<ref name="rt">http://cyberleninka.ru/article/n/matritsy-adamara-nechetnogo-poryadka.pdf</ref> Сравнительно недавно (в 1960 г.) было замечено, что эти матрицы могут быть использованы для построения кодов с большим кодовым расстоянием.

'''''Матрицей Адамара порядка n''''' называется <math>n*n</math> матрица <math>H</math>, элементами которой являются +1 и −1 такая, что <math>H H^T = n E_n</math>,
где <math>E_n</math> - единичная матрица размера n.

Матрица Адамара обладает следующими ''свойствами'':
* Различные строки матрицы ортогональны
* Скалярное произведение любой строки саму на себя равно n
* Умножение любой строки или столбца на -1 переводит H в другую матрицу Адамара
* Если все элементы первой строки и первого столбца равны +1, то матрица Адамара называется нормализованной

Ниже показаны примеры нормализованных матриц Адамара порядка 1,2 и 4, причем нормализованность матриц сохраняется при перестановке любых строк и столбцов, кроме первых:

<math>H_1 = (1)</math>
<math>,
H_2 =
\begin{pmatrix}
1 & 1\\
1 & -1\end{pmatrix}
</math>,
<math>,
H_4 =
\begin{pmatrix}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1\end{pmatrix}
</math>

Предполагается, что существуют матрицы Адамара порядка 1, 2 и всех порядков n, кратных 4, хотя это до сих пор еще не было доказано. Нет универсального алгоритма построения матрицы Адамара произвольного размера, но известно большое число методов для различных частных случаев, и наименьший порядок, для которого матрица Адамара еще не построена, равен 268 (на 1977 г.). <ref name="rt2">Мак-Вильямс Ф. Дж., Слоэн Н. Дж. А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — c. 52-57</ref> Мы приведем метод построения Пейли, который важен для теории кодирования.

====Метод Пейли====
Это построение дает матрицы Адамара любого порядка <math>n=p+1</math>, кратного 4, где p-простое число.

'''Определение.''' Пусть p-простое число. Ненулевые квадраты чисел, приведенные по модулю p, называются квадратичными вычетами по модулю p или просто вычетами по модулю p.

Функция <math>X(i)</math>, называемая символом Лежандра, определяется на целых числах следующим образом:
* <math>X(i)=0</math>, если i кратно p;
* <math>X(i)=1</math>, если остаток от деления i на p является квадратным вычетом по модулю p;
* <math>X(i)=-1</math>, если остаток от деления i на p является невычетом.

Теперь мы построим матрицу Джекобстола <math>Q=(q_{ij})</math>. Она представляет собой <math>(p*p)</math>-матрицу, строки и столбцы которой пронумерованы числами 0,1,..., p-1, а элементы <math>q_{ij}=X(j-i)</math>.

Пусть теперь <math>
H =
\begin{pmatrix}
1 & 1\\
1^T & Q-I\end{pmatrix}
</math>.

Доказано, что такая матрица <math>H</math> представляет собой нормализованную матрицу Адамара порядка p+1, которую называют матрицей типа Пейли.<ref name="rt3">http://tc.nsu.ru/uploads/codingtheory.pdf</ref>

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

Исходные данные - это порядок генерируемой матрицы Адамара <math>n</math>, удовлетворяющее следующим свойствам:

* <math>n>0</math>;

* <math>n</math> делится на 4;

* <math>n-1</math> - простое число.

Вспомогательные данные:

* Число <math>p=n-1</math>;
* Вектор квадратичных вычетов (по модулю <math>p</math>) <math>R</math> (элементы <math>r_i</math>) размера <math>2p</math>. В этом векторе индексация идёт с нуля.

Вычисляемые данные:

* Матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>) размера <math>n \times n</math>. Индексация строчек и столбцов идёт с нуля.

Алгоритм:
:1. Строится вектор квадратичных вычетов <math>R</math>.
:: Первые <math>p</math> элементов вектора <math>R</math> (<math>i=0,1,...,p-1</math>) определяются следующим образом:
::: <math>r_i=1</math>, если <math>i \in \{1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod</math> <math> p\}</math>, <math>i=0,1,...,p-1</math>, то есть если <math>i</math> является квадратичным вычетом по модулю <math>p</math>;
::: <math>r_i=-1</math>, иначе.
::Вторые <math>p</math> элементов (<math>i=p,1,...,2p-1</math>) являются копией первых <math>p</math> элементов:
:::<math>r_i=r_{i-p}, i=p,1,...,2p-1.</math>
:2. Строится матрица Адамара <math>H</math>.
::Элементы матрицы Адамара <math>H</math> находятся следующим образом:
::: <math>h_{0j}=1, j=0,1, ... ,n-1;</math>
::: <math>h_{i0}=1, i=1,2, ... ,n-1;</math>
::: <math>h_{ij}=r_{j-i+p}, i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

Вычислительное ядро алгоритма состоит из <math>(n-1) \times (n-1)</math> операций присваивания следующего вида:

:<math>h_{ij}=r_{j-i+p},</math> <math> i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

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

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

Приведем процедуру на языке С++, реализующую описанный алгоритм. На вход процедуре подается порядок матрицы <math>n</math> и ссылка на заполняемую матрицу <math>result</math>. Считаем, что <math>n</math> положительно, делится на <math>4</math>, <math>n-1</math> - простое число, а размер матрицы <math>result</math> равен <math>n \times n</math>.

<source lang="C">
void buildHadamardMatrix(int n, vector<vector<int>> & result)
{
// 1) Считаем вычеты по модулю p=n-1 и создаем вспомогательный массив вычетов residues
// Достаточно посчитать значения (1^2 mod p), (2^2 mod p), ... , (((p-1)/2)^2 mod p) - эти значениями и будут являться вычетами.
// Строим массив residues размера 2*p, в котором первые p элементов заполняются по следующей схеме: 1, если индекс элемента - вычет, -1 - иначе.
// Вторая половина массива получается дублированием первой половины
int p=n-1;
vector<int> residues;
residues.resize(2*p);
// Заполняем массив
for (int i=0; i<p; i++) {
residue[i] = -1;
}
for (int i=1; i<= (p-1)/2; i++) {
residue[i^2 % p] = 1;
}
for (int i=p; i<2*p; i++) {
residue[i] = residue[i-p];
}

// 2) Построение матрицы Адамара
// Заполнение первой строки 1-цами
for (int j=0; j<n; j++) {
result[0][j] = 1;
}
// Заполнение первого столбца 1-цами
for (int i=1; i<n; i++) {
result[i][0] = 1;
}
// Заполнение оставшейся части матрицы с использованием вспомогательного массива вычетов residues
for (int i=1; i<n; i++) {
for (int j=1; j<n; j++) {
result[i][j] = residues[j-i+p];
}
}
}
</source>

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

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

Основными операциями алгоритма являются:

* <math>\frac{n}{2}-2</math> операций умножения;
* <math>\frac{n}{2}-2</math> операций взятия остатка;
* <math>n^2+\frac{5}{2}n-3</math> операций присваивания.

Из чего следует, что алгоритм имеет квадратичную последовательную сложность.

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

Информационный граф алгоритма можно представить в виде четырёх последовательных блоков. Первый блок содержит <math>n-1</math> параллельных ветвей, второй блок - <math>\frac{n}{2}-1</math> параллельных ветвей, третий - <math>n-1</math> и четвёртый - <math>n^2</math>.

[[Файл:i_graph2.png]]

Каждая вершина из <math>A_1-A_{n-1}</math>, <math>C_1-C_{n-1}</math>, <math>D_1-D_{n^2}</math> соответствует операции присваивания, каждая вершина из <math>B_1-B_{\frac{n}{2}-1}</math> соответствует трём последовательным операциям: умножения, взятия остатка по модулю и присваивания, а вершины, окрашенные серым, представляют собой промежуточные точки синхронизации.

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

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

* <math>n-1</math> операций присваивания;
* <math>\frac{n}{2}-1</math> участков, состоящих из трёх операций: умножения, взятия остатка и присваивания;
* <math>n-1</math> операций присваивания;
* <math>n^2</math> операций присваивания.

Из этого можно сделать вывод, что высота ярусно-параллельной формы информационного графа равняется 6 (присваивание, умножение, взятие остатка, присваивание, присваивание, присваивание). Ширина ярусно-параллельной формы равняется <math>n^2</math>, что означает, что при использовании <math>n^2</math> процессоров матрица Адамара будет строиться за 6 операций.

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

'''Входные данные:''' число <math>n</math> - порядок матрицы Адамара <math>H_n</math>. Дополнительные ограничения на <math>n</math>:
* <math>n</math> - натуральное;
* <math>n</math> делится на 4;
* <math>n-1</math> - простое.
'''Объем входных данных:''' 1 (число <math>n</math>).

'''Выходные данные:''' построенная матрица Адамара <math>H_n</math> (её элементы <math>h_{ij}</math>).

'''Объем выходных данных:''' <math>n^2</math> (количество элементов матрицы Адамара размера <math>n*n</math>).

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

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

Вычислительная мощность алгоритма является постоянной (<math>O(1)</math>).

Алгоритм является полностью детерминированным.

Для вершин <math>A_1-A_{n-1}</math>, <math>B_1-B_{\frac{n}{2}-1}</math>, <math>C_1-C_{n-1}</math> информационного графа степени исхода являются линейными, что означает, что при возможности на этапе реализации необходимо позаботиться об эффективном доступе к элементам массива "<math>residues</math>".

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

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

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

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

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

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

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

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

Алгоритм построения матрицы Адамара реализован в различных математических пакетах и библиотеках:
* [https://www.mathworks.com/help/matlab/ref/hadamard.html?requestedDomain=www.mathworks.com MATLAB] (вносятся дополнительные ограничения, когда n, или n/12, или n/20 являются степенями по основанию 2)
* [http://r-survey.r-forge.r-project.org/survey/html/hadamard.html R]
* [https://reference.wolframcloud.com/cloudplatform/ref/HadamardMatrix.html Wolfram Mathematica]
* [http://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.linalg.hadamard.html SciPy для Python]

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

Участник:Nikita/Построение матрицы Адамара

2016-10-30T12:10:42Z

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

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O(n^2)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>1</math>
| output_data = <math>n^2</math>
}}

Авторы статьи: [[Участник:Nikita|Иванов Н.В.]] (1.1,1.7,1.9,1.10,2.7), [[Участник:Tsyganov Nikita|Цыганов Н.И.]] (1.2,1.3,1.4,1.5,1.6,1.7,1.8).

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

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

Матрицы Адамара были введены в математический обиход в конце прошлого века и играют важную роль в алгебре и комбинаторике. Они находят широкое применение в теории кодирования (коды, исправляющие ошибки), теории планирования многофакторных экспериментов (блок-схемы) и других областях математики.<ref name="rt">http://cyberleninka.ru/article/n/matritsy-adamara-nechetnogo-poryadka.pdf</ref> Сравнительно недавно (в 1960 г.) было замечено, что эти матрицы могут быть использованы для построения кодов с большим кодовым расстоянием.

'''''Матрицей Адамара порядка n''''' называется <math>n*n</math> матрица <math>H</math>, элементами которой являются +1 и −1 такая, что <math>H H^T = n E_n</math>,
где <math>E_n</math> - единичная матрица размера n.

Матрица Адамара обладает следующими ''свойствами'':
* Различные строки матрицы ортогональны
* Скалярное произведение любой строки саму на себя равно n
* Умножение любой строки или столбца на -1 переводит H в другую матрицу Адамара
* Если все элементы первой строки и первого столбца равны +1, то матрица Адамара называется нормализованной

Ниже показаны примеры нормализованных матриц Адамара порядка 1,2 и 4, причем нормализованность матриц сохраняется при перестановке любых строк и столбцов, кроме первых:

<math>H_1 = (1)</math>
<math>,
H_2 =
\begin{pmatrix}
1 & 1\\
1 & -1\end{pmatrix}
</math>,
<math>,
H_4 =
\begin{pmatrix}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1\end{pmatrix}
</math>

Предполагается, что существуют матрицы Адамара порядка 1, 2 и всех порядков n, кратных 4, хотя это до сих пор еще не было доказано. Нет универсального алгоритма построения матрицы Адамара произвольного размера, но известно большое число методов для различных частных случаев, и наименьший порядок, для которого матрица Адамара еще не построена, равен 268 (на 1977 г.). <ref name="rt2">Мак-Вильямс Ф. Дж., Слоэн Н. Дж. А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — c. 52-57</ref> Мы приведем метод построения Пейли, который важен для теории кодирования.

====Метод Пейли====
Это построение дает матрицы Адамара любого порядка <math>n=p+1</math>, кратного 4, где p-простое число.

'''Определение.''' Пусть p-простое число. Ненулевые квадраты чисел, приведенные по модулю p, называются квадратичными вычетами по модулю p или просто вычетами по модулю p.

Функция <math>X(i)</math>, называемая символом Лежандра, определяется на целых числах следующим образом:
* <math>X(i)=0</math>, если i кратно p;
* <math>X(i)=1</math>, если остаток от деления i на p является квадратным вычетом по модулю p;
* <math>X(i)=-1</math>, если остаток от деления i на p является невычетом.

Теперь мы построим матрицу Джекобстола <math>Q=(q_{ij})</math>. Она представляет собой <math>(p*p)</math>-матрицу, строки и столбцы которой пронумерованы числами 0,1,..., p-1, а элементы <math>q_{ij}=X(j-i)</math>.

Пусть теперь <math>
H =
\begin{pmatrix}
1 & 1\\
1^T & Q-I\end{pmatrix}
</math>.

Доказано, что такая матрица <math>H</math> представляет собой нормализованную матрицу Адамара порядка p+1, которую называют матрицей типа Пейли.<ref name="rt3">http://tc.nsu.ru/uploads/codingtheory.pdf</ref>

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

Исходные данные - это порядок генерируемой матрицы Адамара <math>n</math>, удовлетворяющее следующим свойствам:

* <math>n>0</math>;

* <math>n</math> делится на 4;

* <math>n-1</math> - простое число.

Вспомогательные данные:

* Число <math>p=n-1</math>;
* Вектор квадратичных вычетов (по модулю <math>p</math>) <math>R</math> (элементы <math>r_i</math>) размера <math>2p</math>. В этом векторе индексация идёт с нуля.

Вычисляемые данные:

* Матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>) размера <math>n \times n</math>. Индексация строчек и столбцов идёт с нуля.

Алгоритм:
:1. Строится вектор квадратичных вычетов <math>R</math>.
:: Первые <math>p</math> элементов вектора <math>R</math> (<math>i=0,1,...,p-1</math>) определяются следующим образом:
::: <math>r_i=1</math>, если <math>i \in \{1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod</math> <math> p\}</math>, <math>i=0,1,...,p-1</math>, то есть если <math>i</math> является квадратичным вычетом по модулю <math>p</math>;
::: <math>r_i=-1</math>, иначе.
::Вторые <math>p</math> элементов (<math>i=p,1,...,2p-1</math>) являются копией первых <math>p</math> элементов:
:::<math>r_i=r_{i-p}, i=p,1,...,2p-1.</math>
:2. Строится матрица Адамара <math>H</math>.
::Элементы матрицы Адамара <math>H</math> находятся следующим образом:
::: <math>h_{0j}=1, j=0,1, ... ,n-1;</math>
::: <math>h_{i0}=1, i=1,2, ... ,n-1;</math>
::: <math>h_{ij}=r_{j-i+p}, i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

Вычислительное ядро алгоритма состоит из <math>(n-1) \times (n-1)</math> операций присваивания следующего вида:

:<math>h_{ij}=r_{j-i+p},</math> <math> i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

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

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

Приведем процедуру на языке С++, реализующую описанный алгоритм. На вход процедуре подается порядок матрицы <math>n</math> и ссылка на заполняемую матрицу <math>result</math>. Считаем, что <math>n</math> положительно, делится на <math>4</math>, <math>n-1</math> - простое число, а размер матрицы <math>result</math> равен <math>n \times n</math>.

<source lang="C">
void buildHadamardMatrix(int n, vector<vector<int>> & result)
{
// 1) Считаем вычеты по модулю p=n-1 и создаем вспомогательный массив вычетов residues
// Достаточно посчитать значения (1^2 mod p), (2^2 mod p), ... , (((p-1)/2)^2 mod p) - эти значениями и будут являться вычетами.
// Строим массив residues размера 2*p, в котором первые p элементов заполняются по следующей схеме: 1, если индекс элемента - вычет, -1 - иначе.
// Вторая половина массива получается дублированием первой половины
int p=n-1;
vector<int> residues;
residues.resize(2*p);
// Заполняем массив
for (int i=0; i<p; i++) {
residue[i] = -1;
}
for (int i=1; i<= (p-1)/2; i++) {
residue[i^2 % p] = 1;
}
for (int i=p; i<2*p; i++) {
residue[i] = residue[i-p];
}

// 2) Построение матрицы Адамара
// Заполнение первой строки 1-цами
for (int j=0; j<n; j++) {
result[0][j] = 1;
}
// Заполнение первого столбца 1-цами
for (int i=1; i<n; i++) {
result[i][0] = 1;
}
// Заполнение оставшейся части матрицы с использованием вспомогательного массива вычетов residues
for (int i=1; i<n; i++) {
for (int j=1; j<n; j++) {
result[i][j] = residues[j-i+p];
}
}
}
</source>

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

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

Основными операциями алгоритма являются:

* <math>\frac{n}{2}-2</math> операций умножения;
* <math>\frac{n}{2}-2</math> операций взятия остатка;
* <math>n^2+\frac{5}{2}n-3</math> операций присваивания.

Из чего следует, что алгоритм имеет квадратичную последовательную сложность.

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

Информационный граф алгоритма можно представить в виде четырёх последовательных блоков. Первый блок содержит <math>n-1</math> параллельных ветвей, второй блок - <math>\frac{n}{2}-1</math> параллельных ветвей, третий - <math>n-1</math> и четвёртый - <math>n^2</math>.

[[Файл:i_graph2.png]]

Каждая вершина из <math>A_1-A_{n-1}</math>, <math>C_1-C_{n-1}</math>, <math>D_1-D_{n^2}</math> соответствует операции присваивания, каждая вершина из <math>B_1-B_{\frac{n}{2}-1}</math> соответствует трём последовательным операциям: умножения, взятия остатка по модулю и присваивания, а вершины, окрашенные серым, представляют собой промежуточные точки синхронизации.

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

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

* <math>n-1</math> операций присваивания;
* <math>\frac{n}{2}-1</math> участков, состоящих из трёх операций: умножения, взятия остатка и присваивания;
* <math>n-1</math> операций присваивания;
* <math>n^2</math> операций присваивания.

Из этого можно сделать вывод, что высота ярусно-параллельной формы информационного графа равняется 6 (присваивание, умножение, взятие остатка, присваивание, присваивание, присваивание). Ширина ярусно-параллельной формы равняется <math>n^2</math>, что означает, что при использовании <math>n^2</math> процессоров матрица Адамара будет строиться за 6 операций.

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

'''Входные данные:''' число <math>n</math> - порядок матрицы Адамара <math>H_n</math>. Дополнительные ограничения на <math>n</math>:
* <math>n</math> - натуральное;
* <math>n</math> делится на 4;
* <math>n-1</math> - простое.
'''Объем входных данных:''' 1 (число <math>n</math>).

'''Выходные данные:''' построенная матрица Адамара <math>H_n</math> (её элементы <math>h_{ij}</math>).

'''Объем выходных данных:''' <math>n^2</math> (количество элементов матрицы Адамара размера <math>n*n</math>).

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

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

Вычислительная мощность алгоритма является постоянной (<math>O(1)</math>).

Алгоритм является полностью детерминированным.

Для вершин <math>A_1-A_{n-1}</math>, <math>B_1-B_{\frac{n}{2}-1}</math>, <math>C_1-C_{n-1}</math> информационного графа степени исхода являются линейными, что означает, что при возможности на этапе реализации необходимо позаботиться об эффективном доступе к элементам массива "<math>residues</math>".

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

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

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

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

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

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

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

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

Алгоритм построения матрицы Адамара реализован в различных математических пакетах и библиотеках:
* [https://www.mathworks.com/help/matlab/ref/hadamard.html?requestedDomain=www.mathworks.com MATLAB] (вносятся дополнительные ограничения, когда n, или n/12, или n/20 являются степенями по основанию 2)
* [http://r-survey.r-forge.r-project.org/survey/html/hadamard.html R]
* [https://reference.wolframcloud.com/cloudplatform/ref/HadamardMatrix.html Wolfram Mathematica]
* [http://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.linalg.hadamard.html SciPy для Python]

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

Участник:Nikita/Построение матрицы Адамара

2016-10-30T12:04:03Z

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

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O(n^2)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>1</math>
| output_data = <math>n^2</math>
}}

Авторы статьи: [[Участник:Nikita|Иванов Н.В.]] (1.1,1.7,1.9,1.10,2.7), [[Участник:Tsyganov Nikita|Цыганов Н.И.]] (1.2,1.3,1.4,1.5,1.6,1.7,1.8).

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

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

Матрицы Адамара были введены в математический обиход в конце прошлого века и играют важную роль в алгебре и комбинаторике. Они находят широкое применение в теории кодирования (коды, исправляющие ошибки), теории планирования многофакторных экспериментов (блок-схемы) и других областях математики.<ref name="rt">http://cyberleninka.ru/article/n/matritsy-adamara-nechetnogo-poryadka.pdf</ref> Сравнительно недавно (в 1960 г.) было замечено, что эти матрицы могут быть использованы для построения кодов с большим кодовым расстоянием.

'''''Матрицей Адамара порядка n''''' называется <math>n*n</math> матрица <math>H</math>, элементами которой являются +1 и −1 такая, что <math>H H^T = n E_n</math>,
где <math>E_n</math> - единичная матрица размера n.

Матрица Адамара обладает следующими ''свойствами'':
* Различные строки матрицы ортогональны
* Скалярное произведение любой строки саму на себя равно n
* Умножение любой строки или столбца на -1 переводит H в другую матрицу Адамара
* Если все элементы первой строки и первого столбца равны +1, то матрица Адамара называется нормализованной

Ниже показаны примеры нормализованных матриц Адамара порядка 1,2 и 4, причем нормализованность матриц сохраняется при перестановке любых строк и столбцов, кроме первых:

<math>H_1 = (1)</math>
<math>,
H_2 =
\begin{pmatrix}
1 & 1\\
1 & -1\end{pmatrix}
</math>,
<math>,
H_4 =
\begin{pmatrix}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1\end{pmatrix}
</math>

Предполагается, что существуют матрицы Адамара порядка 1, 2 и всех порядков n, кратных 4, хотя это до сих пор еще не было доказано. Нет универсального алгоритма построения матрицы Адамара произвольного размера, но известно большое число методов для различных частных случаев, и наименьший порядок, для которого матрица Адамара еще не построена, равен 268 (на 1977 г.). <ref name="rt2">Мак-Вильямс Ф. Дж., Слоэн Н. Дж. А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — c. 52-57</ref> Мы приведем метод построения Пейли, который важен для теории кодирования.

====Метод Пейли====
Это построение дает матрицы Адамара любого порядка <math>n=p+1</math>, кратного 4, где p-простое число.

'''Определение.''' Пусть p-простое число. Ненулевые квадраты чисел, приведенные по модулю p, называются квадратичными вычетами по модулю p или просто вычетами по модулю p.

Функция <math>X(i)</math>, называемая символом Лежандра, определяется на целых числах следующим образом:
* <math>X(i)=0</math>, если i кратно p;
* <math>X(i)=1</math>, если остаток от деления i на p является квадратным вычетом по модулю p;
* <math>X(i)=-1</math>, если остаток от деления i на p является невычетом.

Теперь мы построим матрицу Джекобстола <math>Q=(q_{ij})</math>. Она представляет собой <math>(p*p)</math>-матрицу, строки и столбцы которой пронумерованы числами 0,1,..., p-1, а элементы <math>q_{ij}=X(j-i)</math>.

Пусть теперь <math>
H =
\begin{pmatrix}
1 & 1\\
1^T & Q-I\end{pmatrix}
</math>.

Доказано, что такая матрица <math>H</math> представляет собой нормализованную матрицу Адамара порядка p+1, которую называют матрицей типа Пейли.<ref name="rt3">http://tc.nsu.ru/uploads/codingtheory.pdf</ref>

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

Исходные данные - это порядок генерируемой матрицы Адамара <math>n</math>, удовлетворяющее следующим свойствам:

* <math>n>0</math>;

* <math>n</math> делится на 4;

* <math>n-1</math> - простое число.

Вспомогательные данные:

* Число <math>p=n-1</math>;
* Вектор квадратичных вычетов (по модулю <math>p</math>) <math>R</math> (элементы <math>r_i</math>) размера <math>2p</math>. В этом векторе индексация идёт с нуля.

Вычисляемые данные:

* Матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>) размера <math>n \times n</math>. Индексация строчек и столбцов идёт с нуля.

Алгоритм:
:1. Строится вектор квадратичных вычетов <math>R</math>.
:: Первые <math>p</math> элементов вектора <math>R</math> (<math>i=0,1,...,p-1</math>) определяются следующим образом:
::: <math>r_i=1</math>, если <math>i \in \{1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod</math> <math> p\}</math>, <math>i=0,1,...,p-1</math>, то есть если <math>i</math> является квадратичным вычетом по модулю <math>p</math>;
::: <math>r_i=-1</math>, иначе.
::Вторые <math>p</math> элементов (<math>i=p,1,...,2p-1</math>) являются копией первых <math>p</math> элементов:
:::<math>r_i=r_{i-p}, i=p,1,...,2p-1.</math>
:2. Строится матрица Адамара <math>H</math>.
::Элементы матрицы Адамара <math>H</math> находятся следующим образом:
::: <math>h_{0j}=1, j=0,1, ... ,n-1;</math>
::: <math>h_{i0}=1, i=1,2, ... ,n-1;</math>
::: <math>h_{ij}=r_{j-i+p}, i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

Вычислительное ядро алгоритма состоит из <math>(n-1) \times (n-1)</math> операций присваивания следующего вида:

:<math>h_{ij}=r_{j-i+p},</math> <math> i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

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

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

Приведем процедуру на языке С++, реализующую описанный алгоритм. На вход процедуре подается порядок матрицы <math>n</math> и ссылка на заполняемую матрицу <math>result</math>. Считаем, что <math>n</math> положительно, делится на <math>4</math>, <math>n-1</math> - простое число, а размер матрицы <math>result</math> равен <math>n \times n</math>.

<source lang="C">
void buildHadamardMatrix(int n, vector<vector<int>> & result)
{
// 1) Считаем вычеты по модулю p=n-1 и создаем вспомогательный массив вычетов residues
// Достаточно посчитать значения (1^2 mod p), (2^2 mod p), ... , (((p-1)/2)^2 mod p) - эти значениями и будут являться вычетами.
// Строим массив residues размера 2*p, в котором первые p элементов заполняются по следующей схеме: 1, если индекс элемента - вычет, -1 - иначе.
// Вторая половина массива получается дублированием первой половины
int p=n-1;
vector<int> residues;
residues.resize(2*p);
// Заполняем массив
for (int i=0; i<p; i++) {
residue[i] = -1;
}
for (int i=1; i<= (p-1)/2; i++) {
residue[i^2 % p] = 1;
}
for (int i=p; i<2*p; i++) {
residue[i] = residue[i-p];
}

// 2) Построение матрицы Адамара
// Заполнение первой строки 1-цами
for (int j=0; j<n; j++) {
result[0][j] = 1;
}
// Заполнение первого столбца 1-цами
for (int i=1; i<n; i++) {
result[i][0] = 1;
}
// Заполнение оставшейся части матрицы с использованием вспомогательного массива вычетов residues
for (int i=1; i<n; i++) {
for (int j=1; j<n; j++) {
result[i][j] = residues[j-i+p];
}
}
}
</source>

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

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

Основными операциями алгоритма являются:

* <math>\frac{n}{2}-2</math> операций умножения;
* <math>\frac{n}{2}-2</math> операций взятия остатка;
* <math>n^2+\frac{5}{2}n-3</math> операций присваивания.

Из чего следует, что алгоритм имеет квадратичную последовательную сложность.

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

Информационный граф алгоритма можно представить в виде четырёх последовательных блоков. Первый блок содержит <math>n-1</math> параллельных ветвей, второй блок - <math>\frac{n}{2}-1</math> параллельных ветвей, третий - <math>n-1</math> и четвёртый - <math>n^2</math>.

[[Файл:i_graph2.png]]

Каждая вершина из <math>A_1-A_{n-1}</math>, <math>C_1-C_{n-1}</math>, <math>D_1-D_{n^2}</math> соответствует операции присваивания. А каждая вершина из <math>B_1-B_{\frac{n}{2}-1}</math> соответствует трём последовательным операциям: умножения, взятия остатка по модулю и присваивания.

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

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

* <math>n-1</math> операций присваивания;
* <math>\frac{n}{2}-1</math> участков, состоящих из трёх операций: умножения, взятия остатка и присваивания;
* <math>n-1</math> операций присваивания;
* <math>n^2</math> операций присваивания.

Из этого можно сделать вывод, что высота ярусно-параллельной формы информационного графа равняется 6 (присваивание, умножение, взятие остатка, присваивание, присваивание, присваивание). Ширина ярусно-параллельной формы равняется <math>n^2</math>, что означает, что при использовании <math>n^2</math> процессоров матрица Адамара будет строиться за 6 операций.

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

'''Входные данные:''' число <math>n</math> - порядок матрицы Адамара <math>H_n</math>. Дополнительные ограничения на <math>n</math>:
* <math>n</math> - натуральное;
* <math>n</math> делится на 4;
* <math>n-1</math> - простое.
'''Объем входных данных:''' 1 (число <math>n</math>).

'''Выходные данные:''' построенная матрица Адамара <math>H_n</math> (её элементы <math>h_{ij}</math>).

'''Объем выходных данных:''' <math>n^2</math> (количество элементов матрицы Адамара размера <math>n*n</math>).

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

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

Вычислительная мощность алгоритма является постоянной (<math>O(1)</math>).

Алгоритм является полностью детерминированным.

Для вершин <math>A_1-A_{n-1}</math>, <math>B_1-B_{\frac{n}{2}-1}</math>, <math>C_1-C_{n-1}</math> информационного графа степени исхода являются линейными, что означает, что при возможности на этапе реализации необходимо позаботиться об эффективном доступе к элементам массива "<math>residues</math>".

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

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

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

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

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

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

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

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

Алгоритм построения матрицы Адамара реализован в различных математических пакетах и библиотеках:
* [https://www.mathworks.com/help/matlab/ref/hadamard.html?requestedDomain=www.mathworks.com MATLAB] (вносятся дополнительные ограничения, когда n, или n/12, или n/20 являются степенями по основанию 2)
* [http://r-survey.r-forge.r-project.org/survey/html/hadamard.html R]
* [https://reference.wolframcloud.com/cloudplatform/ref/HadamardMatrix.html Wolfram Mathematica]
* [http://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.linalg.hadamard.html SciPy для Python]

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

Участник:Nikita/Построение матрицы Адамара

2016-10-30T11:59:57Z

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

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O(n^2)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>1</math>
| output_data = <math>n^2</math>
}}

Авторы статьи: [[Участник:Nikita|Иванов Н.В.]] (1.1,1.7,1.9,1.10,2.7), [[Участник:Tsyganov Nikita|Цыганов Н.И.]] (1.2,1.3,1.4,1.5,1.6,1.7,1.8).

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

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

Матрицы Адамара были введены в математический обиход в конце прошлого века и играют важную роль в алгебре и комбинаторике. Они находят широкое применение в теории кодирования (коды, исправляющие ошибки), теории планирования многофакторных экспериментов (блок-схемы) и других областях математики.<ref name="rt">http://cyberleninka.ru/article/n/matritsy-adamara-nechetnogo-poryadka.pdf</ref> Сравнительно недавно (в 1960 г.) было замечено, что эти матрицы могут быть использованы для построения кодов с большим кодовым расстоянием.

'''''Матрицей Адамара порядка n''''' называется <math>n*n</math> матрица <math>H</math>, элементами которой являются +1 и −1 такая, что <math>H H^T = n E_n</math>,
где <math>E_n</math> - единичная матрица размера n.

Матрица Адамара обладает следующими ''свойствами'':
* Различные строки матрицы ортогональны
* Скалярное произведение любой строки саму на себя равно n
* Умножение любой строки или столбца на -1 переводит H в другую матрицу Адамара
* Если все элементы первой строки и первого столбца равны +1, то матрица Адамара называется нормализованной

Ниже показаны примеры нормализованных матриц Адамара порядка 1,2 и 4, причем нормализованность матриц сохраняется при перестановке любых строк и столбцов, кроме первых:

<math>H_1 = (1)</math>
<math>,
H_2 =
\begin{pmatrix}
1 & 1\\
1 & -1\end{pmatrix}
</math>,
<math>,
H_4 =
\begin{pmatrix}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1\end{pmatrix}
</math>

Предполагается, что существуют матрицы Адамара порядка 1, 2 и всех порядков n, кратных 4, хотя это до сих пор еще не было доказано. Нет универсального алгоритма построения матрицы Адамара произвольного размера, но известно большое число методов для различных частных случаев, и наименьший порядок, для которого матрица Адамара еще не построена, равен 268 (на 1977 г.). <ref name="rt2">Мак-Вильямс Ф. Дж., Слоэн Н. Дж. А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — c. 52-57</ref> Мы приведем метод построения Пейли, который важен для теории кодирования.

====Метод Пейли====
Это построение дает матрицы Адамара любого порядка <math>n=p+1</math>, кратного 4, где p-простое число.

'''Определение.''' Пусть p-простое число. Ненулевые квадраты чисел, приведенные по модулю p, называются квадратичными вычетами по модулю p или просто вычетами по модулю p.

Функция <math>X(i)</math>, называемая символом Лежандра, определяется на целых числах следующим образом:
* <math>X(i)=0</math>, если i кратно p;
* <math>X(i)=1</math>, если остаток от деления i на p является квадратным вычетом по модулю p;
* <math>X(i)=-1</math>, если остаток от деления i на p является невычетом.

Теперь мы построим матрицу Джекобстола <math>Q=(q_{ij})</math>. Она представляет собой <math>(p*p)</math>-матрицу, строки и столбцы которой пронумерованы числами 0,1,..., p-1, а элементы <math>q_{ij}=X(j-i)</math>.

Пусть теперь <math>
H =
\begin{pmatrix}
1 & 1\\
1^T & Q-I\end{pmatrix}
</math>.

Доказано, что такая матрица <math>H</math> представляет собой нормализованную матрицу Адамара порядка p+1, которую называют матрицей типа Пейли.<ref name="rt3">http://tc.nsu.ru/uploads/codingtheory.pdf</ref>

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

Исходные данные - это порядок генерируемой матрицы Адамара <math>n</math>, удовлетворяющее следующим свойствам:

* <math>n>0</math>;

* <math>n</math> делится на 4;

* <math>n-1</math> - простое число.

Вспомогательные данные:

* Число <math>p=n-1</math>;
* Вектор квадратичных вычетов (по модулю <math>p</math>) <math>R</math> (элементы <math>r_i</math>) размера <math>2p</math>. В этом векторе индексация идёт с нуля.

Вычисляемые данные:

* Матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>) размера <math>n \times n</math>. Индексация строчек и столбцов идёт с нуля.

Алгоритм:
:1. Строится вектор квадратичных вычетов <math>R</math>.
:: Первые <math>p</math> элементов вектора <math>R</math> (<math>i=0,1,...,p-1</math>) определяются следующим образом:
::: <math>r_i=1</math>, если <math>i \in \{1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod</math> <math> p\}</math>, <math>i=0,1,...,p-1</math>, то есть если <math>i</math> является квадратичным вычетом по модулю <math>p</math>;
::: <math>r_i=-1</math>, иначе.
::Вторые <math>p</math> элементов (<math>i=p,1,...,2p-1</math>) являются копией первых <math>p</math> элементов:
:::<math>r_i=r_{i-p}, i=p,1,...,2p-1.</math>
:2. Строится матрица Адамара <math>H</math>.
::Элементы матрицы Адамара <math>H</math> находятся следующим образом:
::: <math>h_{0j}=1, j=0,1, ... ,n-1;</math>
::: <math>h_{i0}=1, i=1,2, ... ,n-1;</math>
::: <math>h_{ij}=r_{j-i+p}, i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

Вычислительное ядро алгоритма состоит из <math>(n-1) \times (n-1)</math> операций присваивания следующего вида:

:<math>h_{ij}=r_{j-i+p},</math> <math> i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

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

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

Приведем процедуру на языке С++, реализующую описанный алгоритм. На вход процедуре подается порядок матрицы <math>n</math> и ссылка на заполняемую матрицу <math>result</math>. Считаем, что <math>n</math> положительно, делится на <math>4</math>, <math>n-1</math> - простое число, а размер матрицы <math>result</math> равен <math>n \times n</math>.

<source lang="C">
void buildHadamardMatrix(int n, vector<vector<int>> & result)
{
// 1) Считаем вычеты по модулю p=n-1 и создаем вспомогательный массив вычетов residues
// Достаточно посчитать значения (1^2 mod p), (2^2 mod p), ... , (((p-1)/2)^2 mod p) - эти значениями и будут являться вычетами.
// Строим массив residues размера 2*p, в котором первые p элементов заполняются по следующей схеме: 1, если индекс элемента - вычет, -1 - иначе.
// Вторая половина массива получается дублированием первой половины
int p=n-1;
vector<int> residues;
residues.resize(2*p);
// Заполняем массив
for (int i=0; i<p; i++) {
residue[i] = -1;
}
for (int i=1; i<= (p-1)/2; i++) {
residue[i^2 % p] = 1;
}
for (int i=p; i<2*p; i++) {
residue[i] = residue[i-p];
}

// 2) Построение матрицы Адамара
// Заполнение первой строки 1-цами
for (int j=0; j<n; j++) {
result[0][j] = 1;
}
// Заполнение первого столбца 1-цами
for (int i=1; i<n; i++) {
result[i][0] = 1;
}
// Заполнение оставшейся части матрицы с использованием вспомогательного массива вычетов residues
for (int i=1; i<n; i++) {
for (int j=1; j<n; j++) {
result[i][j] = residues[j-i+p];
}
}
}
</source>

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

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

Основными операциями алгоритма являются:

* <math>\frac{n}{2}-2</math> операций умножения;
* <math>\frac{n}{2}-2</math> операций взятия остатка;
* <math>n^2+\frac{5}{2}n-3</math> операций присваивания.

Из чего следует, что алгоритм имеет квадратичную последовательную сложность.

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

Информационный граф алгоритма можно представить в виде четырёх последовательных блоков. Первый блок содержит <math>n-1</math> параллельных ветвей, второй блок - <math>\frac{n}{2}-1</math> параллельных ветвей, третий - <math>n-1</math> и четвёртый - <math>n^2</math>.

[[Файл:i_graph2.png]]

Каждая вершина из <math>A_1-A_{n-1}</math>, <math>C_1-C_{n-1}</math>, <math>D_1-D_{n^2}</math> соответствует операции присваивания. А каждая вершина из <math>B_1-B_{\frac{n}{2}-1}</math> соответствует трём последовательным операциям: умножения, взятия остатка по модулю и присваивания.

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

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

* <math>n-1</math> операций присваивания;
* <math>\frac{n}{2}-1</math> участков, состоящих из трёх операций: умножения, взятия остатка и присваивания;
* <math>n-1</math> операций присваивания;
* <math>n^2</math> операций присваивания.

Из этого можно сделать вывод, что высота ярусно-параллельной формы информационного графа равняется 6 (присваивание, умножение, взятие остатка, присваивание, присваивание, присваивание). Ширина ярусно-параллельной формы равняется <math>n^2</math>, что означает, что при использовании <math>n^2</math> процессоров матрица Адамара будет строиться за 6 операций.

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

'''Входные данные:''' число <math>n</math> - порядок матрицы Адамара <math>H_n</math>. Дополнительные ограничения на <math>n</math>:
* <math>n</math> - натуральное
* <math>n</math> делится на 4
* <math>n-1</math> - простое.
'''Объем входных данных:''' 1 (число <math>n</math>).

'''Выходные данные:''' построенная матрица Адамара <math>H_n</math> (её элементы <math>h_{ij}</math>).

'''Объем выходных данных:''' <math>n^2</math> (количество элементов матрицы Адамара размера <math>n*n</math>).

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

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

Вычислительная мощность алгоритма является постоянной (<math>O(1)</math>).

Алгоритм является полностью детерминированным.

Для вершин <math>A_1-A_{n-1}</math>, <math>B_1-B_{\frac{n}{2}-1}</math>, <math>C_1-C_{n-1}</math> информационного графа степени исхода являются линейными, что означает, что при возможности на этапе реализации необходимо позаботиться об эффективном доступе к элементам массива "<math>residues</math>".

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

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

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

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

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

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

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

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

Алгоритм построения матрицы Адамара реализован в различных математических пакетах и библиотеках:
* [https://www.mathworks.com/help/matlab/ref/hadamard.html?requestedDomain=www.mathworks.com MATLAB] (вносятся дополнительные ограничения, когда n, или n/12, или n/20 являются степенями по основанию 2)
* [http://r-survey.r-forge.r-project.org/survey/html/hadamard.html R]
* [https://reference.wolframcloud.com/cloudplatform/ref/HadamardMatrix.html Wolfram Mathematica]
* [http://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.linalg.hadamard.html SciPy для Python]

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

Участник:Nikita/Построение матрицы Адамара

2016-10-30T11:58:09Z

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

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O(n^2)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>1</math>
| output_data = <math>n^2</math>
}}

Авторы статьи: [[Участник:Nikita|Иванов Н.В.]] (1.1,1.7,1.9,1.10,2.7), [[Участник:Tsyganov Nikita|Цыганов Н.И.]] (1.2,1.3,1.4,1.5,1.6,1.7,1.8).

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

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

Матрицы Адамара были введены в математический обиход в конце прошлого века и играют важную роль в алгебре и комбинаторике. Они находят широкое применение в теории кодирования (коды, исправляющие ошибки), теории планирования многофакторных экспериментов (блок-схемы) и других областях математики.<ref name="rt">http://cyberleninka.ru/article/n/matritsy-adamara-nechetnogo-poryadka.pdf</ref> Сравнительно недавно (в 1960 г.) было замечено, что эти матрицы могут быть использованы для построения кодов с большим кодовым расстоянием.

'''''Матрицей Адамара порядка n''''' называется <math>n*n</math> матрица <math>H</math>, элементами которой являются +1 и −1 такая, что <math>H H^T = n E_n</math>,
где <math>E_n</math> - единичная матрица размера n.

Матрица Адамара обладает следующими ''свойствами'':
* Различные строки матрицы ортогональны
* Скалярное произведение любой строки саму на себя равно n
* Умножение любой строки или столбца на -1 переводит H в другую матрицу Адамара
* Если все элементы первой строки и первого столбца равны +1, то матрица Адамара называется нормализованной

Ниже показаны примеры нормализованных матриц Адамара порядка 1,2 и 4, причем нормализованность матриц сохраняется при перестановке любых строк и столбцов, кроме первых:

<math>H_1 = (1)</math>
<math>,
H_2 =
\begin{pmatrix}
1 & 1\\
1 & -1\end{pmatrix}
</math>,
<math>,
H_4 =
\begin{pmatrix}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1\end{pmatrix}
</math>

Предполагается, что существуют матрицы Адамара порядка 1, 2 и всех порядков n, кратных 4, хотя это до сих пор еще не было доказано. Нет универсального алгоритма построения матрицы Адамара произвольного размера, но известно большое число методов для различных частных случаев, и наименьший порядок, для которого матрица Адамара еще не построена, равен 268 (на 1977 г.). <ref name="rt2">Мак-Вильямс Ф. Дж., Слоэн Н. Дж. А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — c. 52-57</ref> Мы приведем метод построения Пейли, который важен для теории кодирования.

====Метод Пейли====
Это построение дает матрицы Адамара любого порядка <math>n=p+1</math>, кратного 4, где p-простое число.

'''Определение.''' Пусть p-простое число. Ненулевые квадраты чисел, приведенные по модулю p, называются квадратичными вычетами по модулю p или просто вычетами по модулю p.

Функция <math>X(i)</math>, называемая символом Лежандра, определяется на целых числах следующим образом:
* <math>X(i)=0</math>, если i кратно p;
* <math>X(i)=1</math>, если остаток от деления i на p является квадратным вычетом по модулю p;
* <math>X(i)=-1</math>, если остаток от деления i на p является невычетом.

Теперь мы построим матрицу Джекобстола <math>Q=(q_{ij})</math>. Она представляет собой <math>(p*p)</math>-матрицу, строки и столбцы которой пронумерованы числами 0,1,..., p-1, а элементы <math>q_{ij}=X(j-i)</math>.

Пусть теперь <math>
H =
\begin{pmatrix}
1 & 1\\
1^T & Q-I\end{pmatrix}
</math>.

Доказано, что такая матрица <math>H</math> представляет собой нормализованную матрицу Адамара порядка p+1, которую называют матрицей типа Пейли.<ref name="rt3">http://tc.nsu.ru/uploads/codingtheory.pdf</ref>

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

Исходные данные - это порядок генерируемой матрицы Адамара <math>n</math>, удовлетворяющее следующим свойствам:

* <math>n>0</math>;

* <math>n</math> делится на 4;

* <math>n-1</math> - простое число.

Вспомогательные данные:

* Число <math>p=n-1</math>;
* Вектор квадратичных вычетов (по модулю <math>p</math>) <math>R</math> (элементы <math>r_i</math>) размера <math>2p</math>. В этом векторе индексация идёт с нуля.

Вычисляемые данные:

* Матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>) размера <math>n \times n</math>. Индексация строчек и столбцов идёт с нуля.

Алгоритм:
:1. Строится вектор квадратичных вычетов <math>R</math>.
:: Первые <math>p</math> элементов вектора <math>R</math> (<math>i=0,1,...,p-1</math>) определяются следующим образом:
::: <math>r_i=1</math>, если <math>i \in \{1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod</math> <math> p\}</math>, <math>i=0,1,...,p-1</math>, то есть если <math>i</math> является квадратичным вычетом по модулю <math>p</math>;
::: <math>r_i=-1</math>, иначе.
::Вторые <math>p</math> элементов (<math>i=p,1,...,2p-1</math>) являются копией первых <math>p</math> элементов:
:::<math>r_i=r_{i-p}, i=p,1,...,2p-1.</math>
:2. Строится матрица Адамара <math>H</math>.
::Элементы матрицы Адамара <math>H</math> находятся следующим образом:
::: <math>h_{0j}=1, j=0,1, ... ,n-1;</math>
::: <math>h_{i0}=1, i=1,2, ... ,n-1;</math>
::: <math>h_{ij}=r_{j-i+p}, i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

Вычислительное ядро алгоритма состоит из <math>(n-1) \times (n-1)</math> операций присваивания следующего вида:

:<math>h_{ij}=r_{j-i+p},</math> <math> i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

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

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

Приведем процедуру на языке С++, реализующую описанный алгоритм. На вход процедуре подается порядок матрицы <math>n</math> и ссылка на заполняемую матрицу <math>result</math>. Считаем, что <math>n</math> положительно, делится на <math>4</math>, <math>n-1</math> - простое число, а размер матрицы <math>result</math> равен <math>n \times n</math>.

<source lang="C">
void buildHadamardMatrix(int n, vector<vector<int>> & result)
{
// 1) Считаем вычеты по модулю p=n-1 и создаем вспомогательный массив вычетов residues
// Достаточно посчитать значения (1^2 mod p), (2^2 mod p), ... , (((p-1)/2)^2 mod p) - эти значениями и будут являться вычетами.
// Строим массив residues размера 2*p, в котором первые p элементов заполняются по следующей схеме: 1, если индекс элемента - вычет, -1 - иначе.
// Вторая половина массива получается дублированием первой половины
int p=n-1;
vector<int> residues;
residues.resize(2*p);
// Заполняем массив
for (int i=0; i<p; i++) {
residue[i] = -1;
}
for (int i=1; i<= (p-1)/2; i++) {
residue[i^2 % p] = 1;
}
for (int i=p; i<2*p; i++) {
residue[i] = residue[i-p];
}

// 2) Построение матрицы Адамара
// Заполнение первой строки 1-цами
for (int j=0; j<n; j++) {
result[0][j] = 1;
}
// Заполнение первого столбца 1-цами
for (int i=1; i<n; i++) {
result[i][0] = 1;
}
// Заполнение оставшейся части матрицы с использованием вспомогательного массива вычетов residues
for (int i=1; i<n; i++) {
for (int j=1; j<n; j++) {
result[i][j] = residues[j-i+p];
}
}
}
</source>

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

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

Основными операциями алгоритма являются:

* <math>\frac{n}{2}-2</math> операций умножения;
* <math>\frac{n}{2}-2</math> операций взятия остатка;
* <math>n^2+\frac{5}{2}n-3</math> операций присваивания.

Из чего следует, что алгоритм имеет квадратичную последовательную сложность.

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

Информационный граф алгоритма можно представить в виде четырёх последовательных блоков. Первый блок содержит <math>n-1</math> параллельных ветвей, второй блок - <math>\frac{n}{2}-1</math> параллельных ветвей, третий - <math>n-1</math> и четвёртый - <math>n^2</math>.

[[Файл:i_graph2.png]]

Каждая вершина из <math>A_1-A_{n-1}</math>, <math>C_1-C_{n-1}</math>, <math>D_1-D_{n^2}</math> соответствует операции присваивания. А каждая вершина из <math>B_1-B_{\frac{n}{2}-1}</math> соответствует трём последовательным операциям: умножения, взятия остатка по модулю и присваивания.

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

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

* <math>n-1</math> операций присваивания;
* <math>\frac{n}{2}-1</math> участков, состоящих из трёх операций: умножения, взятия остатка и присваивания;
* <math>n-1</math> операций присваивания;
* <math>n^2</math> операций присваивания.

Из этого можно сделать вывод, что высота ярусно-параллельной формы информационного графа равняется 6 (присваивание, умножение, взятие остатка, присваивание, присваивание, присваивание). Ширина ярусно-параллельной формы равняется <math>n^2</math>, что означает, что при использовании <math>n^2</math> процессоров матрица Адамара будет строиться за 6 операций.

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

'''Входные данные:''' число <math>n</math> - порядок матрицы Адамара <math>H_n</math>. Дополнительные ограничения на <math>n</math>:
* <math>n</math> - натуральное
* <math>n</math> делится на 4
* <math>n-1</math> - простое
'''Объем входных данных:''' 1 (число <math>n</math>)

'''Выходные данные:''' построенная матрица Адамара <math>H_n</math> (её элементы <math>h_{ij}</math>)

'''Объем выходных данных:''' <math>n^2</math> (количество элементов матрицы Адамара размера <math>n*n</math>)

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

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

Вычислительная мощность алгоритма является постоянной (<math>O(1)</math>).

Алгоритм является полностью детерминированным.

Для вершин <math>A_1-A_{n-1}</math>, <math>B_1-B_{\frac{n}{2}-1}</math>, <math>C_1-C_{n-1}</math> информационного графа степени исхода являются линейными, что означает, что при возможности на этапе реализации необходимо позаботиться об эффективном доступе к элементам массива "<math>residues</math>".

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

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

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

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

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

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

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

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

Алгоритм построения матрицы Адамара реализован в различных математических пакетах и библиотеках:
* [https://www.mathworks.com/help/matlab/ref/hadamard.html?requestedDomain=www.mathworks.com MATLAB] (вносятся дополнительные ограничения, когда n, или n/12, или n/20 являются степенями по основанию 2)
* [http://r-survey.r-forge.r-project.org/survey/html/hadamard.html R]
* [https://reference.wolframcloud.com/cloudplatform/ref/HadamardMatrix.html Wolfram Mathematica]
* [http://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.linalg.hadamard.html SciPy для Python]

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

Участник:Nikita/Построение матрицы Адамара

2016-10-30T11:46:22Z

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

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O(n^2)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>1</math>
| output_data = <math>n^2</math>
}}

Авторы статьи: [[Участник:Nikita|Иванов Н.В.]] (1.1,1.7,1.9,1.10,2.7), [[Участник:Tsyganov Nikita|Цыганов Н.И.]] (1.2,1.3,1.4,1.5,1.6,1.7,1.8).

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

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

Матрицы Адамара были введены в математический обиход в конце прошлого века и играют важную роль в алгебре и комбинаторике. Они находят широкое применение в теории кодирования (коды, исправляющие ошибки), теории планирования многофакторных экспериментов (блок-схемы) и других областях математики.<ref name="rt">http://cyberleninka.ru/article/n/matritsy-adamara-nechetnogo-poryadka.pdf</ref> Сравнительно недавно (в 1960 г.) было замечено, что эти матрицы могут быть использованы для построения кодов с большим кодовым расстоянием.

'''''Матрицей Адамара порядка n''''' называется <math>n*n</math> матрица <math>H</math>, элементами которой являются +1 и −1 такая, что <math>H H^T = n E_n</math>,
где <math>E_n</math> - единичная матрица размера n.

Матрица Адамара обладает следующими ''свойствами'':
* Различные строки матрицы ортогональны
* Скалярное произведение любой строки саму на себя равно n
* Умножение любой строки или столбца на -1 переводит H в другую матрицу Адамара
* Если все элементы первой строки и первого столбца равны +1, то матрица Адамара называется нормализованной

Ниже показаны примеры нормализованных матриц Адамара порядка 1,2 и 4, причем нормализованность матриц сохраняется при перестановке любых строк и столбцов, кроме первых:

<math>H_1 = (1)</math>
<math>,
H_2 =
\begin{pmatrix}
1 & 1\\
1 & -1\end{pmatrix}
</math>,
<math>,
H_4 =
\begin{pmatrix}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1\end{pmatrix}
</math>

Предполагается, что существуют матрицы Адамара порядка 1, 2 и всех порядков n, кратных 4, хотя это до сих пор еще не было доказано. Нет универсального алгоритма построения матрицы Адамара произвольного размера, но известно большое число методов для различных частных случаев, и наименьший порядок, для которого матрица Адамара еще не построена, равен 268 (на 1977 г.). <ref name="rt2">Мак-Вильямс Ф. Дж., Слоэн Н. Дж. А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — c. 52-57</ref> Мы приведем метод построения Пейли, который важен для теории кодирования.

====Метод Пейли====
Это построение дает матрицы Адамара любого порядка <math>n=p+1</math>, кратного 4, где p-простое число.

'''Определение.''' Пусть p-простое число. Ненулевые квадраты чисел, приведенные по модулю p, называются квадратичными вычетами по модулю p или просто вычетами по модулю p.

Функция <math>X(i)</math>, называемая символом Лежандра, определяется на целых числах следующим образом:
* <math>X(i)=0</math>, если i кратно p;
* <math>X(i)=1</math>, если остаток от деления i на p является квадратным вычетом по модулю p;
* <math>X(i)=-1</math>, если остаток от деления i на p является невычетом.

Теперь мы построим матрицу Джекобстола <math>Q=(q_{ij})</math>. Она представляет собой <math>(p*p)</math>-матрицу, строки и столбцы которой пронумерованы числами 0,1,..., p-1, а элементы <math>q_{ij}=X(j-i)</math>.

Пусть теперь <math>
H =
\begin{pmatrix}
1 & 1\\
1^T & Q-I\end{pmatrix}
</math>.

Доказано, что такая матрица <math>H</math> представляет собой нормализованную матрицу Адамара порядка p+1, которую называют матрицей типа Пейли.<ref name="rt3">http://tc.nsu.ru/uploads/codingtheory.pdf</ref>

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

Исходные данные - это порядок генерируемой матрицы Адамара <math>n</math>, удовлетворяющее следующим свойствам:

* <math>n>0</math>;

* <math>n</math> делится на 4;

* <math>n-1</math> - простое число.

Вспомогательные данные:

* Число <math>p=n-1</math>;
* Вектор квадратичных вычетов (по модулю <math>p</math>) <math>R</math> (элементы <math>r_i</math>) размера <math>2p</math>. В этом векторе индексация идёт с нуля.

Вычисляемые данные:

* Матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>) размера <math>n \times n</math>. Индексация строчек и столбцов идёт с нуля.

Алгоритм:
:1. Строится вектор квадратичных вычетов <math>R</math>.
:: Первые <math>p</math> элементов вектора <math>R</math> (<math>i=0,1,...,p-1</math>) определяются следующим образом:
::: <math>r_i=1</math>, если <math>i \in \{1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod</math> <math> p\}</math>, <math>i=0,1,...,p-1</math>, то есть если <math>i</math> является квадратичным вычетом по модулю <math>p</math>;
::: <math>r_i=-1</math>, иначе.
::Вторые <math>p</math> элементов (<math>i=p,1,...,2p-1</math>) являются копией первых <math>p</math> элементов:
:::<math>r_i=r_{i-p}, i=p,1,...,2p-1.</math>
:2. Строится матрица Адамара <math>H</math>.
::Элементы матрицы Адамара <math>H</math> находятся следующим образом:
::: <math>h_{0j}=1, j=0,1, ... ,n-1;</math>
::: <math>h_{i0}=1, i=1,2, ... ,n-1;</math>
::: <math>h_{ij}=r_{j-i+p}, i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

Вычислительное ядро алгоритма состоит из <math>(n-1) \times (n-1)</math> операций присваивания следующего вида:

:<math>h_{ij}=r_{j-i+p},</math> <math> i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

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

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

Приведем процедуру на языке С++, реализующую описанный алгоритм. На вход процедуре подается порядок матрицы <math>n</math> и ссылка на заполняемую матрицу <math>result</math>. Считаем, что <math>n</math> положительно, делится на <math>4</math>, <math>n-1</math> - простое число, а размер матрицы <math>result</math> равен <math>n \times n</math>.

<source lang="C">
void buildHadamardMatrix(int n, vector<vector<int>> & result)
{
// 1) Считаем вычеты по модулю p=n-1 и создаем вспомогательный массив вычетов residues
// Достаточно посчитать значения (1^2 mod p), (2^2 mod p), ... , (((p-1)/2)^2 mod p) - эти значениями и будут являться вычетами.
// Строим массив residues размера 2*p, в котором первые p элементов заполняются по следующей схеме: 1, если индекс элемента - вычет, -1 - иначе.
// Вторая половина массива получается дублированием первой половины
int p=n-1;
vector<int> residues;
residues.resize(2*p);
// Заполняем массив
for (int i=0; i<p; i++) {
residue[i] = -1;
}
for (int i=1; i<= (p-1)/2; i++) {
residue[i^2 % p] = 1;
}
for (int i=p; i<2*p; i++) {
residue[i] = residue[i-p];
}

// 2) Построение матрицы Адамара
// Заполнение первой строки 1-цами
for (int j=0; j<n; j++) {
result[0][j] = 1;
}
// Заполнение первого столбца 1-цами
for (int i=1; i<n; i++) {
result[i][0] = 1;
}
// Заполнение оставшейся части матрицы с использованием вспомогательного массива вычетов residues
for (int i=1; i<n; i++) {
for (int j=1; j<n; j++) {
result[i][j] = residues[j-i+p];
}
}
}
</source>

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

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

Основными операциями алгоритма являются:

* <math>\frac{n}{2}-2</math> операций умножения;
* <math>\frac{n}{2}-2</math> операций взятия остатка;
* <math>n^2+\frac{5}{2}n-3</math> операций присваивания.

Из чего следует, что алгоритм имеет квадратичную последовательную сложность.

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

Информационный граф алгоритма можно представить в виде четырёх последовательных блоков. Первый блок содержит <math>n-1</math> параллельных ветвей, второй блок - <math>\frac{n}{2}-1</math> параллельных ветвей, третий - <math>n-1</math> и четвёртый - <math>n^2</math>.

[[Файл:i_graph2.png]]

Каждая вершина из <math>A_1-A_{n-1}</math>, <math>C_1-C_{n-1}</math>, <math>D_1-D_{n^2}</math> соответствует операции присваивания. А каждая вершина из <math>B_1-B_{\frac{n}{2}-1}</math> соответствует трём последовательным операциям: умножения, взятия остатка по модулю и присваивания.

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

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

* <math>n-1</math> операций присваивания;
* <math>\frac{n}{2}-1</math> участков, состоящих из трёх операций: умножения, взятия остатка и присваивания;
* <math>n-1</math> операций присваивания;
* <math>n^2</math> операций присваивания.

Из этого можно сделать вывод, что высота ярусно-параллельной формы информационного графа равняется 6 (присваивание, умножение, взятие остатка, присваивание, присваивание, присваивание). Ширина ярусно-параллельной формы равняется <math>n^2</math>, что означает, что при использовании <math>n^2</math> процессоров матрица Адамара будет строиться за 6 операций.

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

'''Входные данные:''' порядок матрицы Адамара <math>n</math>. Дополнительные ограничения на <math>n</math>:
* <math>n>0</math>
* <math>n</math> делится на 4
* <math>n-1</math> - простое число
'''Объем входных данных:''' 1 (число <math>n</math>)

'''Выходные данные:''' матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>)

'''Объем выходных данных:''' <math>n^2</math> (количество элементов матрицы Адамара порядка <math>n</math>)

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

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

Вычислительная мощность алгоритма является постоянной (<math>O(1)</math>).

Алгоритм является полностью детерминированным.

Для вершин <math>A_1-A_{n-1}</math>, <math>B_1-B_{\frac{n}{2}-1}</math>, <math>C_1-C_{n-1}</math> информационного графа степени исхода являются линейными, что означает, что при возможности на этапе реализации необходимо позаботиться об эффективном доступе к элементам массива "<math>residues</math>".

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

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

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

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

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

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

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

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

Алгоритм построения матрицы Адамара реализован в различных математических пакетах и библиотеках:
* [https://www.mathworks.com/help/matlab/ref/hadamard.html?requestedDomain=www.mathworks.com MATLAB] (вносятся дополнительные ограничения, когда n, или n/12, или n/20 являются степенями по основанию 2)
* [http://r-survey.r-forge.r-project.org/survey/html/hadamard.html R]
* [https://reference.wolframcloud.com/cloudplatform/ref/HadamardMatrix.html Wolfram Mathematica]
* [http://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.linalg.hadamard.html SciPy для Python]

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

Участник:Nikita/Построение матрицы Адамара

2016-10-30T11:45:27Z

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

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O(n^2)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>1</math>
| output_data = <math>n^2</math>
}}

Авторы статьи: [[Участник:Nikita|Иванов Н.В.]] (1.1,1.7,1.9,1.10,2.7), [[Участник:Tsyganov Nikita|Цыганов Н.И.]] (1.2,1.3,1.4,1.5,1.6,1.7,1.8).

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

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

Матрицы Адамара были введены в математический обиход в конце прошлого века и играют важную роль в алгебре и комбинаторике. Они находят широкое применение в теории кодирования (коды, исправляющие ошибки), теории планирования многофакторных экспериментов (блок-схемы) и других областях математики.<ref name="rt">http://cyberleninka.ru/article/n/matritsy-adamara-nechetnogo-poryadka</ref> Сравнительно недавно (в 1960 г.) было замечено, что эти матрицы могут быть использованы для построения кодов с большим кодовым расстоянием.

'''''Матрицей Адамара порядка n''''' называется <math>n*n</math> матрица <math>H</math>, элементами которой являются +1 и −1 такая, что <math>H H^T = n E_n</math>,
где <math>E_n</math> - единичная матрица размера n.

Матрица Адамара обладает следующими ''свойствами'':
* Различные строки матрицы ортогональны
* Скалярное произведение любой строки саму на себя равно n
* Умножение любой строки или столбца на -1 переводит H в другую матрицу Адамара
* Если все элементы первой строки и первого столбца равны +1, то матрица Адамара называется нормализованной

Ниже показаны примеры нормализованных матриц Адамара порядка 1,2 и 4, причем нормализованность матриц сохраняется при перестановке любых строк и столбцов, кроме первых:

<math>H_1 = (1)</math>
<math>,
H_2 =
\begin{pmatrix}
1 & 1\\
1 & -1\end{pmatrix}
</math>,
<math>,
H_4 =
\begin{pmatrix}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1\end{pmatrix}
</math>

Предполагается, что существуют матрицы Адамара порядка 1, 2 и всех порядков n, кратных 4, хотя это до сих пор еще не было доказано. Нет универсального алгоритма построения матрицы Адамара произвольного размера, но известно большое число методов для различных частных случаев, и наименьший порядок, для которого матрица Адамара еще не построена, равен 268 (на 1977 г.). <ref name="rt2">Мак-Вильямс Ф. Дж., Слоэн Н. Дж. А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — c. 52-57</ref> Мы приведем метод построения Пейли, который важен для теории кодирования.

====Метод Пейли====
Это построение дает матрицы Адамара любого порядка <math>n=p+1</math>, кратного 4, где p-простое число.

'''Определение.''' Пусть p-простое число. Ненулевые квадраты чисел, приведенные по модулю p, называются квадратичными вычетами по модулю p или просто вычетами по модулю p.

Функция <math>X(i)</math>, называемая символом Лежандра, определяется на целых числах следующим образом:
* <math>X(i)=0</math>, если i кратно p;
* <math>X(i)=1</math>, если остаток от деления i на p является квадратным вычетом по модулю p;
* <math>X(i)=-1</math>, если остаток от деления i на p является невычетом.

Теперь мы построим матрицу Джекобстола <math>Q=(q_{ij})</math>. Она представляет собой <math>(p*p)</math>-матрицу, строки и столбцы которой пронумерованы числами 0,1,..., p-1, а элементы <math>q_{ij}=X(j-i)</math>.

Пусть теперь <math>
H =
\begin{pmatrix}
1 & 1\\
1^T & Q-I\end{pmatrix}
</math>.

Доказано, что такая матрица <math>H</math> представляет собой нормализованную матрицу Адамара порядка p+1, которую называют матрицей типа Пейли.<ref name="rt3">http://tc.nsu.ru/uploads/codingtheory.pdf</ref>

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

Исходные данные - это порядок генерируемой матрицы Адамара <math>n</math>, удовлетворяющее следующим свойствам:

* <math>n>0</math>;

* <math>n</math> делится на 4;

* <math>n-1</math> - простое число.

Вспомогательные данные:

* Число <math>p=n-1</math>;
* Вектор квадратичных вычетов (по модулю <math>p</math>) <math>R</math> (элементы <math>r_i</math>) размера <math>2p</math>. В этом векторе индексация идёт с нуля.

Вычисляемые данные:

* Матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>) размера <math>n \times n</math>. Индексация строчек и столбцов идёт с нуля.

Алгоритм:
:1. Строится вектор квадратичных вычетов <math>R</math>.
:: Первые <math>p</math> элементов вектора <math>R</math> (<math>i=0,1,...,p-1</math>) определяются следующим образом:
::: <math>r_i=1</math>, если <math>i \in \{1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod</math> <math> p\}</math>, <math>i=0,1,...,p-1</math>, то есть если <math>i</math> является квадратичным вычетом по модулю <math>p</math>;
::: <math>r_i=-1</math>, иначе.
::Вторые <math>p</math> элементов (<math>i=p,1,...,2p-1</math>) являются копией первых <math>p</math> элементов:
:::<math>r_i=r_{i-p}, i=p,1,...,2p-1.</math>
:2. Строится матрица Адамара <math>H</math>.
::Элементы матрицы Адамара <math>H</math> находятся следующим образом:
::: <math>h_{0j}=1, j=0,1, ... ,n-1;</math>
::: <math>h_{i0}=1, i=1,2, ... ,n-1;</math>
::: <math>h_{ij}=r_{j-i+p}, i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

Вычислительное ядро алгоритма состоит из <math>(n-1) \times (n-1)</math> операций присваивания следующего вида:

:<math>h_{ij}=r_{j-i+p},</math> <math> i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

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

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

Приведем процедуру на языке С++, реализующую описанный алгоритм. На вход процедуре подается порядок матрицы <math>n</math> и ссылка на заполняемую матрицу <math>result</math>. Считаем, что <math>n</math> положительно, делится на <math>4</math>, <math>n-1</math> - простое число, а размер матрицы <math>result</math> равен <math>n \times n</math>.

<source lang="C">
void buildHadamardMatrix(int n, vector<vector<int>> & result)
{
// 1) Считаем вычеты по модулю p=n-1 и создаем вспомогательный массив вычетов residues
// Достаточно посчитать значения (1^2 mod p), (2^2 mod p), ... , (((p-1)/2)^2 mod p) - эти значениями и будут являться вычетами.
// Строим массив residues размера 2*p, в котором первые p элементов заполняются по следующей схеме: 1, если индекс элемента - вычет, -1 - иначе.
// Вторая половина массива получается дублированием первой половины
int p=n-1;
vector<int> residues;
residues.resize(2*p);
// Заполняем массив
for (int i=0; i<p; i++) {
residue[i] = -1;
}
for (int i=1; i<= (p-1)/2; i++) {
residue[i^2 % p] = 1;
}
for (int i=p; i<2*p; i++) {
residue[i] = residue[i-p];
}

// 2) Построение матрицы Адамара
// Заполнение первой строки 1-цами
for (int j=0; j<n; j++) {
result[0][j] = 1;
}
// Заполнение первого столбца 1-цами
for (int i=1; i<n; i++) {
result[i][0] = 1;
}
// Заполнение оставшейся части матрицы с использованием вспомогательного массива вычетов residues
for (int i=1; i<n; i++) {
for (int j=1; j<n; j++) {
result[i][j] = residues[j-i+p];
}
}
}
</source>

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

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

Основными операциями алгоритма являются:

* <math>\frac{n}{2}-2</math> операций умножения;
* <math>\frac{n}{2}-2</math> операций взятия остатка;
* <math>n^2+\frac{5}{2}n-3</math> операций присваивания.

Из чего следует, что алгоритм имеет квадратичную последовательную сложность.

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

Информационный граф алгоритма можно представить в виде четырёх последовательных блоков. Первый блок содержит <math>n-1</math> параллельных ветвей, второй блок - <math>\frac{n}{2}-1</math> параллельных ветвей, третий - <math>n-1</math> и четвёртый - <math>n^2</math>.

[[Файл:i_graph2.png]]

Каждая вершина из <math>A_1-A_{n-1}</math>, <math>C_1-C_{n-1}</math>, <math>D_1-D_{n^2}</math> соответствует операции присваивания. А каждая вершина из <math>B_1-B_{\frac{n}{2}-1}</math> соответствует трём последовательным операциям: умножения, взятия остатка по модулю и присваивания.

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

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

* <math>n-1</math> операций присваивания;
* <math>\frac{n}{2}-1</math> участков, состоящих из трёх операций: умножения, взятия остатка и присваивания;
* <math>n-1</math> операций присваивания;
* <math>n^2</math> операций присваивания.

Из этого можно сделать вывод, что высота ярусно-параллельной формы информационного графа равняется 6 (присваивание, умножение, взятие остатка, присваивание, присваивание, присваивание). Ширина ярусно-параллельной формы равняется <math>n^2</math>, что означает, что при использовании <math>n^2</math> процессоров матрица Адамара будет строиться за 6 операций.

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

'''Входные данные:''' порядок матрицы Адамара <math>n</math>. Дополнительные ограничения на <math>n</math>:
* <math>n>0</math>
* <math>n</math> делится на 4
* <math>n-1</math> - простое число
'''Объем входных данных:''' 1 (число <math>n</math>)

'''Выходные данные:''' матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>)

'''Объем выходных данных:''' <math>n^2</math> (количество элементов матрицы Адамара порядка <math>n</math>)

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

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

Вычислительная мощность алгоритма является постоянной (<math>O(1)</math>).

Алгоритм является полностью детерминированным.

Для вершин <math>A_1-A_{n-1}</math>, <math>B_1-B_{\frac{n}{2}-1}</math>, <math>C_1-C_{n-1}</math> информационного графа степени исхода являются линейными, что означает, что при возможности на этапе реализации необходимо позаботиться об эффективном доступе к элементам массива "<math>residues</math>".

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

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

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

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

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

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

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

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

Алгоритм построения матрицы Адамара реализован в различных математических пакетах и библиотеках:
* [https://www.mathworks.com/help/matlab/ref/hadamard.html?requestedDomain=www.mathworks.com MATLAB] (вносятся дополнительные ограничения, когда n, или n/12, или n/20 являются степенями по основанию 2)
* [http://r-survey.r-forge.r-project.org/survey/html/hadamard.html R]
* [https://reference.wolframcloud.com/cloudplatform/ref/HadamardMatrix.html Wolfram Mathematica]
* [http://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.linalg.hadamard.html SciPy для Python]

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

Участник:Nikita/Построение матрицы Адамара

2016-10-30T11:45:04Z

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

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O(n^2)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>1</math>
| output_data = <math>n^2</math>
}}

Авторы статьи: [[Участник:Nikita|Иванов Н.В.]] (1.1,1.7,1.9,1.10,2.7), [[Участник:Tsyganov Nikita|Цыганов Н.И.]] (1.2,1.3,1.4,1.5,1.6,1.7,1.8).

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

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

Матрицы Адамара были введены в математический обиход в конце прошлого века и играют важную роль в алгебре и комбинаторике. Они находят широкое применение в теории кодирования (коды, исправляющие ошибки), теории планирования многофакторных экспериментов (блок-схемы) и других областях математики.<ref name="rt">http://cyberleninka.ru/article/n/matritsy-adamara-nechetnogo-poryadka</ref> Сравнительно недавно (в 1960 г.) было замечено, что эти матрицы могут быть использованы для построения кодов с большим кодовым расстоянием.

'''''Матрицей Адамара порядка n''''' называется <math>n*n</math> матрица <math>H</math>, элементами которой являются +1 и −1 такая, что <math>H H^T = n E_n</math>,
где <math>E_n</math> - единичная матрица размера n.

Матрица Адамара обладает следующими ''свойствами'':
* Различные строки матрицы ортогональны
* Скалярное произведение любой строки саму на себя равно n
* Умножение любой строки или столбца на -1 переводит H в другую матрицу Адамара
* Если все элементы первой строки и первого столбца равны +1, то матрица Адамара называется нормализованной

Ниже показаны примеры нормализованных матриц Адамара порядка 1,2 и 4, причем нормализованность матриц сохраняется при перестановке любых строк и столбцов, кроме первых:

<math>H_1 = (1)</math>
<math>,
H_2 =
\begin{pmatrix}
1 & 1\\
1 & -1\end{pmatrix}
</math>,
<math>,
H_4 =
\begin{pmatrix}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1\end{pmatrix}
</math>

Предполагается, что существуют матрицы Адамара порядка 1, 2 и всех порядков n, кратных 4, хотя это до сих пор еще не было доказано. Нет универсального алгоритма построения матрицы Адамара произвольного размера, но известно большое число методов для различных частных случаев, и наименьший порядок, для которого матрица Адамара еще не построена, равен 268 (на 1977 г.). <ref name="rt2">Мак-Вильямс Ф. Дж., Слоэн Н. Дж. А. Теория кодов, исправляющих ошибки: Пер. с англ. — М: Связь, 1979. — c. 52-57</ref> Мы приведем метод построения Пейли, который важен для теории кодирования.

====Метод Пейли====
Это построение дает матрицы Адамара любого порядка <math>n=p+1</math>, кратного 4, где p-простое число.

'''Определение.''' Пусть p-простое число. Ненулевые квадраты чисел, приведенные по модулю p, называются квадратичными вычетами по модулю p или просто вычетами по модулю p.

Функция <math>X(i)</math>, называемая символом Лежандра, определяется на целых числах следующим образом:
* <math>X(i)=0</math>, если i кратно p;
* <math>X(i)=1</math>, если остаток от деления i на p является квадратным вычетом по модулю p;
* <math>X(i)=-1</math>, если остаток от деления i на p является невычетом.

Теперь мы построим матрицу Джекобстола <math>Q=(q_{ij})</math>. Она представляет собой <math>(p*p)</math>-матрицу, строки и столбцы которой пронумерованы числами 0,1,..., p-1, а элементы <math>q_{ij}=X(j-i)</math>.

Пусть теперь <math>
H =
\begin{pmatrix}
1 & 1\\
1^T & Q-I\end{pmatrix}
</math>.

Доказано, что такая матрица <math>H</math> представляет собой нормализованную матрицу Адамара порядка p+1, которую называют матрицей типа Пейли.<ref name="rt3">http://tc.nsu.ru/uploads/codingtheory.pdf</ref>

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

Исходные данные - это порядок генерируемой матрицы Адамара <math>n</math>, удовлетворяющее следующим свойствам:

* <math>n>0</math>;

* <math>n</math> делится на 4;

* <math>n-1</math> - простое число.

Вспомогательные данные:

* Число <math>p=n-1</math>;
* Вектор квадратичных вычетов (по модулю <math>p</math>) <math>R</math> (элементы <math>r_i</math>) размера <math>2p</math>. В этом векторе индексация идёт с нуля.

Вычисляемые данные:

* Матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>) размера <math>n \times n</math>. Индексация строчек и столбцов идёт с нуля.

Алгоритм:
:1. Строится вектор квадратичных вычетов <math>R</math>.
:: Первые <math>p</math> элементов вектора <math>R</math> (<math>i=0,1,...,p-1</math>) определяются следующим образом:
::: <math>r_i=1</math>, если <math>i \in \{1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod</math> <math> p\}</math>, <math>i=0,1,...,p-1</math>, то есть если <math>i</math> является квадратичным вычетом по модулю <math>p</math>;
::: <math>r_i=-1</math>, иначе.
::Вторые <math>p</math> элементов (<math>i=p,1,...,2p-1</math>) являются копией первых <math>p</math> элементов:
:::<math>r_i=r_{i-p}, i=p,1,...,2p-1.</math>
:2. Строится матрица Адамара <math>H</math>.
::Элементы матрицы Адамара <math>H</math> находятся следующим образом:
::: <math>h_{0j}=1, j=0,1, ... ,n-1;</math>
::: <math>h_{i0}=1, i=1,2, ... ,n-1;</math>
::: <math>h_{ij}=r_{j-i+p}, i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

Вычислительное ядро алгоритма состоит из <math>(n-1) \times (n-1)</math> операций присваивания следующего вида:

:<math>h_{ij}=r_{j-i+p},</math> <math> i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

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

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

Приведем процедуру на языке С++, реализующую описанный алгоритм. На вход процедуре подается порядок матрицы <math>n</math> и ссылка на заполняемую матрицу <math>result</math>. Считаем, что <math>n</math> положительно, делится на <math>4</math>, <math>n-1</math> - простое число, а размер матрицы <math>result</math> равен <math>n \times n</math>.

<source lang="C">
void buildHadamardMatrix(int n, vector<vector<int>> & result)
{
// 1) Считаем вычеты по модулю p=n-1 и создаем вспомогательный массив вычетов residues
// Достаточно посчитать значения (1^2 mod p), (2^2 mod p), ... , (((p-1)/2)^2 mod p) - эти значениями и будут являться вычетами.
// Строим массив residues размера 2*p, в котором первые p элементов заполняются по следующей схеме: 1, если индекс элемента - вычет, -1 - иначе.
// Вторая половина массива получается дублированием первой половины
int p=n-1;
vector<int> residues;
residues.resize(2*p);
// Заполняем массив
for (int i=0; i<p; i++) {
residue[i] = -1;
}
for (int i=1; i<= (p-1)/2; i++) {
residue[i^2 % p] = 1;
}
for (int i=p; i<2*p; i++) {
residue[i] = residue[i-p];
}

// 2) Построение матрицы Адамара
// Заполнение первой строки 1-цами
for (int j=0; j<n; j++) {
result[0][j] = 1;
}
// Заполнение первого столбца 1-цами
for (int i=1; i<n; i++) {
result[i][0] = 1;
}
// Заполнение оставшейся части матрицы с использованием вспомогательного массива вычетов residues
for (int i=1; i<n; i++) {
for (int j=1; j<n; j++) {
result[i][j] = residues[j-i+p];
}
}
}
</source>

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

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

Основными операциями алгоритма являются:

* <math>\frac{n}{2}-2</math> операций умножения;
* <math>\frac{n}{2}-2</math> операций взятия остатка;
* <math>n^2+\frac{5}{2}n-3</math> операций присваивания.

Из чего следует, что алгоритм имеет квадратичную последовательную сложность.

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

Информационный граф алгоритма можно представить в виде четырёх последовательных блоков. Первый блок содержит <math>n-1</math> параллельных ветвей, второй блок - <math>\frac{n}{2}-1</math> параллельных ветвей, третий - <math>n-1</math> и четвёртый - <math>n^2</math>.

[[Файл:i_graph2.png]]

Каждая вершина из <math>A_1-A_{n-1}</math>, <math>C_1-C_{n-1}</math>, <math>D_1-D_{n^2}</math> соответствует операции присваивания. А каждая вершина из <math>B_1-B_{\frac{n}{2}-1}</math> соответствует трём последовательным операциям: умножения, взятия остатка по модулю и присваивания.

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

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

* <math>n-1</math> операций присваивания;
* <math>\frac{n}{2}-1</math> участков, состоящих из трёх операций: умножения, взятия остатка и присваивания;
* <math>n-1</math> операций присваивания;
* <math>n^2</math> операций присваивания.

Из этого можно сделать вывод, что высота ярусно-параллельной формы информационного графа равняется 6 (присваивание, умножение, взятие остатка, присваивание, присваивание, присваивание). Ширина ярусно-параллельной формы равняется <math>n^2</math>, что означает, что при использовании <math>n^2</math> процессоров матрица Адамара будет строиться за 6 операций.

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

'''Входные данные:''' порядок матрицы Адамара <math>n</math>. Дополнительные ограничения на <math>n</math>:
* <math>n>0</math>
* <math>n</math> делится на 4
* <math>n-1</math> - простое число
'''Объем входных данных:''' 1 (число <math>n</math>)

'''Выходные данные:''' матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>)

'''Объем выходных данных:''' <math>n^2</math> (количество элементов матрицы Адамара порядка <math>n</math>)

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

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

Вычислительная мощность алгоритма является постоянной (<math>O(1)</math>).

Алгоритм является полностью детерминированным.

Для вершин <math>A_1-A_{n-1}</math>, <math>B_1-B_{\frac{n}{2}-1}</math>, <math>C_1-C_{n-1}</math> информационного графа степени исхода являются линейными, что означает, что при возможности на этапе реализации необходимо позаботиться об эффективном доступе к элементам массива "<math>residues</math>".

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

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

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

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

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

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

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

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

Алгоритм построения матрицы Адамара реализован в различных математических пакетах и библиотеках:
* [https://www.mathworks.com/help/matlab/ref/hadamard.html?requestedDomain=www.mathworks.com MATLAB] (вносятся дополнительные ограничения, когда n, или n/12, или n/20 являются степенями по основанию 2)
* [http://r-survey.r-forge.r-project.org/survey/html/hadamard.html R]
* [https://reference.wolframcloud.com/cloudplatform/ref/HadamardMatrix.html Wolfram Mathematica]
* [http://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.linalg.hadamard.html SciPy для Python]

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

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

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

Участник:Nikita/Построение матрицы Адамара

2016-10-15T20:27:48Z

Nikita:

{{Assignment}}

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O(n^2)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>1</math>
| output_data = <math>n^2</math>
}}

Авторы статьи: [[Участник:Nikita|Иванов Н.В.]] (1.1,1.7,1.9,1.10,2.7), [[Участник:Tsyganov Nikita|Цыганов Н.И.]] (1.2,1.3,1.4,1.5,1.6,1.7,1.8).

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

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

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

'''''Матрицей Адамара порядка n''''' называется <math>n*n</math> матрица <math>H</math>, элементами которой являются +1 и −1 такая, что <math>H H^T = n E_n</math>,
где <math>E_n</math> - единичная матрица размера n.

Матрица Адамара обладает следующими ''свойствами'':
* Различные строки матрицы ортогональны
* Скалярное произведение любой строки саму на себя равно n
* Умножение любой строки или столбца на -1 переводит H в другую матрицу Адамара
* Если все элементы первой строки и первого столбца равны +1, то матрица Адамара называется нормализованной

Ниже показаны примеры нормализованных матриц Адамара порядка 1,2 и 4, причем нормализованность матриц сохраняется при перестановке любых строк и столбцов, кроме первых:

<math>H_1 = (1)</math>
<math>,
H_2 =
\begin{pmatrix}
1 & 1\\
1 & -1\end{pmatrix}
</math>,
<math>,
H_4 =
\begin{pmatrix}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1\end{pmatrix}
</math>

Предполагается, что существуют матрицы Адамара порядка 1, 2 и всех порядков n, кратных 4, хотя это до сих пор еще не было доказано. Нет универсального алгоритма построения матрицы Адамара произвольного размера, но известно большое число методов для различных частных случаев, и наименьший порядок, для которого матрица Адамара еще не построена, равен 268 (на 1977 г.). Мы приведем метод построения Пейли, который важен для теории кодирования.

====Метод Пейли====
Это построение дает матрицы Адамара любого порядка <math>n=p+1</math>, кратного 4, где p-простое число.

'''Определение.''' Пусть p-простое число. Ненулевые квадраты чисел, приведенные по модулю p, называются квадратичными вычетами по модулю p или просто вычетами по модулю p.

Функция <math>X(i)</math>, называемая символом Лежандра, определяется на целых числах следующим образом:
* <math>X(i)=0</math>, если i кратно p;
* <math>X(i)=1</math>, если остаток от деления i на p является квадратным вычетом по модулю p;
* <math>X(i)=-1</math>, если остаток от деления i на p является невычетом.

Теперь мы построим матрицу Джекобстола <math>Q=(q_{ij})</math>. Она представляет собой <math>(p*p)</math>-матрицу, строки и столбцы которой пронумерованы числами 0,1,..., p-1, а элементы <math>q_{ij}=X(j-i)</math>.

Пусть теперь <math>
H =
\begin{pmatrix}
1 & 1\\
1^T & Q-I\end{pmatrix}
</math>.

Доказано, что такая матрица <math>H</math> представляет собой нормализованную матрицу Адамара порядка p+1, которую называют матрицей типа Пейли.

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

Исходные данные - это порядок генерируемой матрицы Адамара <math>n</math>, удовлетворяющее следующим свойствам:

* <math>n>0</math>;

* <math>n</math> делится на 4;

* <math>n-1</math> - простое число.

Вспомогательные данные:

* Число <math>p=n-1</math>;
* Вектор квадратичных вычетов (по модулю <math>p</math>) <math>R</math> (элементы <math>r_i</math>) размера <math>2p</math>. В этом векторе индексация идёт с нуля.

Вычисляемые данные:

* Матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>) размера <math>n \times n</math>. Индексация строчек и столбцов идёт с нуля.

Алгоритм:
:1. Строится вектор квадратичных вычетов <math>R</math>.
:: Первые <math>p</math> элементов вектора <math>R</math> (<math>i=0,1,...,p-1</math>) определяются следующим образом:
::: <math>r_i=1</math>, если <math>i \in \{1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod</math> <math> p\}</math>, <math>i=0,1,...,p-1</math>, то есть если <math>i</math> является квадратичным вычетом по модулю <math>p</math>;
::: <math>r_i=-1</math>, иначе.
::Вторые <math>p</math> элементов (<math>i=p,1,...,2p-1</math>) являются копией первых <math>p</math> элементов:
:::<math>r_i=r_{i-p}, i=p,1,...,2p-1.</math>
:2. Строится матрица Адамара <math>H</math>.
::Элементы матрицы Адамара <math>H</math> находятся следующим образом:
::: <math>h_{0j}=1, j=0,1, ... ,n-1;</math>
::: <math>h_{i0}=1, i=1,2, ... ,n-1;</math>
::: <math>h_{ij}=r_{j-i+p}, i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

Вычислительное ядро алгоритма состоит из <math>(n-1) \times (n-1)</math> операций присваивания следующего вида:

:<math>h_{ij}=r_{j-i+p},</math> <math> i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

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

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

Приведем процедуру на языке С++, реализующую описанный алгоритм. На вход процедуре подается порядок матрицы <math>n</math> и ссылка на заполняемую матрицу <math>result</math>. Считаем, что <math>n</math> положительно, делится на <math>4</math>, <math>n-1</math> - простое число, а размер матрицы <math>result</math> равен <math>n \times n</math>.

<source lang="C">
void buildHadamardMatrix(int n, vector<vector<int>> & result)
{
// 1) Считаем вычеты по модулю p=n-1 и создаем вспомогательный массив вычетов residues
// Достаточно посчитать значения (1^2 mod p), (2^2 mod p), ... , (((p-1)/2)^2 mod p) - эти значениями и будут являться вычетами.
// Строим массив residues размера 2*p, в котором первые p элементов заполняются по следующей схеме: 1, если индекс элемента - вычет, -1 - иначе.
// Вторая половина массива получается дублированием первой половины
int p=n-1;
vector<int> residues;
residues.resize(2*p);
// Заполняем массив
for (int i=0; i<p; i++) {
residue[i] = -1;
}
for (int i=1; i<= (p-1)/2; i++) {
residue[i^2 % p] = 1;
}
for (int i=p; i<2*p; i++) {
residue[i] = residue[i-p];
}

// 2) Построение матрицы Адамара
// Заполнение первой строки 1-цами
for (int j=0; j<n; j++) {
result[0][j] = 1;
}
// Заполнение первого столбца 1-цами
for (int i=1; i<n; i++) {
result[i][0] = 1;
}
// Заполнение оставшейся части матрицы с использованием вспомогательного массива вычетов residues
for (int i=1; i<n; i++) {
for (int j=1; j<n; j++) {
result[i][j] = residues[j-i+p];
}
}
}
</source>

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

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

Основными операциями алгоритма являются:

* <math>\frac{n}{2}-2</math> операций умножения;
* <math>\frac{n}{2}-2</math> операций взятия остатка;
* <math>n^2+\frac{5}{2}n-3</math> операций присваивания.

Из чего следует, что алгоритм имеет квадратичную последовательную сложность.

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

Информационный граф алгоритма можно представить в виде четырёх последовательных блоков. Первый блок содержит <math>n-1</math> параллельных ветвей, второй блок - <math>\frac{n}{2}-1</math> параллельных ветвей, третий - <math>n-1</math> и четвёртый - <math>n^2</math>.

[[Файл:i_graph2.png]]

Каждая вершина из <math>A_1-A_{n-1}</math>, <math>C_1-C_{n-1}</math>, <math>D_1-D_{n^2}</math> соответствует операции присваивания. А каждая вершина из <math>B_1-B_{\frac{n}{2}-1}</math> соответствует трём последовательным операциям: умножения, взятия остатка по модулю и присваивания.

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

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

* <math>n-1</math> операций присваивания;
* <math>\frac{n}{2}-1</math> участков, состоящих из трёх операций: умножения, взятия остатка и присваивания;
* <math>n-1</math> операций присваивания;
* <math>n^2</math> операций присваивания.

Из этого можно сделать вывод, что высота ярусно-параллельной формы информационного графа равняется 6 (присваивание, умножение, взятие остатка, присваивание, присваивание, присваивание). Ширина ярусно-параллельной формы равняется <math>n^2</math>, что означает, что при использовании <math>n^2</math> процессоров матрица Адамара будет строиться за 6 операций.

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

'''Входные данные:''' порядок матрицы Адамара <math>n</math>. Дополнительные ограничения на <math>n</math>:
* <math>n>0</math>
* <math>n</math> делится на 4
* <math>n-1</math> - простое число
'''Объем входных данных:''' 1 (число <math>n</math>)

'''Выходные данные:''' матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>)

'''Объем выходных данных:''' <math>n^2</math> (количество элементов матрицы Адамара порядка <math>n</math>)

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

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

Вычислительная мощность алгоритма является постоянной (<math>O(1)</math>).

Алгоритм является полностью детерминированным.

Для вершин <math>A_1-A_{n-1}</math>, <math>B_1-B_{\frac{n}{2}-1}</math>, <math>C_1-C_{n-1}</math> информационного графа степени исхода являются линейными, что означает, что при возможности на этапе реализации необходимо позаботиться об эффективном доступе к элементам массива "<math>residues</math>".

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

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

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

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

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

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

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

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

Алгоритм построения матрицы Адамара реализован в различных математических пакетах и библиотеках:
* [https://www.mathworks.com/help/matlab/ref/hadamard.html?requestedDomain=www.mathworks.com MATLAB] (вносятся дополнительные ограничения, когда n, или n/12, или n/20 являются степенями по основанию 2)
* [http://r-survey.r-forge.r-project.org/survey/html/hadamard.html R]
* [https://reference.wolframcloud.com/cloudplatform/ref/HadamardMatrix.html Wolfram Mathematica]
* [http://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.linalg.hadamard.html SciPy для Python]

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

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

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

Участник:Nikita/Построение матрицы Адамара

2016-10-15T20:24:16Z

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

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O(n^2)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>1</math>
| output_data = <math>n^2</math>
}}

Авторы статьи: [[Участник:Nikita|Иванов Н.В.]] (1.1,1.7,1.9,1.10,2.7), [[Участник:Tsyganov Nikita|Цыганов Н.И.]] (1.2,1.3,1.4,1.5,1.6,1.7,1.8).

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

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

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

'''''Матрицей Адамара порядка n''''' называется <math>n*n</math> матрица <math>H</math>, элементами которой являются +1 и −1 такая, что <math>H H^T = n E_n</math>,
где <math>E_n</math> - единичная матрица размера n.

Матрица Адамара обладает следующими ''свойствами'':
* Различные строки матрицы ортогональны
* Скалярное произведение любой строки саму на себя равно n
* Умножение любой строки или столбца на -1 переводит H в другую матрицу Адамара
* Если все элементы первой строки и первого столбца равны +1, то матрица Адамара называется нормализованной

Ниже показаны примеры нормализованных матриц Адамара порядка 1,2 и 4, причем нормализованность матриц сохраняется при перестановке любых строк и столбцов, кроме первых:

<math>H_1 = (1)</math>
<math>,
H_2 =
\begin{pmatrix}
1 & 1\\
1 & -1\end{pmatrix}
</math>,
<math>,
H_4 =
\begin{pmatrix}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1\end{pmatrix}
</math>

Предполагается, что существуют матрицы Адамара порядка 1, 2 и всех порядков n, кратных 4, хотя это до сих пор еще не было доказано. Нет универсального алгоритма построения матрицы Адамара произвольного размера, но известно большое число методов для различных частных случаев, и наименьший порядок, для которого матрица Адамара еще не построена, равен 268 (на 1977 г.). Мы приведем метод построения Пейли, который важен для теории кодирования.

====Метод Пейли====
Это построение дает матрицы Адамара любого порядка <math>n=p+1</math>, кратного 4, где p-простое число.

'''Определение.''' Пусть p-простое число. Ненулевые квадраты чисел, приведенные по модулю p, называются квадратичными вычетами по модулю p или просто вычетами по модулю p.

Функция <math>X(i)</math>, называемая символом Лежандра, определяется на целых числах следующим образом:
* <math>X(i)=0</math>, если i кратно p;
* <math>X(i)=1</math>, если остаток от деления i на p является квадратным вычетом по модулю p;
* <math>X(i)=-1</math>, если остаток от деления i на p является невычетом.

Теперь мы построим матрицу Джекобстола <math>Q=(q_{ij})</math>. Она представляет собой <math>(p*p)</math>-матрицу, строки и столбцы которой пронумерованы числами 0,1,..., p-1, а элементы <math>q_{ij}=X(j-i)</math>.

Пусть теперь <math>
H =
\begin{pmatrix}
1 & 1\\
1^T & Q-I\end{pmatrix}
</math>.

Доказано, что такая матрица <math>H</math> представляет собой нормализованную матрицу Адамара порядка p+1, которую называют матрицей типа Пейли.

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

Исходные данные - это порядок генерируемой матрицы Адамара <math>n</math>, удовлетворяющее следующим свойствам:

* <math>n>0</math>;

* <math>n</math> делится на 4;

* <math>n-1</math> - простое число.

Вспомогательные данные:

* Число <math>p=n-1</math>;
* Вектор квадратичных вычетов (по модулю <math>p</math>) <math>R</math> (элементы <math>r_i</math>) размера <math>2p</math>. В этом векторе индексация идёт с нуля.

Вычисляемые данные:

* Матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>) размера <math>n \times n</math>. Индексация строчек и столбцов идёт с нуля.

Алгоритм:
:1. Строится вектор квадратичных вычетов <math>R</math>.
:: Первые <math>p</math> элементов вектора <math>R</math> (<math>i=0,1,...,p-1</math>) определяются следующим образом:
::: <math>r_i=1</math>, если <math>i \in \{1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod</math> <math> p\}</math>, <math>i=0,1,...,p-1</math>, то есть если <math>i</math> является квадратичным вычетом по модулю <math>p</math>;
::: <math>r_i=-1</math>, иначе.
::Вторые <math>p</math> элементов (<math>i=p,1,...,2p-1</math>) являются копией первых <math>p</math> элементов:
:::<math>r_i=r_{i-p}, i=p,1,...,2p-1.</math>
:2. Строится матрица Адамара <math>H</math>.
::Элементы матрицы Адамара <math>H</math> находятся следующим образом:
::: <math>h_{0j}=1, j=0,1, ... ,n-1;</math>
::: <math>h_{i0}=1, i=1,2, ... ,n-1;</math>
::: <math>h_{ij}=r_{j-i+p}, i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

Вычислительное ядро алгоритма состоит из <math>(n-1) \times (n-1)</math> операций присваивания следующего вида:

:<math>h_{ij}=r_{j-i+p},</math> <math> i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

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

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

Приведем процедуру на языке С++, реализующую описанный алгоритм. На вход процедуре подается порядок матрицы <math>n</math> и ссылка на заполняемую матрицу <math>result</math>. Считаем, что <math>n</math> положительно, делится на <math>4</math>, <math>n-1</math> - простое число, а размер матрицы <math>result</math> равен <math>n \times n</math>.

<source lang="C">
void buildHadamardMatrix(int n, vector<vector<int>> & result)
{
// 1) Считаем вычеты по модулю p=n-1 и создаем вспомогательный массив вычетов residues
// Достаточно посчитать значения (1^2 mod p), (2^2 mod p), ... , (((p-1)/2)^2 mod p) - эти значениями и будут являться вычетами.
// Строим массив residues размера 2*p, в котором первые p элементов заполняются по следующей схеме: 1, если индекс элемента - вычет, -1 - иначе.
// Вторая половина массива получается дублированием первой половины
int p=n-1;
vector<int> residues;
residues.resize(2*p);
// Заполняем массив
for (int i=0; i<p; i++) {
residue[i] = -1;
}
for (int i=1; i<= (p-1)/2; i++) {
residue[i^2 % p] = 1;
}
for (int i=p; i<2*p; i++) {
residue[i] = residue[i-p];
}

// 2) Построение матрицы Адамара
// Заполнение первой строки 1-цами
for (int j=0; j<n; j++) {
result[0][j] = 1;
}
// Заполнение первого столбца 1-цами
for (int i=1; i<n; i++) {
result[i][0] = 1;
}
// Заполнение оставшейся части матрицы с использованием вспомогательного массива вычетов residues
for (int i=1; i<n; i++) {
for (int j=1; j<n; j++) {
result[i][j] = residues[j-i+p];
}
}
}
</source>

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

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

Основными операциями алгоритма являются:

* <math>\frac{n}{2}-2</math> операций умножения;
* <math>\frac{n}{2}-2</math> операций взятия остатка;
* <math>n^2+\frac{5}{2}n-3</math> операций присваивания.

Из чего следует, что алгоритм имеет квадратичную последовательную сложность.

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

Информационный граф алгоритма можно представить в виде четырёх последовательных блоков. Первый блок содержит <math>n-1</math> параллельных ветвей, второй блок - <math>\frac{n}{2}-1</math> параллельных ветвей, третий - <math>n-1</math> и четвёртый - <math>n^2</math>.

[[Файл:i_graph2.png]]

Каждая вершина из <math>A_1-A_{n-1}</math>, <math>C_1-C_{n-1}</math>, <math>D_1-D_{n^2}</math> соответствует операции присваивания. А каждая вершина из <math>B_1-B_{\frac{n}{2}-1}</math> соответствует трём последовательным операциям: умножения, взятия остатка по модулю и присваивания.

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

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

* <math>n-1</math> операций присваивания;
* <math>\frac{n}{2}-1</math> участков, состоящих из трёх операций: умножения, взятия остатка и присваивания;
* <math>n-1</math> операций присваивания;
* <math>n^2</math> операций присваивания.

Из этого можно сделать вывод, что высота ярусно-параллельной формы информационного графа равняется 6 (присваивание, умножение, взятие остатка, присваивание, присваивание, присваивание). Ширина ярусно-параллельной формы равняется <math>n^2</math>, что означает, что при использовании <math>n^2</math> процессоров матрица Адамара будет строиться за 6 операций.

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

'''Входные данные:''' порядок матрицы Адамара <math>n</math>. Дополнительные ограничения на <math>n</math>:
* <math>n>0</math>
* <math>n</math> делится на 4
* <math>n-1</math> - простое число
'''Объем входных данных:''' 1 (число <math>n</math>)

'''Выходные данные:''' матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>)

'''Объем выходных данных:''' <math>n^2</math> (количество элементов матрицы Адамара порядка <math>n</math>)

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

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

Вычислительная мощность алгоритма является постоянной (<math>O(1)</math>).

Алгоритм является полностью детерминированным.

Для вершин <math>A_1-A_{n-1}</math>, <math>B_1-B_{\frac{n}{2}-1}</math>, <math>C_1-C_{n-1}</math> информационного графа степени исхода являются линейными, что означает, что при возможности на этапе реализации необходимо позаботиться об эффективном доступе к элементам массива "<math>residues</math>".

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

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

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

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

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

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

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

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

Алгоритм построения матрицы Адамара реализован в различных математических пакетах и библиотеках:
* [https://www.mathworks.com/help/matlab/ref/hadamard.html?requestedDomain=www.mathworks.com MATLAB] (вносятся дополнительные ограничения, когда n, или n/12, или n/20 являются степенями по основанию 2)
* [http://r-survey.r-forge.r-project.org/survey/html/hadamard.html R]
* [https://reference.wolframcloud.com/cloudplatform/ref/HadamardMatrix.html Wolfram Mathematica]
* [http://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.linalg.hadamard.html SciPy для Python]

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

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

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

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

2016-10-15T20:01:31Z

Nikita: /* Перенос */

== Перенос ==
Статья: [[Кластеризация сетями Кохонена]]
Выполняют: [[Участник:Kravtsovkirill| Кравцов Кирилл]] и [[Участник:Emaksimov| Максимов Егор]]

Статья: [[Нахождение собственных чисел квадратной матрицы методом QR разложения (2)]]
Выполняют: Баев Олег и Шевелев Александр

Статья: [[Стабилизированный метод биспоряженных градиентов (BiCGSTAB)]]
Выполняют: Гаврилов Алексей и Новиков Александр

Статья: [[Участники: Бобошко А., Юмакаева А./Решение начальной задачи Коши для системы ОДУ методом Рунге-Кутта 4-го порядка]];
Выполняют: Бобошко Алексей и Юмакаева Алина

Статья: [[Алгоритм кластеризации, основанный на сетях Кохоннена]];
Выполняют: Логвиненко Александра и Адиев Тохтар

Статья: [[Ортогонализация Грама-Шмидта]];
Выполняют: [[Участник:KibAndrey| Кибанов Андрей]] и Аджиева Татьяна

Статья: [[Самоорганизующиеся карты Кохонена]];
Выполняет: [[Участник:Anton goy| Гой Антон]]

Статья:[[ЕМ-алгоритм_(Тематическое_моделирование)]];
Выполняют: Мурат Апишев и Андрей Заночкин

Статья:[[Алгоритм_Ланцоша_с_полной_переортогонализацией]];
Выполняет:[[Участник:Sfedotov| Федотов С.А.]]

Статья: [[Алгоритм_k-средних]]
Выполняют: [[Участник:Error2407|Богомазов Евгений]], [[Участник:Илья_Егоров|Егоров Илья]]

Статья: [[Алгоритм k-means]]
Выполняют: [[Участник:Бротиковская Данута|Данута Бротиковская]] и [[Участник:DennZo1993|Денис Зобнин]]

Статья: [[Partitioning Around Medoids (Алгоритм)]]
Выполняют: [[Участник:Denemmy| Галеев Данил]] и [[Участник:Ivan.Z| Запутляев Иван]]

Статья: [[Нечеткий_алгоритм_С_средних]]
Выполняют: [[Участник: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 группа)/Построение матрицы Адамара произвольной размерности]]
Выполняют:[[ Участник:Бугаков Юрий| Бугаков Юрий]], [[Участник:Кужамалиев Ернур| Кужамалиев Ернур]]

Статья: [[Участник:Nikita/Построение_матрицы_Адамара|Построение матрицы Адамара]]
Выполняют: [[Участник:Nikita|Иванов Никита]], [[Участник:Tsyganov Nikita|Цыганов Никита]]

Участник:Nikita/Построение матрицы Адамара

2016-10-15T19:53:28Z

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

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O(n^2)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>1</math>
| output_data = <math>n^2</math>
}}

Авторы статьи: [[Участник:Nikita|Иванов Н.В.]] (1.1,1.7,1.9,1.10,2.7), [[Участник:Tsyganov Nikita|Цыганов Н.И.]] (1.2,1.3,1.4,1.5,1.6,1.7,1.8).

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

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

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

'''''Матрицей Адамара порядка n''''' называется <math>n*n</math> матрица <math>H</math>, элементами которой являются +1 и −1 такая, что <math>H H^T = n E_n</math>,
где <math>E_n</math> - единичная матрица размера n.

Матрица Адамара обладает следующими ''свойствами'':
* Различные строки матрицы ортогональны
* Скалярное произведение любой строки саму на себя равно n
* Умножение любой строки или столбца на -1 переводит H в другую матрицу Адамара
* Если все элементы первой строки и первого столбца равны +1, то матрица Адамара называется нормализованной

Ниже показаны примеры нормализованных матриц Адамара порядка 1,2 и 4, причем нормализованность матриц сохраняется при перестановке любых строк и столбцов, кроме первых:

<math>H_1 = (1)</math>
<math>,
H_2 =
\begin{pmatrix}
1 & 1\\
1 & -1\end{pmatrix}
</math>,
<math>,
H_4 =
\begin{pmatrix}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1\end{pmatrix}
</math>

Предполагается, что существуют матрицы Адамара порядка 1, 2 и всех порядков n, кратных 4, хотя это до сих пор еще не было доказано. Нет универсального алгоритма построения матрицы Адамара произвольного размера, но известно большое число методов для различных частных случаев, и наименьший порядок, для которого матрица Адамара еще не построена, равен 268 (на 1977 г.). Мы приведем метод построения Пейли, который важен для теории кодирования.

====Метод Пейли====
Это построение дает матрицы Адамара любого порядка <math>n=p+1</math>, кратного 4, где p-простое число.

'''Определение.''' Пусть p-простое число. Ненулевые квадраты чисел, приведенные по модулю p, называются квадратичными вычетами по модулю p или просто вычетами по модулю p.

Функция <math>X(i)</math>, называемая символом Лежандра, определяется на целых числах следующим образом:
* <math>X(i)=0</math>, если i кратно p;
* <math>X(i)=1</math>, если остаток от деления i на p является квадратным вычетом по модулю p;
* <math>X(i)=-1</math>, если остаток от деления i на p является невычетом.

Теперь мы построим матрицу Джекобстола <math>Q=(q_{ij})</math>. Она представляет собой <math>(p*p)</math>-матрицу, строки и столбцы которой пронумерованы числами 0,1,..., p-1, а элементы <math>q_{ij}=X(j-i)</math>.

Пусть теперь <math>
H =
\begin{pmatrix}
1 & 1\\
1^T & Q-I\end{pmatrix}
</math>.

Доказано, что такая матрица <math>H</math> представляет собой нормализованную матрицу Адамара порядка p+1, которую называют матрицей типа Пейли.

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

Исходные данные - это порядок генерируемой матрицы Адамара <math>n</math>, удовлетворяющее следующим свойствам:

* <math>n>0</math>;

* <math>n</math> делится на 4;

* <math>n-1</math> - простое число.

Вспомогательные данные:

* Число <math>p=n-1</math>;
* Вектор квадратичных вычетов (по модулю <math>p</math>) <math>R</math> (элементы <math>r_i</math>) размера <math>2p</math>. В этом векторе индексация идёт с нуля.

Вычисляемые данные:

* Матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>) размера <math>n \times n</math>. Индексация строчек и столбцов идёт с нуля.

Алгоритм:
:1. Строится вектор квадратичных вычетов <math>R</math>.
:: Первые <math>p</math> элементов вектора <math>R</math> (<math>i=0,1,...,p-1</math>) определяются следующим образом:
::: <math>r_i=1</math>, если <math>i \in \{1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod</math> <math> p\}</math>, <math>i=0,1,...,p-1</math>, то есть если <math>i</math> является квадратичным вычетом по модулю <math>p</math>;
::: <math>r_i=-1</math>, иначе.
::Вторые <math>p</math> элементов (<math>i=p,1,...,2p-1</math>) являются копией первых <math>p</math> элементов:
:::<math>r_i=r_{i-p}, i=p,1,...,2p-1.</math>
:2. Строится матрица Адамара <math>H</math>.
::Элементы матрицы Адамара <math>H</math> находятся следующим образом:
::: <math>h_{0j}=1, j=0,1, ... ,n-1;</math>
::: <math>h_{i0}=1, i=1,2, ... ,n-1;</math>
::: <math>h_{ij}=r_{j-i+p}, i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

Вычислительное ядро алгоритма состоит из <math>(n-1) \times (n-1)</math> операций присваивания следующего вида:

:<math>h_{ij}=r_{j-i+p},</math> <math> i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

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

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

Приведем процедуру на языке С++, реализующую описанный алгоритм. На вход процедуре подается порядок матрицы <math>n</math> и ссылка на заполняемую матрицу <math>result</math>. Считаем, что <math>n</math> положительно, делится на <math>4</math>, <math>n-1</math> - простое число, а размер матрицы <math>result</math> равен <math>n \times n</math>.

<source lang="C">
void buildHadamardMatrix(int n, vector<vector<int>> & result)
{
// 1) Считаем вычеты по модулю p=n-1 и создаем вспомогательный массив вычетов residues
// Достаточно посчитать значения (1^2 mod p), (2^2 mod p), ... , (((p-1)/2)^2 mod p) - эти значениями и будут являться вычетами.
// Строим массив residues размера 2*p, в котором первые p элементов заполняются по следующей схеме: 1, если индекс элемента - вычет, -1 - иначе.
// Вторая половина массива получается дублированием первой половины
int p=n-1;
vector<int> residues;
residues.resize(2*p);
// Заполняем массив
for (int i=0; i<p; i++) {
residue[i] = -1;
}
for (int i=1; i<= (p-1)/2; i++) {
residue[i^2 % p] = 1;
}
for (int i=p; i<2*p; i++) {
residue[i] = residue[i-p];
}

// 2) Построение матрицы Адамара
// Заполнение первой строки 1-цами
for (int j=0; j<n; j++) {
result[0][j] = 1;
}
// Заполнение первого столбца 1-цами
for (int i=1; i<n; i++) {
result[i][0] = 1;
}
// Заполнение оставшейся части матрицы с использованием вспомогательного массива вычетов residues
for (int i=1; i<n; i++) {
for (int j=1; j<n; j++) {
result[i][j] = residues[j-i+p];
}
}
}
</source>

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

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

Основными операциями алгоритма являются:

* <math>\frac{n}{2}-2</math> операций умножения;
* <math>\frac{n}{2}-2</math> операций взятия остатка;
* <math>n^2+\frac{5}{2}n-3</math> операций присваивания.

Из чего следует, что алгоритм имеет квадратичную последовательную сложность.

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

Информационный граф алгоритма можно представить в виде четырёх последовательных блоков. Первый блок содержит <math>n-1</math> параллельных ветвей, второй блок - <math>\frac{n}{2}-1</math> параллельных ветвей, третий - <math>n-1</math> и четвёртый - <math>n^2</math>.

[[Файл:i_graph.png]]

Каждая вершина из <math>A_1-A_{n-1}</math>, <math>C_1-C_{n-1}</math>, <math>D_1-D_{n^2}</math> соответствует операции присваивания. А каждая вершина из <math>B_1-B_{\frac{n}{2}-1}</math> соответствует трём последовательным операциям: умножения, взятия остатка по модулю и присваивания.

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

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

* <math>n-1</math> операций присваивания;
* <math>\frac{n}{2}-1</math> участков, состоящих из трёх операций: умножения, взятия остатка и присваивания;
* <math>n-1</math> операций присваивания;
* <math>n^2</math> операций присваивания.

Из этого можно сделать вывод, что высота ярусно-параллельной формы информационного графа равняется 6 (присваивание, умножение, взятие остатка, присваивание, присваивание, присваивание). Ширина ярусно-параллельной формы равняется <math>n^2</math>, что означает, что при использовании <math>n^2</math> процессоров матрица Адамара будет строиться за 6 операций.

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

'''Входные данные:''' порядок матрицы Адамара <math>n</math>. Дополнительные ограничения на <math>n</math>:
* <math>n>0</math>
* <math>n</math> делится на 4
* <math>n-1</math> - простое число
'''Объем входных данных:''' 1 (число <math>n</math>)

'''Выходные данные:''' матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>)

'''Объем выходных данных:''' <math>n^2</math> (количество элементов матрицы Адамара порядка <math>n</math>)

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

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

Вычислительная мощность алгоритма является постоянной (<math>O(1)</math>).

Алгоритм является полностью детерминированным.

Для вершин <math>A_1-A_{n-1}</math>, <math>B_1-B_{\frac{n}{2}-1}</math>, <math>C_1-C_{n-1}</math> информационного графа степени исхода являются линейными, что означает, что при возможности на этапе реализации необходимо позаботиться об эффективном доступе к элементам массива "<math>residues</math>".

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

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

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

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

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

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

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

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

Алгоритм построения матрицы Адамара реализован в различных математических пакетах и библиотеках:
* [https://www.mathworks.com/help/matlab/ref/hadamard.html?requestedDomain=www.mathworks.com MATLAB] (вносятся дополнительные ограничения, когда n, или n/12, или n/20 являются степенями по основанию 2)
* [http://r-survey.r-forge.r-project.org/survey/html/hadamard.html R]
* [https://reference.wolframcloud.com/cloudplatform/ref/HadamardMatrix.html Wolfram Mathematica]
* [http://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.linalg.hadamard.html SciPy для Python]

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

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

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

Участник:Nikita

2016-10-15T19:25:58Z

Nikita:

Иванов Никита Валерьевич, группа 611

МГУ им. М.В.Ломоносова, факультет ВМК, кафедра Исследования Операций.

Участник:Nikita/Построение матрицы Адамара

2016-10-15T19:19:06Z

Nikita:

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O(n^2)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>1</math>
| output_data = <math>n^2</math>
}}

Авторы статьи: [[Участник:Nikita|Иванов Н.В.]] (1.1,1.7,1.9,1.10,2.7), [[Участник:Tsyganov Nikita|Цыганов Н.И.]] (1.2,1.3,1.4,1.5,1.6,1.7,1.8).

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

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

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

'''''Матрицей Адамара порядка n''''' называется <math>n*n</math> матрица <math>H</math>, элементами которой являются +1 и −1 такая, что <math>H H^T = n E_n</math>,
где <math>E_n</math> - единичная матрица размера n.

Матрица Адамара обладает следующими ''свойствами'':
* Различные строки матрицы ортогональны
* Скалярное произведение любой строки саму на себя равно n
* Умножение любой строки или столбца на -1 переводит H в другую матрицу Адамара
* Если все элементы первой строки и первого столбца равны +1, то матрица Адамара называется нормализованной

Ниже показаны примеры нормализованных матриц Адамара порядка 1,2 и 4, причем нормализованность матриц сохраняется при перестановке любых строк и столбцов, кроме первых:

<math>H_1 = (1)</math>
<math>,
H_2 =
\begin{pmatrix}
1 & 1\\
1 & -1\end{pmatrix}
</math>,
<math>,
H_4 =
\begin{pmatrix}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1\end{pmatrix}
</math>

Предполагается, что существуют матрицы Адамара порядка 1, 2 и всех порядков n, кратных 4, хотя это до сих пор еще не было доказано. Нет универсального алгоритма построения матрицы Адамара произвольного размера, но известно большое число методов для различных частных случаев, и наименьший порядок, для которого матрица Адамара еще не построена, равен 268 (на 1977 г.). Мы приведем метод построения Пейли, который важен для теории кодирования.

====Метод Пейли====
Это построение дает матрицы Адамара любого порядка <math>n=p+1</math>, кратного 4, где p-простое число.

'''Определение.''' Пусть p-простое число. Ненулевые квадраты чисел, приведенные по модулю p, называются квадратичными вычетами по модулю p или просто вычетами по модулю p.

Функция <math>X(i)</math>, называемая символом Лежандра, определяется на целых числах следующим образом:
* <math>X(i)=0</math>, если i кратно p;
* <math>X(i)=1</math>, если остаток от деления i на p является квадратным вычетом по модулю p;
* <math>X(i)=-1</math>, если остаток от деления i на p является невычетом.

Теперь мы построим матрицу Джекобстола <math>Q=(q_{ij})</math>. Она представляет собой <math>(p*p)</math>-матрицу, строки и столбцы которой пронумерованы числами 0,1,..., p-1, а элементы <math>q_{ij}=X(j-i)</math>.

Пусть теперь <math>
H =
\begin{pmatrix}
1 & 1\\
1^T & Q-I\end{pmatrix}
</math>.

Доказано, что такая матрица <math>H</math> представляет собой нормализованную матрицу Адамара порядка p+1, которую называют матрицей типа Пейли.

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

Исходные данные - это порядок генерируемой матрицы Адамара <math>n</math>, удовлетворяющее следующим свойствам:

* <math>n>0</math>;

* <math>n</math> делится на 4;

* <math>n-1</math> - простое число.

Вспомогательные данные:

* Число <math>p=n-1</math>;
* Вектор квадратичных вычетов (по модулю <math>p</math>) <math>R</math> (элементы <math>r_i</math>) размера <math>2p</math>. В этом векторе индексация идёт с нуля.

Вычисляемые данные:

* Матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>) размера <math>n \times n</math>. Индексация строчек и столбцов идёт с нуля.

Алгоритм:
:1. Строится вектор квадратичных вычетов <math>R</math>.
:: Первые <math>p</math> элементов вектора <math>R</math> (<math>i=0,1,...,p-1</math>) определяются следующим образом:
::: <math>r_i=1</math>, если <math>i \in \{1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod</math> <math> p\}</math>, <math>i=0,1,...,p-1</math>, то есть если <math>i</math> является квадратичным вычетом по модулю <math>p</math>;
::: <math>r_i=-1</math>, иначе.
::Вторые <math>p</math> элементов (<math>i=p,1,...,2p-1</math>) являются копией первых <math>p</math> элементов:
:::<math>r_i=r_{i-p}, i=p,1,...,2p-1.</math>
:2. Строится матрица Адамара <math>H</math>.
::Элементы матрицы Адамара <math>H</math> находятся следующим образом:
::: <math>h_{0j}=1, j=0,1, ... ,n-1;</math>
::: <math>h_{i0}=1, i=1,2, ... ,n-1;</math>
::: <math>h_{ij}=r_{j-i+p}, i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

Вычислительное ядро алгоритма состоит из <math>(n-1) \times (n-1)</math> операций присваивания следующего вида:

:<math>h_{ij}=r_{j-i+p},</math> <math> i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

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

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

Приведем процедуру на языке С++, реализующую описанный алгоритм. На вход процедуре подается порядок матрицы <math>n</math> и ссылка на заполняемую матрицу <math>result</math>. Считаем, что <math>n</math> положительно, делится на <math>4</math>, <math>n-1</math> - простое число, а размер матрицы <math>result</math> равен <math>n \times n</math>.

<source lang="C">
void buildHadamardMatrix(int n, vector<vector<int>> & result)
{
// 1) Считаем вычеты по модулю p=n-1 и создаем вспомогательный массив вычетов residues
// Достаточно посчитать значения (1^2 mod p), (2^2 mod p), ... , (((p-1)/2)^2 mod p) - эти значениями и будут являться вычетами.
// Строим массив residues размера 2*p, в котором первые p элементов заполняются по следующей схеме: 1, если индекс элемента - вычет, -1 - иначе.
// Вторая половина массива получается дублированием первой половины
int p=n-1;
vector<int> residues;
residues.resize(2*p);
// Заполняем массив
for (int i=0; i<p; i++) {
residue[i] = -1;
}
for (int i=1; i<= (p-1)/2; i++) {
residue[i^2 % p] = 1;
}
for (int i=p; i<2*p; i++) {
residue[i] = residue[i-p];
}

// 2) Построение матрицы Адамара
// Заполнение первой строки 1-цами
for (int j=0; j<n; j++) {
result[0][j] = 1;
}
// Заполнение первого столбца 1-цами
for (int i=1; i<n; i++) {
result[i][0] = 1;
}
// Заполнение оставшейся части матрицы с использованием вспомогательного массива вычетов residues
for (int i=1; i<n; i++) {
for (int j=1; j<n; j++) {
result[i][j] = residues[j-i+p];
}
}
}
</source>

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

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

Основными операциями алгоритма являются:

* <math>\frac{n}{2}-2</math> операций умножения;
* <math>\frac{n}{2}-2</math> операций взятия остатка;
* <math>n^2+\frac{5}{2}n-3</math> операций присваивания.

Из чего следует, что алгоритм имеет квадратичную последовательную сложность.

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

Информационный граф алгоритма можно представить в виде четырёх последовательных блоков. Первый блок содержит <math>n-1</math> параллельных ветвей, второй блок - <math>\frac{n}{2}-1</math> параллельных ветвей, третий - <math>n-1</math> и четвёртый - <math>n^2</math>.

[[Файл:i_graph.png]]

Каждая вершина из <math>A_1-A_{n-1}</math>, <math>C_1-C_{n-1}</math>, <math>D_1-D_{n^2}</math> соответствует операции присваивания. А каждая вершина из <math>B_1-B_{\frac{n}{2}-1}</math> соответствует трём последовательным операциям: умножения, взятия остатка по модулю и присваивания.

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

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

* <math>n-1</math> операций присваивания;
* <math>\frac{n}{2}-1</math> участков, состоящих из трёх операций: умножения, взятия остатка и присваивания;
* <math>n-1</math> операций присваивания;
* <math>n^2</math> операций присваивания.

Из этого можно сделать вывод, что высота ярусно-параллельной формы информационного графа равняется 6 (присваивание, умножение, взятие остатка, присваивание, присваивание, присваивание). Ширина ярусно-параллельной формы равняется <math>n^2</math>, что означает, что при использовании <math>n^2</math> процессоров матрица Адамара будет строиться за 6 операций.

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

'''Входные данные:''' порядок матрицы Адамара <math>n</math>. Дополнительные ограничения на <math>n</math>:
* <math>n>0</math>
* <math>n</math> делится на 4
* <math>n-1</math> - простое число
'''Объем входных данных:''' 1 (число <math>n</math>)

'''Выходные данные:''' матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>)

'''Объем выходных данных:''' <math>n^2</math> (количество элементов матрицы Адамара порядка <math>n</math>)

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

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

Вычислительная мощность алгоритма является постоянной (<math>O(1)</math>).

Алгоритм является полностью детерминированным.

Для вершин <math>A_1-A_{n-1}</math>, <math>B_1-B_{\frac{n}{2}-1}</math>, <math>C_1-C_{n-1}</math> информационного графа степени исхода являются линейными, что означает, что при возможности на этапе реализации необходимо позаботиться об эффективном доступе к элементам массива "<math>residues</math>".

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

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

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

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

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

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

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

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

Алгоритм построения матрицы Адамара реализован в различных математических пакетах и библиотеках:
* [https://www.mathworks.com/help/matlab/ref/hadamard.html?requestedDomain=www.mathworks.com MATLAB] (вносятся дополнительные ограничения, когда n, или n/12, или n/20 являются степенями по основанию 2)
* [http://r-survey.r-forge.r-project.org/survey/html/hadamard.html R]
* [https://reference.wolframcloud.com/cloudplatform/ref/HadamardMatrix.html Wolfram Mathematica]
* [http://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.linalg.hadamard.html SciPy для Python]

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

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

Участник:Nikita/Построение матрицы Адамара

2016-10-15T19:12:53Z

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

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O(n^2)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>1</math>
| output_data = <math>n^2</math>
}}

Авторы статьи: [[Участник:Nikita|Иванов Н.В.]] (1.1,1.7,1.9,2.7), [[Участник:Tsyganov Nikita|Цыганов Н.И.]] (1.2,1.3,1.4,1.5,1.6,1.7).

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

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

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

'''''Матрицей Адамара порядка n''''' называется <math>n*n</math> матрица <math>H</math>, элементами которой являются +1 и −1 такая, что <math>H H^T = n E_n</math>,
где <math>E_n</math> - единичная матрица размера n.

Матрица Адамара обладает следующими ''свойствами'':
* Различные строки матрицы ортогональны
* Скалярное произведение любой строки саму на себя равно n
* Умножение любой строки или столбца на -1 переводит H в другую матрицу Адамара
* Если все элементы первой строки и первого столбца равны +1, то матрица Адамара называется нормализованной

Ниже показаны примеры нормализованных матриц Адамара порядка 1,2 и 4, причем нормализованность матриц сохраняется при перестановке любых строк и столбцов, кроме первых:

<math>H_1 = (1)</math>
<math>,
H_2 =
\begin{pmatrix}
1 & 1\\
1 & -1\end{pmatrix}
</math>,
<math>,
H_4 =
\begin{pmatrix}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1\end{pmatrix}
</math>

Предполагается, что существуют матрицы Адамара порядка 1, 2 и всех порядков n, кратных 4, хотя это до сих пор еще не было доказано. Нет универсального алгоритма построения матрицы Адамара произвольного размера, но известно большое число методов для различных частных случаев, и наименьший порядок, для которого матрица Адамара еще не построена, равен 268 (на 1977 г.). Мы приведем метод построения Пейли, который важен для теории кодирования.

====Метод Пейли====
Это построение дает матрицы Адамара любого порядка <math>n=p+1</math>, кратного 4, где p-простое число.

'''Определение.''' Пусть p-простое число. Ненулевые квадраты чисел, приведенные по модулю p, называются квадратичными вычетами по модулю p или просто вычетами по модулю p.

Функция <math>X(i)</math>, называемая символом Лежандра, определяется на целых числах следующим образом:
* <math>X(i)=0</math>, если i кратно p;
* <math>X(i)=1</math>, если остаток от деления i на p является квадратным вычетом по модулю p;
* <math>X(i)=-1</math>, если остаток от деления i на p является невычетом.

Теперь мы построим матрицу Джекобстола <math>Q=(q_{ij})</math>. Она представляет собой <math>(p*p)</math>-матрицу, строки и столбцы которой пронумерованы числами 0,1,..., p-1, а элементы <math>q_{ij}=X(j-i)</math>.

Пусть теперь <math>
H =
\begin{pmatrix}
1 & 1\\
1^T & Q-I\end{pmatrix}
</math>.

Доказано, что такая матрица <math>H</math> представляет собой нормализованную матрицу Адамара порядка p+1, которую называют матрицей типа Пейли.

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

Исходные данные - это порядок генерируемой матрицы Адамара <math>n</math>, удовлетворяющее следующим свойствам:

* <math>n>0</math>;

* <math>n</math> делится на 4;

* <math>n-1</math> - простое число.

Вспомогательные данные:

* Число <math>p=n-1</math>;
* Вектор квадратичных вычетов (по модулю <math>p</math>) <math>R</math> (элементы <math>r_i</math>) размера <math>2p</math>. В этом векторе индексация идёт с нуля.

Вычисляемые данные:

* Матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>) размера <math>n \times n</math>. Индексация строчек и столбцов идёт с нуля.

Алгоритм:
:1. Строится вектор квадратичных вычетов <math>R</math>.
:: Первые <math>p</math> элементов вектора <math>R</math> (<math>i=0,1,...,p-1</math>) определяются следующим образом:
::: <math>r_i=1</math>, если <math>i \in \{1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod</math> <math> p\}</math>, <math>i=0,1,...,p-1</math>, то есть если <math>i</math> является квадратичным вычетом по модулю <math>p</math>;
::: <math>r_i=-1</math>, иначе.
::Вторые <math>p</math> элементов (<math>i=p,1,...,2p-1</math>) являются копией первых <math>p</math> элементов:
:::<math>r_i=r_{i-p}, i=p,1,...,2p-1.</math>
:2. Строится матрица Адамара <math>H</math>.
::Элементы матрицы Адамара <math>H</math> находятся следующим образом:
::: <math>h_{0j}=1, j=0,1, ... ,n-1;</math>
::: <math>h_{i0}=1, i=1,2, ... ,n-1;</math>
::: <math>h_{ij}=r_{j-i+p}, i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

Вычислительное ядро алгоритма состоит из <math>(n-1) \times (n-1)</math> операций присваивания следующего вида:

:<math>h_{ij}=r_{j-i+p},</math> <math> i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

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

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

Приведем процедуру на языке С++, реализующую описанный алгоритм. На вход процедуре подается порядок матрицы <math>n</math> и ссылка на заполняемую матрицу <math>result</math>. Считаем, что <math>n</math> положительно, делится на <math>4</math>, <math>n-1</math> - простое число, а размер матрицы <math>result</math> равен <math>n \times n</math>.

<source lang="C">
void buildHadamardMatrix(int n, vector<vector<int>> & result)
{
// 1) Считаем вычеты по модулю p=n-1 и создаем вспомогательный массив вычетов residues
// Достаточно посчитать значения (1^2 mod p), (2^2 mod p), ... , (((p-1)/2)^2 mod p) - эти значениями и будут являться вычетами.
// Строим массив residues размера 2*p, в котором первые p элементов заполняются по следующей схеме: 1, если индекс элемента - вычет, -1 - иначе.
// Вторая половина массива получается дублированием первой половины
int p=n-1;
vector<int> residues;
residues.resize(2*p);
// Заполняем массив
for (int i=0; i<p; i++) {
residue[i] = -1;
}
for (int i=1; i<= (p-1)/2; i++) {
residue[i^2 % p] = 1;
}
for (int i=p; i<2*p; i++) {
residue[i] = residue[i-p];
}

// 2) Построение матрицы Адамара
// Заполнение первой строки 1-цами
for (int j=0; j<n; j++) {
result[0][j] = 1;
}
// Заполнение первого столбца 1-цами
for (int i=1; i<n; i++) {
result[i][0] = 1;
}
// Заполнение оставшейся части матрицы с использованием вспомогательного массива вычетов residues
for (int i=1; i<n; i++) {
for (int j=1; j<n; j++) {
result[i][j] = residues[j-i+p];
}
}
}
</source>

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

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

Основными операциями алгоритма являются:

* <math>\frac{n}{2}-2</math> операций умножения;
* <math>\frac{n}{2}-2</math> операций взятия остатка;
* <math>n^2+\frac{5}{2}n-3</math> операций присваивания.

Из чего следует, что алгоритм имеет квадратичную последовательную сложность.

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

Информационный граф алгоритма можно представить в виде четырёх последовательных блоков. Первый блок содержит <math>n-1</math> параллельных ветвей, второй блок - <math>\frac{n}{2}-1</math> параллельных ветвей, третий - <math>n-1</math> и четвёртый - <math>n^2</math>.

[[Файл:i_graph.png]]

Каждая вершина из <math>A_1-A_{n-1}</math>, <math>C_1-C_{n-1}</math>, <math>D_1-D_{n^2}</math> соответствует операции присваивания. А каждая вершина из <math>B_1-B_{\frac{n}{2}-1}</math> соответствует трём последовательным операциям: умножения, взятия остатка по модулю и присваивания.

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

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

* <math>n-1</math> операций присваивания;
* <math>\frac{n}{2}-1</math> участков, состоящих из трёх операций: умножения, взятия остатка и присваивания;
* <math>n-1</math> операций присваивания;
* <math>n^2</math> операций присваивания.

Из этого можно сделать вывод, что высота ярусно-параллельной формы информационного графа равняется 6 (присваивание, умножение, взятие остатка, присваивание, присваивание, присваивание). Ширина ярусно-параллельной формы равняется <math>n^2</math>, что означает, что при использовании <math>n^2</math> процессоров матрица Адамара будет строиться за 6 операций.

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

'''Входные данные:''' порядок матрицы Адамара <math>n</math>. Дополнительные ограничения на <math>n</math>:
* <math>n>0</math>
* <math>n</math> делится на 4
* <math>n-1</math> - простое число
'''Объем входных данных:''' 1 (число <math>n</math>)

'''Выходные данные:''' матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>)

'''Объем выходных данных:''' <math>n^2</math> (количество элементов матрицы Адамара порядка <math>n</math>)

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

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

Вычислительная мощность алгоритма является постоянной (<math>O(1)</math>).

Алгоритм является полностью детерминированным.

Для вершин <math>A_1-A_{n-1}</math>, <math>B_1-B_{\frac{n}{2}-1}</math>, <math>C_1-C_{n-1}</math> информационного графа степени исхода являются линейными, что означает, что при возможности на этапе реализации необходимо позаботиться об эффективном доступе к элементам массива "<math>residues</math>".

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

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

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

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

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

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

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

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

Алгоритм построения матрицы Адамара реализован в различных математических пакетах и библиотеках:
* [https://www.mathworks.com/help/matlab/ref/hadamard.html?requestedDomain=www.mathworks.com MATLAB] (вносятся дополнительные ограничения, когда n, или n/12, или n/20 являются степенями по основанию 2)
* [http://r-survey.r-forge.r-project.org/survey/html/hadamard.html R]
* [https://reference.wolframcloud.com/cloudplatform/ref/HadamardMatrix.html Wolfram Mathematica]
* [http://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.linalg.hadamard.html SciPy для Python]

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

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

Участник:Nikita/Построение матрицы Адамара

2016-10-15T19:07:13Z

Nikita:

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O(n^2)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>1</math>
| output_data = <math>n^2</math>
}}

Авторы статьи: [[Участник:Nikita|Иванов Н.В.]] (1.1,1.7,1.9,2.7), [[Участник:Tsyganov Nikita|Цыганов Н.И.]] (1.2,1.3,1.4,1.5,1.6,1.7).

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

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

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

'''''Матрицей Адамара порядка n''''' называется <math>n*n</math> матрица <math>H</math>, элементами которой являются +1 и −1 такая, что <math>H H^T = n E_n</math>,
где <math>E_n</math> - единичная матрица размера n.

Матрица Адамара обладает следующими ''свойствами'':
* Различные строки матрицы ортогональны
* Скалярное произведение любой строки саму на себя равно n
* Умножение любой строки или столбца на -1 переводит H в другую матрицу Адамара
* Если все элементы первой строки и первого столбца равны +1, то матрица Адамара называется нормализованной

Ниже показаны примеры нормализованных матриц Адамара порядка 1,2 и 4, причем нормализованность матриц сохраняется при перестановке любых строк и столбцов, кроме первых:

<math>H_1 = (1)</math>
<math>,
H_2 =
\begin{pmatrix}
1 & 1\\
1 & -1\end{pmatrix}
</math>,
<math>,
H_4 =
\begin{pmatrix}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1\end{pmatrix}
</math>

Предполагается, что существуют матрицы Адамара порядка 1, 2 и всех порядков n, кратных 4, хотя это до сих пор еще не было доказано. Нет универсального алгоритма построения матрицы Адамара произвольного размера, но известно большое число методов для различных частных случаев, и наименьший порядок, для которого матрица Адамара еще не построена, равен 268 (на 1977 г.). Мы приведем метод построения Пейли, который важен для теории кодирования.

====Метод Пейли====
Это построение дает матрицы Адамара любого порядка <math>n=p+1</math>, кратного 4, где p-простое число.

'''Определение.''' Пусть p-простое число. Ненулевые квадраты чисел, приведенные по модулю p, называются квадратичными вычетами по модулю p или просто вычетами по модулю p.

Функция <math>X(i)</math>, называемая символом Лежандра, определяется на целых числах следующим образом:
* <math>X(i)=0</math>, если i кратно p;
* <math>X(i)=1</math>, если остаток от деления i на p является квадратным вычетом по модулю p;
* <math>X(i)=-1</math>, если остаток от деления i на p является невычетом.

Теперь мы построим матрицу Джекобстола <math>Q=(q_{ij})</math>. Она представляет собой <math>(p*p)</math>-матрицу, строки и столбцы которой пронумерованы числами 0,1,..., p-1, а элементы <math>q_{ij}=X(j-i)</math>.

Пусть теперь <math>
H =
\begin{pmatrix}
1 & 1\\
1^T & Q-I\end{pmatrix}
</math>.

Доказано, что такая матрица <math>H</math> представляет собой нормализованную матрицу Адамара порядка p+1, которую называют матрицей типа Пейли.

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

Исходные данные - это порядок генерируемой матрицы Адамара <math>n</math>, удовлетворяющее следующим свойствам:

* <math>n>0</math>;

* <math>n</math> делится на 4;

* <math>n-1</math> - простое число.

Вспомогательные данные:

* Число <math>p=n-1</math>;
* Вектор квадратичных вычетов (по модулю <math>p</math>) <math>R</math> (элементы <math>r_i</math>) размера <math>2p</math>. В этом векторе индексация идёт с нуля.

Вычисляемые данные:

* Матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>) размера <math>n \times n</math>. Индексация строчек и столбцов идёт с нуля.

Алгоритм:
:1. Строится вектор квадратичных вычетов <math>R</math>.
:: Первые <math>p</math> элементов вектора <math>R</math> (<math>i=0,1,...,p-1</math>) определяются следующим образом:
::: <math>r_i=1</math>, если <math>i \in \{1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod</math> <math> p\}</math>, <math>i=0,1,...,p-1</math>, то есть если <math>i</math> является квадратичным вычетом по модулю <math>p</math>;
::: <math>r_i=-1</math>, иначе.
::Вторые <math>p</math> элементов (<math>i=p,1,...,2p-1</math>) являются копией первых <math>p</math> элементов:
:::<math>r_i=r_{i-p}, i=p,1,...,2p-1.</math>
:2. Строится матрица Адамара <math>H</math>.
::Элементы матрицы Адамара <math>H</math> находятся следующим образом:
::: <math>h_{0j}=1, j=0,1, ... ,n-1;</math>
::: <math>h_{i0}=1, i=1,2, ... ,n-1;</math>
::: <math>h_{ij}=r_{j-i+p}, i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

Вычислительное ядро алгоритма состоит из <math>(n-1) \times (n-1)</math> операций присваивания следующего вида:

:<math>h_{ij}=r_{j-i+p},</math> <math> i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

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

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

Приведем процедуру на языке С++, реализующую описанный алгоритм. На вход процедуре подается порядок матрицы <math>n</math> и ссылка на заполняемую матрицу <math>result</math>. Считаем, что <math>n</math> положительно, делится на <math>4</math>, <math>n-1</math> - простое число, а размер матрицы <math>result</math> равен <math>n \times n</math>.

<source lang="C">
void buildHadamardMatrix(int n, vector<vector<int>> & result)
{
// 1) Считаем вычеты по модулю p=n-1 и создаем вспомогательный массив вычетов residues
// Достаточно посчитать значения (1^2 mod p), (2^2 mod p), ... , (((p-1)/2)^2 mod p) - эти значениями и будут являться вычетами.
// Строим массив residues размера 2*p, в котором первые p элементов заполняются по следующей схеме: 1, если индекс элемента - вычет, -1 - иначе.
// Вторая половина массива получается дублированием первой половины
int p=n-1;
vector<int> residues;
residues.resize(2*p);
// Заполняем массив
for (int i=0; i<p; i++) {
residue[i] = -1;
}
for (int i=1; i<= (p-1)/2; i++) {
residue[i^2 % p] = 1;
}
for (int i=p; i<2*p; i++) {
residue[i] = residue[i-p];
}

// 2) Построение матрицы Адамара
// Заполнение первой строки 1-цами
for (int j=0; j<n; j++) {
result[0][j] = 1;
}
// Заполнение первого столбца 1-цами
for (int i=1; i<n; i++) {
result[i][0] = 1;
}
// Заполнение оставшейся части матрицы с использованием вспомогательного массива вычетов residues
for (int i=1; i<n; i++) {
for (int j=1; j<n; j++) {
result[i][j] = residues[j-i+p];
}
}
}
</source>

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

Основными операциями алгоритма являются:

* <math>\frac{n}{2}-2</math> операций умножения;
* <math>\frac{n}{2}-2</math> операций взятия остатка;
* <math>n^2+\frac{5}{2}n-3</math> операций присваивания.

Из чего следует, что алгоритм имеет квадратичную последовательную сложность.

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

Информационный граф алгоритма можно представить в виде четырёх последовательных блоков. Первый блок содержит <math>n-1</math> параллельных ветвей, второй блок - <math>\frac{n}{2}-1</math> параллельных ветвей, третий - <math>n-1</math> и четвёртый - <math>n^2</math>.

[[Файл:i_graph.png]]

Каждая вершина из <math>A_1-A_{n-1}</math>, <math>C_1-C_{n-1}</math>, <math>D_1-D_{n^2}</math> соответствует операции присваивания. А каждая вершина из <math>B_1-B_{\frac{n}{2}-1}</math> соответствует трём последовательным операциям: умножения, взятия остатка по модулю и присваивания.

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

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

* <math>n-1</math> операций присваивания;
* <math>\frac{n}{2}-1</math> участков, состоящих из трёх операций: умножения, взятия остатка и присваивания;
* <math>n-1</math> операций присваивания;
* <math>n^2</math> операций присваивания.

Из этого можно сделать вывод, что высота ярусно-параллельной формы информационного графа равняется 6 (присваивание, умножение, взятие остатка, присваивание, присваивание, присваивание). Ширина ярусно-параллельной формы равняется <math>n^2</math>, что означает, что при использовании <math>n^2</math> процессоров матрица Адамара будет строиться за 6 операций.

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

'''Входные данные:''' порядок матрицы Адамара <math>n</math>. Дополнительные ограничения на <math>n</math>:
* <math>n>0</math>
* <math>n</math> делится на 4
* <math>n-1</math> - простое число
'''Объем входных данных:''' 1 (число <math>n</math>)

'''Выходные данные:''' матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>)

'''Объем выходных данных:''' <math>n^2</math> (количество элементов матрицы Адамара порядка <math>n</math>)

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

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

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

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

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

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

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

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

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

Алгоритм построения матрицы Адамара реализован в различных математических пакетах и библиотеках:
* [https://www.mathworks.com/help/matlab/ref/hadamard.html?requestedDomain=www.mathworks.com MATLAB] (вносятся дополнительные ограничения, когда n, или n/12, или n/20 являются степенями по основанию 2)
* [http://r-survey.r-forge.r-project.org/survey/html/hadamard.html R]
* [https://reference.wolframcloud.com/cloudplatform/ref/HadamardMatrix.html Wolfram Mathematica]
* [http://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.linalg.hadamard.html SciPy для Python]

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

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

Участник:Nikita

2016-10-15T18:53:15Z

Nikita:

Иванов Никита, студент 611 группы

Участник:Nikita/Построение матрицы Адамара

2016-10-15T17:55:18Z

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

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O(n^2)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>1</math>
| output_data = <math>n^2</math>
}}

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

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

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

'''''Матрицей Адамара порядка n''''' называется <math>n*n</math> матрица <math>H</math>, элементами которой являются +1 и −1 такая, что <math>H H^T = n E_n</math>,
где <math>E_n</math> - единичная матрица размера n.

Матрица Адамара обладает следующими ''свойствами'':
* Различные строки матрицы ортогональны
* Скалярное произведение любой строки саму на себя равно n
* Умножение любой строки или столбца на -1 переводит H в другую матрицу Адамара
* Если все элементы первой строки и первого столбца равны +1, то матрица Адамара называется нормализованной

Ниже показаны примеры нормализованных матриц Адамара порядка 1,2 и 4, причем нормализованность матриц сохраняется при перестановке любых строк и столбцов, кроме первых:

<math>H_1 = (1)</math>
<math>,
H_2 =
\begin{pmatrix}
1 & 1\\
1 & -1\end{pmatrix}
</math>,
<math>,
H_4 =
\begin{pmatrix}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1\end{pmatrix}
</math>

Предполагается, что существуют матрицы Адамара порядка 1, 2 и всех порядков n, кратных 4, хотя это до сих пор еще не было доказано. Нет универсального алгоритма построения матрицы Адамара произвольного размера, но известно большое число методов для различных частных случаев, и наименьший порядок, для которого матрица Адамара еще не построена, равен 268 (на 1977 г.). Мы приведем метод построения Пейли, который важен для теории кодирования.

====Метод Пейли====
Это построение дает матрицы Адамара любого порядка <math>n=p+1</math>, кратного 4, где p-простое число.

'''Определение.''' Пусть p-простое число. Ненулевые квадраты чисел, приведенные по модулю p, называются квадратичными вычетами по модулю p или просто вычетами по модулю p.

Функция <math>X(i)</math>, называемая символом Лежандра, определяется на целых числах следующим образом:
* <math>X(i)=0</math>, если i кратно p;
* <math>X(i)=1</math>, если остаток от деления i на p является квадратным вычетом по модулю p;
* <math>X(i)=-1</math>, если остаток от деления i на p является невычетом.

Теперь мы построим матрицу Джекобстола <math>Q=(q_{ij})</math>. Она представляет собой <math>(p*p)</math>-матрицу, строки и столбцы которой пронумерованы числами 0,1,..., p-1, а элементы <math>q_{ij}=X(j-i)</math>.

Пусть теперь <math>
H =
\begin{pmatrix}
1 & 1\\
1^T & Q-I\end{pmatrix}
</math>.

Доказано, что такая матрица <math>H</math> представляет собой нормализованную матрицу Адамара порядка p+1, которую называют матрицей типа Пейли.

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

Исходные данные - это порядок генерируемой матрицы Адамара <math>n</math>, удовлетворяющее следующим свойствам:

* <math>n>0</math>;

* <math>n</math> делится на 4;

* <math>n-1</math> - простое число.

Вспомогательные данные:

* Число <math>p=n-1</math>;
* Вектор квадратичных вычетов (по модулю <math>p</math>) <math>R</math> (элементы <math>r_i</math>) размера <math>2p</math>. В этом векторе индексация идёт с нуля.

Вычисляемые данные:

* Матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>) размера <math>n \times n</math>. Индексация строчек и столбцов идёт с нуля.

Алгоритм:
:1. Строится вектор квадратичных вычетов <math>R</math>.
:: Первые <math>p</math> элементов вектора <math>R</math> (<math>i=0,1,...,p-1</math>) определяются следующим образом:
::: <math>r_i=1</math>, если <math>i \in \{1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod</math> <math> p\}</math>, <math>i=0,1,...,p-1</math>, то есть если <math>i</math> является квадратичным вычетом по модулю <math>p</math>;
::: <math>r_i=-1</math>, иначе.
::Вторые <math>p</math> элементов (<math>i=p,1,...,2p-1</math>) являются копией первых <math>p</math> элементов:
:::<math>r_i=r_{i-p}, i=p,1,...,2p-1.</math>
:2. Строится матрица Адамара <math>H</math>.
::Элементы матрицы Адамара <math>H</math> находятся следующим образом:
::: <math>h_{0j}=1, j=0,1, ... ,n-1;</math>
::: <math>h_{i0}=1, i=1,2, ... ,n-1;</math>
::: <math>h_{ij}=r_{j-i+p}, i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

Вычислительное ядро алгоритма состоит из <math>(n-1) \times (n-1)</math> операций присваивания следующего вида:

:<math>h_{ij}=r_{j-i+p},</math> <math> i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

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

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

Приведем процедуру на языке С++, реализующую описанный алгоритм. На вход процедуре подается порядок матрицы <math>n</math> и ссылка на заполняемую матрицу <math>result</math>. Считаем, что <math>n</math> положительно, делится на <math>4</math>, <math>n-1</math> - простое число, а размер матрицы <math>result</math> равен <math>n \times n</math>.

<source lang=c++">
void buildHadamardMatrix(int n, vector<vector<int>> & result)
{
// 1) Считаем вычеты по модулю p=n-1 и создаем вспомогательный массив вычетов residues
// Достаточно посчитать значения (1^2 mod p), (2^2 mod p), ... , (((p-1)/2)^2 mod p) - эти значениями и будут являться вычетами.
// Строим массив residues размера 2*p, в котором первые p элементов заполняются по следующей схеме: 1, если индекс элемента - вычет, -1 - иначе.
// Вторая половина массива получается дублированием первой половины
int p=n-1;
vector<int> residues;
residues.resize(2*p);
// Заполняем массив
for (int i=0; i<p; i++) {
residue[i] = -1;
}
for (int i=1; i<= (p-1)/2; i++) {
residue[i^2 % p] = 1;
}
for (int i=p; i<2*p; i++) {
residue[i] = residue[i-p];
}

// 2) Построение матрицы Адамара
// Заполнение первой строки 1-цами
for (int j=0; j<n; j++) {
result[0][j] = 1;
}
// Заполнение первого столбца 1-цами
for (int i=1; i<n; i++) {
result[i][0] = 1;
}
// Заполнение оставшейся части матрицы с использованием вспомогательного массива вычетов residues
for (int i=1; i<n; i++) {
for (int j=1; j<n; j++) {
result[i][j] = residues[j-i+p];
}
}
}
</source>

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

Основными операциями алгоритма являются:

* <math>\frac{n}{2}-2</math> операций умножения;
* <math>\frac{n}{2}-2</math> операций взятия остатка;
* <math>n^2+\frac{5}{2}n-3</math> операций присваивания.

Из чего следует, что алгоритм имеет квадратичную последовательную сложность.

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

Информационный граф алгоритма можно представить в виде четырёх последовательных блоков. Первый блок содержит <math>n-1</math> параллельных ветвей, второй блок - <math>\frac{n}{2}-1</math> параллельных ветвей, третий - <math>n-1</math> и четвёртый - <math>n^2</math>.

[[Файл:i_graph.png]]

Каждая вершина из <math>A_1-A_{n-1}</math>, <math>C_1-C_{n-1}</math>, <math>D_1-D_{n^2}</math> соответствует операции присваивания. А каждая вершина из <math>B_1-B_{\frac{n}{2}-1}</math> соответствует трём последовательным операциям: умножения, взятия остатка по модулю и присваивания.

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

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

'''Входные данные:''' порядок матрицы Адамара <math>n</math>. Дополнительные ограничения на <math>n</math>:
* <math>n>0</math>
* <math>n</math> делится на 4
* <math>n-1</math> - простое число
'''Объем входных данных:''' 1 (число <math>n</math>)

'''Выходные данные:''' матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>)

'''Объем выходных данных:''' <math>n^2</math> (количество элементов матрицы Адамара порядка <math>n</math>)

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

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

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

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

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

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

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

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

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

Алгоритм построения матрицы Адамара реализован в различных математических пакетах и библиотеках:
* [https://www.mathworks.com/help/matlab/ref/hadamard.html?requestedDomain=www.mathworks.com MATLAB] (вносятся дополнительные ограничения, когда n, или n/12, или n/20 являются степенями по основанию 2)
* [http://r-survey.r-forge.r-project.org/survey/html/hadamard.html R]
* [https://reference.wolframcloud.com/cloudplatform/ref/HadamardMatrix.html Wolfram Mathematica]
* [http://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.linalg.hadamard.html SciPy для Python]

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

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

Участник:Nikita/Построение матрицы Адамара

2016-10-15T14:57:15Z

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

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O(n^2)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>1</math>
| output_data = <math>n^2</math>
}}

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

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

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

'''''Матрицей Адамара порядка n''''' называется <math>n*n</math> матрица <math>H</math>, элементами которой являются +1 и −1 такая, что <math>H H^T = n E_n</math>,
где <math>E_n</math> - единичная матрица размера n.

Матрица Адамара обладает следующими ''свойствами'':
* Различные строки матрицы ортогональны
* Скалярное произведение любой строки саму на себя равно n
* Умножение любой строки или столбца на -1 переводит H в другую матрицу Адамара
* Если все элементы первой строки и первого столбца равны +1, то матрица Адамара называется нормализованной

Ниже показаны примеры нормализованных матриц Адамара порядка 1,2 и 4, причем нормализованность матриц сохраняется при перестановке любых строк и столбцов, кроме первых:

<math>H_1 = (1)</math>
<math>,
H_2 =
\begin{pmatrix}
1 & 1\\
1 & -1\end{pmatrix}
</math>,
<math>,
H_4 =
\begin{pmatrix}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1\end{pmatrix}
</math>

Предполагается, что существуют матрицы Адамара порядка 1, 2 и всех порядков n, кратных 4, хотя это до сих пор еще не было доказано. Нет универсального алгоритма построения матрицы Адамара произвольного размера, но известно большое число методов для различных частных случаев, и наименьший порядок, для которого матрица Адамара еще не построена, равен 268 (на 1977 г.). Мы приведем метод построения Пейли, который важен для теории кодирования.

====Метод Пейли====
Это построение дает матрицы Адамара любого порядка <math>n=p+1</math>, кратного 4, где p-простое число.

'''Определение.''' Пусть p-простое число. Ненулевые квадраты чисел, приведенные по модулю p, называются квадратичными вычетами по модулю p или просто вычетами по модулю p.

Функция <math>X(i)</math>, называемая символом Лежандра, определяется на целых числах следующим образом:
* <math>X(i)=0</math>, если i кратно p;
* <math>X(i)=1</math>, если остаток от деления i на p является квадратным вычетом по модулю p;
* <math>X(i)=-1</math>, если остаток от деления i на p является невычетом.

Теперь мы построим матрицу Джекобстола <math>Q=(q_{ij})</math>. Она представляет собой <math>(p*p)</math>-матрицу, строки и столбцы которой пронумерованы числами 0,1,..., p-1, а элементы <math>q_{ij}=X(j-i)</math>.

Пусть теперь <math>
H =
\begin{pmatrix}
1 & 1\\
1^T & Q-I\end{pmatrix}
</math>.

Доказано, что такая матрица <math>H</math> представляет собой нормализованную матрицу Адамара порядка p+1, которую называют матрицей типа Пейли.

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

Исходные данные - это порядок генерируемой матрицы Адамара <math>n</math>, удовлетворяющее следующим свойствам:

* <math>n>0</math>;

* <math>n</math> делится на 4;

* <math>n-1</math> - простое число.

Вспомогательные данные:

* Число <math>p=n-1</math>;
* Вектор квадратичных вычетов (по модулю <math>p</math>) <math>R</math> (элементы <math>r_i</math>) размера <math>2p</math>. В этом векторе индексация идёт с нуля.

Вычисляемые данные:

* Матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>) размера <math>n \times n</math>. Индексация строчек и столбцов идёт с нуля.

Алгоритм:
:1. Строится вектор квадратичных вычетов <math>R</math>.
:: Первые <math>p</math> элементов вектора <math>R</math> (<math>i=0,1,...,p-1</math>) определяются следующим образом:
::: <math>r_i=1</math>, если <math>i \in \{1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod</math> <math> p\}</math>, <math>i=0,1,...,p-1</math>, то есть если <math>i</math> является квадратичным вычетом по модулю <math>p</math>;
::: <math>r_i=-1</math>, иначе.
::Вторые <math>p</math> элементов (<math>i=p,1,...,2p-1</math>) являются копией первых <math>p</math> элементов:
:::<math>r_i=r_{i-p}, i=p,1,...,2p-1.</math>
:2. Строится матрица Адамара <math>H</math>.
::Элементы матрицы Адамара <math>H</math> находятся следующим образом:
::: <math>h_{0j}=1, j=0,1, ... ,n-1;</math>
::: <math>h_{i0}=1, i=1,2, ... ,n-1;</math>
::: <math>h_{ij}=r_{j-i+p}, i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

Вычислительное ядро алгоритма состоит из <math>(n-1) \times (n-1)</math> операций присваивания следующего вида:

:<math>h_{ij}=r_{j-i+p},</math> <math> i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

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

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

Приведем процедуру на языке С++, реализующую описанный алгоритм. На вход процедуре подается порядок матрицы <math>n</math> и ссылка на заполняемую матрицу <math>result</math>. Считаем, что <math>n</math> положительно, делится на <math>4</math>, <math>n-1</math> - простое число, а размер матрицы <math>result</math> равен <math>n \times n</math>.

<source lang=c++">
void buildHadamardMatrix(int n, vector<vector<int>> & result)
{
// 1) Считаем вычеты по модулю p=n-1 и создаем вспомогательный массив вычетов residues
// Достаточно посчитать значения (1^2 mod p), (2^2 mod p), ... , (((p-1)/2)^2 mod p) - эти значениями и будут являться вычетами.
// Строим массив residues размера 2*p, в котором первые p элементов заполняются по следующей схеме: 1, если индекс элемента - вычет, -1 - иначе.
// Вторая половина массива получается дублированием первой половины
int p=n-1;
vector<int> residues;
residues.resize(2*p);
// Заполняем массив
for (int i=0; i<p; i++) {
residue[i] = -1;
}
for (int i=1; i<= (p-1)/2; i++) {
residue[i^2 % p] = 1;
}
for (int i=p; i<2*p; i++) {
residue[i] = residue[i-p];
}

// 2) Построение матрицы Адамара
// Заполнение первой строки 1-цами
for (int j=0; j<n; j++) {
result[0][j] = 1;
}
// Заполнение первого столбца 1-цами
for (int i=1; i<n; i++) {
result[i][0] = 1;
}
// Заполнение оставшейся части матрицы с использованием вспомогательного массива вычетов residues
for (int i=1; i<n; i++) {
for (int j=1; j<n; j++) {
result[i][j] = residues[j-i+p];
}
}
}
</source>

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

Основными операциями алгоритма являются:

* <math>\frac{n}{2}-2</math> операций умножения;
* <math>\frac{n}{2}-2</math> операций взятия остатка;
* <math>n^2+2n-2</math> операций присваивания.

Из чего следует, что алгоритм имеет квадратичную последовательную сложность.

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

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

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

'''Входные данные:''' порядок матрицы Адамара <math>n</math>. Дополнительные ограничения на <math>n</math>:
* <math>n>0</math>
* <math>n</math> делится на 4
* <math>n-1</math> - простое число
'''Объем входных данных:''' 1 (число <math>n</math>)

'''Выходные данные:''' матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>)

'''Объем выходных данных:''' <math>n^2</math> (количество элементов матрицы Адамара порядка <math>n</math>)

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

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

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

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

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

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

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

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

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

Алгоритм построения матрицы Адамара реализован в различных математических пакетах и библиотеках:
* [https://www.mathworks.com/help/matlab/ref/hadamard.html?requestedDomain=www.mathworks.com MATLAB] (вносятся дополнительные ограничения, когда n, или n/12, или n/20 являются степенями по основанию 2)
* [http://r-survey.r-forge.r-project.org/survey/html/hadamard.html R]
* [https://reference.wolframcloud.com/cloudplatform/ref/HadamardMatrix.html Wolfram Mathematica]
* [http://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.linalg.hadamard.html SciPy для Python]

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

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

Участник:Nikita/Построение матрицы Адамара

2016-10-15T10:36:20Z

Nikita: /* Существующие реализации алгоритма */

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O(n^2)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>1</math>
| output_data = <math>n^2</math>
}}

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

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

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

'''''Матрицей Адамара порядка n''''' называется <math>n*n</math> матрица <math>H</math>, элементами которой являются +1 и −1 такая, что <math>H H^T = n E_n</math>,
где <math>E_n</math> - единичная матрица размера n.

Матрица Адамара обладает следующими ''свойствами'':
* Различные строки матрицы ортогональны
* Скалярное произведение любой строки саму на себя равно n
* Умножение любой строки или столбца на -1 переводит H в другую матрицу Адамара
* Если все элементы первой строки и первого столбца равны +1, то матрица Адамара называется нормализованной

Ниже показаны примеры нормализованных матриц Адамара порядка 1,2 и 4, причем нормализованность матриц сохраняется при перестановке любых строк и столбцов, кроме первых:

<math>H_1 = (1)</math>
<math>,
H_2 =
\begin{pmatrix}
1 & 1\\
1 & -1\end{pmatrix}
</math>,
<math>,
H_4 =
\begin{pmatrix}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1\end{pmatrix}
</math>

Предполагается, что существуют матрицы Адамара порядка 1, 2 и всех порядков n, кратных 4, хотя это до сих пор еще не было доказано. Нет универсального алгоритма построения матрицы Адамара произвольного размера, но известно большое число методов для различных частных случаев, и наименьший порядок, для которого матрица Адамара еще не построена, равен 268 (на 1977 г.). Мы приведем метод построения Пейли, который важен для теории кодирования.

====Метод Пейли====
Это построение дает матрицы Адамара любого порядка <math>n=p+1</math>, кратного 4, где p-простое число.

'''Определение.''' Пусть p-простое число. Ненулевые квадраты чисел, приведенные по модулю p, называются квадратичными вычетами по модулю p или просто вычетами по модулю p.

Функция <math>X(i)</math>, называемая символом Лежандра, определяется на целых числах следующим образом:
* <math>X(i)=0</math>, если i кратно p;
* <math>X(i)=1</math>, если остаток от деления i на p является квадратным вычетом по модулю p;
* <math>X(i)=-1</math>, если остаток от деления i на p является невычетом.

Теперь мы построим матрицу Джекобстола <math>Q=(q_{ij})</math>. Она представляет собой <math>(p*p)</math>-матрицу, строки и столбцы которой пронумерованы числами 0,1,..., p-1, а элементы <math>q_{ij}=X(j-i)</math>.

Пусть теперь <math>
H =
\begin{pmatrix}
1 & 1\\
1^T & Q-I\end{pmatrix}
</math>.

Доказано, что такая матрица <math>H</math> представляет собой нормализованную матрицу Адамара порядка p+1, которую называют матрицей типа Пейли.

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

Исходные данные - это порядок генерируемой матрицы Адамара <math>n</math>, удовлетворяющее следующим свойствам:

* <math>n>0</math>;

* <math>n</math> делится на 4;

* <math>n-1</math> - простое число.

Вспомогательные данные:

* Число <math>p=n-1</math>;
* Вектор квадратичных вычетов (по модулю <math>p</math>) <math>R</math> (элементы <math>r_i</math>) размера <math>2p</math>. В этом векторе индексация идёт с нуля.

Вычисляемые данные:

* Матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>) размера <math>n \times n</math>. Индексация строчек и столбцов идёт с нуля.

Алгоритм:
:1. Строится вектор квадратичных вычетов <math>R</math>.
:: Первые <math>p</math> элементов вектора <math>R</math> (<math>i=0,1,...,p-1</math>) определяются следующим образом:
::: <math>r_i=1</math>, если <math>i \in \{1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod</math> <math> p\}</math>, <math>i=0,1,...,p-1</math>, то есть если <math>i</math> является квадратичным вычетом по модулю <math>p</math>;
::: <math>r_i=-1</math>, иначе.
::Вторые <math>p</math> элементов (<math>i=p,1,...,2p-1</math>) являются копией первых <math>p</math> элементов:
:::<math>r_i=r_{i-p}, i=p,1,...,2p-1.</math>
:2. Строится матрица Адамара <math>H</math>.
::Элементы матрицы Адамара <math>H</math> находятся следующим образом:
::: <math>h_{0j}=1, j=0,1, ... ,n-1;</math>
::: <math>h_{i0}=1, i=1,2, ... ,n-1;</math>
::: <math>h_{ij}=r_{j-i+p}, i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

Вычислительное ядро алгоритма состоит из <math>(n-1) \times (n-1)</math> операций присваивания следующего вида:

:<math>h_{ij}=r_{j-i+p},</math> <math> i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

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

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

Приведем процедуру на языке С++, реализующую описанный алгоритм. На вход процедуре подается порядок матрицы <math>n</math> и ссылка на заполняемую матрицу <math>result</math>. Считаем, что <math>n</math> положительно, делится на <math>4</math>, <math>n-1</math> - простое число, а размер матрицы <math>result</math> равен <math>n \times n</math>.

<source lang=c++">
void buildHadamardMatrix(int n, vector<vector<int>> & result)
{
// 1) Считаем вычеты по модулю p=n-1 и создаем вспомогательный массив вычетов residues
// Достаточно посчитать значения (1^2 mod p), (2^2 mod p), ... , (((p-1)/2)^2 mod p) - эти значениями и будут являться вычетами.
// Строим массив residues размера 2*p, в котором первые p элементов заполняются по следующей схеме: 1, если индекс элемента - вычет, -1 - иначе.
// Вторая половина массива получается дублированием первой половины
int p=n-1;
vector<int> residues;
residues.resize(2*p);
// Заполняем массив
for (int i=0; i<p; i++) {
residue[i] = -1;
}
for (int i=1; i<= (p-1)/2; i++) {
residue[i^2 % p] = 1;
}
for (int i=p; i<2*p; i++) {
residue[i] = residue[i-p];
}

// 2) Построение матрицы Адамара
// Заполнение первой строки 1-цами
for (int j=0; j<n; j++) {
result[0][j] = 1;
}
// Заполнение первого столбца 1-цами
for (int i=1; i<n; i++) {
result[i][0] = 1;
}
// Заполнение оставшейся части матрицы с использованием вспомогательного массива вычетов residues
for (int i=1; i<n; i++) {
for (int j=1; j<n; j++) {
result[i][j] = residues[j-i+p];
}
}
}
</source>

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

Основными операциями алгоритма являются:

* <math>\frac{n}{2}-2</math> операций умножения;
* <math>\frac{n}{2}-2</math> операций взятия остатка;
* <math>n^2+2n-2</math> операций присваивания.

Из чего следует, что алгоритм имеет квадратичную последовательную сложность.

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

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

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

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

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

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

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

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

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

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

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

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

Алгоритм построения матрицы Адамара реализован в различных математических пакетах и библиотеках:
* [https://www.mathworks.com/help/matlab/ref/hadamard.html?requestedDomain=www.mathworks.com MATLAB] (вносятся дополнительные ограничения, когда n, или n/12, или n/20 являются степенями по основанию 2)
* [http://r-survey.r-forge.r-project.org/survey/html/hadamard.html R]
* [https://reference.wolframcloud.com/cloudplatform/ref/HadamardMatrix.html Wolfram Mathematica]
* [http://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.linalg.hadamard.html SciPy для Python]

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

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

Участник:Nikita/Построение матрицы Адамара

2016-10-15T10:20:41Z

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

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O(n^2)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>1</math>
| output_data = <math>n^2</math>
}}

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

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

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

'''''Матрицей Адамара порядка n''''' называется <math>n*n</math> матрица <math>H</math>, элементами которой являются +1 и −1 такая, что <math>H H^T = n E_n</math>,
где <math>E_n</math> - единичная матрица размера n.

Матрица Адамара обладает следующими ''свойствами'':
* Различные строки матрицы ортогональны
* Скалярное произведение любой строки саму на себя равно n
* Умножение любой строки или столбца на -1 переводит H в другую матрицу Адамара
* Если все элементы первой строки и первого столбца равны +1, то матрица Адамара называется нормализованной

Ниже показаны примеры нормализованных матриц Адамара порядка 1,2 и 4, причем нормализованность матриц сохраняется при перестановке любых строк и столбцов, кроме первых:

<math>H_1 = (1)</math>
<math>,
H_2 =
\begin{pmatrix}
1 & 1\\
1 & -1\end{pmatrix}
</math>,
<math>,
H_4 =
\begin{pmatrix}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1\end{pmatrix}
</math>

Предполагается, что существуют матрицы Адамара порядка 1, 2 и всех порядков n, кратных 4, хотя это до сих пор еще не было доказано. Нет универсального алгоритма построения матрицы Адамара произвольного размера, но известно большое число методов для различных частных случаев, и наименьший порядок, для которого матрица Адамара еще не построена, равен 268 (на 1977 г.). Мы приведем метод построения Пейли, который важен для теории кодирования.

====Метод Пейли====
Это построение дает матрицы Адамара любого порядка <math>n=p+1</math>, кратного 4, где p-простое число.

'''Определение.''' Пусть p-простое число. Ненулевые квадраты чисел, приведенные по модулю p, называются квадратичными вычетами по модулю p или просто вычетами по модулю p.

Функция <math>X(i)</math>, называемая символом Лежандра, определяется на целых числах следующим образом:
* <math>X(i)=0</math>, если i кратно p;
* <math>X(i)=1</math>, если остаток от деления i на p является квадратным вычетом по модулю p;
* <math>X(i)=-1</math>, если остаток от деления i на p является невычетом.

Теперь мы построим матрицу Джекобстола <math>Q=(q_{ij})</math>. Она представляет собой <math>(p*p)</math>-матрицу, строки и столбцы которой пронумерованы числами 0,1,..., p-1, а элементы <math>q_{ij}=X(j-i)</math>.

Пусть теперь <math>
H =
\begin{pmatrix}
1 & 1\\
1^T & Q-I\end{pmatrix}
</math>.

Доказано, что такая матрица <math>H</math> представляет собой нормализованную матрицу Адамара порядка p+1, которую называют матрицей типа Пейли.

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

Исходные данные - это порядок генерируемой матрицы Адамара <math>n</math>, удовлетворяющее следующим свойствам:

* <math>n>0</math>;

* <math>n</math> делится на 4;

* <math>n-1</math> - простое число.

Вспомогательные данные:

* Число <math>p=n-1</math>;
* Вектор квадратичных вычетов (по модулю <math>p</math>) <math>R</math> (элементы <math>r_i</math>) размера <math>2p</math>. В этом векторе индексация идёт с нуля.

Вычисляемые данные:

* Матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>) размера <math>n \times n</math>. Индексация строчек и столбцов идёт с нуля.

Алгоритм:
:1. Строится вектор квадратичных вычетов <math>R</math>.
:: Первые <math>p</math> элементов вектора <math>R</math> (<math>i=0,1,...,p-1</math>) определяются следующим образом:
::: <math>r_i=1</math>, если <math>i \in \{1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod</math> <math> p\}</math>, <math>i=0,1,...,p-1</math>, то есть если <math>i</math> является квадратичным вычетом по модулю <math>p</math>;
::: <math>r_i=-1</math>, иначе.
::Вторые <math>p</math> элементов (<math>i=p,1,...,2p-1</math>) являются копией первых <math>p</math> элементов:
:::<math>r_i=r_{i-p}, i=p,1,...,2p-1.</math>
:2. Строится матрица Адамара <math>H</math>.
::Элементы матрицы Адамара <math>H</math> находятся следующим образом:
::: <math>h_{0j}=1, j=0,1, ... ,n-1;</math>
::: <math>h_{i0}=1, i=1,2, ... ,n-1;</math>
::: <math>h_{ij}=r_{j-i+p}, i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

Вычислительное ядро алгоритма состоит из <math>(n-1) \times (n-1)</math> операций присваивания следующего вида:

:<math>h_{ij}=r_{j-i+p},</math> <math> i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

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

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

Приведем процедуру на языке С++, реализующую описанный алгоритм. На вход процедуре подается порядок матрицы <math>n</math> и ссылка на заполняемую матрицу <math>result</math>. Считаем, что <math>n</math> положительно, делится на <math>4</math>, <math>n-1</math> - простое число, а размер матрицы <math>result</math> равен <math>n \times n</math>.

<source lang=c++">
void buildHadamardMatrix(int n, vector<vector<int>> & result)
{
// 1) Считаем вычеты по модулю p=n-1 и создаем вспомогательный массив вычетов residues
// Достаточно посчитать значения (1^2 mod p), (2^2 mod p), ... , (((p-1)/2)^2 mod p) - эти значениями и будут являться вычетами.
// Строим массив residues размера 2*p, в котором первые p элементов заполняются по следующей схеме: 1, если индекс элемента - вычет, -1 - иначе.
// Вторая половина массива получается дублированием первой половины
int p=n-1;
vector<int> residues;
residues.resize(2*p);
// Заполняем массив
for (int i=0; i<p; i++) {
residue[i] = -1;
}
for (int i=1; i<= (p-1)/2; i++) {
residue[i^2 % p] = 1;
}
for (int i=p; i<2*p; i++) {
residue[i] = residue[i-p];
}

// 2) Построение матрицы Адамара
// Заполнение первой строки 1-цами
for (int j=0; j<n; j++) {
result[0][j] = 1;
}
// Заполнение первого столбца 1-цами
for (int i=1; i<n; i++) {
result[i][0] = 1;
}
// Заполнение оставшейся части матрицы с использованием вспомогательного массива вычетов residues
for (int i=1; i<n; i++) {
for (int j=1; j<n; j++) {
result[i][j] = residues[j-i+p];
}
}
}
</source>

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

Основными операциями алгоритма являются:

* <math>\frac{n}{2}-2</math> операций умножения;
* <math>\frac{n}{2}-2</math> операций взятия остатка;
* <math>n^2+2n-2</math> операций присваивания.

Из чего следует, что алгоритм имеет квадратичную последовательную сложность.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Участник:Nikita/Построение матрицы Адамара

2016-10-14T14:53:39Z

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

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O(n^2)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>1</math>
| output_data = <math>n^2</math>
}}

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

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

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

'''''Матрицей Адамара порядка n''''' называется <math>n*n</math> матрица <math>H</math>, элементами которой являются +1 и −1 такая, что <math>H H^T = n E_n</math>,
где <math>E_n</math> - единичная матрица размера n.

Матрица Адамара обладает следующими ''свойствами'':
* Различные строки матрицы ортогональны
* Скалярное произведение любой строки саму на себя равно n
* Умножение любой строки или столбца на -1 переводит H в другую матрицу Адамара
* Если все элементы первой строки и первого столбца равны +1, то матрица Адамара называется нормализованной

Ниже показаны примеры нормализованных матриц Адамара порядка 1,2 и 4, причем нормализованность матриц сохраняется при перестановке любых строк и столбцов, кроме первых:

<math>H_1 = (1)</math>
<math>,
H_2 =
\begin{pmatrix}
1 & 1\\
1 & -1\end{pmatrix}
</math>,
<math>,
H_4 =
\begin{pmatrix}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1\end{pmatrix}
</math>

Предполагается, что существуют матрицы Адамара порядка 1, 2 и всех порядков n, кратных 4, хотя это до сих пор еще не было доказано. Известно большое число методов построения, и наименьший порядок, для которого матрица Адамара еще не построена, равен 268 (на 1977 г.). Мы приведем метод построения Пейли, который важен для теории кодирования.

====Метод Пейли====
Это построение дает матрицы Адамара любого порядка <math>n=p+1</math>, кратного 4, где p-простое число.

'''Определение.''' Пусть p-простое число. Ненулевые квадраты чисел, приведенные по модулю p, называются квадратичными вычетами по модулю p или просто вычетами по модулю p.

Функция <math>X(i)</math>, называемая символом Лежандра, определяется на целых числах следующим образом:
* <math>X(i)=0</math>, если i кратно p;
* <math>X(i)=1</math>, если остаток от деления i на p является квадратным вычетом по модулю p;
* <math>X(i)=-1</math>, если остаток от деления i на p является невычетом.

Теперь мы построим матрицу Джекобстола <math>Q=(q_{ij})</math>. Она представляет собой <math>(p*p)</math>-матрицу, строки и столбцы которой пронумерованы числами 0,1,..., p-1, а элементы <math>q_{ij}=X(j-i)</math>.

Пусть теперь <math>
H =
\begin{pmatrix}
1 & 1\\
1^T & Q-I\end{pmatrix}
</math>.

Доказано, что такая матрица <math>H</math> представляет собой нормализованную матрицу Адамара порядка p+1, которую называют матрицей типа Пейли.

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

Исходные данные - это порядок генерируемой матрицы Адамара <math>n</math>, удовлетворяющее следующим свойствам:

* <math>n>0</math>;

* <math>n</math> делится на 4;

* <math>n-1</math> - простое число.

Вспомогательные данные:

* Число <math>p=n-1</math>;
* Вектор квадратичных вычетов (по модулю <math>p</math>) <math>R</math> (элементы <math>r_i</math>) размера <math>2p</math>. В этом векторе индексация идёт с нуля.

Вычисляемые данные:

* Матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>) размера <math>n \times n</math>. Индексация строчек и столбцов идёт с нуля.

Алгоритм:
:1. Строится вектор квадратичных вычетов <math>R</math>.
:: Первые <math>p</math> элементов вектора <math>R</math> (<math>i=0,1,...,p-1</math>) определяются следующим образом:
::: <math>r_i=1</math>, если <math>i \in \{1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod</math> <math> p\}</math>, <math>i=0,1,...,p-1</math>, то есть если <math>i</math> является квадратичным вычетом по модулю <math>p</math>;
::: <math>r_i=-1</math>, иначе.
::Вторые <math>p</math> элементов (<math>i=p,1,...,2p-1</math>) являются копией первых <math>p</math> элементов:
:::<math>r_i=r_{i-p}, i=p,1,...,2p-1.</math>
:2. Строится матрица Адамара <math>H</math>.
::Элементы матрицы Адамара <math>H</math> находятся следующим образом:
::: <math>h_{0j}=1, j=0,1, ... ,n-1;</math>
::: <math>h_{i0}=1, i=1,2, ... ,n-1;</math>
::: <math>h_{ij}=r_{j-i+p}, i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

Вычислительное ядро алгоритма состоит из <math>(n-1) \times (n-1)</math> операций присваивания следующего вида:

:<math>h_{ij}=r_{j-i+p},</math> <math> i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

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

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

Приведем процедуру на языке С++, реализующую описанный алгоритм. На вход процедуре подается порядок матрицы <math>n</math> и ссылка на заполняемую матрицу <math>result</math>. Считаем, что <math>n</math> положительно, делится на <math>4</math>, <math>n-1</math> - простое число, а размер матрицы <math>result</math> равен <math>n \times n</math>.

<source lang=c++">
void buildHadamardMatrix(int n, vector<vector<int>> & result)
{
// 1) Считаем вычеты по модулю p=n-1 и создаем вспомогательный массив вычетов residues
// Достаточно посчитать значения (1^2 mod p), (2^2 mod p), ... , (((p-1)/2)^2 mod p) - эти значениями и будут являться вычетами.
// Строим массив residues размера 2*p, в котором первые p элементов заполняются по следующей схеме: 1, если индекс элемента - вычет, -1 - иначе.
// Вторая половина массива получается дублированием первой половины
int p=n-1;
vector<int> residues;
residues.resize(2*p);
// Заполняем массив
for (int i=0; i<p; i++) {
residue[i] = -1;
}
for (int i=1; i<= (p-1)/2; i++) {
residue[i^2 % p] = 1;
}
for (int i=p; i<2*p; i++) {
residue[i] = residue[i-p];
}

// 2) Построение матрицы Адамара
// Заполнение первой строки 1-цами
for (int j=0; j<n; j++) {
result[0][j] = 1;
}
// Заполнение первого столбца 1-цами
for (int i=1; i<n; i++) {
result[i][0] = 1;
}
// Заполнение оставшейся части матрицы с использованием вспомогательного массива вычетов residues
for (int i=1; i<n; i++) {
for (int j=1; j<n; j++) {
result[i][j] = residues[j-i+p];
}
}
}
</source>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

[1] http://info.sernam.ru/book_tcod.php?id=16

Участник:Nikita/Построение матрицы Адамара

2016-10-14T14:37:18Z

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

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O(n^2)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>1</math>
| output_data = <math>n^2</math>
}}

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

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

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

'''''Матрицей Адамара порядка n''''' называется <math>n*n</math> матрица <math>H</math>, элементами которой являются +1 и −1 такая, что <math>H H^T = n E_n</math>,
где <math>E_n</math> - единичная матрица размера n.

Матрица Адамара обладает следующими ''свойствами'':
* Различные строки матрицы ортогональны
* Скалярное произведение любой строки саму на себя равно n
* Умножение любой строки или столбца на -1 переводит H в другую матрицу Адамара
* Если все элементы первой строки и первого столбца равны +1, то матрица Адамара называется нормализованной

Ниже показаны примеры нормализованных матриц Адамара порядка 1,2 и 4, причем нормализованность матриц сохраняется при перестановке любых строк и столбцов, кроме первых:

<math>H_1 = (1)</math>
<math>,
H_2 =
\begin{pmatrix}
1 & 1\\
1 & -1\end{pmatrix}
</math>,
<math>,
H_4 =
\begin{pmatrix}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1\end{pmatrix}
</math>

Предполагается, что существуют матрицы Адамара порядка 1, 2 и всех порядков n, кратных 4, хотя это до сих пор еще не было доказано. Известно большое число методов построения, и наименьший порядок, для которого матрица Адамара еще не построена, равен 268 (на 1977 г.). Мы приведем метод построения Пейли, который важен для теории кодирования.

====Метод Пейли====
Это построение дает матрицы Адамара любого порядка <math>n=p+1</math>, кратного 4, где p-простое число.

'''Определение.''' Пусть p-простое число. Ненулевые квадраты чисел, приведенные по модулю p, называются квадратичными вычетами по модулю p или просто вычетами по модулю p.

Функция <math>X(i)</math>, называемая символом Лежандра, определяется на целых числах следующим образом:
* <math>X(i)=0</math>, если i кратно p;
* <math>X(i)=1</math>, если остаток от деления i на p является квадратным вычетом по модулю p;
* <math>X(i)=-1</math>, если остаток от деления i на p является невычетом.

Теперь мы построим матрицу Джекобстола <math>Q=(q_{ij})</math>. Она представляет собой <math>(p*p)</math>-матрицу, строки и столбцы которой пронумерованы числами 0,1,..., p-1, а элементы <math>q_{ij}=X(j-i)</math>.

Пусть теперь <math>
H =
\begin{pmatrix}
1 & 1\\
1^T & Q-I\end{pmatrix}
</math>.

Доказано, что такая матрица <math>H</math> представляет собой нормализованную матрицу Адамара порядка p+1, которую называют матрицей типа Пейли.

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

Исходные данные - это порядок генерируемой матрицы Адамара <math>n</math>, удовлетворяющее следующим свойствам:

* <math>n>0</math>;

* <math>n</math> делится на 4;

* <math>n-1</math> - простое число.

Вспомогательные данные:

* Число <math>p=n-1</math>;
* Вектор квадратичных вычетов (по модулю <math>p</math>) <math>R</math> (элементы <math>r_i</math>) размера <math>2p</math>. В этом векторе индексация идёт с нуля.

Вычисляемые данные:

* Матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>) размера <math>n \times n</math>. Индексация строчек и столбцов идёт с нуля.

Алгоритм:
:1. Строится вектор квадратичных вычетов <math>R</math>.
:: Первые <math>p</math> элементов вектора <math>R</math> (<math>i=0,1,...,p-1</math>) определяются следующим образом:
::: <math>r_i=1</math>, если <math>i \in \{1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod</math> <math> p\}</math>, <math>i=0,1,...,p-1</math>, то есть если <math>i</math> является квадратичным вычетом по модулю <math>p</math>;
::: <math>r_i=-1</math>, иначе.
::Вторые <math>p</math> элементов (<math>i=p,1,...,2p-1</math>) являются копией первых <math>p</math> элементов:
:::<math>r_i=r_{i-p}, i=p,1,...,2p-1.</math>
:2. Строится матрица Адамара <math>H</math>.
::Элементы матрицы Адамара <math>H</math> находятся следующим образом:
::: <math>h_{0j}=1, j=0,1, ... ,n-1;</math>
::: <math>h_{i0}=1, i=1,2, ... ,n-1;</math>
::: <math>h_{ij}=r_{j-i+p}, i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

Вычислительное ядро алгоритма состоит из <math>(n-1) \times (n-1)</math> операций присваивания следующего вида:

:<math>h_{ij}=r_{j-i+p},</math> <math> i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<references \>

Участник:Nikita/Построение матрицы Адамара

2016-10-14T14:26:56Z

Nikita: /* Метод Пейли */

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O(n^2)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>1</math>
| output_data = <math>n^2</math>
}}

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

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

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

'''''Матрицей Адамара порядка n''''' называется <math>n*n</math> матрица <math>H</math>, элементами которой являются +1 и −1 такая, что <math>H H^T = n E_n</math>,
где <math>E_n</math> - единичная матрица размера n.

Матрица Адамара обладает следующими ''свойствами'':
* Различные строки матрицы ортогональны
* Скалярное произведение любой строки саму на себя равно n
* Умножение любой строки или столбца на -1 переводит H в другую матрицу Адамара
* Если все элементы первой строки и первого столбца равны +1, то матрица Адамара называется нормализованной

Ниже показаны примеры нормализованных матриц Адамара порядка 1,2 и 4, причем нормализованность матриц сохраняется при перестановке любых строк и столбцов, кроме первых:

<math>H_1 = (1)</math>
<math>,
H_2 =
\begin{pmatrix}
1 & 1\\
1 & -1\end{pmatrix}
</math>,
<math>,
H_4 =
\begin{pmatrix}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1\end{pmatrix}
</math>

Предполагается, что существуют матрицы Адамара порядка 1, 2 и всех порядков n, кратных 4, хотя это до сих пор еще не было доказано. Известно большое число методов построения, и наименьший порядок, для которого матрица Адамара еще не построена, равен 268 (на 1977 г.). Мы приведем метод построения Пейли, который важен для теории кодирования.

====Метод Пейли====
Это построение дает матрицы Адамара любого порядка <math>n=p+1</math>, кратного 4, где p-простое число.

'''Определение.''' Пусть p-простое число. Ненулевые квадраты чисел, приведенные по модулю p, называются квадратичными вычетами по модулю p или просто вычетами по модулю p.

Функция <math>X(i)</math>, называемая символом Лежандра, определяется на целых числах следующим образом:
* <math>X(i)=0</math>, если i кратно p;
* <math>X(i)=1</math>, если остаток от деления i на p является квадратным вычетом по модулю p;
* <math>X(i)=-1</math>, если остаток от деления i на p является невычетом.

Теперь мы построим матрицу Джекобстола <math>Q=(q_{ij})</math>. Она представляет собой <math>(p*p)</math>-матрицу, строки и столбцы которой пронумерованы числами 0,1,..., p-1, а элементы <math>q_{ij}=X(j-i)</math>.

Пусть теперь <math>
H =
\begin{pmatrix}
1 & 1\\
1^T & Q-I\end{pmatrix}
</math>.

Доказано, что такая матрица <math>H</math> представляет собой нормализованную матрицу Адамара порядка p+1, которую называют матрицей типа Пейли.

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

Исходные данные - это порядок генерируемой матрицы Адамара <math>n</math>, удовлетворяющее следующим свойствам:

* <math>n>0</math>;

* <math>n</math> делится на 4;

* <math>n-1</math> - простое число.

Вспомогательные данные:

* Число <math>p=n-1</math>;
* Вектор квадратичных вычетов (по модулю <math>p</math>) <math>R</math> (элементы <math>r_i</math>) размера <math>2p</math>. В этом векторе индексация идёт с нуля.

Вычисляемые данные:

* Матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>) размера <math>n \times n</math>. Индексация строчек и столбцов идёт с нуля.

Алгоритм:
:1. Строится вектор квадратичных вычетов <math>R</math>.
:: Первые <math>p</math> элементов вектора <math>R</math> (<math>i=0,1,...,p-1</math>) определяются следующим образом:
::: <math>r_i=1</math>, если <math>i \in \{1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod</math> <math> p\}</math>, <math>i=0,1,...,p-1</math>, то есть если <math>i</math> является квадратичным вычетом по модулю <math>p</math>;
::: <math>r_i=-1</math>, иначе.
::Вторые <math>p</math> элементов (<math>i=p,1,...,2p-1</math>) являются копией первых <math>p</math> элементов:
:::<math>r_i=r_{i-p}, i=p,1,...,2p-1.</math>
:2. Строится матрица Адамара <math>H</math>.
::Элементы матрицы Адамара <math>H</math> находятся следующим образом:
::: <math>h_{0j}=1, j=0,1, ... ,n-1;</math>
::: <math>h_{i0}=1, i=1,2, ... ,n-1;</math>
::: <math>h_{ij}=r_{j-i+p}, i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

Вычислительное ядро алгоритма состоит из <math>(n-1) \times (n-1)</math> операций присваивания следующего вида:

:<math>h_{ij}=r_{j-i+p},</math> <math> i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Участник:Nikita/Построение матрицы Адамара

2016-10-14T14:25:57Z

Nikita: /* Метод Пейли */

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O(n^2)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>1</math>
| output_data = <math>n^2</math>
}}

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

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

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

'''''Матрицей Адамара порядка n''''' называется <math>n*n</math> матрица <math>H</math>, элементами которой являются +1 и −1 такая, что <math>H H^T = n E_n</math>,
где <math>E_n</math> - единичная матрица размера n.

Матрица Адамара обладает следующими ''свойствами'':
* Различные строки матрицы ортогональны
* Скалярное произведение любой строки саму на себя равно n
* Умножение любой строки или столбца на -1 переводит H в другую матрицу Адамара
* Если все элементы первой строки и первого столбца равны +1, то матрица Адамара называется нормализованной

Ниже показаны примеры нормализованных матриц Адамара порядка 1,2 и 4, причем нормализованность матриц сохраняется при перестановке любых строк и столбцов, кроме первых:

<math>H_1 = (1)</math>
<math>,
H_2 =
\begin{pmatrix}
1 & 1\\
1 & -1\end{pmatrix}
</math>,
<math>,
H_4 =
\begin{pmatrix}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1\end{pmatrix}
</math>

Предполагается, что существуют матрицы Адамара порядка 1, 2 и всех порядков n, кратных 4, хотя это до сих пор еще не было доказано. Известно большое число методов построения, и наименьший порядок, для которого матрица Адамара еще не построена, равен 268 (на 1977 г.). Мы приведем метод построения Пейли, который важен для теории кодирования.

====Метод Пейли====
Это построение дает матрицы Адамара любого порядка <math>n=p+1</math>, кратного 4, где p-простое число.

'''Определение.''' Пусть p-простое число. Ненулевые квадраты чисел, приведенные по модулю p, называются квадратичными вычетами по модулю p или просто вычетами по модулю p.

Функция <math>X(i)</math>, называемая символом Лежандра, определяется на целых числах следующим образом:
* <math>X(i)=0</math>, если i кратно p;
* <math>X(i)=1</math>, если остаток от деления i на p является квадратным вычетом по модулю p;
* <math>X(i)=-1</math>, если остаток от деления i на p является невычетом.

Теперь мы построим матрицу Джекобстола <math>Q=(q_{ij})</math>. Она представляет собой <math>(p*p)</math>-матрицу, строки и столбцы которой пронумерованы числами 0,1,..., p-1, а элементы <math>q_{ij}=X(j-i)</math>.

Пусть теперь <math>
H =
\begin{pmatrix}
1 & 1\\
1^T & Q-I\end{pmatrix}
</math>.

Таким образом, <math>H</math> представляет собой нормализованную матрицу Адамара порядка p+1, которую называют матрицей типа Пейли.

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

Исходные данные - это порядок генерируемой матрицы Адамара <math>n</math>, удовлетворяющее следующим свойствам:

* <math>n>0</math>;

* <math>n</math> делится на 4;

* <math>n-1</math> - простое число.

Вспомогательные данные:

* Число <math>p=n-1</math>;
* Вектор квадратичных вычетов (по модулю <math>p</math>) <math>R</math> (элементы <math>r_i</math>) размера <math>2p</math>. В этом векторе индексация идёт с нуля.

Вычисляемые данные:

* Матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>) размера <math>n \times n</math>. Индексация строчек и столбцов идёт с нуля.

Алгоритм:
:1. Строится вектор квадратичных вычетов <math>R</math>.
:: Первые <math>p</math> элементов вектора <math>R</math> (<math>i=0,1,...,p-1</math>) определяются следующим образом:
::: <math>r_i=1</math>, если <math>i \in \{1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod</math> <math> p\}</math>, <math>i=0,1,...,p-1</math>, то есть если <math>i</math> является квадратичным вычетом по модулю <math>p</math>;
::: <math>r_i=-1</math>, иначе.
::Вторые <math>p</math> элементов (<math>i=p,1,...,2p-1</math>) являются копией первых <math>p</math> элементов:
:::<math>r_i=r_{i-p}, i=p,1,...,2p-1.</math>
:2. Строится матрица Адамара <math>H</math>.
::Элементы матрицы Адамара <math>H</math> находятся следующим образом:
::: <math>h_{0j}=1, j=0,1, ... ,n-1;</math>
::: <math>h_{i0}=1, i=1,2, ... ,n-1;</math>
::: <math>h_{ij}=r_{j-i+p}, i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

Вычислительное ядро алгоритма состоит из <math>(n-1) \times (n-1)</math> операций присваивания следующего вида:

:<math>h_{ij}=r_{j-i+p},</math> <math> i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

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

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

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

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

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

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

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

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

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

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

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

== Литература ==

Участник:Nikita/Построение матрицы Адамара

2016-10-14T14:12:58Z

Nikita: /* Общее описание алгоритма */

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O(n^2)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>1</math>
| output_data = <math>n^2</math>
}}

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Матрицы Адамара были введены в математический обиход в конце прошлого века и играют важную роль в алгебре и комбинаторике. Они находят широкое применение в теории кодирования (коды, исправляющие ошибки), теории планирования многофакторных экспериментов (блок-схемы) и других областях математики. Сравнительно недавно (в 1960 г.) было замечено, что эти матрицы могут быть использованы для построения кодов с большим кодовым расстоянием.

'''''Матрицей Адамара порядка n''''' называется <math>n*n</math> матрица <math>H</math>, элементами которой являются +1 и −1 такая, что <math>H H^T = n E_n</math>,
где <math>E_n</math> - единичная матрица размера n.

Матрица Адамара обладает следующими ''свойствами'':
* Различные строки матрицы ортогональны
* Скалярное произведение любой строки саму на себя равно n
* Умножение любой строки или столбца на -1 переводит H в другую матрицу Адамара
* Если все элементы первой строки и первого столбца равны +1, то матрица Адамара называется нормализованной

Ниже показаны примеры нормализованных матриц Адамара порядка 1,2 и 4, причем нормализованность матриц сохраняется при перестановке любых строк и столбцов, кроме первых:

<math>H_1 = (1)</math>
<math>,
H_2 =
\begin{pmatrix}
1 & 1\\
1 & -1\end{pmatrix}
</math>,
<math>,
H_4 =
\begin{pmatrix}
1 & 1 & 1 & 1\\
1 & -1 & 1 & -1\\
1 & 1 & -1 & -1\\
1 & -1 & -1 & 1\end{pmatrix}
</math>

Предполагается, что существуют матрицы Адамара порядка 1, 2 и всех порядков n, кратных 4, хотя это до сих пор еще не было доказано. Известно большое число методов построения, и наименьший порядок, для которого матрица Адамара еще не построена, равен 268 (на 1977 г.). Мы приведем метод построения Пейли, который важен для теории кодирования.

====Метод Пейли====
Это построение дает матрицы Адамара любого порядка <math>n=p+1</math>, кратного 4, где p-простое число.

'''Определение.''' Пусть p-простое число. Ненулевые квадраты чисел, приведенные по модулю p, называются квадратичными вычетами по модулю p или просто вычетами по модулю p.

Функция <math>X(i)</math>, называемая символом Лежандра, определяется на целых числах следующим образом:
* <math>X(i)=0</math>, если i кратно p;
* <math>X(i)=1</math>, если остаток от деления i на p является квадратным вычетом по модулю p;
* <math>X(i)=-1</math>, если остаток от деления i на p является невычетом.

Теперь мы построим матрицу Джекобстола <math>Q=(q_{ij}))</math>. Она представляет собой <math>(p*p)</math>-матрицу, строки и столбцы которой пронумерованы числами 0,1,..., p-1, а элементы <math>q_{ij}=X(j-i)</math>.

Пусть теперь <math>
H =
\begin{pmatrix}
1 & 1\\
1^T & Q-I\end{pmatrix}
</math>.

Таким образом, <math>H</math> представляет собой нормализованную матрицу Адамара порядка p+1, которую называют матрицей типа Пейли.

=== Математическое описание алгоритма ===

Исходные данные - это порядок генерируемой матрицы Адамара <math>n</math>, удовлетворяющее следующим свойствам:

* <math>n>0</math>;

* <math>n</math> делится на 4;

* <math>n-1</math> - простое число.

Вспомогательные данные:

* Число <math>p=n-1</math>;
* Вектор квадратичных вычетов (по модулю <math>p</math>) <math>R</math> (элементы <math>r_i</math>) размера <math>2p</math>. В этом векторе индексация идёт с нуля.

Вычисляемые данные:

* Матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>) размера <math>n \times n</math>. Индексация строчек и столбцов идёт с нуля.

Алгоритм:
:1. Строится вектор квадратичных вычетов <math>R</math>.
:: Первые <math>p</math> элементов вектора <math>R</math> (<math>i=0,1,...,p-1</math>) определяются следующим образом:
::: <math>r_i=1</math>, если <math>i \in \{1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod</math> <math> p\}</math>, <math>i=0,1,...,p-1</math>, то есть если <math>i</math> является квадратичным вычетом по модулю <math>p</math>;
::: <math>r_i=-1</math>, иначе.
::Вторые <math>p</math> элементов (<math>i=p,1,...,2p-1</math>) являются копией первых <math>p</math> элементов:
:::<math>r_i=r_{i-p}, i=p,1,...,2p-1.</math>
:2. Строится матрица Адамара <math>H</math>.
::Элементы матрицы Адамара <math>H</math> находятся следующим образом:
::: <math>h_{0j}=1, j=0,1, ... ,n-1;</math>
::: <math>h_{i0}=1, i=1,2, ... ,n-1;</math>
::: <math>h_{ij}=r_{j-i+p}, i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

=== Вычислительное ядро алгоритма ===

Вычислительное ядро алгоритма состоит из <math>(n-1) \times (n-1)</math> операций присваивания следующего вида:

:<math>h_{ij}=r_{j-i+p},</math> <math> i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

=== Макроструктура алгоритма ===

Как видно из математического описания, алгоритм основан на простейших операциях с числами, поэтому макроструктура алгоритма полностью соответствует его математическому описанию.

=== Схема реализации последовательного алгоритма ===

=== Последовательная сложность алгоритма ===

=== Информационный граф ===

=== Ресурс параллелизма алгоритма ===

=== Входные и выходные данные алгоритма ===

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

== Литература ==

Участник:Nikita/Построение матрицы Адамара

2016-10-14T12:59:46Z

Nikita: /* Общее описание алгоритма */

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O(n^2)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>1</math>
| output_data = <math>n^2</math>
}}

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Матрицы Адамара были введены в математический обиход в конце прошлого века и играют важную роль в алгебре и комбинаторике. Они находят широкое применение в теории кодирования (коды, исправляющие ошибки), теории планирования многофакторных экспериментов (блок-схемы) и других областях математики. Сравнительно недавно (в 1960 г.) было замечено, что эти матрицы могут быть использованы для построения кодов с большим кодовым расстоянием.

'''''Матрицей Адамара порядка n''''' называется <math>n*n</math> матрица <math>H</math>, элементами которой являются +1 и −1 такая, что <math>H H^T = n E_n</math>,
где <math>E_n</math> - единичная матрица размера n.

Матрица Адамара обладает следующими ''свойствами'':
* Различные строки матрицы ортогональны
* Скалярное произведение любой строки саму на себя равно n
* Умножение любой строки или столбца на -1 переводит H в другую матрицу Адамара
* Если все элементы первой строки и первого столбца равны +1, то матрица Адамара называется нормализованной

Для матриц Адамара справедлива следующая '''гипотеза''': если существует матрица Адамара порядка n, то n равно 1 или 2 или делится на 4, однако до сих пор не была доказана.

Примеры матриц (1,2,4,8)

Предполагается, что существуют матрицы Адамара всех порядков n, кратных 4, хотя это до сих пор еще не было доказано. Известно большое число методов построения, и наименьший порядок, для которого матрица Адамара еще не построена, равен 268 (на 1977 г.). Мы приведем метод построения Пейли, который важен для теории кодирования. Это построение дает матрицы Адамара любого порядка <math>n=p+1</math>, кратного 4, где p-простое число.
Сначала мы построим матрицу Джекобстола <math>Q=(q_ij)</math>. Она представляет собой (pxp)-матрицу, строки и столбцы которой пронумерованы числами 0,1,..., p-1, а элементы <math>q_ij=X(j-i)</math>

=== Математическое описание алгоритма ===

Исходные данные - это порядок генерируемой матрицы Адамара <math>n</math>, удовлетворяющее следующим свойствам:

* <math>n>0</math>;

* <math>n</math> делится на 4;

* <math>n-1</math> - простое число.

Вспомогательные данные:

* Число <math>p=n-1</math>;
* Вектор квадратичных вычетов (по модулю <math>p</math>) <math>R</math> (элементы <math>r_i</math>) размера <math>2p</math>. В этом векторе индексация идёт с нуля, вторые <math>p</math> элементов (<math>i=p,1,...,2p-1</math>) являются копией первых <math>p</math> элементов (<math>r_i=r_{i-p}</math>), которые, в свою очередь, определяются следующим образом:
** <math>r_i=1</math>, если <math>i \in \{1^2</math> <math>mod</math> <math>p, 2^2</math> <math>mod</math> <math>p, ... , (\frac{p-1}{2})^2</math> <math> mod</math> <math> p\}</math>, <math>i=0,1,...,p-1</math>, то есть если <math>i</math> является квадратичным вычетом по модулю <math>p</math>;
** <math>r_i=-1</math>, иначе.

Вычисляемые данные:

* Матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>) размера <math>n \times n</math>. Индексация строчек и столбцов идёт с нуля. Элементы находятся следующим образом:
** <math>h_{0j}=1, j=0,1, ... ,n-1;</math>
** <math>h_{i0}=1, i=1,2, ... ,n-1;</math>
** <math>h_{ij}=r_{j-i+p}, i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

Алгоритм:
# Строится вектор квадратичных вычетов <math>R</math>;
# Строится матрица Адамара <math>H</math>.

=== Вычислительное ядро алгоритма ===

Вычислительное ядро алгоритма состоит из <math>(n-1) \times (n-1)</math> операций присваивания вида <math>h_{ij}=r_{j-i+p}, i=1,2, ... ,n-1, j=1,2, ... ,n-1.</math>

=== Макроструктура алгоритма ===

=== Схема реализации последовательного алгоритма ===

=== Последовательная сложность алгоритма ===

=== Информационный граф ===

=== Ресурс параллелизма алгоритма ===

=== Входные и выходные данные алгоритма ===

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

== Литература ==

Участник:Nikita/Построение матрицы Адамара

2016-10-14T12:12:16Z

Nikita: /* Общее описание алгоритма */

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O(n^2)</math>
| pf_height = <math>O(1)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>1</math>
| output_data = <math>n^2</math>
}}

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

Матрицы Адамара были введены в математический обиход в конце прошлого века и играют важную роль в алгебре и комбинаторике. Сравнительно недавно (в 1960 г.) было замечено, что эти матрицы могут быть использованы для построения кодов с большим кодовым расстоянием.

'''''Матрицей Адамара порядка n''''' называется <math>n*n</math> матрица <math>H</math>, элементами которой являются +1 и −1 такая, что <math>H H^T = n E_n</math>,
где <math>E_n</math> - единичная матрица размера n.

Матрица Адамара обладает следующими ''свойствами'':
* Различные строки матрицы ортогональны
* Скалярное произведение любой строки саму на себя равно n
* Умножение любой строки или столбца на -1 переводит H в другую матрицу Адамара

Если все элементы первой строки и первого столбца равны +1, то матрица Адамара называется нормализованной.

Для матриц Адамара справедливо следующее утверждение: если существует матрица Адамара порядка n, то n равно 1 или 2 или делится на 4.

Примеры матриц (1,2,4,8)

=== Математическое описание алгоритма ===

Исходные данные - это порядок генерируемой матрицы Адамара <math>n</math>, удовлетворяющее следующим свойствам:

* <math>n>0</math>;

* <math>n</math> делится на 4;

* <math>n-1</math> - простое число.

Вспомогательные данные:

* Число <math>p=n-1</math>;
* Вектор вычетов <math>R</math> (элементы <math>r_i</math>) размера <math>2p</math>. В этом векторе индексация идет от нуля, первые <math>p</math> элементов образуются следующим образом:
** ыфвыв

Вычисляемые данные:

* Матрица Адамара <math>H</math> (элементы <math>h_{ij}</math>) размера <math>n \times n</math>.

=== Вычислительное ядро алгоритма ===

=== Макроструктура алгоритма ===

=== Схема реализации последовательного алгоритма ===

=== Последовательная сложность алгоритма ===

=== Информационный граф ===

=== Ресурс параллелизма алгоритма ===

=== Входные и выходные данные алгоритма ===

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

== Литература ==

Участник:Nikita/Построение матрицы Адамара

2016-10-14T09:25:35Z

Nikita:

{{algorithm
| name = Построение матрицы Адамара
| serial_complexity = <math>O(n^3)</math>
| pf_height = <math>O(n)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>\frac{n (n + 1)}{2}</math>
| output_data = <math>\frac{n (n + 1)}{2}</math>
}}

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

=== Математическое описание алгоритма ===

=== Вычислительное ядро алгоритма ===

=== Макроструктура алгоритма ===

=== Схема реализации последовательного алгоритма ===

=== Последовательная сложность алгоритма ===

=== Информационный граф ===

=== Ресурс параллелизма алгоритма ===

=== Входные и выходные данные алгоритма ===

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

== Литература ==

Участник:Nikita/Построение матрицы Адамара

2016-10-14T09:25:23Z

Nikita:

{{algorithm
| name = Построение матрица Адамара
| serial_complexity = <math>O(n^3)</math>
| pf_height = <math>O(n)</math>
| pf_width = <math>O(n^2)</math>
| input_data = <math>\frac{n (n + 1)}{2}</math>
| output_data = <math>\frac{n (n + 1)}{2}</math>
}}

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

=== Математическое описание алгоритма ===

=== Вычислительное ядро алгоритма ===

=== Макроструктура алгоритма ===

=== Схема реализации последовательного алгоритма ===

=== Последовательная сложность алгоритма ===

=== Информационный граф ===

=== Ресурс параллелизма алгоритма ===

=== Входные и выходные данные алгоритма ===

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

== Литература ==

Участник:Nikita/Построение матрицы Адамара

2016-10-14T09:23:49Z

Nikita: /* Программная реализация алгоритма */

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

=== Математическое описание алгоритма ===

=== Вычислительное ядро алгоритма ===

=== Макроструктура алгоритма ===

=== Схема реализации последовательного алгоритма ===

=== Последовательная сложность алгоритма ===

=== Информационный граф ===

=== Ресурс параллелизма алгоритма ===

=== Входные и выходные данные алгоритма ===

=== Свойства алгоритма ===

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

== Литература ==

Участник:Nikita/Построение матрицы Адамара

2016-10-14T09:06:31Z

Nikita: Новая страница: «== Свойства и структура алгоритма == === Общее описание алгоритма === === Математическое опи…»

Участник:Nikita

2016-10-14T08:31:58Z

Nikita: Создана пустая страница