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

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-11-07T18:34:23Z

Екатерина Буторина:

{{Assignment}}
{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nnz</math>
| pf_height = <math>O(n)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>2(nnz+n)+1</math>
| output_data = <math>n</math>
}}
Авторы статьи: [[Участница:Руфина_Третьякова|Третьякова Р. М.]] (группа 603), [[Участница:Екатерина_Буторина|Буторина Е. В.]] (группа 603)

Руфина Третьякова отвечает за программную реализацию алгоритма, Екатерина Буторина - за написание статьи.

==ЧАСТЬ. Свойства и структура алгоритма ==

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

=== Математическое описание алгоритма ===
Исходные данные: разреженная матрица <math>M^{n*n}</math>, вектор <math>x^n</math>

Наиболее удобным форматом для вычисления произведения матрицы на вектор является "Compressed Sparse Row" или сокращенно CSR-формат.

Рассмотрим CSR-представление разреженной матрицы: пусть число ненулевых элементов матрицы равно <math>nnz</math>
CSR-формат представляет матрицу <math>M</math> в виде 3-х одномерных массивов:

массив <math>A</math> размера <math>nnz</math> содержит ненулевые значения матрицы,
<math>JA</math> размера <math>nnz</math> - номера столбцов ненулевых элементов.,
<math>IA</math> размера <math>n</math>- содержит номер с которого начинается описание элементов строки в массивах <math>A</math> и <math>JA</math>.

Этот формат позволяет производить перемножение матрицы <math>M</math> на вектор <math>x</math> за <math>O(nnz)</math> умножений и сложений.
Если при умножении плотной матрицы на вектор каждый элемент результата определяется по формуле
<math>y_i = \sum_{k = 1}^{n} A_{ik} x_k</math>,
то в случае разреженной матрицы достаточно выполнять умножения только для ненулевых элементов <math>A_ik</math>, которые хранятся в массиве <math>A</math> в части соответствующей строке <math>i</math> (элементы с индексами от <math>IA_i</math> до <math>IA_{i+1}</math>). Необходимо также знать на какой элемент вектора должен быть домножен данный ненулевой элемент массива, то есть нужен столбцовый индекс каждого элемента <math>A</math>. Для этого используется массив <math>JA</math>. Таким образом, каждый элемент итогового вектора определятся формулой
:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>
Нетрудно заметить, что общее число операций умножения равно числу элементов <math>A</math>, то есть числу ненулевых элементов разреженной матрицы.

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 0 \\
2 & 0 & 0 & 1 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
представляемая в формате CSR
A = [ 2 1 3 4 ]
IA = [ 0 0 2 3 4 ]
JA = [ 0 3 2 1 ]
домножим ее на вектор
x = [ 5 6 7 8 ]
получим
y[0] = 0
y[1] = a[0]*x[0] + a[1]*x[3] = 18
y[2] = a[2]*x[2] = 21
y[3] = a[3]*x[1] = 24

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

=== Вычислительное ядро алгоритма ===
Вычислительным ядром алгоритма является формула умножения разреженной матрицы на плотный вектор:
:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>
для всех <math>i = 1,n</math>

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.
'''read CSR''' ''n'', ''IA'', ''JA'', ''A'';
'''read''' ''x''
'''for''' ''i'' = 1,n:
'''for''' ''k'' = ''IA(i)'', ''IA(i+1)-1'':
''y(i)'' += ''A(k)''*''x(JA(k))'';
'''write''' ''y'';

=== Схема реализации последовательного алгоритма ===
Метод можно описать следующим образом:
# привести матрицу <math>M</math> к формату CSR
# для <math>i</math> от <math>0</math> до <math>n-1</math> вычислить <math>y_i</math> по формуле <math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Последовательная сложность алгоритма ===
Для вычисления матрично-векторного произведения матрицы размера <math>n*n</math> и вектора размера n в последовательном варианте требуется:

* <math>nnz</math> сложений,
* <math>nnz</math> умножений.

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

Для того чтобы построить информационный граф рассмотрим процесс вычисления значения одного элемента результирующего вектора <math>y_i</math>. Число последовательных ярусов равно числу последовательных операций -- <math> AI_{i+1} - AI_i </math> (в данном случае умножение и сложение будем считать за одну операцию).
Если же вычисления всех <math>y_i</math> производить параллельно, на каждом ярусе будет производиться <math>n</math> операций.

[[Файл:Pic.jpg|800x800px|center|thumb|Информационный граф алгоритма умножения разреженной матрицы на плотный вектор
(Рисунок составлен самостоятельно)]]

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

Возможность параллельной реализации алгоритма появляется благодаря независимости вычисления каждого элемента результирующего вектора <math>y_i</math>. Предположим, что имеется неограниченное число процессоров (теоретически, для максимальной эффективности требуется <math>n</math> процессоров). Каждый процессор работает с одной строкой разреженной матрицы и хранит в памяти только те части массивов
<math> AJ </math> и <math> A </math>, которые соответствуют данной строке. Вектор <math> x </math> хранится в памяти всех процессоров. Таким образом достигается экономия памяти (объем данных для i-ого процессора <math> 2(AI_{i+1} - AI_i) + n </math>). На данном процессоре выполняется
<math> AI_{i+1} - AI_i </math> последовательных операций умножения и сложения. Число ярусов для i-ого процессора равно <math> AI_{i+1} - AI_i </math>. Поскольку изначальная разреженная матрица имеет произвольную структуру, число ярусов на различных процессорах может быть различно. В худшем случае (если в строке все элементы ненулевые) число ярусов будет равно <math>n</math>.

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

* не более чем <math>n</math> ярусов умножений и сложений,
* в каждом из ярусов не более чем <math>n</math> операций.

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

''Замечание:'' если число процессоров <math>k</math> меньше числа строк, но отношение <math>\frac{n}{k} = c</math> является константой, то каждый процессор вычисляет <math>c</math> элементов результирующего вектора, и число ярусов не более чем <math>cn</math>. Таким образом, предыдущие оценки сложности сохранятся.

=== Входные и выходные данные алгоритма ===
Входными данными алгоритма являются:
# размер разреженной матрицы <math> n </math>;
# вектор <math> AI </math> размерности <math> n+1 </math>;
# вектор <math> AJ </math> размерности <math> nnz </math>;
# вектор <math> A </math> размерности <math> nnz </math>;
# вектор <math> x </math> размерности <math> n </math>.

Суммарная размерность входных данных: <math> 2(nnz + n) + 1 </math>

Выходными данными является
# вектор <math> y </math> размерности <math> n </math>.

Объем выходных данных: <math> n </math>.

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

Если размерность матрицы <math>n</math>, число ненулевых элементов <math>nnz</math>, для вычисления используется <math>k</math> процессоров тогда:

*Каждый процессор оперирует с <math>\frac{n}{k}</math> строками, в каждой из которых примерно <math>\frac{nnz}{n}</math> элементов. Параллельная сложность алгоритма - <math>O(\frac{nnz}{k})</math>.

*Вычислительная мощность алгоритма (отношение числа операций к суммарному объему входных и выходных данных) - <math>O(\frac{nnz}{2nnz + 3n}) = O(1)</math> - для последовательного алгоритма; <math>O(\frac{nnz}{n} / (2\frac{nnz}{n} + n)) = O(1) </math> - для параллельного алгоритма.

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Переделаю, время еще есть...

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

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

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

Последовательная реализация имеется в пакете SPARSKIT [http://w3.pppl.gov/~hammett/work/2006/gmres/SPARSKIT2/BLASSM/matvec.f], Python.Scipy [https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.sparse.csr_matrix.html]

Параллельный алгоритм реализован в библиотеке Matlab [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.83.6692&rep=rep1&type=pdf], Intel MKL [https://software.intel.com/en-us/node/468536#D09FB46A-B404-44CC-94ED-1C434C41B6E1]

== Литература ==
[1] С. Писсанецки. Технология разреженных матриц. Изд. Мир, 1988.

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

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-11-07T18:32:54Z

Екатерина Буторина: /* Информационный граф */

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nnz</math>
| pf_height = <math>O(n)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>2(nnz+n)+1</math>
| output_data = <math>n</math>
}}
Авторы статьи: [[Участница:Руфина_Третьякова|Третьякова Р. М.]] (группа 603), [[Участница:Екатерина_Буторина|Буторина Е. В.]] (группа 603)

Руфина Третьякова отвечает за программную реализацию алгоритма, Екатерина Буторина - за написание статьи.

==ЧАСТЬ. Свойства и структура алгоритма ==

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

=== Математическое описание алгоритма ===
Исходные данные: разреженная матрица <math>M^{n*n}</math>, вектор <math>x^n</math>

Наиболее удобным форматом для вычисления произведения матрицы на вектор является "Compressed Sparse Row" или сокращенно CSR-формат.

Рассмотрим CSR-представление разреженной матрицы: пусть число ненулевых элементов матрицы равно <math>nnz</math>
CSR-формат представляет матрицу <math>M</math> в виде 3-х одномерных массивов:

массив <math>A</math> размера <math>nnz</math> содержит ненулевые значения матрицы,
<math>JA</math> размера <math>nnz</math> - номера столбцов ненулевых элементов.,
<math>IA</math> размера <math>n</math>- содержит номер с которого начинается описание элементов строки в массивах <math>A</math> и <math>JA</math>.

Этот формат позволяет производить перемножение матрицы <math>M</math> на вектор <math>x</math> за <math>O(nnz)</math> умножений и сложений.
Если при умножении плотной матрицы на вектор каждый элемент результата определяется по формуле
<math>y_i = \sum_{k = 1}^{n} A_{ik} x_k</math>,
то в случае разреженной матрицы достаточно выполнять умножения только для ненулевых элементов <math>A_ik</math>, которые хранятся в массиве <math>A</math> в части соответствующей строке <math>i</math> (элементы с индексами от <math>IA_i</math> до <math>IA_{i+1}</math>). Необходимо также знать на какой элемент вектора должен быть домножен данный ненулевой элемент массива, то есть нужен столбцовый индекс каждого элемента <math>A</math>. Для этого используется массив <math>JA</math>. Таким образом, каждый элемент итогового вектора определятся формулой
:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>
Нетрудно заметить, что общее число операций умножения равно числу элементов <math>A</math>, то есть числу ненулевых элементов разреженной матрицы.

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 0 \\
2 & 0 & 0 & 1 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
представляемая в формате CSR
A = [ 2 1 3 4 ]
IA = [ 0 0 2 3 4 ]
JA = [ 0 3 2 1 ]
домножим ее на вектор
x = [ 5 6 7 8 ]
получим
y[0] = 0
y[1] = a[0]*x[0] + a[1]*x[3] = 18
y[2] = a[2]*x[2] = 21
y[3] = a[3]*x[1] = 24

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

=== Вычислительное ядро алгоритма ===
Вычислительным ядром алгоритма является формула умножения разреженной матрицы на плотный вектор:
:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>
для всех <math>i = 1,n</math>

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.
'''read CSR''' ''n'', ''IA'', ''JA'', ''A'';
'''read''' ''x''
'''for''' ''i'' = 1,n:
'''for''' ''k'' = ''IA(i)'', ''IA(i+1)-1'':
''y(i)'' += ''A(k)''*''x(JA(k))'';
'''write''' ''y'';

=== Схема реализации последовательного алгоритма ===
Метод можно описать следующим образом:
# привести матрицу <math>M</math> к формату CSR
# для <math>i</math> от <math>0</math> до <math>n-1</math> вычислить <math>y_i</math> по формуле <math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Последовательная сложность алгоритма ===
Для вычисления матрично-векторного произведения матрицы размера <math>n*n</math> и вектора размера n в последовательном варианте требуется:

* <math>nnz</math> сложений,
* <math>nnz</math> умножений.

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

Для того чтобы построить информационный граф рассмотрим процесс вычисления значения одного элемента результирующего вектора <math>y_i</math>. Число последовательных ярусов равно числу последовательных операций -- <math> AI_{i+1} - AI_i </math> (в данном случае умножение и сложение будем считать за одну операцию).
Если же вычисления всех <math>y_i</math> производить параллельно, на каждом ярусе будет производиться <math>n</math> операций.

[[Файл:Pic.jpg|800x800px|center|thumb|Информационный граф алгоритма умножения разреженной матрицы на плотный вектор
(Рисунок составлен самостоятельно)]]

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

Возможность параллельной реализации алгоритма появляется благодаря независимости вычисления каждого элемента результирующего вектора <math>y_i</math>. Предположим, что имеется неограниченное число процессоров (теоретически, для максимальной эффективности требуется <math>n</math> процессоров). Каждый процессор работает с одной строкой разреженной матрицы и хранит в памяти только те части массивов
<math> AJ </math> и <math> A </math>, которые соответствуют данной строке. Вектор <math> x </math> хранится в памяти всех процессоров. Таким образом достигается экономия памяти (объем данных для i-ого процессора <math> 2(AI_{i+1} - AI_i) + n </math>). На данном процессоре выполняется
<math> AI_{i+1} - AI_i </math> последовательных операций умножения и сложения. Число ярусов для i-ого процессора равно <math> AI_{i+1} - AI_i </math>. Поскольку изначальная разреженная матрица имеет произвольную структуру, число ярусов на различных процессорах может быть различно. В худшем случае (если в строке все элементы ненулевые) число ярусов будет равно <math>n</math>.

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

* не более чем <math>n</math> ярусов умножений и сложений,
* в каждом из ярусов не более чем <math>n</math> операций.

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

''Замечание:'' если число процессоров <math>k</math> меньше числа строк, но отношение <math>\frac{n}{k} = c</math> является константой, то каждый процессор вычисляет <math>c</math> элементов результирующего вектора, и число ярусов не более чем <math>cn</math>. Таким образом, предыдущие оценки сложности сохранятся.

=== Входные и выходные данные алгоритма ===
Входными данными алгоритма являются:
# размер разреженной матрицы <math> n </math>;
# вектор <math> AI </math> размерности <math> n+1 </math>;
# вектор <math> AJ </math> размерности <math> nnz </math>;
# вектор <math> A </math> размерности <math> nnz </math>;
# вектор <math> x </math> размерности <math> n </math>.

Суммарная размерность входных данных: <math> 2(nnz + n) + 1 </math>

Выходными данными является
# вектор <math> y </math> размерности <math> n </math>.

Объем выходных данных: <math> n </math>.

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

Если размерность матрицы <math>n</math>, число ненулевых элементов <math>nnz</math>, для вычисления используется <math>k</math> процессоров тогда:

*Каждый процессор оперирует с <math>\frac{n}{k}</math> строками, в каждой из которых примерно <math>\frac{nnz}{n}</math> элементов. Параллельная сложность алгоритма - <math>O(\frac{nnz}{k})</math>.

*Вычислительная мощность алгоритма (отношение числа операций к суммарному объему входных и выходных данных) - <math>O(\frac{nnz}{2nnz + 3n}) = O(1)</math> - для последовательного алгоритма; <math>O(\frac{nnz}{n} / (2\frac{nnz}{n} + n)) = O(1) </math> - для параллельного алгоритма.

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Переделаю, время еще есть...

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

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

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

Последовательная реализация имеется в пакете SPARSKIT [http://w3.pppl.gov/~hammett/work/2006/gmres/SPARSKIT2/BLASSM/matvec.f], Python.Scipy [https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.sparse.csr_matrix.html]

Параллельный алгоритм реализован в библиотеке Matlab [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.83.6692&rep=rep1&type=pdf], Intel MKL [https://software.intel.com/en-us/node/468536#D09FB46A-B404-44CC-94ED-1C434C41B6E1]

== Литература ==
[1] С. Писсанецки. Технология разреженных матриц. Изд. Мир, 1988.

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

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-11-07T18:28:14Z

Екатерина Буторина:

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nnz</math>
| pf_height = <math>O(n)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>2(nnz+n)+1</math>
| output_data = <math>n</math>
}}
Авторы статьи: [[Участница:Руфина_Третьякова|Третьякова Р. М.]] (группа 603), [[Участница:Екатерина_Буторина|Буторина Е. В.]] (группа 603)

Руфина Третьякова отвечает за программную реализацию алгоритма, Екатерина Буторина - за написание статьи.

==ЧАСТЬ. Свойства и структура алгоритма ==

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

=== Математическое описание алгоритма ===
Исходные данные: разреженная матрица <math>M^{n*n}</math>, вектор <math>x^n</math>

Наиболее удобным форматом для вычисления произведения матрицы на вектор является "Compressed Sparse Row" или сокращенно CSR-формат.

Рассмотрим CSR-представление разреженной матрицы: пусть число ненулевых элементов матрицы равно <math>nnz</math>
CSR-формат представляет матрицу <math>M</math> в виде 3-х одномерных массивов:

массив <math>A</math> размера <math>nnz</math> содержит ненулевые значения матрицы,
<math>JA</math> размера <math>nnz</math> - номера столбцов ненулевых элементов.,
<math>IA</math> размера <math>n</math>- содержит номер с которого начинается описание элементов строки в массивах <math>A</math> и <math>JA</math>.

Этот формат позволяет производить перемножение матрицы <math>M</math> на вектор <math>x</math> за <math>O(nnz)</math> умножений и сложений.
Если при умножении плотной матрицы на вектор каждый элемент результата определяется по формуле
<math>y_i = \sum_{k = 1}^{n} A_{ik} x_k</math>,
то в случае разреженной матрицы достаточно выполнять умножения только для ненулевых элементов <math>A_ik</math>, которые хранятся в массиве <math>A</math> в части соответствующей строке <math>i</math> (элементы с индексами от <math>IA_i</math> до <math>IA_{i+1}</math>). Необходимо также знать на какой элемент вектора должен быть домножен данный ненулевой элемент массива, то есть нужен столбцовый индекс каждого элемента <math>A</math>. Для этого используется массив <math>JA</math>. Таким образом, каждый элемент итогового вектора определятся формулой
:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>
Нетрудно заметить, что общее число операций умножения равно числу элементов <math>A</math>, то есть числу ненулевых элементов разреженной матрицы.

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 0 \\
2 & 0 & 0 & 1 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
представляемая в формате CSR
A = [ 2 1 3 4 ]
IA = [ 0 0 2 3 4 ]
JA = [ 0 3 2 1 ]
домножим ее на вектор
x = [ 5 6 7 8 ]
получим
y[0] = 0
y[1] = a[0]*x[0] + a[1]*x[3] = 18
y[2] = a[2]*x[2] = 21
y[3] = a[3]*x[1] = 24

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

=== Вычислительное ядро алгоритма ===
Вычислительным ядром алгоритма является формула умножения разреженной матрицы на плотный вектор:
:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>
для всех <math>i = 1,n</math>

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.
'''read CSR''' ''n'', ''IA'', ''JA'', ''A'';
'''read''' ''x''
'''for''' ''i'' = 1,n:
'''for''' ''k'' = ''IA(i)'', ''IA(i+1)-1'':
''y(i)'' += ''A(k)''*''x(JA(k))'';
'''write''' ''y'';

=== Схема реализации последовательного алгоритма ===
Метод можно описать следующим образом:
# привести матрицу <math>M</math> к формату CSR
# для <math>i</math> от <math>0</math> до <math>n-1</math> вычислить <math>y_i</math> по формуле <math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Последовательная сложность алгоритма ===
Для вычисления матрично-векторного произведения матрицы размера <math>n*n</math> и вектора размера n в последовательном варианте требуется:

* <math>nnz</math> сложений,
* <math>nnz</math> умножений.

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

Для того чтобы построить информационный граф рассмотрим процесс вычисления значения одного элемента результирующего вектора <math>y_i</math>. Число последовательных ярусов равно числу последовательных операций -- <math> AI_{i+1} - AI_i </math> (в данном случае умножение и сложение будем считать за одну операцию).
Если же вычисления всех <math>y_i</math> производить параллельно, на каждом ярусе будет производиться <math>n</math> операций.

[[Файл:pic.jpg|800x800px|center|thumb|Информационный граф алгоритма умножения разреженной матрицы на плотный вектор
(Рисунок составлен самостоятельно)]]

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

Возможность параллельной реализации алгоритма появляется благодаря независимости вычисления каждого элемента результирующего вектора <math>y_i</math>. Предположим, что имеется неограниченное число процессоров (теоретически, для максимальной эффективности требуется <math>n</math> процессоров). Каждый процессор работает с одной строкой разреженной матрицы и хранит в памяти только те части массивов
<math> AJ </math> и <math> A </math>, которые соответствуют данной строке. Вектор <math> x </math> хранится в памяти всех процессоров. Таким образом достигается экономия памяти (объем данных для i-ого процессора <math> 2(AI_{i+1} - AI_i) + n </math>). На данном процессоре выполняется
<math> AI_{i+1} - AI_i </math> последовательных операций умножения и сложения. Число ярусов для i-ого процессора равно <math> AI_{i+1} - AI_i </math>. Поскольку изначальная разреженная матрица имеет произвольную структуру, число ярусов на различных процессорах может быть различно. В худшем случае (если в строке все элементы ненулевые) число ярусов будет равно <math>n</math>.

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

* не более чем <math>n</math> ярусов умножений и сложений,
* в каждом из ярусов не более чем <math>n</math> операций.

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

''Замечание:'' если число процессоров <math>k</math> меньше числа строк, но отношение <math>\frac{n}{k} = c</math> является константой, то каждый процессор вычисляет <math>c</math> элементов результирующего вектора, и число ярусов не более чем <math>cn</math>. Таким образом, предыдущие оценки сложности сохранятся.

=== Входные и выходные данные алгоритма ===
Входными данными алгоритма являются:
# размер разреженной матрицы <math> n </math>;
# вектор <math> AI </math> размерности <math> n+1 </math>;
# вектор <math> AJ </math> размерности <math> nnz </math>;
# вектор <math> A </math> размерности <math> nnz </math>;
# вектор <math> x </math> размерности <math> n </math>.

Суммарная размерность входных данных: <math> 2(nnz + n) + 1 </math>

Выходными данными является
# вектор <math> y </math> размерности <math> n </math>.

Объем выходных данных: <math> n </math>.

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

Если размерность матрицы <math>n</math>, число ненулевых элементов <math>nnz</math>, для вычисления используется <math>k</math> процессоров тогда:

