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

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-12-10T17:08:53Z

Сергей:

{{assignment}}

Автор: [[U:Сергей|Герасимов Сергей]] (619)

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

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

'''Разреженная матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается плотной.

Нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:

~ есть O(n).

~ ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.

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

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

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

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

По-видимому, наиболее очевидным способом хранения произвольной разреженной матрицы является '''координатный формат''': хранятся только ненулевые элементы матрицы, и их координаты (номера строк и столбцов). При данном подходе хранение матрицы A можно обеспечить в трех одномерных массивах:

~ массив ненулевых элементов матрицы A (обозначим его как values);

~ массив номеров строк матрицы A, соответствующих элементам массива values (обозначим его как rows);

~ массив номеров столбцов матрицы A, соответствующих элементам массива values (обозначим его как cols);

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

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

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

В соответствии с рассматриваемой схемой для хранения матрицы A требуется три одномерных массива:

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его опять как values);

~ массив номеров столбцов для соответствующих элементов массива values (обозначим его как cols);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его pointer). Описание k-й строки хранится в позициях с pointer[k]-й по (pointer[k+1]–1)-ю массивов values и cols. Если pointer[k]=pointer[k+1], то k-я строка пустая. Если матрица A состоит из n строк, то длина массива pointer будет n+1.

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

Очевидно, что объем памяти, требуемый для хранения вектора pointer, значительно меньше, чем для хранения вектора rows. Более того, разреженный строчный формат обеспечивает эффективный доступ к строчкам матрицы; доступ к столбцам по прежнему затруднен (имеется ввиду, что по индексу строки мы получаем информацию из массива pointer[] о расположении ''идущих по порядку элементов этой строки'' в массиве values[], а чтобы получить все элементы какого-то конкретного столбца придется пройтись по всему вектору pointer[]). Поэтому предпочтительно использовать этот способ хранения в тех алгоритмах, в которых преобладают строчные операции.

Существует также '''разреженный столбцовый формат''', который строится аналогичным способом.

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

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

Пусть матрица размером <math>N\times M</math> содержит в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N \cdot M (N \le M)</math>

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

На входе у нас 4 массива: val(ненулевые элементы матрицы), col(номера столбцов), row(массив указателей) и vec(вектор, на который мы умножаем матрицу).

На выходе получим вектор out.

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}, \ i=\overline{0,N-1}</math>, где <math>N</math> - число строк матрицы.

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

Ядром алгоритма является вычисление сумм произведений:

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}</math>

Итого: <math>NZ</math> умножений + <math>NZ-N</math> сложений(случай с нулевыми строками рассматривать не будем).

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

Метод состоит из вычисления неполных скалярных произведений.

[[Файл:sparse.jpg|thumb|center|500px|Рис.1 Умножение разреженной матрицы на вектор]]

Элементы из массива val умножаются на элементы из массива vec с соответствующим индексом. Черным отмечены ненулевые элементы.

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

Предполагается, что матрица представлена в разреженном строчном формате.

for(i=0; i<N; i++)
{
out[i]=0;
for(j=row[i]; j<row[i+1]; j++)
{
out[i] += val[j]*vec[col[j]];
}
}

Внешний цикл - цикл по элементам выходного вектора. Внутренний - цикл по строкам разреженной матрицы.
Во внутреннем цикле реализовано накопление сумм произведений в выходной элемент.
Индекс ''j'' показывает с какого по какой элемент нужно считать из ''val'' (вектор с ненулевыми значениями матрицы), а также позволяет определить в каких столбцах расположены эти значения в матрице (с помощью вектора ''col'').
Минимальное и максимальное значение ''j'' узнается из вектора ''row''.

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

<math>\bullet \ NZ</math> умножений

<math>\bullet \ NZ-N</math> сложений.

Всего <math>2NZ-N</math> операций, где <math>NZ</math> - количество ненулевых элементов, а <math>N</math> - количество строк в матрице.

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

Опишем граф алгоритма.

Граф алгоритма состоит из двух групп вершин, расположенных в целочисленных узлах двух областей одной размерности.

'''Первая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a \cdot b</math>. Координаты области следующие:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math> k </math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>. (На рисунке вместо обозначения ''row'' использовано обозначение ''r'').

Результаты операции - '''промежуточные''' данные алгоритма.

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a + b</math>.
Координаты области таковы:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>.

Результат операции:

<math>\cdot</math> при <math>j < k - 1</math> является '''промежуточным''' данным алгоритма;

<math>\cdot</math> при <math>j = k - 1</math> является '''выходным''' данным <math>out[i]</math>.

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

[[Файл:new_sparse.png|thumb|center|1000px|Рис.2 Умножение разреженной матрицы на вектор. Информационный граф]]

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

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

~ 1 ярус умножений

~ <math>Z-1</math> операция сложения, где Z - максимальное число ненулевых элементов в строке.

Максимальное число требуемых процессоров - NZ.

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

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

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его как val);

~ массив номеров столбцов для соответствующих элементов массива val (обозначим его как col);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его row);

~ вектор, на который будет умножаться матрица (обозначим его vec).

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

Для матрицы размером <math>N\times M</math>, содержащей в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N\cdot M (N \le M)</math>,

~ вектор val - NZ элементов;

~ вектор col - NZ элементов;

~ вектор row - N+1 элемент;

~ вектор vec - M элементов.

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

Вектор out размером N.

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

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

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

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

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Проведём исследование масштабируемости параллельной реализации умножения разреженной матрицы на вектор. Исследование проводилось на вычислительном комплексе [http://hpc.cmc.msu.ru/bgp Blue Gene/P]<ref> Blue Gene/P http://hpc.cmc.msu.ru/bgp</ref>. Вычисления проводились с помощью следующего программного [https://www.dropbox.com/s/gx0s5r0jg58y8wa/main.c кода]<ref>Sparse matrix-vector MPI multiplication </ref>.
Матрицы генерировались случайным образом. Размерность матрицы в рассматриваемом эксперименте роли не играла, так генерировался сразу строчный формат хранения матрицы.

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

[[Файл:plot_more_points.png|thumb|center|1000px|Рис.3 Умножение разреженной матрицы на вектор. Масштабируемость]]

На рисунке ниже изображен график эффективности в зависимости от числа процессоров и размера задачи. Можно заметить небольшой всплеск эффективности при использовании 64 процессоров.

[[Файл:plot_eff_new.png|thumb|center|1000px|Рис.4 Умножение разреженной матрицы на вектор. Эффективность]]

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

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

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

Эффективная работа с разреженными матрицами реализована во многих библиотеках, например, [https://software.intel.com/en-us/intel-mkl Intel Math Kernel Library], базирующуюся на библиотеках BLAS и LAPACK, также математический пакет [http://matlab.ru/products/matlab Matlab] имеет собственную реализацию.

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

[1] Писсанецки С. Технология разреженных матриц. - М.: Мир, 1988. — 410 с.

[2] https://software.intel.com/sites/default/files/m/d/4/1/d/8/LW_SparseMM_ppt.pdf

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-12-10T17:01:06Z

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

Автор: [[U:Сергей|Герасимов Сергей]] (619)

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

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

'''Разреженная матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается плотной.

Нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:

~ есть O(n).

~ ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.

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

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

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

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

По-видимому, наиболее очевидным способом хранения произвольной разреженной матрицы является '''координатный формат''': хранятся только ненулевые элементы матрицы, и их координаты (номера строк и столбцов). При данном подходе хранение матрицы A можно обеспечить в трех одномерных массивах:

~ массив ненулевых элементов матрицы A (обозначим его как values);

~ массив номеров строк матрицы A, соответствующих элементам массива values (обозначим его как rows);

~ массив номеров столбцов матрицы A, соответствующих элементам массива values (обозначим его как cols);

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

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

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

В соответствии с рассматриваемой схемой для хранения матрицы A требуется три одномерных массива:

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его опять как values);

~ массив номеров столбцов для соответствующих элементов массива values (обозначим его как cols);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его pointer). Описание k-й строки хранится в позициях с pointer[k]-й по (pointer[k+1]–1)-ю массивов values и cols. Если pointer[k]=pointer[k+1], то k-я строка пустая. Если матрица A состоит из n строк, то длина массива pointer будет n+1.

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

Очевидно, что объем памяти, требуемый для хранения вектора pointer, значительно меньше, чем для хранения вектора rows. Более того, разреженный строчный формат обеспечивает эффективный доступ к строчкам матрицы; доступ к столбцам по прежнему затруднен (имеется ввиду, что по индексу строки мы получаем информацию из массива pointer[] о расположении ''идущих по порядку элементов этой строки'' в массиве values[], а чтобы получить все элементы какого-то конкретного столбца придется пройтись по всему вектору pointer[]). Поэтому предпочтительно использовать этот способ хранения в тех алгоритмах, в которых преобладают строчные операции.

Существует также '''разреженный столбцовый формат''', который строится аналогичным способом.

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

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

Пусть матрица размером <math>N\times M</math> содержит в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N \cdot M (N \le M)</math>

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

На входе у нас 4 массива: val(ненулевые элементы матрицы), col(номера столбцов), row(массив указателей) и vec(вектор, на который мы умножаем матрицу).

На выходе получим вектор out.

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}, \ i=\overline{0,N-1}</math>, где <math>N</math> - число строк матрицы.

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

Ядром алгоритма является вычисление сумм произведений:

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}</math>

Итого: <math>NZ</math> умножений + <math>NZ-N</math> сложений(случай с нулевыми строками рассматривать не будем).

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

Метод состоит из вычисления неполных скалярных произведений.

[[Файл:sparse.jpg|thumb|center|500px|Рис.1 Умножение разреженной матрицы на вектор]]

Элементы из массива val умножаются на элементы из массива vec с соответствующим индексом. Черным отмечены ненулевые элементы.

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

Предполагается, что матрица представлена в разреженном строчном формате.

for(i=0; i<N; i++)
{
out[i]=0;
for(j=row[i]; j<row[i+1]; j++)
{
out[i] += val[j]*vec[col[j]];
}
}

Внешний цикл - цикл по элементам выходного вектора. Внутренний - цикл по строкам разреженной матрицы.
Во внутреннем цикле реализовано накопление сумм произведений в выходной элемент.
Индекс ''j'' показывает с какого по какой элемент нужно считать из ''val'' (вектор с ненулевыми значениями матрицы), а также позволяет определить в каких столбцах расположены эти значения в матрице (с помощью вектора ''col'').
Минимальное и максимальное значение ''j'' узнается из вектора ''row''.

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

<math>\bullet \ NZ</math> умножений

<math>\bullet \ NZ-N</math> сложений.

Всего <math>2NZ-N</math> операций, где <math>NZ</math> - количество ненулевых элементов, а <math>N</math> - количество строк в матрице.

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

Опишем граф алгоритма.

Граф алгоритма состоит из двух групп вершин, расположенных в целочисленных узлах двух областей одной размерности.

'''Первая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a \cdot b</math>. Координаты области следующие:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math> k </math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>. (На рисунке вместо обозначения ''row'' использовано обозначение ''r'').

Результаты операции - '''промежуточные''' данные алгоритма.

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a + b</math>.
Координаты области таковы:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>.

Результат операции:

<math>\cdot</math> при <math>j < k - 1</math> является '''промежуточным''' данным алгоритма;

<math>\cdot</math> при <math>j = k - 1</math> является '''выходным''' данным <math>out[i]</math>.

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

[[Файл:new_sparse.png|thumb|center|1000px|Рис.2 Умножение разреженной матрицы на вектор. Информационный граф]]

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

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

~ 1 ярус умножений

~ <math>Z-1</math> операция сложения, где Z - максимальное число ненулевых элементов в строке.

Максимальное число требуемых процессоров - NZ.

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

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

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его как val);

~ массив номеров столбцов для соответствующих элементов массива val (обозначим его как col);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его row);

~ вектор, на который будет умножаться матрица (обозначим его vec).

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

Для матрицы размером <math>N\times M</math>, содержащей в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N\cdot M (N \le M)</math>,

~ вектор val - NZ элементов;

~ вектор col - NZ элементов;

~ вектор row - N+1 элемент;

~ вектор vec - M элементов.

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

Вектор out размером N.

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

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

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

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

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Проведём исследование масштабируемости параллельной реализации умножения разреженной матрицы на вектор. Исследование проводилось на вычислительном комплексе [http://hpc.cmc.msu.ru/bgp Blue Gene/P]<ref> Blue Gene/P http://hpc.cmc.msu.ru/bgp</ref>. Вычисления проводились с помощью следующего программного [https://www.dropbox.com/s/gx0s5r0jg58y8wa/main.c кода]<ref>Sparse matrix-vector MPI multiplication </ref>.
Матрицы генерировались случайным образом. Размерность матрицы в рассматриваемом эксперименте роли не играла, так генерировался сразу строчный формат хранения матрицы.

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

[[Файл:plot_more_points.png|thumb|center|1000px|Рис.3 Умножение разреженной матрицы на вектор. Масштабируемость]]

На рисунке ниже изображен график эффективности в зависимости от числа процессоров и размера задачи. Можно заметить небольшой всплеск эффективности при использовании 64 процессоров.

[[Файл:plot_eff_new.png|thumb|center|1000px|Рис.4 Умножение разреженной матрицы на вектор. Эффективность]]

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

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

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

Эффективная работа с разреженными матрицами реализована во многих библиотеках, например, [https://software.intel.com/en-us/intel-mkl Intel Math Kernel Library], базирующуюся на библиотеках BLAS и LAPACK, также математический пакет [http://matlab.ru/products/matlab Matlab] имеет собственную реализацию.

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

[1] Писсанецки С. Технология разреженных матриц. - М.: Мир, 1988. — 410 с.

[2] https://software.intel.com/sites/default/files/m/d/4/1/d/8/LW_SparseMM_ppt.pdf

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-12-10T16:43:10Z

Сергей: /* Свойства алгоритма */

Автор: [[U:Сергей|Герасимов Сергей]] (619)

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

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

'''Разреженная матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается плотной.

Нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:

~ есть O(n).

~ ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.

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

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

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

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

По-видимому, наиболее очевидным способом хранения произвольной разреженной матрицы является '''координатный формат''': хранятся только ненулевые элементы матрицы, и их координаты (номера строк и столбцов). При данном подходе хранение матрицы A можно обеспечить в трех одномерных массивах:

~ массив ненулевых элементов матрицы A (обозначим его как values);

~ массив номеров строк матрицы A, соответствующих элементам массива values (обозначим его как rows);

~ массив номеров столбцов матрицы A, соответствующих элементам массива values (обозначим его как cols);

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

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

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

В соответствии с рассматриваемой схемой для хранения матрицы A требуется три одномерных массива:

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его опять как values);

~ массив номеров столбцов для соответствующих элементов массива values (обозначим его как cols);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его pointer). Описание k-й строки хранится в позициях с pointer[k]-й по (pointer[k+1]–1)-ю массивов values и cols. Если pointer[k]=pointer[k+1], то k-я строка пустая. Если матрица A состоит из n строк, то длина массива pointer будет n+1.

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

Очевидно, что объем памяти, требуемый для хранения вектора pointer, значительно меньше, чем для хранения вектора rows. Более того, разреженный строчный формат обеспечивает эффективный доступ к строчкам матрицы; доступ к столбцам по прежнему затруднен (имеется ввиду, что по индексу строки мы получаем информацию из массива pointer[] о расположении ''идущих по порядку элементов этой строки'' в массиве values[], а чтобы получить все элементы какого-то конкретного столбца придется пройтись по всему вектору pointer[]). Поэтому предпочтительно использовать этот способ хранения в тех алгоритмах, в которых преобладают строчные операции.

Существует также '''разреженный столбцовый формат''', который строится аналогичным способом.

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

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

Пусть матрица размером <math>N\times M</math> содержит в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N \cdot M (N \le M)</math>

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

На входе у нас 4 массива: val(ненулевые элементы матрицы), col(номера столбцов), row(массив указателей) и vec(вектор, на который мы умножаем матрицу).

На выходе получим вектор out.

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}, \ i=\overline{0,N-1}</math>, где <math>N</math> - число строк матрицы.

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

Ядром алгоритма является вычисление сумм произведений:

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}</math>

Итого: <math>NZ</math> умножений + <math>NZ-N</math> сложений(случай с нулевыми строками рассматривать не будем).

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

Метод состоит из вычисления неполных скалярных произведений.

[[Файл:sparse.jpg|thumb|center|500px|Рис.1 Умножение разреженной матрицы на вектор]]

Элементы из массива val умножаются на элементы из массива vec с соответствующим индексом. Черным отмечены ненулевые элементы.

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

Предполагается, что матрица представлена в разреженном строчном формате.

for(i=0; i<N; i++)
{
out[i]=0;
for(j=row[i]; j<row[i+1]; j++)
{
out[i] += val[j]*vec[col[j]];
}
}

Внешний цикл - цикл по элементам выходного вектора. Внутренний - цикл по строкам разреженной матрицы.
Во внутреннем цикле реализовано накопление сумм произведений в выходной элемент.
Индекс ''j'' показывает с какого по какой элемент нужно считать из ''val'' (вектор с ненулевыми значениями матрицы), а также позволяет определить в каких столбцах расположены эти значения в матрице (с помощью вектора ''col'').
Минимальное и максимальное значение ''j'' узнается из вектора ''row''.

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

<math>\bullet \ NZ</math> умножений

<math>\bullet \ NZ-N</math> сложений.

Всего <math>2NZ-N</math> операций, где <math>NZ</math> - количество ненулевых элементов, а <math>N</math> - количество строк в матрице.

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

Опишем граф алгоритма.

Граф алгоритма состоит из двух групп вершин, расположенных в целочисленных узлах двух областей одной размерности.

'''Первая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a \cdot b</math>. Координаты области следующие:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math> k </math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>. (На рисунке вместо обозначения ''row'' использовано обозначение ''r'').

Результаты операции - '''промежуточные''' данные алгоритма.

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a + b</math>.
Координаты области таковы:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>.

Результат операции:

<math>\cdot</math> при <math>j < k - 1</math> является '''промежуточным''' данным алгоритма;

<math>\cdot</math> при <math>j = k - 1</math> является '''выходным''' данным <math>out[i]</math>.

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

[[Файл:new_sparse.png|thumb|center|1000px|Рис.2 Умножение разреженной матрицы на вектор. Информационный граф]]

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

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

~ 1 ярус умножений

~ <math>Z-1</math> операция сложения, где Z - максимальное число ненулевых элементов в строке.

Максимальное число требуемых процессоров - NZ.

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

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

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его как val);

~ массив номеров столбцов для соответствующих элементов массива val (обозначим его как col);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его row);

~ вектор, на который будет умножаться матрица (обозначим его vec).

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

Для матрицы размером <math>N\times M</math>, содержащей в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N\cdot M (N \le M)</math>,

~ вектор val - NZ элементов;

~ вектор col - NZ элементов;

~ вектор row - N+1 элемент;

~ вектор vec - M элементов.

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

Вектор out размером N.

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

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

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

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

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Проведём исследование масштабируемости параллельной реализации умножения разреженной матрицы на вектор. Исследование проводилось на вычислительном комплексе [http://hpc.cmc.msu.ru/bgp Blue Gene/P]<ref> Blue Gene/P http://hpc.cmc.msu.ru/bgp</ref>. Вычисления проводились с помощью следующего программного [https://www.dropbox.com/s/gx0s5r0jg58y8wa/main.c кода]<ref>Sparse matrix-vector MPI multiplication </ref>.
Матрицы генерировались случайным образом.

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

[[Файл:plot_more_points.png|thumb|center|1000px|Рис.3 Умножение разреженной матрицы на вектор. Масштабируемость]]

На рисунке ниже изображен график эффективности в зависимости от числа процессоров и размера задачи. Можно заметить небольшой всплеск эффективности при использовании 64 процессоров.

[[Файл:plot_eff_new.png|thumb|center|1000px|Рис.4 Умножение разреженной матрицы на вектор. Эффективность]]

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

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

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

Эффективная работа с разреженными матрицами реализована во многих библиотеках, например, [https://software.intel.com/en-us/intel-mkl Intel Math Kernel Library], базирующуюся на библиотеках BLAS и LAPACK, также математический пакет [http://matlab.ru/products/matlab Matlab] имеет собственную реализацию.

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

[1] Писсанецки С. Технология разреженных матриц. - М.: Мир, 1988. — 410 с.

[2] https://software.intel.com/sites/default/files/m/d/4/1/d/8/LW_SparseMM_ppt.pdf

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-12-10T16:33:29Z

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

Автор: [[U:Сергей|Герасимов Сергей]] (619)

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

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

'''Разреженная матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается плотной.

Нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:

~ есть O(n).

~ ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.

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

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

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

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

По-видимому, наиболее очевидным способом хранения произвольной разреженной матрицы является '''координатный формат''': хранятся только ненулевые элементы матрицы, и их координаты (номера строк и столбцов). При данном подходе хранение матрицы A можно обеспечить в трех одномерных массивах:

~ массив ненулевых элементов матрицы A (обозначим его как values);

~ массив номеров строк матрицы A, соответствующих элементам массива values (обозначим его как rows);

~ массив номеров столбцов матрицы A, соответствующих элементам массива values (обозначим его как cols);

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

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

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

В соответствии с рассматриваемой схемой для хранения матрицы A требуется три одномерных массива:

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его опять как values);

~ массив номеров столбцов для соответствующих элементов массива values (обозначим его как cols);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его pointer). Описание k-й строки хранится в позициях с pointer[k]-й по (pointer[k+1]–1)-ю массивов values и cols. Если pointer[k]=pointer[k+1], то k-я строка пустая. Если матрица A состоит из n строк, то длина массива pointer будет n+1.

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

Очевидно, что объем памяти, требуемый для хранения вектора pointer, значительно меньше, чем для хранения вектора rows. Более того, разреженный строчный формат обеспечивает эффективный доступ к строчкам матрицы; доступ к столбцам по прежнему затруднен (имеется ввиду, что по индексу строки мы получаем информацию из массива pointer[] о расположении ''идущих по порядку элементов этой строки'' в массиве values[], а чтобы получить все элементы какого-то конкретного столбца придется пройтись по всему вектору pointer[]). Поэтому предпочтительно использовать этот способ хранения в тех алгоритмах, в которых преобладают строчные операции.

Существует также '''разреженный столбцовый формат''', который строится аналогичным способом.

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

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

Пусть матрица размером <math>N\times M</math> содержит в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N \cdot M (N \le M)</math>

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

На входе у нас 4 массива: val(ненулевые элементы матрицы), col(номера столбцов), row(массив указателей) и vec(вектор, на который мы умножаем матрицу).

На выходе получим вектор out.

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}, \ i=\overline{0,N-1}</math>, где <math>N</math> - число строк матрицы.

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

Ядром алгоритма является вычисление сумм произведений:

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}</math>

Итого: <math>NZ</math> умножений + <math>NZ-N</math> сложений(случай с нулевыми строками рассматривать не будем).

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

Метод состоит из вычисления неполных скалярных произведений.

[[Файл:sparse.jpg|thumb|center|500px|Рис.1 Умножение разреженной матрицы на вектор]]

Элементы из массива val умножаются на элементы из массива vec с соответствующим индексом. Черным отмечены ненулевые элементы.

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

Предполагается, что матрица представлена в разреженном строчном формате.

for(i=0; i<N; i++)
{
out[i]=0;
for(j=row[i]; j<row[i+1]; j++)
{
out[i] += val[j]*vec[col[j]];
}
}

Внешний цикл - цикл по элементам выходного вектора. Внутренний - цикл по строкам разреженной матрицы.
Во внутреннем цикле реализовано накопление сумм произведений в выходной элемент.
Индекс ''j'' показывает с какого по какой элемент нужно считать из ''val'' (вектор с ненулевыми значениями матрицы), а также позволяет определить в каких столбцах расположены эти значения в матрице (с помощью вектора ''col'').
Минимальное и максимальное значение ''j'' узнается из вектора ''row''.

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

<math>\bullet \ NZ</math> умножений

<math>\bullet \ NZ-N</math> сложений.

Всего <math>2NZ-N</math> операций, где <math>NZ</math> - количество ненулевых элементов, а <math>N</math> - количество строк в матрице.

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

Опишем граф алгоритма.

Граф алгоритма состоит из двух групп вершин, расположенных в целочисленных узлах двух областей одной размерности.

'''Первая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a \cdot b</math>. Координаты области следующие:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math> k </math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>. (На рисунке вместо обозначения ''row'' использовано обозначение ''r'').

Результаты операции - '''промежуточные''' данные алгоритма.

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a + b</math>.
Координаты области таковы:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>.

Результат операции:

<math>\cdot</math> при <math>j < k - 1</math> является '''промежуточным''' данным алгоритма;

<math>\cdot</math> при <math>j = k - 1</math> является '''выходным''' данным <math>out[i]</math>.

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

[[Файл:new_sparse.png|thumb|center|1000px|Рис.2 Умножение разреженной матрицы на вектор. Информационный граф]]

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

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

~ 1 ярус умножений

~ <math>Z-1</math> операция сложения, где Z - максимальное число ненулевых элементов в строке.

Максимальное число требуемых процессоров - NZ.

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

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

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его как val);

~ массив номеров столбцов для соответствующих элементов массива val (обозначим его как col);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его row);

~ вектор, на который будет умножаться матрица (обозначим его vec).

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

Для матрицы размером <math>N\times M</math>, содержащей в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N\cdot M (N \le M)</math>,

~ вектор val - NZ элементов;

~ вектор col - NZ элементов;

~ вектор row - N+1 элемент;

~ вектор vec - M элементов.

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

Вектор out размером N.

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

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

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

Данный алгоритм обладает свойством детерминированности.

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Проведём исследование масштабируемости параллельной реализации умножения разреженной матрицы на вектор. Исследование проводилось на вычислительном комплексе [http://hpc.cmc.msu.ru/bgp Blue Gene/P]<ref> Blue Gene/P http://hpc.cmc.msu.ru/bgp</ref>. Вычисления проводились с помощью следующего программного [https://www.dropbox.com/s/gx0s5r0jg58y8wa/main.c кода]<ref>Sparse matrix-vector MPI multiplication </ref>.
Матрицы генерировались случайным образом.

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

[[Файл:plot_more_points.png|thumb|center|1000px|Рис.3 Умножение разреженной матрицы на вектор. Масштабируемость]]

На рисунке ниже изображен график эффективности в зависимости от числа процессоров и размера задачи. Можно заметить небольшой всплеск эффективности при использовании 64 процессоров.

[[Файл:plot_eff_new.png|thumb|center|1000px|Рис.4 Умножение разреженной матрицы на вектор. Эффективность]]

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

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

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

Эффективная работа с разреженными матрицами реализована во многих библиотеках, например, [https://software.intel.com/en-us/intel-mkl Intel Math Kernel Library], базирующуюся на библиотеках BLAS и LAPACK, также математический пакет [http://matlab.ru/products/matlab Matlab] имеет собственную реализацию.

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

[1] Писсанецки С. Технология разреженных матриц. - М.: Мир, 1988. — 410 с.

[2] https://software.intel.com/sites/default/files/m/d/4/1/d/8/LW_SparseMM_ppt.pdf

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-12-10T16:31:54Z

Сергей: /* Вычислительное ядро алгоритма */

Автор: [[U:Сергей|Герасимов Сергей]] (619)

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

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

'''Разреженная матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается плотной.

Нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:

~ есть O(n).

~ ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.

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

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

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

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

По-видимому, наиболее очевидным способом хранения произвольной разреженной матрицы является '''координатный формат''': хранятся только ненулевые элементы матрицы, и их координаты (номера строк и столбцов). При данном подходе хранение матрицы A можно обеспечить в трех одномерных массивах:

~ массив ненулевых элементов матрицы A (обозначим его как values);

~ массив номеров строк матрицы A, соответствующих элементам массива values (обозначим его как rows);

~ массив номеров столбцов матрицы A, соответствующих элементам массива values (обозначим его как cols);

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

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

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

В соответствии с рассматриваемой схемой для хранения матрицы A требуется три одномерных массива:

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его опять как values);

~ массив номеров столбцов для соответствующих элементов массива values (обозначим его как cols);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его pointer). Описание k-й строки хранится в позициях с pointer[k]-й по (pointer[k+1]–1)-ю массивов values и cols. Если pointer[k]=pointer[k+1], то k-я строка пустая. Если матрица A состоит из n строк, то длина массива pointer будет n+1.

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

Очевидно, что объем памяти, требуемый для хранения вектора pointer, значительно меньше, чем для хранения вектора rows. Более того, разреженный строчный формат обеспечивает эффективный доступ к строчкам матрицы; доступ к столбцам по прежнему затруднен (имеется ввиду, что по индексу строки мы получаем информацию из массива pointer[] о расположении ''идущих по порядку элементов этой строки'' в массиве values[], а чтобы получить все элементы какого-то конкретного столбца придется пройтись по всему вектору pointer[]). Поэтому предпочтительно использовать этот способ хранения в тех алгоритмах, в которых преобладают строчные операции.

Существует также '''разреженный столбцовый формат''', который строится аналогичным способом.

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

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

Пусть матрица размером <math>N\times M</math> содержит в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N \cdot M (N \le M)</math>

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

На входе у нас 4 массива: val(ненулевые элементы матрицы), col(номера столбцов), row(массив указателей) и vec(вектор, на который мы умножаем матрицу).

На выходе получим вектор out.

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}, \ i=\overline{0,N-1}</math>, где <math>N</math> - число строк матрицы.

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

Ядром алгоритма является вычисление сумм произведений:

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}</math>

Итого: <math>NZ</math> умножений + <math>NZ-N</math> сложений(случай с нулевыми строками рассматривать не будем).

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

Метод состоит из вычисления неполных скалярных произведений.

[[Файл:sparse.jpg|thumb|center|500px|Рис.1 Умножение разреженной матрицы на вектор]]

Элементы из массива val умножаются на элементы из массива vec с соответствующим индексом. Черным отмечены ненулевые элементы.

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

Предполагается, что матрица представлена в разреженном строчном формате.

for(i=0; i<N; i++)
{
out[i]=0;
for(j=row[i]; j<row[i+1]; j++)
{
out[i] += val[j]*vec[col[j]];
}
}

Внешний цикл - цикл по элементам выходного вектора. Внутренний - цикл по строкам разреженной матрицы.
Во внутреннем цикле реализовано накопление сумм произведений в выходной элемент.
Индекс ''j'' показывает с какого по какой элемент нужно считать из ''val'' (вектор с ненулевыми значениями матрицы), а также позволяет определить в каких столбцах расположены эти значения в матрице (с помощью вектора ''col'').
Минимальное и максимальное значение ''j'' узнается из вектора ''row''.

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

<math>\bullet \ NZ</math> умножений

<math>\bullet \ x</math> сложений(<math>NZ-N<x<NZ-1</math>).

Всего <math>2NZ</math> операций, где <math>NZ</math> - количество ненулевых элементов.

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

Опишем граф алгоритма.

Граф алгоритма состоит из двух групп вершин, расположенных в целочисленных узлах двух областей одной размерности.

'''Первая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a \cdot b</math>. Координаты области следующие:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math> k </math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>. (На рисунке вместо обозначения ''row'' использовано обозначение ''r'').

Результаты операции - '''промежуточные''' данные алгоритма.

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a + b</math>.
Координаты области таковы:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>.

Результат операции:

<math>\cdot</math> при <math>j < k - 1</math> является '''промежуточным''' данным алгоритма;

<math>\cdot</math> при <math>j = k - 1</math> является '''выходным''' данным <math>out[i]</math>.

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

[[Файл:new_sparse.png|thumb|center|1000px|Рис.2 Умножение разреженной матрицы на вектор. Информационный граф]]

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

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

~ 1 ярус умножений

~ <math>Z-1</math> операция сложения, где Z - максимальное число ненулевых элементов в строке.

Максимальное число требуемых процессоров - NZ.

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

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

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его как val);

~ массив номеров столбцов для соответствующих элементов массива val (обозначим его как col);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его row);

~ вектор, на который будет умножаться матрица (обозначим его vec).

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

Для матрицы размером <math>N\times M</math>, содержащей в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N\cdot M (N \le M)</math>,

~ вектор val - NZ элементов;

~ вектор col - NZ элементов;

~ вектор row - N+1 элемент;

~ вектор vec - M элементов.

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

Вектор out размером N.

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

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

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

Данный алгоритм обладает свойством детерминированности.

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Проведём исследование масштабируемости параллельной реализации умножения разреженной матрицы на вектор. Исследование проводилось на вычислительном комплексе [http://hpc.cmc.msu.ru/bgp Blue Gene/P]<ref> Blue Gene/P http://hpc.cmc.msu.ru/bgp</ref>. Вычисления проводились с помощью следующего программного [https://www.dropbox.com/s/gx0s5r0jg58y8wa/main.c кода]<ref>Sparse matrix-vector MPI multiplication </ref>.
Матрицы генерировались случайным образом.

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

[[Файл:plot_more_points.png|thumb|center|1000px|Рис.3 Умножение разреженной матрицы на вектор. Масштабируемость]]

На рисунке ниже изображен график эффективности в зависимости от числа процессоров и размера задачи. Можно заметить небольшой всплеск эффективности при использовании 64 процессоров.

[[Файл:plot_eff_new.png|thumb|center|1000px|Рис.4 Умножение разреженной матрицы на вектор. Эффективность]]

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

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

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

Эффективная работа с разреженными матрицами реализована во многих библиотеках, например, [https://software.intel.com/en-us/intel-mkl Intel Math Kernel Library], базирующуюся на библиотеках BLAS и LAPACK, также математический пакет [http://matlab.ru/products/matlab Matlab] имеет собственную реализацию.

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

[1] Писсанецки С. Технология разреженных матриц. - М.: Мир, 1988. — 410 с.

[2] https://software.intel.com/sites/default/files/m/d/4/1/d/8/LW_SparseMM_ppt.pdf

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-12-10T16:29:09Z

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

Автор: [[U:Сергей|Герасимов Сергей]] (619)

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

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

'''Разреженная матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается плотной.

Нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:

~ есть O(n).

~ ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.

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

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

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

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

По-видимому, наиболее очевидным способом хранения произвольной разреженной матрицы является '''координатный формат''': хранятся только ненулевые элементы матрицы, и их координаты (номера строк и столбцов). При данном подходе хранение матрицы A можно обеспечить в трех одномерных массивах:

~ массив ненулевых элементов матрицы A (обозначим его как values);

~ массив номеров строк матрицы A, соответствующих элементам массива values (обозначим его как rows);

~ массив номеров столбцов матрицы A, соответствующих элементам массива values (обозначим его как cols);

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

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

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

В соответствии с рассматриваемой схемой для хранения матрицы A требуется три одномерных массива:

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его опять как values);

~ массив номеров столбцов для соответствующих элементов массива values (обозначим его как cols);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его pointer). Описание k-й строки хранится в позициях с pointer[k]-й по (pointer[k+1]–1)-ю массивов values и cols. Если pointer[k]=pointer[k+1], то k-я строка пустая. Если матрица A состоит из n строк, то длина массива pointer будет n+1.

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

Очевидно, что объем памяти, требуемый для хранения вектора pointer, значительно меньше, чем для хранения вектора rows. Более того, разреженный строчный формат обеспечивает эффективный доступ к строчкам матрицы; доступ к столбцам по прежнему затруднен (имеется ввиду, что по индексу строки мы получаем информацию из массива pointer[] о расположении ''идущих по порядку элементов этой строки'' в массиве values[], а чтобы получить все элементы какого-то конкретного столбца придется пройтись по всему вектору pointer[]). Поэтому предпочтительно использовать этот способ хранения в тех алгоритмах, в которых преобладают строчные операции.

Существует также '''разреженный столбцовый формат''', который строится аналогичным способом.

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

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

Пусть матрица размером <math>N\times M</math> содержит в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N \cdot M (N \le M)</math>

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

На входе у нас 4 массива: val(ненулевые элементы матрицы), col(номера столбцов), row(массив указателей) и vec(вектор, на который мы умножаем матрицу).

На выходе получим вектор out.

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}, \ i=\overline{0,N-1}</math>, где <math>N</math> - число строк матрицы.

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

Ядром алгоритма является вычисление сумм произведений:

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}</math>

Итого: <math>NZ</math> умножений + <math>x</math> сложений(<math>NZ-N<x<NZ-1</math>).

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

Метод состоит из вычисления неполных скалярных произведений.

[[Файл:sparse.jpg|thumb|center|500px|Рис.1 Умножение разреженной матрицы на вектор]]

Элементы из массива val умножаются на элементы из массива vec с соответствующим индексом. Черным отмечены ненулевые элементы.

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

Предполагается, что матрица представлена в разреженном строчном формате.

for(i=0; i<N; i++)
{
out[i]=0;
for(j=row[i]; j<row[i+1]; j++)
{
out[i] += val[j]*vec[col[j]];
}
}

Внешний цикл - цикл по элементам выходного вектора. Внутренний - цикл по строкам разреженной матрицы.
Во внутреннем цикле реализовано накопление сумм произведений в выходной элемент.
Индекс ''j'' показывает с какого по какой элемент нужно считать из ''val'' (вектор с ненулевыми значениями матрицы), а также позволяет определить в каких столбцах расположены эти значения в матрице (с помощью вектора ''col'').
Минимальное и максимальное значение ''j'' узнается из вектора ''row''.

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

<math>\bullet \ NZ</math> умножений

<math>\bullet \ x</math> сложений(<math>NZ-N<x<NZ-1</math>).

Всего <math>2NZ</math> операций, где <math>NZ</math> - количество ненулевых элементов.

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

Опишем граф алгоритма.

Граф алгоритма состоит из двух групп вершин, расположенных в целочисленных узлах двух областей одной размерности.

'''Первая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a \cdot b</math>. Координаты области следующие:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math> k </math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>. (На рисунке вместо обозначения ''row'' использовано обозначение ''r'').

Результаты операции - '''промежуточные''' данные алгоритма.

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a + b</math>.
Координаты области таковы:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>.

Результат операции:

<math>\cdot</math> при <math>j < k - 1</math> является '''промежуточным''' данным алгоритма;

<math>\cdot</math> при <math>j = k - 1</math> является '''выходным''' данным <math>out[i]</math>.

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

[[Файл:new_sparse.png|thumb|center|1000px|Рис.2 Умножение разреженной матрицы на вектор. Информационный граф]]

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

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

~ 1 ярус умножений

~ <math>Z-1</math> операция сложения, где Z - максимальное число ненулевых элементов в строке.

Максимальное число требуемых процессоров - NZ.

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

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

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его как val);

~ массив номеров столбцов для соответствующих элементов массива val (обозначим его как col);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его row);

~ вектор, на который будет умножаться матрица (обозначим его vec).

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

Для матрицы размером <math>N\times M</math>, содержащей в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N\cdot M (N \le M)</math>,

~ вектор val - NZ элементов;

~ вектор col - NZ элементов;

~ вектор row - N+1 элемент;

~ вектор vec - M элементов.

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

Вектор out размером N.

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

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

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

Данный алгоритм обладает свойством детерминированности.

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Проведём исследование масштабируемости параллельной реализации умножения разреженной матрицы на вектор. Исследование проводилось на вычислительном комплексе [http://hpc.cmc.msu.ru/bgp Blue Gene/P]<ref> Blue Gene/P http://hpc.cmc.msu.ru/bgp</ref>. Вычисления проводились с помощью следующего программного [https://www.dropbox.com/s/gx0s5r0jg58y8wa/main.c кода]<ref>Sparse matrix-vector MPI multiplication </ref>.
Матрицы генерировались случайным образом.

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

[[Файл:plot_more_points.png|thumb|center|1000px|Рис.3 Умножение разреженной матрицы на вектор. Масштабируемость]]

На рисунке ниже изображен график эффективности в зависимости от числа процессоров и размера задачи. Можно заметить небольшой всплеск эффективности при использовании 64 процессоров.

[[Файл:plot_eff_new.png|thumb|center|1000px|Рис.4 Умножение разреженной матрицы на вектор. Эффективность]]

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

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

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

Эффективная работа с разреженными матрицами реализована во многих библиотеках, например, [https://software.intel.com/en-us/intel-mkl Intel Math Kernel Library], базирующуюся на библиотеках BLAS и LAPACK, также математический пакет [http://matlab.ru/products/matlab Matlab] имеет собственную реализацию.

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

[1] Писсанецки С. Технология разреженных матриц. - М.: Мир, 1988. — 410 с.

[2] https://software.intel.com/sites/default/files/m/d/4/1/d/8/LW_SparseMM_ppt.pdf

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-12-10T16:26:21Z

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

Автор: [[U:Сергей|Герасимов Сергей]] (619)

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

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

'''Разреженная матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается плотной.

Нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:

~ есть O(n). Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;

~ в каждой строке не превышает 10 в типичном случае;

~ ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.

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

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

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

По-видимому, наиболее очевидным способом хранения произвольной разреженной матрицы является '''координатный формат''': хранятся только ненулевые элементы матрицы, и их координаты (номера строк и столбцов). При данном подходе хранение матрицы A можно обеспечить в трех одномерных массивах:

~ массив ненулевых элементов матрицы A (обозначим его как values);

~ массив номеров строк матрицы A, соответствующих элементам массива values (обозначим его как rows);

~ массив номеров столбцов матрицы A, соответствующих элементам массива values (обозначим его как cols);

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

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

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

В соответствии с рассматриваемой схемой для хранения матрицы A требуется три одномерных массива:

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его опять как values);

~ массив номеров столбцов для соответствующих элементов массива values (обозначим его как cols);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его pointer). Описание k-й строки хранится в позициях с pointer[k]-й по (pointer[k+1]–1)-ю массивов values и cols. Если pointer[k]=pointer[k+1], то k-я строка пустая. Если матрица A состоит из n строк, то длина массива pointer будет n+1.

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

Очевидно, что объем памяти, требуемый для хранения вектора pointer, значительно меньше, чем для хранения вектора rows. Более того, разреженный строчный формат обеспечивает эффективный доступ к строчкам матрицы; доступ к столбцам по прежнему затруднен (имеется ввиду, что по индексу строки мы получаем информацию из массива pointer[] о расположении ''идущих по порядку элементов этой строки'' в массиве values[], а чтобы получить все элементы какого-то конкретного столбца придется пройтись по всему вектору pointer[]). Поэтому предпочтительно использовать этот способ хранения в тех алгоритмах, в которых преобладают строчные операции.

Существует также '''разреженный столбцовый формат''', который строится аналогичным способом.

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

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

Пусть матрица размером <math>N\times M</math> содержит в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N \cdot M (N \le M)</math>

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

На входе у нас 4 массива: val(ненулевые элементы матрицы), col(номера столбцов), row(массив указателей) и vec(вектор, на который мы умножаем матрицу).

На выходе получим вектор out.

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}, \ i=\overline{0,N-1}</math>, где <math>N</math> - число строк матрицы.

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

Ядром алгоритма является вычисление сумм произведений:

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}</math>

Итого: <math>NZ</math> умножений + <math>x</math> сложений(<math>NZ-N<x<NZ-1</math>).

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

Метод состоит из вычисления неполных скалярных произведений.

[[Файл:sparse.jpg|thumb|center|500px|Рис.1 Умножение разреженной матрицы на вектор]]

Элементы из массива val умножаются на элементы из массива vec с соответствующим индексом. Черным отмечены ненулевые элементы.

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

Предполагается, что матрица представлена в разреженном строчном формате.

for(i=0; i<N; i++)
{
out[i]=0;
for(j=row[i]; j<row[i+1]; j++)
{
out[i] += val[j]*vec[col[j]];
}
}

Внешний цикл - цикл по элементам выходного вектора. Внутренний - цикл по строкам разреженной матрицы.
Во внутреннем цикле реализовано накопление сумм произведений в выходной элемент.
Индекс ''j'' показывает с какого по какой элемент нужно считать из ''val'' (вектор с ненулевыми значениями матрицы), а также позволяет определить в каких столбцах расположены эти значения в матрице (с помощью вектора ''col'').
Минимальное и максимальное значение ''j'' узнается из вектора ''row''.

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

<math>\bullet \ NZ</math> умножений

<math>\bullet \ x</math> сложений(<math>NZ-N<x<NZ-1</math>).

Всего <math>2NZ</math> операций, где <math>NZ</math> - количество ненулевых элементов.

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

Опишем граф алгоритма.

Граф алгоритма состоит из двух групп вершин, расположенных в целочисленных узлах двух областей одной размерности.

'''Первая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a \cdot b</math>. Координаты области следующие:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math> k </math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>. (На рисунке вместо обозначения ''row'' использовано обозначение ''r'').

Результаты операции - '''промежуточные''' данные алгоритма.

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a + b</math>.
Координаты области таковы:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>.

Результат операции:

<math>\cdot</math> при <math>j < k - 1</math> является '''промежуточным''' данным алгоритма;

<math>\cdot</math> при <math>j = k - 1</math> является '''выходным''' данным <math>out[i]</math>.

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

[[Файл:new_sparse.png|thumb|center|1000px|Рис.2 Умножение разреженной матрицы на вектор. Информационный граф]]

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

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

~ 1 ярус умножений

~ <math>Z-1</math> операция сложения, где Z - максимальное число ненулевых элементов в строке.

Максимальное число требуемых процессоров - NZ.

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

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

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его как val);

~ массив номеров столбцов для соответствующих элементов массива val (обозначим его как col);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его row);

~ вектор, на который будет умножаться матрица (обозначим его vec).

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

Для матрицы размером <math>N\times M</math>, содержащей в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N\cdot M (N \le M)</math>,

~ вектор val - NZ элементов;

~ вектор col - NZ элементов;

~ вектор row - N+1 элемент;

~ вектор vec - M элементов.

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

Вектор out размером N.

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

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

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

Данный алгоритм обладает свойством детерминированности.

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Проведём исследование масштабируемости параллельной реализации умножения разреженной матрицы на вектор. Исследование проводилось на вычислительном комплексе [http://hpc.cmc.msu.ru/bgp Blue Gene/P]<ref> Blue Gene/P http://hpc.cmc.msu.ru/bgp</ref>. Вычисления проводились с помощью следующего программного [https://www.dropbox.com/s/gx0s5r0jg58y8wa/main.c кода]<ref>Sparse matrix-vector MPI multiplication </ref>.
Матрицы генерировались случайным образом.

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

[[Файл:plot_more_points.png|thumb|center|1000px|Рис.3 Умножение разреженной матрицы на вектор. Масштабируемость]]

На рисунке ниже изображен график эффективности в зависимости от числа процессоров и размера задачи. Можно заметить небольшой всплеск эффективности при использовании 64 процессоров.

[[Файл:plot_eff_new.png|thumb|center|1000px|Рис.4 Умножение разреженной матрицы на вектор. Эффективность]]

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

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

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

Эффективная работа с разреженными матрицами реализована во многих библиотеках, например, [https://software.intel.com/en-us/intel-mkl Intel Math Kernel Library], базирующуюся на библиотеках BLAS и LAPACK, также математический пакет [http://matlab.ru/products/matlab Matlab] имеет собственную реализацию.

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

[1] Писсанецки С. Технология разреженных матриц. - М.: Мир, 1988. — 410 с.

[2] https://software.intel.com/sites/default/files/m/d/4/1/d/8/LW_SparseMM_ppt.pdf

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-12-10T16:20:52Z

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

Автор: [[U:Сергей|Герасимов Сергей]] (619)

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

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

'''Разреженная матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается плотной.

Нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:

~ есть O(n). Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;

~ в каждой строке не превышает 10 в типичном случае;

~ ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.

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

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

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

По-видимому, наиболее очевидным способом хранения произвольной разреженной матрицы является '''координатный формат''': хранятся только ненулевые элементы матрицы, и их координаты (номера строк и столбцов). При данном подходе хранение матрицы A можно обеспечить в трех одномерных массивах:

~ массив ненулевых элементов матрицы A (обозначим его как values);

~ массив номеров строк матрицы A, соответствующих элементам массива values (обозначим его как rows);

~ массив номеров столбцов матрицы A, соответствующих элементам массива values (обозначим его как cols);

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

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

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

В соответствии с рассматриваемой схемой для хранения матрицы A требуется три одномерных массива:

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его опять как values);

~ массив номеров столбцов для соответствующих элементов массива values (обозначим его как cols);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его pointer). Описание k-й строки хранится в позициях с pointer[k]-й по (pointer[k+1]–1)-ю массивов values и cols. Если pointer[k]=pointer[k+1], то k-я строка пустая. Если матрица A состоит из n строк, то длина массива pointer будет n+1.

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

Очевидно, что объем памяти, требуемый для хранения вектора pointer, значительно меньше, чем для хранения вектора rows. Более того, разреженный строчный формат обеспечивает эффективный доступ к строчкам матрицы; доступ к столбцам по прежнему затруднен (имеется ввиду, что по индексу строки мы получаем информацию из массива pointer[] о расположении элементов этой строки в массиве values[]). Поэтому предпочтительно использовать этот способ хранения в тех алгоритмах, в которых преобладают строчные операции.

Существует также '''разреженный столбцовый формат''', который строится аналогичным способом.

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

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

Пусть матрица размером <math>N\times M</math> содержит в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N \cdot M (N \le M)</math>

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

На входе у нас 4 массива: val(ненулевые элементы матрицы), col(номера столбцов), row(массив указателей) и vec(вектор, на который мы умножаем матрицу).

На выходе получим вектор out.

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}, \ i=\overline{0,N-1}</math>, где <math>N</math> - число строк матрицы.

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

Ядром алгоритма является вычисление сумм произведений:

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}</math>

Итого: <math>NZ</math> умножений + <math>x</math> сложений(<math>NZ-N<x<NZ-1</math>).

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

Метод состоит из вычисления неполных скалярных произведений.

[[Файл:sparse.jpg|thumb|center|500px|Рис.1 Умножение разреженной матрицы на вектор]]

Элементы из массива val умножаются на элементы из массива vec с соответствующим индексом. Черным отмечены ненулевые элементы.

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

Предполагается, что матрица представлена в разреженном строчном формате.

for(i=0; i<N; i++)
{
out[i]=0;
for(j=row[i]; j<row[i+1]; j++)
{
out[i] += val[j]*vec[col[j]];
}
}

Внешний цикл - цикл по элементам выходного вектора. Внутренний - цикл по строкам разреженной матрицы.
Во внутреннем цикле реализовано накопление сумм произведений в выходной элемент.
Индекс ''j'' показывает с какого по какой элемент нужно считать из ''val'' (вектор с ненулевыми значениями матрицы), а также позволяет определить в каких столбцах расположены эти значения в матрице (с помощью вектора ''col'').
Минимальное и максимальное значение ''j'' узнается из вектора ''row''.

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

<math>\bullet \ NZ</math> умножений

<math>\bullet \ x</math> сложений(<math>NZ-N<x<NZ-1</math>).

Всего <math>2NZ</math> операций, где <math>NZ</math> - количество ненулевых элементов.

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

Опишем граф алгоритма.

Граф алгоритма состоит из двух групп вершин, расположенных в целочисленных узлах двух областей одной размерности.

'''Первая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a \cdot b</math>. Координаты области следующие:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math> k </math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>. (На рисунке вместо обозначения ''row'' использовано обозначение ''r'').

Результаты операции - '''промежуточные''' данные алгоритма.

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a + b</math>.
Координаты области таковы:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>.

Результат операции:

<math>\cdot</math> при <math>j < k - 1</math> является '''промежуточным''' данным алгоритма;

<math>\cdot</math> при <math>j = k - 1</math> является '''выходным''' данным <math>out[i]</math>.

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

[[Файл:new_sparse.png|thumb|center|1000px|Рис.2 Умножение разреженной матрицы на вектор. Информационный граф]]

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

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

~ 1 ярус умножений

~ <math>Z-1</math> операция сложения, где Z - максимальное число ненулевых элементов в строке.

Максимальное число требуемых процессоров - NZ.

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

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

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его как val);

~ массив номеров столбцов для соответствующих элементов массива val (обозначим его как col);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его row);

~ вектор, на который будет умножаться матрица (обозначим его vec).

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

Для матрицы размером <math>N\times M</math>, содержащей в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N\cdot M (N \le M)</math>,

~ вектор val - NZ элементов;

~ вектор col - NZ элементов;

~ вектор row - N+1 элемент;

~ вектор vec - M элементов.

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

Вектор out размером N.

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

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

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

Данный алгоритм обладает свойством детерминированности.

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Проведём исследование масштабируемости параллельной реализации умножения разреженной матрицы на вектор. Исследование проводилось на вычислительном комплексе [http://hpc.cmc.msu.ru/bgp Blue Gene/P]<ref> Blue Gene/P http://hpc.cmc.msu.ru/bgp</ref>. Вычисления проводились с помощью следующего программного [https://www.dropbox.com/s/gx0s5r0jg58y8wa/main.c кода]<ref>Sparse matrix-vector MPI multiplication </ref>.
Матрицы генерировались случайным образом.

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

[[Файл:plot_more_points.png|thumb|center|1000px|Рис.3 Умножение разреженной матрицы на вектор. Масштабируемость]]

На рисунке ниже изображен график эффективности в зависимости от числа процессоров и размера задачи. Можно заметить небольшой всплеск эффективности при использовании 64 процессоров.

[[Файл:plot_eff_new.png|thumb|center|1000px|Рис.4 Умножение разреженной матрицы на вектор. Эффективность]]

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

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

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

Эффективная работа с разреженными матрицами реализована во многих библиотеках, например, [https://software.intel.com/en-us/intel-mkl Intel Math Kernel Library], базирующуюся на библиотеках BLAS и LAPACK, также математический пакет [http://matlab.ru/products/matlab Matlab] имеет собственную реализацию.

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

[1] Писсанецки С. Технология разреженных матриц. - М.: Мир, 1988. — 410 с.

[2] https://software.intel.com/sites/default/files/m/d/4/1/d/8/LW_SparseMM_ppt.pdf

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-12-05T17:32:51Z

Сергей:

Автор: [[U:Сергей|Герасимов Сергей]] (619)

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

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

'''Разреженная матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается плотной.

Нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:

~ есть O(n). Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;

~ в каждой строке не превышает 10 в типичном случае;

~ ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.

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

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

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

По-видимому, наиболее очевидным способом хранения произвольной разреженной матрицы является '''координатный формат''': хранятся только ненулевые элементы матрицы, и их координаты (номера строк и столбцов). При данном подходе хранение матрицы A можно обеспечить в трех одномерных массивах:

~ массив ненулевых элементов матрицы A (обозначим его как values);

~ массив номеров строк матрицы A, соответствующих элементам массива values (обозначим его как rows);

~ массив номеров столбцов матрицы A, соответствующих элементам массива values (обозначим его как cols);

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

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

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

В соответствии с рассматриваемой схемой для хранения матрицы A требуется три одномерных массива:

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его опять как values);

~ массив номеров столбцов для соответствующих элементов массива values (обозначим его как cols);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его pointer). Описание k-й строки хранится в позициях с pointer[k]-й по (pointer[k+1]–1)-ю массивов values и cols. Если pointer[k]=pointer[k+1], то k-я строка пустая. Если матрица A состоит из n строк, то длина массива pointer будет n+1.

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

Очевидно, что объем памяти, требуемый для хранения вектора pointer, значительно меньше, чем для хранения вектора rows. Более того, разреженный строчный формат обеспечивает эффективный доступ к строчкам матрицы; доступ к столбцам по прежнему затруднен. Поэтому предпочтительно использовать этот способ хранения в тех алгоритмах, в которых преобладают строчные операции.

Существует также '''разреженный столбцовый формат''', который строится аналогичным способом.

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

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

Пусть матрица размером <math>N\times M</math> содержит в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N \cdot M (N \le M)</math>

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

На входе у нас 4 массива: val(ненулевые элементы матрицы), col(номера столбцов), row(массив указателей) и vec(вектор, на который мы умножаем матрицу).

На выходе получим вектор out.

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}, \ i=\overline{0,N-1}</math>, где <math>N</math> - число строк матрицы.

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

Ядром алгоритма является вычисление сумм произведений:

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}</math>

Итого: <math>NZ</math> умножений + <math>x</math> сложений(<math>NZ-N<x<NZ-1</math>).

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

Метод состоит из вычисления неполных скалярных произведений.

[[Файл:sparse.jpg|thumb|center|500px|Рис.1 Умножение разреженной матрицы на вектор]]

Элементы из массива val умножаются на элементы из массива vec с соответствующим индексом. Черным отмечены ненулевые элементы.

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

Предполагается, что матрица представлена в разреженном строчном формате.

for(i=0; i<N; i++)
{
out[i]=0;
for(j=row[i]; j<row[i+1]; j++)
{
out[i] += val[j]*vec[col[j]];
}
}

Внешний цикл - цикл по элементам выходного вектора. Внутренний - цикл по строкам разреженной матрицы.
Во внутреннем цикле реализовано накопление сумм произведений в выходной элемент.
Индекс ''j'' показывает с какого по какой элемент нужно считать из ''val'' (вектор с ненулевыми значениями матрицы), а также позволяет определить в каких столбцах расположены эти значения в матрице (с помощью вектора ''col'').
Минимальное и максимальное значение ''j'' узнается из вектора ''row''.

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

<math>\bullet \ NZ</math> умножений

<math>\bullet \ x</math> сложений(<math>NZ-N<x<NZ-1</math>).

Всего <math>2NZ</math> операций, где <math>NZ</math> - количество ненулевых элементов.

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

Опишем граф алгоритма.

Граф алгоритма состоит из двух групп вершин, расположенных в целочисленных узлах двух областей одной размерности.

'''Первая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a \cdot b</math>. Координаты области следующие:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math> k </math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>. (На рисунке вместо обозначения ''row'' использовано обозначение ''r'').

Результаты операции - '''промежуточные''' данные алгоритма.

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a + b</math>.
Координаты области таковы:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>.

Результат операции:

<math>\cdot</math> при <math>j < k - 1</math> является '''промежуточным''' данным алгоритма;

<math>\cdot</math> при <math>j = k - 1</math> является '''выходным''' данным <math>out[i]</math>.

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

[[Файл:new_sparse.png|thumb|center|1000px|Рис.2 Умножение разреженной матрицы на вектор. Информационный граф]]

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

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

~ 1 ярус умножений

~ <math>Z-1</math> операция сложения, где Z - максимальное число ненулевых элементов в строке.

Максимальное число требуемых процессоров - NZ.

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

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

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его как val);

~ массив номеров столбцов для соответствующих элементов массива val (обозначим его как col);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его row);