*Каждый процессор оперирует с <math>\frac{n}{k}</math> строками, в каждой из которых примерно <math>\frac{nnz}{n}</math> элементов. Параллельная сложность алгоритма - <math>O(\frac{nnz}{k})</math>.

*Вычислительная мощность алгоритма (отношение числа операций к суммарному объему входных и выходных данных) - <math>O(\frac{nnz}{2nnz + 3n}) = O(1)</math> - для последовательного алгоритма; <math>O(\frac{nnz}{n} / (2\frac{nnz}{n} + n)) = O(1) </math> - для параллельного алгоритма.

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Переделаю, время еще есть...

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

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

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

Последовательная реализация имеется в пакете SPARSKIT [http://w3.pppl.gov/~hammett/work/2006/gmres/SPARSKIT2/BLASSM/matvec.f], Python.Scipy [https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.sparse.csr_matrix.html]

Параллельный алгоритм реализован в библиотеке Matlab [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.83.6692&rep=rep1&type=pdf], Intel MKL [https://software.intel.com/en-us/node/468536#D09FB46A-B404-44CC-94ED-1C434C41B6E1]

== Литература ==
[1] С. Писсанецки. Технология разреженных матриц. Изд. Мир, 1988.

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

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-11-07T18:28:02Z

Екатерина Буторина:

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nnz</math>
| pf_height = <math>O(n)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>2(nnz+n)+1</math>
| output_data = <math>n</math>
}}
Авторы статьи: [[Участница:Руфина_Третьякова|Третьякова Р. М.]] (группа 603), [[Участница:Екатерина_Буторина|Буторина Е. В.]] (группа 603)

Руфина Третьякова отвечает за программную реализацию алгоритма, Екатерина Буторина - за написание статьи.

==ЧАСТЬ. Свойства и структура алгоритма ==

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

=== Математическое описание алгоритма ===
Исходные данные: разреженная матрица <math>M^{n*n}</math>, вектор <math>x^n</math>

Наиболее удобным форматом для вычисления произведения матрицы на вектор является "Compressed Sparse Row" или сокращенно CSR-формат.

Рассмотрим CSR-представление разреженной матрицы: пусть число ненулевых элементов матрицы равно <math>nnz</math>
CSR-формат представляет матрицу <math>M</math> в виде 3-х одномерных массивов:

массив <math>A</math> размера <math>nnz</math> содержит ненулевые значения матрицы,
<math>JA</math> размера <math>nnz</math> - номера столбцов ненулевых элементов.,
<math>IA</math> размера <math>n</math>- содержит номер с которого начинается описание элементов строки в массивах <math>A</math> и <math>JA</math>.

Этот формат позволяет производить перемножение матрицы <math>M</math> на вектор <math>x</math> за <math>O(nnz)</math> умножений и сложений.
Если при умножении плотной матрицы на вектор каждый элемент результата определяется по формуле
<math>y_i = \sum_{k = 1}^{n} A_{ik} x_k</math>,
то в случае разреженной матрицы достаточно выполнять умножения только для ненулевых элементов <math>A_ik</math>, которые хранятся в массиве <math>A</math> в части соответствующей строке <math>i</math> (элементы с индексами от <math>IA_i</math> до <math>IA_{i+1}</math>). Необходимо также знать на какой элемент вектора должен быть домножен данный ненулевой элемент массива, то есть нужен столбцовый индекс каждого элемента <math>A</math>. Для этого используется массив <math>JA</math>. Таким образом, каждый элемент итогового вектора определятся формулой
:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>
Нетрудно заметить, что общее число операций умножения равно числу элементов <math>A</math>, то есть числу ненулевых элементов разреженной матрицы.

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 0 \\
2 & 0 & 0 & 1 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
представляемая в формате CSR
A = [ 2 1 3 4 ]
IA = [ 0 0 2 3 4 ]
JA = [ 0 3 2 1 ]
домножим ее на вектор
x = [ 5 6 7 8 ]
получим
y[0] = 0
y[1] = a[0]*x[0] + a[1]*x[3] = 18
y[2] = a[2]*x[2] = 21
y[3] = a[3]*x[1] = 24

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

=== Вычислительное ядро алгоритма ===
Вычислительным ядром алгоритма является формула умножения разреженной матрицы на плотный вектор:
:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>
для всех <math>i = 1,n</math>

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.
'''read CSR''' ''n'', ''IA'', ''JA'', ''A'';
'''read''' ''x''
'''for''' ''i'' = 1,n:
'''for''' ''k'' = ''IA(i)'', ''IA(i+1)-1'':
''y(i)'' += ''A(k)''*''x(JA(k))'';
'''write''' ''y'';

=== Схема реализации последовательного алгоритма ===
Метод можно описать следующим образом:
# привести матрицу <math>M</math> к формату CSR
# для <math>i</math> от <math>0</math> до <math>n-1</math> вычислить <math>y_i</math> по формуле <math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Последовательная сложность алгоритма ===
Для вычисления матрично-векторного произведения матрицы размера <math>n*n</math> и вектора размера n в последовательном варианте требуется:

* <math>nnz</math> сложений,
* <math>nnz</math> умножений.

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

Для того чтобы построить информационный граф рассмотрим процесс вычисления значения одного элемента результирующего вектора <math>y_i</math>. Число последовательных ярусов равно числу последовательных операций -- <math> AI_{i+1} - AI_i </math> (в данном случае умножение и сложение будем считать за одну операцию).
Если же вычисления всех <math>y_i</math> производить параллельно, на каждом ярусе будет производиться <math>n</math> операций.

[[Файл:.jpg|800x800px|center|thumb|Информационный граф алгоритма умножения разреженной матрицы на плотный вектор
(Рисунок составлен самостоятельно)]]

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

Возможность параллельной реализации алгоритма появляется благодаря независимости вычисления каждого элемента результирующего вектора <math>y_i</math>. Предположим, что имеется неограниченное число процессоров (теоретически, для максимальной эффективности требуется <math>n</math> процессоров). Каждый процессор работает с одной строкой разреженной матрицы и хранит в памяти только те части массивов
<math> AJ </math> и <math> A </math>, которые соответствуют данной строке. Вектор <math> x </math> хранится в памяти всех процессоров. Таким образом достигается экономия памяти (объем данных для i-ого процессора <math> 2(AI_{i+1} - AI_i) + n </math>). На данном процессоре выполняется
<math> AI_{i+1} - AI_i </math> последовательных операций умножения и сложения. Число ярусов для i-ого процессора равно <math> AI_{i+1} - AI_i </math>. Поскольку изначальная разреженная матрица имеет произвольную структуру, число ярусов на различных процессорах может быть различно. В худшем случае (если в строке все элементы ненулевые) число ярусов будет равно <math>n</math>.

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

* не более чем <math>n</math> ярусов умножений и сложений,
* в каждом из ярусов не более чем <math>n</math> операций.

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

''Замечание:'' если число процессоров <math>k</math> меньше числа строк, но отношение <math>\frac{n}{k} = c</math> является константой, то каждый процессор вычисляет <math>c</math> элементов результирующего вектора, и число ярусов не более чем <math>cn</math>. Таким образом, предыдущие оценки сложности сохранятся.

=== Входные и выходные данные алгоритма ===
Входными данными алгоритма являются:
# размер разреженной матрицы <math> n </math>;
# вектор <math> AI </math> размерности <math> n+1 </math>;
# вектор <math> AJ </math> размерности <math> nnz </math>;
# вектор <math> A </math> размерности <math> nnz </math>;
# вектор <math> x </math> размерности <math> n </math>.

Суммарная размерность входных данных: <math> 2(nnz + n) + 1 </math>

Выходными данными является
# вектор <math> y </math> размерности <math> n </math>.

Объем выходных данных: <math> n </math>.

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

Если размерность матрицы <math>n</math>, число ненулевых элементов <math>nnz</math>, для вычисления используется <math>k</math> процессоров тогда:

*Каждый процессор оперирует с <math>\frac{n}{k}</math> строками, в каждой из которых примерно <math>\frac{nnz}{n}</math> элементов. Параллельная сложность алгоритма - <math>O(\frac{nnz}{k})</math>.

*Вычислительная мощность алгоритма (отношение числа операций к суммарному объему входных и выходных данных) - <math>O(\frac{nnz}{2nnz + 3n}) = O(1)</math> - для последовательного алгоритма; <math>O(\frac{nnz}{n} / (2\frac{nnz}{n} + n)) = O(1) </math> - для параллельного алгоритма.

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Переделаю, время еще есть...

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

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

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

Последовательная реализация имеется в пакете SPARSKIT [http://w3.pppl.gov/~hammett/work/2006/gmres/SPARSKIT2/BLASSM/matvec.f], Python.Scipy [https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.sparse.csr_matrix.html]

Параллельный алгоритм реализован в библиотеке Matlab [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.83.6692&rep=rep1&type=pdf], Intel MKL [https://software.intel.com/en-us/node/468536#D09FB46A-B404-44CC-94ED-1C434C41B6E1]

== Литература ==
[1] С. Писсанецки. Технология разреженных матриц. Изд. Мир, 1988.

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

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-11-07T18:23:44Z

Екатерина Буторина:

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nnz</math>
| pf_height = <math>O(n)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>2(nnz+n)+1</math>
| output_data = <math>n</math>
}}
Авторы статьи: [[Участница:Руфина_Третьякова|Третьякова Р. М.]] (группа 603), [[Участница:Екатерина_Буторина|Буторина Е. В.]] (группа 603)

Руфина Третьякова отвечает за программную реализацию алгоритма, Екатерина Буторина - за написание статьи.

==ЧАСТЬ. Свойства и структура алгоритма ==

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

=== Математическое описание алгоритма ===
Исходные данные: разреженная матрица <math>M^{n*n}</math>, вектор <math>x^n</math>

Наиболее удобным форматом для вычисления произведения матрицы на вектор является "Compressed Sparse Row" или сокращенно CSR-формат.

Рассмотрим CSR-представление разреженной матрицы: пусть число ненулевых элементов матрицы равно <math>nnz</math>
CSR-формат представляет матрицу <math>M</math> в виде 3-х одномерных массивов:

массив <math>A</math> размера <math>nnz</math> содержит ненулевые значения матрицы,
<math>JA</math> размера <math>nnz</math> - номера столбцов ненулевых элементов.,
<math>IA</math> размера <math>n</math>- содержит номер с которого начинается описание элементов строки в массивах <math>A</math> и <math>JA</math>.

Этот формат позволяет производить перемножение матрицы <math>M</math> на вектор <math>x</math> за <math>O(nnz)</math> умножений и сложений.
Если при умножении плотной матрицы на вектор каждый элемент результата определяется по формуле
<math>y_i = \sum_{k = 1}^{n} A_{ik} x_k</math>,
то в случае разреженной матрицы достаточно выполнять умножения только для ненулевых элементов <math>A_ik</math>, которые хранятся в массиве <math>A</math> в части соответствующей строке <math>i</math> (элементы с индексами от <math>IA_i</math> до <math>IA_{i+1}</math>). Необходимо также знать на какой элемент вектора должен быть домножен данный ненулевой элемент массива, то есть нужен столбцовый индекс каждого элемента <math>A</math>. Для этого используется массив <math>JA</math>. Таким образом, каждый элемент итогового вектора определятся формулой
:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>
Нетрудно заметить, что общее число операций умножения равно числу элементов <math>A</math>, то есть числу ненулевых элементов разреженной матрицы.

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 0 \\
2 & 0 & 0 & 1 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
представляемая в формате CSR
A = [ 2 1 3 4 ]
IA = [ 0 0 2 3 4 ]
JA = [ 0 3 2 1 ]
домножим ее на вектор
x = [ 5 6 7 8 ]
получим
y[0] = 0
y[1] = a[0]*x[0] + a[1]*x[3] = 18
y[2] = a[2]*x[2] = 21
y[3] = a[3]*x[1] = 24

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

=== Вычислительное ядро алгоритма ===
Вычислительным ядром алгоритма является формула умножения разреженной матрицы на плотный вектор:
:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>
для всех <math>i = 1,n</math>

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.
'''read CSR''' ''n'', ''IA'', ''JA'', ''A'';
'''read''' ''x''
'''for''' ''i'' = 1,n:
'''for''' ''k'' = ''IA(i)'', ''IA(i+1)-1'':
''y(i)'' += ''A(k)''*''x(JA(k))'';
'''write''' ''y'';

=== Схема реализации последовательного алгоритма ===
Метод можно описать следующим образом:
# привести матрицу <math>M</math> к формату CSR
# для <math>i</math> от <math>0</math> до <math>n-1</math> вычислить <math>y_i</math> по формуле <math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Последовательная сложность алгоритма ===
Для вычисления матрично-векторного произведения матрицы размера <math>n*n</math> и вектора размера n в последовательном варианте требуется:

* <math>nnz</math> сложений,
* <math>nnz</math> умножений.

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

Для того чтобы построить информационный граф рассмотрим процесс вычисления значения одного элемента результирующего вектора <math>y_i</math>. Число последовательных ярусов равно числу последовательных операций -- <math> AI_{i+1} - AI_i </math> (в данном случае умножение и сложение будем считать за одну операцию).
Если же вычисления всех <math>y_i</math> производить параллельно, на каждом ярусе будет производиться <math>n</math> операций.

[[Файл:pic.jpg|800x800px|center|thumb|Информационный граф алгоритма умножения разреженной матрицы на плотный вектор
(Рисунок составлен самостоятельно)]]

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

Возможность параллельной реализации алгоритма появляется благодаря независимости вычисления каждого элемента результирующего вектора <math>y_i</math>. Предположим, что имеется неограниченное число процессоров (теоретически, для максимальной эффективности требуется <math>n</math> процессоров). Каждый процессор работает с одной строкой разреженной матрицы и хранит в памяти только те части массивов
<math> AJ </math> и <math> A </math>, которые соответствуют данной строке. Вектор <math> x </math> хранится в памяти всех процессоров. Таким образом достигается экономия памяти (объем данных для i-ого процессора <math> 2(AI_{i+1} - AI_i) + n </math>). На данном процессоре выполняется
<math> AI_{i+1} - AI_i </math> последовательных операций умножения и сложения. Число ярусов для i-ого процессора равно <math> AI_{i+1} - AI_i </math>. Поскольку изначальная разреженная матрица имеет произвольную структуру, число ярусов на различных процессорах может быть различно. В худшем случае (если в строке все элементы ненулевые) число ярусов будет равно <math>n</math>.

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

* не более чем <math>n</math> ярусов умножений и сложений,
* в каждом из ярусов не более чем <math>n</math> операций.

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

''Замечание:'' если число процессоров <math>k</math> меньше числа строк, но отношение <math>\frac{n}{k} = c</math> является константой, то каждый процессор вычисляет <math>c</math> элементов результирующего вектора, и число ярусов не более чем <math>cn</math>. Таким образом, предыдущие оценки сложности сохранятся.

=== Входные и выходные данные алгоритма ===
Входными данными алгоритма являются:
# размер разреженной матрицы <math> n </math>;
# вектор <math> AI </math> размерности <math> n+1 </math>;
# вектор <math> AJ </math> размерности <math> nnz </math>;
# вектор <math> A </math> размерности <math> nnz </math>;
# вектор <math> x </math> размерности <math> n </math>.

Суммарная размерность входных данных: <math> 2(nnz + n) + 1 </math>

Выходными данными является
# вектор <math> y </math> размерности <math> n </math>.

Объем выходных данных: <math> n </math>.

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

Если размерность матрицы <math>n</math>, число ненулевых элементов <math>nnz</math>, для вычисления используется <math>k</math> процессоров тогда:

*Каждый процессор оперирует с <math>\frac{n}{k}</math> строками, в каждой из которых примерно <math>\frac{nnz}{n}</math> элементов. Параллельная сложность алгоритма - <math>O(\frac{nnz}{k})</math>.

*Вычислительная мощность алгоритма (отношение числа операций к суммарному объему входных и выходных данных) - <math>O(\frac{nnz}{2nnz + 3n}) = O(1)</math> - для последовательного алгоритма; <math>O(\frac{nnz}{n} / (2\frac{nnz}{n} + n)) = O(1) </math> - для параллельного алгоритма.

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

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Переделаю, время еще есть...

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

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

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

Последовательная реализация имеется в пакете SPARSKIT [http://w3.pppl.gov/~hammett/work/2006/gmres/SPARSKIT2/BLASSM/matvec.f], Python.Scipy [https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.sparse.csr_matrix.html]

Параллельный алгоритм реализован в библиотеке Matlab [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.83.6692&rep=rep1&type=pdf], Intel MKL [https://software.intel.com/en-us/node/468536#D09FB46A-B404-44CC-94ED-1C434C41B6E1]

== Литература ==
[1] С. Писсанецки. Технология разреженных матриц. Изд. Мир, 1988.

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

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-10-28T12:56:29Z

Екатерина Буторина:

{{Assignment}}
{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nnz</math>
| pf_height = <math>O(n)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>2(nnz+n)+1</math>
| output_data = <math>n</math>
}}
Авторы статьи: [[Участница:Руфина_Третьякова|Третьякова Р. М.]] (группа 603), [[Участница:Екатерина_Буторина|Буторина Е. В.]] (группа 603)

Руфина Третьякова отвечает за программную реализацию алгоритма, Екатерина Буторина - за написание статьи.

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

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

=== Математическое описание алгоритма ===
Исходные данные: разреженная матрица <math>M^{n*n}</math>, вектор <math>x^n</math>

Наиболее удобным форматом для вычисления произведения матрицы на вектор является "Compressed Sparse Row" или сокращенно CSR-формат.

Рассмотрим CSR-представление разреженной матрицы: пусть число ненулевых элементов матрицы равно <math>nnz</math>
CSR-формат представляет матрицу <math>M</math> в виде 3-х одномерных массивов:

массив <math>A</math> размера <math>nnz</math> содержит ненулевые значения матрицы,
<math>JA</math> размера <math>nnz</math> - номера столбцов ненулевых элементов.,
<math>IA</math> размера <math>n</math>- содержит номер с которого начинается описание элементов строки в массивах <math>A</math> и <math>JA</math>.

Этот формат позволяет производить перемножение матрицы <math>M</math> на вектор <math>x</math> за <math>O(nnz)</math> умножений и сложений.
Если при умножении плотной матрицы на вектор каждый элемент результата определяется по формуле
<math>y_i = \sum_{k = 1}^{n} A_{ik} x_k</math>,
то в случае разреженной матрицы достаточно выполнять умножения только для ненулевых элементов <math>A_ik</math>, которые хранятся в массиве <math>A</math> в части соответствующей строке <math>i</math> (элементы с индексами от <math>IA_i</math> до <math>IA_{i+1}</math>). Необходимо также знать на какой элемент вектора должен быть домножен данный ненулевой элемент массива, то есть нужен столбцовый индекс каждого элемента <math>A</math>. Для этого используется массив <math>JA</math>. Таким образом, каждый элемент итогового вектора определятся формулой
:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>
Нетрудно заметить, что общее число операций умножения равно числу элементов <math>A</math>, то есть числу ненулевых элементов разреженной матрицы.

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 0 \\
2 & 0 & 0 & 1 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
представляемая в формате CSR
A = [ 2 1 3 4 ]
IA = [ 0 0 2 3 4 ]
JA = [ 0 3 2 1 ]
домножим ее на вектор
x = [ 5 6 7 8 ]
получим
y[0] = 0
y[1] = a[0]*x[0] + a[1]*x[3] = 18
y[2] = a[2]*x[2] = 21
y[3] = a[3]*x[1] = 24

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

=== Вычислительное ядро алгоритма ===
Вычислительным ядром алгоритма является формула умножения разреженной матрицы на плотный вектор:
:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>
для всех <math>i = 1,n</math>

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.
'''read CSR''' ''n'', ''IA'', ''JA'', ''A'';
'''read''' ''x''
'''for''' ''i'' = 1,n:
'''for''' ''k'' = ''IA(i)'', ''IA(i+1)-1'':
''y(i)'' += ''A(k)''*''x(JA(k))'';
'''write''' ''y'';

=== Схема реализации последовательного алгоритма ===
Метод можно описать следующим образом:
# привести матрицу <math>M</math> к формату CSR
# для <math>i</math> от <math>0</math> до <math>n-1</math> вычислить <math>y_i</math> по формуле <math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Последовательная сложность алгоритма ===
Для вычисления матрично-векторного произведения матрицы размера <math>n*n</math> и вектора размера n в последовательном варианте требуется:

* <math>nnz</math> сложений,
* <math>nnz</math> умножений.

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

Для того чтобы построить информационный граф рассмотрим процесс вычисления значения одного элемента результирующего вектора <math>y_i</math>. Число последовательных ярусов равно числу последовательных операций -- <math> AI_{i+1} - AI_i </math> (в данном случае умножение и сложение будем считать за одну операцию).
Если же вычисления всех <math>y_i</math> производить параллельно, на каждом ярусе будет производиться <math>n</math> операций.

[[Файл:1111.jpg|800x800px|center|thumb|Информационный граф алгоритма умножения разреженной матрицы на плотный вектор
(Рисунок составлен самостоятельно)]]

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

Возможность параллельной реализации алгоритма появляется благодаря независимости вычисления каждого элемента результирующего вектора <math>y_i</math>. Предположим, что имеется неограниченное число процессоров (теоретически, для максимальной эффективности требуется <math>n</math> процессоров). Каждый процессор работает с одной строкой разреженной матрицы и хранит в памяти только те части массивов
<math> AJ </math> и <math> A </math>, которые соответствуют данной строке. Вектор <math> x </math> хранится в памяти всех процессоров. Таким образом достигается экономия памяти (объем данных для i-ого процессора <math> 2(AI_{i+1} - AI_i) + n </math>). На данном процессоре выполняется
<math> AI_{i+1} - AI_i </math> последовательных операций умножения и сложения. Число ярусов для i-ого процессора равно <math> AI_{i+1} - AI_i </math>. Поскольку изначальная разреженная матрица имеет произвольную структуру, число ярусов на различных процессорах может быть различно. В худшем случае (если в строке все элементы ненулевые) число ярусов будет равно <math>n</math>.

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

* не более чем <math>n</math> ярусов умножений и сложений,
* в каждом из ярусов не более чем <math>n</math> операций.

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

''Замечание:'' если число процессоров <math>k</math> меньше числа строк, но отношение <math>\frac{n}{k} = c</math> является константой, то каждый процессор вычисляет <math>c</math> элементов результирующего вектора, и число ярусов не более чем <math>cn</math>. Таким образом, предыдущие оценки сложности сохранятся.

=== Входные и выходные данные алгоритма ===
Входными данными алгоритма являются:
# размер разреженной матрицы <math> n </math>;
# вектор <math> AI </math> размерности <math> n+1 </math>;
# вектор <math> AJ </math> размерности <math> nnz </math>;
# вектор <math> A </math> размерности <math> nnz </math>;
# вектор <math> x </math> размерности <math> n </math>.

Суммарная размерность входных данных: <math> 2(nnz + n) + 1 </math>

Выходными данными является
# вектор <math> y </math> размерности <math> n </math>.

Объем выходных данных: <math> n </math>.

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

Если размерность матрицы <math>n</math>, число ненулевых элементов <math>nnz</math>, для вычисления используется <math>k</math> процессоров тогда:

*Каждый процессор оперирует с <math>\frac{n}{k}</math> строками, в каждой из которых примерно <math>\frac{nnz}{n}</math> элементов. Параллельная сложность алгоритма - <math>O(\frac{nnz}{k})</math>.

*Вычислительная мощность алгоритма (отношение числа операций к суммарному объему входных и выходных данных) - <math>O(\frac{nnz}{2nnz + 3n}) = O(1)</math> - для последовательного алгоритма; <math>O(\frac{nnz}{n} / (2\frac{nnz}{n} + n)) = O(1) </math> - для параллельного алгоритма.

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

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

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

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

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

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

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

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

Последовательная реализация имеется в пакете SPARSKIT [http://w3.pppl.gov/~hammett/work/2006/gmres/SPARSKIT2/BLASSM/matvec.f], Python.Scipy [https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.sparse.csr_matrix.html]

Параллельный алгоритм реализован в библиотеке Matlab [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.83.6692&rep=rep1&type=pdf], Intel MKL [https://software.intel.com/en-us/node/468536#D09FB46A-B404-44CC-94ED-1C434C41B6E1]

== Литература ==
[1] С. Писсанецки. Технология разреженных матриц. Изд. Мир, 1988.

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

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-10-27T18:45:13Z

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

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nnz</math>
| pf_height = <math>O(n)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>2(nnz+n)+1</math>
| output_data = <math>n</math>
}}
Авторы статьи: [[Участница:Руфина_Третьякова|Третьякова Р. М.]] (группа 603), [[Участница:Екатерина_Буторина|Буторина Е. В.]] (группа 603)

Руфина Третьякова отвечает за программную реализацию алгоритма, Екатерина Буторина - за написание статьи.

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

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

=== Математическое описание алгоритма ===
Исходные данные: разреженная матрица <math>M^{n*n}</math>, вектор <math>x^n</math>

Наиболее удобным форматом для вычисления произведения матрицы на вектор является "Compressed Sparse Row" или сокращенно CSR-формат.

Рассмотрим CSR-представление разреженной матрицы: пусть число ненулевых элементов матрицы равно <math>nnz</math>
CSR-формат представляет матрицу <math>M</math> в виде 3-х одномерных массивов:

массив <math>A</math> размера <math>nnz</math> содержит ненулевые значения матрицы,
<math>JA</math> размера <math>nnz</math> - номера столбцов ненулевых элементов.,
<math>IA</math> размера <math>n</math>- содержит номер с которого начинается описание элементов строки в массивах <math>A</math> и <math>JA</math>.

Этот формат позволяет производить перемножение матрицы <math>M</math> на вектор <math>x</math> за <math>O(nnz)</math> умножений и сложений.
Если при умножении плотной матрицы на вектор каждый элемент результата определяется по формуле
<math>y_i = \sum_{k = 1}^{n} A_{ik} x_k</math>,
то в случае разреженной матрицы достаточно выполнять умножения только для ненулевых элементов <math>A_ik</math>, которые хранятся в массиве <math>A</math> в части соответствующей строке <math>i</math> (элементы с индексами от <math>IA_i</math> до <math>IA_{i+1}</math>). Необходимо также знать на какой элемент вектора должен быть домножен данный ненулевой элемент массива, то есть нужен столбцовый индекс каждого элемента <math>A</math>. Для этого используется массив <math>JA</math>. Таким образом, каждый элемент итогового вектора определятся формулой
:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>
Нетрудно заметить, что общее число операций умножения равно числу элементов <math>A</math>, то есть числу ненулевых элементов разреженной матрицы.

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 0 \\
2 & 0 & 0 & 1 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
представляемая в формате CSR
A = [ 2 1 3 4 ]
IA = [ 0 0 2 3 4 ]
JA = [ 0 3 2 1 ]
домножим ее на вектор
x = [ 5 6 7 8 ]
получим
y[0] = 0
y[1] = a[0]*x[0] + a[1]*x[3] = 18
y[2] = a[2]*x[2] = 21
y[3] = a[3]*x[1] = 24

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

=== Вычислительное ядро алгоритма ===
Вычислительным ядром алгоритма является формула умножения разреженной матрицы на плотный вектор:
:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>
для всех <math>i = 1,n</math>

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.
'''read CSR''' ''n'', ''IA'', ''JA'', ''A'';
'''read''' ''x''
'''for''' ''i'' = 1,n:
'''for''' ''k'' = ''IA(i)'', ''IA(i+1)-1'':
''y(i)'' += ''A(k)''*''x(JA(k))'';
'''write''' ''y'';

=== Схема реализации последовательного алгоритма ===
Метод можно описать следующим образом:
# привести матрицу <math>M</math> к формату CSR
# для <math>i</math> от <math>0</math> до <math>n-1</math> вычислить <math>y_i</math> по формуле <math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Последовательная сложность алгоритма ===
Для вычисления матрично-векторного произведения матрицы размера <math>n*n</math> и вектора размера n в последовательном варианте требуется:

* <math>nnz</math> сложений,
* <math>nnz</math> умножений.

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

Для того чтобы построить информационный граф рассмотрим процесс вычисления значения одного элемента результирующего вектора <math>y_i</math>. Число последовательных ярусов равно числу последовательных операций -- <math> AI_{i+1} - AI_i </math> (в данном случае умножение и сложение будем считать за одну операцию).
Если же вычисления всех <math>y_i</math> производить параллельно, на каждом ярусе будет производиться <math>n</math> операций.

[[Файл:1111.jpg|800x800px|center|thumb|Информационный граф алгоритма умножения разреженной матрицы на плотный вектор
(Рисунок составлен самостоятельно)]]

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

Возможность параллельной реализации алгоритма появляется благодаря независимости вычисления каждого элемента результирующего вектора <math>y_i</math>. Предположим, что имеется неограниченное число процессоров (теоретически, для максимальной эффективности требуется <math>n</math> процессоров). Каждый процессор работает с одной строкой разреженной матрицы и хранит в памяти только те части массивов
<math> AJ </math> и <math> A </math>, которые соответствуют данной строке. Вектор <math> x </math> хранится в памяти всех процессоров. Таким образом достигается экономия памяти (объем данных для i-ого процессора <math> 2(AI_{i+1} - AI_i) + n </math>). На данном процессоре выполняется
<math> AI_{i+1} - AI_i </math> последовательных операций умножения и сложения. Число ярусов для i-ого процессора равно <math> AI_{i+1} - AI_i </math>. Поскольку изначальная разреженная матрица имеет произвольную структуру, число ярусов на различных процессорах может быть различно. В худшем случае (если в строке все элементы ненулевые) число ярусов будет равно <math>n</math>.

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

* не более чем <math>n</math> ярусов умножений и сложений,
* в каждом из ярусов не более чем <math>n</math> операций.

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

''Замечание:'' если число процессоров <math>k</math> меньше числа строк, но отношение <math>\frac{n}{k} = c</math> является константой, то каждый процессор вычисляет <math>c</math> элементов результирующего вектора, и число ярусов не более чем <math>cn</math>. Таким образом, предыдущие оценки сложности сохранятся.

=== Входные и выходные данные алгоритма ===
Входными данными алгоритма являются:
# размер разреженной матрицы <math> n </math>;
# вектор <math> AI </math> размерности <math> n+1 </math>;
# вектор <math> AJ </math> размерности <math> nnz </math>;
# вектор <math> A </math> размерности <math> nnz </math>;
# вектор <math> x </math> размерности <math> n </math>.

Суммарная размерность входных данных: <math> 2(nnz + n) + 1 </math>

Выходными данными является
# вектор <math> y </math> размерности <math> n </math>.

Объем выходных данных: <math> n </math>.

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

Если размерность матрицы <math>n</math>, число ненулевых элементов <math>nnz</math>, для вычисления используется <math>k</math> процессоров тогда:

*Каждый процессор оперирует с <math>\frac{n}{k}</math> строками, в каждой из которых примерно <math>\frac{nnz}{n}</math> элементов. Параллельная сложность алгоритма - <math>O(\frac{nnz}{k})</math>.

*Вычислительная мощность алгоритма (отношение числа операций к суммарному объему входных и выходных данных) - <math>O(\frac{nnz}{2nnz + 3n}) = O(1)</math> - для последовательного алгоритма; <math>O(\frac{nnz}{n} / (2\frac{nnz}{n} + n)) = O(1) </math> - для параллельного алгоритма.

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

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

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

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

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

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

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

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

Последовательная реализация имеется в пакете SPARSKIT [http://w3.pppl.gov/~hammett/work/2006/gmres/SPARSKIT2/BLASSM/matvec.f], Python.Scipy [https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.sparse.csr_matrix.html]

Параллельный алгоритм реализован в библиотеке Matlab [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.83.6692&rep=rep1&type=pdf], Intel MKL [https://software.intel.com/en-us/node/468536#D09FB46A-B404-44CC-94ED-1C434C41B6E1]

== Литература ==
[1] С. Писсанецки. Технология разреженных матриц. Изд. Мир, 1988.

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

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-10-27T18:45:00Z

Екатерина Буторина: /* ЧАСТЬ. Свойства и структура алгоритма */

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nnz</math>
| pf_height = <math>O(n)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>2(nnz+n)+1</math>
| output_data = <math>n</math>
}}
Авторы статьи: [[Участница:Руфина_Третьякова|Третьякова Р. М.]] (группа 603), [[Участница:Екатерина_Буторина|Буторина Е. В.]] (группа 603)

Руфина Третьякова отвечает за программную реализацию алгоритма, Екатерина Буторина - за написание статьи.

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

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

=== Математическое описание алгоритма ===
Исходные данные: разреженная матрица <math>M^{n*n}</math>, вектор <math>x^n</math>

Наиболее удобным форматом для вычисления произведения матрицы на вектор является "Compressed Sparse Row" или сокращенно CSR-формат.

Рассмотрим CSR-представление разреженной матрицы: пусть число ненулевых элементов матрицы равно <math>nnz</math>
CSR-формат представляет матрицу <math>M</math> в виде 3-х одномерных массивов:

массив <math>A</math> размера <math>nnz</math> содержит ненулевые значения матрицы,
<math>JA</math> размера <math>nnz</math> - номера столбцов ненулевых элементов.,
<math>IA</math> размера <math>n</math>- содержит номер с которого начинается описание элементов строки в массивах <math>A</math> и <math>JA</math>.

Этот формат позволяет производить перемножение матрицы <math>M</math> на вектор <math>x</math> за <math>O(nnz)</math> умножений и сложений.
Если при умножении плотной матрицы на вектор каждый элемент результата определяется по формуле
<math>y_i = \sum_{k = 1}^{n} A_{ik} x_k</math>,
то в случае разреженной матрицы достаточно выполнять умножения только для ненулевых элементов <math>A_ik</math>, которые хранятся в массиве <math>A</math> в части соответствующей строке <math>i</math> (элементы с индексами от <math>IA_i</math> до <math>IA_{i+1}</math>). Необходимо также знать на какой элемент вектора должен быть домножен данный ненулевой элемент массива, то есть нужен столбцовый индекс каждого элемента <math>A</math>. Для этого используется массив <math>JA</math>. Таким образом, каждый элемент итогового вектора определятся формулой
:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>
Нетрудно заметить, что общее число операций умножения равно числу элементов <math>A</math>, то есть числу ненулевых элементов разреженной матрицы.

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 0 \\
2 & 0 & 0 & 1 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
представляемая в формате CSR
A = [ 2 1 3 4 ]
IA = [ 0 0 2 3 4 ]
JA = [ 0 3 2 1 ]
домножим ее на вектор
x = [ 5 6 7 8 ]
получим
y[0] = 0
y[1] = a[0]*x[0] + a[1]*x[3] = 18
y[2] = a[2]*x[2] = 21
y[3] = a[3]*x[1] = 24

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

=== Вычислительное ядро алгоритма ===
Вычислительным ядром алгоритма является формула умножения разреженной матрицы на плотный вектор:
:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>
для всех <math>i = 1,n</math>

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.
'''read CSR''' ''n'', ''IA'', ''JA'', ''A'';
'''read''' ''x''
'''for''' ''i'' = 1,n:
'''for''' ''k'' = ''IA(i)'', ''IA(i+1)-1'':
''y(i)'' += ''A(k)''*''x(JA(k))'';
'''write''' ''y'';

=== Схема реализации последовательного алгоритма ===
Метод можно описать следующим образом:
# привести матрицу <math>M</math> к формату CSR
# для <math>i</math> от <math>0</math> до <math>n-1</math> вычислить <math>y_i</math> по формуле <math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Последовательная сложность алгоритма ===
Для вычисления матрично-векторного произведения матрицы размера <math>n*n</math> и вектора размера n в последовательном варианте требуется:

* <math>nnz</math> сложений,
* <math>nnz</math> умножений.

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

Для того чтобы построить информационный граф рассмотрим процесс вычисления значения одного элемента результирующего вектора <math>y_i</math>. Число последовательных ярусов равно числу последовательных операций -- <math> AI_{i+1} - AI_i </math> (в данном случае умножение и сложение будем считать за одну операцию).
Если же вычисления всех <math>y_i</math> производить параллельно, на каждом ярусе будет производиться <math>n</math> операций.

[[Файл:1111.jpg|800x800px|center|thumb|Информационный граф алгоритма умножения разреженной матрицы на плотный вектор
(Рисунок составлен самостоятельно)]]

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

Возможность параллельной реализации алгоритма появляется благодаря независимости вычисления каждого элемента результирующего вектора <math>y_i</math>. Предположим, что имеется неограниченное число процессоров (теоретически, для максимальной эффективности требуется <math>n</math> процессоров). Каждый процессор работает с одной строкой разреженной матрицы и хранит в памяти только те части массивов
<math> AJ </math> и <math> A </math>, которые соответствуют данной строке. Вектор <math> x </math> хранится в памяти всех процессоров. Таким образом достигается экономия памяти (объем данных для i-ого процессора <math> 2(AI_{i+1} - AI_i) + n </math>). На данном процессоре выполняется
<math> AI_{i+1} - AI_i </math> последовательных операций умножения и сложения. Число ярусов для i-ого процессора равно <math> AI_{i+1} - AI_i </math>. Поскольку изначальная разреженная матрица имеет произвольную структуру, число ярусов на различных процессорах может быть различно. В худшем случае (если в строке все элементы ненулевые) число ярусов будет равно <math>n</math>.

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

* не более чем <math>n</math> ярусов умножений и сложений,
* в каждом из ярусов не более чем <math>n</math> операций.

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

''Замечание:'' если число процессоров <math>k</math> меньше числа строк, но отношение <math>\frac{n}{k} = c</math> является константой, то каждый процессор вычисляет <math>c</math> элементов результирующего вектора, и число ярусов не более чем <math>cn</math>. Таким образом, предыдущие оценки сложности сохранятся.

=== Входные и выходные данные алгоритма ===
Входными данными алгоритма являются:
# размер разреженной матрицы <math> n </math>;
# вектор <math> AI </math> размерности <math> n+1 </math>;
# вектор <math> AJ </math> размерности <math> nnz </math>;
# вектор <math> A </math> размерности <math> nnz </math>;
# вектор <math> x </math> размерности <math> n </math>.

Суммарная размерность входных данных: <math> 2(nnz + n) + 1 </math>

Выходными данными является
# вектор <math> y </math> размерности <math> n </math>.

Объем выходных данных: <math> n </math>.

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

Если размерность матрицы <math>n</math>, число ненулевых элементов <math>nnz</math>, для вычисления используется <math>k</math> процессоров тогда:

*Каждый процессор оперирует с <math>\frac{n}{k}</math> строками, в каждой из которых примерно <math>\frac{nnz}{n}</math> элементов. Параллельная сложность алгоритма - <math>O(\frac{nnz}{k})</math>.

*Вычислительная мощность алгоритма (отношение числа операций к суммарному объему входных и выходных данных) - <math>O(\frac{nnz}{2nnz + 3n}) = O(1)</math> - для последовательного алгоритма; <math>O(\frac{nnz}{n} / (2\frac{nnz}{n} + n)) = O(1) </math> - для параллельного алгоритма.

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

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

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

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

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

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

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

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

Последовательная реализация имеется в пакете SPARSKIT [http://w3.pppl.gov/~hammett/work/2006/gmres/SPARSKIT2/BLASSM/matvec.f], Python.Scipy [https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.sparse.csr_matrix.html]

Параллельный алгоритм реализован в библиотеке Matlab [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.83.6692&rep=rep1&type=pdf], Intel MKL [https://software.intel.com/en-us/node/468536#D09FB46A-B404-44CC-94ED-1C434C41B6E1]

== Литература ==
[1] С. Писсанецки. Технология разреженных матриц. Изд. Мир, 1988.

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

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-10-27T18:43:38Z

Екатерина Буторина:

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nnz</math>
| pf_height = <math>O(n)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>2(nnz+n)+1</math>
| output_data = <math>n</math>
}}
Авторы статьи: [[Участница:Руфина_Третьякова|Третьякова Р. М.]] (группа 603), [[Участница:Екатерина_Буторина|Буторина Е. В.]] (группа 603)

Руфина Третьякова отвечает за программную реализацию алгоритма, Екатерина Буторина - за написание статьи.

== ЧАСТЬ. Свойства и структура алгоритма ==

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

=== Математическое описание алгоритма ===
Исходные данные: разреженная матрица <math>M^{n*n}</math>, вектор <math>x^n</math>

Наиболее удобным форматом для вычисления произведения матрицы на вектор является "Compressed Sparse Row" или сокращенно CSR-формат.

Рассмотрим CSR-представление разреженной матрицы: пусть число ненулевых элементов матрицы равно <math>nnz</math>
CSR-формат представляет матрицу <math>M</math> в виде 3-х одномерных массивов:

массив <math>A</math> размера <math>nnz</math> содержит ненулевые значения матрицы,
<math>JA</math> размера <math>nnz</math> - номера столбцов ненулевых элементов.,
<math>IA</math> размера <math>n</math>- содержит номер с которого начинается описание элементов строки в массивах <math>A</math> и <math>JA</math>.

Этот формат позволяет производить перемножение матрицы <math>M</math> на вектор <math>x</math> за <math>O(nnz)</math> умножений и сложений.
Если при умножении плотной матрицы на вектор каждый элемент результата определяется по формуле
<math>y_i = \sum_{k = 1}^{n} A_{ik} x_k</math>,
то в случае разреженной матрицы достаточно выполнять умножения только для ненулевых элементов <math>A_ik</math>, которые хранятся в массиве <math>A</math> в части соответствующей строке <math>i</math> (элементы с индексами от <math>IA_i</math> до <math>IA_{i+1}</math>). Необходимо также знать на какой элемент вектора должен быть домножен данный ненулевой элемент массива, то есть нужен столбцовый индекс каждого элемента <math>A</math>. Для этого используется массив <math>JA</math>. Таким образом, каждый элемент итогового вектора определятся формулой
:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>
Нетрудно заметить, что общее число операций умножения равно числу элементов <math>A</math>, то есть числу ненулевых элементов разреженной матрицы.

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 0 \\
2 & 0 & 0 & 1 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
представляемая в формате CSR
A = [ 2 1 3 4 ]
IA = [ 0 0 2 3 4 ]
JA = [ 0 3 2 1 ]
домножим ее на вектор
x = [ 5 6 7 8 ]
получим
y[0] = 0
y[1] = a[0]*x[0] + a[1]*x[3] = 18
y[2] = a[2]*x[2] = 21
y[3] = a[3]*x[1] = 24

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

=== Вычислительное ядро алгоритма ===
Вычислительным ядром алгоритма является формула умножения разреженной матрицы на плотный вектор:
:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>
для всех <math>i = 1,n</math>

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.
'''read CSR''' ''n'', ''IA'', ''JA'', ''A'';
'''read''' ''x''
'''for''' ''i'' = 1,n:
'''for''' ''k'' = ''IA(i)'', ''IA(i+1)-1'':
''y(i)'' += ''A(k)''*''x(JA(k))'';
'''write''' ''y'';

=== Схема реализации последовательного алгоритма ===
Метод можно описать следующим образом:
# привести матрицу <math>M</math> к формату CSR
# для <math>i</math> от <math>0</math> до <math>n-1</math> вычислить <math>y_i</math> по формуле <math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Последовательная сложность алгоритма ===
Для вычисления матрично-векторного произведения матрицы размера <math>n*n</math> и вектора размера n в последовательном варианте требуется:

* <math>nnz</math> сложений,
* <math>nnz</math> умножений.

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

Для того чтобы построить информационный граф рассмотрим процесс вычисления значения одного элемента результирующего вектора <math>y_i</math>. Число последовательных ярусов равно числу последовательных операций -- <math> AI_{i+1} - AI_i </math> (в данном случае умножение и сложение будем считать за одну операцию).
Если же вычисления всех <math>y_i</math> производить параллельно, на каждом ярусе будет производиться <math>n</math> операций.

[[Файл:1111.jpg|800x800px|center|thumb|Информационный граф алгоритма умножения разреженной матрицы на плотный вектор
(Рисунок составлен самостоятельно)]]

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

Возможность параллельной реализации алгоритма появляется благодаря независимости вычисления каждого элемента результирующего вектора <math>y_i</math>. Предположим, что имеется неограниченное число процессоров (теоретически, для максимальной эффективности требуется <math>n</math> процессоров). Каждый процессор работает с одной строкой разреженной матрицы и хранит в памяти только те части массивов
<math> AJ </math> и <math> A </math>, которые соответствуют данной строке. Вектор <math> x </math> хранится в памяти всех процессоров. Таким образом достигается экономия памяти (объем данных для i-ого процессора <math> 2(AI_{i+1} - AI_i) + n </math>). На данном процессоре выполняется
<math> AI_{i+1} - AI_i </math> последовательных операций умножения и сложения. Число ярусов для i-ого процессора равно <math> AI_{i+1} - AI_i </math>. Поскольку изначальная разреженная матрица имеет произвольную структуру, число ярусов на различных процессорах может быть различно. В худшем случае (если в строке все элементы ненулевые) число ярусов будет равно <math>n</math>.

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

* не более чем <math>n</math> ярусов умножений и сложений,
* в каждом из ярусов не более чем <math>n</math> операций.

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

''Замечание:'' если число процессоров <math>k</math> меньше числа строк, но отношение <math>\frac{n}{k} = c</math> является константой, то каждый процессор вычисляет <math>c</math> элементов результирующего вектора, и число ярусов не более чем <math>cn</math>. Таким образом, предыдущие оценки сложности сохранятся.

=== Входные и выходные данные алгоритма ===
Входными данными алгоритма являются:
# размер разреженной матрицы <math> n </math>;
# вектор <math> AI </math> размерности <math> n+1 </math>;
# вектор <math> AJ </math> размерности <math> nnz </math>;
# вектор <math> A </math> размерности <math> nnz </math>;
# вектор <math> x </math> размерности <math> n </math>.

Суммарная размерность входных данных: <math> 2(nnz + n) + 1 </math>

Выходными данными является
# вектор <math> y </math> размерности <math> n </math>.

Объем выходных данных: <math> n </math>.

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

Если размерность матрицы <math>n</math>, число ненулевых элементов <math>nnz</math>, для вычисления используется <math>k</math> процессоров тогда:

*Каждый процессор оперирует с <math>\frac{n}{k}</math> строками, в каждой из которых примерно <math>\frac{nnz}{n}</math> элементов. Параллельная сложность алгоритма - <math>O(\frac{nnz}{k})</math>.

*Вычислительная мощность алгоритма (отношение числа операций к суммарному объему входных и выходных данных) - <math>O(\frac{nnz}{2nnz + 3n}) = O(1)</math> - для последовательного алгоритма; <math>O(\frac{nnz}{n} / (2\frac{nnz}{n} + n)) = O(1) </math> - для параллельного алгоритма.

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

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

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

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

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

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

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

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

Последовательная реализация имеется в пакете SPARSKIT [http://w3.pppl.gov/~hammett/work/2006/gmres/SPARSKIT2/BLASSM/matvec.f], Python.Scipy [https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.sparse.csr_matrix.html]

Параллельный алгоритм реализован в библиотеке Matlab [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.83.6692&rep=rep1&type=pdf], Intel MKL [https://software.intel.com/en-us/node/468536#D09FB46A-B404-44CC-94ED-1C434C41B6E1]

== Литература ==
[1] С. Писсанецки. Технология разреженных матриц. Изд. Мир, 1988.

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

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-10-14T20:06:22Z

Екатерина Буторина:

{{Assignment}}
{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nnz</math>
| pf_height = <math>O(n)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>2(nnz+n)+1</math>
| output_data = <math>n</math>
}}
Авторы статьи: [[Участница:Руфина_Третьякова|Третьякова Р. М.]] (группа 603), [[Участница:Екатерина_Буторина|Буторина Е. В.]] (группа 603)

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

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

=== Математическое описание алгоритма ===
Исходные данные: разреженная матрица <math>M^{n*n}</math>, вектор <math>x^n</math>

Наиболее удобным форматом для вычисления произведения матрицы на вектор является "Compressed Sparse Row" или сокращенно CSR-формат.

Рассмотрим CSR-представление разреженной матрицы: пусть число ненулевых элементов матрицы равно <math>nnz</math>
CSR-формат представляет матрицу <math>M</math> в виде 3-х одномерных массивов:

массив <math>A</math> размера <math>nnz</math> содержит ненулевые значения матрицы,
<math>JA</math> размера <math>nnz</math> - номера столбцов ненулевых элементов.,
<math>IA</math> размера <math>n</math>- содержит номер с которого начинается описание элементов строки в массивах <math>A</math> и <math>JA</math>.

Этот формат позволяет производить перемножение матрицы <math>M</math> на вектор <math>x</math> за <math>O(nnz)</math> умножений и сложений.
Если при умножении плотной матрицы на вектор каждый элемент результата определяется по формуле
<math>y_i = \sum_{k = 1}^{n} A_{ik} x_k</math>,
то в случае разреженной матрицы достаточно выполнять умножения только для ненулевых элементов <math>A_ik</math>, которые хранятся в массиве <math>A</math> в части соответствующей строке <math>i</math> (элементы с индексами от <math>IA_i</math> до <math>IA_{i+1}</math>). Необходимо также знать на какой элемент вектора должен быть домножен данный ненулевой элемент массива, то есть нужен столбцовый индекс каждого элемента <math>A</math>. Для этого используется массив <math>JA</math>. Таким образом, каждый элемент итогового вектора определятся формулой
:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>
Нетрудно заметить, что общее число операций умножения равно числу элементов <math>A</math>, то есть числу ненулевых элементов разреженной матрицы.

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 0 \\
2 & 0 & 0 & 1 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
представляемая в формате CSR
A = [ 2 1 3 4 ]
IA = [ 0 0 2 3 4 ]
JA = [ 0 3 2 1 ]
домножим ее на вектор
x = [ 5 6 7 8 ]
получим
y[0] = 0
y[1] = a[0]*x[0] + a[1]*x[3] = 18
y[2] = a[2]*x[2] = 21
y[3] = a[3]*x[1] = 24

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

=== Вычислительное ядро алгоритма ===
Вычислительным ядром алгоритма является формула умножения разреженной матрицы на плотный вектор:
:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>
для всех <math>i = 1,n</math>

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.
'''read CSR''' ''n'', ''IA'', ''JA'', ''A'';
'''read''' ''x''
'''for''' ''i'' = 1,n:
'''for''' ''k'' = ''IA(i)'', ''IA(i+1)-1'':
''y(i)'' += ''A(k)''*''x(JA(k))'';
'''write''' ''y'';

=== Схема реализации последовательного алгоритма ===
Метод можно описать следующим образом:
# привести матрицу <math>M</math> к формату CSR
# для <math>i</math> от <math>0</math> до <math>n-1</math> вычислить <math>y_i</math> по формуле <math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Последовательная сложность алгоритма ===
Для вычисления матрично-векторного произведения матрицы размера <math>n*n</math> и вектора размера n в последовательном варианте требуется:

* <math>nnz</math> сложений,
* <math>nnz</math> умножений.

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

Для того чтобы построить информационный граф рассмотрим процесс вычисления значения одного элемента результирующего вектора <math>y_i</math>. Число последовательных ярусов равно числу последовательных операций -- <math> AI_{i+1} - AI_i </math> (в данном случае умножение и сложение будем считать за одну операцию).
Если же вычисления всех <math>y_i</math> производить параллельно, на каждом ярусе будет производиться <math>n</math> операций.

[[Файл:1111.jpg|800x800px|center|thumb|Информационный граф алгоритма умножения разреженной матрицы на плотный вектор]]

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

Возможность параллельной реализации алгоритма появляется благодаря независимости вычисления каждого элемента результирующего вектора <math>y_i</math>. Предположим, что имеется неограниченное число процессоров (теоретически, для максимальной эффективности требуется <math>n</math> процессоров). Каждый процессор работает с одной строкой разреженной матрицы и хранит в памяти только те части массивов
<math> AJ </math> и <math> A </math>, которые соответствуют данной строке. Вектор <math> x </math> хранится в памяти всех процессоров. Таким образом достигается экономия памяти (объем данных для i-ого процессора <math> 2(AI_{i+1} - AI_i) + n </math>). На данном процессоре выполняется
<math> AI_{i+1} - AI_i </math> последовательных операций умножения и сложения. Число ярусов для i-ого процессора равно <math> AI_{i+1} - AI_i </math>. Поскольку изначальная разреженная матрица имеет произвольную структуру, число ярусов на различных процессорах может быть различно. В худшем случае (если в строке все элементы ненулевые) число ярусов будет равно <math>n</math>.

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

* не более чем <math>n</math> ярусов умножений и сложений,
* в каждом из ярусов не более чем <math>n</math> операций.

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

''Замечание:'' если число процессоров <math>k</math> меньше числа строк, но отношение <math>\frac{n}{k} = c</math> является константой, то каждый процессор вычисляет <math>c</math> элементов результирующего вектора, и число ярусов не более чем <math>cn</math>. Таким образом, предыдущие оценки сложности сохранятся.

=== Входные и выходные данные алгоритма ===
Входными данными алгоритма являются:
# размер разреженной матрицы <math> n </math>;
# вектор <math> AI </math> размерности <math> n+1 </math>;
# вектор <math> AJ </math> размерности <math> nnz </math>;
# вектор <math> A </math> размерности <math> nnz </math>;
# вектор <math> x </math> размерности <math> n </math>.

Суммарная размерность входных данных: <math> 2(nnz + n) + 1 </math>

Выходными данными является
# вектор <math> y </math> размерности <math> n </math>.

Объем выходных данных: <math> n </math>.

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

Если размерность матрицы <math>n</math>, число ненулевых элементов <math>nnz</math>, для вычисления используется <math>k</math> процессоров тогда:

*Каждый процессор оперирует с <math>\frac{n}{k}</math> строками, в каждой из которых примерно <math>\frac{nnz}{n}</math> элементов. Параллельная сложность алгоритма - <math>O(\frac{nnz}{k})</math>.

*Вычислительная мощность алгоритма (отношение числа операций к суммарному объему входных и выходных данных) - <math>O(\frac{nnz}{2nnz + 3n}) = O(1)</math> - для последовательного алгоритма; <math>O(\frac{nnz}{n} / (2\frac{nnz}{n} + n)) = O(1) </math> - для параллельного алгоритма.

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

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

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

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

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

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

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

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

Последовательная реализация имеется в пакете SPARSKIT [http://w3.pppl.gov/~hammett/work/2006/gmres/SPARSKIT2/BLASSM/matvec.f], Python.Scipy [https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.sparse.csr_matrix.html]

Параллельный алгоритм реализован в библиотеке Matlab [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.83.6692&rep=rep1&type=pdf], Intel MKL [https://software.intel.com/en-us/node/468536#D09FB46A-B404-44CC-94ED-1C434C41B6E1]

== Литература ==
[1] С. Писсанецки. Технология разреженных матриц. Изд. Мир, 1988.

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

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-10-13T20:43:34Z

Екатерина Буторина: /* Информационный граф */

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nnz</math>
| pf_height = <math>O(n)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>2(nnz+n)+1</math>
| output_data = <math>n</math>
}}
Авторы статьи: [[Участница:Руфина_Третьякова|Третьякова Р. М.]] (группа 603), [[Участница:Екатерина_Буторина|Буторина Е. В.]] (группа 603)

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

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

=== Математическое описание алгоритма ===
Исходные данные: разреженная матрица <math>M^{n*n}</math>, вектор <math>x^n</math>

Наиболее удобным форматом для вычисления произведения матрицы на вектор является "Compressed Sparse Row" или сокращенно CSR-формат.

Рассмотрим CSR-представление разреженной матрицы: пусть число ненулевых элементов матрицы равно <math>nnz</math>
CSR-формат представляет матрицу <math>M</math> в виде 3-х одномерных массивов:

массив <math>A</math> размера <math>nnz</math> содержит ненулевые значения матрицы,
<math>JA</math> размера <math>nnz</math> - номера столбцов ненулевых элементов.,
<math>IA</math> размера <math>n</math>- содержит номер с которого начинается описание элементов строки в массивах <math>A</math> и <math>JA</math>.

Этот формат позволяет производить перемножение матрицы <math>M</math> на вектор <math>x</math> за <math>O(nnz)</math> умножений и сложений.
Если при умножении плотной матрицы на вектор каждый элемент результата определяется по формуле
<math>y_i = \sum_{k = 1}^{n} A_{ik} x_k</math>,
то в случае разреженной матрицы достаточно выполнять умножения только для ненулевых элементов <math>A_ik</math>, которые хранятся в массиве <math>A</math> в части соответствующей строке <math>i</math> (элементы с индексами от <math>IA_i</math> до <math>IA_{i+1}</math>). Необходимо также знать на какой элемент вектора должен быть домножен данный ненулевой элемент массива, то есть нужен столбцовый индекс каждого элемента <math>A</math>. Для этого используется массив <math>JA</math>. Таким образом, каждый элемент итогового вектора определятся формулой
:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>
Нетрудно заметить, что общее число операций умножения равно числу элементов <math>A</math>, то есть числу ненулевых элементов разреженной матрицы.

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 0 \\
2 & 0 & 0 & 1 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
представляемая в формате CSR
A = [ 2 1 3 4 ]
IA = [ 0 0 2 3 4 ]
JA = [ 0 3 2 1 ]
домножим ее на вектор
x = [ 5 6 7 8 ]
получим
y[0] = 0
y[1] = a[0]*x[0] + a[1]*x[3] = 18
y[2] = a[2]*x[2] = 21
y[3] = a[3]*x[1] = 24

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

=== Вычислительное ядро алгоритма ===
Вычислительным ядром алгоритма является формула умножения разреженной матрицы на плотный вектор:
:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>
для всех <math>i = 1,n</math>

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.
'''read CSR''' ''n'', ''IA'', ''JA'', ''A'';
'''read''' ''x''
'''for''' ''i'' = 1,n:
'''for''' ''k'' = ''IA(i)'', ''IA(i+1)-1'':
''y(i)'' += ''A(k)''*''x(JA(k))'';
'''write''' ''y'';

=== Схема реализации последовательного алгоритма ===
Метод можно описать следующим образом:
# привести матрицу <math>M</math> к формату CSR
# для <math>i</math> от <math>0</math> до <math>n-1</math> вычислить <math>y_i</math> по формуле <math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Последовательная сложность алгоритма ===
Для вычисления матрично-векторного произведения матрицы размера <math>n*n</math> и вектора размера n в последовательном варианте требуется:

* <math>nnz</math> сложений,
* <math>nnz</math> умножений.

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

Для того чтобы построить информационный граф рассмотрим процесс вычисления значения одного элемента результирующего вектора <math>y_i</math>. Число последовательных ярусов равно числу последовательных операций -- <math> AI_{i+1} - AI_i </math> (в данном случае умножение и сложение будем считать за одну операцию).
Если же вычисления всех <math>y_i</math> производить параллельно, на каждом ярусе будет производиться <math>n</math> операций.

[[Файл:1111.jpg]]

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

Возможность параллельной реализации алгоритма появляется благодаря независимости вычисления каждого элемента результирующего вектора <math>y_i</math>. Предположим, что имеется неограниченное число процессоров (теоретически, для максимальной эффективности требуется <math>n</math> процессоров). Каждый процессор работает с одной строкой разреженной матрицы и хранит в памяти только те части массивов
<math> AJ </math> и <math> A </math>, которые соответствуют данной строке. Вектор <math> x </math> хранится в памяти всех процессоров. Таким образом достигается экономия памяти (объем данных для i-ого процессора <math> 2(AI_{i+1} - AI_i) + n </math>). На данном процессоре выполняется
<math> AI_{i+1} - AI_i </math> последовательных операций умножения и сложения. Число ярусов для i-ого процессора равно <math> AI_{i+1} - AI_i </math>. Поскольку изначальная разреженная матрица имеет произвольную структуру, число ярусов на различных процессорах может быть различно. В худшем случае (если в строке все элементы ненулевые) число ярусов будет равно <math>n</math>.

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

* не более чем <math>n</math> ярусов умножений и сложений,
* в каждом из ярусов не более чем <math>n</math> операций.

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

''Замечание:'' если число процессоров <math>k</math> меньше числа строк, но отношение <math>\frac{n}{k} = c</math> является константой, то каждый процессор вычисляет <math>c</math> элементов результирующего вектора, и число ярусов не более чем <math>cn</math>. Таким образом, предыдущие оценки сложности сохранятся.

=== Входные и выходные данные алгоритма ===
Входными данными алгоритма являются:
# размер разреженной матрицы <math> n </math>;
# вектор <math> AI </math> размерности <math> n+1 </math>;
# вектор <math> AJ </math> размерности <math> nnz </math>;
# вектор <math> A </math> размерности <math> nnz </math>;
# вектор <math> x </math> размерности <math> n </math>.

Суммарная размерность входных данных: <math> 2(nnz + n) + 1 </math>

Выходными данными является
# вектор <math> y </math> размерности <math> n </math>.

Объем выходных данных: <math> n </math>.

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

Если размерность матрицы <math>n</math>, число ненулевых элементов <math>nnz</math>, для вычисления используется <math>k</math> процессоров тогда:

*Каждый процессор оперирует с <math>\frac{n}{k}</math> строками, в каждой из которых примерно <math>\frac{nnz}{n}</math> элементов. Параллельная сложность алгоритма - <math>O(\frac{nnz}{k})</math>.

*Вычислительная мощность алгоритма (отношение числа операций к суммарному объему входных и выходных данных) - <math>O(\frac{nnz}{2nnz + 3n}) = O(1)</math> - для последовательного алгоритма; <math>O(\frac{nnz}{n} / (2\frac{nnz}{n} + n)) = O(1) </math> - для параллельного алгоритма.

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

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

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

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

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

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

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

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

Последовательная реализация имеется в пакете SPARSKIT [http://w3.pppl.gov/~hammett/work/2006/gmres/SPARSKIT2/BLASSM/matvec.f], Python.Scipy [https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.sparse.csr_matrix.html]

Параллельный алгоритм реализован в библиотеке Matlab [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.83.6692&rep=rep1&type=pdf], Intel MKL [https://software.intel.com/en-us/node/468536#D09FB46A-B404-44CC-94ED-1C434C41B6E1]

== Литература ==
[1] С. Писсанецки. Технология разреженных матриц. Изд. Мир, 1988.

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

Файл:1111.jpg

2016-10-13T20:42:36Z

Екатерина Буторина:

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-10-13T18:41:11Z

Екатерина Буторина:

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nnz</math>
| pf_height = <math>O(n)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>2(nnz+n)+1</math>
| output_data = <math>n</math>
}}
Авторы статьи: [[Участница:Руфина_Третьякова|Третьякова Р. М.]] (группа 603), [[Участница:Екатерина_Буторина|Буторина Е. В.]] (группа 603)

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

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

=== Математическое описание алгоритма ===
Исходные данные: разреженная матрица <math>M^{n*n}</math>, вектор <math>x^n</math>

Наиболее удобным форматом для вычисления произведения матрицы на вектор является "Compressed Sparse Row" или сокращенно CSR-формат.

Рассмотрим CSR-представление разреженной матрицы: пусть число ненулевых элементов матрицы равно <math>nnz</math>
CSR-формат представляет матрицу <math>M</math> в виде 3-х одномерных массивов:

массив <math>A</math> размера <math>nnz</math> содержит ненулевые значения матрицы,
<math>JA</math> размера <math>nnz</math> - номера столбцов ненулевых элементов.,
<math>IA</math> размера <math>n</math>- содержит номер с которого начинается описание элементов строки в массивах <math>A</math> и <math>JA</math>.

Этот формат позволяет производить перемножение матрицы <math>M</math> на вектор <math>x</math> за <math>O(nnz)</math> умножений и сложений.
Если при умножении плотной матрицы на вектор каждый элемент результата определяется по формуле
<math>y_i = \sum_{k = 1}^{n} A_{ik} x_k</math>,
то в случае разреженной матрицы достаточно выполнять умножения только для ненулевых элементов <math>A_ik</math>, которые хранятся в массиве <math>A</math> в части соответствующей строке <math>i</math> (элементы с индексами от <math>IA_i</math> до <math>IA_{i+1}</math>). Необходимо также знать на какой элемент вектора должен быть домножен данный ненулевой элемент массива, то есть нужен столбцовый индекс каждого элемента <math>A</math>. Для этого используется массив <math>JA</math>. Таким образом, каждый элемент итогового вектора определятся формулой
:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>
Нетрудно заметить, что общее число операций умножения равно числу элементов <math>A</math>, то есть числу ненулевых элементов разреженной матрицы.

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 0 \\
2 & 0 & 0 & 1 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
представляемая в формате CSR
A = [ 2 1 3 4 ]
IA = [ 0 0 2 3 4 ]
JA = [ 0 3 2 1 ]
домножим ее на вектор
x = [ 5 6 7 8 ]
получим
y[0] = 0
y[1] = a[0]*x[0] + a[1]*x[3] = 18
y[2] = a[2]*x[2] = 21
y[3] = a[3]*x[1] = 24

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

=== Вычислительное ядро алгоритма ===
Вычислительным ядром алгоритма является формула умножения разреженной матрицы на плотный вектор:
:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>
для всех <math>i = 1,n</math>

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.
'''read CSR''' ''n'', ''IA'', ''JA'', ''A'';
'''read''' ''x''
'''for''' ''i'' = 1,n:
'''for''' ''k'' = ''IA(i)'', ''IA(i+1)-1'':
''y(i)'' += ''A(k)''*''x(JA(k))'';
'''write''' ''y'';

=== Схема реализации последовательного алгоритма ===
Метод можно описать следующим образом:
# привести матрицу <math>M</math> к формату CSR
# для <math>i</math> от <math>0</math> до <math>n-1</math> вычислить <math>y_i</math> по формуле <math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Последовательная сложность алгоритма ===
Для вычисления матрично-векторного произведения матрицы размера <math>n*n</math> и вектора размера n в последовательном варианте требуется:

* <math>nnz</math> сложений,
* <math>nnz</math> умножений.

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

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

Для параллельного умножения матрицы на вектор порядка <math>n</math> требуется последовательно выполнить следующие ярусы:

=== Входные и выходные данные алгоритма ===
Входными данными алгоритма являются:
# размер разреженной матрицы <math> n </math>;
# вектор <math> AI </math> размерности <math> n+1 </math>;
# вектор <math> AJ </math> размерности <math> nnz </math>;
# вектор <math> A </math> размерности <math> nnz </math>;
# вектор <math> x </math> размерности <math> n </math>.

Суммарная размерность входных данных: <math> 2(nnz + n) + 1 </math>

Выходными данными является
# вектор <math> y </math> размерности <math> n </math>.

Объем выходных данных: <math> n </math>.

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

Если размерность матрицы <math>n</math>, число ненулевых элементов <math>nnz</math>, для вычисления используется <math>k</math> процессоров тогда:

*Каждый процессор оперирует с <math>\frac{n}{k}</math> строками, в каждой из которых примерно <math>\frac{nnz}{n}</math> элементов. Параллельная сложность алгоритма - <math>O(\frac{nnz}{k})</math>.

*Вычислительная мощность алгоритма (отношение числа операций к суммарному объему входных и выходных данных) - <math>O(\frac{nnz}{2nnz + 3n}) = O(1)</math> - для последовательного алгоритма; <math>O(\frac{nnz}{n} / (2\frac{nnz}{n} + n)) = O(1) </math> - для параллельного алгоритма.

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

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

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

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

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

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

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

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

Последовательная реализация имеется в пакете SPARSKIT [http://w3.pppl.gov/~hammett/work/2006/gmres/SPARSKIT2/BLASSM/matvec.f], Python.Scipy [https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.sparse.csr_matrix.html]

Параллельный алгоритм реализован в библиотеке Matlab [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.83.6692&rep=rep1&type=pdf], Intel MKL [https://software.intel.com/en-us/node/468536#D09FB46A-B404-44CC-94ED-1C434C41B6E1]

== Литература ==
[1] С. Писсанецки. Технология разреженных матриц. Изд. Мир, 1988.

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

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-10-13T17:00:41Z

Екатерина Буторина: /* Свойства алгоритма */

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nnz</math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math>2(nnz+n)+1</math>
| output_data = <math>n</math>
}}
Авторы статьи: [[Участница:Руфина_Третьякова|Третьякова Р. М.]] (группа 603), [[Участница:Екатерина_Буторина|Буторина Е. В.]] (группа 603)

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

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

=== Математическое описание алгоритма ===
Исходные данные: разреженная матрица <math>M^{n*n}</math>, вектор <math>x^{n*1}</math>

Наиболее удобным форматом для вычисления произведения матрицы на вектор является "Compressed Sparse Row" или сокращенно CSR-формат.

Рассмотрим CSR-представление разреженной матрицы: пусть число ненулевых элементов матрицы равно <math>nnz</math>
CSR-формат представляет матрицу <math>M</math> в виде 3-х одномерных массивов:

массив <math>A</math> размера <math>nnz</math> содержит ненулевые значения матрицы,
<math>JA</math> размера <math>nnz</math> - номера столбцов ненулевых элементов.,
<math>IA</math> размера <math>n</math>- содержит номер с которого начинается описание элементов строки в массивах <math>A</math> и <math>JA</math>.
Этот формат позволяет производить перемножение матрицы <math>M</math> на вектор <math>x</math> за <math>O(nnz)</math> умножений и сложений.

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 1 \\
2 & 0 & 0 & 0 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
представляемая в формате CSR
A = [ 1 2 3 4 ]
IA = [ 0 1 2 3 4 ]
JA = [ 3 0 2 1 ]

Вычисляемые данные: вектор <math>M*x=y</math>

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

:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.
'''read CSR''' ''n'', ''IA'', ''JA'', ''A'';
'''read''' ''x''
'''for''' ''i'' = 1,n:
'''for''' ''k'' = ''IA(i)'', ''IA(i+1)-1'':
''y(i)'' += ''A(k)''*''x(JA(k))'';
'''write''' ''y'';

=== Схема реализации последовательного алгоритма ===
Метод можно описать следующим образом:
# привести матрицу <math>M</math> к формату CSR
# для <math>i</math> от <math>0</math> до <math>n-1</math> вычислить <math>y_i</math> по формуле <math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Последовательная сложность алгоритма ===
Для вычисления матрично-векторного произведения матрицы размера <math>n*n</math> и вектора размера n в последовательном варианте требуется:

* <math>nnz</math> сложений,
* <math>nnz</math> умножений.

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

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

Для параллельного умножения матрицы на вектор порядка <math>n</math> требуется последовательно выполнить следующие ярусы:

=== Входные и выходные данные алгоритма ===
Входными данными алгоритма являются:
# размер разреженной матрицы <math> n </math>;
# вектор <math> AI </math> размерности <math> n+1 </math>;
# вектор <math> AJ </math> размерности <math> nnz </math>;
# вектор <math> A </math> размерности <math> nnz </math>;
# вектор <math> x </math> размерности <math> n </math>.

Суммарная размерность входных данных: <math> 2(nnz + n) + 1 </math>

Выходными данными является
# вектор <math> y </math> размерности <math> n </math>.

Объем выходных данных: <math> n </math>.

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

Пусть используется <math>k</math> процессоров, матрица размера <math>n*n</math>, в которой <math>nnz</math> ненулевых элементов, тогда:

*Параллельная сложность алгоритма - <math>O(nnz*\frac{k}{n})</math>

*Последовательная сложность алгоритма - <math>nnz</math>

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

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

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

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

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

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

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

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

Последовательная реализация имеется в пакете SPARSKIT [http://w3.pppl.gov/~hammett/work/2006/gmres/SPARSKIT2/BLASSM/matvec.f], Python.Scipy [https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.sparse.csr_matrix.html]

Параллельный алгоритм реализован в библиотеке Matlab [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.83.6692&rep=rep1&type=pdf], Intel MKL [https://software.intel.com/en-us/node/468536#D09FB46A-B404-44CC-94ED-1C434C41B6E1]

== Литература ==
[1] С. Писсанецки. Технология разреженных матриц. Изд. Мир, 1988.

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

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-10-13T16:58:48Z

Екатерина Буторина: /* Свойства алгоритма */

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nnz</math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math>2(nnz+n)+1</math>
| output_data = <math>n</math>
}}
Авторы статьи: [[Участница:Руфина_Третьякова|Третьякова Р. М.]] (группа 603), [[Участница:Екатерина_Буторина|Буторина Е. В.]] (группа 603)

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

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

=== Математическое описание алгоритма ===
Исходные данные: разреженная матрица <math>M^{n*n}</math>, вектор <math>x^{n*1}</math>

Наиболее удобным форматом для вычисления произведения матрицы на вектор является "Compressed Sparse Row" или сокращенно CSR-формат.

Рассмотрим CSR-представление разреженной матрицы: пусть число ненулевых элементов матрицы равно <math>nnz</math>
CSR-формат представляет матрицу <math>M</math> в виде 3-х одномерных массивов:

массив <math>A</math> размера <math>nnz</math> содержит ненулевые значения матрицы,
<math>JA</math> размера <math>nnz</math> - номера столбцов ненулевых элементов.,
<math>IA</math> размера <math>n</math>- содержит номер с которого начинается описание элементов строки в массивах <math>A</math> и <math>JA</math>.
Этот формат позволяет производить перемножение матрицы <math>M</math> на вектор <math>x</math> за <math>O(nnz)</math> умножений и сложений.

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 1 \\
2 & 0 & 0 & 0 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
представляемая в формате CSR
A = [ 1 2 3 4 ]
IA = [ 0 1 2 3 4 ]
JA = [ 3 0 2 1 ]

Вычисляемые данные: вектор <math>M*x=y</math>

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

:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.
'''read CSR''' ''n'', ''IA'', ''JA'', ''A'';
'''read''' ''x''
'''for''' ''i'' = 1,n:
'''for''' ''k'' = ''IA(i)'', ''IA(i+1)-1'':
''y(i)'' += ''A(k)''*''x(JA(k))'';
'''write''' ''y'';

=== Схема реализации последовательного алгоритма ===
Метод можно описать следующим образом:
# привести матрицу <math>M</math> к формату CSR
# для <math>i</math> от <math>0</math> до <math>n-1</math> вычислить <math>y_i</math> по формуле <math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Последовательная сложность алгоритма ===
Для вычисления матрично-векторного произведения матрицы размера <math>n*n</math> и вектора размера n в последовательном варианте требуется:

* <math>nnz</math> сложений,
* <math>nnz</math> умножений.

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

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

Для параллельного умножения матрицы на вектор порядка <math>n</math> требуется последовательно выполнить следующие ярусы:

=== Входные и выходные данные алгоритма ===
Входными данными алгоритма являются:
# размер разреженной матрицы <math> n </math>;
# вектор <math> AI </math> размерности <math> n+1 </math>;
# вектор <math> AJ </math> размерности <math> nnz </math>;
# вектор <math> A </math> размерности <math> nnz </math>;
# вектор <math> x </math> размерности <math> n </math>.

Суммарная размерность входных данных: <math> 2(nnz + n) + 1 </math>

Выходными данными является
# вектор <math> y </math> размерности <math> n </math>.

Объем выходных данных: <math> n </math>.

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

Пусть используется <math>k</math> процессоров, матрица размера <math>n*n</math>, в которой <math>nnz</math> ненулевых элементов, тогда:

*Параллельная сложность алгоритма - <math>O(nnz*k/n)</math>

*Последовательная сложность алгоритма - <math>nnz</math>

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

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

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

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

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

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

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

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

Последовательная реализация имеется в пакете SPARSKIT [http://w3.pppl.gov/~hammett/work/2006/gmres/SPARSKIT2/BLASSM/matvec.f], Python.Scipy [https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.sparse.csr_matrix.html]

Параллельный алгоритм реализован в библиотеке Matlab [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.83.6692&rep=rep1&type=pdf], Intel MKL [https://software.intel.com/en-us/node/468536#D09FB46A-B404-44CC-94ED-1C434C41B6E1]

== Литература ==
[1] С. Писсанецки. Технология разреженных матриц. Изд. Мир, 1988.

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

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-10-13T16:57:32Z

Екатерина Буторина: /* Свойства алгоритма */

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nnz</math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math>2(nnz+n)+1</math>
| output_data = <math>n</math>
}}
Авторы статьи: [[Участница:Руфина_Третьякова|Третьякова Р. М.]] (группа 603), [[Участница:Екатерина_Буторина|Буторина Е. В.]] (группа 603)

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

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

=== Математическое описание алгоритма ===
Исходные данные: разреженная матрица <math>M^{n*n}</math>, вектор <math>x^{n*1}</math>

Наиболее удобным форматом для вычисления произведения матрицы на вектор является "Compressed Sparse Row" или сокращенно CSR-формат.

Рассмотрим CSR-представление разреженной матрицы: пусть число ненулевых элементов матрицы равно <math>nnz</math>
CSR-формат представляет матрицу <math>M</math> в виде 3-х одномерных массивов:

массив <math>A</math> размера <math>nnz</math> содержит ненулевые значения матрицы,
<math>JA</math> размера <math>nnz</math> - номера столбцов ненулевых элементов.,
<math>IA</math> размера <math>n</math>- содержит номер с которого начинается описание элементов строки в массивах <math>A</math> и <math>JA</math>.
Этот формат позволяет производить перемножение матрицы <math>M</math> на вектор <math>x</math> за <math>O(nnz)</math> умножений и сложений.

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 1 \\
2 & 0 & 0 & 0 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
представляемая в формате CSR
A = [ 1 2 3 4 ]
IA = [ 0 1 2 3 4 ]
JA = [ 3 0 2 1 ]

Вычисляемые данные: вектор <math>M*x=y</math>

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

:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.
'''read CSR''' ''n'', ''IA'', ''JA'', ''A'';
'''read''' ''x''
'''for''' ''i'' = 1,n:
'''for''' ''k'' = ''IA(i)'', ''IA(i+1)-1'':
''y(i)'' += ''A(k)''*''x(JA(k))'';
'''write''' ''y'';

=== Схема реализации последовательного алгоритма ===
Метод можно описать следующим образом:
# привести матрицу <math>M</math> к формату CSR
# для <math>i</math> от <math>0</math> до <math>n-1</math> вычислить <math>y_i</math> по формуле <math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Последовательная сложность алгоритма ===
Для вычисления матрично-векторного произведения матрицы размера <math>n*n</math> и вектора размера n в последовательном варианте требуется:

* <math>nnz</math> сложений,
* <math>nnz</math> умножений.

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

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

Для параллельного умножения матрицы на вектор порядка <math>n</math> требуется последовательно выполнить следующие ярусы:

=== Входные и выходные данные алгоритма ===
Входными данными алгоритма являются:
# размер разреженной матрицы <math> n </math>;
# вектор <math> AI </math> размерности <math> n+1 </math>;
# вектор <math> AJ </math> размерности <math> nnz </math>;
# вектор <math> A </math> размерности <math> nnz </math>;
# вектор <math> x </math> размерности <math> n </math>.

Суммарная размерность входных данных: <math> 2(nnz + n) + 1 </math>

Выходными данными является
# вектор <math> y </math> размерности <math> n </math>.

Объем выходных данных: <math> n </math>.

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

Пусть используется <math>k</math> процессоров, матрица размера <math>n*n</math>, в которой <math>nnz</math> ненулевых элементов, тогда:

*Параллельная сложность <math>O(nnz*k/n)</math>

*Последовательная <math>nnz</math>

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

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

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

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

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

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

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

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

Последовательная реализация имеется в пакете SPARSKIT [http://w3.pppl.gov/~hammett/work/2006/gmres/SPARSKIT2/BLASSM/matvec.f], Python.Scipy [https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.sparse.csr_matrix.html]

Параллельный алгоритм реализован в библиотеке Matlab [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.83.6692&rep=rep1&type=pdf], Intel MKL [https://software.intel.com/en-us/node/468536#D09FB46A-B404-44CC-94ED-1C434C41B6E1]

== Литература ==
[1] С. Писсанецки. Технология разреженных матриц. Изд. Мир, 1988.

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

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-10-13T16:46:50Z

Екатерина Буторина: /* Литература */

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nnz</math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math>2(nnz+n)+1</math>
| output_data = <math>n</math>
}}
Авторы статьи: [[Участница:Руфина_Третьякова|Третьякова Р. М.]] (группа 603), [[Участница:Екатерина_Буторина|Буторина Е. В.]] (группа 603)

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

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

=== Математическое описание алгоритма ===
Исходные данные: разреженная матрица <math>M^{n*n}</math>, вектор <math>x^{n*1}</math>

Наиболее удобным форматом для вычисления произведения матрицы на вектор является "Compressed Sparse Row" или сокращенно CSR-формат.

Рассмотрим CSR-представление разреженной матрицы: пусть число ненулевых элементов матрицы равно <math>nnz</math>
CSR-формат представляет матрицу <math>M</math> в виде 3-х одномерных массивов:

массив <math>A</math> размера <math>nnz</math> содержит ненулевые значения матрицы,
<math>JA</math> размера <math>nnz</math> - номера столбцов ненулевых элементов.,
<math>IA</math> размера <math>n</math>- содержит номер с которого начинается описание элементов строки в массивах <math>A</math> и <math>JA</math>.
Этот формат позволяет производить перемножение матрицы <math>M</math> на вектор <math>x</math> за <math>O(nnz)</math> умножений и сложений.

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 1 \\
2 & 0 & 0 & 0 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
представляемая в формате CSR
A = [ 1 2 3 4 ]
IA = [ 0 1 2 3 4 ]
JA = [ 3 0 2 1 ]

Вычисляемые данные: вектор <math>M*x=y</math>

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

:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.
'''read CSR''' ''n'', ''IA'', ''JA'', ''A'';
'''read''' ''x''
'''for''' ''i'' = 1,n:
'''for''' ''k'' = ''IA(i)'', ''IA(i+1)-1'':
''y(i)'' += ''A(k)''*''x(JA(k))'';
'''write''' ''y'';

=== Схема реализации последовательного алгоритма ===
Метод можно описать следующим образом:
# привести матрицу <math>M</math> к формату CSR
# для <math>i</math> от <math>0</math> до <math>n-1</math> вычислить <math>y_i</math> по формуле <math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Последовательная сложность алгоритма ===
Для вычисления матрично-векторного произведения матрицы размера <math>n*n</math> и вектора размера n в последовательном варианте требуется:

* <math>nnz</math> сложений,
* <math>nnz</math> умножений.

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

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

Для параллельного умножения матрицы на вектор порядка <math>n</math> требуется последовательно выполнить следующие ярусы:

=== Входные и выходные данные алгоритма ===
Входными данными алгоритма являются:
# размер разреженной матрицы <math> n </math>;
# вектор <math> AI </math> размерности <math> n+1 </math>;
# вектор <math> AJ </math> размерности <math> nnz </math>;
# вектор <math> A </math> размерности <math> nnz </math>;
# вектор <math> x </math> размерности <math> n </math>.

Суммарная размерность входных данных: <math> 2(nnz + n) + 1 </math>

Выходными данными является
# вектор <math> y </math> размерности <math> n </math>.

Объем выходных данных: <math> n </math>.

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

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

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

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

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

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

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

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

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

Последовательная реализация имеется в пакете SPARSKIT [http://w3.pppl.gov/~hammett/work/2006/gmres/SPARSKIT2/BLASSM/matvec.f], Python.Scipy [https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.sparse.csr_matrix.html]

Параллельный алгоритм реализован в библиотеке Matlab [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.83.6692&rep=rep1&type=pdf], Intel MKL [https://software.intel.com/en-us/node/468536#D09FB46A-B404-44CC-94ED-1C434C41B6E1]

== Литература ==
[1] С. Писсанецки. Технология разреженных матриц. Изд. Мир, 1988.

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

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-10-13T16:44:32Z

Екатерина Буторина: /* Входные и выходные данные алгоритма */

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nnz</math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math>2(nnz+n)+1</math>
| output_data = <math>n</math>
}}
Авторы статьи: [[Участница:Руфина_Третьякова|Третьякова Р. М.]] (группа 603), [[Участница:Екатерина_Буторина|Буторина Е. В.]] (группа 603)

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

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

=== Математическое описание алгоритма ===
Исходные данные: разреженная матрица <math>M^{n*n}</math>, вектор <math>x^{n*1}</math>

Наиболее удобным форматом для вычисления произведения матрицы на вектор является "Compressed Sparse Row" или сокращенно CSR-формат.

Рассмотрим CSR-представление разреженной матрицы: пусть число ненулевых элементов матрицы равно <math>nnz</math>
CSR-формат представляет матрицу <math>M</math> в виде 3-х одномерных массивов:

массив <math>A</math> размера <math>nnz</math> содержит ненулевые значения матрицы,
<math>JA</math> размера <math>nnz</math> - номера столбцов ненулевых элементов.,
<math>IA</math> размера <math>n</math>- содержит номер с которого начинается описание элементов строки в массивах <math>A</math> и <math>JA</math>.
Этот формат позволяет производить перемножение матрицы <math>M</math> на вектор <math>x</math> за <math>O(nnz)</math> умножений и сложений.

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 1 \\
2 & 0 & 0 & 0 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
представляемая в формате CSR
A = [ 1 2 3 4 ]
IA = [ 0 1 2 3 4 ]
JA = [ 3 0 2 1 ]

Вычисляемые данные: вектор <math>M*x=y</math>

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

:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.
'''read CSR''' ''n'', ''IA'', ''JA'', ''A'';
'''read''' ''x''
'''for''' ''i'' = 1,n:
'''for''' ''k'' = ''IA(i)'', ''IA(i+1)-1'':
''y(i)'' += ''A(k)''*''x(JA(k))'';
'''write''' ''y'';

=== Схема реализации последовательного алгоритма ===
Метод можно описать следующим образом:
# привести матрицу <math>M</math> к формату CSR
# для <math>i</math> от <math>0</math> до <math>n-1</math> вычислить <math>y_i</math> по формуле <math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Последовательная сложность алгоритма ===
Для вычисления матрично-векторного произведения матрицы размера <math>n*n</math> и вектора размера n в последовательном варианте требуется:

* <math>nnz</math> сложений,
* <math>nnz</math> умножений.

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

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

Для параллельного умножения матрицы на вектор порядка <math>n</math> требуется последовательно выполнить следующие ярусы:

=== Входные и выходные данные алгоритма ===
Входными данными алгоритма являются:
# размер разреженной матрицы <math> n </math>;
# вектор <math> AI </math> размерности <math> n+1 </math>;
# вектор <math> AJ </math> размерности <math> nnz </math>;
# вектор <math> A </math> размерности <math> nnz </math>;
# вектор <math> x </math> размерности <math> n </math>.

Суммарная размерность входных данных: <math> 2(nnz + n) + 1 </math>

Выходными данными является
# вектор <math> y </math> размерности <math> n </math>.

Объем выходных данных: <math> n </math>.

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

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

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

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

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

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

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

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

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

Последовательная реализация имеется в пакете SPARSKIT [http://w3.pppl.gov/~hammett/work/2006/gmres/SPARSKIT2/BLASSM/matvec.f], Python.Scipy [https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.sparse.csr_matrix.html]

Параллельный алгоритм реализован в библиотеке Matlab [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.83.6692&rep=rep1&type=pdf], Intel MKL [https://software.intel.com/en-us/node/468536#D09FB46A-B404-44CC-94ED-1C434C41B6E1]

== Литература ==
[1] С. Писсанецки. Технология разреженных матриц. Изд. Мир, 1988.

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-10-13T11:59:59Z

Екатерина Буторина:

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nnz</math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math>2(nnz+n)+1</math>
| output_data = <math>n</math>
}}
Авторы статьи: [[Участница:Руфина_Третьякова|Третьякова Р. М.]] (группа 603), [[Участница:Екатерина_Буторина|Буторина Е. В.]] (группа 603)

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

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

=== Математическое описание алгоритма ===
Исходные данные: разреженная матрица <math>M^{n*n}</math>, вектор <math>x^{n*1}</math>

Наиболее удобным форматом для вычисления произведения матрицы на вектор является "Compressed Sparse Row" или сокращенно CSR-формат.

Рассмотрим CSR-представление разреженной матрицы: пусть число ненулевых элементов матрицы равно <math>nnz</math>
CSR-формат представляет матрицу <math>M</math> в виде 3-х одномерных массивов:

массив <math>A</math> размера <math>nnz</math> содержит ненулевые значения матрицы,
<math>JA</math> размера <math>nnz</math> - номера столбцов ненулевых элементов.,
<math>IA</math> размера <math>n</math>- содержит номер с которого начинается описание элементов строки в массивах <math>A</math> и <math>JA</math>.
Этот формат позволяет производить перемножение матрицы <math>M</math> на вектор <math>x</math> за <math>O(nnz)</math> умножений и сложений.

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 1 \\
2 & 0 & 0 & 0 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
представляемая в формате CSR
A = [ 1 2 3 4 ]
IA = [ 0 1 2 3 4 ]
JA = [ 3 0 2 1 ]

Вычисляемые данные: вектор <math>M*x=y</math>

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

:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.
'''read CSR''' ''n'', ''IA'', ''JA'', ''A'';
'''read''' ''x''
'''for''' ''i'' = 1,n:
'''for''' ''k'' = ''IA(i)'', ''IA(i+1)-1'':
''y(i)'' += ''A(k)''*''x(JA(k))'';
'''write''' ''y'';

=== Схема реализации последовательного алгоритма ===
Метод можно описать следующим образом:
# привести матрицу <math>M</math> к формату CSR
# для <math>i</math> от <math>0</math> до <math>n-1</math> вычислить <math>y_i</math> по формуле <math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Последовательная сложность алгоритма ===
Для вычисления матрично-векторного произведения матрицы размера <math>n*n</math> и вектора размера n в последовательном варианте требуется:

* <math>nnz</math> сложений,
* <math>nnz</math> умножений.

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

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

Для параллельного умножения матрицы на вектор порядка <math>n</math> требуется последовательно выполнить следующие ярусы:

=== Входные и выходные данные алгоритма ===
Входными данными алгоритма являются:
# размер разреженной матрицы <math> n </math>;
# вектор <math> AI </math> размерности <math> n+1 </math>;
# вектор <math> AJ </math> размерности <math> nnz </math>;
# вектор <math> A </math> размерности <math> nnz </math>;
# вектор <math> x </math> размерности <math> n </math>.

Суммарная размерность входных данных: <math> 2(nnz + n) + 1 </math>

Выходными данными является
# вектор <math> y </math> размерности <math> n </math>.

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

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

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

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

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

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

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

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

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

Последовательная реализация имеется в пакете SPARSKIT [http://w3.pppl.gov/~hammett/work/2006/gmres/SPARSKIT2/BLASSM/matvec.f], Python.Scipy [https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.sparse.csr_matrix.html]

Параллельный алгоритм реализован в библиотеке Matlab [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.83.6692&rep=rep1&type=pdf], Intel MKL [https://software.intel.com/en-us/node/468536#D09FB46A-B404-44CC-94ED-1C434C41B6E1]

== Литература ==
[1] С. Писсанецки. Технология разреженных матриц. Изд. Мир, 1988.

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-10-13T11:57:27Z

Екатерина Буторина: /* Ресурс параллелизма алгоритма */

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nnz</math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math>2nnz+2n+1</math>
| output_data = <math>n</math>
}}
Авторы статьи: [[Участница:Руфина_Третьякова|Третьякова Р. М.]] (группа 603), [[Участница:Екатерина_Буторина|Буторина Е. В.]] (группа 603)

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

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

=== Математическое описание алгоритма ===
Исходные данные: разреженная матрица <math>M^{n*n}</math>, вектор <math>x^{n*1}</math>

Наиболее удобным форматом для вычисления произведения матрицы на вектор является "Compressed Sparse Row" или сокращенно CSR-формат.

Рассмотрим CSR-представление разреженной матрицы: пусть число ненулевых элементов матрицы равно <math>nnz</math>
CSR-формат представляет матрицу <math>M</math> в виде 3-х одномерных массивов:

массив <math>A</math> размера <math>nnz</math> содержит ненулевые значения матрицы,
<math>JA</math> размера <math>nnz</math> - номера столбцов ненулевых элементов.,
<math>IA</math> размера <math>n</math>- содержит номер с которого начинается описание элементов строки в массивах <math>A</math> и <math>JA</math>.
Этот формат позволяет производить перемножение матрицы <math>M</math> на вектор <math>x</math> за <math>O(nnz)</math> умножений и сложений.

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 1 \\
2 & 0 & 0 & 0 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
представляемая в формате CSR
A = [ 1 2 3 4 ]
IA = [ 0 1 2 3 4 ]
JA = [ 3 0 2 1 ]

Вычисляемые данные: вектор <math>M*x=y</math>

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

:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.
'''read CSR''' ''n'', ''IA'', ''JA'', ''A'';
'''read''' ''x''
'''for''' ''i'' = 1,n:
'''for''' ''k'' = ''IA(i)'', ''IA(i+1)-1'':
''y(i)'' += ''A(k)''*''x(JA(k))'';
'''write''' ''y'';

=== Схема реализации последовательного алгоритма ===
Метод можно описать следующим образом:
# привести матрицу <math>M</math> к формату CSR
# для <math>i</math> от <math>0</math> до <math>n-1</math> вычислить <math>y_i</math> по формуле <math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Последовательная сложность алгоритма ===
Для вычисления матрично-векторного произведения матрицы размера <math>n*n</math> и вектора размера n в последовательном варианте требуется:

* <math>nnz</math> сложений,
* <math>nnz</math> умножений.

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

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

Для параллельного умножения матрицы на вектор порядка <math>n</math> требуется последовательно выполнить следующие ярусы:

=== Входные и выходные данные алгоритма ===
Входными данными алгоритма являются:
# размер разреженной матрицы <math> n </math>;
# вектор <math> AI </math> размерности <math> n+1 </math>;
# вектор <math> AJ </math> размерности <math> nnz </math>;
# вектор <math> A </math> размерности <math> nnz </math>;
# вектор <math> x </math> размерности <math> n </math>.

Суммарная размерность входных данных: <math> 2(nnz + n) + 1 </math>

Выходными данными является
# вектор <math> y </math> размерности <math> n </math>.

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

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

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

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

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

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

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

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

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

Последовательная реализация имеется в пакете SPARSKIT [http://w3.pppl.gov/~hammett/work/2006/gmres/SPARSKIT2/BLASSM/matvec.f], Python.Scipy [https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.sparse.csr_matrix.html]

Параллельный алгоритм реализован в библиотеке Matlab [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.83.6692&rep=rep1&type=pdf], Intel MKL [https://software.intel.com/en-us/node/468536#D09FB46A-B404-44CC-94ED-1C434C41B6E1]

== Литература ==
[1] С. Писсанецки. Технология разреженных матриц. Изд. Мир, 1988.

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-10-13T11:54:54Z

Екатерина Буторина: /* Входные и выходные данные алгоритма */

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nnz</math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math>2nnz+2n+1</math>
| output_data = <math>n</math>
}}
Авторы статьи: [[Участница:Руфина_Третьякова|Третьякова Р. М.]] (группа 603), [[Участница:Екатерина_Буторина|Буторина Е. В.]] (группа 603)

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

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

=== Математическое описание алгоритма ===
Исходные данные: разреженная матрица <math>M^{n*n}</math>, вектор <math>x^{n*1}</math>

Наиболее удобным форматом для вычисления произведения матрицы на вектор является "Compressed Sparse Row" или сокращенно CSR-формат.

Рассмотрим CSR-представление разреженной матрицы: пусть число ненулевых элементов матрицы равно <math>nnz</math>
CSR-формат представляет матрицу <math>M</math> в виде 3-х одномерных массивов:

массив <math>A</math> размера <math>nnz</math> содержит ненулевые значения матрицы,
<math>JA</math> размера <math>nnz</math> - номера столбцов ненулевых элементов.,
<math>IA</math> размера <math>n</math>- содержит номер с которого начинается описание элементов строки в массивах <math>A</math> и <math>JA</math>.
Этот формат позволяет производить перемножение матрицы <math>M</math> на вектор <math>x</math> за <math>O(nnz)</math> умножений и сложений.

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 1 \\
2 & 0 & 0 & 0 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
представляемая в формате CSR
A = [ 1 2 3 4 ]
IA = [ 0 1 2 3 4 ]
JA = [ 3 0 2 1 ]

Вычисляемые данные: вектор <math>M*x=y</math>

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

:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.
'''read CSR''' ''n'', ''IA'', ''JA'', ''A'';
'''read''' ''x''
'''for''' ''i'' = 1,n:
'''for''' ''k'' = ''IA(i)'', ''IA(i+1)-1'':
''y(i)'' += ''A(k)''*''x(JA(k))'';
'''write''' ''y'';

=== Схема реализации последовательного алгоритма ===
Метод можно описать следующим образом:
# привести матрицу <math>M</math> к формату CSR
# для <math>i</math> от <math>0</math> до <math>n-1</math> вычислить <math>y_i</math> по формуле <math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Последовательная сложность алгоритма ===
Для вычисления матрично-векторного произведения матрицы размера <math>n*n</math> и вектора размера n в последовательном варианте требуется:

* <math>nnz</math> сложений,
* <math>nnz</math> умножений.

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

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

=== Входные и выходные данные алгоритма ===
Входными данными алгоритма являются:
# размер разреженной матрицы <math> n </math>;
# вектор <math> AI </math> размерности <math> n+1 </math>;
# вектор <math> AJ </math> размерности <math> nnz </math>;
# вектор <math> A </math> размерности <math> nnz </math>;
# вектор <math> x </math> размерности <math> n </math>.

Суммарная размер входных данных: <math> 2(nnz + n) + 1 </math>

Выходными данными является
# вектор <math> y </math> размерности <math> n </math>.

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

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

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

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

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

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

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

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

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

Последовательная реализация имеется в пакете SPARSKIT [http://w3.pppl.gov/~hammett/work/2006/gmres/SPARSKIT2/BLASSM/matvec.f], Python.Scipy [https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.sparse.csr_matrix.html]

Параллельный алгоритм реализован в библиотеке Matlab [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.83.6692&rep=rep1&type=pdf], Intel MKL [https://software.intel.com/en-us/node/468536#D09FB46A-B404-44CC-94ED-1C434C41B6E1]

== Литература ==
[1] С. Писсанецки. Технология разреженных матриц. Изд. Мир, 1988.

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-10-13T11:42:48Z

Екатерина Буторина: /* Существующие реализации алгоритма */

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nnz</math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math>2nnz+2n+1</math>
| output_data = <math>n</math>
}}
Авторы статьи: [[Участница:Руфина_Третьякова|Третьякова Р. М.]] (группа 603), [[Участница:Екатерина_Буторина|Буторина Е. В.]] (группа 603)

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

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

=== Математическое описание алгоритма ===
Исходные данные: разреженная матрица <math>M^{n*n}</math>, вектор <math>x^{n*1}</math>

Наиболее удобным форматом для вычисления произведения матрицы на вектор является "Compressed Sparse Row" или сокращенно CSR-формат.

Рассмотрим CSR-представление разреженной матрицы: пусть число ненулевых элементов матрицы равно <math>nnz</math>
CSR-формат представляет матрицу <math>M</math> в виде 3-х одномерных массивов:

массив <math>A</math> размера <math>nnz</math> содержит ненулевые значения матрицы,
<math>JA</math> размера <math>nnz</math> - номера столбцов ненулевых элементов.,
<math>IA</math> размера <math>n</math>- содержит номер с которого начинается описание элементов строки в массивах <math>A</math> и <math>JA</math>.
Этот формат позволяет производить перемножение матрицы <math>M</math> на вектор <math>x</math> за <math>O(nnz)</math> умножений и сложений.

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 1 \\
2 & 0 & 0 & 0 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
представляемая в формате CSR
A = [ 1 2 3 4 ]
IA = [ 0 1 2 3 4 ]
JA = [ 3 0 2 1 ]

Вычисляемые данные: вектор <math>M*x=y</math>

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

:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.
'''read CSR''' ''n'', ''IA'', ''JA'', ''A'';
'''read''' ''x''
'''for''' ''i'' = 1,n:
'''for''' ''k'' = ''IA(i)'', ''IA(i+1)-1'':
''y(i)'' += ''A(k)''*''x(JA(k))'';
'''write''' ''y'';

=== Схема реализации последовательного алгоритма ===
Метод можно описать следующим образом:
# привести матрицу <math>M</math> к формату CSR
# для <math>i</math> от <math>0</math> до <math>n-1</math> вычислить <math>y_i</math> по формуле <math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Последовательная сложность алгоритма ===
Для вычисления матрично-векторного произведения матрицы размера <math>n*n</math> и вектора размера n в последовательном варианте требуется:

* <math>nnz</math> сложений,
* <math>nnz</math> умножений.

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

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

=== Входные и выходные данные алгоритма ===
'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.

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

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

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

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

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

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

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

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

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

Последовательная реализация имеется в пакете SPARSKIT [http://w3.pppl.gov/~hammett/work/2006/gmres/SPARSKIT2/BLASSM/matvec.f], Python.Scipy [https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.sparse.csr_matrix.html]

Параллельный алгоритм реализован в библиотеке Matlab [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.83.6692&rep=rep1&type=pdf], Intel MKL [https://software.intel.com/en-us/node/468536#D09FB46A-B404-44CC-94ED-1C434C41B6E1]

== Литература ==
[1] С. Писсанецки. Технология разреженных матриц. Изд. Мир, 1988.

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-10-13T11:41:52Z

Екатерина Буторина: /* Существующие реализации алгоритма */

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nnz</math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math>2nnz+2n+1</math>
| output_data = <math>n</math>
}}
Авторы статьи: [[Участница:Руфина_Третьякова|Третьякова Р. М.]] (группа 603), [[Участница:Екатерина_Буторина|Буторина Е. В.]] (группа 603)

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

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

=== Математическое описание алгоритма ===
Исходные данные: разреженная матрица <math>M^{n*n}</math>, вектор <math>x^{n*1}</math>

Наиболее удобным форматом для вычисления произведения матрицы на вектор является "Compressed Sparse Row" или сокращенно CSR-формат.

Рассмотрим CSR-представление разреженной матрицы: пусть число ненулевых элементов матрицы равно <math>nnz</math>
CSR-формат представляет матрицу <math>M</math> в виде 3-х одномерных массивов:

массив <math>A</math> размера <math>nnz</math> содержит ненулевые значения матрицы,
<math>JA</math> размера <math>nnz</math> - номера столбцов ненулевых элементов.,
<math>IA</math> размера <math>n</math>- содержит номер с которого начинается описание элементов строки в массивах <math>A</math> и <math>JA</math>.
Этот формат позволяет производить перемножение матрицы <math>M</math> на вектор <math>x</math> за <math>O(nnz)</math> умножений и сложений.

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 1 \\
2 & 0 & 0 & 0 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
представляемая в формате CSR
A = [ 1 2 3 4 ]
IA = [ 0 1 2 3 4 ]
JA = [ 3 0 2 1 ]

Вычисляемые данные: вектор <math>M*x=y</math>

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

:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.
'''read CSR''' ''n'', ''IA'', ''JA'', ''A'';
'''read''' ''x''
'''for''' ''i'' = 1,n:
'''for''' ''k'' = ''IA(i)'', ''IA(i+1)-1'':
''y(i)'' += ''A(k)''*''x(JA(k))'';
'''write''' ''y'';

=== Схема реализации последовательного алгоритма ===
Метод можно описать следующим образом:
# привести матрицу <math>M</math> к формату CSR
# для <math>i</math> от <math>0</math> до <math>n-1</math> вычислить <math>y_i</math> по формуле <math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Последовательная сложность алгоритма ===
Для вычисления матрично-векторного произведения матрицы размера <math>n*n</math> и вектора размера n в последовательном варианте требуется:

* <math>nnz</math> сложений,
* <math>nnz</math> умножений.

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

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

=== Входные и выходные данные алгоритма ===
'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.

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

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

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

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

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

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

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

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

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

Последовательная реализация имеется в пакете SPARSKIT [http://w3.pppl.gov/~hammett/work/2006/gmres/SPARSKIT2/BLASSM/matvec.f], Python.Scipy

Параллельный алгоритм реализован в библиотеке Matlab [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.83.6692&rep=rep1&type=pdf], Intel MKL [https://software.intel.com/en-us/node/468536#D09FB46A-B404-44CC-94ED-1C434C41B6E1]

== Литература ==
[1] С. Писсанецки. Технология разреженных матриц. Изд. Мир, 1988.

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-10-13T11:40:42Z

Екатерина Буторина: /* Существующие реализации алгоритма */

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nnz</math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math>2nnz+2n+1</math>
| output_data = <math>n</math>
}}
Авторы статьи: [[Участница:Руфина_Третьякова|Третьякова Р. М.]] (группа 603), [[Участница:Екатерина_Буторина|Буторина Е. В.]] (группа 603)

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

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

=== Математическое описание алгоритма ===
Исходные данные: разреженная матрица <math>M^{n*n}</math>, вектор <math>x^{n*1}</math>

Наиболее удобным форматом для вычисления произведения матрицы на вектор является "Compressed Sparse Row" или сокращенно CSR-формат.

Рассмотрим CSR-представление разреженной матрицы: пусть число ненулевых элементов матрицы равно <math>nnz</math>
CSR-формат представляет матрицу <math>M</math> в виде 3-х одномерных массивов:

массив <math>A</math> размера <math>nnz</math> содержит ненулевые значения матрицы,
<math>JA</math> размера <math>nnz</math> - номера столбцов ненулевых элементов.,
<math>IA</math> размера <math>n</math>- содержит номер с которого начинается описание элементов строки в массивах <math>A</math> и <math>JA</math>.
Этот формат позволяет производить перемножение матрицы <math>M</math> на вектор <math>x</math> за <math>O(nnz)</math> умножений и сложений.

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 1 \\
2 & 0 & 0 & 0 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
представляемая в формате CSR
A = [ 1 2 3 4 ]
IA = [ 0 1 2 3 4 ]
JA = [ 3 0 2 1 ]

Вычисляемые данные: вектор <math>M*x=y</math>

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

:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.
'''read CSR''' ''n'', ''IA'', ''JA'', ''A'';
'''read''' ''x''
'''for''' ''i'' = 1,n:
'''for''' ''k'' = ''IA(i)'', ''IA(i+1)-1'':
''y(i)'' += ''A(k)''*''x(JA(k))'';
'''write''' ''y'';

=== Схема реализации последовательного алгоритма ===
Метод можно описать следующим образом:
# привести матрицу <math>M</math> к формату CSR
# для <math>i</math> от <math>0</math> до <math>n-1</math> вычислить <math>y_i</math> по формуле <math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Последовательная сложность алгоритма ===
Для вычисления матрично-векторного произведения матрицы размера <math>n*n</math> и вектора размера n в последовательном варианте требуется:

* <math>nnz</math> сложений,
* <math>nnz</math> умножений.

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

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

=== Входные и выходные данные алгоритма ===
'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.

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

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

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

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

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

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

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

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

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

Последовательная реализация имеется в пакете SPARSKIT, Python.Scipy

Параллельный алгоритм реализован в библиотеке Matlab [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.83.6692&rep=rep1&type=pdf], Intel MKL [https://software.intel.com/en-us/node/468536#D09FB46A-B404-44CC-94ED-1C434C41B6E1]

== Литература ==
[1] С. Писсанецки. Технология разреженных матриц. Изд. Мир, 1988.

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-10-13T11:40:05Z

Екатерина Буторина: /* Существующие реализации алгоритма */

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nnz</math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math>2nnz+2n+1</math>
| output_data = <math>n</math>
}}
Авторы статьи: [[Участница:Руфина_Третьякова|Третьякова Р. М.]] (группа 603), [[Участница:Екатерина_Буторина|Буторина Е. В.]] (группа 603)

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

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

=== Математическое описание алгоритма ===
Исходные данные: разреженная матрица <math>M^{n*n}</math>, вектор <math>x^{n*1}</math>

Наиболее удобным форматом для вычисления произведения матрицы на вектор является "Compressed Sparse Row" или сокращенно CSR-формат.

Рассмотрим CSR-представление разреженной матрицы: пусть число ненулевых элементов матрицы равно <math>nnz</math>
CSR-формат представляет матрицу <math>M</math> в виде 3-х одномерных массивов:

массив <math>A</math> размера <math>nnz</math> содержит ненулевые значения матрицы,
<math>JA</math> размера <math>nnz</math> - номера столбцов ненулевых элементов.,
<math>IA</math> размера <math>n</math>- содержит номер с которого начинается описание элементов строки в массивах <math>A</math> и <math>JA</math>.
Этот формат позволяет производить перемножение матрицы <math>M</math> на вектор <math>x</math> за <math>O(nnz)</math> умножений и сложений.

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 1 \\
2 & 0 & 0 & 0 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
представляемая в формате CSR
A = [ 1 2 3 4 ]
IA = [ 0 1 2 3 4 ]
JA = [ 3 0 2 1 ]

Вычисляемые данные: вектор <math>M*x=y</math>

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

:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.
'''read CSR''' ''n'', ''IA'', ''JA'', ''A'';
'''read''' ''x''
'''for''' ''i'' = 1,n:
'''for''' ''k'' = ''IA(i)'', ''IA(i+1)-1'':
''y(i)'' += ''A(k)''*''x(JA(k))'';
'''write''' ''y'';

=== Схема реализации последовательного алгоритма ===
Метод можно описать следующим образом:
# привести матрицу <math>M</math> к формату CSR
# для <math>i</math> от <math>0</math> до <math>n-1</math> вычислить <math>y_i</math> по формуле <math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Последовательная сложность алгоритма ===
Для вычисления матрично-векторного произведения матрицы размера <math>n*n</math> и вектора размера n в последовательном варианте требуется:

* <math>nnz</math> сложений,
* <math>nnz</math> умножений.

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

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

=== Входные и выходные данные алгоритма ===
'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.

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

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

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

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

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

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

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

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

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

Последовательная реализация имеется в пакете SPARSKIT, Python.Scipy

Параллельный алгоритм реализован в библиотеке Matlab, Intel MKL [https://software.intel.com/en-us/node/468536#D09FB46A-B404-44CC-94ED-1C434C41B6E1]

== Литература ==
[1] С. Писсанецки. Технология разреженных матриц. Изд. Мир, 1988.

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-10-13T11:37:12Z

Екатерина Буторина: /* Существующие реализации алгоритма */

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nnz</math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math>2nnz+2n+1</math>
| output_data = <math>n</math>
}}
Авторы статьи: [[Участница:Руфина_Третьякова|Третьякова Р. М.]] (группа 603), [[Участница:Екатерина_Буторина|Буторина Е. В.]] (группа 603)

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

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