~ вектор, на который будет умножаться матрица (обозначим его vec).

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

Для матрицы размером <math>N\times M</math>, содержащей в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N\cdot M (N \le M)</math>,

~ вектор val - NZ элементов;

~ вектор col - NZ элементов;

~ вектор row - N+1 элемент;

~ вектор vec - M элементов.

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

Вектор out размером N.

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

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

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

Данный алгоритм обладает свойством детерминированности.

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Проведём исследование масштабируемости параллельной реализации умножения разреженной матрицы на вектор. Исследование проводилось на вычислительном комплексе [http://hpc.cmc.msu.ru/bgp Blue Gene/P]<ref> Blue Gene/P http://hpc.cmc.msu.ru/bgp</ref>. Вычисления проводились с помощью следующего программного [https://www.dropbox.com/s/gx0s5r0jg58y8wa/main.c кода]<ref>Sparse matrix-vector MPI multiplication </ref>.
Матрицы генерировались случайным образом.

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

[[Файл:plot_more_points.png|thumb|center|1000px|Рис.3 Умножение разреженной матрицы на вектор. Масштабируемость]]

На рисунке ниже изображен график эффективности в зависимости от числа процессоров и размера задачи. Можно заметить небольшой всплеск эффективности при использовании 64 процессоров.

[[Файл:plot_eff_new.png|thumb|center|1000px|Рис.4 Умножение разреженной матрицы на вектор. Эффективность]]

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

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

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

Эффективная работа с разреженными матрицами реализована во многих библиотеках, например, [https://software.intel.com/en-us/intel-mkl Intel Math Kernel Library], базирующуюся на библиотеках BLAS и LAPACK, также математический пакет [http://matlab.ru/products/matlab Matlab] имеет собственную реализацию.

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

[1] Писсанецки С. Технология разреженных матриц. - М.: Мир, 1988. — 410 с.

[2] https://software.intel.com/sites/default/files/m/d/4/1/d/8/LW_SparseMM_ppt.pdf

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-11-18T21:05:13Z

Сергей:

{{assignment}}

Автор: [[U:Сергей|Герасимов Сергей]] (619)

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

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

'''Разреженная матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается плотной.

Нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:

~ есть O(n). Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;

~ в каждой строке не превышает 10 в типичном случае;

~ ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.

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

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

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

По-видимому, наиболее очевидным способом хранения произвольной разреженной матрицы является '''координатный формат''': хранятся только ненулевые элементы матрицы, и их координаты (номера строк и столбцов). При данном подходе хранение матрицы A можно обеспечить в трех одномерных массивах:

~ массив ненулевых элементов матрицы A (обозначим его как values);

~ массив номеров строк матрицы A, соответствующих элементам массива values (обозначим его как rows);

~ массив номеров столбцов матрицы A, соответствующих элементам массива values (обозначим его как cols);

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

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

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

В соответствии с рассматриваемой схемой для хранения матрицы A требуется три одномерных массива:

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его опять как values);

~ массив номеров столбцов для соответствующих элементов массива values (обозначим его как cols);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его pointer). Описание k-й строки хранится в позициях с pointer[k]-й по (pointer[k+1]–1)-ю массивов values и cols. Если pointer[k]=pointer[k+1], то k-я строка пустая. Если матрица A состоит из n строк, то длина массива pointer будет n+1.

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

Очевидно, что объем памяти, требуемый для хранения вектора pointer, значительно меньше, чем для хранения вектора rows. Более того, разреженный строчный формат обеспечивает эффективный доступ к строчкам матрицы; доступ к столбцам по прежнему затруднен. Поэтому предпочтительно использовать этот способ хранения в тех алгоритмах, в которых преобладают строчные операции.

Существует также '''разреженный столбцовый формат''', который строится аналогичным способом.

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

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

Пусть матрица размером <math>N\times M</math> содержит в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>

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

На входе у нас 4 массива: val(ненулевые элементы матрицы), col(номера столбцов), row(массив указателей) и vec(вектор, на который мы умножаем матрицу).

На выходе получим вектор out.

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}, \ i=\overline{0,N-1}</math>, где <math>N</math> - число строк матрицы.

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

Ядром алгоритма является вычисление сумм произведений:

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}</math>

Итого: <math>NZ</math> умножений + <math>x</math> сложений(<math>NZ-N<x<NZ-1</math>).

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

Метод состоит из вычисления неполных скалярных произведений.

[[Файл:sparse.jpg|thumb|center|500px|Рис.1 Умножение разреженной матрицы на вектор]]

Элементы из массива val умножаются на элементы из массива vec с соответствующим индексом. Черным отмечены ненулевые элементы.

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

Предполагается, что матрица представлена в разреженном строчном формате.

for(i=0; i<N; i++)
{
out[i]=0;
for(j=row[i]; j<row[i+1]; j++)
{
out[i] += val[j]*vec[col[j]];
}
}

Внешний цикл - цикл по элементам выходного вектора. Внутренний - цикл по строкам разреженной матрицы.
Во внутреннем цикле реализовано накопление сумм произведений в выходной элемент.
Индекс ''j'' показывает с какого по какой элемент нужно считать из ''val'' (вектор с ненулевыми значениями матрицы), а также позволяет определить в каких столбцах расположены эти значения в матрице (с помощью вектора ''col'').
Минимальное и максимальное значение ''j'' узнается из вектора ''row''.

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

<math>\bullet \ NZ</math> умножений

<math>\bullet \ x</math> сложений(<math>NZ-N<x<NZ-1</math>).

Всего <math>2NZ</math> операций, где <math>NZ</math> - количество ненулевых элементов.

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

Опишем граф алгоритма.

Граф алгоритма состоит из двух групп вершин, расположенных в целочисленных узлах двух областей одной размерности.

'''Первая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a \cdot b</math>. Координаты области следующие:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math> k </math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>. (На рисунке вместо обозначения ''row'' использовано обозначение ''r'').

Результаты операции - '''промежуточные''' данные алгоритма.

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a + b</math>.
Координаты области таковы:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>.

Результат операции:

<math>\cdot</math> при <math>j < k - 1</math> является '''промежуточным''' данным алгоритма;

<math>\cdot</math> при <math>j = k - 1</math> является '''выходным''' данным <math>out[i]</math>.

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

[[Файл:new_sparse.png|thumb|center|1000px|Рис.2 Умножение разреженной матрицы на вектор. Информационный граф]]

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

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

~ 1 ярус умножений

~ <math>Z-1</math> операция сложения, где Z - максимальное число ненулевых элементов в строке.

Максимальное число требуемых процессоров - NZ.

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

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

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его как val);

~ массив номеров столбцов для соответствующих элементов массива val (обозначим его как col);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его row);

~ вектор, на который будет умножаться матрица (обозначим его vec).

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

Для матрицы размером <math>N\times M</math>, содержащей в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>,

~ вектор val - NZ элементов;

~ вектор col - NZ элементов;

~ вектор row - N+1 элемент;

~ вектор vec - M элементов.

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

Вектор out размером N.

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

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

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

Данный алгоритм обладает свойством детерминированности.

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Проведём исследование масштабируемости параллельной реализации умножения разреженной матрицы на вектор. Исследование проводилось на вычислительном комплексе [http://hpc.cmc.msu.ru/bgp Blue Gene/P]<ref> Blue Gene/P http://hpc.cmc.msu.ru/bgp</ref>. Вычисления проводились с помощью следующего программного [https://www.dropbox.com/s/gx0s5r0jg58y8wa/main.c кода]<ref>Sparse matrix-vector MPI multiplication </ref>.
Матрицы генерировались случайным образом.

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

[[Файл:plot_more_points.png|thumb|center|1000px|Рис.3 Умножение разреженной матрицы на вектор. Масштабируемость]]

На рисунке ниже изображен график эффективности в зависимости от числа процессоров и размера задачи. Можно заметить небольшой всплеск эффективности при использовании 64 процессоров.

[[Файл:plot_eff_new.png|thumb|center|1000px|Рис.4 Умножение разреженной матрицы на вектор. Эффективность]]

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

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

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

Эффективная работа с разреженными матрицами реализована во многих библиотеках, например, [https://software.intel.com/en-us/intel-mkl Intel Math Kernel Library], базирующуюся на библиотеках BLAS и LAPACK, также математических пакет [http://matlab.ru/products/matlab Matlab] имеет собственную реализацию.

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

[1] Писсанецки С. Технология разреженных матриц. - М.: Мир, 1988. — 410 с.

[2] https://software.intel.com/sites/default/files/m/d/4/1/d/8/LW_SparseMM_ppt.pdf

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-11-18T21:03:54Z

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

Автор: [[U:Сергей|Герасимов Сергей]] (619)

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

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

'''Разреженная матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается плотной.

Нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:

~ есть O(n). Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;

~ в каждой строке не превышает 10 в типичном случае;

~ ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.

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

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

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

По-видимому, наиболее очевидным способом хранения произвольной разреженной матрицы является '''координатный формат''': хранятся только ненулевые элементы матрицы, и их координаты (номера строк и столбцов). При данном подходе хранение матрицы A можно обеспечить в трех одномерных массивах:

~ массив ненулевых элементов матрицы A (обозначим его как values);

~ массив номеров строк матрицы A, соответствующих элементам массива values (обозначим его как rows);

~ массив номеров столбцов матрицы A, соответствующих элементам массива values (обозначим его как cols);

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

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

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

В соответствии с рассматриваемой схемой для хранения матрицы A требуется три одномерных массива:

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его опять как values);

~ массив номеров столбцов для соответствующих элементов массива values (обозначим его как cols);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его pointer). Описание k-й строки хранится в позициях с pointer[k]-й по (pointer[k+1]–1)-ю массивов values и cols. Если pointer[k]=pointer[k+1], то k-я строка пустая. Если матрица A состоит из n строк, то длина массива pointer будет n+1.

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

Очевидно, что объем памяти, требуемый для хранения вектора pointer, значительно меньше, чем для хранения вектора rows. Более того, разреженный строчный формат обеспечивает эффективный доступ к строчкам матрицы; доступ к столбцам по прежнему затруднен. Поэтому предпочтительно использовать этот способ хранения в тех алгоритмах, в которых преобладают строчные операции.

Существует также '''разреженный столбцовый формат''', который строится аналогичным способом.

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

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

Пусть матрица размером <math>N\times M</math> содержит в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>

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

На входе у нас 4 массива: val(ненулевые элементы матрицы), col(номера столбцов), row(массив указателей) и vec(вектор, на который мы умножаем матрицу).

На выходе получим вектор out.

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}, \ i=\overline{0,N-1}</math>, где <math>N</math> - число строк матрицы.

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

Ядром алгоритма является вычисление сумм произведений:

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}</math>

Итого: <math>NZ</math> умножений + <math>x</math> сложений(<math>NZ-N<x<NZ-1</math>).

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

Метод состоит из вычисления неполных скалярных произведений.

[[Файл:sparse.jpg|thumb|center|500px|Рис.1 Умножение разреженной матрицы на вектор]]

Элементы из массива val умножаются на элементы из массива vec с соответствующим индексом. Черным отмечены ненулевые элементы.

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

Предполагается, что матрица представлена в разреженном строчном формате.

for(i=0; i<N; i++)
{
out[i]=0;
for(j=row[i]; j<row[i+1]; j++)
{
out[i] += val[j]*vec[col[j]];
}
}

Внешний цикл - цикл по элементам выходного вектора. Внутренний - цикл по строкам разреженной матрицы.
Во внутреннем цикле реализовано накопление сумм произведений в выходной элемент.
Индекс ''j'' показывает с какого по какой элемент нужно считать из ''val'' (вектор с ненулевыми значениями матрицы), а также позволяет определить в каких столбцах расположены эти значения в матрице (с помощью вектора ''col'').
Минимальное и максимальное значение ''j'' узнается из вектора ''row''.

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

<math>\bullet \ NZ</math> умножений

<math>\bullet \ x</math> сложений(<math>NZ-N<x<NZ-1</math>).

Всего <math>2NZ</math> операций, где <math>NZ</math> - количество ненулевых элементов.

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

Опишем граф алгоритма.

Граф алгоритма состоит из двух групп вершин, расположенных в целочисленных узлах двух областей одной размерности.

'''Первая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a \cdot b</math>. Координаты области следующие:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math> k </math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>. (На рисунке вместо обозначения ''row'' использовано обозначение ''r'').

Результаты операции - '''промежуточные''' данные алгоритма.

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a + b</math>.
Координаты области таковы:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>.

Результат операции:

<math>\cdot</math> при <math>j < k - 1</math> является '''промежуточным''' данным алгоритма;

<math>\cdot</math> при <math>j = k - 1</math> является '''выходным''' данным <math>out[i]</math>.

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

[[Файл:new_sparse.png|thumb|center|1000px|Рис.2 Умножение разреженной матрицы на вектор. Информационный граф]]

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

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

~ 1 ярус умножений

~ <math>Z-1</math> операция сложения, где Z - максимальное число ненулевых элементов в строке.

Максимальное число требуемых процессоров - NZ.

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

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

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его как val);

~ массив номеров столбцов для соответствующих элементов массива val (обозначим его как col);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его row);

~ вектор, на который будет умножаться матрица (обозначим его vec).

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

Для матрицы размером <math>N\times M</math>, содержащей в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>,

~ вектор val - NZ элементов;

~ вектор col - NZ элементов;

~ вектор row - N+1 элемент;

~ вектор vec - M элементов.

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

Вектор out размером N.

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

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

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

Данный алгоритм обладает свойством детерминированности.

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Проведём исследование масштабируемости параллельной реализации умножения разреженной матрицы на вектор. Исследование проводилось на вычислительном комплексе [http://hpc.cmc.msu.ru/bgp Blue Gene/P]<ref> Blue Gene/P http://hpc.cmc.msu.ru/bgp</ref>. Вычисления проводились с помощью следующего программного [https://www.dropbox.com/s/gx0s5r0jg58y8wa/main.c кода]<ref>Sparse matrix-vector MPI multiplication </ref>.
Матрицы генерировались случайным образом.

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

[[Файл:plot_more_points.png|thumb|center|1000px|Рис.3 Умножение разреженной матрицы на вектор. Масштабируемость]]

На рисунке ниже изображен график эффективности в зависимости от числа процессоров и размера задачи. Можно заметить небольшой всплеск эффективности при использовании 64 процессоров.

[[Файл:plot_eff_new.png|thumb|center|1000px|Рис.4 Умножение разреженной матрицы на вектор. Эффективность]]

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

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

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

Эффективная работа с разреженными матрицами реализована во многих библиотеках, например, [https://software.intel.com/en-us/intel-mkl Intel Math Kernel Library], базирующуюся на библиотеках BLAS и LAPACK, также математических пакет [http://matlab.ru/products/matlab Matlab] имеет собственную реализацию.

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

[1] Писсанецки С. Технология разреженных матриц. - М.: Мир, 1988. — 410 с.

[2] https://software.intel.com/sites/default/files/m/d/4/1/d/8/LW_SparseMM_ppt.pdf

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-11-18T21:02:50Z

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

Автор: [[U:Сергей|Герасимов Сергей]] (619)

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

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

'''Разреженная матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается плотной.

Нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:

~ есть O(n). Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;

~ в каждой строке не превышает 10 в типичном случае;

~ ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.

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

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

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

По-видимому, наиболее очевидным способом хранения произвольной разреженной матрицы является '''координатный формат''': хранятся только ненулевые элементы матрицы, и их координаты (номера строк и столбцов). При данном подходе хранение матрицы A можно обеспечить в трех одномерных массивах:

~ массив ненулевых элементов матрицы A (обозначим его как values);

~ массив номеров строк матрицы A, соответствующих элементам массива values (обозначим его как rows);

~ массив номеров столбцов матрицы A, соответствующих элементам массива values (обозначим его как cols);

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

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

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

В соответствии с рассматриваемой схемой для хранения матрицы A требуется три одномерных массива:

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его опять как values);

~ массив номеров столбцов для соответствующих элементов массива values (обозначим его как cols);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его pointer). Описание k-й строки хранится в позициях с pointer[k]-й по (pointer[k+1]–1)-ю массивов values и cols. Если pointer[k]=pointer[k+1], то k-я строка пустая. Если матрица A состоит из n строк, то длина массива pointer будет n+1.

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

Очевидно, что объем памяти, требуемый для хранения вектора pointer, значительно меньше, чем для хранения вектора rows. Более того, разреженный строчный формат обеспечивает эффективный доступ к строчкам матрицы; доступ к столбцам по прежнему затруднен. Поэтому предпочтительно использовать этот способ хранения в тех алгоритмах, в которых преобладают строчные операции.

Существует также '''разреженный столбцовый формат''', который строится аналогичным способом.

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

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

Пусть матрица размером <math>N\times M</math> содержит в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>

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

На входе у нас 4 массива: val(ненулевые элементы матрицы), col(номера столбцов), row(массив указателей) и vec(вектор, на который мы умножаем матрицу).

На выходе получим вектор out.

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}, \ i=\overline{0,N-1}</math>, где <math>N</math> - число строк матрицы.

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

Ядром алгоритма является вычисление сумм произведений:

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}</math>

Итого: <math>NZ</math> умножений + <math>x</math> сложений(<math>NZ-N<x<NZ-1</math>).

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

Метод состоит из вычисления неполных скалярных произведений.

[[Файл:sparse.jpg|thumb|center|500px|Рис.1 Умножение разреженной матрицы на вектор]]

Элементы из массива val умножаются на элементы из массива vec с соответствующим индексом. Черным отмечены ненулевые элементы.

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

Предполагается, что матрица представлена в разреженном строчном формате.

for(i=0; i<N; i++)
{
out[i]=0;
for(j=row[i]; j<row[i+1]; j++)
{
out[i] += val[j]*vec[col[j]];
}
}

Внешний цикл - цикл по элементам выходного вектора. Внутренний - цикл по строкам разреженной матрицы.
Во внутреннем цикле реализовано накопление сумм произведений в выходной элемент.
Индекс ''j'' показывает с какого по какой элемент нужно считать из ''val'' (вектор с ненулевыми значениями матрицы), а также позволяет определить в каких столбцах расположены эти значения в матрице (с помощью вектора ''col'').
Минимальное и максимальное значение ''j'' узнается из вектора ''row''.

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

<math>\bullet \ NZ</math> умножений

<math>\bullet \ x</math> сложений(<math>NZ-N<x<NZ-1</math>).

Всего <math>2NZ</math> операций, где <math>NZ</math> - количество ненулевых элементов.

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

Опишем граф алгоритма.

Граф алгоритма состоит из двух групп вершин, расположенных в целочисленных узлах двух областей одной размерности.

'''Первая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a \cdot b</math>. Координаты области следующие:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math> k </math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>. (На рисунке вместо обозначения ''row'' использовано обозначение ''r'').

Результаты операции - '''промежуточные''' данные алгоритма.

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a + b</math>.
Координаты области таковы:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>.

Результат операции:

<math>\cdot</math> при <math>j < k - 1</math> является '''промежуточным''' данным алгоритма;

<math>\cdot</math> при <math>j = k - 1</math> является '''выходным''' данным <math>out[i]</math>.

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

[[Файл:new_sparse.png|thumb|center|1000px|Рис.2 Умножение разреженной матрицы на вектор. Информационный граф]]

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

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

~ 1 ярус умножений

~ <math>Z-1</math> операция сложения, где Z - максимальное число ненулевых элементов в строке.

Максимальное число требуемых процессоров - NZ.

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

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

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его как val);

~ массив номеров столбцов для соответствующих элементов массива val (обозначим его как col);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его row);

~ вектор, на который будет умножаться матрица (обозначим его vec).

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

Для матрицы размером <math>N\times M</math>, содержащей в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>,

~ вектор val - NZ элементов;

~ вектор col - NZ элементов;

~ вектор row - N+1 элемент;

~ вектор vec - M элементов.

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

Вектор out размером N.

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

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

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

Данный алгоритм обладает свойством детерминированности.

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Проведём исследование масштабируемости параллельной реализации умножения разреженной матрицы на вектор. Исследование проводилось на вычислительном комплексе [http://hpc.cmc.msu.ru/bgp Blue Gene/P]<ref> Blue Gene/P http://hpc.cmc.msu.ru/bgp</ref>. Вычисления проводились с помощью следующего программного [https://www.dropbox.com/s/gx0s5r0jg58y8wa/main.c кода]<ref>Sparse matrix-vector MPI multiplication </ref>.

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

[[Файл:plot_more_points.png|thumb|center|1000px|Рис.3 Умножение разреженной матрицы на вектор. Масштабируемость]]

На рисунке ниже изображен график эффективности в зависимости от числа процессоров и размера задачи. Можно заметить небольшой всплеск эффективности при использовании 64 процессоров.

[[Файл:plot_eff_new.png|thumb|center|1000px|Рис.4 Умножение разреженной матрицы на вектор. Эффективность]]

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

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

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

Эффективная работа с разреженными матрицами реализована во многих библиотеках, например, [https://software.intel.com/en-us/intel-mkl Intel Math Kernel Library], базирующуюся на библиотеках BLAS и LAPACK, также математических пакет [http://matlab.ru/products/matlab Matlab] имеет собственную реализацию.

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

[1] Писсанецки С. Технология разреженных матриц. - М.: Мир, 1988. — 410 с.

[2] https://software.intel.com/sites/default/files/m/d/4/1/d/8/LW_SparseMM_ppt.pdf

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-11-18T20:31:28Z

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

Автор: [[U:Сергей|Герасимов Сергей]] (619)

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

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

'''Разреженная матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается плотной.

Нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:

~ есть O(n). Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;

~ в каждой строке не превышает 10 в типичном случае;

~ ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.

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

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

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

По-видимому, наиболее очевидным способом хранения произвольной разреженной матрицы является '''координатный формат''': хранятся только ненулевые элементы матрицы, и их координаты (номера строк и столбцов). При данном подходе хранение матрицы A можно обеспечить в трех одномерных массивах:

~ массив ненулевых элементов матрицы A (обозначим его как values);

~ массив номеров строк матрицы A, соответствующих элементам массива values (обозначим его как rows);

~ массив номеров столбцов матрицы A, соответствующих элементам массива values (обозначим его как cols);

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

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

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

В соответствии с рассматриваемой схемой для хранения матрицы A требуется три одномерных массива:

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его опять как values);

~ массив номеров столбцов для соответствующих элементов массива values (обозначим его как cols);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его pointer). Описание k-й строки хранится в позициях с pointer[k]-й по (pointer[k+1]–1)-ю массивов values и cols. Если pointer[k]=pointer[k+1], то k-я строка пустая. Если матрица A состоит из n строк, то длина массива pointer будет n+1.

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

Очевидно, что объем памяти, требуемый для хранения вектора pointer, значительно меньше, чем для хранения вектора rows. Более того, разреженный строчный формат обеспечивает эффективный доступ к строчкам матрицы; доступ к столбцам по прежнему затруднен. Поэтому предпочтительно использовать этот способ хранения в тех алгоритмах, в которых преобладают строчные операции.

Существует также '''разреженный столбцовый формат''', который строится аналогичным способом.

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

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

Пусть матрица размером <math>N\times M</math> содержит в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>

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

На входе у нас 4 массива: val(ненулевые элементы матрицы), col(номера столбцов), row(массив указателей) и vec(вектор, на который мы умножаем матрицу).

На выходе получим вектор out.

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}, \ i=\overline{0,N-1}</math>, где <math>N</math> - число строк матрицы.

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

Ядром алгоритма является вычисление сумм произведений:

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}</math>

Итого: <math>NZ</math> умножений + <math>x</math> сложений(<math>NZ-N<x<NZ-1</math>).

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

Метод состоит из вычисления неполных скалярных произведений.

[[Файл:sparse.jpg|thumb|center|500px|Рис.1 Умножение разреженной матрицы на вектор]]

Элементы из массива val умножаются на элементы из массива vec с соответствующим индексом. Черным отмечены ненулевые элементы.

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

Предполагается, что матрица представлена в разреженном строчном формате.

for(i=0; i<N; i++)
{
out[i]=0;
for(j=row[i]; j<row[i+1]; j++)
{
out[i] += val[j]*vec[col[j]];
}
}

Внешний цикл - цикл по элементам выходного вектора. Внутренний - цикл по строкам разреженной матрицы.
Во внутреннем цикле реализовано накопление сумм произведений в выходной элемент.
Индекс ''j'' показывает с какого по какой элемент нужно считать из ''val'' (вектор с ненулевыми значениями матрицы), а также позволяет определить в каких столбцах расположены эти значения в матрице (с помощью вектора ''col'').
Минимальное и максимальное значение ''j'' узнается из вектора ''row''.

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

<math>\bullet \ NZ</math> умножений

<math>\bullet \ x</math> сложений(<math>NZ-N<x<NZ-1</math>).

Всего <math>2NZ</math> операций, где <math>NZ</math> - количество ненулевых элементов.

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

Опишем граф алгоритма.

Граф алгоритма состоит из двух групп вершин, расположенных в целочисленных узлах двух областей одной размерности.

'''Первая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a \cdot b</math>. Координаты области следующие:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math> k </math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>. (На рисунке вместо обозначения ''row'' использовано обозначение ''r'').

Результаты операции - '''промежуточные''' данные алгоритма.

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a + b</math>.
Координаты области таковы:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>.

Результат операции:

<math>\cdot</math> при <math>j < k - 1</math> является '''промежуточным''' данным алгоритма;

<math>\cdot</math> при <math>j = k - 1</math> является '''выходным''' данным <math>out[i]</math>.

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

[[Файл:new_sparse.png|thumb|center|1000px|Рис.2 Умножение разреженной матрицы на вектор. Информационный граф]]

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

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

~ 1 ярус умножений

~ <math>Z-1</math> операция сложения, где Z - максимальное число ненулевых элементов в строке.

Максимальное число требуемых процессоров - NZ.

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

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

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его как val);

~ массив номеров столбцов для соответствующих элементов массива val (обозначим его как col);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его row);

~ вектор, на который будет умножаться матрица (обозначим его vec).

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

Для матрицы размером <math>N\times M</math>, содержащей в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>,

~ вектор val - NZ элементов;

~ вектор col - NZ элементов;

~ вектор row - N+1 элемент;

~ вектор vec - M элементов.

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

Вектор out размером N.

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

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

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