=== Математическое описание алгоритма ===
Исходные данные: разреженная матрица <math>M^{n*n}</math>, вектор <math>x^{n*1}</math>

Наиболее удобным форматом для вычисления произведения матрицы на вектор является "Compressed Sparse Row" или сокращенно CSR-формат.

Рассмотрим CSR-представление разреженной матрицы: пусть число ненулевых элементов матрицы равно <math>nnz</math>
CSR-формат представляет матрицу <math>M</math> в виде 3-х одномерных массивов:

массив <math>A</math> размера <math>nnz</math> содержит ненулевые значения матрицы,
<math>JA</math> размера <math>nnz</math> - номера столбцов ненулевых элементов.,
<math>IA</math> размера <math>n</math>- содержит номер с которого начинается описание элементов строки в массивах <math>A</math> и <math>JA</math>.
Этот формат позволяет производить перемножение матрицы <math>M</math> на вектор <math>x</math> за <math>O(nnz)</math> умножений и сложений.

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 1 \\
2 & 0 & 0 & 0 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
представляемая в формате CSR
A = [ 1 2 3 4 ]
IA = [ 0 1 2 3 4 ]
JA = [ 3 0 2 1 ]

Вычисляемые данные: вектор <math>M*x=y</math>

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

:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.
'''read CSR''' ''n'', ''IA'', ''JA'', ''A'';
'''read''' ''x''
'''for''' ''i'' = 1,n:
'''for''' ''k'' = ''IA(i)'', ''IA(i+1)-1'':
''y(i)'' += ''A(k)''*''x(JA(k))'';
'''write''' ''y'';