Данный алгоритм обладает свойством детерминированности.

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Проведём исследование масштабируемости параллельной реализации умножения разреженной матрицы на вектор. Исследование проводилось на вычислительном комплексе [http://hpc.cmc.msu.ru/bgp Blue Gene/P]<ref> Blue Gene/P http://hpc.cmc.msu.ru/bgp</ref>. Вычисления проводились с помощью следующего программного [https://dropbox.com кода]<ref>Sparse matrix-vector MPI multiplication </ref>.

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

[[Файл:plot_more_points.png|thumb|center|1000px|Рис.3 Умножение разреженной матрицы на вектор. Масштабируемость]]

На рисунке ниже изображен график эффективности в зависимости от числа процессоров и размера задачи. Можно заметить небольшой всплеск эффективности при использовании 64 процессоров.

[[Файл:plot_eff_new.png|thumb|center|1000px|Рис.4 Умножение разреженной матрицы на вектор. Эффективность]]

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

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

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

Эффективная работа с разреженными матрицами реализована во многих библиотеках, например, [https://software.intel.com/en-us/intel-mkl Intel Math Kernel Library], базирующуюся на библиотеках BLAS и LAPACK, также математических пакет [http://matlab.ru/products/matlab Matlab] имеет собственную реализацию.

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

[1] Писсанецки С. Технология разреженных матриц. - М.: Мир, 1988. — 410 с.

[2] https://software.intel.com/sites/default/files/m/d/4/1/d/8/LW_SparseMM_ppt.pdf

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-11-15T23:33:21Z

Сергей:

{{Assignment|Dan}}

Автор: [[U:Сергей|Герасимов Сергей]] (619)

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

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

'''Разреженная матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается плотной.

Нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:

~ есть O(n). Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;

~ в каждой строке не превышает 10 в типичном случае;

~ ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.

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

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

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

По-видимому, наиболее очевидным способом хранения произвольной разреженной матрицы является '''координатный формат''': хранятся только ненулевые элементы матрицы, и их координаты (номера строк и столбцов). При данном подходе хранение матрицы A можно обеспечить в трех одномерных массивах:

~ массив ненулевых элементов матрицы A (обозначим его как values);

~ массив номеров строк матрицы A, соответствующих элементам массива values (обозначим его как rows);

~ массив номеров столбцов матрицы A, соответствующих элементам массива values (обозначим его как cols);

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

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

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

В соответствии с рассматриваемой схемой для хранения матрицы A требуется три одномерных массива:

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его опять как values);

~ массив номеров столбцов для соответствующих элементов массива values (обозначим его как cols);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его pointer). Описание k-й строки хранится в позициях с pointer[k]-й по (pointer[k+1]–1)-ю массивов values и cols. Если pointer[k]=pointer[k+1], то k-я строка пустая. Если матрица A состоит из n строк, то длина массива pointer будет n+1.

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

Очевидно, что объем памяти, требуемый для хранения вектора pointer, значительно меньше, чем для хранения вектора rows. Более того, разреженный строчный формат обеспечивает эффективный доступ к строчкам матрицы; доступ к столбцам по прежнему затруднен. Поэтому предпочтительно использовать этот способ хранения в тех алгоритмах, в которых преобладают строчные операции.

Существует также '''разреженный столбцовый формат''', который строится аналогичным способом.

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

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

Пусть матрица размером <math>N\times M</math> содержит в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>

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

На входе у нас 4 массива: val(ненулевые элементы матрицы), col(номера столбцов), row(массив указателей) и vec(вектор, на который мы умножаем матрицу).

На выходе получим вектор out.

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}, \ i=\overline{0,N-1}</math>, где <math>N</math> - число строк матрицы.

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

Ядром алгоритма является вычисление сумм произведений:

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}</math>

Итого: <math>NZ</math> умножений + <math>x</math> сложений(<math>NZ-N<x<NZ-1</math>).

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

Метод состоит из вычисления неполных скалярных произведений.

[[Файл:sparse.jpg|thumb|center|500px|Рис.1 Умножение разреженной матрицы на вектор]]

Элементы из массива val умножаются на элементы из массива vec с соответствующим индексом. Черным отмечены ненулевые элементы.

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

Предполагается, что матрица представлена в разреженном строчном формате.

for(i=0; i<N; i++)
{
out[i]=0;
for(j=row[i]; j<row[i+1]; j++)
{
out[i] += val[j]*vec[col[j]];
}
}

Внешний цикл - цикл по элементам выходного вектора. Внутренний - цикл по строкам разреженной матрицы.
Во внутреннем цикле реализовано накопление сумм произведений в выходной элемент.
Индекс ''j'' показывает с какого по какой элемент нужно считать из ''val'' (вектор с ненулевыми значениями матрицы), а также позволяет определить в каких столбцах расположены эти значения в матрице (с помощью вектора ''col'').
Минимальное и максимальное значение ''j'' узнается из вектора ''row''.

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

<math>\bullet \ NZ</math> умножений

<math>\bullet \ x</math> сложений(<math>NZ-N<x<NZ-1</math>).

Всего <math>2NZ</math> операций, где <math>NZ</math> - количество ненулевых элементов.

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

Опишем граф алгоритма.

Граф алгоритма состоит из двух групп вершин, расположенных в целочисленных узлах двух областей одной размерности.

'''Первая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a \cdot b</math>. Координаты области следующие:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math> k </math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>. (На рисунке вместо обозначения ''row'' использовано обозначение ''r'').

Результаты операции - '''промежуточные''' данные алгоритма.

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a + b</math>.
Координаты области таковы:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>.

Результат операции:

<math>\cdot</math> при <math>j < k - 1</math> является '''промежуточным''' данным алгоритма;

<math>\cdot</math> при <math>j = k - 1</math> является '''выходным''' данным <math>out[i]</math>.

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

[[Файл:new_sparse.png|thumb|center|1000px|Рис.2 Умножение разреженной матрицы на вектор. Информационный граф]]

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

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

~ 1 ярус умножений

~ <math>Z-1</math> операция сложения, где Z - максимальное число ненулевых элементов в строке.

Максимальное число требуемых процессоров - NZ.

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

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

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его как val);

~ массив номеров столбцов для соответствующих элементов массива val (обозначим его как col);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его row);

~ вектор, на который будет умножаться матрица (обозначим его vec).

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

Для матрицы размером <math>N\times M</math>, содержащей в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>,

~ вектор val - NZ элементов;

~ вектор col - NZ элементов;

~ вектор row - N+1 элемент;

~ вектор vec - M элементов.

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

Вектор out размером N.

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

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

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

Данный алгоритм обладает свойством детерминированности.

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

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

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

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

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

[[Файл:plot_more_points.png|thumb|center|1000px|Рис.3 Умножение разреженной матрицы на вектор. Масштабируемость]]

[[Файл:plot_eff_new.png|thumb|center|1000px|Рис.4 Умножение разреженной матрицы на вектор. Эффективность]]

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

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

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

Эффективная работа с разреженными матрицами реализована во многих библиотеках, например, [https://software.intel.com/en-us/intel-mkl Intel Math Kernel Library], базирующуюся на библиотеках BLAS и LAPACK, также математических пакет [http://matlab.ru/products/matlab Matlab] имеет собственную реализацию.

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

[1] Писсанецки С. Технология разреженных матриц. - М.: Мир, 1988. — 410 с.

[2] https://software.intel.com/sites/default/files/m/d/4/1/d/8/LW_SparseMM_ppt.pdf

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-11-15T23:22:12Z

Сергей:

{{Assignment|Dan}}

Автор: [[U:Сергей|Герасимов Сергей]] (619)

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

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

'''Разреженная матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается плотной.

Нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:

~ есть O(n). Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;

~ в каждой строке не превышает 10 в типичном случае;

~ ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.

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

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

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

По-видимому, наиболее очевидным способом хранения произвольной разреженной матрицы является '''координатный формат''': хранятся только ненулевые элементы матрицы, и их координаты (номера строк и столбцов). При данном подходе хранение матрицы A можно обеспечить в трех одномерных массивах:

~ массив ненулевых элементов матрицы A (обозначим его как values);

~ массив номеров строк матрицы A, соответствующих элементам массива values (обозначим его как rows);

~ массив номеров столбцов матрицы A, соответствующих элементам массива values (обозначим его как cols);

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

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

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

В соответствии с рассматриваемой схемой для хранения матрицы A требуется три одномерных массива:

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его опять как values);

~ массив номеров столбцов для соответствующих элементов массива values (обозначим его как cols);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его pointer). Описание k-й строки хранится в позициях с pointer[k]-й по (pointer[k+1]–1)-ю массивов values и cols. Если pointer[k]=pointer[k+1], то k-я строка пустая. Если матрица A состоит из n строк, то длина массива pointer будет n+1.

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

Очевидно, что объем памяти, требуемый для хранения вектора pointer, значительно меньше, чем для хранения вектора rows. Более того, разреженный строчный формат обеспечивает эффективный доступ к строчкам матрицы; доступ к столбцам по прежнему затруднен. Поэтому предпочтительно использовать этот способ хранения в тех алгоритмах, в которых преобладают строчные операции.

Существует также '''разреженный столбцовый формат''', который строится аналогичным способом.

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

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

Пусть матрица размером <math>N\times M</math> содержит в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>

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

На входе у нас 4 массива: val(ненулевые элементы матрицы), col(номера столбцов), row(массив указателей) и vec(вектор, на который мы умножаем матрицу).

На выходе получим вектор out.

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}, \ i=\overline{0,N-1}</math>, где <math>N</math> - число строк матрицы.

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

Ядром алгоритма является вычисление сумм произведений:

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}</math>

Итого: <math>NZ</math> умножений + <math>x</math> сложений(<math>NZ-N<x<NZ-1</math>).

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

Метод состоит из вычисления неполных скалярных произведений.

[[Файл:sparse.jpg|thumb|center|500px|Рис.1 Умножение разреженной матрицы на вектор]]

Элементы из массива val умножаются на элементы из массива vec с соответствующим индексом. Черным отмечены ненулевые элементы.

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

Предполагается, что матрица представлена в разреженном строчном формате.

for(i=0; i<N; i++)
{
out[i]=0;
for(j=row[i]; j<row[i+1]; j++)
{
out[i] += val[j]*vec[col[j]];
}
}

Внешний цикл - цикл по элементам выходного вектора. Внутренний - цикл по строкам разреженной матрицы.
Во внутреннем цикле реализовано накопление сумм произведений в выходной элемент.
Индекс ''j'' показывает с какого по какой элемент нужно считать из ''val'' (вектор с ненулевыми значениями матрицы), а также позволяет определить в каких столбцах расположены эти значения в матрице (с помощью вектора ''col'').
Минимальное и максимальное значение ''j'' узнается из вектора ''row''.

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

<math>\bullet \ NZ</math> умножений

<math>\bullet \ x</math> сложений(<math>NZ-N<x<NZ-1</math>).

Всего <math>2NZ</math> операций, где <math>NZ</math> - количество ненулевых элементов.

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

Опишем граф алгоритма.

Граф алгоритма состоит из двух групп вершин, расположенных в целочисленных узлах двух областей одной размерности.

'''Первая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a \cdot b</math>. Координаты области следующие:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math> k </math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>. (На рисунке вместо обозначения ''row'' использовано обозначение ''r'').

Результаты операции - '''промежуточные''' данные алгоритма.

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a + b</math>.
Координаты области таковы:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>.

Результат операции:

<math>\cdot</math> при <math>j < k - 1</math> является '''промежуточным''' данным алгоритма;

<math>\cdot</math> при <math>j = k - 1</math> является '''выходным''' данным <math>out[i]</math>.

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

[[Файл:new_sparse.png|thumb|center|1000px|Рис.2 Умножение разреженной матрицы на вектор. Информационный граф]]

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

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

~ 1 ярус умножений

~ <math>Z-1</math> операция сложения, где Z - максимальное число ненулевых элементов в строке.

Максимальное число требуемых процессоров - NZ.

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

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

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его как val);

~ массив номеров столбцов для соответствующих элементов массива val (обозначим его как col);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его row);

~ вектор, на который будет умножаться матрица (обозначим его vec).

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

Для матрицы размером <math>N\times M</math>, содержащей в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>,

~ вектор val - NZ элементов;

~ вектор col - NZ элементов;

~ вектор row - N+1 элемент;

~ вектор vec - M элементов.

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

Вектор out размером N.

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

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

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

Данный алгоритм обладает свойством детерминированности.

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

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

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

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

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

[[Файл:plot_more_points.png|thumb|center|1000px|Рис.3 Умножение разреженной матрицы на вектор. Масштабируемость]]

[[Файл:plot_eff.png|thumb|center|1000px|Рис.4 Умножение разреженной матрицы на вектор. Эффективность]]

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

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

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

Эффективная работа с разреженными матрицами реализована во многих библиотеках, например, [https://software.intel.com/en-us/intel-mkl Intel Math Kernel Library], базирующуюся на библиотеках BLAS и LAPACK, также математических пакет [http://matlab.ru/products/matlab Matlab] имеет собственную реализацию.

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

[1] Писсанецки С. Технология разреженных матриц. - М.: Мир, 1988. — 410 с.

[2] https://software.intel.com/sites/default/files/m/d/4/1/d/8/LW_SparseMM_ppt.pdf

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-11-15T22:45:53Z

Сергей:

{{Assignment|Dan}}

Автор: [[U:Сергей|Герасимов Сергей]] (619)

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

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

'''Разреженная матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается плотной.

Нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:

~ есть O(n). Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;

~ в каждой строке не превышает 10 в типичном случае;

~ ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.

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

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

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

По-видимому, наиболее очевидным способом хранения произвольной разреженной матрицы является '''координатный формат''': хранятся только ненулевые элементы матрицы, и их координаты (номера строк и столбцов). При данном подходе хранение матрицы A можно обеспечить в трех одномерных массивах:

~ массив ненулевых элементов матрицы A (обозначим его как values);

~ массив номеров строк матрицы A, соответствующих элементам массива values (обозначим его как rows);

~ массив номеров столбцов матрицы A, соответствующих элементам массива values (обозначим его как cols);

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

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

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

В соответствии с рассматриваемой схемой для хранения матрицы A требуется три одномерных массива:

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его опять как values);

~ массив номеров столбцов для соответствующих элементов массива values (обозначим его как cols);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его pointer). Описание k-й строки хранится в позициях с pointer[k]-й по (pointer[k+1]–1)-ю массивов values и cols. Если pointer[k]=pointer[k+1], то k-я строка пустая. Если матрица A состоит из n строк, то длина массива pointer будет n+1.

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

Очевидно, что объем памяти, требуемый для хранения вектора pointer, значительно меньше, чем для хранения вектора rows. Более того, разреженный строчный формат обеспечивает эффективный доступ к строчкам матрицы; доступ к столбцам по прежнему затруднен. Поэтому предпочтительно использовать этот способ хранения в тех алгоритмах, в которых преобладают строчные операции.

Существует также '''разреженный столбцовый формат''', который строится аналогичным способом.

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

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

Пусть матрица размером <math>N\times M</math> содержит в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>

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

На входе у нас 4 массива: val(ненулевые элементы матрицы), col(номера столбцов), row(массив указателей) и vec(вектор, на который мы умножаем матрицу).

На выходе получим вектор out.

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}, \ i=\overline{0,N-1}</math>, где <math>N</math> - число строк матрицы.

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

Ядром алгоритма является вычисление сумм произведений:

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}</math>

Итого: <math>NZ</math> умножений + <math>x</math> сложений(<math>NZ-N<x<NZ-1</math>).

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

Метод состоит из вычисления неполных скалярных произведений.

[[Файл:sparse.jpg|thumb|center|500px|Рис.1 Умножение разреженной матрицы на вектор]]

Элементы из массива val умножаются на элементы из массива vec с соответствующим индексом. Черным отмечены ненулевые элементы.

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

Предполагается, что матрица представлена в разреженном строчном формате.

for(i=0; i<N; i++)
{
out[i]=0;
for(j=row[i]; j<row[i+1]; j++)
{
out[i] += val[j]*vec[col[j]];
}
}

Внешний цикл - цикл по элементам выходного вектора. Внутренний - цикл по строкам разреженной матрицы.
Во внутреннем цикле реализовано накопление сумм произведений в выходной элемент.
Индекс ''j'' показывает с какого по какой элемент нужно считать из ''val'' (вектор с ненулевыми значениями матрицы), а также позволяет определить в каких столбцах расположены эти значения в матрице (с помощью вектора ''col'').
Минимальное и максимальное значение ''j'' узнается из вектора ''row''.

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

<math>\bullet \ NZ</math> умножений

<math>\bullet \ x</math> сложений(<math>NZ-N<x<NZ-1</math>).

Всего <math>2NZ</math> операций, где <math>NZ</math> - количество ненулевых элементов.

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

Опишем граф алгоритма.

Граф алгоритма состоит из двух групп вершин, расположенных в целочисленных узлах двух областей одной размерности.

'''Первая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a \cdot b</math>. Координаты области следующие:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math> k </math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>. (На рисунке вместо обозначения ''row'' использовано обозначение ''r'').

Результаты операции - '''промежуточные''' данные алгоритма.

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a + b</math>.
Координаты области таковы:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>.

Результат операции:

<math>\cdot</math> при <math>j < k - 1</math> является '''промежуточным''' данным алгоритма;

<math>\cdot</math> при <math>j = k - 1</math> является '''выходным''' данным <math>out[i]</math>.

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

[[Файл:new_sparse.png|thumb|center|1000px|Рис.2 Умножение разреженной матрицы на вектор. Информационный граф]]

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

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

~ 1 ярус умножений

~ <math>Z-1</math> операция сложения, где Z - максимальное число ненулевых элементов в строке.

Максимальное число требуемых процессоров - NZ.

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

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

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его как val);

~ массив номеров столбцов для соответствующих элементов массива val (обозначим его как col);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его row);

~ вектор, на который будет умножаться матрица (обозначим его vec).

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

Для матрицы размером <math>N\times M</math>, содержащей в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>,

~ вектор val - NZ элементов;

~ вектор col - NZ элементов;

~ вектор row - N+1 элемент;

~ вектор vec - M элементов.

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

Вектор out размером N.

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

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

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

Данный алгоритм обладает свойством детерминированности.

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

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

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

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

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

[[Файл:plot_more_points.png|thumb|center|1000px|Рис.3 Умножение разреженной матрицы на вектор. MPI]]

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

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

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

Эффективная работа с разреженными матрицами реализована во многих библиотеках, например, [https://software.intel.com/en-us/intel-mkl Intel Math Kernel Library], базирующуюся на библиотеках BLAS и LAPACK, также математических пакет [http://matlab.ru/products/matlab Matlab] имеет собственную реализацию.

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

[1] Писсанецки С. Технология разреженных матриц. - М.: Мир, 1988. — 410 с.

[2] https://software.intel.com/sites/default/files/m/d/4/1/d/8/LW_SparseMM_ppt.pdf

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-11-15T16:10:50Z

Сергей:

{{Assignment|Dan}}

Автор: [[U:Сергей|Герасимов Сергей]] (619)

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

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

'''Разреженная матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается плотной.

Нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:

~ есть O(n). Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;

~ в каждой строке не превышает 10 в типичном случае;

~ ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.

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

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

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

По-видимому, наиболее очевидным способом хранения произвольной разреженной матрицы является '''координатный формат''': хранятся только ненулевые элементы матрицы, и их координаты (номера строк и столбцов). При данном подходе хранение матрицы A можно обеспечить в трех одномерных массивах:

~ массив ненулевых элементов матрицы A (обозначим его как values);

~ массив номеров строк матрицы A, соответствующих элементам массива values (обозначим его как rows);

~ массив номеров столбцов матрицы A, соответствующих элементам массива values (обозначим его как cols);

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

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

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

В соответствии с рассматриваемой схемой для хранения матрицы A требуется три одномерных массива:

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его опять как values);

~ массив номеров столбцов для соответствующих элементов массива values (обозначим его как cols);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его pointer). Описание k-й строки хранится в позициях с pointer[k]-й по (pointer[k+1]–1)-ю массивов values и cols. Если pointer[k]=pointer[k+1], то k-я строка пустая. Если матрица A состоит из n строк, то длина массива pointer будет n+1.

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

Очевидно, что объем памяти, требуемый для хранения вектора pointer, значительно меньше, чем для хранения вектора rows. Более того, разреженный строчный формат обеспечивает эффективный доступ к строчкам матрицы; доступ к столбцам по прежнему затруднен. Поэтому предпочтительно использовать этот способ хранения в тех алгоритмах, в которых преобладают строчные операции.

Существует также '''разреженный столбцовый формат''', который строится аналогичным способом.

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

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

Пусть матрица размером <math>N\times M</math> содержит в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>

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

На входе у нас 4 массива: val(ненулевые элементы матрицы), col(номера столбцов), row(массив указателей) и vec(вектор, на который мы умножаем матрицу).

На выходе получим вектор out.

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}, \ i=\overline{0,N-1}</math>, где <math>N</math> - число строк матрицы.

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

Ядром алгоритма является вычисление сумм произведений:

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}</math>

Итого: <math>NZ</math> умножений + <math>x</math> сложений(<math>NZ-N<x<NZ-1</math>).

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

Метод состоит из вычисления неполных скалярных произведений.

[[Файл:sparse.jpg|thumb|center|500px|Рис.1 Умножение разреженной матрицы на вектор]]

Элементы из массива val умножаются на элементы из массива vec с соответствующим индексом. Черным отмечены ненулевые элементы.

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

Предполагается, что матрица представлена в разреженном строчном формате.

for(i=0; i<N; i++)
{
out[i]=0;
for(j=row[i]; j<row[i+1]; j++)
{
out[i] += val[j]*vec[col[j]];
}
}

Внешний цикл - цикл по элементам выходного вектора. Внутренний - цикл по строкам разреженной матрицы.
Во внутреннем цикле реализовано накопление сумм произведений в выходной элемент.
Индекс ''j'' показывает с какого по какой элемент нужно считать из ''val'' (вектор с ненулевыми значениями матрицы), а также позволяет определить в каких столбцах расположены эти значения в матрице (с помощью вектора ''col'').
Минимальное и максимальное значение ''j'' узнается из вектора ''row''.

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

<math>\bullet \ NZ</math> умножений

<math>\bullet \ x</math> сложений(<math>NZ-N<x<NZ-1</math>).

Всего <math>2NZ</math> операций, где <math>NZ</math> - количество ненулевых элементов.

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

Опишем граф алгоритма.

Граф алгоритма состоит из двух групп вершин, расположенных в целочисленных узлах двух областей одной размерности.

'''Первая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a \cdot b</math>. Координаты области следующие:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math> k </math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>. (На рисунке вместо обозначения ''row'' использовано обозначение ''r'').

Результаты операции - '''промежуточные''' данные алгоритма.

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a + b</math>.
Координаты области таковы:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>.

Результат операции:

<math>\cdot</math> при <math>j < k - 1</math> является '''промежуточным''' данным алгоритма;

<math>\cdot</math> при <math>j = k - 1</math> является '''выходным''' данным <math>out[i]</math>.

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

[[Файл:new_sparse.png|thumb|center|1000px|Рис.2 Умножение разреженной матрицы на вектор. Информационный граф]]

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

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

~ 1 ярус умножений

~ <math>Z-1</math> операция сложения, где Z - максимальное число ненулевых элементов в строке.

Максимальное число требуемых процессоров - NZ.

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

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

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его как val);

~ массив номеров столбцов для соответствующих элементов массива val (обозначим его как col);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его row);

~ вектор, на который будет умножаться матрица (обозначим его vec).

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

Для матрицы размером <math>N\times M</math>, содержащей в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>,

~ вектор val - NZ элементов;

~ вектор col - NZ элементов;

~ вектор row - N+1 элемент;

~ вектор vec - M элементов.

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

Вектор out размером N.

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

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

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

Данный алгоритм обладает свойством детерминированности.

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

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

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

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

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

[[Файл:plot.png|thumb|center|1000px|Рис.3 Умножение разреженной матрицы на вектор. MPI]]

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

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

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

Эффективная работа с разреженными матрицами реализована во многих библиотеках, например, [https://software.intel.com/en-us/intel-mkl Intel Math Kernel Library], базирующуюся на библиотеках BLAS и LAPACK, также математических пакет [http://matlab.ru/products/matlab Matlab] имеет собственную реализацию.

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

[1] Писсанецки С. Технология разреженных матриц. - М.: Мир, 1988. — 410 с.

[2] https://software.intel.com/sites/default/files/m/d/4/1/d/8/LW_SparseMM_ppt.pdf

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-11-15T13:36:13Z

Сергей:

{{Assignment}}

Автор: [[U:Сергей|Герасимов Сергей]] (619)

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

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

'''Разреженная матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается плотной.

Нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:

~ есть O(n). Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;

~ в каждой строке не превышает 10 в типичном случае;

~ ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.

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

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

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

По-видимому, наиболее очевидным способом хранения произвольной разреженной матрицы является '''координатный формат''': хранятся только ненулевые элементы матрицы, и их координаты (номера строк и столбцов). При данном подходе хранение матрицы A можно обеспечить в трех одномерных массивах:

~ массив ненулевых элементов матрицы A (обозначим его как values);

~ массив номеров строк матрицы A, соответствующих элементам массива values (обозначим его как rows);

~ массив номеров столбцов матрицы A, соответствующих элементам массива values (обозначим его как cols);

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

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

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

В соответствии с рассматриваемой схемой для хранения матрицы A требуется три одномерных массива:

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его опять как values);

~ массив номеров столбцов для соответствующих элементов массива values (обозначим его как cols);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его pointer). Описание k-й строки хранится в позициях с pointer[k]-й по (pointer[k+1]–1)-ю массивов values и cols. Если pointer[k]=pointer[k+1], то k-я строка пустая. Если матрица A состоит из n строк, то длина массива pointer будет n+1.

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

Очевидно, что объем памяти, требуемый для хранения вектора pointer, значительно меньше, чем для хранения вектора rows. Более того, разреженный строчный формат обеспечивает эффективный доступ к строчкам матрицы; доступ к столбцам по прежнему затруднен. Поэтому предпочтительно использовать этот способ хранения в тех алгоритмах, в которых преобладают строчные операции.

Существует также '''разреженный столбцовый формат''', который строится аналогичным способом.

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

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

Пусть матрица размером <math>N\times M</math> содержит в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>

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

На входе у нас 4 массива: val(ненулевые элементы матрицы), col(номера столбцов), row(массив указателей) и vec(вектор, на который мы умножаем матрицу).

На выходе получим вектор out.

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}, \ i=\overline{0,N-1}</math>, где <math>N</math> - число строк матрицы.

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

Ядром алгоритма является вычисление сумм произведений:

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}</math>

Итого: <math>NZ</math> умножений + <math>x</math> сложений(<math>NZ-N<x<NZ-1</math>).

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

Метод состоит из вычисления неполных скалярных произведений.

[[Файл:sparse.jpg|thumb|center|500px|Рис.1 Умножение разреженной матрицы на вектор]]

Элементы из массива val умножаются на элементы из массива vec с соответствующим индексом. Черным отмечены ненулевые элементы.

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

Предполагается, что матрица представлена в разреженном строчном формате.

for(i=0; i<N; i++)
{
out[i]=0;
for(j=row[i]; j<row[i+1]; j++)
{
out[i] += val[j]*vec[col[j]];
}
}

Внешний цикл - цикл по элементам выходного вектора. Внутренний - цикл по строкам разреженной матрицы.
Во внутреннем цикле реализовано накопление сумм произведений в выходной элемент.
Индекс ''j'' показывает с какого по какой элемент нужно считать из ''val'' (вектор с ненулевыми значениями матрицы), а также позволяет определить в каких столбцах расположены эти значения в матрице (с помощью вектора ''col'').
Минимальное и максимальное значение ''j'' узнается из вектора ''row''.

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

<math>\bullet \ NZ</math> умножений

<math>\bullet \ x</math> сложений(<math>NZ-N<x<NZ-1</math>).

Всего <math>2NZ</math> операций, где <math>NZ</math> - количество ненулевых элементов.

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

Опишем граф алгоритма.

Граф алгоритма состоит из двух групп вершин, расположенных в целочисленных узлах двух областей одной размерности.

'''Первая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a \cdot b</math>. Координаты области следующие:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math> k </math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>. (На рисунке вместо обозначения ''row'' использовано обозначение ''r'').

Результаты операции - '''промежуточные''' данные алгоритма.

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a + b</math>.
Координаты области таковы:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>.

Результат операции:

<math>\cdot</math> при <math>j < k - 1</math> является '''промежуточным''' данным алгоритма;

<math>\cdot</math> при <math>j = k - 1</math> является '''выходным''' данным <math>out[i]</math>.

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

[[Файл:new_sparse.png|thumb|center|1000px|Рис.2 Умножение разреженной матрицы на вектор. Информационный граф]]

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

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

~ 1 ярус умножений

~ <math>Z-1</math> операция сложения, где Z - максимальное число ненулевых элементов в строке.

Максимальное число требуемых процессоров - NZ.

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

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

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его как val);

~ массив номеров столбцов для соответствующих элементов массива val (обозначим его как col);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его row);

~ вектор, на который будет умножаться матрица (обозначим его vec).

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

Для матрицы размером <math>N\times M</math>, содержащей в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>,

~ вектор val - NZ элементов;

~ вектор col - NZ элементов;

~ вектор row - N+1 элемент;

~ вектор vec - M элементов.

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

Вектор out размером N.

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

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

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

Данный алгоритм обладает свойством детерминированности.

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

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

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

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

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

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

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

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

Эффективная работа с разреженными матрицами реализована во многих библиотеках, например, [https://software.intel.com/en-us/intel-mkl Intel Math Kernel Library], базирующуюся на библиотеках BLAS и LAPACK, также математических пакет [http://matlab.ru/products/matlab Matlab] имеет собственную реализацию.

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

[1] Писсанецки С. Технология разреженных матриц. - М.: Мир, 1988. — 410 с.

[2] https://software.intel.com/sites/default/files/m/d/4/1/d/8/LW_SparseMM_ppt.pdf

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-11-15T13:33:43Z

Сергей:

Автор: [[U:Сергей|Герасимов Сергей]] (619)

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

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

'''Разреженная матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается плотной.

Нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:

~ есть O(n). Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;

~ в каждой строке не превышает 10 в типичном случае;

~ ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.

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

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

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

По-видимому, наиболее очевидным способом хранения произвольной разреженной матрицы является '''координатный формат''': хранятся только ненулевые элементы матрицы, и их координаты (номера строк и столбцов). При данном подходе хранение матрицы A можно обеспечить в трех одномерных массивах:

~ массив ненулевых элементов матрицы A (обозначим его как values);

~ массив номеров строк матрицы A, соответствующих элементам массива values (обозначим его как rows);

~ массив номеров столбцов матрицы A, соответствующих элементам массива values (обозначим его как cols);

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

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

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

В соответствии с рассматриваемой схемой для хранения матрицы A требуется три одномерных массива:

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его опять как values);

~ массив номеров столбцов для соответствующих элементов массива values (обозначим его как cols);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его pointer). Описание k-й строки хранится в позициях с pointer[k]-й по (pointer[k+1]–1)-ю массивов values и cols. Если pointer[k]=pointer[k+1], то k-я строка пустая. Если матрица A состоит из n строк, то длина массива pointer будет n+1.

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

Очевидно, что объем памяти, требуемый для хранения вектора pointer, значительно меньше, чем для хранения вектора rows. Более того, разреженный строчный формат обеспечивает эффективный доступ к строчкам матрицы; доступ к столбцам по прежнему затруднен. Поэтому предпочтительно использовать этот способ хранения в тех алгоритмах, в которых преобладают строчные операции.

Существует также '''разреженный столбцовый формат''', который строится аналогичным способом.

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

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

Пусть матрица размером <math>N\times M</math> содержит в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>

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

На входе у нас 4 массива: val(ненулевые элементы матрицы), col(номера столбцов), row(массив указателей) и vec(вектор, на который мы умножаем матрицу).

На выходе получим вектор out.

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}, \ i=\overline{0,N-1}</math>, где <math>N</math> - число строк матрицы.

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

Ядром алгоритма является вычисление сумм произведений:

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}</math>

Итого: <math>NZ</math> умножений + <math>x</math> сложений(<math>NZ-N<x<NZ-1</math>).

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

Метод состоит из вычисления неполных скалярных произведений.

[[Файл:sparse.jpg|thumb|center|500px|Рис.1 Умножение разреженной матрицы на вектор]]

Элементы из массива val умножаются на элементы из массива vec с соответствующим индексом. Черным отмечены ненулевые элементы.

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

Предполагается, что матрица представлена в разреженном строчном формате.

for(i=0; i<N; i++)
{
out[i]=0;
for(j=row[i]; j<row[i+1]; j++)
{
out[i] += val[j]*vec[col[j]];
}
}

Внешний цикл - цикл по элементам выходного вектора. Внутренний - цикл по строкам разреженной матрицы.
Во внутреннем цикле реализовано накопление сумм произведений в выходной элемент.
Индекс ''j'' показывает с какого по какой элемент нужно считать из ''val'' (вектор с ненулевыми значениями матрицы), а также позволяет определить в каких столбцах расположены эти значения в матрице (с помощью вектора ''col'').
Минимальное и максимальное значение ''j'' узнается из вектора ''row''.

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

<math>\bullet \ NZ</math> умножений

<math>\bullet \ x</math> сложений(<math>NZ-N<x<NZ-1</math>).

Всего <math>2NZ</math> операций, где <math>NZ</math> - количество ненулевых элементов.

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

Опишем граф алгоритма.

Граф алгоритма состоит из двух групп вершин, расположенных в целочисленных узлах двух областей одной размерности.

'''Первая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a \cdot b</math>. Координаты области следующие:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math> k </math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>. (На рисунке вместо обозначения ''row'' использовано обозначение ''r'').

Результаты операции - '''промежуточные''' данные алгоритма.

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a + b</math>.
Координаты области таковы:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>.

Результат операции:

<math>\cdot</math> при <math>j < k - 1</math> является '''промежуточным''' данным алгоритма;

<math>\cdot</math> при <math>j = k - 1</math> является '''выходным''' данным <math>out[i]</math>.

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

[[Файл:new_sparse.png|thumb|center|1000px|Рис.2 Умножение разреженной матрицы на вектор. Информационный граф]]

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

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

~ 1 ярус умножений

~ <math>Z-1</math> операция сложения, где Z - максимальное число ненулевых элементов в строке.

Максимальное число требуемых процессоров - NZ.

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

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

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его как val);

~ массив номеров столбцов для соответствующих элементов массива val (обозначим его как col);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его row);

~ вектор, на который будет умножаться матрица (обозначим его vec).

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

Для матрицы размером <math>N\times M</math>, содержащей в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>,

~ вектор val - NZ элементов;

~ вектор col - NZ элементов;

~ вектор row - N+1 элемент;

~ вектор vec - M элементов.

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

Вектор out размером N.

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

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

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

Данный алгоритм обладает свойством детерминированности.

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

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

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

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

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

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

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

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

Эффективная работа с разреженными матрицами реализована во многих библиотеках, например, [https://software.intel.com/en-us/intel-mkl Intel Math Kernel Library], базирующуюся на библиотеках BLAS и LAPACK, также математических пакет [http://matlab.ru/products/matlab Matlab] имеет собственную реализацию.

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

[1] Писсанецки С. Технология разреженных матриц. - М.: Мир, 1988. — 410 с.

[2] https://software.intel.com/sites/default/files/m/d/4/1/d/8/LW_SparseMM_ppt.pdf

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-11-15T13:32:02Z

Сергей:

Автор: [[U:Сергей|Герасимов Сергей]] (619)

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

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

'''Разреженная матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается плотной.

Нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:

~ есть O(n). Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;

~ в каждой строке не превышает 10 в типичном случае;

~ ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.

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

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

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

По-видимому, наиболее очевидным способом хранения произвольной разреженной матрицы является '''координатный формат''': хранятся только ненулевые элементы матрицы, и их координаты (номера строк и столбцов). При данном подходе хранение матрицы A можно обеспечить в трех одномерных массивах:

~ массив ненулевых элементов матрицы A (обозначим его как values);

~ массив номеров строк матрицы A, соответствующих элементам массива values (обозначим его как rows);

~ массив номеров столбцов матрицы A, соответствующих элементам массива values (обозначим его как cols);

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

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

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

В соответствии с рассматриваемой схемой для хранения матрицы A требуется три одномерных массива:

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его опять как values);

~ массив номеров столбцов для соответствующих элементов массива values (обозначим его как cols);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его pointer). Описание k-й строки хранится в позициях с pointer[k]-й по (pointer[k+1]–1)-ю массивов values и cols. Если pointer[k]=pointer[k+1], то k-я строка пустая. Если матрица A состоит из n строк, то длина массива pointer будет n+1.

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

Очевидно, что объем памяти, требуемый для хранения вектора pointer, значительно меньше, чем для хранения вектора rows. Более того, разреженный строчный формат обеспечивает эффективный доступ к строчкам матрицы; доступ к столбцам по прежнему затруднен. Поэтому предпочтительно использовать этот способ хранения в тех алгоритмах, в которых преобладают строчные операции.

Существует также '''разреженный столбцовый формат''', который строится аналогичным способом.

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

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

Пусть матрица размером <math>N\times M</math> содержит в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>

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

На входе у нас 4 массива: val(ненулевые элементы матрицы), col(номера столбцов), row(массив указателей) и vec(вектор, на который мы умножаем матрицу).

На выходе получим вектор out.

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}, \ i=\overline{0,N-1}</math>, где <math>N</math> - число строк матрицы.

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

Ядром алгоритма является вычисление сумм произведений:

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}</math>

Итого: <math>NZ</math> умножений + <math>x</math> сложений(<math>NZ-N<x<NZ-1</math>).

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

Метод состоит из вычисления неполных скалярных произведений.

[[Файл:sparse.jpg|thumb|center|500px|Рис.1 Умножение разреженной матрицы на вектор]]

Элементы из массива val умножаются на элементы из массива vec с соответствующим индексом. Черным отмечены ненулевые элементы.

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

Предполагается, что матрица представлена в разреженном строчном формате.

for(i=0; i<N; i++)
{
out[i]=0;
for(j=row[i]; j<row[i+1]; j++)
{
out[i] += val[j]*vec[col[j]];
}
}

Внешний цикл - цикл по элементам выходного вектора. Внутренний - цикл по строкам разреженной матрицы.
Во внутреннем цикле реализовано накопление сумм произведений в выходной элемент.
Индекс ''j'' показывает с какого по какой элемент нужно считать из ''val'' (вектор с ненулевыми значениями матрицы), а также позволяет определить в каких столбцах расположены эти значения в матрице (с помощью вектора ''col'').
Минимальное и максимальное значение ''j'' узнается из вектора ''row''.

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

<math>\bullet \ NZ</math> умножений

<math>\bullet \ x</math> сложений(<math>NZ-N<x<NZ-1</math>).

Всего <math>2NZ</math> операций, где <math>NZ</math> - количество ненулевых элементов.

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

Опишем граф алгоритма.

Граф алгоритма состоит из двух групп вершин, расположенных в целочисленных узлах двух областей одной размерности.

'''Первая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a \cdot b</math>. Координаты области следующие:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math> k </math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>. (На рисунке вместо обозначения ''row'' использовано обозначение ''r'').

Результаты операции - '''промежуточные''' данные алгоритма.

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a + b</math>.
Координаты области таковы:

<math>\cdot</math> <math>i</math> - меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> - меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>.

Результат операции:
<math>\cdot</math> при <math>j < k - 1</math> является '''промежуточным''' данным алгоритма;
<math>\cdot</math> при <math>j = k - 1</math> является '''выходным''' данным <math>out[i]</math>.

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

[[Файл:new_sparse.png|thumb|center|1000px|Рис.2 Умножение разреженной матрицы на вектор. Информационный граф]]

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

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

~ 1 ярус умножений

~ <math>Z-1</math> операция сложения, где Z - максимальное число ненулевых элементов в строке.

Максимальное число требуемых процессоров - NZ.

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

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

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его как val);

~ массив номеров столбцов для соответствующих элементов массива val (обозначим его как col);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его row);

~ вектор, на который будет умножаться матрица (обозначим его vec).

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

Для матрицы размером <math>N\times M</math>, содержащей в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>,

~ вектор val - NZ элементов;

~ вектор col - NZ элементов;

~ вектор row - N+1 элемент;

~ вектор vec - M элементов.

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

Вектор out размером N.

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

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

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

Данный алгоритм обладает свойством детерминированности.

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

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

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

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

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

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

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

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

Эффективная работа с разреженными матрицами реализована во многих библиотеках, например, [https://software.intel.com/en-us/intel-mkl Intel Math Kernel Library], базирующуюся на библиотеках BLAS и LAPACK, также математических пакет [http://matlab.ru/products/matlab Matlab] имеет собственную реализацию.

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

[1] Писсанецки С. Технология разреженных матриц. - М.: Мир, 1988. — 410 с.

[2] https://software.intel.com/sites/default/files/m/d/4/1/d/8/LW_SparseMM_ppt.pdf

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-11-15T13:31:07Z

Сергей:

Автор: [[U:Сергей|Герасимов Сергей]] (619)

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

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

'''Разреженная матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается плотной.

Нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:

~ есть O(n). Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;

~ в каждой строке не превышает 10 в типичном случае;

~ ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.

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

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

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

По-видимому, наиболее очевидным способом хранения произвольной разреженной матрицы является '''координатный формат''': хранятся только ненулевые элементы матрицы, и их координаты (номера строк и столбцов). При данном подходе хранение матрицы A можно обеспечить в трех одномерных массивах:

~ массив ненулевых элементов матрицы A (обозначим его как values);

~ массив номеров строк матрицы A, соответствующих элементам массива values (обозначим его как rows);

~ массив номеров столбцов матрицы A, соответствующих элементам массива values (обозначим его как cols);

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

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

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

В соответствии с рассматриваемой схемой для хранения матрицы A требуется три одномерных массива:

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его опять как values);

~ массив номеров столбцов для соответствующих элементов массива values (обозначим его как cols);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его pointer). Описание k-й строки хранится в позициях с pointer[k]-й по (pointer[k+1]–1)-ю массивов values и cols. Если pointer[k]=pointer[k+1], то k-я строка пустая. Если матрица A состоит из n строк, то длина массива pointer будет n+1.

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

Очевидно, что объем памяти, требуемый для хранения вектора pointer, значительно меньше, чем для хранения вектора rows. Более того, разреженный строчный формат обеспечивает эффективный доступ к строчкам матрицы; доступ к столбцам по прежнему затруднен. Поэтому предпочтительно использовать этот способ хранения в тех алгоритмах, в которых преобладают строчные операции.

Существует также '''разреженный столбцовый формат''', который строится аналогичным способом.

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

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

Пусть матрица размером <math>N\times M</math> содержит в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>

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

На входе у нас 4 массива: val(ненулевые элементы матрицы), col(номера столбцов), row(массив указателей) и vec(вектор, на который мы умножаем матрицу).

На выходе получим вектор out.

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}, \ i=\overline{0,N-1}</math>, где <math>N</math> - число строк матрицы.

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

Ядром алгоритма является вычисление сумм произведений:

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}</math>

Итого: <math>NZ</math> умножений + <math>x</math> сложений(<math>NZ-N<x<NZ-1</math>).

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

Метод состоит из вычисления неполных скалярных произведений.

[[Файл:sparse.jpg|thumb|center|500px|Рис.1 Умножение разреженной матрицы на вектор]]

Элементы из массива val умножаются на элементы из массива vec с соответствующим индексом. Черным отмечены ненулевые элементы.

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

Предполагается, что матрица представлена в разреженном строчном формате.

for(i=0; i<N; i++)
{
out[i]=0;
for(j=row[i]; j<row[i+1]; j++)
{
out[i] += val[j]*vec[col[j]];
}
}

Внешний цикл - цикл по элементам выходного вектора. Внутренний - цикл по строкам разреженной матрицы.
Во внутреннем цикле реализовано накопление сумм произведений в выходной элемент.
Индекс ''j'' показывает с какого по какой элемент нужно считать из ''val'' (вектор с ненулевыми значениями матрицы), а также позволяет определить в каких столбцах расположены эти значения в матрице (с помощью вектора ''col'').
Минимальное и максимальное значение ''j'' узнается из вектора ''row''.

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

<math>\bullet \ NZ</math> умножений

<math>\bullet \ x</math> сложений(<math>NZ-N<x<NZ-1</math>).

Всего <math>2NZ</math> операций, где <math>NZ</math> - количество ненулевых элементов.

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

Опишем граф алгоритма.

Граф алгоритма состоит из двух групп вершин, расположенных в целочисленных узлах двух областей одной размерности.

'''Первая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a \cdot b</math>. Координаты области следующие:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;
<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math> k </math>, принимая все натуральные значения,
где <math>k = k(i) = row[i+1]-row[i]</math>. (На рисунке вместо обозначения ''row'' использовано обозначение ''r'').

Результаты операции - '''промежуточные''' данные алгоритма.

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a + b</math>.
Координаты области таковы:

<math>\cdot</math> <math>i</math> - меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все целочисленные значения;
<math>\cdot</math> <math>j</math> - меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все целочисленные значения,
где <math>k = k(i) = row[i+1]-row[i]</math>.

Результат операции:
<math>\cdot</math> при <math>j < k - 1</math> является '''промежуточным''' данным алгоритма;
<math>\cdot</math> при <math>j = k - 1</math> является '''выходным''' данным <math>out[i]</math>.

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

[[Файл:new_sparse.png|thumb|center|1000px|Рис.2 Умножение разреженной матрицы на вектор. Информационный граф]]

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

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

~ 1 ярус умножений

~ <math>Z-1</math> операция сложения, где Z - максимальное число ненулевых элементов в строке.

Максимальное число требуемых процессоров - NZ.

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

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

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его как val);

~ массив номеров столбцов для соответствующих элементов массива val (обозначим его как col);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его row);

~ вектор, на который будет умножаться матрица (обозначим его vec).

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

Для матрицы размером <math>N\times M</math>, содержащей в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>,

~ вектор val - NZ элементов;

~ вектор col - NZ элементов;

~ вектор row - N+1 элемент;

~ вектор vec - M элементов.

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

Вектор out размером N.

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

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

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

Данный алгоритм обладает свойством детерминированности.

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

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

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

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

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

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

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

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

Эффективная работа с разреженными матрицами реализована во многих библиотеках, например, [https://software.intel.com/en-us/intel-mkl Intel Math Kernel Library], базирующуюся на библиотеках BLAS и LAPACK, также математических пакет [http://matlab.ru/products/matlab Matlab] имеет собственную реализацию.

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

[1] Писсанецки С. Технология разреженных матриц. - М.: Мир, 1988. — 410 с.

[2] https://software.intel.com/sites/default/files/m/d/4/1/d/8/LW_SparseMM_ppt.pdf

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-11-15T13:15:00Z

Сергей:

Автор: [[U:Сергей|Герасимов Сергей]] (619)

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

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

'''Разреженная матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается плотной.

Нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:

~ есть O(n). Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;

~ в каждой строке не превышает 10 в типичном случае;

~ ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.

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

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

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

По-видимому, наиболее очевидным способом хранения произвольной разреженной матрицы является '''координатный формат''': хранятся только ненулевые элементы матрицы, и их координаты (номера строк и столбцов). При данном подходе хранение матрицы A можно обеспечить в трех одномерных массивах:

~ массив ненулевых элементов матрицы A (обозначим его как values);

~ массив номеров строк матрицы A, соответствующих элементам массива values (обозначим его как rows);

~ массив номеров столбцов матрицы A, соответствующих элементам массива values (обозначим его как cols);

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

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

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

В соответствии с рассматриваемой схемой для хранения матрицы A требуется три одномерных массива:

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его опять как values);

~ массив номеров столбцов для соответствующих элементов массива values (обозначим его как cols);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его pointer). Описание k-й строки хранится в позициях с pointer[k]-й по (pointer[k+1]–1)-ю массивов values и cols. Если pointer[k]=pointer[k+1], то k-я строка пустая. Если матрица A состоит из n строк, то длина массива pointer будет n+1.

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

Очевидно, что объем памяти, требуемый для хранения вектора pointer, значительно меньше, чем для хранения вектора rows. Более того, разреженный строчный формат обеспечивает эффективный доступ к строчкам матрицы; доступ к столбцам по прежнему затруднен. Поэтому предпочтительно использовать этот способ хранения в тех алгоритмах, в которых преобладают строчные операции.

Существует также '''разреженный столбцовый формат''', который строится аналогичным способом.

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

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

Пусть матрица размером <math>N\times M</math> содержит в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>

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

На входе у нас 4 массива: val(ненулевые элементы матрицы), col(номера столбцов), row(массив указателей) и vec(вектор, на который мы умножаем матрицу).

На выходе получим вектор out.

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}, \ i=\overline{0,N-1}</math>, где <math>N</math> - число строк матрицы.

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

Ядром алгоритма является вычисление сумм произведений:

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}</math>

Итого: <math>NZ</math> умножений + <math>x</math> сложений(<math>NZ-N<x<NZ-1</math>).

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

Метод состоит из вычисления неполных скалярных произведений.

[[Файл:sparse.jpg|thumb|center|500px|Рис.1 Умножение разреженной матрицы на вектор]]

Элементы из массива val умножаются на элементы из массива vec с соответствующим индексом. Черным отмечены ненулевые элементы.

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

Предполагается, что матрица представлена в разреженном строчном формате.

for(i=0; i<N; i++)
{
out[i]=0;
for(j=row[i]; j<row[i+1]; j++)
{
out[i] += val[j]*vec[col[j]];
}
}

Внешний цикл - цикл по элементам выходного вектора. Внутренний - цикл по строкам разреженной матрицы.
Во внутреннем цикле реализовано накопление сумм произведений в выходной элемент.
Индекс ''j'' показывает с какого по какой элемент нужно считать из ''val'' (вектор с ненулевыми значениями матрицы), а также позволяет определить в каких столбцах расположены эти значения в матрице (с помощью вектора ''col'').
Минимальное и максимальное значение ''j'' узнается из вектора ''row''.

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

<math>\bullet \ NZ</math> умножений

<math>\bullet \ x</math> сложений(<math>NZ-N<x<NZ-1</math>).

Всего <math>2NZ</math> операций, где <math>NZ</math> - количество ненулевых элементов.

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

[[Файл:new_sparse.png|thumb|center|1000px|Рис.2 Умножение разреженной матрицы на вектор. Информационный граф]]

Элементы из массива val умножаются на элементы из массива vec с соответствующим индексом. Черным отмечены ненулевые элементы. При увеличении числа N граф будет аналогичным.

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

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

~ 1 ярус умножений

~ <math>Z-1</math> операция сложения, где Z - максимальное число ненулевых элементов в строке.

Максимальное число требуемых процессоров - NZ.

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

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

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его как val);

~ массив номеров столбцов для соответствующих элементов массива val (обозначим его как col);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его row);

~ вектор, на который будет умножаться матрица (обозначим его vec).

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

Для матрицы размером <math>N\times M</math>, содержащей в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>,

~ вектор val - NZ элементов;

~ вектор col - NZ элементов;

~ вектор row - N+1 элемент;

~ вектор vec - M элементов.

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

Вектор out размером N.

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

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

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

Данный алгоритм обладает свойством детерминированности.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

Эффективная работа с разреженными матрицами реализована во многих библиотеках, например, [https://software.intel.com/en-us/intel-mkl Intel Math Kernel Library], базирующуюся на библиотеках BLAS и LAPACK, также математических пакет [http://matlab.ru/products/matlab Matlab] имеет собственную реализацию.

== Литература ==

[1] Писсанецки С. Технология разреженных матриц. - М.: Мир, 1988. — 410 с.

[2] https://software.intel.com/sites/default/files/m/d/4/1/d/8/LW_SparseMM_ppt.pdf

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-11-15T13:12:52Z

Сергей:

Автор: [[U:Сергей|Герасимов Сергей]] (619)

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

'''Разреженная матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается плотной.

Нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:

~ есть O(n). Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;

~ в каждой строке не превышает 10 в типичном случае;

~ ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.

Огромные разрежённые матрицы часто возникают при решении таких задач, как дифференциальное уравнение в частных производных.

При хранении и преобразовании разрежённых матриц в компьютере бывает полезно, а часто и необходимо, использовать специальные алгоритмы и структуры данных, которые учитывают разрежённую структуру матрицы. Операции и алгоритмы, применяемые для работы с обычными, плотными матрицами, применительно к большим разрежённым матрицам работают относительно медленно и требуют значительных объёмов памяти. Однако разрежённые матрицы могут быть легко сжаты путём записи только своих ненулевых элементов, что снижает требования к компьютерной памяти.

'''Существуют различные форматы хранения разреженных матриц.''' Одни предназначены для хранения матриц специального вида (например, ленточных), другие обеспечивают работу с матрицами общего вида. Ниже рассмотрим некоторые весьма распространенные способы представления разреженных матриц.

По-видимому, наиболее очевидным способом хранения произвольной разреженной матрицы является '''координатный формат''': хранятся только ненулевые элементы матрицы, и их координаты (номера строк и столбцов). При данном подходе хранение матрицы A можно обеспечить в трех одномерных массивах:

~ массив ненулевых элементов матрицы A (обозначим его как values);

~ массив номеров строк матрицы A, соответствующих элементам массива values (обозначим его как rows);

~ массив номеров столбцов матрицы A, соответствующих элементам массива values (обозначим его как cols);

Данный способ представления называют полным, поскольку представлена вся матрица А, и неупорядоченным, поскольку элементы матрицы могут храниться в произвольном порядке.

Хотя многие математические библиотеки поддерживают матрично-векторные операции в координатном формате, данный формат обеспечивает медленный доступ к элементам матрицы, и является затратным по используемой памяти. В рассмотренном выше примере избыточность по памяти образом проявляется в массиве rows, в котором строчные координаты хранятся неоптимальным образом.

Перейдем далее к рассмотрению более экономных форматов хранения. '''Разреженный строчный формат''' - это одна из наиболее широко используемых схем хранения разреженных матриц. Эта схема предъявляет минимальные требования к памяти и в то же время оказывается очень удобной для нескольких важных операций над разреженными матрицами: сложения, умножения, перестановок строк и столбцов, транспонирования, решения линейных систем с разреженными матрицами коэффициентов как прямыми, так и итерационными методами и т. д.

В соответствии с рассматриваемой схемой для хранения матрицы A требуется три одномерных массива:

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его опять как values);

~ массив номеров столбцов для соответствующих элементов массива values (обозначим его как cols);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его pointer). Описание k-й строки хранится в позициях с pointer[k]-й по (pointer[k+1]–1)-ю массивов values и cols. Если pointer[k]=pointer[k+1], то k-я строка пустая. Если матрица A состоит из n строк, то длина массива pointer будет n+1.

Данный способ представления также является полным, и упорядоченным, поскольку элементы каждой строки хранятся в соответствии с возрастанием столбцовых индексов.

Очевидно, что объем памяти, требуемый для хранения вектора pointer, значительно меньше, чем для хранения вектора rows. Более того, разреженный строчный формат обеспечивает эффективный доступ к строчкам матрицы; доступ к столбцам по прежнему затруднен. Поэтому предпочтительно использовать этот способ хранения в тех алгоритмах, в которых преобладают строчные операции.

Существует также '''разреженный столбцовый формат''', который строится аналогичным способом.

Теперь, разобравшись со способами хранения разреженных матриц, можно перейти к ''алгоритму умножения разреженной матрицы на вектор''. Умножение матрицы на вектор является подзадачей для нахождения решений СЛАУ итерационными методами.

=== Математическое описание алгоритма ===

Пусть матрица размером <math>N\times M</math> содержит в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>

Условимся использовать строчный формат хранения матрицы, который описан выше.

На входе у нас 4 массива: val(ненулевые элементы матрицы), col(номера столбцов), row(массив указателей) и vec(вектор, на который мы умножаем матрицу).

На выходе получим вектор out.

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}, \ i=\overline{0,N-1}</math>, где <math>N</math> - число строк матрицы.

=== Вычислительное ядро алгоритма ===

Ядром алгоритма является вычисление сумм произведений:

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}</math>

Итого: <math>NZ</math> умножений + <math>x</math> сложений(<math>NZ-N<x<NZ-1</math>).

=== Макроструктура алгоритма ===

Метод состоит из вычисления неполных скалярных произведений.

[[Файл:sparse.jpg|thumb|center|500px|Рис.1 Умножение разреженной матрицы на вектор]]

Элементы из массива val умножаются на элементы из массива vec с соответствующим индексом. Черным отмечены ненулевые элементы.

=== Схема реализации последовательного алгоритма ===

Предполагается, что матрица представлена в разреженном строчном формате.

for(i=0; i<N; i++)
{
out[i]=0;
for(j=row[i]; j<row[i+1]; j++)
{
out[i] += val[j]*vec[col[j]];
}
}

Внешний цикл - цикл по элементам выходного вектора. Внутренний - цикл по строкам разреженной матрицы.
Во внутреннем цикле реализовано накопление сумм произведений в выходной элемент.
Индекс ''j'' показывает с какого по какой элемент нужно считать из ''val'' (вектор с ненулевыми значениями матрицы), а также позволяет определить в каких столбцах расположены эти значения в матрице (с помощью вектора ''col'').

=== Последовательная сложность алгоритма ===

<math>\bullet \ NZ</math> умножений

<math>\bullet \ x</math> сложений(<math>NZ-N<x<NZ-1</math>).

Всего <math>2NZ</math> операций, где <math>NZ</math> - количество ненулевых элементов.

=== Информационный граф ===

[[Файл:new_sparse.png|thumb|center|1000px|Рис.2 Умножение разреженной матрицы на вектор. Информационный граф]]

Элементы из массива val умножаются на элементы из массива vec с соответствующим индексом. Черным отмечены ненулевые элементы. При увеличении числа N граф будет аналогичным.

=== Ресурс параллелизма алгоритма ===

При наличии бесконечного числа процессоров для умножения разреженной матрицы на вектор потребуется:

~ 1 ярус умножений

~ <math>Z-1</math> операция сложения, где Z - максимальное число ненулевых элементов в строке.

Максимальное число требуемых процессоров - NZ.

=== Входные и выходные данные алгоритма ===

'''Входные данные:'''

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его как val);

~ массив номеров столбцов для соответствующих элементов массива val (обозначим его как col);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его row);

~ вектор, на который будет умножаться матрица (обозначим его vec).

'''Объем входных данных:'''

Для матрицы размером <math>N\times M</math>, содержащей в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>,

~ вектор val - NZ элементов;

~ вектор col - NZ элементов;

~ вектор row - N+1 элемент;

~ вектор vec - M элементов.

'''Выходные данные:'''

Вектор out размером N.

=== Свойства алгоритма ===

Соотношение последовательной и параллельной сложности в случае неограниченных ресурсов, как хорошо видно, является ''линейным''.

Вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных – чуть меньше ''единицы''.

Данный алгоритм обладает свойством детерминированности.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