=== Схема реализации последовательного алгоритма ===
Метод можно описать следующим образом:
# привести матрицу <math>M</math> к формату CSR
# для <math>i</math> от <math>0</math> до <math>n-1</math> вычислить <math>y_i</math> по формуле <math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Последовательная сложность алгоритма ===
Для вычисления матрично-векторного произведения матрицы размера <math>n*n</math> и вектора размера n в последовательном варианте требуется:

* <math>nnz</math> сложений,
* <math>nnz</math> умножений.

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

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

=== Входные и выходные данные алгоритма ===
'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.

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

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

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

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

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

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

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

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

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

Последовательная реализация имеется в пакете SPARSKIT, Python.Scipy, Intel MKL

Параллельный алгоритм реализован в библиотеке Matlab, ScaLapack

== Литература ==
[1] С. Писсанецки. Технология разреженных матриц. Изд. Мир, 1988.

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-10-13T11:33:46Z

Екатерина Буторина: /* Существующие реализации алгоритма */

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nnz</math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math>2nnz+2n+1</math>
| output_data = <math>n</math>
}}
Авторы статьи: [[Участница:Руфина_Третьякова|Третьякова Р. М.]] (группа 603), [[Участница:Екатерина_Буторина|Буторина Е. В.]] (группа 603)

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

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