Эффективная работа с разреженными матрицами реализована во многих библиотеках, например, [https://software.intel.com/en-us/intel-mkl Intel Math Kernel Library], базирующуюся на библиотеках BLAS и LAPACK, также математических пакет [http://matlab.ru/products/matlab Matlab] имеет собственную реализацию.

== Литература ==

[1] Писсанецки С. Технология разреженных матриц. - М.: Мир, 1988. — 410 с.

[2] https://software.intel.com/sites/default/files/m/d/4/1/d/8/LW_SparseMM_ppt.pdf

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-11-15T13:05:49Z

Сергей:

Автор: [[U:Сергей|Герасимов Сергей]] (619)

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

'''Разреженная матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается плотной.

Нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:

~ есть O(n). Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;

~ в каждой строке не превышает 10 в типичном случае;

~ ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.

Огромные разрежённые матрицы часто возникают при решении таких задач, как дифференциальное уравнение в частных производных.

При хранении и преобразовании разрежённых матриц в компьютере бывает полезно, а часто и необходимо, использовать специальные алгоритмы и структуры данных, которые учитывают разрежённую структуру матрицы. Операции и алгоритмы, применяемые для работы с обычными, плотными матрицами, применительно к большим разрежённым матрицам работают относительно медленно и требуют значительных объёмов памяти. Однако разрежённые матрицы могут быть легко сжаты путём записи только своих ненулевых элементов, что снижает требования к компьютерной памяти.

'''Существуют различные форматы хранения разреженных матриц.''' Одни предназначены для хранения матриц специального вида (например, ленточных), другие обеспечивают работу с матрицами общего вида. Ниже рассмотрим некоторые весьма распространенные способы представления разреженных матриц.

По-видимому, наиболее очевидным способом хранения произвольной разреженной матрицы является '''координатный формат''': хранятся только ненулевые элементы матрицы, и их координаты (номера строк и столбцов). При данном подходе хранение матрицы A можно обеспечить в трех одномерных массивах:

~ массив ненулевых элементов матрицы A (обозначим его как values);

~ массив номеров строк матрицы A, соответствующих элементам массива values (обозначим его как rows);

~ массив номеров столбцов матрицы A, соответствующих элементам массива values (обозначим его как cols);

Данный способ представления называют полным, поскольку представлена вся матрица А, и неупорядоченным, поскольку элементы матрицы могут храниться в произвольном порядке.

Хотя многие математические библиотеки поддерживают матрично-векторные операции в координатном формате, данный формат обеспечивает медленный доступ к элементам матрицы, и является затратным по используемой памяти. В рассмотренном выше примере избыточность по памяти образом проявляется в массиве rows, в котором строчные координаты хранятся неоптимальным образом.

Перейдем далее к рассмотрению более экономных форматов хранения. '''Разреженный строчный формат''' - это одна из наиболее широко используемых схем хранения разреженных матриц. Эта схема предъявляет минимальные требования к памяти и в то же время оказывается очень удобной для нескольких важных операций над разреженными матрицами: сложения, умножения, перестановок строк и столбцов, транспонирования, решения линейных систем с разреженными матрицами коэффициентов как прямыми, так и итерационными методами и т. д.

В соответствии с рассматриваемой схемой для хранения матрицы A требуется три одномерных массива:

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его опять как values);

~ массив номеров столбцов для соответствующих элементов массива values (обозначим его как cols);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его pointer). Описание k-й строки хранится в позициях с pointer[k]-й по (pointer[k+1]–1)-ю массивов values и cols. Если pointer[k]=pointer[k+1], то k-я строка пустая. Если матрица A состоит из n строк, то длина массива pointer будет n+1.

Данный способ представления также является полным, и упорядоченным, поскольку элементы каждой строки хранятся в соответствии с возрастанием столбцовых индексов.

Очевидно, что объем памяти, требуемый для хранения вектора pointer, значительно меньше, чем для хранения вектора rows. Более того, разреженный строчный формат обеспечивает эффективный доступ к строчкам матрицы; доступ к столбцам по прежнему затруднен. Поэтому предпочтительно использовать этот способ хранения в тех алгоритмах, в которых преобладают строчные операции.

Существует также '''разреженный столбцовый формат''', который строится аналогичным способом.

Теперь, разобравшись со способами хранения разреженных матриц, можно перейти к ''алгоритму умножения разреженной матрицы на вектор''. Умножение матрицы на вектор является подзадачей для нахождения решений СЛАУ итерационными методами.

=== Математическое описание алгоритма ===

Пусть матрица размером <math>N\times M</math> содержит в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>

Условимся использовать строчный формат хранения матрицы, который описан выше.

На входе у нас 4 массива: val(ненулевые элементы матрицы), col(номера столбцов), row(массив указателей) и vec(вектор, на который мы умножаем матрицу).

На выходе получим вектор out.

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}, \ i=\overline{0,N-1}</math>, где <math>N</math> - число строк матрицы.

=== Вычислительное ядро алгоритма ===

Ядром алгоритма является вычисление сумм произведений:

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}</math>

Итого: <math>NZ</math> умножений + <math>x</math> сложений(<math>NZ-N<x<NZ-1</math>).

=== Макроструктура алгоритма ===

Метод состоит из вычисления неполных скалярных произведений.

[[Файл:sparse.jpg|thumb|center|500px|Рис.1 Умножение разреженной матрицы на вектор]]

Элементы из массива val умножаются на элементы из массива vec с соответствующим индексом. Черным отмечены ненулевые элементы.

=== Схема реализации последовательного алгоритма ===

for(i=0; i<N; i++)
{
out[i]=0;
for(j=row[i]; j<row[i+1]; j++)
{
out[i] += val[j]*vec[col[j]];
}
}

Внешний цикл - цикл по элементам выходного вектора. Внутренний - цикл по строкам разреженной матрицы.
Во внутреннем цикле реализовано накопление сумм произведений в выходной элемент.

=== Последовательная сложность алгоритма ===

<math>\bullet \ NZ</math> умножений

<math>\bullet \ x</math> сложений(<math>NZ-N<x<NZ-1</math>).

Всего <math>2NZ</math> операций, где <math>NZ</math> - количество ненулевых элементов.

=== Информационный граф ===

[[Файл:new_sparse.png|thumb|center|700px|Рис.2 Умножение разреженной матрицы на вектор. Информационный граф]]

Элементы из массива val умножаются на элементы из массива vec с соответствующим индексом. Черным отмечены ненулевые элементы. При увеличении числа N граф будет аналогичным.

=== Ресурс параллелизма алгоритма ===

При наличии бесконечного числа процессоров для умножения разреженной матрицы на вектор потребуется:

~ 1 ярус умножений

~ <math>Z-1</math> операция сложения, где Z - максимальное число ненулевых элементов в строке.

Максимальное число требуемых процессоров - NZ.

=== Входные и выходные данные алгоритма ===

'''Входные данные:'''

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его как val);

~ массив номеров столбцов для соответствующих элементов массива val (обозначим его как col);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его row);

~ вектор, на который будет умножаться матрица (обозначим его vec).

'''Объем входных данных:'''

Для матрицы размером <math>N\times M</math>, содержащей в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>,

~ вектор val - NZ элементов;

~ вектор col - NZ элементов;

~ вектор row - N+1 элемент;

~ вектор vec - M элементов.

'''Выходные данные:'''

Вектор out размером N.

=== Свойства алгоритма ===

Соотношение последовательной и параллельной сложности в случае неограниченных ресурсов, как хорошо видно, является ''линейным''.

Вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных – чуть меньше ''единицы''.

Данный алгоритм обладает свойством детерминированности.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

Эффективная работа с разреженными матрицами реализована во многих библиотеках, например, [https://software.intel.com/en-us/intel-mkl Intel Math Kernel Library], базирующуюся на библиотеках BLAS и LAPACK, также математических пакет [http://matlab.ru/products/matlab Matlab] имеет собственную реализацию.

== Литература ==

[1] Писсанецки С. Технология разреженных матриц. - М.: Мир, 1988. — 410 с.

[2] https://software.intel.com/sites/default/files/m/d/4/1/d/8/LW_SparseMM_ppt.pdf

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-11-15T13:03:53Z

Сергей:

Автор: [[U:Сергей|Герасимов Сергей]] (619)

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

'''Разреженная матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается плотной.

Нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:

~ есть O(n). Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;

~ в каждой строке не превышает 10 в типичном случае;

~ ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.

Огромные разрежённые матрицы часто возникают при решении таких задач, как дифференциальное уравнение в частных производных.

При хранении и преобразовании разрежённых матриц в компьютере бывает полезно, а часто и необходимо, использовать специальные алгоритмы и структуры данных, которые учитывают разрежённую структуру матрицы. Операции и алгоритмы, применяемые для работы с обычными, плотными матрицами, применительно к большим разрежённым матрицам работают относительно медленно и требуют значительных объёмов памяти. Однако разрежённые матрицы могут быть легко сжаты путём записи только своих ненулевых элементов, что снижает требования к компьютерной памяти.

'''Существуют различные форматы хранения разреженных матриц.''' Одни предназначены для хранения матриц специального вида (например, ленточных), другие обеспечивают работу с матрицами общего вида. Ниже рассмотрим некоторые весьма распространенные способы представления разреженных матриц.

По-видимому, наиболее очевидным способом хранения произвольной разреженной матрицы является '''координатный формат''': хранятся только ненулевые элементы матрицы, и их координаты (номера строк и столбцов). При данном подходе хранение матрицы A можно обеспечить в трех одномерных массивах:

~ массив ненулевых элементов матрицы A (обозначим его как values);

~ массив номеров строк матрицы A, соответствующих элементам массива values (обозначим его как rows);

~ массив номеров столбцов матрицы A, соответствующих элементам массива values (обозначим его как cols);

Данный способ представления называют полным, поскольку представлена вся матрица А, и неупорядоченным, поскольку элементы матрицы могут храниться в произвольном порядке.

Хотя многие математические библиотеки поддерживают матрично-векторные операции в координатном формате, данный формат обеспечивает медленный доступ к элементам матрицы, и является затратным по используемой памяти. В рассмотренном выше примере избыточность по памяти образом проявляется в массиве rows, в котором строчные координаты хранятся неоптимальным образом.

Перейдем далее к рассмотрению более экономных форматов хранения. '''Разреженный строчный формат''' - это одна из наиболее широко используемых схем хранения разреженных матриц. Эта схема предъявляет минимальные требования к памяти и в то же время оказывается очень удобной для нескольких важных операций над разреженными матрицами: сложения, умножения, перестановок строк и столбцов, транспонирования, решения линейных систем с разреженными матрицами коэффициентов как прямыми, так и итерационными методами и т. д.

В соответствии с рассматриваемой схемой для хранения матрицы A требуется три одномерных массива:

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его опять как values);

~ массив номеров столбцов для соответствующих элементов массива values (обозначим его как cols);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его pointer). Описание k-й строки хранится в позициях с pointer[k]-й по (pointer[k+1]–1)-ю массивов values и cols. Если pointer[k]=pointer[k+1], то k-я строка пустая. Если матрица A состоит из n строк, то длина массива pointer будет n+1.

Данный способ представления также является полным, и упорядоченным, поскольку элементы каждой строки хранятся в соответствии с возрастанием столбцовых индексов.

Очевидно, что объем памяти, требуемый для хранения вектора pointer, значительно меньше, чем для хранения вектора rows. Более того, разреженный строчный формат обеспечивает эффективный доступ к строчкам матрицы; доступ к столбцам по прежнему затруднен. Поэтому предпочтительно использовать этот способ хранения в тех алгоритмах, в которых преобладают строчные операции.

Существует также '''разреженный столбцовый формат''', который строится аналогичным способом.

Теперь, разобравшись со способами хранения разреженных матриц, можно перейти к ''алгоритму умножения разреженной матрицы на вектор''. Умножение матрицы на вектор является подзадачей для нахождения решений СЛАУ итерационными методами.

=== Математическое описание алгоритма ===

Пусть матрица размером <math>N\times M</math> содержит в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>

Условимся использовать строчный формат хранения матрицы, который описан выше.

На входе у нас 4 массива: val(ненулевые элементы матрицы), col(номера столбцов), row(массив указателей) и vec(вектор, на который мы умножаем матрицу).

На выходе получим вектор out.

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}, \ i=\overline{0,N-1}</math>, где <math>N</math> - число строк матрицы.

=== Вычислительное ядро алгоритма ===

Ядром алгоритма является вычисление сумм произведений:

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}</math>

Итого: <math>NZ</math> умножений + <math>x</math> сложений(<math>NZ-N<x<NZ-1</math>).

=== Макроструктура алгоритма ===

Метод состоит из вычисления неполных скалярных произведений.

[[Файл:sparse.jpg|thumb|center|500px|Рис.1 Умножение разреженной матрицы на вектор]]

Элементы из массива val умножаются на элементы из массива vec с соответствующим индексом. Черным отмечены ненулевые элементы.

=== Схема реализации последовательного алгоритма ===

for(i=0; i<N; i++)
{
out[i]=0;
for(j=row[i]; j<row[i+1]; j++)
{
out[i] += val[j]*vec[col[j]];
}
}

Внешний цикл - цикл по элементам выходного вектора. Внутренний - цикл по строкам разреженной матрицы.
Во внутреннем цикле реализовано накопление сумм произведений в выходной элемент.

=== Последовательная сложность алгоритма ===

<math>\bullet \ NZ</math> умножений

<math>\bullet \ x</math> сложений(<math>NZ-N<x<NZ-1</math>).

Всего <math>2NZ</math> операций, где <math>NZ</math> - количество ненулевых элементов.

=== Информационный граф ===

[[Файл:sparse.jpg|thumb|center|500px|Рис.1 Умножение разреженной матрицы на вектор. Информационный граф]]

Элементы из массива val умножаются на элементы из массива vec с соответствующим индексом. Черным отмечены ненулевые элементы. При увеличении числа N граф будет аналогичным.

=== Ресурс параллелизма алгоритма ===

При наличии бесконечного числа процессоров для умножения разреженной матрицы на вектор потребуется:

~ 1 ярус умножений

~ <math>Z-1</math> операция сложения, где Z - максимальное число ненулевых элементов в строке.

Максимальное число требуемых процессоров - NZ.

=== Входные и выходные данные алгоритма ===

'''Входные данные:'''

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его как val);

~ массив номеров столбцов для соответствующих элементов массива val (обозначим его как col);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его row);

~ вектор, на который будет умножаться матрица (обозначим его vec).

'''Объем входных данных:'''

Для матрицы размером <math>N\times M</math>, содержащей в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>,

~ вектор val - NZ элементов;

~ вектор col - NZ элементов;

~ вектор row - N+1 элемент;

~ вектор vec - M элементов.

'''Выходные данные:'''

Вектор out размером N.

=== Свойства алгоритма ===

Соотношение последовательной и параллельной сложности в случае неограниченных ресурсов, как хорошо видно, является ''линейным''.

Вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных – чуть меньше ''единицы''.

Данный алгоритм обладает свойством детерминированности.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

Эффективная работа с разреженными матрицами реализована во многих библиотеках, например, [https://software.intel.com/en-us/intel-mkl Intel Math Kernel Library], базирующуюся на библиотеках BLAS и LAPACK, также математических пакет [http://matlab.ru/products/matlab Matlab] имеет собственную реализацию.

== Литература ==

[1] Писсанецки С. Технология разреженных матриц. - М.: Мир, 1988. — 410 с.

[2] https://software.intel.com/sites/default/files/m/d/4/1/d/8/LW_SparseMM_ppt.pdf

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-11-03T16:58:22Z

Сергей:

{{Assignment}}

Автор: [[U:Сергей|Герасимов Сергей]] (619)

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

'''Разреженная матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается плотной.

Нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:

~ есть O(n). Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;

~ в каждой строке не превышает 10 в типичном случае;

~ ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.

Огромные разрежённые матрицы часто возникают при решении таких задач, как дифференциальное уравнение в частных производных.

При хранении и преобразовании разрежённых матриц в компьютере бывает полезно, а часто и необходимо, использовать специальные алгоритмы и структуры данных, которые учитывают разрежённую структуру матрицы. Операции и алгоритмы, применяемые для работы с обычными, плотными матрицами, применительно к большим разрежённым матрицам работают относительно медленно и требуют значительных объёмов памяти. Однако разрежённые матрицы могут быть легко сжаты путём записи только своих ненулевых элементов, что снижает требования к компьютерной памяти.

'''Существуют различные форматы хранения разреженных матриц.''' Одни предназначены для хранения матриц специального вида (например, ленточных), другие обеспечивают работу с матрицами общего вида. Ниже рассмотрим некоторые весьма распространенные способы представления разреженных матриц.

По-видимому, наиболее очевидным способом хранения произвольной разреженной матрицы является '''координатный формат''': хранятся только ненулевые элементы матрицы, и их координаты (номера строк и столбцов). При данном подходе хранение матрицы A можно обеспечить в трех одномерных массивах:

~ массив ненулевых элементов матрицы A (обозначим его как values);

~ массив номеров строк матрицы A, соответствующих элементам массива values (обозначим его как rows);

~ массив номеров столбцов матрицы A, соответствующих элементам массива values (обозначим его как cols);

Данный способ представления называют полным, поскольку представлена вся матрица А, и неупорядоченным, поскольку элементы матрицы могут храниться в произвольном порядке.

Хотя многие математические библиотеки поддерживают матрично-векторные операции в координатном формате, данный формат обеспечивает медленный доступ к элементам матрицы, и является затратным по используемой памяти. В рассмотренном выше примере избыточность по памяти образом проявляется в массиве rows, в котором строчные координаты хранятся неоптимальным образом.

Перейдем далее к рассмотрению более экономных форматов хранения. '''Разреженный строчный формат''' - это одна из наиболее широко используемых схем хранения разреженных матриц. Эта схема предъявляет минимальные требования к памяти и в то же время оказывается очень удобной для нескольких важных операций над разреженными матрицами: сложения, умножения, перестановок строк и столбцов, транспонирования, решения линейных систем с разреженными матрицами коэффициентов как прямыми, так и итерационными методами и т. д.

В соответствии с рассматриваемой схемой для хранения матрицы A требуется три одномерных массива:

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его опять как values);

~ массив номеров столбцов для соответствующих элементов массива values (обозначим его как cols);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его pointer). Описание k-й строки хранится в позициях с pointer[k]-й по (pointer[k+1]–1)-ю массивов values и cols. Если pointer[k]=pointer[k+1], то k-я строка пустая. Если матрица A состоит из n строк, то длина массива pointer будет n+1.

Данный способ представления также является полным, и упорядоченным, поскольку элементы каждой строки хранятся в соответствии с возрастанием столбцовых индексов.

Очевидно, что объем памяти, требуемый для хранения вектора pointer, значительно меньше, чем для хранения вектора rows. Более того, разреженный строчный формат обеспечивает эффективный доступ к строчкам матрицы; доступ к столбцам по прежнему затруднен. Поэтому предпочтительно использовать этот способ хранения в тех алгоритмах, в которых преобладают строчные операции.

Существует также '''разреженный столбцовый формат''', который строится аналогичным способом.

Теперь, разобравшись со способами хранения разреженных матриц, можно перейти к ''алгоритму умножения разреженной матрицы на вектор''. Умножение матрицы на вектор является подзадачей для нахождения решений СЛАУ итерационными методами.

=== Математическое описание алгоритма ===

Пусть матрица размером <math>N\times M</math> содержит в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>

Условимся использовать строчный формат хранения матрицы, который описан выше.

На входе у нас 4 массива: val(ненулевые элементы матрицы), col(номера столбцов), row(массив указателей) и vec(вектор, на который мы умножаем матрицу).

На выходе получим вектор out.

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}, \ i=\overline{0,N-1}</math>, где <math>N</math> - число строк матрицы.

=== Вычислительное ядро алгоритма ===

Ядром алгоритма является вычисление сумм произведений:

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}</math>

Итого: <math>NZ</math> умножений + <math>x</math> сложений(<math>NZ-N<x<NZ-1</math>).

=== Макроструктура алгоритма ===

Метод состоит из вычисления неполных скалярных произведений.

=== Схема реализации последовательного алгоритма ===

for(i=0; i<N; i++)
{
out[i]=0;
for(j=row[i]; j<row[i+1]; j++)
{
out[i] += val[j]*vec[col[j]];
}
}

Внешний цикл - цикл по элементам выходного вектора. Внутренний - цикл по строкам разреженной матрицы.
Во внутреннем цикле реализовано накопление сумм произведений в выходной элемент.

=== Последовательная сложность алгоритма ===

<math>\bullet \ NZ</math> умножений

<math>\bullet \ x</math> сложений(<math>NZ-N<x<NZ-1</math>).

Всего <math>2NZ</math> операций, где <math>NZ</math> - количество ненулевых элементов.

=== Информационный граф ===

[[Файл:sparse.jpg|thumb|center|500px|Рис.1 Умножение разреженной матрицы на вектор. Информационный граф]]

Элементы из массива val умножаются на элементы из массива vec с соответствующим индексом. Черным отмечены ненулевые элементы. При увеличении числа N граф будет аналогичным.

=== Ресурс параллелизма алгоритма ===

При наличии бесконечного числа процессоров для умножения разреженной матрицы на вектор потребуется:

~ 1 ярус умножений

~ <math>Z-1</math> операция сложения, где Z - максимальное число ненулевых элементов в строке.

Максимальное число требуемых процессоров - NZ.

=== Входные и выходные данные алгоритма ===

'''Входные данные:'''

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его как val);

~ массив номеров столбцов для соответствующих элементов массива val (обозначим его как col);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его row);

~ вектор, на который будет умножаться матрица (обозначим его vec).

'''Объем входных данных:'''

Для матрицы размером <math>N\times M</math>, содержащей в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>,

~ вектор val - NZ элементов;

~ вектор col - NZ элементов;

~ вектор row - N+1 элемент;

~ вектор vec - M элементов.

'''Выходные данные:'''

Вектор out размером N.

=== Свойства алгоритма ===

Соотношение последовательной и параллельной сложности в случае неограниченных ресурсов, как хорошо видно, является ''линейным''.

Вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных – чуть меньше ''единицы''.

Данный алгоритм обладает свойством детерминированности.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

Эффективная работа с разреженными матрицами реализована во многих библиотеках, например, [https://software.intel.com/en-us/intel-mkl Intel Math Kernel Library], базирующуюся на библиотеках BLAS и LAPACK, также математических пакет [http://matlab.ru/products/matlab Matlab] имеет собственную реализацию.

== Литература ==

[1] Писсанецки С. Технология разреженных матриц. - М.: Мир, 1988. — 410 с.

[2] https://software.intel.com/sites/default/files/m/d/4/1/d/8/LW_SparseMM_ppt.pdf

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-11-01T12:07:42Z

Сергей: /* Литература */

Обсуждение участника:Сергей

2016-11-01T11:56:08Z

Сергей: Полностью удалено содержимое страницы

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-11-01T11:53:42Z

Сергей: /* Существующие реализации алгоритма */

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-11-01T11:48:19Z

Сергей: /* Схема реализации последовательного алгоритма */

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-11-01T11:38:31Z

Сергей: /* Последовательная сложность алгоритма */

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-11-01T11:37:49Z

Сергей: /* Последовательная сложность алгоритма */

Обсуждение участника:Сергей

2016-11-01T11:28:38Z

Сергей:

= Пункт 1.5 =
Добавить описание к псевдокоду.

= Пункт 1.6 =
Указать итоговую сложность.

= Пункт 2.7 =
Добавить ссылки на реализации.

= Литература =
Отсутствует раздел источников, необходимо добавить.

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-11-01T11:27:47Z

Сергей: /* Информационный граф */

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-11-01T11:27:29Z

Сергей: /* Информационный граф */

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-11-01T11:26:54Z

Сергей: /* Информационный граф */

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-11-01T11:26:03Z

Сергей: /* Информационный граф */

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-11-01T11:21:23Z

Сергей:

Обсуждение участника:Сергей

2016-11-01T11:19:43Z

Сергей:

= Пункт 1.3 =
Лучше избегать ссылок на соседние пункты. Подразделы д.б. самодостаточны.

= Пункт 1.4 =
Следует просто привести описание макроструктуры, без ссылки на другие пункты.

= Пункт 1.5 =
Добавить описание к псевдокоду.
Если заимствован, дать ссылку на источник.

= Пункт 1.6 =
Указать итоговую сложность.

= Пункт 1.7 =
Оформить как рисунок с номером и подписью.
Если рисунок заимствован, надо дать ссылку на источник.

= Пункт 2.7 =
Добавить ссылки на реализации.

= Литература =
Отсутствует раздел источников, необходимо добавить.

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-11-01T10:52:41Z

Сергей:

Автор: [[U:Сергей|Герасимов Сергей]] (619)

= Содержание =

== 1 Свойства и структура алгоритма ==

'''1.1 Общее описание алгоритма'''

'''Разреженная матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается плотной.

Нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:

~ есть O(n). Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;

~ в каждой строке не превышает 10 в типичном случае;

~ ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.

Огромные разрежённые матрицы часто возникают при решении таких задач, как дифференциальное уравнение в частных производных.

При хранении и преобразовании разрежённых матриц в компьютере бывает полезно, а часто и необходимо, использовать специальные алгоритмы и структуры данных, которые учитывают разрежённую структуру матрицы. Операции и алгоритмы, применяемые для работы с обычными, плотными матрицами, применительно к большим разрежённым матрицам работают относительно медленно и требуют значительных объёмов памяти. Однако разрежённые матрицы могут быть легко сжаты путём записи только своих ненулевых элементов, что снижает требования к компьютерной памяти.

'''Существуют различные форматы хранения разреженных матриц.''' Одни предназначены для хранения матриц специального вида (например, ленточных), другие обеспечивают работу с матрицами общего вида. Ниже рассмотрим некоторые весьма распространенные способы представления разреженных матриц.

По-видимому, наиболее очевидным способом хранения произвольной разреженной матрицы является '''координатный формат''': хранятся только ненулевые элементы матрицы, и их координаты (номера строк и столбцов). При данном подходе хранение матрицы A можно обеспечить в трех одномерных массивах:

~ массив ненулевых элементов матрицы A (обозначим его как values);

~ массив номеров строк матрицы A, соответствующих элементам массива values (обозначим его как rows);

~ массив номеров столбцов матрицы A, соответствующих элементам массива values (обозначим его как cols);

Данный способ представления называют полным, поскольку представлена вся матрица А, и неупорядоченным, поскольку элементы матрицы могут храниться в произвольном порядке.

Хотя многие математические библиотеки поддерживают матрично-векторные операции в координатном формате, данный формат обеспечивает медленный доступ к элементам матрицы, и является затратным по используемой памяти. В рассмотренном выше примере избыточность по памяти образом проявляется в массиве rows, в котором строчные координаты хранятся неоптимальным образом.

Перейдем далее к рассмотрению более экономных форматов хранения. '''Разреженный строчный формат''' - это одна из наиболее широко используемых схем хранения разреженных матриц. Эта схема предъявляет минимальные требования к памяти и в то же время оказывается очень удобной для нескольких важных операций над разреженными матрицами: сложения, умножения, перестановок строк и столбцов, транспонирования, решения линейных систем с разреженными матрицами коэффициентов как прямыми, так и итерационными методами и т. д.

В соответствии с рассматриваемой схемой для хранения матрицы A требуется три одномерных массива:

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его опять как values);

~ массив номеров столбцов для соответствующих элементов массива values (обозначим его как cols);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его pointer). Описание k-й строки хранится в позициях с pointer[k]-й по (pointer[k+1]–1)-ю массивов values и cols. Если pointer[k]=pointer[k+1], то k-я строка пустая. Если матрица A состоит из n строк, то длина массива pointer будет n+1.

Данный способ представления также является полным, и упорядоченным, поскольку элементы каждой строки хранятся в соответствии с возрастанием столбцовых индексов.

Очевидно, что объем памяти, требуемый для хранения вектора pointer, значительно меньше, чем для хранения вектора rows. Более того, разреженный строчный формат обеспечивает эффективный доступ к строчкам матрицы; доступ к столбцам по прежнему затруднен. Поэтому предпочтительно использовать этот способ хранения в тех алгоритмах, в которых преобладают строчные операции.

Существует также '''разреженный столбцовый формат''', который строится аналогичным способом.

Теперь, разобравшись со способами хранения разреженных матриц, можно перейти к ''алгоритму умножения разреженной матрицы на вектор''. Умножение матрицы на вектор является подзадачей для нахождения решений СЛАУ итерационными методами.

'''1.2 Математическое описание алгоритма'''

Пусть матрица размером <math>N\times M</math> содержит в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>

Условимся использовать строчный формат хранения матрицы, который описан выше.

На входе у нас 4 массива: val(ненулевые элементы матрицы), col(номера столбцов), row(массив указателей) и vec(вектор, на который мы умножаем матрицу).

На выходе получим вектор out.

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}, \ i=\overline{0,N-1}</math>, где <math>N</math> - число строк матрицы.

'''1.3 Вычислительное ядро алгоритма'''

Ядром алгоритма является вычисление сумм произведений, описанное в [[предыдущем пункте]].

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}</math>

Итого: <math>NZ</math> умножений + <math>x</math> сложений(<math>NZ-N<x<NZ-1</math>).

'''1.4 Макроструктура алгоритма'''

Как видно из [[описания алгоритма]], метод состоит из вычисления неполных скалярных произведений.

'''1.5 Схема реализации последовательного алгоритма'''

for(i=0; i<N; i++)
{
out[i]=0;
for(j=row[i]; j<row[i+1]; j++)
{
out[i] += val[j]*vec[col[j]];
}
}

'''1.6 Последовательная сложность алгоритма'''

<math>\bullet \ NZ</math> умножений

<math>\bullet \ x</math> сложений(<math>NZ-N<x<NZ-1</math>).

'''1.7 Информационный граф'''

[[Файл:sparse.jpg|500px|при N=3]]

Элементы из массива val умножаются на элементы из массива vec с соответствующим индексом. Черным отмечены ненулевые элементы. При увеличении числа N граф будет аналогичным.

'''1.8 Ресурс параллелизма алгоритма'''

При наличии бесконечного числа процессоров для умножения разреженной матрицы на вектор потребуется:

~ 1 ярус умножений

~ <math>Z-1</math> операция сложения, где Z - максимальное число ненулевых элементов в строке.

Максимальное число требуемых процессоров - NZ.

'''1.9 Входные и выходные данные алгоритма'''

'''Входные данные:'''

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его как val);

~ массив номеров столбцов для соответствующих элементов массива val (обозначим его как col);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его row);

~ вектор, на который будет умножаться матрица (обозначим его vec).

'''Объем входных данных:'''

Для матрицы размером <math>N\times M</math>, содержащей в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>,

~ вектор val - NZ элементов;

~ вектор col - NZ элементов;

~ вектор row - N+1 элемент;

~ вектор vec - M элементов.

'''Выходные данные:'''

Вектор out размером N.

'''1.10 Свойства алгоритма'''

Соотношение последовательной и параллельной сложности в случае неограниченных ресурсов, как хорошо видно, является ''линейным''.

Вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных – чуть меньше ''единицы''.

Данный алгоритм обладает свойством детерминированности.

== 2 Программная реализация алгоритма ==

'''2.7 Существующие реализации алгоритма'''

Эффективная работа с разреженными матрицами реализована во многих библиотеках, например, Intel Math Kernel Library, базирующуюся на библиотеках BLAS и LAPACK, также математических пакет Matlab имеет собственную реализацию.

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-10-15T01:00:07Z

Сергей:

{{Assignment}}
== 1 Свойства и структура алгоритма ==

'''1.1 Общее описание алгоритма'''

'''Разреженная матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается плотной.

Нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:

~ есть O(n). Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;

~ в каждой строке не превышает 10 в типичном случае;

~ ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.

Огромные разрежённые матрицы часто возникают при решении таких задач, как дифференциальное уравнение в частных производных.

При хранении и преобразовании разрежённых матриц в компьютере бывает полезно, а часто и необходимо, использовать специальные алгоритмы и структуры данных, которые учитывают разрежённую структуру матрицы. Операции и алгоритмы, применяемые для работы с обычными, плотными матрицами, применительно к большим разрежённым матрицам работают относительно медленно и требуют значительных объёмов памяти. Однако разрежённые матрицы могут быть легко сжаты путём записи только своих ненулевых элементов, что снижает требования к компьютерной памяти.

'''Существуют различные форматы хранения разреженных матриц.''' Одни предназначены для хранения матриц специального вида (например, ленточных), другие обеспечивают работу с матрицами общего вида. Ниже рассмотрим некоторые весьма распространенные способы представления разреженных матриц.

По-видимому, наиболее очевидным способом хранения произвольной разреженной матрицы является '''координатный формат''': хранятся только ненулевые элементы матрицы, и их координаты (номера строк и столбцов). При данном подходе хранение матрицы A можно обеспечить в трех одномерных массивах:

~ массив ненулевых элементов матрицы A (обозначим его как values);

~ массив номеров строк матрицы A, соответствующих элементам массива values (обозначим его как rows);

~ массив номеров столбцов матрицы A, соответствующих элементам массива values (обозначим его как cols);

Данный способ представления называют полным, поскольку представлена вся матрица А, и неупорядоченным, поскольку элементы матрицы могут храниться в произвольном порядке.

Хотя многие математические библиотеки поддерживают матрично-векторные операции в координатном формате, данный формат обеспечивает медленный доступ к элементам матрицы, и является затратным по используемой памяти. В рассмотренном выше примере избыточность по памяти образом проявляется в массиве rows, в котором строчные координаты хранятся неоптимальным образом.

Перейдем далее к рассмотрению более экономных форматов хранения. '''Разреженный строчный формат''' - это одна из наиболее широко используемых схем хранения разреженных матриц. Эта схема предъявляет минимальные требования к памяти и в то же время оказывается очень удобной для нескольких важных операций над разреженными матрицами: сложения, умножения, перестановок строк и столбцов, транспонирования, решения линейных систем с разреженными матрицами коэффициентов как прямыми, так и итерационными методами и т. д.

В соответствии с рассматриваемой схемой для хранения матрицы A требуется три одномерных массива:

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его опять как values);

~ массив номеров столбцов для соответствующих элементов массива values (обозначим его как cols);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его pointer). Описание k-й строки хранится в позициях с pointer[k]-й по (pointer[k+1]–1)-ю массивов values и cols. Если pointer[k]=pointer[k+1], то k-я строка пустая. Если матрица A состоит из n строк, то длина массива pointer будет n+1.

Данный способ представления также является полным, и упорядоченным, поскольку элементы каждой строки хранятся в соответствии с возрастанием столбцовых индексов.

Очевидно, что объем памяти, требуемый для хранения вектора pointer, значительно меньше, чем для хранения вектора rows. Более того, разреженный строчный формат обеспечивает эффективный доступ к строчкам матрицы; доступ к столбцам по прежнему затруднен. Поэтому предпочтительно использовать этот способ хранения в тех алгоритмах, в которых преобладают строчные операции.

Существует также '''разреженный столбцовый формат''', который строится аналогичным способом.

Теперь, разобравшись со способами хранения разреженных матриц, можно перейти к ''алгоритму умножения разреженной матрицы на вектор''. Умножение матрицы на вектор является подзадачей для нахождения решений СЛАУ итерационными методами.

'''1.2 Математическое описание алгоритма'''

Пусть матрица размером <math>N\times M</math> содержит в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>

Условимся использовать строчный формат хранения матрицы, который описан выше.

На входе у нас 4 массива: val(ненулевые элементы матрицы), col(номера столбцов), row(массив указателей) и vec(вектор, на который мы умножаем матрицу).

На выходе получим вектор out.

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}, \ i=\overline{0,N-1}</math>, где <math>N</math> - число строк матрицы.

'''1.3 Вычислительное ядро алгоритма'''

Ядром алгоритма является вычисление сумм произведений, описанное в [[предыдущем пункте]].

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}</math>

Итого: <math>NZ</math> умножений + <math>x</math> сложений(<math>NZ-N<x<NZ-1</math>).

'''1.4 Макроструктура алгоритма'''

Как видно из [[описания алгоритма]], метод состоит из вычисления неполных скалярных произведений.

'''1.5 Схема реализации последовательного алгоритма'''

for(i=0; i<N; i++)
{
out[i]=0;
for(j=row[i]; j<row[i+1]; j++)
{
out[i] += val[j]*vec[col[j]];
}
}

'''1.6 Последовательная сложность алгоритма'''

<math>\bullet \ NZ</math> умножений

<math>\bullet \ x</math> сложений(<math>NZ-N<x<NZ-1</math>).

'''1.7 Информационный граф'''

[[Файл:sparse.jpg|500px|при N=3]]

Элементы из массива val умножаются на элементы из массива vec с соответствующим индексом. Черным отмечены ненулевые элементы. При увеличении числа N граф будет аналогичным.

'''1.8 Ресурс параллелизма алгоритма'''

При наличии бесконечного числа процессоров для умножения разреженной матрицы на вектор потребуется:

~ 1 ярус умножений

~ <math>Z-1</math> операция сложения, где Z - максимальное число ненулевых элементов в строке.

Максимальное число требуемых процессоров - NZ.

'''1.9 Входные и выходные данные алгоритма'''

'''Входные данные:'''

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его как val);

~ массив номеров столбцов для соответствующих элементов массива val (обозначим его как col);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его row);

~ вектор, на который будет умножаться матрица (обозначим его vec).

'''Объем входных данных:'''

Для матрицы размером <math>N\times M</math>, содержащей в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>,

~ вектор val - NZ элементов;

~ вектор col - NZ элементов;

~ вектор row - N+1 элемент;

~ вектор vec - M элементов.

'''Выходные данные:'''

Вектор out размером N.

'''1.10 Свойства алгоритма'''

Соотношение последовательной и параллельной сложности в случае неограниченных ресурсов, как хорошо видно, является ''линейным''.

Вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных – чуть меньше ''единицы''.

Данный алгоритм обладает свойством детерминированности.

== 2 Программная реализация алгоритма ==

'''2.7 Существующие реализации алгоритма'''

Эффективная работа с разреженными матрицами реализована во многих библиотеках, например, Intel Math Kernel Library, базирующуюся на библиотеках BLAS и LAPACK, также математических пакет Matlab имеет собственную реализацию.

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-10-15T00:47:10Z

Сергей:

== 1 Свойства и структура алгоритма ==

'''1.1 Общее описание алгоритма'''

'''Разреженная матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается плотной.

Нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:

~ есть O(n). Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;

~ в каждой строке не превышает 10 в типичном случае;

~ ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.

Огромные разрежённые матрицы часто возникают при решении таких задач, как дифференциальное уравнение в частных производных.

При хранении и преобразовании разрежённых матриц в компьютере бывает полезно, а часто и необходимо, использовать специальные алгоритмы и структуры данных, которые учитывают разрежённую структуру матрицы. Операции и алгоритмы, применяемые для работы с обычными, плотными матрицами, применительно к большим разрежённым матрицам работают относительно медленно и требуют значительных объёмов памяти. Однако разрежённые матрицы могут быть легко сжаты путём записи только своих ненулевых элементов, что снижает требования к компьютерной памяти.

'''Существуют различные форматы хранения разреженных матриц.''' Одни предназначены для хранения матриц специального вида (например, ленточных), другие обеспечивают работу с матрицами общего вида. Ниже рассмотрим некоторые весьма распространенные способы представления разреженных матриц.

По-видимому, наиболее очевидным способом хранения произвольной разреженной матрицы является '''координатный формат''': хранятся только ненулевые элементы матрицы, и их координаты (номера строк и столбцов). При данном подходе хранение матрицы A можно обеспечить в трех одномерных массивах:

~ массив ненулевых элементов матрицы A (обозначим его как values);

~ массив номеров строк матрицы A, соответствующих элементам массива values (обозначим его как rows);

~ массив номеров столбцов матрицы A, соответствующих элементам массива values (обозначим его как cols);

Данный способ представления называют полным, поскольку представлена вся матрица А, и неупорядоченным, поскольку элементы матрицы могут храниться в произвольном порядке.

Хотя многие математические библиотеки поддерживают матрично-векторные операции в координатном формате, данный формат обеспечивает медленный доступ к элементам матрицы, и является затратным по используемой памяти. В рассмотренном выше примере избыточность по памяти образом проявляется в массиве rows, в котором строчные координаты хранятся неоптимальным образом.

Перейдем далее к рассмотрению более экономных форматов хранения. '''Разреженный строчный формат''' - это одна из наиболее широко используемых схем хранения разреженных матриц. Эта схема предъявляет минимальные требования к памяти и в то же время оказывается очень удобной для нескольких важных операций над разреженными матрицами: сложения, умножения, перестановок строк и столбцов, транспонирования, решения линейных систем с разреженными матрицами коэффициентов как прямыми, так и итерационными методами и т. д.

В соответствии с рассматриваемой схемой для хранения матрицы A требуется три одномерных массива:

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его опять как values);

~ массив номеров столбцов для соответствующих элементов массива values (обозначим его как cols);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его pointer). Описание k-й строки хранится в позициях с pointer[k]-й по (pointer[k+1]–1)-ю массивов values и cols. Если pointer[k]=pointer[k+1], то k-я строка пустая. Если матрица A состоит из n строк, то длина массива pointer будет n+1.

Данный способ представления также является полным, и упорядоченным, поскольку элементы каждой строки хранятся в соответствии с возрастанием столбцовых индексов.

Очевидно, что объем памяти, требуемый для хранения вектора pointer, значительно меньше, чем для хранения вектора rows. Более того, разреженный строчный формат обеспечивает эффективный доступ к строчкам матрицы; доступ к столбцам по прежнему затруднен. Поэтому предпочтительно использовать этот способ хранения в тех алгоритмах, в которых преобладают строчные операции.

Существует также '''разреженный столбцовый формат''', который строится аналогичным способом.

Теперь, разобравшись со способами хранения разреженных матриц, можно перейти к ''алгоритму умножения разреженной матрицы на вектор''. Умножение матрицы на вектор является подзадачей для нахождения решений СЛАУ итерационными методами.

'''1.2 Математическое описание алгоритма'''

Пусть матрица размером <math>N\times M</math> содержит в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>

Условимся использовать строчный формат хранения матрицы, который описан выше.

На входе у нас 4 массива: val(ненулевые элементы матрицы), col(номера столбцов), row(массив указателей) и vec(вектор, на который мы умножаем матрицу).

На выходе получим вектор out.

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}, \ i=\overline{0,N-1}</math>, где <math>N</math> - число строк матрицы.

'''1.3 Вычислительное ядро алгоритма'''

Ядром алгоритма является вычисление сумм произведений, описанное в [[предыдущем пункте]].

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}</math>

Итого: <math>NZ</math> умножений + <math>x</math> сложений(<math>NZ-N<x<NZ-1</math>).

'''1.4 Макроструктура алгоритма'''

Как видно из [[описания алгоритма]], метод состоит из вычисления неполных скалярных произведений.

'''1.5 Схема реализации последовательного алгоритма'''

for(i=0; i<N; i++)
{
out[i]=0;
for(j=row[i]; j<row[i+1]; j++)
{
out[i] += val[j]*vec[col[j]];
}
}

'''1.6 Последовательная сложность алгоритма'''

<math>\bullet \ NZ</math> умножений

<math>\bullet \ x</math> сложений(<math>NZ-N<x<NZ-1</math>).

'''1.7 Информационный граф'''

[[Файл:sparse.jpg|500px|при N=3]]

Элементы из массива val умножаются на элементы из массива vec с соответствующим индексом. Черным отмечены ненулевые элементы. При увеличении числа N граф будет аналогичным.

'''1.8 Ресурс параллелизма алгоритма'''

При наличии бесконечного числа процессоров для умножения разреженной матрицы на вектор потребуется:

~ 1 ярус умножений

~ <math>\log_2{Z}</math> ярусов сложений, где Z - максимальное число ненулевых элементов в строке.

Максимальное число требуемых процессоров - NZ.

'''1.9 Входные и выходные данные алгоритма'''

'''Входные данные:'''

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его как val);

~ массив номеров столбцов для соответствующих элементов массива val (обозначим его как col);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его row);

~ вектор, на который будет умножаться матрица (обозначим его vec).

'''Объем входных данных:'''

Для матрицы размером <math>N\times M</math>, содержащей в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>,

~ вектор val - NZ элементов;

~ вектор col - NZ элементов;

~ вектор row - N+1 элемент;

~ вектор vec - M элементов.

'''Выходные данные:'''

Вектор out размером N.

'''1.10 Свойства алгоритма'''

Соотношение последовательной и параллельной сложности в случае неограниченных ресурсов, как хорошо видно, является ''линейным''.

Вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных – чуть меньше ''единицы''.

Данный алгоритм обладает свойством детерминированности.

== 2 Программная реализация алгоритма ==

'''2.7 Существующие реализации алгоритма'''

Эффективная работа с разреженными матрицами реализована во многих библиотеках, например, Intel Math Kernel Library, базирующуюся на библиотеках BLAS и LAPACK, также математических пакет Matlab имеет собственную реализацию.

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-10-15T00:31:36Z

Сергей:

== 1 Свойства и структура алгоритма ==

'''1.1 Общее описание алгоритма'''

'''Разреженная матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается плотной.

Нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:

~ есть O(n). Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;

~ в каждой строке не превышает 10 в типичном случае;

~ ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.

Огромные разрежённые матрицы часто возникают при решении таких задач, как дифференциальное уравнение в частных производных.

При хранении и преобразовании разрежённых матриц в компьютере бывает полезно, а часто и необходимо, использовать специальные алгоритмы и структуры данных, которые учитывают разрежённую структуру матрицы. Операции и алгоритмы, применяемые для работы с обычными, плотными матрицами, применительно к большим разрежённым матрицам работают относительно медленно и требуют значительных объёмов памяти. Однако разрежённые матрицы могут быть легко сжаты путём записи только своих ненулевых элементов, что снижает требования к компьютерной памяти.

'''Существуют различные форматы хранения разреженных матриц.''' Одни предназначены для хранения матриц специального вида (например, ленточных), другие обеспечивают работу с матрицами общего вида. Ниже рассмотрим некоторые весьма распространенные способы представления разреженных матриц.

По-видимому, наиболее очевидным способом хранения произвольной разреженной матрицы является '''координатный формат''': хранятся только ненулевые элементы матрицы, и их координаты (номера строк и столбцов). При данном подходе хранение матрицы A можно обеспечить в трех одномерных массивах:

~ массив ненулевых элементов матрицы A (обозначим его как values);

~ массив номеров строк матрицы A, соответствующих элементам массива values (обозначим его как rows);

~ массив номеров столбцов матрицы A, соответствующих элементам массива values (обозначим его как cols);

Данный способ представления называют полным, поскольку представлена вся матрица А, и неупорядоченным, поскольку элементы матрицы могут храниться в произвольном порядке.

Хотя многие математические библиотеки поддерживают матрично-векторные операции в координатном формате, данный формат обеспечивает медленный доступ к элементам матрицы, и является затратным по используемой памяти. В рассмотренном выше примере избыточность по памяти образом проявляется в массиве rows, в котором строчные координаты хранятся неоптимальным образом.

Перейдем далее к рассмотрению более экономных форматов хранения. '''Разреженный строчный формат''' - это одна из наиболее широко используемых схем хранения разреженных матриц. Эта схема предъявляет минимальные требования к памяти и в то же время оказывается очень удобной для нескольких важных операций над разреженными матрицами: сложения, умножения, перестановок строк и столбцов, транспонирования, решения линейных систем с разреженными матрицами коэффициентов как прямыми, так и итерационными методами и т. д.

В соответствии с рассматриваемой схемой для хранения матрицы A требуется три одномерных массива:

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его опять как values);

~ массив номеров столбцов для соответствующих элементов массива values (обозначим его как cols);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его pointer). Описание k-й строки хранится в позициях с pointer[k]-й по (pointer[k+1]–1)-ю массивов values и cols. Если pointer[k]=pointer[k+1], то k-я строка пустая. Если матрица A состоит из n строк, то длина массива pointer будет n+1.

Данный способ представления также является полным, и упорядоченным, поскольку элементы каждой строки хранятся в соответствии с возрастанием столбцовых индексов.

Очевидно, что объем памяти, требуемый для хранения вектора pointer, значительно меньше, чем для хранения вектора rows. Более того, разреженный строчный формат обеспечивает эффективный доступ к строчкам матрицы; доступ к столбцам по прежнему затруднен. Поэтому предпочтительно использовать этот способ хранения в тех алгоритмах, в которых преобладают строчные операции.

Существует также '''разреженный столбцовый формат''', который строится аналогичным способом.

Теперь, разобравшись со способами хранения разреженных матриц, можно перейти к ''алгоритму умножения разреженной матрицы на вектор''. Умножение матрицы на вектор является подзадачей для нахождения решений СЛАУ итерационными методами.

'''1.2 Математическое описание алгоритма'''

Пусть матрица размером <math>N\times M</math> содержит в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>

Условимся использовать строчный формат хранения матрицы, который описан выше.

На входе у нас 4 массива: val(ненулевые элементы матрицы), col(номера столбцов), row(массив указателей) и vec(вектор, на который мы умножаем матрицу).

На выходе получим вектор out.

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}, \ i=\overline{0,N-1}</math>, где <math>N</math> - число строк матрицы.

'''1.3 Вычислительное ядро алгоритма'''

Ядром алгоритма является вычисление сумм произведений, описанное в [[предыдущем пункте]].

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}</math>

Итого: <math>NZ</math> умножений + <math>x</math> сложений(<math>NZ-N<x<NZ-1</math>).

'''1.4 Макроструктура алгоритма'''

Как видно из [[описания алгоритма]], метод состоит из вычисления неполных скалярных произведений.

'''1.5 Схема реализации последовательного алгоритма'''

for(i=0; i<N; i++)
{
out[i]=0;
for(j=row[i]; j<row[i+1]; j++)
{
out[i] += val[j]*vec[col[j]];
}
}

'''1.6 Последовательная сложность алгоритма'''

<math>\bullet \ NZ</math> умножений

<math>\bullet \ x</math> сложений(<math>NZ-N<x<NZ-1</math>).

'''1.7 Информационный граф'''

[[Файл:sparse.jpg|500px|при N=3]]

Элементы из массива val умножаются на элементы из массива vec с соответствующим индексом. Черным отмечены ненулевые элементы. При увеличении числа N граф будет аналогичным.

'''1.8 Ресурс параллелизма алгоритма'''

При наличии бесконечного числа процессоров для умножения разреженной матрицы на вектор потребуется:

~ 1 ярус умножений

~ <math>\log_2{Z}</math> ярусов сложений, где Z - максимальное число ненулевых элементов в строке.

Максимальное число требуемых процессоров - NZ.

'''1.9 Входные и выходные данные алгоритма'''

'''Входные данные:'''

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его как val);

~ массив номеров столбцов для соответствующих элементов массива val (обозначим его как col);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его row);

~ вектор, на который будет умножаться матрица (обозначим его vec).

'''Объем входных данных:'''

Для матрицы размером <math>N\times M</math>, содержащей в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>,

~ вектор val - NZ элементов;

~ вектор col - NZ элементов;

~ вектор row - N+1 элемент;

~ вектор vec - M элементов.

'''Выходные данные:'''

Вектор out размером N.

'''1.10 Свойства алгоритма'''

Соотношение последовательной и параллельной сложности в случае неограниченных ресурсов, как хорошо видно, является ''линейным''.

Вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных – чуть меньше ''единицы''.

Данный алгоритм не обладает свойством детерминированности, так как не известна исходная структура матрицы и число ненулевых компонент в разных строках может отличаться.

== 2 Программная реализация алгоритма ==

'''2.7 Существующие реализации алгоритма'''

Эффективная работа с разреженными матрицами реализована во многих библиотеках, например, Intel Math Kernel Library, базирующуюся на библиотеках BLAS и LAPACK, также математических пакет Matlab имеет собственную реализацию.

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-10-15T00:11:54Z

Сергей:

== 1 Свойства и структура алгоритма ==

'''1.1 Общее описание алгоритма'''

'''Разреженная матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается плотной.

Нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:

~ есть O(n). Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;

~ в каждой строке не превышает 10 в типичном случае;

~ ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.

Огромные разрежённые матрицы часто возникают при решении таких задач, как дифференциальное уравнение в частных производных.

При хранении и преобразовании разрежённых матриц в компьютере бывает полезно, а часто и необходимо, использовать специальные алгоритмы и структуры данных, которые учитывают разрежённую структуру матрицы. Операции и алгоритмы, применяемые для работы с обычными, плотными матрицами, применительно к большим разрежённым матрицам работают относительно медленно и требуют значительных объёмов памяти. Однако разрежённые матрицы могут быть легко сжаты путём записи только своих ненулевых элементов, что снижает требования к компьютерной памяти.

'''Существуют различные форматы хранения разреженных матриц.''' Одни предназначены для хранения матриц специального вида (например, ленточных), другие обеспечивают работу с матрицами общего вида. Ниже рассмотрим некоторые весьма распространенные способы представления разреженных матриц.

По-видимому, наиболее очевидным способом хранения произвольной разреженной матрицы является '''координатный формат''': хранятся только ненулевые элементы матрицы, и их координаты (номера строк и столбцов). При данном подходе хранение матрицы A можно обеспечить в трех одномерных массивах:

~ массив ненулевых элементов матрицы A (обозначим его как values);

~ массив номеров строк матрицы A, соответствующих элементам массива values (обозначим его как rows);

~ массив номеров столбцов матрицы A, соответствующих элементам массива values (обозначим его как cols);

Данный способ представления называют полным, поскольку представлена вся матрица А, и неупорядоченным, поскольку элементы матрицы могут храниться в произвольном порядке.

Хотя многие математические библиотеки поддерживают матрично-векторные операции в координатном формате, данный формат обеспечивает медленный доступ к элементам матрицы, и является затратным по используемой памяти. В рассмотренном выше примере избыточность по памяти образом проявляется в массиве rows, в котором строчные координаты хранятся неоптимальным образом.

Перейдем далее к рассмотрению более экономных форматов хранения. '''Разреженный строчный формат''' - это одна из наиболее широко используемых схем хранения разреженных матриц. Эта схема предъявляет минимальные требования к памяти и в то же время оказывается очень удобной для нескольких важных операций над разреженными матрицами: сложения, умножения, перестановок строк и столбцов, транспонирования, решения линейных систем с разреженными матрицами коэффициентов как прямыми, так и итерационными методами и т. д.

В соответствии с рассматриваемой схемой для хранения матрицы A требуется три одномерных массива:

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его опять как values);

~ массив номеров столбцов для соответствующих элементов массива values (обозначим его как cols);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его pointer). Описание k-й строки хранится в позициях с pointer[k]-й по (pointer[k+1]–1)-ю массивов values и cols. Если pointer[k]=pointer[k+1], то k-я строка пустая. Если матрица A состоит из n строк, то длина массива pointer будет n+1.

Данный способ представления также является полным, и упорядоченным, поскольку элементы каждой строки хранятся в соответствии с возрастанием столбцовых индексов.

Очевидно, что объем памяти, требуемый для хранения вектора pointer, значительно меньше, чем для хранения вектора rows. Более того, разреженный строчный формат обеспечивает эффективный доступ к строчкам матрицы; доступ к столбцам по прежнему затруднен. Поэтому предпочтительно использовать этот способ хранения в тех алгоритмах, в которых преобладают строчные операции.

Существует также '''разреженный столбцовый формат''', который строится аналогичным способом.

Теперь, разобравшись со способами хранения разреженных матриц, можно перейти к ''алгоритму умножения разреженной матрицы на вектор''. Умножение матрицы на вектор является подзадачей для нахождения решений СЛАУ итерационными методами.

'''1.2 Математическое описание алгоритма'''

Пусть матрица размером <math>N\times M</math> содержит в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>

Условимся использовать строчный формат хранения матрицы, который описан выше.

На входе у нас 4 массива: val(ненулевые элементы матрицы), col(номера столбцов), row(массив указателей) и vec(вектор, на который мы умножаем матрицу).

На выходе получим вектор out.

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}, \ i=\overline{0,N-1}</math>, где <math>N</math> - число строк матрицы.

'''1.3 Вычислительное ядро алгоритма'''

Ядром алгоритма является вычисление сумм произведений, описанное в [[предыдущем пункте]].

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}</math>

Итого: <math>NZ</math> умножений + <math>x</math> сложений(<math>NZ-N<x<NZ-1</math>).

'''1.4 Макроструктура алгоритма'''

Как видно из [[описания алгоритма]], метод состоит из вычисления неполных скалярных произведений.

'''1.5 Схема реализации последовательного алгоритма'''

for(i=0; i<N; i++)
{
out[i]=0;
for(j=row[i]; j<row[i+1]; j++)
{
out[i] += val[j]*vec[col[j]];
}
}

'''1.6 Последовательная сложность алгоритма'''

<math>\bullet \ NZ</math> умножений

<math>\bullet \ x</math> сложений(<math>NZ-N<x<NZ-1</math>).

'''1.7 Информационный граф'''

[[Файл:sparse.jpg|500px|при N=3]]

Элементы из массива val умножаются на элементы из массива vec с соответствующим индексом. Черным отмечены ненулевые элементы. При увеличении числа N граф будет аналогичным.

'''1.8 Ресурс параллелизма алгоритма'''

При наличии бесконечного числа процессоров для умножения разреженной матрицы на вектор потребуется:

~ 1 ярус умножений

~ <math>\log_2{Z}</math> ярусов сложений, где Z - максимальное число ненулевых элементов в строке.

Максимальное число требуемых процессоров - NZ.

'''1.9 Входные и выходные данные алгоритма'''

'''Входные данные:'''

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его как val);

~ массив номеров столбцов для соответствующих элементов массива val (обозначим его как col);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его row);

~ вектор, на который будет умножаться матрица (обозначим его vec).

'''Объем входных данных:'''

Для матрицы размером <math>N\times M</math>, содержащей в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>,

~ вектор val - NZ элементов;

~ вектор col - NZ элементов;

~ вектор row - N+1 элемент;

~ вектор vec - M элементов.

'''Выходные данные:'''

Вектор out размером N.

'''1.10 Свойства алгоритма'''

Соотношение последовательной и параллельной сложности в случае неограниченных ресурсов, как хорошо видно, является ''линейным''.

Вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных – чуть меньше ''единицы''.

Данный алгоритм не обладает свойством детерминированности, так как не известна исходная структура матрицы и число ненулевых компонент в разных строках может отличаться.

== 2 Программная реализация алгоритма ==

'''2.7 Существующие реализации алгоритма'''

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-10-15T00:02:49Z

Сергей:

== 1 Свойства и структура алгоритма ==

'''1.1 Общее описание алгоритма'''