=== Математическое описание алгоритма ===
Исходные данные: разреженная матрица <math>M^{n*n}</math>, вектор <math>x^{n*1}</math>

Наиболее удобным форматом для вычисления произведения матрицы на вектор является "Compressed Sparse Row" или сокращенно CSR-формат.

Рассмотрим CSR-представление разреженной матрицы: пусть число ненулевых элементов матрицы равно <math>nnz</math>
CSR-формат представляет матрицу <math>M</math> в виде 3-х одномерных массивов:

массив <math>A</math> размера <math>nnz</math> содержит ненулевые значения матрицы,
<math>JA</math> размера <math>nnz</math> - номера столбцов ненулевых элементов.,
<math>IA</math> размера <math>n</math>- содержит номер с которого начинается описание элементов строки в массивах <math>A</math> и <math>JA</math>.
Этот формат позволяет производить перемножение матрицы <math>M</math> на вектор <math>x</math> за <math>O(nnz)</math> умножений и сложений.

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 1 \\
2 & 0 & 0 & 0 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
представляемая в формате CSR
A = [ 1 2 3 4 ]
IA = [ 0 1 2 3 4 ]
JA = [ 3 0 2 1 ]

Вычисляемые данные: вектор <math>M*x=y</math>

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

:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.
'''read CSR''' ''n'', ''IA'', ''JA'', ''A'';
'''read''' ''x''
'''for''' ''i'' = 1,n:
'''for''' ''k'' = ''IA(i)'', ''IA(i+1)-1'':
''y(i)'' += ''A(k)''*''x(JA(k))'';
'''write''' ''y'';

=== Схема реализации последовательного алгоритма ===
Метод можно описать следующим образом:
# привести матрицу <math>M</math> к формату CSR
# для <math>i</math> от <math>0</math> до <math>n-1</math> вычислить <math>y_i</math> по формуле <math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Последовательная сложность алгоритма ===
Для вычисления матрично-векторного произведения матрицы размера <math>n*n</math> и вектора размера n в последовательном варианте требуется:

* <math>nnz</math> сложений,
* <math>nnz</math> умножений.

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

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

=== Входные и выходные данные алгоритма ===
'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.

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

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

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

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

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

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

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

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

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

Последовательная реализация имеется в пакете SPARSKIT, Python.Scipy

Параллельный алгоритм реализован в библиотеке Matlab, ScaLapack

== Литература ==
[1] С. Писсанецки. Технология разреженных матриц. Изд. Мир, 1988.

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-10-13T11:33:11Z

Екатерина Буторина: /* Существующие реализации алгоритма */

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nnz</math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math>2nnz+2n+1</math>
| output_data = <math>n</math>
}}
Авторы статьи: [[Участница:Руфина_Третьякова|Третьякова Р. М.]] (группа 603), [[Участница:Екатерина_Буторина|Буторина Е. В.]] (группа 603)

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

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

=== Математическое описание алгоритма ===
Исходные данные: разреженная матрица <math>M^{n*n}</math>, вектор <math>x^{n*1}</math>

Наиболее удобным форматом для вычисления произведения матрицы на вектор является "Compressed Sparse Row" или сокращенно CSR-формат.

Рассмотрим CSR-представление разреженной матрицы: пусть число ненулевых элементов матрицы равно <math>nnz</math>
CSR-формат представляет матрицу <math>M</math> в виде 3-х одномерных массивов:

массив <math>A</math> размера <math>nnz</math> содержит ненулевые значения матрицы,
<math>JA</math> размера <math>nnz</math> - номера столбцов ненулевых элементов.,
<math>IA</math> размера <math>n</math>- содержит номер с которого начинается описание элементов строки в массивах <math>A</math> и <math>JA</math>.
Этот формат позволяет производить перемножение матрицы <math>M</math> на вектор <math>x</math> за <math>O(nnz)</math> умножений и сложений.

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 1 \\
2 & 0 & 0 & 0 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
представляемая в формате CSR
A = [ 1 2 3 4 ]
IA = [ 0 1 2 3 4 ]
JA = [ 3 0 2 1 ]

Вычисляемые данные: вектор <math>M*x=y</math>

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

:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.
'''read CSR''' ''n'', ''IA'', ''JA'', ''A'';
'''read''' ''x''
'''for''' ''i'' = 1,n:
'''for''' ''k'' = ''IA(i)'', ''IA(i+1)-1'':
''y(i)'' += ''A(k)''*''x(JA(k))'';
'''write''' ''y'';

=== Схема реализации последовательного алгоритма ===
Метод можно описать следующим образом:
# привести матрицу <math>M</math> к формату CSR
# для <math>i</math> от <math>0</math> до <math>n-1</math> вычислить <math>y_i</math> по формуле <math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Последовательная сложность алгоритма ===
Для вычисления матрично-векторного произведения матрицы размера <math>n*n</math> и вектора размера n в последовательном варианте требуется:

* <math>nnz</math> сложений,
* <math>nnz</math> умножений.

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

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

=== Входные и выходные данные алгоритма ===
'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.

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

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

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

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

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

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

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

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

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

Последовательная реализация имеется в пакете SPARSKIT, Python.Scipy

Параллельный алгоритм реализован в библиотеке Matlab

== Литература ==
[1] С. Писсанецки. Технология разреженных матриц. Изд. Мир, 1988.

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-10-13T11:33:03Z

Екатерина Буторина: /* Существующие реализации алгоритма */

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nnz</math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math>2nnz+2n+1</math>
| output_data = <math>n</math>
}}
Авторы статьи: [[Участница:Руфина_Третьякова|Третьякова Р. М.]] (группа 603), [[Участница:Екатерина_Буторина|Буторина Е. В.]] (группа 603)

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

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

=== Математическое описание алгоритма ===
Исходные данные: разреженная матрица <math>M^{n*n}</math>, вектор <math>x^{n*1}</math>

Наиболее удобным форматом для вычисления произведения матрицы на вектор является "Compressed Sparse Row" или сокращенно CSR-формат.

Рассмотрим CSR-представление разреженной матрицы: пусть число ненулевых элементов матрицы равно <math>nnz</math>
CSR-формат представляет матрицу <math>M</math> в виде 3-х одномерных массивов:

массив <math>A</math> размера <math>nnz</math> содержит ненулевые значения матрицы,
<math>JA</math> размера <math>nnz</math> - номера столбцов ненулевых элементов.,
<math>IA</math> размера <math>n</math>- содержит номер с которого начинается описание элементов строки в массивах <math>A</math> и <math>JA</math>.
Этот формат позволяет производить перемножение матрицы <math>M</math> на вектор <math>x</math> за <math>O(nnz)</math> умножений и сложений.

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 1 \\
2 & 0 & 0 & 0 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
представляемая в формате CSR
A = [ 1 2 3 4 ]
IA = [ 0 1 2 3 4 ]
JA = [ 3 0 2 1 ]

Вычисляемые данные: вектор <math>M*x=y</math>

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

:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.
'''read CSR''' ''n'', ''IA'', ''JA'', ''A'';
'''read''' ''x''
'''for''' ''i'' = 1,n:
'''for''' ''k'' = ''IA(i)'', ''IA(i+1)-1'':
''y(i)'' += ''A(k)''*''x(JA(k))'';
'''write''' ''y'';

=== Схема реализации последовательного алгоритма ===
Метод можно описать следующим образом:
# привести матрицу <math>M</math> к формату CSR
# для <math>i</math> от <math>0</math> до <math>n-1</math> вычислить <math>y_i</math> по формуле <math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Последовательная сложность алгоритма ===
Для вычисления матрично-векторного произведения матрицы размера <math>n*n</math> и вектора размера n в последовательном варианте требуется:

* <math>nnz</math> сложений,
* <math>nnz</math> умножений.

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

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

=== Входные и выходные данные алгоритма ===
'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.

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

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

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

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

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

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

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

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

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

Последовательная реализация имеется в пакете SPARSKIT, Python.Scipy
Параллельный алгоритм реализован в библиотеке Matlab

== Литература ==
[1] С. Писсанецки. Технология разреженных матриц. Изд. Мир, 1988.

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-10-13T11:31:19Z

Екатерина Буторина: /* Существующие реализации алгоритма */

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nnz</math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math>2nnz+2n+1</math>
| output_data = <math>n</math>
}}
Авторы статьи: [[Участница:Руфина_Третьякова|Третьякова Р. М.]] (группа 603), [[Участница:Екатерина_Буторина|Буторина Е. В.]] (группа 603)

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

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

=== Математическое описание алгоритма ===
Исходные данные: разреженная матрица <math>M^{n*n}</math>, вектор <math>x^{n*1}</math>

Наиболее удобным форматом для вычисления произведения матрицы на вектор является "Compressed Sparse Row" или сокращенно CSR-формат.

Рассмотрим CSR-представление разреженной матрицы: пусть число ненулевых элементов матрицы равно <math>nnz</math>
CSR-формат представляет матрицу <math>M</math> в виде 3-х одномерных массивов:

массив <math>A</math> размера <math>nnz</math> содержит ненулевые значения матрицы,
<math>JA</math> размера <math>nnz</math> - номера столбцов ненулевых элементов.,
<math>IA</math> размера <math>n</math>- содержит номер с которого начинается описание элементов строки в массивах <math>A</math> и <math>JA</math>.
Этот формат позволяет производить перемножение матрицы <math>M</math> на вектор <math>x</math> за <math>O(nnz)</math> умножений и сложений.

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 1 \\
2 & 0 & 0 & 0 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
представляемая в формате CSR
A = [ 1 2 3 4 ]
IA = [ 0 1 2 3 4 ]
JA = [ 3 0 2 1 ]

Вычисляемые данные: вектор <math>M*x=y</math>

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

:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.
'''read CSR''' ''n'', ''IA'', ''JA'', ''A'';
'''read''' ''x''
'''for''' ''i'' = 1,n:
'''for''' ''k'' = ''IA(i)'', ''IA(i+1)-1'':
''y(i)'' += ''A(k)''*''x(JA(k))'';
'''write''' ''y'';

=== Схема реализации последовательного алгоритма ===
Метод можно описать следующим образом:
# привести матрицу <math>M</math> к формату CSR
# для <math>i</math> от <math>0</math> до <math>n-1</math> вычислить <math>y_i</math> по формуле <math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Последовательная сложность алгоритма ===
Для вычисления матрично-векторного произведения матрицы размера <math>n*n</math> и вектора размера n в последовательном варианте требуется:

* <math>nnz</math> сложений,
* <math>nnz</math> умножений.

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

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

=== Входные и выходные данные алгоритма ===
'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.

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

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

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

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

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

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

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

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

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

Последовательная реализация имеется в пакете SPARSKIT, Matlab, Python.Scipy

== Литература ==
[1] С. Писсанецки. Технология разреженных матриц. Изд. Мир, 1988.

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-10-13T11:25:59Z

Екатерина Буторина: /* Существующие реализации алгоритма */

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nnz</math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math>2nnz+2n+1</math>
| output_data = <math>n</math>
}}
Авторы статьи: [[Участница:Руфина_Третьякова|Третьякова Р. М.]] (группа 603), [[Участница:Екатерина_Буторина|Буторина Е. В.]] (группа 603)

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

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

=== Математическое описание алгоритма ===
Исходные данные: разреженная матрица <math>M^{n*n}</math>, вектор <math>x^{n*1}</math>

Наиболее удобным форматом для вычисления произведения матрицы на вектор является "Compressed Sparse Row" или сокращенно CSR-формат.

Рассмотрим CSR-представление разреженной матрицы: пусть число ненулевых элементов матрицы равно <math>nnz</math>
CSR-формат представляет матрицу <math>M</math> в виде 3-х одномерных массивов:

массив <math>A</math> размера <math>nnz</math> содержит ненулевые значения матрицы,
<math>JA</math> размера <math>nnz</math> - номера столбцов ненулевых элементов.,
<math>IA</math> размера <math>n</math>- содержит номер с которого начинается описание элементов строки в массивах <math>A</math> и <math>JA</math>.
Этот формат позволяет производить перемножение матрицы <math>M</math> на вектор <math>x</math> за <math>O(nnz)</math> умножений и сложений.

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 1 \\
2 & 0 & 0 & 0 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
представляемая в формате CSR
A = [ 1 2 3 4 ]
IA = [ 0 1 2 3 4 ]
JA = [ 3 0 2 1 ]

Вычисляемые данные: вектор <math>M*x=y</math>

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

:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.
'''read CSR''' ''n'', ''IA'', ''JA'', ''A'';
'''read''' ''x''
'''for''' ''i'' = 1,n:
'''for''' ''k'' = ''IA(i)'', ''IA(i+1)-1'':
''y(i)'' += ''A(k)''*''x(JA(k))'';
'''write''' ''y'';

=== Схема реализации последовательного алгоритма ===
Метод можно описать следующим образом:
# привести матрицу <math>M</math> к формату CSR
# для <math>i</math> от <math>0</math> до <math>n-1</math> вычислить <math>y_i</math> по формуле <math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Последовательная сложность алгоритма ===
Для вычисления матрично-векторного произведения матрицы размера <math>n*n</math> и вектора размера n в последовательном варианте требуется:

* <math>nnz</math> сложений,
* <math>nnz</math> умножений.

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

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

=== Входные и выходные данные алгоритма ===
'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.

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

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

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

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

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

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

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

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

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

Последовательная реализация имеется в пакете SPARSKIT, ScaLAPACK, Matlab, Python.Scipy

== Литература ==
[1] С. Писсанецки. Технология разреженных матриц. Изд. Мир, 1988.

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-10-13T11:12:35Z

Екатерина Буторина: /* Входные и выходные данные алгоритма */

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nnz</math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math>2nnz+2n+1</math>
| output_data = <math>n</math>
}}
Авторы статьи: [[Участница:Руфина_Третьякова|Третьякова Р. М.]] (группа 603), [[Участница:Екатерина_Буторина|Буторина Е. В.]] (группа 603)

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

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

=== Математическое описание алгоритма ===
Исходные данные: разреженная матрица <math>M^{n*n}</math>, вектор <math>x^{n*1}</math>

Наиболее удобным форматом для вычисления произведения матрицы на вектор является "Compressed Sparse Row" или сокращенно CSR-формат.

Рассмотрим CSR-представление разреженной матрицы: пусть число ненулевых элементов матрицы равно <math>nnz</math>
CSR-формат представляет матрицу <math>M</math> в виде 3-х одномерных массивов:

массив <math>A</math> размера <math>nnz</math> содержит ненулевые значения матрицы,
<math>JA</math> размера <math>nnz</math> - номера столбцов ненулевых элементов.,
<math>IA</math> размера <math>n</math>- содержит номер с которого начинается описание элементов строки в массивах <math>A</math> и <math>JA</math>.
Этот формат позволяет производить перемножение матрицы <math>M</math> на вектор <math>x</math> за <math>O(nnz)</math> умножений и сложений.

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 1 \\
2 & 0 & 0 & 0 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
представляемая в формате CSR
A = [ 1 2 3 4 ]
IA = [ 0 1 2 3 4 ]
JA = [ 3 0 2 1 ]

Вычисляемые данные: вектор <math>M*x=y</math>

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

:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.
'''read CSR''' ''n'', ''IA'', ''JA'', ''A'';
'''read''' ''x''
'''for''' ''i'' = 1,n:
'''for''' ''k'' = ''IA(i)'', ''IA(i+1)-1'':
''y(i)'' += ''A(k)''*''x(JA(k))'';
'''write''' ''y'';

=== Схема реализации последовательного алгоритма ===
Метод можно описать следующим образом:
# привести матрицу <math>M</math> к формату CSR
# для <math>i</math> от <math>0</math> до <math>n-1</math> вычислить <math>y_i</math> по формуле <math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Последовательная сложность алгоритма ===
Для вычисления матрично-векторного произведения матрицы размера <math>n*n</math> и вектора размера n в последовательном варианте требуется:

* <math>nnz</math> сложений,
* <math>nnz</math> умножений.

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

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

=== Входные и выходные данные алгоритма ===
'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.

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

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

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

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

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

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

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

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

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

Последовательная реализация имеется в пакете SPARSKIT

== Литература ==
[1] С. Писсанецки. Технология разреженных матриц. Изд. Мир, 1988.

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-10-13T11:09:40Z

Екатерина Буторина:

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nnz</math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math>2nnz+2n+1</math>
| output_data = <math>n</math>
}}
Авторы статьи: [[Участница:Руфина_Третьякова|Третьякова Р. М.]] (группа 603), [[Участница:Екатерина_Буторина|Буторина Е. В.]] (группа 603)

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

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

=== Математическое описание алгоритма ===
Исходные данные: разреженная матрица <math>M^{n*n}</math>, вектор <math>x^{n*1}</math>

Наиболее удобным форматом для вычисления произведения матрицы на вектор является "Compressed Sparse Row" или сокращенно CSR-формат.

Рассмотрим CSR-представление разреженной матрицы: пусть число ненулевых элементов матрицы равно <math>nnz</math>
CSR-формат представляет матрицу <math>M</math> в виде 3-х одномерных массивов:

массив <math>A</math> размера <math>nnz</math> содержит ненулевые значения матрицы,
<math>JA</math> размера <math>nnz</math> - номера столбцов ненулевых элементов.,
<math>IA</math> размера <math>n</math>- содержит номер с которого начинается описание элементов строки в массивах <math>A</math> и <math>JA</math>.
Этот формат позволяет производить перемножение матрицы <math>M</math> на вектор <math>x</math> за <math>O(nnz)</math> умножений и сложений.

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 1 \\
2 & 0 & 0 & 0 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
представляемая в формате CSR
A = [ 1 2 3 4 ]
IA = [ 0 1 2 3 4 ]
JA = [ 3 0 2 1 ]

Вычисляемые данные: вектор <math>M*x=y</math>

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

:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.
'''read CSR''' ''n'', ''IA'', ''JA'', ''A'';
'''read''' ''x''
'''for''' ''i'' = 1,n:
'''for''' ''k'' = ''IA(i)'', ''IA(i+1)-1'':
''y(i)'' += ''A(k)''*''x(JA(k))'';
'''write''' ''y'';

=== Схема реализации последовательного алгоритма ===
Метод можно описать следующим образом:
# привести матрицу <math>M</math> к формату CSR
# для <math>i</math> от <math>0</math> до <math>n-1</math> вычислить <math>y_i</math> по формуле <math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Последовательная сложность алгоритма ===
Для вычисления матрично-векторного произведения матрицы размера <math>n*n</math> и вектора размера n в последовательном варианте требуется:

* <math>nnz</math> сложений,
* <math>nnz</math> умножений.

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

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

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

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

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

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

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

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

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

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

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

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

Последовательная реализация имеется в пакете SPARSKIT

== Литература ==
[1] С. Писсанецки. Технология разреженных матриц. Изд. Мир, 1988.

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-10-13T11:08:41Z