'''Разреженная матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается плотной.

Нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:

~ есть O(n). Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;

~ в каждой строке не превышает 10 в типичном случае;

~ ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.

Огромные разрежённые матрицы часто возникают при решении таких задач, как дифференциальное уравнение в частных производных.

При хранении и преобразовании разрежённых матриц в компьютере бывает полезно, а часто и необходимо, использовать специальные алгоритмы и структуры данных, которые учитывают разрежённую структуру матрицы. Операции и алгоритмы, применяемые для работы с обычными, плотными матрицами, применительно к большим разрежённым матрицам работают относительно медленно и требуют значительных объёмов памяти. Однако разрежённые матрицы могут быть легко сжаты путём записи только своих ненулевых элементов, что снижает требования к компьютерной памяти.

'''Существуют различные форматы хранения разреженных матриц.''' Одни предназначены для хранения матриц специального вида (например, ленточных), другие обеспечивают работу с матрицами общего вида. Ниже рассмотрим некоторые весьма распространенные способы представления разреженных матриц.

По-видимому, наиболее очевидным способом хранения произвольной разреженной матрицы является '''координатный формат''': хранятся только ненулевые элементы матрицы, и их координаты (номера строк и столбцов). При данном подходе хранение матрицы A можно обеспечить в трех одномерных массивах:

~ массив ненулевых элементов матрицы A (обозначим его как values);

~ массив номеров строк матрицы A, соответствующих элементам массива values (обозначим его как rows);

~ массив номеров столбцов матрицы A, соответствующих элементам массива values (обозначим его как cols);

Данный способ представления называют полным, поскольку представлена вся матрица А, и неупорядоченным, поскольку элементы матрицы могут храниться в произвольном порядке.

Хотя многие математические библиотеки поддерживают матрично-векторные операции в координатном формате, данный формат обеспечивает медленный доступ к элементам матрицы, и является затратным по используемой памяти. В рассмотренном выше примере избыточность по памяти образом проявляется в массиве rows, в котором строчные координаты хранятся неоптимальным образом.

Перейдем далее к рассмотрению более экономных форматов хранения. '''Разреженный строчный формат''' - это одна из наиболее широко используемых схем хранения разреженных матриц. Эта схема предъявляет минимальные требования к памяти и в то же время оказывается очень удобной для нескольких важных операций над разреженными матрицами: сложения, умножения, перестановок строк и столбцов, транспонирования, решения линейных систем с разреженными матрицами коэффициентов как прямыми, так и итерационными методами и т. д.

В соответствии с рассматриваемой схемой для хранения матрицы A требуется три одномерных массива:

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его опять как values);

~ массив номеров столбцов для соответствующих элементов массива values (обозначим его как cols);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его pointer). Описание k-й строки хранится в позициях с pointer[k]-й по (pointer[k+1]–1)-ю массивов values и cols. Если pointer[k]=pointer[k+1], то k-я строка пустая. Если матрица A состоит из n строк, то длина массива pointer будет n+1.

Данный способ представления также является полным, и упорядоченным, поскольку элементы каждой строки хранятся в соответствии с возрастанием столбцовых индексов.

Очевидно, что объем памяти, требуемый для хранения вектора pointer, значительно меньше, чем для хранения вектора rows. Более того, разреженный строчный формат обеспечивает эффективный доступ к строчкам матрицы; доступ к столбцам по прежнему затруднен. Поэтому предпочтительно использовать этот способ хранения в тех алгоритмах, в которых преобладают строчные операции.

Существует также '''разреженный столбцовый формат''', который строится аналогичным способом.

Теперь, разобравшись со способами хранения разреженных матриц, можно перейти к ''алгоритму умножения разреженной матрицы на вектор''. Умножение матрицы на вектор является подзадачей для нахождения решений СЛАУ итерационными методами.

'''1.2 Математическое описание алгоритма'''

Пусть матрица размером <math>N\times M</math> содержит в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>

Условимся использовать строчный формат хранения матрицы, который описан выше.

На входе у нас 4 массива: val(ненулевые элементы матрицы), col(номера столбцов), row(массив указателей) и vec(вектор, на который мы умножаем матрицу).

На выходе получим вектор out.

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}, \ i=\overline{0,N-1}</math>, где <math>N</math> - число строк матрицы.

'''1.3 Вычислительное ядро алгоритма'''

Ядром алгоритма является вычисление сумм произведений, описанное в [[предыдущем пункте]].

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}</math>

Итого: <math>NZ</math> умножений + <math>x</math> сложений(<math>NZ-N<x<NZ-1</math>).

'''1.4 Макроструктура алгоритма'''

Как видно из [[описания алгоритма]], метод состоит из вычисления неполных скалярных произведений.

'''1.5 Схема реализации последовательного алгоритма'''

for(i=0; i<N; i++)
{
out[i]=0;
for(j=row[i]; j<row[i+1]; j++)
{
out[i] += val[j]*vec[col[j]];
}
}

'''1.6 Последовательная сложность алгоритма'''

<math>\bullet \ NZ</math> умножений

<math>\bullet \ x</math> сложений(<math>NZ-N<x<NZ-1</math>).

'''1.7 Информационный граф'''

[[Файл:sparse.jpg|500px|при N=3]]

Элементы из массива val умножаются на элементы из массива vec с соответствующим индексом. Черным отмечены ненулевые элементы. При увеличении числа N граф будет аналогичным.

'''1.8 Ресурс параллелизма алгоритма'''

При наличии бесконечного числа процессоров для умножения разреженной матрицы на вектор потребуется:

~ 1 ярус умножений

~ <math>\log_2{Z}</math> ярусов сложений, где Z - максимальное число ненулевых элементов в строке.

Максимальное число требуемых процессоров - NZ.

'''1.9 Входные и выходные данные алгоритма'''

'''Входные данные:'''

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его как val);

~ массив номеров столбцов для соответствующих элементов массива val (обозначим его как col);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его row);

~ вектор, на который будет умножаться матрица (обозначим его vec).

'''Объем входных данных:'''

Для матрицы размером <math>N\times M</math>, содержащей в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>,

~ вектор val - NZ элементов;

~ вектор col - NZ элементов;

~ вектор row - N+1 элемент;

~ вектор vec - M элементов.

'''Выходные данные:'''

Вектор out размером N.

'''1.10 Свойства алгоритма'''

Соотношение последовательной и параллельной сложности в случае неограниченных ресурсов, как хорошо видно, является ''линейным''.

Вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных – чуть меньше ''единицы''.

== 2 Программная реализация алгоритма ==

'''2.7 Существующие реализации алгоритма'''

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-10-14T23:52:08Z

Сергей:

== 1 Свойства и структура алгоритма ==

'''1.1 Общее описание алгоритма'''

'''Разреженная матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается плотной.

Нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:

~ есть O(n). Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;

~ в каждой строке не превышает 10 в типичном случае;

~ ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.

Огромные разрежённые матрицы часто возникают при решении таких задач, как дифференциальное уравнение в частных производных.

При хранении и преобразовании разрежённых матриц в компьютере бывает полезно, а часто и необходимо, использовать специальные алгоритмы и структуры данных, которые учитывают разрежённую структуру матрицы. Операции и алгоритмы, применяемые для работы с обычными, плотными матрицами, применительно к большим разрежённым матрицам работают относительно медленно и требуют значительных объёмов памяти. Однако разрежённые матрицы могут быть легко сжаты путём записи только своих ненулевых элементов, что снижает требования к компьютерной памяти.

'''Существуют различные форматы хранения разреженных матриц.''' Одни предназначены для хранения матриц специального вида (например, ленточных), другие обеспечивают работу с матрицами общего вида. Ниже рассмотрим некоторые весьма распространенные способы представления разреженных матриц.

По-видимому, наиболее очевидным способом хранения произвольной разреженной матрицы является '''координатный формат''': хранятся только ненулевые элементы матрицы, и их координаты (номера строк и столбцов). При данном подходе хранение матрицы A можно обеспечить в трех одномерных массивах:

~ массив ненулевых элементов матрицы A (обозначим его как values);

~ массив номеров строк матрицы A, соответствующих элементам массива values (обозначим его как rows);

~ массив номеров столбцов матрицы A, соответствующих элементам массива values (обозначим его как cols);

Данный способ представления называют полным, поскольку представлена вся матрица А, и неупорядоченным, поскольку элементы матрицы могут храниться в произвольном порядке.

Хотя многие математические библиотеки поддерживают матрично-векторные операции в координатном формате, данный формат обеспечивает медленный доступ к элементам матрицы, и является затратным по используемой памяти. В рассмотренном выше примере избыточность по памяти образом проявляется в массиве rows, в котором строчные координаты хранятся неоптимальным образом.

Перейдем далее к рассмотрению более экономных форматов хранения. '''Разреженный строчный формат''' - это одна из наиболее широко используемых схем хранения разреженных матриц. Эта схема предъявляет минимальные требования к памяти и в то же время оказывается очень удобной для нескольких важных операций над разреженными матрицами: сложения, умножения, перестановок строк и столбцов, транспонирования, решения линейных систем с разреженными матрицами коэффициентов как прямыми, так и итерационными методами и т. д.

В соответствии с рассматриваемой схемой для хранения матрицы A требуется три одномерных массива:

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его опять как values);

~ массив номеров столбцов для соответствующих элементов массива values (обозначим его как cols);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его pointer). Описание k-й строки хранится в позициях с pointer[k]-й по (pointer[k+1]–1)-ю массивов values и cols. Если pointer[k]=pointer[k+1], то k-я строка пустая. Если матрица A состоит из n строк, то длина массива pointer будет n+1.

Данный способ представления также является полным, и упорядоченным, поскольку элементы каждой строки хранятся в соответствии с возрастанием столбцовых индексов.

Очевидно, что объем памяти, требуемый для хранения вектора pointer, значительно меньше, чем для хранения вектора rows. Более того, разреженный строчный формат обеспечивает эффективный доступ к строчкам матрицы; доступ к столбцам по прежнему затруднен. Поэтому предпочтительно использовать этот способ хранения в тех алгоритмах, в которых преобладают строчные операции.

Существует также '''разреженный столбцовый формат''', который строится аналогичным способом.

Теперь, разобравшись со способами хранения разреженных матриц, можно перейти к ''алгоритму умножения разреженной матрицы на вектор''. Умножение матрицы на вектор является подзадачей для нахождения решений СЛАУ итерационными методами.

'''1.2 Математическое описание алгоритма'''

Пусть матрица размером <math>N\times M</math> содержит в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>

Условимся использовать строчный формат хранения матрицы, который описан выше.

На входе у нас 4 массива: val(ненулевые элементы матрицы), col(номера столбцов), row(массив указателей) и vec(вектор, на который мы умножаем матрицу).

На выходе получим вектор out.

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}, \ i=\overline{0,N-1}</math>, где <math>N</math> - число строк матрицы.

'''1.3 Вычислительное ядро алгоритма'''

Ядром алгоритма является вычисление сумм произведений, описанное в [[предыдущем пункте]].

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}</math>

Итого: <math>NZ</math> умножений + <math>x</math> сложений(<math>NZ-N<x<NZ-1</math>).

'''1.4 Макроструктура алгоритма'''

Как видно из [[описания алгоритма]], метод состоит из вычисления неполных скалярных произведений.

'''1.5 Схема реализации последовательного алгоритма'''

for(i=0; i<N; i++)
{
out[i]=0;
for(j=row[i]; j<row[i+1]; j++)
{
out[i] += val[j]*vec[col[j]];
}
}

'''1.6 Последовательная сложность алгоритма'''

<math>\bullet \ NZ</math> умножений

<math>\bullet \ x</math> сложений(<math>NZ-N<x<NZ-1</math>).

'''1.7 Информационный граф'''

[[Файл:sparse.jpg|500px|при N=3]]

Элементы из массива val умножаются на элементы из массива vec с соответствующим индексом. Черным отмечены ненулевые элементы. При увеличении числа N граф будет аналогичным.

'''1.8 Ресурс параллелизма алгоритма'''

При наличии бесконечного числа процессоров для умножения разреженной матрицы на вектор потребуется:

~ 1 ярус умножений

~ <math>\log_2{Z}</math> ярусов сложений, где Z - максимальное число ненулевых элементов в строке.

Максимальное число требуемых процессоров - NZ.

'''1.9 Входные и выходные данные алгоритма'''

'''Входные данные:'''

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его как val);

~ массив номеров столбцов для соответствующих элементов массива val (обозначим его как col);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его row);

~ вектор, на который будет умножаться матрица (обозначим его vec).

'''Объем входных данных:'''

Для матрицы размером <math>N\times M</math>, содержащей в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>,

~ вектор val - NZ элементов;

~ вектор col - NZ элементов;

~ вектор row - N+1 элемент;

~ вектор vec - M элементов.

'''Выходные данные:'''

Вектор out размером N.

'''1.10 Свойства алгоритма'''

== 2 Программная реализация алгоритма ==

'''2.7 Существующие реализации алгоритма'''

Файл:Sparse.jpg

2016-10-14T23:50:03Z

Сергей:

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-10-14T23:34:23Z

Сергей:

== 1 Свойства и структура алгоритма ==

'''1.1 Общее описание алгоритма'''

'''Разреженная матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается плотной.

Нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:

~ есть O(n). Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;

~ в каждой строке не превышает 10 в типичном случае;

~ ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.

Огромные разрежённые матрицы часто возникают при решении таких задач, как дифференциальное уравнение в частных производных.

При хранении и преобразовании разрежённых матриц в компьютере бывает полезно, а часто и необходимо, использовать специальные алгоритмы и структуры данных, которые учитывают разрежённую структуру матрицы. Операции и алгоритмы, применяемые для работы с обычными, плотными матрицами, применительно к большим разрежённым матрицам работают относительно медленно и требуют значительных объёмов памяти. Однако разрежённые матрицы могут быть легко сжаты путём записи только своих ненулевых элементов, что снижает требования к компьютерной памяти.

'''Существуют различные форматы хранения разреженных матриц.''' Одни предназначены для хранения матриц специального вида (например, ленточных), другие обеспечивают работу с матрицами общего вида. Ниже рассмотрим некоторые весьма распространенные способы представления разреженных матриц.

По-видимому, наиболее очевидным способом хранения произвольной разреженной матрицы является '''координатный формат''': хранятся только ненулевые элементы матрицы, и их координаты (номера строк и столбцов). При данном подходе хранение матрицы A можно обеспечить в трех одномерных массивах:

~ массив ненулевых элементов матрицы A (обозначим его как values);

~ массив номеров строк матрицы A, соответствующих элементам массива values (обозначим его как rows);

~ массив номеров столбцов матрицы A, соответствующих элементам массива values (обозначим его как cols);

Данный способ представления называют полным, поскольку представлена вся матрица А, и неупорядоченным, поскольку элементы матрицы могут храниться в произвольном порядке.

Хотя многие математические библиотеки поддерживают матрично-векторные операции в координатном формате, данный формат обеспечивает медленный доступ к элементам матрицы, и является затратным по используемой памяти. В рассмотренном выше примере избыточность по памяти образом проявляется в массиве rows, в котором строчные координаты хранятся неоптимальным образом.

Перейдем далее к рассмотрению более экономных форматов хранения. '''Разреженный строчный формат''' - это одна из наиболее широко используемых схем хранения разреженных матриц. Эта схема предъявляет минимальные требования к памяти и в то же время оказывается очень удобной для нескольких важных операций над разреженными матрицами: сложения, умножения, перестановок строк и столбцов, транспонирования, решения линейных систем с разреженными матрицами коэффициентов как прямыми, так и итерационными методами и т. д.

В соответствии с рассматриваемой схемой для хранения матрицы A требуется три одномерных массива:

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его опять как values);

~ массив номеров столбцов для соответствующих элементов массива values (обозначим его как cols);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его pointer). Описание k-й строки хранится в позициях с pointer[k]-й по (pointer[k+1]–1)-ю массивов values и cols. Если pointer[k]=pointer[k+1], то k-я строка пустая. Если матрица A состоит из n строк, то длина массива pointer будет n+1.

Данный способ представления также является полным, и упорядоченным, поскольку элементы каждой строки хранятся в соответствии с возрастанием столбцовых индексов.

Очевидно, что объем памяти, требуемый для хранения вектора pointer, значительно меньше, чем для хранения вектора rows. Более того, разреженный строчный формат обеспечивает эффективный доступ к строчкам матрицы; доступ к столбцам по прежнему затруднен. Поэтому предпочтительно использовать этот способ хранения в тех алгоритмах, в которых преобладают строчные операции.

Существует также '''разреженный столбцовый формат''', который строится аналогичным способом.

Теперь, разобравшись со способами хранения разреженных матриц, можно перейти к ''алгоритму умножения разреженной матрицы на вектор''. Умножение матрицы на вектор является подзадачей для нахождения решений СЛАУ итерационными методами.

'''1.2 Математическое описание алгоритма'''

Пусть матрица размером <math>N\times M</math> содержит в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>

Условимся использовать строчный формат хранения матрицы, который описан выше.

На входе у нас 4 массива: val(ненулевые элементы матрицы), col(номера столбцов), row(массив указателей) и vec(вектор, на который мы умножаем матрицу).

На выходе получим вектор out.

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}, \ i=\overline{0,N-1}</math>, где <math>N</math> - число строк матрицы.

'''1.3 Вычислительное ядро алгоритма'''

Ядром алгоритма является вычисление сумм произведений, описанное в [[предыдущем пункте]].

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}</math>

Итого: <math>NZ</math> умножений + <math>x</math> сложений(<math>NZ-N<x<NZ-1</math>).

'''1.4 Макроструктура алгоритма'''

Как видно из [[описания алгоритма]], метод состоит из вычисления неполных скалярных произведений.

'''1.5 Схема реализации последовательного алгоритма'''

for(i=0; i<N; i++)
{
out[i]=0;
for(j=row[i]; j<row[i+1]; j++)
{
out[i] += val[j]*vec[col[j]];
}
}

'''1.6 Последовательная сложность алгоритма'''

<math>\bullet \ NZ</math> умножений

<math>\bullet \ x</math> сложений(<math>NZ-N<x<NZ-1</math>).

'''1.7 Информационный граф'''

[[Файл:sparse_matrix.jpg|500px|при N=3]]

Черным отмечены ненулевые элементы. При увеличении числа N граф будет аналогичным.

'''1.8 Ресурс параллелизма алгоритма'''

При наличии бесконечного числа процессоров для умножения разреженной матрицы на вектор потребуется:

~ 1 ярус умножений

~ <math>\log_2{Z}</math> ярусов сложений, где Z - максимальное число ненулевых элементов в строке.

Максимальное число требуемых процессоров - NZ.

'''1.9 Входные и выходные данные алгоритма'''

'''Входные данные:'''

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его как val);

~ массив номеров столбцов для соответствующих элементов массива val (обозначим его как col);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его row);

~ вектор, на который будет умножаться матрица (обозначим его vec).

'''Объем входных данных:'''

Для матрицы размером <math>N\times M</math>, содержащей в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>,

~ вектор val - NZ элементов;

~ вектор col - NZ элементов;

~ вектор row - N+1 элемент;

~ вектор vec - M элементов.

'''Выходные данные:'''

Вектор out размером N.

'''1.10 Свойства алгоритма'''

== 2 Программная реализация алгоритма ==

'''2.7 Существующие реализации алгоритма'''

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-10-14T23:13:22Z

Сергей:

== 1 Свойства и структура алгоритма ==

'''1.1 Общее описание алгоритма'''

'''Разреженная матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается плотной.

Нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:

~ есть O(n). Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;

~ в каждой строке не превышает 10 в типичном случае;

~ ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.

Огромные разрежённые матрицы часто возникают при решении таких задач, как дифференциальное уравнение в частных производных.

При хранении и преобразовании разрежённых матриц в компьютере бывает полезно, а часто и необходимо, использовать специальные алгоритмы и структуры данных, которые учитывают разрежённую структуру матрицы. Операции и алгоритмы, применяемые для работы с обычными, плотными матрицами, применительно к большим разрежённым матрицам работают относительно медленно и требуют значительных объёмов памяти. Однако разрежённые матрицы могут быть легко сжаты путём записи только своих ненулевых элементов, что снижает требования к компьютерной памяти.

'''Существуют различные форматы хранения разреженных матриц.''' Одни предназначены для хранения матриц специального вида (например, ленточных), другие обеспечивают работу с матрицами общего вида. Ниже рассмотрим некоторые весьма распространенные способы представления разреженных матриц.

По-видимому, наиболее очевидным способом хранения произвольной разреженной матрицы является '''координатный формат''': хранятся только ненулевые элементы матрицы, и их координаты (номера строк и столбцов). При данном подходе хранение матрицы A можно обеспечить в трех одномерных массивах:

~ массив ненулевых элементов матрицы A (обозначим его как values);

~ массив номеров строк матрицы A, соответствующих элементам массива values (обозначим его как rows);

~ массив номеров столбцов матрицы A, соответствующих элементам массива values (обозначим его как cols);

Данный способ представления называют полным, поскольку представлена вся матрица А, и неупорядоченным, поскольку элементы матрицы могут храниться в произвольном порядке.

Хотя многие математические библиотеки поддерживают матрично-векторные операции в координатном формате, данный формат обеспечивает медленный доступ к элементам матрицы, и является затратным по используемой памяти. В рассмотренном выше примере избыточность по памяти образом проявляется в массиве rows, в котором строчные координаты хранятся неоптимальным образом.

Перейдем далее к рассмотрению более экономных форматов хранения. '''Разреженный строчный формат''' - это одна из наиболее широко используемых схем хранения разреженных матриц. Эта схема предъявляет минимальные требования к памяти и в то же время оказывается очень удобной для нескольких важных операций над разреженными матрицами: сложения, умножения, перестановок строк и столбцов, транспонирования, решения линейных систем с разреженными матрицами коэффициентов как прямыми, так и итерационными методами и т. д.

В соответствии с рассматриваемой схемой для хранения матрицы A требуется три одномерных массива:

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его опять как values);

~ массив номеров столбцов для соответствующих элементов массива values (обозначим его как cols);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его pointer). Описание k-й строки хранится в позициях с pointer[k]-й по (pointer[k+1]–1)-ю массивов values и cols. Если pointer[k]=pointer[k+1], то k-я строка пустая. Если матрица A состоит из n строк, то длина массива pointer будет n+1.

Данный способ представления также является полным, и упорядоченным, поскольку элементы каждой строки хранятся в соответствии с возрастанием столбцовых индексов.

Очевидно, что объем памяти, требуемый для хранения вектора pointer, значительно меньше, чем для хранения вектора rows. Более того, разреженный строчный формат обеспечивает эффективный доступ к строчкам матрицы; доступ к столбцам по прежнему затруднен. Поэтому предпочтительно использовать этот способ хранения в тех алгоритмах, в которых преобладают строчные операции.

Существует также '''разреженный столбцовый формат''', который строится аналогичным способом.

Теперь, разобравшись со способами хранения разреженных матриц, можно перейти к ''алгоритму умножения разреженной матрицы на вектор''. Умножение матрицы на вектор является подзадачей для нахождения решений СЛАУ итерационными методами.

'''1.2 Математическое описание алгоритма'''

Пусть матрица размером <math>N\times M</math> содержит в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>

Условимся использовать строчный формат хранения матрицы, который описан выше.

На входе у нас 4 массива: val(ненулевые элементы матрицы), col(номера столбцов), row(массив указателей) и vec(вектор, на который мы умножаем матрицу).

На выходе получим вектор out.

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}, \ i=\overline{0,N-1}</math>, где <math>N</math> - число строк матрицы.

'''1.3 Вычислительное ядро алгоритма'''

Ядром алгоритма является вычисление сумм произведений, описанное в [[предыдущем пункте]].

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}</math>

Итого: <math>NZ</math> умножений + <math>x</math> сложений(<math>NZ-N<x<NZ-1</math>).

'''1.4 Макроструктура алгоритма'''

Как видно из [[описания алгоритма]], метод состоит из вычисления неполных скалярных произведений.

'''1.5 Схема реализации последовательного алгоритма'''

for(i=0; i<N; i++)
{
out[i]=0;
for(j=row[i]; j<row[i+1]; j++)
{
out[i] += val[j]*vec[col[j]];
}
}

'''1.6 Последовательная сложность алгоритма'''

<math>\bullet \ NZ</math> умножений

<math>\bullet \ x</math> сложений(<math>NZ-N<x<NZ-1</math>).

'''1.7 Информационный граф'''

[[Файл:sparse_matrix.jpg|500px|при N=3]]

Черным отмечены ненулевые элементы. При увеличении числа N граф будет аналогичным.

'''1.8 Ресурс параллелизма алгоритма'''

'''1.9 Входные и выходные данные алгоритма'''

'''Входные данные:'''

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его как val);

~ массив номеров столбцов для соответствующих элементов массива val (обозначим его как col);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его row);

~ вектор, на который будет умножаться матрица (обозначим его vec).

'''Объем входных данных:'''

Для матрицы размером <math>N\times M</math>, содержащей в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>,

вектор val - NZ элементов;

вектор col - NZ элементов;

вектор row - N+1 элемент;

вектор vec - M элементов.

'''Выходные данные:'''

Вектор out размером N.

'''1.10 Свойства алгоритма'''

== 2 Программная реализация алгоритма ==

'''2.7 Существующие реализации алгоритма'''

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-10-14T22:53:32Z

Сергей:

== 1 Свойства и структура алгоритма ==

'''1.1 Общее описание алгоритма'''

'''Разреженная матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается плотной.

Нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:

~ есть O(n). Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;

~ в каждой строке не превышает 10 в типичном случае;

~ ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.

Огромные разрежённые матрицы часто возникают при решении таких задач, как дифференциальное уравнение в частных производных.

При хранении и преобразовании разрежённых матриц в компьютере бывает полезно, а часто и необходимо, использовать специальные алгоритмы и структуры данных, которые учитывают разрежённую структуру матрицы. Операции и алгоритмы, применяемые для работы с обычными, плотными матрицами, применительно к большим разрежённым матрицам работают относительно медленно и требуют значительных объёмов памяти. Однако разрежённые матрицы могут быть легко сжаты путём записи только своих ненулевых элементов, что снижает требования к компьютерной памяти.

'''Существуют различные форматы хранения разреженных матриц.''' Одни предназначены для хранения матриц специального вида (например, ленточных), другие обеспечивают работу с матрицами общего вида. Ниже рассмотрим некоторые весьма распространенные способы представления разреженных матриц.

По-видимому, наиболее очевидным способом хранения произвольной разреженной матрицы является '''координатный формат''': хранятся только ненулевые элементы матрицы, и их координаты (номера строк и столбцов). При данном подходе хранение матрицы A можно обеспечить в трех одномерных массивах:

~ массив ненулевых элементов матрицы A (обозначим его как values);

~ массив номеров строк матрицы A, соответствующих элементам массива values (обозначим его как rows);

~ массив номеров столбцов матрицы A, соответствующих элементам массива values (обозначим его как cols);

Данный способ представления называют полным, поскольку представлена вся матрица А, и неупорядоченным, поскольку элементы матрицы могут храниться в произвольном порядке.

Хотя многие математические библиотеки поддерживают матрично-векторные операции в координатном формате, данный формат обеспечивает медленный доступ к элементам матрицы, и является затратным по используемой памяти. В рассмотренном выше примере избыточность по памяти образом проявляется в массиве rows, в котором строчные координаты хранятся неоптимальным образом.

Перейдем далее к рассмотрению более экономных форматов хранения. '''Разреженный строчный формат''' - это одна из наиболее широко используемых схем хранения разреженных матриц. Эта схема предъявляет минимальные требования к памяти и в то же время оказывается очень удобной для нескольких важных операций над разреженными матрицами: сложения, умножения, перестановок строк и столбцов, транспонирования, решения линейных систем с разреженными матрицами коэффициентов как прямыми, так и итерационными методами и т. д.

В соответствии с рассматриваемой схемой для хранения матрицы A требуется три одномерных массива:

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его опять как values);

~ массив номеров столбцов для соответствующих элементов массива values (обозначим его как cols);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его pointer). Описание k-й строки хранится в позициях с pointer[k]-й по (pointer[k+1]–1)-ю массивов values и cols. Если pointer[k]=pointer[k+1], то k-я строка пустая. Если матрица A состоит из n строк, то длина массива pointer будет n+1.

Данный способ представления также является полным, и упорядоченным, поскольку элементы каждой строки хранятся в соответствии с возрастанием столбцовых индексов.

Очевидно, что объем памяти, требуемый для хранения вектора pointer, значительно меньше, чем для хранения вектора rows. Более того, разреженный строчный формат обеспечивает эффективный доступ к строчкам матрицы; доступ к столбцам по прежнему затруднен. Поэтому предпочтительно использовать этот способ хранения в тех алгоритмах, в которых преобладают строчные операции.

Существует также '''разреженный столбцовый формат''', который строится аналогичным способом.

Теперь, разобравшись со способами хранения разреженных матриц, можно перейти к ''алгоритму умножения разреженной матрицы на вектор''. Умножение матрицы на вектор является подзадачей для нахождения решений СЛАУ итерационными методами.

'''1.2 Математическое описание алгоритма'''

Пусть матрица размером <math>N\times M</math> содержит в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>

Условимся использовать строчный формат хранения матрицы, который описан выше.

На входе у нас 4 массива: val(ненулевые элементы матрицы), col(номера столбцов), row(массив указателей) и vec(вектор, на который мы умножаем матрицу).

На выходе получим вектор out.

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}, \ i=\overline{0,N-1}</math>, где <math>N</math> - число строк матрицы.

'''1.3 Вычислительное ядро алгоритма'''

Ядром алгоритма является вычисление сумм произведений, описанное в [[предыдущем пункте]].

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}</math>

Итого: <math>NZ</math> умножений + <math>x</math> сложений(<math>NZ-N<x<NZ-1</math>).

'''1.4 Макроструктура алгоритма'''

Как видно из [[описания алгоритма]], метод состоит из вычисления неполных скалярных произведений.

'''1.5 Схема реализации последовательного алгоритма'''

for(i=0; i<N; i++)
{
out[i]=0;
for(j=row[i]; j<row[i+1]; j++)
{
out[i] += val[j]*vec[col[j]];
}
}

'''1.6 Последовательная сложность алгоритма'''

<math>\bullet \ NZ</math> умножений

<math>\bullet \ x</math> сложений(<math>NZ-N<x<NZ-1</math>).

'''1.7 Информационный граф'''

[[Файл:sparse_matrix.jpg|500px|при N=3]]

Черным отмечены ненулевые элементы. При увеличении числа N граф будет аналогичным.