Екатерина Буторина:

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nnz</math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math>2nnz+2n+1</math>
| output_data = <math>n</math>
}}
Авторы статьи: [[Участница:Руфина_Третьякова|Третьякова Р. М.]] (группа 603), [[Участница:Екатерина_Буторина|Буторина Е. В.]] (группа 603)

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

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

=== Математическое описание алгоритма ===
Исходные данные: разреженная матрица <math>M^{n*n}</math>, вектор <math>x^{n*1}</math>

Наиболее удобным форматом для вычисления произведения матрицы на вектор является "Compressed Sparse Row" или сокращенно CSR-формат.

Рассмотрим CSR-представление разреженной матрицы: пусть число ненулевых элементов матрицы равно <math>nnz</math>
CSR-формат представляет матрицу <math>M</math> в виде 3-х одномерных массивов:

массив <math>A</math> размера <math>nnz</math> содержит ненулевые значения матрицы,
<math>JA</math> размера <math>nnz</math> - номера столбцов ненулевых элементов.,
<math>IA</math> размера <math>n</math>- содержит номер с которого начинается описание элементов строки в массивах <math>A</math> и <math>JA</math>.
Этот формат позволяет производить перемножение матрицы <math>M</math> на вектор <math>x</math> за <math>O(nnz)</math> умножений и сложений.

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 1 \\
2 & 0 & 0 & 0 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
представляемая в формате CSR
A = [ 1 2 3 4 ]
IA = [ 0 1 2 3 4 ]
JA = [ 3 0 2 1 ]

Вычисляемые данные: вектор <math>M*x=y</math>

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

:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.
'''read CSR''' ''n'', ''IA'', ''JA'', ''A'';
'''read''' ''x''
'''for''' ''i'' = 1,n:
'''for''' ''k'' = ''IA(i)'', ''IA(i+1)-1'':
''y(i)'' += ''A(k)''*''x(JA(k))'';
'''write''' ''y'';

=== Схема реализации последовательного алгоритма ===
Метод можно описать следующим образом:
# привести матрицу <math>M</math> к формату CSR
# для <math>i</math> от <math>0</math> до <math>n-1</math> вычислить <math>y_i</math> по формуле <math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Последовательная сложность алгоритма ===
Для вычисления матрично-векторного произведения матрицы размера <math>n*n</math> и вектора размера n в последовательном варианте требуется:

* <math>nnz</math> сложений,
* <math>nnz</math> умножений.

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

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

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

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

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

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

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

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

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

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

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

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

Последовательная реализация имеется в пакете SPARSKIT

== Литература ==
[1] С. Писсанецки. Технология разреженных матриц. Изд. Мир, 1988.

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-10-13T11:07:59Z

Екатерина Буторина: /* Программная реализация алгоритма */

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nnz</math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math>2nnz+2n+1</math>
| output_data = <math>n</math>
}}
Авторы статьи: [[Участница:Руфина_Третьякова|Третьякова Р. М.]] (группа 603), [[Участница:Екатерина_Буторина|Буторина Е. В.]] (группа 603)

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

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

=== Математическое описание алгоритма ===
Исходные данные: разреженная матрица <math>M^{n*n}</math>, вектор <math>x^{n*1}</math>

Наиболее удобным форматом для вычисления произведения матрицы на вектор является "Compressed Sparse Row" или сокращенно CSR-формат.

Рассмотрим CSR-представление разреженной матрицы: пусть число ненулевых элементов матрицы равно <math>nnz</math>
CSR-формат представляет матрицу <math>M</math> в виде 3-х одномерных массивов:

массив <math>A</math> размера <math>nnz</math> содержит ненулевые значения матрицы,
<math>JA</math> размера <math>nnz</math> - номера столбцов ненулевых элементов.,
<math>IA</math> размера <math>n</math>- содержит номер с которого начинается описание элементов строки в массивах <math>A</math> и <math>JA</math>.
Этот формат позволяет производить перемножение матрицы <math>M</math> на вектор <math>x</math> за <math>O(nnz)</math> умножений и сложений.

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 1 \\
2 & 0 & 0 & 0 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
представляемая в формате CSR
A = [ 1 2 3 4 ]
IA = [ 0 1 2 3 4 ]
JA = [ 3 0 2 1 ]

Вычисляемые данные: вектор <math>M*x=y</math>

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

:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.
'''read CSR''' ''n'', ''IA'', ''JA'', ''A'';
'''read''' ''x''
'''for''' ''i'' = 1,n:
'''for''' ''k'' = ''IA(i)'', ''IA(i+1)-1'':
''y(i)'' += ''A(k)''*''x(JA(k))'';
'''write''' ''y'';

=== Схема реализации последовательного алгоритма ===
Метод можно описать следующим образом:
# привести матрицу <math>M</math> к формату CSR
# для <math>i</math> от <math>0</math> до <math>n-1</math> вычислить <math>y_i</math> по формуле <math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Последовательная сложность алгоритма ===
Для вычисления матрично-векторного произведения матрицы размера <math>n*n</math> и вектора размера n в последовательном варианте требуется:

* <math>nnz</math> сложений,
* <math>nnz</math> умножений.

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

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

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

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

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

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

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

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

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

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

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

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

Последовательная реализация имеется в пакете SPARSKIT

== Литература ==
[1] С. Писсанецки. Технология разреженных матриц. Изд. Мир, 1988.

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-10-13T11:07:41Z

Екатерина Буторина: /* Программная реализация алгоритма */

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nnz</math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math>2nnz+2n+1</math>
| output_data = <math>n</math>
}}
Авторы статьи: [[Участница:Руфина_Третьякова|Третьякова Р. М.]] (группа 603), [[Участница:Екатерина_Буторина|Буторина Е. В.]] (группа 603)

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

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

=== Математическое описание алгоритма ===
Исходные данные: разреженная матрица <math>M^{n*n}</math>, вектор <math>x^{n*1}</math>

Наиболее удобным форматом для вычисления произведения матрицы на вектор является "Compressed Sparse Row" или сокращенно CSR-формат.

Рассмотрим CSR-представление разреженной матрицы: пусть число ненулевых элементов матрицы равно <math>nnz</math>
CSR-формат представляет матрицу <math>M</math> в виде 3-х одномерных массивов:

массив <math>A</math> размера <math>nnz</math> содержит ненулевые значения матрицы,
<math>JA</math> размера <math>nnz</math> - номера столбцов ненулевых элементов.,
<math>IA</math> размера <math>n</math>- содержит номер с которого начинается описание элементов строки в массивах <math>A</math> и <math>JA</math>.
Этот формат позволяет производить перемножение матрицы <math>M</math> на вектор <math>x</math> за <math>O(nnz)</math> умножений и сложений.

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 1 \\
2 & 0 & 0 & 0 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
представляемая в формате CSR
A = [ 1 2 3 4 ]
IA = [ 0 1 2 3 4 ]
JA = [ 3 0 2 1 ]

Вычисляемые данные: вектор <math>M*x=y</math>

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

:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.
'''read CSR''' ''n'', ''IA'', ''JA'', ''A'';
'''read''' ''x''
'''for''' ''i'' = 1,n:
'''for''' ''k'' = ''IA(i)'', ''IA(i+1)-1'':
''y(i)'' += ''A(k)''*''x(JA(k))'';
'''write''' ''y'';

=== Схема реализации последовательного алгоритма ===
Метод можно описать следующим образом:
# привести матрицу <math>M</math> к формату CSR
# для <math>i</math> от <math>0</math> до <math>n-1</math> вычислить <math>y_i</math> по формуле <math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Последовательная сложность алгоритма ===
Для вычисления матрично-векторного произведения матрицы размера <math>n*n</math> и вектора размера n в последовательном варианте требуется:

* <math>nnz</math> сложений,
* <math>nnz</math> умножений.

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

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

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

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

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

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

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

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

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

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

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

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

Последовательная реализация имеется в пакете SPARSKIT

== Литература ==
[1] С. Писсанецки. Технология разреженных матриц. Изд. Мир, 1988.

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-10-12T23:03:44Z

Екатерина Буторина:

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-10-12T21:53:30Z

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

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-10-12T21:53:06Z

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

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-10-12T21:51:27Z

Екатерина Буторина: /* Литература */

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-10-12T21:51:06Z

Екатерина Буторина: /* Литература */

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-10-12T21:50:42Z

Екатерина Буторина: /* Существующие реализации алгоритма */

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-10-12T21:50:28Z

Екатерина Буторина: /* Существующие реализации алгоритма */

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-10-12T21:46:08Z

Екатерина Буторина:

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-10-12T21:45:03Z

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

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math></math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math>2nnz+n+1</math>
| output_data = <math>n</math>
}}
Авторы статьи: [[Участница:Руфина_Третьякова|Третьякова Р. М.]] (группа 603), [[Участница:Екатерина_Буторина|Буторина Е. В.]] (группа 603)

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

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

=== Математическое описание алгоритма ===
Исходные данные: разреженная матрица <math>M^{n*n}</math>, вектор <math>x^{n*1}</math>

Наиболее удобным форматом для вычисления произведения матрицы на вектор является "Compressed Sparse Row" или сокращенно CSR-формат.

Рассмотрим CSR-представление разреженной матрицы: пусть число ненулевых элементов матрицы равно <math>nnz</math>
CSR-формат представляет матрицу <math>M</math> в виде 3-х одномерных массивов:

массив <math>A</math> размера <math>nnz</math> содержит ненулевые значения матрицы,
<math>JA</math> размера <math>nnz</math> - номера столбцов ненулевых элементов.,
<math>IA</math> размера <math>n</math>- содержит номер с которого начинается описание элементов строки в массивах <math>A</math> и <math>JA</math>.
Этот формат позволяет производить перемножение матрицы <math>M</math> на вектор <math>x</math> за <math>O(nnz)</math> умножений и сложений.

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 1 \\
2 & 0 & 0 & 0 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
представляемая в формате CSR
A = [ 1 2 3 4 ]
IA = [ 0 1 2 3 4 ]
JA = [ 3 0 2 1 ]

Вычисляемые данные: вектор <math>M*x=y</math>

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

:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.
'''read CSR''' ''n'', ''IA'', ''JA'', ''A'';
'''read''' ''x''
'''for''' ''i'' = 1,n:
'''for''' ''k'' = ''IA(i)'', ''IA(i+1)-1'':
''y(i)'' += ''A(k)''*''x(JA(k))'';
'''write''' ''y'';

=== Схема реализации последовательного алгоритма ===
Метод можно описать следующим образом:

=== Последовательная сложность алгоритма ===
Для вычисления сингулярных чисел и векторов матрицы порядка n в последовательном варианте требуется:

* <math></math> делений,
* <math></math> сложений (вычитаний),
* <math></math> умножений.

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

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

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

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

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

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

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

== Литература ==
1. С. Писсанецки Технология разреженных матриц. Изд. Мир, 1988.

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-10-12T21:44:36Z

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

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math></math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math>2nnz+n+1</math>
| output_data = <math>n</math>
}}
Авторы статьи: [[Участница:Руфина_Третьякова|Третьякова Р. М.]] (группа 603), [[Участница:Екатерина_Буторина|Буторина Е. В.]] (группа 603)

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

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

=== Математическое описание алгоритма ===
Исходные данные: разреженная матрица <math>M^{n*n}</math>, вектор <math>x^{n*1}</math>

Наиболее удобным форматом для вычисления произведения матрицы на вектор является "Compressed Sparse Row" или сокращенно CSR-формат.

Рассмотрим CSR-представление разреженной матрицы: пусть число ненулевых элементов матрицы равно <math>nnz</math>
CSR-формат представляет матрицу <math>M</math> в виде 3-х одномерных массивов:

массив <math>A</math> размера <math>nnz</math> содержит ненулевые значения матрицы,
<math>JA</math> размера <math>nnz</math> - номера столбцов ненулевых элементов.,
<math>IA</math> размера <math>n</math>- содержит номер с которого начинается описание элементов строки в массивах <math>A</math> и <math>JA</math>.
Этот формат позволяет производить перемножение матрицы <math>M</math> на вектор <math>x</math> за <math>O(nnz)</math> умножений и сложений.

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 1 \\
2 & 0 & 0 & 0 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,

представляемая в формате CSR

A = [ 1 2 3 4 ]
IA = [ 0 1 2 3 4 ]
JA = [ 3 0 2 1 ]

Вычисляемые данные: вектор <math>M*x=y</math>

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

:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.
'''read''' ''n'', ''IA'', ''JA'', ''A'';
'''read''' ''x''
'''for''' ''i'' = 1,n:
'''for''' ''k'' = ''IA(i)'', ''IA(i+1)-1'':
''y(i)'' += ''A(k)''*''x(JA(k))'';
'''write''' ''y'';

=== Схема реализации последовательного алгоритма ===
Метод можно описать следующим образом:

=== Последовательная сложность алгоритма ===
Для вычисления сингулярных чисел и векторов матрицы порядка n в последовательном варианте требуется:

* <math></math> делений,
* <math></math> сложений (вычитаний),
* <math></math> умножений.

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

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

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

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

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

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

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

== Литература ==
1. С. Писсанецки Технология разреженных матриц. Изд. Мир, 1988.

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-10-12T21:44:12Z

Екатерина Буторина:

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math></math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math>2nnz+n+1</math>
| output_data = <math>n</math>
}}
Авторы статьи: [[Участница:Руфина_Третьякова|Третьякова Р. М.]] (группа 603), [[Участница:Екатерина_Буторина|Буторина Е. В.]] (группа 603)

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

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

=== Математическое описание алгоритма ===
Исходные данные: разреженная матрица <math>M^{n*n}</math>, вектор <math>x^{n*1}</math>

Наиболее удобным форматом для вычисления произведения матрицы на вектор является "Compressed Sparse Row" или сокращенно CSR-формат.

Рассмотрим CSR-представление разреженной матрицы: пусть число ненулевых элементов матрицы равно <math>NNZ</math>
CSR-формат представляет матрицу <math>M</math> в виде 3-х одномерных массивов:

массив <math>A</math> размера <math>nnz</math> содержит ненулевые значения матрицы,
<math>JA</math> размера <math>nnz</math> - номера столбцов ненулевых элементов.,
<math>IA</math> размера <math>n</math>- содержит номер с которого начинается описание элементов строки в массивах <math>A</math> и <math>JA</math>.
Этот формат позволяет производить перемножение матрицы <math>M</math> на вектор <math>x</math> за <math>O(nnz)</math> умножений и сложений.

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 1 \\
2 & 0 & 0 & 0 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,

представляемая в формате CSR

A = [ 1 2 3 4 ]
IA = [ 0 1 2 3 4 ]
JA = [ 3 0 2 1 ]

Вычисляемые данные: вектор <math>M*x=y</math>

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

:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.
'''read''' ''n'', ''IA'', ''JA'', ''A'';
'''read''' ''x''
'''for''' ''i'' = 1,n:
'''for''' ''k'' = ''IA(i)'', ''IA(i+1)-1'':
''y(i)'' += ''A(k)''*''x(JA(k))'';
'''write''' ''y'';

=== Схема реализации последовательного алгоритма ===
Метод можно описать следующим образом:

=== Последовательная сложность алгоритма ===
Для вычисления сингулярных чисел и векторов матрицы порядка n в последовательном варианте требуется:

* <math></math> делений,
* <math></math> сложений (вычитаний),
* <math></math> умножений.

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

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

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

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

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

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

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

== Литература ==
1. С. Писсанецки Технология разреженных матриц. Изд. Мир, 1988.

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-10-12T21:43:15Z

Екатерина Буторина: /* Макроструктура алгоритма */

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math></math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math>2NNZ+n+1</math>
| output_data = <math>n</math>
}}
Авторы статьи: [[Участница:Руфина_Третьякова|Третьякова Р. М.]] (группа 603), [[Участница:Екатерина_Буторина|Буторина Е. В.]] (группа 603)

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

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

=== Математическое описание алгоритма ===
Исходные данные: разреженная матрица <math>M^{n*n}</math>, вектор <math>x^{n*1}</math>

Наиболее удобным форматом для вычисления произведения матрицы на вектор является "Compressed Sparse Row" или сокращенно CSR-формат.

Рассмотрим CSR-представление разреженной матрицы: пусть число ненулевых элементов матрицы равно <math>NNZ</math>
CSR-формат представляет матрицу <math>M</math> в виде 3-х одномерных массивов:

массив <math>A</math> размера <math>NNZ</math> содержит ненулевые значения матрицы,
<math>JA</math> размера <math>NNZ</math> - номера столбцов ненулевых элементов.,
<math>IA</math> размера <math>n</math>- содержит номер с которого начинается описание элементов строки в массивах <math>A</math> и <math>JA</math>.
Этот формат позволяет производить перемножение матрицы <math>M</math> на вектор <math>x</math> за <math>O(NNZ)</math> умножений и сложений.

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 1 \\
2 & 0 & 0 & 0 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,

представляемая в формате CSR

A = [ 1 2 3 4 ]
IA = [ 0 1 2 3 4 ]
JA = [ 3 0 2 1 ]

Вычисляемые данные: вектор <math>M*x=y</math>

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

:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.
'''read''' ''n'', ''IA'', ''JA'', ''A'';
'''read''' ''x''
'''for''' ''i'' = 1,n:
'''for''' ''k'' = ''IA(i)'', ''IA(i+1)-1'':
''y(i)'' += ''A(k)''*''x(JA(k))'';
'''write''' ''y'';

=== Схема реализации последовательного алгоритма ===
Метод можно описать следующим образом:

=== Последовательная сложность алгоритма ===
Для вычисления сингулярных чисел и векторов матрицы порядка n в последовательном варианте требуется:

* <math></math> делений,
* <math></math> сложений (вычитаний),
* <math></math> умножений.

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

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

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

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

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

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

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

== Литература ==
1. С. Писсанецки Технология разреженных матриц. Изд. Мир, 1988.

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-10-12T21:41:42Z

Екатерина Буторина:

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math></math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math>2NNZ+n+1</math>
| output_data = <math>n</math>
}}
Авторы статьи: [[Участница:Руфина_Третьякова|Третьякова Р. М.]] (группа 603), [[Участница:Екатерина_Буторина|Буторина Е. В.]] (группа 603)

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

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

=== Математическое описание алгоритма ===
Исходные данные: разреженная матрица <math>M^{n*n}</math>, вектор <math>x^{n*1}</math>

Наиболее удобным форматом для вычисления произведения матрицы на вектор является "Compressed Sparse Row" или сокращенно CSR-формат.

Рассмотрим CSR-представление разреженной матрицы: пусть число ненулевых элементов матрицы равно <math>NNZ</math>
CSR-формат представляет матрицу <math>M</math> в виде 3-х одномерных массивов:

массив <math>A</math> размера <math>NNZ</math> содержит ненулевые значения матрицы,
<math>JA</math> размера <math>NNZ</math> - номера столбцов ненулевых элементов.,
<math>IA</math> размера <math>n</math>- содержит номер с которого начинается описание элементов строки в массивах <math>A</math> и <math>JA</math>.
Этот формат позволяет производить перемножение матрицы <math>M</math> на вектор <math>x</math> за <math>O(NNZ)</math> умножений и сложений.

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 1 \\
2 & 0 & 0 & 0 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,

представляемая в формате CSR

A = [ 1 2 3 4 ]
IA = [ 0 1 2 3 4 ]
JA = [ 3 0 2 1 ]

Вычисляемые данные: вектор <math>M*x=y</math>

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

:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.

'''for''' ''i'' = 1,n:
'''for''' ''k'' = ''IA(i)'', ''IA(i+1)-1'':
''y(i)'' += ''A(k)''*''x(JA(k))'';

=== Схема реализации последовательного алгоритма ===
Метод можно описать следующим образом:

=== Последовательная сложность алгоритма ===
Для вычисления сингулярных чисел и векторов матрицы порядка n в последовательном варианте требуется:

* <math></math> делений,
* <math></math> сложений (вычитаний),
* <math></math> умножений.

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

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

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

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

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

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

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

== Литература ==
1. С. Писсанецки Технология разреженных матриц. Изд. Мир, 1988.

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-10-12T21:38:05Z

Екатерина Буторина:

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math></math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math>2NNZ+N+1</math>
| output_data = <math>N</math>
}}
Авторы статьи: [[Участница:Руфина_Третьякова|Третьякова Р. М.]] (группа 603), [[Участница:Екатерина_Буторина|Буторина Е. В.]] (группа 603)

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

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

=== Математическое описание алгоритма ===
Исходные данные: разреженная матрица <math>M^{n*n}</math>, вектор <math>x^{n*1}</math>

Наиболее удобным форматом для вычисления произведения матрицы на вектор является "Compressed Sparse Row" или сокращенно CSR-формат.

Рассмотрим CSR-представление разреженной матрицы: пусть число ненулевых элементов матрицы
CSR-формат представляет матрицу <math>M</math> в виде 3-х одномерных массивов:

массив <math>A</math> размера <math>nnz</math> содержит ненулевые значения матрицы,
<math>JA</math> - номера столбцов ненулевых элементов.,
<math>IA</math>- содержит номер с которого начинается описание элементов в массивах,
Этот формат позволяет быстро производить перемножение матрицы <math>M</math> на вектор <math>x</math>.

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 1 \\
2 & 0 & 0 & 0 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,

представляемая в формате CSR

A = [ 1 2 3 4 ]
IA = [ 0 1 2 3 4 ]
JA = [ 3 0 2 1 ]

Вычисляемые данные: вектор <math>M*x=y</math>

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

:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.

'''for''' ''i'' = 1,n:
'''for''' ''k'' = ''IA(i)'', ''IA(i+1)-1'':
''y(i)'' += ''A(k)''*''x(JA(k))'';

=== Схема реализации последовательного алгоритма ===
Метод можно описать следующим образом:

=== Последовательная сложность алгоритма ===
Для вычисления сингулярных чисел и векторов матрицы порядка n в последовательном варианте требуется:

* <math></math> делений,
* <math></math> сложений (вычитаний),
* <math></math> умножений.

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

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

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

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

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

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

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

== Литература ==
1. С. Писсанецки Технология разреженных матриц. Изд. Мир, 1988.