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

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

2016-12-02T14:02:58Z

Blizn:

{{Assignment}}

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>O(l)</math>
| pf_height = <math>O(m)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>2l+m+n+1</math>
| output_data = <math>n</math>
}}
Выполнила: [[Участник:Blizn|И.В. Близнякова]] (611 группа).

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

== Общее описание алгоритма<ref>С.Писсанецки. Технология разреженных матриц. - М.: Мир, 1988.</ref> ==
'''Разрежённая матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается '''''плотной'''''.

Среди специалистов нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:
* есть <math>O(n)</math>. Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;
* в каждой строке не превышает 10 в типичном случае;
* ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.
* таково, что для данного алгоритма и вычислительной системы имеет смысл извлекать выгоду из наличия в ней нулей.

=== Хранение разреженной матрицы ===
==== Формат RR(C)O ====
Рассмотрим сначала формат '''RR(C)O'''. Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Ordered"'' (строчное представление, полное и упорядоченное). В данном формате вместо одного двумерного массива, используются три одномерных. Значения ненулевых элементов матрицы и соответствующие им столбцовые индексы хранятся в этом формате по строкам в двух массивах <math>AN</math> и <math>JA</math>. Массив указателей <math>IA</math>, используется для ссылки на компоненты массивов <math>AN</math> и <math>JA</math>, с которых начинается описание очередной строки. Последняя компонента массива <math>IA</math> содержит указатель первой свободной компоненты в массивах <math>AN</math> и <math>JA</math>, т.е. равна числу ненулевых элементов матрицы, увеличенному на единицу. Здесь уместно привести пример.

Рассмотрим матрицу <math>A</math>:
:<math>\begin{pmatrix}
0 & 0 & 0 & 2 & 0 \\
1 & 0 & 3 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 \\
0 & 6 & 0 & 0 & 0 \\
0 & 0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
тогда ее представление в формате '''RR(C)O''' будет иметь вид:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 1 3 2 3 ]
AN = [ 2 1 3 6 4 ]
Т.е. массив <math>AN</math> содержит все не нулевые элементы исходной матрицы <math>A</math>, массив <math>JA</math> номер столбца в котором находится соответствующий элемент из <math>AN</math> и наконец массив <math>IA</math> содержит номер с которого начинается описание элементов в массивах <math>JA</math> и <math>AN</math>. Таким образом информация об элементах 2-ой строки матрицы хранится в элементах с <math>IA[2] = 2</math> по <math>IA[3] - 1 = 3</math> включительно массивов <math>JA</math> и <math>AN</math>. Можно обратить внимание, что <math>IA[3] = IA[4] = 4</math>, а это означает, что 3-я строка матрицы <math>A</math> нулевая.

В общем случае описание <math>r</math>-й строки матрицы A хранится в компонентах с <math>IA[r]</math> до <math>IA[r + 1] - 1</math> включительно массивов <math>AN</math> и <math>JA</math>. Если <math>IA[r + 1] = IA[r]</math>, то это означает, что <math>r</math>-я строка нулевая. Количество элементов в массиве <math>IA</math> на единицу больше, чем число строк исходной матрицы, а количество элементов в массивах <math>JA</math> и <math>AN</math> равно числу ненулевых элементов исходной матрицы.

Данный способ представления называют ''полным'', поскольку представлена вся матрица <math>A</math>, ''упорядоченным'', поскольку элементы каждой строки матрицы <math>A</math> хранятся в соответствии с возрастанием столбцовых индексов, и строчным, поскольку информация о матрице <math>A</math> указывается по строкам.

Массивы <math>IA</math> и <math>JA</math> представляют портрет (структуру) матрицы <math>A</math>, задаваемый как множество списков смежности ассоциированного с <math>A</math> графа. Если алгоритм, реализующий какую-либо операцию над разреженными матрицами, разбит на этапы символической обработки, на котором определяется портрет результирующей матрицы, и численной обработки, на котором определяются значения элементов результирующей матрицы, то массивы <math>IA</math> и <math>JA</math> заполняются на первом этапе, а массив <math>AN</math> - на втором.

==== Формат RR(C)U ====

Рассмотрим теперь формат '''RR(C)U'''.

Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Unordered"'' (строчное представление, полное, но неупорядоченное). Формат '''RR(C)U''' отличается от '''RR(C)O''' тем, что в данном случае соблюдается упорядоченность строк, но внутри каждой строки элементы исходных матриц могут храниться в произвольном порядке. Для матрицы <math>A</math> нашего примера вполне можно было бы использовать и строчное представление, полное, но неупорядоченное такое:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 3 1 2 3 ]
AN = [ 2 1 3 6 4 ]
Такие неупорядоченные представления могут быть очень удобны в практических вычислениях. Результаты большинства матричных операций получаются неупорядоченными (например, операции вставки и удаления новых коэффициентов), а их упорядочение стоило бы значительных затрат машинного времени. В то же время, за немногими исключениями, алгоритмы для разреженных матриц не требуют, чтобы их представления были упорядоченными.

==== Замечания ====

Несколько замечаний по поводу рассмотренных форматов представления:
# Очевидно, что представление матрицы в формате '''RR(C)O''' так же является и представлением в формате '''RR(C)U''', но не наоборот.
# Из представления матрицы в формате '''RR(C)''' нельзя получить информацию о точном количестве столбцов исходной матрицы.
# Целесообразно (в вопросе экономии памяти) использовать представления '''RR(C)''' в случае, если матрица содержит значительное число нулевых элементов.

=== Умножение разреженной матрицы на вектор ===

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

Мы рассмотрим умножение разреженной матрицы общего вида, хранимой в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math> на заполненный вектор-столбец.

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

Исходные данные: разреженная матрица общего вида <math>A</math> с элементами <math>a_{ij}</math> (<math>i = 1,...,n</math> и <math>j = 1,...,m</math>). Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> (<math>j =1,...,m</math>).

Вычисляемые данные: заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

Формулы метода:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

где <math>l_{i}</math> - количество ненулевых элементов строки <math>i</math> матрицы <math>A</math>, <math>j(k)</math> - индекс <math>k</math>-го ненулевого элемента матрицы <math>A</math>.

== Вычислительное ядро алгоритма ==
Вычислительное ядро последовательной версии умножения разреженной матрицы на вектор можно составить из множественных (всего их <math>n</math>) вычислений скалярных произведений строк матрицы:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>.

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

Как записано и в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют множественные (всего <math>n</math>) вычисления сумм:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

которые могут вычисляться в произвольном порядке.

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

Далее предполагаем, что разреженная матрица общего вида <math>A</math> хранится в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>.
Последовательность исполнения метода следующая:

Выполнять для <math>i</math> от <math>1</math> до <math>n</math>
# <math>c_{i} = 0</math>
# <math>IAA = IA[i]</math>
# <math>IAB = IA[i + 1] - 1</math>
# <math>c_{i} = \sum\limits_{k = IAA}^{IAB} AN[k]b_{JA[k]}</math>.
После этого (если <math>i \le n</math>) происходит переход к шагу 1 с бо́льшим <math>i</math>.

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размером <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в последовательном (наиболее быстром) варианте требуется:

* <math>O(l)</math> сложений,
* <math>O(l)</math> умножений.

Умножения и сложения составляют ''основную часть алгоритма''.

При классификации по последовательной сложности, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам <math>O(l)</math>.

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

Опишем [[глоссарий#Граф алгоритма|граф алгоритма]]<ref>Воеводин В.В. Математические основы параллельных вычислений// М.: Изд. Моск. ун-та, 1991. 345 с.</ref><ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. – СПб.: БХВ - Петербург, 2002. – 608 с.</ref><ref>Фролов А.В.. Принципы построения и описание языка Сигма. Препринт ОВМ АН N 236. М.: ОВМ АН СССР, 1989.</ref> как аналитически, так и в виде рисунка.

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

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

* <math>i</math> — меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math> - элемент ''входных данных'', а именно <math>AN[IA_{i}+j-1]</math>.
* <math>b</math> - элемент ''входных данных'', а именно <math>b[IA_{i}+j-1]</math>.

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

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция <math>a + b</math>.
Естественно введённые координаты области таковы:
* <math>i</math> - меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> - меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math>:
** при <math>j = 1</math> - результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j)</math>;
** при <math>j > 1</math> - результат срабатывания операции, соответствующей вершине из второй группы, с координатами <math>(i, j - 1)</math>;
* <math>b</math> — результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j + 1)</math>.

Результат срабатывания операции:
* при <math>j < k - 1</math> является ''промежуточным данным'' алгоритма;
* при <math>j = k - 1</math> является ''выходным данным'' <math>c_{i}</math>.

Описанный граф можно посмотреть на рис.1. Здесь вершины первой группы обозначены красным цветом и отмечены знаком умножения, вершины второй - зелёным цветом и знаком сложения. Вершины, соответствующие входным данным обозначены белым цветом и выходным - синим.
[[file:Bliznalg.png|thumb|center|1000px|Рисунок 1. Граф алгоритма умножения разреженной матрицы на вектор]]

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размерности <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в параллельном варианте требуется последовательно выполнить следующие ярусы:

* Не более чем <math>m</math> сложений и умножений (<math>n</math> вычислений в каждом из ярусов)

При классификации по высоте ЯПФ, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам со сложностью <math>O(m)</math>. При классификации по ширине ЯПФ его сложность будет <math>O(n)</math>.

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

'''Входные данные''': разреженная матрица общего вида <math>A</math> размерности <math>n \times m</math>, хранимая в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>. Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> размерности <math>m \times 1</math>.

'''Объём входных данных''': <math>2l+m+n+1</math>, где <math>l</math> - количество ненулевых элементов в матрице <math>A</math>.

'''Выходные данные''': заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

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

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

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

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

Пусть <math>l</math> - количество ненулевых элементов матрицы <math>A</math> размерности <math>n \times m</math>. Пусть <math>x</math> - объем памяти, используемый для хранения значения элемента матрицы, <math>y</math> - объём памяти, используемый для хранения номера столбца или строки. В таком случае для хранения матрицы в стандартном представлении нам потребуется объем памяти, равный <math>x \cdot n \cdot m</math>, для хранения в формате '''RR(C)''' - <math>y(n + 1) + (x + y)l</math>. Таким образом хранение в формате '''RR(C)''' не является эффективным (в вопросе используемой памяти) для матриц, в которых <math>l > \frac{xnm - y(n+1)}{x+y}</math>.

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

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

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

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

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

Параллельная реализация алгоритма заключается в следующем:

# Каждый процессор считывает входные данные из файла, зависящего от его номера. Данные имеют вид: вектор <math>b</math> и набор определённых строк матрицы <math>A</math> в формате '''RR(C)U''' в зависимости от номера процессора и их числа;
# Процессоры проводят вычисления значений вектора <math>c</math> в зависимости от имеющихся данных;
# Все процессоры отправляют результаты вычисления процессору, выбранному главным, и главный процессор выводит результат вычислений.

<div class="mw-collapsible mw-collapsed" style="width:100%">
Текст использованной в экспериментах реализации (язык ''С++''):
<div class="mw-collapsible-content">
<source lang="c++">
#include <mpi.h>
#include <memory>
#include <iostream>
#include <vector>
#include <sstream>
#include <fstream>
#include <string>
#include <iterator>

typedef std::shared_ptr<std::vector<std::vector<int> > > MyData;

MyData ReadData(const std::string& data_path) {
std::ifstream file_stream;
MyData retval(new std::vector<std::vector<int> >());
file_stream.open(data_path);

while (!file_stream.eof()) {
std::string str;
std::getline(file_stream, str);

std::istringstream iss(str);
auto temp_1 = (std::istream_iterator<std::string>(iss));
auto temp_2 = (std::istream_iterator<std::string>());

std::vector<std::string> coordinates{ temp_1, temp_2};
retval->push_back(std::vector<int>());
for (auto& e : coordinates) {
retval->back().push_back(std::stoi(e));
}
}

return retval;
}

// input: vector b, vector ia, vector ja, vector an
int main(int argc, char** argv){
MPI_Init(&argc, &argv);
int pid, np;
MPI_Status *s = new MPI_Status;
MPI_Comm_rank(MPI_COMM_WORLD, &pid);
MPI_Comm_size(MPI_COMM_WORLD, &np);
if (argc == 2){
int n;
int indx = 0;
int stp;
double strttime = MPI_Wtime();
std::vector<int> b;
std::vector<int> ia;
std::vector<int> ja;
std::vector<int> an;
auto data = ReadData("data_" + std::to_string(static_cast<long long>(pid)) + ".txt");
b = (*data)[0];
ia = (*data)[1];
ja = (*data)[2];
an = (*data)[3];
n = (*data)[0].size();
std::vector<int> c;
stp = n / np + ((n % np > pid) ? 1 : 0);
if (pid == 0){
c.resize(n, 0);
}
else{
c.resize(stp, 0);
}
for (int i = 0; i < stp; i++){
int strt = ia[i] - ia[0];
int lstr = ia[i + 1] - ia[i];
for (int j = 0; j < lstr; j++){
c[i] += an[strt + j] * b[ja[strt + j]];
}
}
if (pid == 0){
for (int i = 1; i < np; i++){
indx += n / np + ((n % np > i - 1) ? 1 : 0);
stp = n / np + ((n % np > i) ? 1 : 0);
MPI_Recv(&c[indx], stp, MPI_INT, i, 0, MPI_COMM_WORLD, s);
}
}
else{
MPI_Send(&c[0], stp, MPI_INT, 0, 0, MPI_COMM_WORLD);
}
if (pid == 0){
for (int e : c) {
std::cout << e << "\n";
}
double endtime = MPI_Wtime();
std::cout << "Success! Time = " << endtime - strttime << "\n";
}
}
MPI_Finalize();
return 0;
}
</source>
</div></div>

<div class="mw-collapsible mw-collapsed" style="width:100%">
Для формирования входных данных использовался следующий алгоритм (язык ''Python''):
<div class="mw-collapsible-content">
<source lang="python">
from scipy import sparse as sp
from numpy.random import randint
from os import mkdir
from os.path import join as jn

n = 10000
np = [1, 2, 4, 8, 16, 32, 64, 128]

a = sp.csr_matrix(randint(0, 2, (n, n)))
b = randint(1, 5, n)
i = 0

for j in np:
mkdir('data_' + str(j))
indx = 0
for i in range(0, j):
stp = n / j + (1 if (n % j > i) else 0)
ael = a.indptr[indx + stp] - a.indptr[indx]
strt = a.indptr[indx]
with open(jn('data_' + str(j), 'data_' + str(i) + '.txt'), 'w') as fout:

for e in b:
fout.write('{0} '.format(e))
fout.write('\n')

s = a.indptr[indx:indx + stp + 1]
for e in s:
fout.write('{0} '.format(e))
fout.write('\n')

s = a.indices[strt:strt + ael]
for e in s:
fout.write('{0} '.format(e))
fout.write('\n')

s = a.data[strt:strt + ael]
for e in s:
fout.write('{0} '.format(e))
fout.write('\n')

indx = indx + n / j + (1 if (n % j > i) else 0)
</source>
</div></div>

Проведём исследование масштабируемости параллельной реализации алгоритма умножения разреженной матрицы на вектор. Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета]. Входные данные формировались на персональном компьютере в силу того, что интерпретатор на суперкомпьютере "Ломоносов" не удовлетворял нужным требованиям, и потом отправлялись на суперкомпьютер для последующей обработки.

Программа была собрана на узле компиляции суперкомпьютера "Ломоносов", с помощью компилятора ''intel/15.0.090'' и компилятора ''openmpi/1.6.5-icc'', на языке ''С++11''.

<div class="mw-collapsible mw-collapsed" style="width:100%">
Сборка производилась с помощью ''CMakeLists.txt'', его содержание прилагается:
<div class="mw-collapsible-content">
<pre>
cmake_minimum_required(VERSION 2.8)

project(task1)

set(CMAKE_CXX_STANDARD 11)

set(CXX_STANDARD_REQUIRED)

set(CMAKE_C_COMPILER mpicc)
set(CMAKE_CXX_COMPILER mpicxx)

find_package(MPI REQUIRED)

include_directories(${MPI_INCLUDE_PATH})

SET(CMAKE_CXX_COMPILER mpicc)

if(MPI_COMPILE_FLAGS)
set_target_properties(task1 PROPERTIES
COMPILE_FLAGS "${MPI_COMPILE_FLAGS}")
endif()

set(CMAKE_CXX_FLAGS "-std=c++11 -fpermissive " ${MPI_COMPILE_FLAGS})

set(SOURCE_EXE task1.cpp)

add_executable(task1 ${SOURCE_EXE})

target_link_libraries(task1)
</pre>
</div></div>

Запуск производился на вычислительных узлах суперкомпьютера "Ломоносов".

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

* число процессоров [1 : 128] по степеням 2;
* размер матрицы [1000 : 10000] с шагом 1000.

Распределение ненулевых и нулевых коэффициентов: 1:1. Однако стоит обратить внимание, что матрица генерировалась случайным образом, а значит, это лишь распределение, а не точное значение.

[[file:Blizntime.png|thumb|center|1000px|Рисунок 2. Время работы программы в зависимости от количества процессоров и размера матрицы]]

Можно заметить, что при небольшом количестве входных данных, и большом количестве процессоров эффективность распараллеливания падает до нуля, поскольку время вычисления элементов вектора <math>c</math> становится несоизмеримо малым по сравнению с временем, затраченным на пересылку в пункте (3).

[[file:Efficiency(paral).png|thumb|center|1000px|Рисунок 4. Эффективность распараллеливания в зависимости от количества процессоров и размера матрицы]]

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

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

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

Существующие реализации:

SciPy [https://docs.scipy.org/doc/scipy-0.18.1/reference/index.html],

MatLab [https://www.mathworks.com/help/matlab/math/sparse-matrix-operations.html],

Intel MKL [https://software.intel.com/en-us/articles/intel-math-kernel-library-inspector-executor-sparse-blas-routines].

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

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

2016-12-02T13:57:38Z

Blizn: /* Пункт 1.6 */

--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK) К Вашей работе есть несколько замечаний по содержанию.

== Пункт 1.1 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

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

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

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

- Если первое определение подходит только для “теоретического анализа”, то чем лучше третье?

- Второе определение, по-моему, не совсем корректно – оно слишком строгое, не понятно, что за типичный случай, почему именно используется привязка к строкам матрицы, почему именно 10 и т.д. Есть ли какие-то ссылки на литературу, где такое определение использовалось для анализа или для практических задач? Нужно пояснить смысл такого определения.

'''В качестве теоретической основы использовался Писсанецки, ссылка на него указана выше в статье. Текст использовался именно оттуда, ничего своего я не придумывала. Почему именно 10? Потому что, как было сказано, НЕЛЬЗЯ дать строгого определения тому, начиная с какого количества элементов матрица перестаёт быть плотной и начинает считаться разреженной. А значит, что нельзя сказать, что запрещено определить матрицу именно так. По этой же причине ни одно определение не хуже и не лучше, они просто даны разными людьми в попытках дать более строгое определение, чем просто "много нулей".'''

== Пункт 1.1.1.1 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

'''В данном формате вместо одного двумерного массива, используются три одномерных.'''

Плотную матрицу можно представить и, например, в виде одномерного массива. Тогда получается обычный формат хранения лучше?

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

== Пункт 1.1.1.2 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

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

Хорошо бы привести примеры матричных операций, для которых неупорядоченное представление дает выигрыш, по сравнению с упорядоченным.

== Пункт 1.1.2 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

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

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

'''Это просто примеры, и рассмотрение их значимости и примечательности не относится к теме разреженных матриц.'''

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

Достоинство этих процедур, по сравнению с какими? В некоторых итерационных методах, например, требуется также умножение и транспонированной матрицы на вектор.

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

== Пункт 1.6 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

'''Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размером <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в последовательном (наиболее быстром) варианте требуется:'''

''' <math>l</math> сложений,'''

''' <math>l</math> умножений.'''

Что здесь понимается как «наиболее быстрый вариант»? Есть ли какие-то более медленные альтернативы? Оценка <math>l</math> сложений похоже не совсем правильная. Например, сколько нужно сложений для матрицы с одним ненулевым элементом в алгоритме 1.5?

'''Медленные альтернативы есть везде. Ту же сортировку можно делать обезьянью, а можно сортировать qsort'ом.'''

== Пункт 1.8 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

Можно ли записать параллельный алгоритм, использующий больше чем n процессоров, где n - число строк(столбцов)?

'''Можно, но не имеет смысла. Как было указано ниже в пункте 2.4 при большом количестве процессоров и малом количестве данных основные временные затраты приходятся именно на пересылки, а не на вычисления, поэтому логично свести их к минимуму. При увеличении числа процессоров число пересылок только увеличится и, разумеется, программа станет работать только дольше.'''

== Пункт 1.10 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

'''Таким образом хранение в формате RR(C) не является эффективным для матриц, в которых <math>l > \frac{xnm - y(n+1)}{x+y}</math>.'''

Нужно уточнить по какому критерию сравнивается «эффективность». Просто занимает меньше памяти? Или, например, сравнивается скорость доступа к памяти или время выполнения матричных операций?

== Пункт 2.4 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

Нужно явно написать в тексте, что рассматривался целочисленный алгоритм. Почему не вещественное матрично-векторное умножение? Приводимые оценки для числа операций алгоритма (п.1.6, 1.8) разве учитывают вспомогательные целочисленные операции, например, для организации циклов?

'''Конечно нет, потому что всё это - особенности реализации, зависящие от неё (там же не учитывается время на пересылки, время на вывод данных, на их считывание и так далее). Описание алгоритма не зависит от реализации. Если речь идёт в вычисление "старта" и количестве элементов в строке - это аналог вычисление IAA и IAB, на которые слишком малочисленны, а в пункте 1.6 указано, что "Умножения и сложения составляют основную часть алгоритма."'''

'''Целочисленное - потому что захотелось и лично мне так было удобнее при ручном тестировании правильности работы кода. Везде, где идёт определение элементов матрицы и вектора, можно заменить int на double, я считаю, этот вопрос не является принципиальным.'''

'''размер матрицы [1000 : 10000] с шагом 1000.'''

Здесь размер матрицы – это число ненулевых элементов? Нужно привести и размер матрицы, и число ненулевых элементов.

'''Здесь размер матрицы - это её размерность. Матрицы генерировались случайно, а данные стёрты и восстановить их невозможно, а значит я не могу указать точно, сколько именно было ненулевых элементов. Впрочем, из генератора видно, что число нулевых и ненулевых элементов было где-то 50/50.'''

Какая структура матрицы, которая использовалась в экспериментах? Какова доля операций чтения из файла в экспериментах?

'''Что значит "структура матрицы"? Матрица, как я и писала, генерировалась случайно с помощью функций языка Python. Что же касается чтения в самом начале указано, что каждый процессор считает кусок данных, предоставленных ему. Происходит это 1 раз и в самом начале.'''

== Статья [[Участник:Blizn/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор.]] ==

=== Отсутствующие части ===
* Нет информации в разделе 2.7. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:47, 27 октября 2016 (MSK)
* Не заполнен раздел 2.4 описания. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:27, 16 ноября 2016 (MSK)

=== Замечания по тексту ===
* В разделе 1.4 не нужно дублировать написанное в разделе 1.3, а требуется описание алгоритма на верхнем уровне. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:47, 27 октября 2016 (MSK)
** Замечание не исправлено. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:04, 2 ноября 2016 (MSK)
* В разделе 2.4 не приведены все параметры запуска теста - какой компилятор, с какими опциями использовался, какие версии библиотек, на каких узлах проводился запуск и т.д. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 11:09, 30 ноября 2016 (MSK)
* В разделе 2.4 не приведён сам текст использованной в экспериментах реализации алгоритма. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 11:09, 30 ноября 2016 (MSK)

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

2016-12-02T13:52:46Z

Blizn: /* Формат RR(C)U */

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>O(l)</math>
| pf_height = <math>O(m)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>2l+m+n+1</math>
| output_data = <math>n</math>
}}
Выполнила: [[Участник:Blizn|И.В. Близнякова]] (611 группа).

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

== Общее описание алгоритма<ref>С.Писсанецки. Технология разреженных матриц. - М.: Мир, 1988.</ref> ==
'''Разрежённая матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается '''''плотной'''''.

Среди специалистов нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:
* есть <math>O(n)</math>. Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;
* в каждой строке не превышает 10 в типичном случае;
* ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.
* таково, что для данного алгоритма и вычислительной системы имеет смысл извлекать выгоду из наличия в ней нулей.

=== Хранение разреженной матрицы ===
==== Формат RR(C)O ====
Рассмотрим сначала формат '''RR(C)O'''. Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Ordered"'' (строчное представление, полное и упорядоченное). В данном формате вместо одного двумерного массива, используются три одномерных. Значения ненулевых элементов матрицы и соответствующие им столбцовые индексы хранятся в этом формате по строкам в двух массивах <math>AN</math> и <math>JA</math>. Массив указателей <math>IA</math>, используется для ссылки на компоненты массивов <math>AN</math> и <math>JA</math>, с которых начинается описание очередной строки. Последняя компонента массива <math>IA</math> содержит указатель первой свободной компоненты в массивах <math>AN</math> и <math>JA</math>, т.е. равна числу ненулевых элементов матрицы, увеличенному на единицу. Здесь уместно привести пример.

Рассмотрим матрицу <math>A</math>:
:<math>\begin{pmatrix}
0 & 0 & 0 & 2 & 0 \\
1 & 0 & 3 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 \\
0 & 6 & 0 & 0 & 0 \\
0 & 0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
тогда ее представление в формате '''RR(C)O''' будет иметь вид:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 1 3 2 3 ]
AN = [ 2 1 3 6 4 ]
Т.е. массив <math>AN</math> содержит все не нулевые элементы исходной матрицы <math>A</math>, массив <math>JA</math> номер столбца в котором находится соответствующий элемент из <math>AN</math> и наконец массив <math>IA</math> содержит номер с которого начинается описание элементов в массивах <math>JA</math> и <math>AN</math>. Таким образом информация об элементах 2-ой строки матрицы хранится в элементах с <math>IA[2] = 2</math> по <math>IA[3] - 1 = 3</math> включительно массивов <math>JA</math> и <math>AN</math>. Можно обратить внимание, что <math>IA[3] = IA[4] = 4</math>, а это означает, что 3-я строка матрицы <math>A</math> нулевая.

В общем случае описание <math>r</math>-й строки матрицы A хранится в компонентах с <math>IA[r]</math> до <math>IA[r + 1] - 1</math> включительно массивов <math>AN</math> и <math>JA</math>. Если <math>IA[r + 1] = IA[r]</math>, то это означает, что <math>r</math>-я строка нулевая. Количество элементов в массиве <math>IA</math> на единицу больше, чем число строк исходной матрицы, а количество элементов в массивах <math>JA</math> и <math>AN</math> равно числу ненулевых элементов исходной матрицы.

Данный способ представления называют ''полным'', поскольку представлена вся матрица <math>A</math>, ''упорядоченным'', поскольку элементы каждой строки матрицы <math>A</math> хранятся в соответствии с возрастанием столбцовых индексов, и строчным, поскольку информация о матрице <math>A</math> указывается по строкам.

Массивы <math>IA</math> и <math>JA</math> представляют портрет (структуру) матрицы <math>A</math>, задаваемый как множество списков смежности ассоциированного с <math>A</math> графа. Если алгоритм, реализующий какую-либо операцию над разреженными матрицами, разбит на этапы символической обработки, на котором определяется портрет результирующей матрицы, и численной обработки, на котором определяются значения элементов результирующей матрицы, то массивы <math>IA</math> и <math>JA</math> заполняются на первом этапе, а массив <math>AN</math> - на втором.

==== Формат RR(C)U ====

Рассмотрим теперь формат '''RR(C)U'''.

Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Unordered"'' (строчное представление, полное, но неупорядоченное). Формат '''RR(C)U''' отличается от '''RR(C)O''' тем, что в данном случае соблюдается упорядоченность строк, но внутри каждой строки элементы исходных матриц могут храниться в произвольном порядке. Для матрицы <math>A</math> нашего примера вполне можно было бы использовать и строчное представление, полное, но неупорядоченное такое:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 3 1 2 3 ]
AN = [ 2 1 3 6 4 ]
Такие неупорядоченные представления могут быть очень удобны в практических вычислениях. Результаты большинства матричных операций получаются неупорядоченными (например, операции вставки и удаления новых коэффициентов), а их упорядочение стоило бы значительных затрат машинного времени. В то же время, за немногими исключениями, алгоритмы для разреженных матриц не требуют, чтобы их представления были упорядоченными.

==== Замечания ====

Несколько замечаний по поводу рассмотренных форматов представления:
# Очевидно, что представление матрицы в формате '''RR(C)O''' так же является и представлением в формате '''RR(C)U''', но не наоборот.
# Из представления матрицы в формате '''RR(C)''' нельзя получить информацию о точном количестве столбцов исходной матрицы.
# Целесообразно (в вопросе экономии памяти) использовать представления '''RR(C)''' в случае, если матрица содержит значительное число нулевых элементов.

=== Умножение разреженной матрицы на вектор ===

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

Мы рассмотрим умножение разреженной матрицы общего вида, хранимой в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math> на заполненный вектор-столбец.

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

Исходные данные: разреженная матрица общего вида <math>A</math> с элементами <math>a_{ij}</math> (<math>i = 1,...,n</math> и <math>j = 1,...,m</math>). Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> (<math>j =1,...,m</math>).

Вычисляемые данные: заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

Формулы метода:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

где <math>l_{i}</math> - количество ненулевых элементов строки <math>i</math> матрицы <math>A</math>, <math>j(k)</math> - индекс <math>k</math>-го ненулевого элемента матрицы <math>A</math>.

== Вычислительное ядро алгоритма ==
Вычислительное ядро последовательной версии умножения разреженной матрицы на вектор можно составить из множественных (всего их <math>n</math>) вычислений скалярных произведений строк матрицы:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>.

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

Как записано и в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют множественные (всего <math>n</math>) вычисления сумм:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

которые могут вычисляться в произвольном порядке.

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

Далее предполагаем, что разреженная матрица общего вида <math>A</math> хранится в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>.
Последовательность исполнения метода следующая:

Выполнять для <math>i</math> от <math>1</math> до <math>n</math>
# <math>c_{i} = 0</math>
# <math>IAA = IA[i]</math>
# <math>IAB = IA[i + 1] - 1</math>
# <math>c_{i} = \sum\limits_{k = IAA}^{IAB} AN[k]b_{JA[k]}</math>.
После этого (если <math>i \le n</math>) происходит переход к шагу 1 с бо́льшим <math>i</math>.

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размером <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в последовательном (наиболее быстром) варианте требуется:

* <math>O(l)</math> сложений,
* <math>O(l)</math> умножений.

Умножения и сложения составляют ''основную часть алгоритма''.

При классификации по последовательной сложности, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам <math>O(l)</math>.

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

Опишем [[глоссарий#Граф алгоритма|граф алгоритма]]<ref>Воеводин В.В. Математические основы параллельных вычислений// М.: Изд. Моск. ун-та, 1991. 345 с.</ref><ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. – СПб.: БХВ - Петербург, 2002. – 608 с.</ref><ref>Фролов А.В.. Принципы построения и описание языка Сигма. Препринт ОВМ АН N 236. М.: ОВМ АН СССР, 1989.</ref> как аналитически, так и в виде рисунка.

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

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

* <math>i</math> — меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math> - элемент ''входных данных'', а именно <math>AN[IA_{i}+j-1]</math>.
* <math>b</math> - элемент ''входных данных'', а именно <math>b[IA_{i}+j-1]</math>.

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

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция <math>a + b</math>.
Естественно введённые координаты области таковы:
* <math>i</math> - меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> - меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math>:
** при <math>j = 1</math> - результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j)</math>;
** при <math>j > 1</math> - результат срабатывания операции, соответствующей вершине из второй группы, с координатами <math>(i, j - 1)</math>;
* <math>b</math> — результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j + 1)</math>.

Результат срабатывания операции:
* при <math>j < k - 1</math> является ''промежуточным данным'' алгоритма;
* при <math>j = k - 1</math> является ''выходным данным'' <math>c_{i}</math>.

Описанный граф можно посмотреть на рис.1. Здесь вершины первой группы обозначены красным цветом и отмечены знаком умножения, вершины второй - зелёным цветом и знаком сложения. Вершины, соответствующие входным данным обозначены белым цветом и выходным - синим.
[[file:Bliznalg.png|thumb|center|1000px|Рисунок 1. Граф алгоритма умножения разреженной матрицы на вектор]]

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размерности <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в параллельном варианте требуется последовательно выполнить следующие ярусы:

* Не более чем <math>m</math> сложений и умножений (<math>n</math> вычислений в каждом из ярусов)

При классификации по высоте ЯПФ, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам со сложностью <math>O(m)</math>. При классификации по ширине ЯПФ его сложность будет <math>O(n)</math>.

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

'''Входные данные''': разреженная матрица общего вида <math>A</math> размерности <math>n \times m</math>, хранимая в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>. Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> размерности <math>m \times 1</math>.

'''Объём входных данных''': <math>2l+m+n+1</math>, где <math>l</math> - количество ненулевых элементов в матрице <math>A</math>.

'''Выходные данные''': заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

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

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

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

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

Пусть <math>l</math> - количество ненулевых элементов матрицы <math>A</math> размерности <math>n \times m</math>. Пусть <math>x</math> - объем памяти, используемый для хранения значения элемента матрицы, <math>y</math> - объём памяти, используемый для хранения номера столбца или строки. В таком случае для хранения матрицы в стандартном представлении нам потребуется объем памяти, равный <math>x \cdot n \cdot m</math>, для хранения в формате '''RR(C)''' - <math>y(n + 1) + (x + y)l</math>. Таким образом хранение в формате '''RR(C)''' не является эффективным (в вопросе используемой памяти) для матриц, в которых <math>l > \frac{xnm - y(n+1)}{x+y}</math>.

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

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

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

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

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

Параллельная реализация алгоритма заключается в следующем:

# Каждый процессор считывает входные данные из файла, зависящего от его номера. Данные имеют вид: вектор <math>b</math> и набор определённых строк матрицы <math>A</math> в формате '''RR(C)U''' в зависимости от номера процессора и их числа;
# Процессоры проводят вычисления значений вектора <math>c</math> в зависимости от имеющихся данных;
# Все процессоры отправляют результаты вычисления процессору, выбранному главным, и главный процессор выводит результат вычислений.

<div class="mw-collapsible mw-collapsed" style="width:100%">
Текст использованной в экспериментах реализации (язык ''С++''):
<div class="mw-collapsible-content">
<source lang="c++">
#include <mpi.h>
#include <memory>
#include <iostream>
#include <vector>
#include <sstream>
#include <fstream>
#include <string>
#include <iterator>

typedef std::shared_ptr<std::vector<std::vector<int> > > MyData;

MyData ReadData(const std::string& data_path) {
std::ifstream file_stream;
MyData retval(new std::vector<std::vector<int> >());
file_stream.open(data_path);

while (!file_stream.eof()) {
std::string str;
std::getline(file_stream, str);

std::istringstream iss(str);
auto temp_1 = (std::istream_iterator<std::string>(iss));
auto temp_2 = (std::istream_iterator<std::string>());

std::vector<std::string> coordinates{ temp_1, temp_2};
retval->push_back(std::vector<int>());
for (auto& e : coordinates) {
retval->back().push_back(std::stoi(e));
}
}

return retval;
}

// input: vector b, vector ia, vector ja, vector an
int main(int argc, char** argv){
MPI_Init(&argc, &argv);
int pid, np;
MPI_Status *s = new MPI_Status;
MPI_Comm_rank(MPI_COMM_WORLD, &pid);
MPI_Comm_size(MPI_COMM_WORLD, &np);
if (argc == 2){
int n;
int indx = 0;
int stp;
double strttime = MPI_Wtime();
std::vector<int> b;
std::vector<int> ia;
std::vector<int> ja;
std::vector<int> an;
auto data = ReadData("data_" + std::to_string(static_cast<long long>(pid)) + ".txt");
b = (*data)[0];
ia = (*data)[1];
ja = (*data)[2];
an = (*data)[3];
n = (*data)[0].size();
std::vector<int> c;
stp = n / np + ((n % np > pid) ? 1 : 0);
if (pid == 0){
c.resize(n, 0);
}
else{
c.resize(stp, 0);
}
for (int i = 0; i < stp; i++){
int strt = ia[i] - ia[0];
int lstr = ia[i + 1] - ia[i];
for (int j = 0; j < lstr; j++){
c[i] += an[strt + j] * b[ja[strt + j]];
}
}
if (pid == 0){
for (int i = 1; i < np; i++){
indx += n / np + ((n % np > i - 1) ? 1 : 0);
stp = n / np + ((n % np > i) ? 1 : 0);
MPI_Recv(&c[indx], stp, MPI_INT, i, 0, MPI_COMM_WORLD, s);
}
}
else{
MPI_Send(&c[0], stp, MPI_INT, 0, 0, MPI_COMM_WORLD);
}
if (pid == 0){
for (int e : c) {
std::cout << e << "\n";
}
double endtime = MPI_Wtime();
std::cout << "Success! Time = " << endtime - strttime << "\n";
}
}
MPI_Finalize();
return 0;
}
</source>
</div></div>

<div class="mw-collapsible mw-collapsed" style="width:100%">
Для формирования входных данных использовался следующий алгоритм (язык ''Python''):
<div class="mw-collapsible-content">
<source lang="python">
from scipy import sparse as sp
from numpy.random import randint
from os import mkdir
from os.path import join as jn

n = 10000
np = [1, 2, 4, 8, 16, 32, 64, 128]

a = sp.csr_matrix(randint(0, 2, (n, n)))
b = randint(1, 5, n)
i = 0

for j in np:
mkdir('data_' + str(j))
indx = 0
for i in range(0, j):
stp = n / j + (1 if (n % j > i) else 0)
ael = a.indptr[indx + stp] - a.indptr[indx]
strt = a.indptr[indx]
with open(jn('data_' + str(j), 'data_' + str(i) + '.txt'), 'w') as fout:

for e in b:
fout.write('{0} '.format(e))
fout.write('\n')

s = a.indptr[indx:indx + stp + 1]
for e in s:
fout.write('{0} '.format(e))
fout.write('\n')

s = a.indices[strt:strt + ael]
for e in s:
fout.write('{0} '.format(e))
fout.write('\n')

s = a.data[strt:strt + ael]
for e in s:
fout.write('{0} '.format(e))
fout.write('\n')

indx = indx + n / j + (1 if (n % j > i) else 0)
</source>
</div></div>

Проведём исследование масштабируемости параллельной реализации алгоритма умножения разреженной матрицы на вектор. Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета]. Входные данные формировались на персональном компьютере в силу того, что интерпретатор на суперкомпьютере "Ломоносов" не удовлетворял нужным требованиям, и потом отправлялись на суперкомпьютер для последующей обработки.

Программа была собрана на узле компиляции суперкомпьютера "Ломоносов", с помощью компилятора ''intel/15.0.090'' и компилятора ''openmpi/1.6.5-icc'', на языке ''С++11''.

<div class="mw-collapsible mw-collapsed" style="width:100%">
Сборка производилась с помощью ''CMakeLists.txt'', его содержание прилагается:
<div class="mw-collapsible-content">
<pre>
cmake_minimum_required(VERSION 2.8)

project(task1)

set(CMAKE_CXX_STANDARD 11)

set(CXX_STANDARD_REQUIRED)

set(CMAKE_C_COMPILER mpicc)
set(CMAKE_CXX_COMPILER mpicxx)

find_package(MPI REQUIRED)

include_directories(${MPI_INCLUDE_PATH})

SET(CMAKE_CXX_COMPILER mpicc)

if(MPI_COMPILE_FLAGS)
set_target_properties(task1 PROPERTIES
COMPILE_FLAGS "${MPI_COMPILE_FLAGS}")
endif()

set(CMAKE_CXX_FLAGS "-std=c++11 -fpermissive " ${MPI_COMPILE_FLAGS})

set(SOURCE_EXE task1.cpp)

add_executable(task1 ${SOURCE_EXE})

target_link_libraries(task1)
</pre>
</div></div>

Запуск производился на вычислительных узлах суперкомпьютера "Ломоносов".

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

* число процессоров [1 : 128] по степеням 2;
* размер матрицы [1000 : 10000] с шагом 1000.

[[file:Blizntime.png|thumb|center|1000px|Рисунок 2. Время работы программы в зависимости от количества процессоров и размера матрицы]]

Можно заметить, что при небольшом количестве входных данных, и большом количестве процессоров эффективность распараллеливания падает до нуля, поскольку время вычисления элементов вектора <math>c</math> становится несоизмеримо малым по сравнению с временем, затраченным на пересылку в пункте (3).

[[file:Efficiency(paral).png|thumb|center|1000px|Рисунок 4. Эффективность распараллеливания в зависимости от количества процессоров и размера матрицы]]

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

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

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

Существующие реализации:

SciPy [https://docs.scipy.org/doc/scipy-0.18.1/reference/index.html],

MatLab [https://www.mathworks.com/help/matlab/math/sparse-matrix-operations.html],

Intel MKL [https://software.intel.com/en-us/articles/intel-math-kernel-library-inspector-executor-sparse-blas-routines].

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

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

2016-12-02T13:34:10Z

Blizn: /* Пункт 2.4 */

--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK) К Вашей работе есть несколько замечаний по содержанию.

== Пункт 1.1 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

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

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

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

- Если первое определение подходит только для “теоретического анализа”, то чем лучше третье?

- Второе определение, по-моему, не совсем корректно – оно слишком строгое, не понятно, что за типичный случай, почему именно используется привязка к строкам матрицы, почему именно 10 и т.д. Есть ли какие-то ссылки на литературу, где такое определение использовалось для анализа или для практических задач? Нужно пояснить смысл такого определения.

'''В качестве теоретической основы использовался Писсанецки, ссылка на него указана выше в статье. Текст использовался именно оттуда, ничего своего я не придумывала. Почему именно 10? Потому что, как было сказано, НЕЛЬЗЯ дать строгого определения тому, начиная с какого количества элементов матрица перестаёт быть плотной и начинает считаться разреженной. А значит, что нельзя сказать, что запрещено определить матрицу именно так. По этой же причине ни одно определение не хуже и не лучше, они просто даны разными людьми в попытках дать более строгое определение, чем просто "много нулей".'''

== Пункт 1.1.1.1 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

'''В данном формате вместо одного двумерного массива, используются три одномерных.'''

Плотную матрицу можно представить и, например, в виде одномерного массива. Тогда получается обычный формат хранения лучше?

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

== Пункт 1.1.1.2 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

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

Хорошо бы привести примеры матричных операций, для которых неупорядоченное представление дает выигрыш, по сравнению с упорядоченным.

== Пункт 1.1.2 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

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

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

'''Это просто примеры, и рассмотрение их значимости и примечательности не относится к теме разреженных матриц.'''

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

Достоинство этих процедур, по сравнению с какими? В некоторых итерационных методах, например, требуется также умножение и транспонированной матрицы на вектор.

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

== Пункт 1.6 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

'''Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размером <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в последовательном (наиболее быстром) варианте требуется:'''

''' <math>l</math> сложений,'''

''' <math>l</math> умножений.'''

Что здесь понимается как «наиболее быстрый вариант»? Есть ли какие-то более медленные альтернативы? Оценка <math>l</math> сложений похоже не совсем правильная. Например, сколько нужно сложений для матрицы с одним ненулевым элементом в алгоритме 1.5?

== Пункт 1.8 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

Можно ли записать параллельный алгоритм, использующий больше чем n процессоров, где n - число строк(столбцов)?

'''Можно, но не имеет смысла. Как было указано ниже в пункте 2.4 при большом количестве процессоров и малом количестве данных основные временные затраты приходятся именно на пересылки, а не на вычисления, поэтому логично свести их к минимуму. При увеличении числа процессоров число пересылок только увеличится и, разумеется, программа станет работать только дольше.'''

== Пункт 1.10 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

'''Таким образом хранение в формате RR(C) не является эффективным для матриц, в которых <math>l > \frac{xnm - y(n+1)}{x+y}</math>.'''

Нужно уточнить по какому критерию сравнивается «эффективность». Просто занимает меньше памяти? Или, например, сравнивается скорость доступа к памяти или время выполнения матричных операций?

== Пункт 2.4 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

Нужно явно написать в тексте, что рассматривался целочисленный алгоритм. Почему не вещественное матрично-векторное умножение? Приводимые оценки для числа операций алгоритма (п.1.6, 1.8) разве учитывают вспомогательные целочисленные операции, например, для организации циклов?

'''Конечно нет, потому что всё это - особенности реализации, зависящие от неё (там же не учитывается время на пересылки, время на вывод данных, на их считывание и так далее). Описание алгоритма не зависит от реализации. Если речь идёт в вычисление "старта" и количестве элементов в строке - это аналог вычисление IAA и IAB, на которые слишком малочисленны, а в пункте 1.6 указано, что "Умножения и сложения составляют основную часть алгоритма."'''

'''Целочисленное - потому что захотелось и лично мне так было удобнее при ручном тестировании правильности работы кода. Везде, где идёт определение элементов матрицы и вектора, можно заменить int на double, я считаю, этот вопрос не является принципиальным.'''

'''размер матрицы [1000 : 10000] с шагом 1000.'''

Здесь размер матрицы – это число ненулевых элементов? Нужно привести и размер матрицы, и число ненулевых элементов.

'''Здесь размер матрицы - это её размерность. Матрицы генерировались случайно, а данные стёрты и восстановить их невозможно, а значит я не могу указать точно, сколько именно было ненулевых элементов. Впрочем, из генератора видно, что число нулевых и ненулевых элементов было где-то 50/50.'''

Какая структура матрицы, которая использовалась в экспериментах? Какова доля операций чтения из файла в экспериментах?

'''Что значит "структура матрицы"? Матрица, как я и писала, генерировалась случайно с помощью функций языка Python. Что же касается чтения в самом начале указано, что каждый процессор считает кусок данных, предоставленных ему. Происходит это 1 раз и в самом начале.'''

== Статья [[Участник:Blizn/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор.]] ==

=== Отсутствующие части ===
* Нет информации в разделе 2.7. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:47, 27 октября 2016 (MSK)
* Не заполнен раздел 2.4 описания. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:27, 16 ноября 2016 (MSK)

=== Замечания по тексту ===
* В разделе 1.4 не нужно дублировать написанное в разделе 1.3, а требуется описание алгоритма на верхнем уровне. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:47, 27 октября 2016 (MSK)
** Замечание не исправлено. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:04, 2 ноября 2016 (MSK)
* В разделе 2.4 не приведены все параметры запуска теста - какой компилятор, с какими опциями использовался, какие версии библиотек, на каких узлах проводился запуск и т.д. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 11:09, 30 ноября 2016 (MSK)
* В разделе 2.4 не приведён сам текст использованной в экспериментах реализации алгоритма. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 11:09, 30 ноября 2016 (MSK)

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

2016-12-02T13:14:32Z

Blizn: /* Пункт 1.8 */

--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK) К Вашей работе есть несколько замечаний по содержанию.

== Пункт 1.1 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

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

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

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

- Если первое определение подходит только для “теоретического анализа”, то чем лучше третье?

- Второе определение, по-моему, не совсем корректно – оно слишком строгое, не понятно, что за типичный случай, почему именно используется привязка к строкам матрицы, почему именно 10 и т.д. Есть ли какие-то ссылки на литературу, где такое определение использовалось для анализа или для практических задач? Нужно пояснить смысл такого определения.

'''В качестве теоретической основы использовался Писсанецки, ссылка на него указана выше в статье. Текст использовался именно оттуда, ничего своего я не придумывала. Почему именно 10? Потому что, как было сказано, НЕЛЬЗЯ дать строгого определения тому, начиная с какого количества элементов матрица перестаёт быть плотной и начинает считаться разреженной. А значит, что нельзя сказать, что запрещено определить матрицу именно так. По этой же причине ни одно определение не хуже и не лучше, они просто даны разными людьми в попытках дать более строгое определение, чем просто "много нулей".'''

== Пункт 1.1.1.1 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

'''В данном формате вместо одного двумерного массива, используются три одномерных.'''

Плотную матрицу можно представить и, например, в виде одномерного массива. Тогда получается обычный формат хранения лучше?

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

== Пункт 1.1.1.2 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

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

Хорошо бы привести примеры матричных операций, для которых неупорядоченное представление дает выигрыш, по сравнению с упорядоченным.

== Пункт 1.1.2 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

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

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

'''Это просто примеры, и рассмотрение их значимости и примечательности не относится к теме разреженных матриц.'''

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

Достоинство этих процедур, по сравнению с какими? В некоторых итерационных методах, например, требуется также умножение и транспонированной матрицы на вектор.

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

== Пункт 1.6 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

'''Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размером <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в последовательном (наиболее быстром) варианте требуется:'''

''' <math>l</math> сложений,'''

''' <math>l</math> умножений.'''

Что здесь понимается как «наиболее быстрый вариант»? Есть ли какие-то более медленные альтернативы? Оценка <math>l</math> сложений похоже не совсем правильная. Например, сколько нужно сложений для матрицы с одним ненулевым элементом в алгоритме 1.5?

== Пункт 1.8 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

Можно ли записать параллельный алгоритм, использующий больше чем n процессоров, где n - число строк(столбцов)?

'''Можно, но не имеет смысла. Как было указано ниже в пункте 2.4 при большом количестве процессоров и малом количестве данных основные временные затраты приходятся именно на пересылки, а не на вычисления, поэтому логично свести их к минимуму. При увеличении числа процессоров число пересылок только увеличится и, разумеется, программа станет работать только дольше.'''

== Пункт 1.10 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

'''Таким образом хранение в формате RR(C) не является эффективным для матриц, в которых <math>l > \frac{xnm - y(n+1)}{x+y}</math>.'''

Нужно уточнить по какому критерию сравнивается «эффективность». Просто занимает меньше памяти? Или, например, сравнивается скорость доступа к памяти или время выполнения матричных операций?

== Пункт 2.4 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

Нужно явно написать в тексте, что рассматривался целочисленный алгоритм. Почему не вещественное матрично-векторное умножение? Приводимые оценки для числа операций алгоритма (п.1.6, 1.8) разве учитывают вспомогательные целочисленные операции, например, для организации циклов?

'''размер матрицы [1000 : 10000] с шагом 1000.'''

Здесь размер матрицы – это число ненулевых элементов? Нужно привести и размер матрицы, и число ненулевых элементов.

Какая структура матрицы, которая использовалась в экспериментах? Какова доля операций чтения из файла в экспериментах?

== Статья [[Участник:Blizn/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор.]] ==

=== Отсутствующие части ===
* Нет информации в разделе 2.7. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:47, 27 октября 2016 (MSK)
* Не заполнен раздел 2.4 описания. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:27, 16 ноября 2016 (MSK)

=== Замечания по тексту ===
* В разделе 1.4 не нужно дублировать написанное в разделе 1.3, а требуется описание алгоритма на верхнем уровне. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:47, 27 октября 2016 (MSK)
** Замечание не исправлено. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:04, 2 ноября 2016 (MSK)
* В разделе 2.4 не приведены все параметры запуска теста - какой компилятор, с какими опциями использовался, какие версии библиотек, на каких узлах проводился запуск и т.д. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 11:09, 30 ноября 2016 (MSK)
* В разделе 2.4 не приведён сам текст использованной в экспериментах реализации алгоритма. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 11:09, 30 ноября 2016 (MSK)

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

2016-12-02T13:09:09Z

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

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>O(l)</math>
| pf_height = <math>O(m)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>2l+m+n+1</math>
| output_data = <math>n</math>
}}
Выполнила: [[Участник:Blizn|И.В. Близнякова]] (611 группа).

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

== Общее описание алгоритма<ref>С.Писсанецки. Технология разреженных матриц. - М.: Мир, 1988.</ref> ==
'''Разрежённая матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается '''''плотной'''''.

Среди специалистов нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:
* есть <math>O(n)</math>. Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;
* в каждой строке не превышает 10 в типичном случае;
* ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.
* таково, что для данного алгоритма и вычислительной системы имеет смысл извлекать выгоду из наличия в ней нулей.

=== Хранение разреженной матрицы ===
==== Формат RR(C)O ====
Рассмотрим сначала формат '''RR(C)O'''. Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Ordered"'' (строчное представление, полное и упорядоченное). В данном формате вместо одного двумерного массива, используются три одномерных. Значения ненулевых элементов матрицы и соответствующие им столбцовые индексы хранятся в этом формате по строкам в двух массивах <math>AN</math> и <math>JA</math>. Массив указателей <math>IA</math>, используется для ссылки на компоненты массивов <math>AN</math> и <math>JA</math>, с которых начинается описание очередной строки. Последняя компонента массива <math>IA</math> содержит указатель первой свободной компоненты в массивах <math>AN</math> и <math>JA</math>, т.е. равна числу ненулевых элементов матрицы, увеличенному на единицу. Здесь уместно привести пример.

Рассмотрим матрицу <math>A</math>:
:<math>\begin{pmatrix}
0 & 0 & 0 & 2 & 0 \\
1 & 0 & 3 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 \\
0 & 6 & 0 & 0 & 0 \\
0 & 0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
тогда ее представление в формате '''RR(C)O''' будет иметь вид:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 1 3 2 3 ]
AN = [ 2 1 3 6 4 ]
Т.е. массив <math>AN</math> содержит все не нулевые элементы исходной матрицы <math>A</math>, массив <math>JA</math> номер столбца в котором находится соответствующий элемент из <math>AN</math> и наконец массив <math>IA</math> содержит номер с которого начинается описание элементов в массивах <math>JA</math> и <math>AN</math>. Таким образом информация об элементах 2-ой строки матрицы хранится в элементах с <math>IA[2] = 2</math> по <math>IA[3] - 1 = 3</math> включительно массивов <math>JA</math> и <math>AN</math>. Можно обратить внимание, что <math>IA[3] = IA[4] = 4</math>, а это означает, что 3-я строка матрицы <math>A</math> нулевая.

В общем случае описание <math>r</math>-й строки матрицы A хранится в компонентах с <math>IA[r]</math> до <math>IA[r + 1] - 1</math> включительно массивов <math>AN</math> и <math>JA</math>. Если <math>IA[r + 1] = IA[r]</math>, то это означает, что <math>r</math>-я строка нулевая. Количество элементов в массиве <math>IA</math> на единицу больше, чем число строк исходной матрицы, а количество элементов в массивах <math>JA</math> и <math>AN</math> равно числу ненулевых элементов исходной матрицы.

Данный способ представления называют ''полным'', поскольку представлена вся матрица <math>A</math>, ''упорядоченным'', поскольку элементы каждой строки матрицы <math>A</math> хранятся в соответствии с возрастанием столбцовых индексов, и строчным, поскольку информация о матрице <math>A</math> указывается по строкам.

Массивы <math>IA</math> и <math>JA</math> представляют портрет (структуру) матрицы <math>A</math>, задаваемый как множество списков смежности ассоциированного с <math>A</math> графа. Если алгоритм, реализующий какую-либо операцию над разреженными матрицами, разбит на этапы символической обработки, на котором определяется портрет результирующей матрицы, и численной обработки, на котором определяются значения элементов результирующей матрицы, то массивы <math>IA</math> и <math>JA</math> заполняются на первом этапе, а массив <math>AN</math> - на втором.

==== Формат RR(C)U ====

Рассмотрим теперь формат '''RR(C)U'''.

Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Unordered"'' (строчное представление, полное, но неупорядоченное). Формат '''RR(C)U''' отличается от '''RR(C)O''' тем, что в данном случае соблюдается упорядоченность строк, но внутри каждой строки элементы исходных матриц могут храниться в произвольном порядке. Для матрицы <math>A</math> нашего примера вполне можно было бы использовать и строчное представление, полное, но неупорядоченное такое:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 3 1 2 3 ]
AN = [ 2 1 3 6 4 ]
Такие неупорядоченные представления могут быть очень удобны в практических вычислениях. Результаты большинства матричных операций получаются неупорядоченными, а их упорядочение стоило бы значительных затрат машинного времени. В то же время, за немногими исключениями, алгоритмы для разреженных матриц не требуют, чтобы их представления были упорядоченными.

==== Замечания ====

Несколько замечаний по поводу рассмотренных форматов представления:
# Очевидно, что представление матрицы в формате '''RR(C)O''' так же является и представлением в формате '''RR(C)U''', но не наоборот.
# Из представления матрицы в формате '''RR(C)''' нельзя получить информацию о точном количестве столбцов исходной матрицы.
# Целесообразно (в вопросе экономии памяти) использовать представления '''RR(C)''' в случае, если матрица содержит значительное число нулевых элементов.

=== Умножение разреженной матрицы на вектор ===

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

Мы рассмотрим умножение разреженной матрицы общего вида, хранимой в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math> на заполненный вектор-столбец.

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

Исходные данные: разреженная матрица общего вида <math>A</math> с элементами <math>a_{ij}</math> (<math>i = 1,...,n</math> и <math>j = 1,...,m</math>). Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> (<math>j =1,...,m</math>).

Вычисляемые данные: заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

Формулы метода:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

где <math>l_{i}</math> - количество ненулевых элементов строки <math>i</math> матрицы <math>A</math>, <math>j(k)</math> - индекс <math>k</math>-го ненулевого элемента матрицы <math>A</math>.

== Вычислительное ядро алгоритма ==
Вычислительное ядро последовательной версии умножения разреженной матрицы на вектор можно составить из множественных (всего их <math>n</math>) вычислений скалярных произведений строк матрицы:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>.

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

Как записано и в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют множественные (всего <math>n</math>) вычисления сумм:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

которые могут вычисляться в произвольном порядке.

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

Далее предполагаем, что разреженная матрица общего вида <math>A</math> хранится в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>.
Последовательность исполнения метода следующая:

Выполнять для <math>i</math> от <math>1</math> до <math>n</math>
# <math>c_{i} = 0</math>
# <math>IAA = IA[i]</math>
# <math>IAB = IA[i + 1] - 1</math>
# <math>c_{i} = \sum\limits_{k = IAA}^{IAB} AN[k]b_{JA[k]}</math>.
После этого (если <math>i \le n</math>) происходит переход к шагу 1 с бо́льшим <math>i</math>.

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размером <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в последовательном (наиболее быстром) варианте требуется:

* <math>O(l)</math> сложений,
* <math>O(l)</math> умножений.

Умножения и сложения составляют ''основную часть алгоритма''.

При классификации по последовательной сложности, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам <math>O(l)</math>.

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

Опишем [[глоссарий#Граф алгоритма|граф алгоритма]]<ref>Воеводин В.В. Математические основы параллельных вычислений// М.: Изд. Моск. ун-та, 1991. 345 с.</ref><ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. – СПб.: БХВ - Петербург, 2002. – 608 с.</ref><ref>Фролов А.В.. Принципы построения и описание языка Сигма. Препринт ОВМ АН N 236. М.: ОВМ АН СССР, 1989.</ref> как аналитически, так и в виде рисунка.

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

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

* <math>i</math> — меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math> - элемент ''входных данных'', а именно <math>AN[IA_{i}+j-1]</math>.
* <math>b</math> - элемент ''входных данных'', а именно <math>b[IA_{i}+j-1]</math>.

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

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция <math>a + b</math>.
Естественно введённые координаты области таковы:
* <math>i</math> - меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> - меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math>:
** при <math>j = 1</math> - результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j)</math>;
** при <math>j > 1</math> - результат срабатывания операции, соответствующей вершине из второй группы, с координатами <math>(i, j - 1)</math>;
* <math>b</math> — результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j + 1)</math>.

Результат срабатывания операции:
* при <math>j < k - 1</math> является ''промежуточным данным'' алгоритма;
* при <math>j = k - 1</math> является ''выходным данным'' <math>c_{i}</math>.

Описанный граф можно посмотреть на рис.1. Здесь вершины первой группы обозначены красным цветом и отмечены знаком умножения, вершины второй - зелёным цветом и знаком сложения. Вершины, соответствующие входным данным обозначены белым цветом и выходным - синим.
[[file:Bliznalg.png|thumb|center|1000px|Рисунок 1. Граф алгоритма умножения разреженной матрицы на вектор]]

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размерности <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в параллельном варианте требуется последовательно выполнить следующие ярусы:

* Не более чем <math>m</math> сложений и умножений (<math>n</math> вычислений в каждом из ярусов)

При классификации по высоте ЯПФ, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам со сложностью <math>O(m)</math>. При классификации по ширине ЯПФ его сложность будет <math>O(n)</math>.

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

'''Входные данные''': разреженная матрица общего вида <math>A</math> размерности <math>n \times m</math>, хранимая в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>. Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> размерности <math>m \times 1</math>.

'''Объём входных данных''': <math>2l+m+n+1</math>, где <math>l</math> - количество ненулевых элементов в матрице <math>A</math>.

'''Выходные данные''': заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

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

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

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

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

Пусть <math>l</math> - количество ненулевых элементов матрицы <math>A</math> размерности <math>n \times m</math>. Пусть <math>x</math> - объем памяти, используемый для хранения значения элемента матрицы, <math>y</math> - объём памяти, используемый для хранения номера столбца или строки. В таком случае для хранения матрицы в стандартном представлении нам потребуется объем памяти, равный <math>x \cdot n \cdot m</math>, для хранения в формате '''RR(C)''' - <math>y(n + 1) + (x + y)l</math>. Таким образом хранение в формате '''RR(C)''' не является эффективным (в вопросе используемой памяти) для матриц, в которых <math>l > \frac{xnm - y(n+1)}{x+y}</math>.

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

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

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

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

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

Параллельная реализация алгоритма заключается в следующем:

# Каждый процессор считывает входные данные из файла, зависящего от его номера. Данные имеют вид: вектор <math>b</math> и набор определённых строк матрицы <math>A</math> в формате '''RR(C)U''' в зависимости от номера процессора и их числа;
# Процессоры проводят вычисления значений вектора <math>c</math> в зависимости от имеющихся данных;
# Все процессоры отправляют результаты вычисления процессору, выбранному главным, и главный процессор выводит результат вычислений.

<div class="mw-collapsible mw-collapsed" style="width:100%">
Текст использованной в экспериментах реализации (язык ''С++''):
<div class="mw-collapsible-content">
<source lang="c++">
#include <mpi.h>
#include <memory>
#include <iostream>
#include <vector>
#include <sstream>
#include <fstream>
#include <string>
#include <iterator>

typedef std::shared_ptr<std::vector<std::vector<int> > > MyData;

MyData ReadData(const std::string& data_path) {
std::ifstream file_stream;
MyData retval(new std::vector<std::vector<int> >());
file_stream.open(data_path);

while (!file_stream.eof()) {
std::string str;
std::getline(file_stream, str);

std::istringstream iss(str);
auto temp_1 = (std::istream_iterator<std::string>(iss));
auto temp_2 = (std::istream_iterator<std::string>());

std::vector<std::string> coordinates{ temp_1, temp_2};
retval->push_back(std::vector<int>());
for (auto& e : coordinates) {
retval->back().push_back(std::stoi(e));
}
}

return retval;
}

// input: vector b, vector ia, vector ja, vector an
int main(int argc, char** argv){
MPI_Init(&argc, &argv);
int pid, np;
MPI_Status *s = new MPI_Status;
MPI_Comm_rank(MPI_COMM_WORLD, &pid);
MPI_Comm_size(MPI_COMM_WORLD, &np);
if (argc == 2){
int n;
int indx = 0;
int stp;
double strttime = MPI_Wtime();
std::vector<int> b;
std::vector<int> ia;
std::vector<int> ja;
std::vector<int> an;
auto data = ReadData("data_" + std::to_string(static_cast<long long>(pid)) + ".txt");
b = (*data)[0];
ia = (*data)[1];
ja = (*data)[2];
an = (*data)[3];
n = (*data)[0].size();
std::vector<int> c;
stp = n / np + ((n % np > pid) ? 1 : 0);
if (pid == 0){
c.resize(n, 0);
}
else{
c.resize(stp, 0);
}
for (int i = 0; i < stp; i++){
int strt = ia[i] - ia[0];
int lstr = ia[i + 1] - ia[i];
for (int j = 0; j < lstr; j++){
c[i] += an[strt + j] * b[ja[strt + j]];
}
}
if (pid == 0){
for (int i = 1; i < np; i++){
indx += n / np + ((n % np > i - 1) ? 1 : 0);
stp = n / np + ((n % np > i) ? 1 : 0);
MPI_Recv(&c[indx], stp, MPI_INT, i, 0, MPI_COMM_WORLD, s);
}
}
else{
MPI_Send(&c[0], stp, MPI_INT, 0, 0, MPI_COMM_WORLD);
}
if (pid == 0){
for (int e : c) {
std::cout << e << "\n";
}
double endtime = MPI_Wtime();
std::cout << "Success! Time = " << endtime - strttime << "\n";
}
}
MPI_Finalize();
return 0;
}
</source>
</div></div>

<div class="mw-collapsible mw-collapsed" style="width:100%">
Для формирования входных данных использовался следующий алгоритм (язык ''Python''):
<div class="mw-collapsible-content">
<source lang="python">
from scipy import sparse as sp
from numpy.random import randint
from os import mkdir
from os.path import join as jn

n = 10000
np = [1, 2, 4, 8, 16, 32, 64, 128]

a = sp.csr_matrix(randint(0, 2, (n, n)))
b = randint(1, 5, n)
i = 0

for j in np:
mkdir('data_' + str(j))
indx = 0
for i in range(0, j):
stp = n / j + (1 if (n % j > i) else 0)
ael = a.indptr[indx + stp] - a.indptr[indx]
strt = a.indptr[indx]
with open(jn('data_' + str(j), 'data_' + str(i) + '.txt'), 'w') as fout:

for e in b:
fout.write('{0} '.format(e))
fout.write('\n')

s = a.indptr[indx:indx + stp + 1]
for e in s:
fout.write('{0} '.format(e))
fout.write('\n')

s = a.indices[strt:strt + ael]
for e in s:
fout.write('{0} '.format(e))
fout.write('\n')

s = a.data[strt:strt + ael]
for e in s:
fout.write('{0} '.format(e))
fout.write('\n')

indx = indx + n / j + (1 if (n % j > i) else 0)
</source>
</div></div>

Проведём исследование масштабируемости параллельной реализации алгоритма умножения разреженной матрицы на вектор. Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета]. Входные данные формировались на персональном компьютере в силу того, что интерпретатор на суперкомпьютере "Ломоносов" не удовлетворял нужным требованиям, и потом отправлялись на суперкомпьютер для последующей обработки.

Программа была собрана на узле компиляции суперкомпьютера "Ломоносов", с помощью компилятора ''intel/15.0.090'' и компилятора ''openmpi/1.6.5-icc'', на языке ''С++11''.

<div class="mw-collapsible mw-collapsed" style="width:100%">
Сборка производилась с помощью ''CMakeLists.txt'', его содержание прилагается:
<div class="mw-collapsible-content">
<pre>
cmake_minimum_required(VERSION 2.8)

project(task1)

set(CMAKE_CXX_STANDARD 11)

set(CXX_STANDARD_REQUIRED)

set(CMAKE_C_COMPILER mpicc)
set(CMAKE_CXX_COMPILER mpicxx)

find_package(MPI REQUIRED)

include_directories(${MPI_INCLUDE_PATH})

SET(CMAKE_CXX_COMPILER mpicc)

if(MPI_COMPILE_FLAGS)
set_target_properties(task1 PROPERTIES
COMPILE_FLAGS "${MPI_COMPILE_FLAGS}")
endif()

set(CMAKE_CXX_FLAGS "-std=c++11 -fpermissive " ${MPI_COMPILE_FLAGS})

set(SOURCE_EXE task1.cpp)

add_executable(task1 ${SOURCE_EXE})

target_link_libraries(task1)
</pre>
</div></div>

Запуск производился на вычислительных узлах суперкомпьютера "Ломоносов".

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

* число процессоров [1 : 128] по степеням 2;
* размер матрицы [1000 : 10000] с шагом 1000.

[[file:Blizntime.png|thumb|center|1000px|Рисунок 2. Время работы программы в зависимости от количества процессоров и размера матрицы]]

Можно заметить, что при небольшом количестве входных данных, и большом количестве процессоров эффективность распараллеливания падает до нуля, поскольку время вычисления элементов вектора <math>c</math> становится несоизмеримо малым по сравнению с временем, затраченным на пересылку в пункте (3).

[[file:Efficiency(paral).png|thumb|center|1000px|Рисунок 4. Эффективность распараллеливания в зависимости от количества процессоров и размера матрицы]]

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

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

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

Существующие реализации:

SciPy [https://docs.scipy.org/doc/scipy-0.18.1/reference/index.html],

MatLab [https://www.mathworks.com/help/matlab/math/sparse-matrix-operations.html],

Intel MKL [https://software.intel.com/en-us/articles/intel-math-kernel-library-inspector-executor-sparse-blas-routines].

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

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

2016-12-02T13:06:46Z

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

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>O(l)</math>
| pf_height = <math>O(m)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>2l+m+n+1</math>
| output_data = <math>n</math>
}}
Выполнила: [[Участник:Blizn|И.В. Близнякова]] (611 группа).

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

== Общее описание алгоритма<ref>С.Писсанецки. Технология разреженных матриц. - М.: Мир, 1988.</ref> ==
'''Разрежённая матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается '''''плотной'''''.

Среди специалистов нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:
* есть <math>O(n)</math>. Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;
* в каждой строке не превышает 10 в типичном случае;
* ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.
* таково, что для данного алгоритма и вычислительной системы имеет смысл извлекать выгоду из наличия в ней нулей.

=== Хранение разреженной матрицы ===
==== Формат RR(C)O ====
Рассмотрим сначала формат '''RR(C)O'''. Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Ordered"'' (строчное представление, полное и упорядоченное). В данном формате вместо одного двумерного массива, используются три одномерных. Значения ненулевых элементов матрицы и соответствующие им столбцовые индексы хранятся в этом формате по строкам в двух массивах <math>AN</math> и <math>JA</math>. Массив указателей <math>IA</math>, используется для ссылки на компоненты массивов <math>AN</math> и <math>JA</math>, с которых начинается описание очередной строки. Последняя компонента массива <math>IA</math> содержит указатель первой свободной компоненты в массивах <math>AN</math> и <math>JA</math>, т.е. равна числу ненулевых элементов матрицы, увеличенному на единицу. Здесь уместно привести пример.

Рассмотрим матрицу <math>A</math>:
:<math>\begin{pmatrix}
0 & 0 & 0 & 2 & 0 \\
1 & 0 & 3 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 \\
0 & 6 & 0 & 0 & 0 \\
0 & 0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
тогда ее представление в формате '''RR(C)O''' будет иметь вид:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 1 3 2 3 ]
AN = [ 2 1 3 6 4 ]
Т.е. массив <math>AN</math> содержит все не нулевые элементы исходной матрицы <math>A</math>, массив <math>JA</math> номер столбца в котором находится соответствующий элемент из <math>AN</math> и наконец массив <math>IA</math> содержит номер с которого начинается описание элементов в массивах <math>JA</math> и <math>AN</math>. Таким образом информация об элементах 2-ой строки матрицы хранится в элементах с <math>IA[2] = 2</math> по <math>IA[3] - 1 = 3</math> включительно массивов <math>JA</math> и <math>AN</math>. Можно обратить внимание, что <math>IA[3] = IA[4] = 4</math>, а это означает, что 3-я строка матрицы <math>A</math> нулевая.

В общем случае описание <math>r</math>-й строки матрицы A хранится в компонентах с <math>IA[r]</math> до <math>IA[r + 1] - 1</math> включительно массивов <math>AN</math> и <math>JA</math>. Если <math>IA[r + 1] = IA[r]</math>, то это означает, что <math>r</math>-я строка нулевая. Количество элементов в массиве <math>IA</math> на единицу больше, чем число строк исходной матрицы, а количество элементов в массивах <math>JA</math> и <math>AN</math> равно числу ненулевых элементов исходной матрицы.

Данный способ представления называют ''полным'', поскольку представлена вся матрица <math>A</math>, ''упорядоченным'', поскольку элементы каждой строки матрицы <math>A</math> хранятся в соответствии с возрастанием столбцовых индексов, и строчным, поскольку информация о матрице <math>A</math> указывается по строкам.

Массивы <math>IA</math> и <math>JA</math> представляют портрет (структуру) матрицы <math>A</math>, задаваемый как множество списков смежности ассоциированного с <math>A</math> графа. Если алгоритм, реализующий какую-либо операцию над разреженными матрицами, разбит на этапы символической обработки, на котором определяется портрет результирующей матрицы, и численной обработки, на котором определяются значения элементов результирующей матрицы, то массивы <math>IA</math> и <math>JA</math> заполняются на первом этапе, а массив <math>AN</math> - на втором.

==== Формат RR(C)U ====

Рассмотрим теперь формат '''RR(C)U'''.

Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Unordered"'' (строчное представление, полное, но неупорядоченное). Формат '''RR(C)U''' отличается от '''RR(C)O''' тем, что в данном случае соблюдается упорядоченность строк, но внутри каждой строки элементы исходных матриц могут храниться в произвольном порядке. Для матрицы <math>A</math> нашего примера вполне можно было бы использовать и строчное представление, полное, но неупорядоченное такое:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 3 1 2 3 ]
AN = [ 2 1 3 6 4 ]
Такие неупорядоченные представления могут быть очень удобны в практических вычислениях. Результаты большинства матричных операций получаются неупорядоченными, а их упорядочение стоило бы значительных затрат машинного времени. В то же время, за немногими исключениями, алгоритмы для разреженных матриц не требуют, чтобы их представления были упорядоченными.

==== Замечания ====

Несколько замечаний по поводу рассмотренных форматов представления:
# Очевидно, что представление матрицы в формате '''RR(C)O''' так же является и представлением в формате '''RR(C)U''', но не наоборот.
# Из представления матрицы в формате '''RR(C)''' нельзя получить информацию о точном количестве столбцов исходной матрицы.
# Целесообразно (в вопросе экономии памяти) использовать представления '''RR(C)''' в случае, если матрица содержит значительное число нулевых элементов.

=== Умножение разреженной матрицы на вектор ===

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

Мы рассмотрим умножение разреженной матрицы общего вида, хранимой в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math> на заполненный вектор-столбец.

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

Исходные данные: разреженная матрица общего вида <math>A</math> с элементами <math>a_{ij}</math> (<math>i = 1,...,n</math> и <math>j = 1,...,m</math>). Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> (<math>j =1,...,m</math>).

Вычисляемые данные: заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

Формулы метода:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

где <math>l_{i}</math> - количество ненулевых элементов строки <math>i</math> матрицы <math>A</math>, <math>j(k)</math> - индекс <math>k</math>-го ненулевого элемента матрицы <math>A</math>.

== Вычислительное ядро алгоритма ==
Вычислительное ядро последовательной версии умножения разреженной матрицы на вектор можно составить из множественных (всего их <math>n</math>) вычислений скалярных произведений строк матрицы:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>.

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

Как записано и в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют множественные (всего <math>n</math>) вычисления сумм:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

которые могут вычисляться в произвольном порядке.

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

Далее предполагаем, что разреженная матрица общего вида <math>A</math> хранится в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>.
Последовательность исполнения метода следующая:

Выполнять для <math>i</math> от <math>1</math> до <math>n</math>
# <math>c_{i} = 0</math>
# <math>IAA = IA[i]</math>
# <math>IAB = IA[i + 1] - 1</math>
# <math>c_{i} = \sum\limits_{k = IAA}^{IAB} AN[k]b_{JA[k]}</math>.
После этого (если <math>i \le n</math>) происходит переход к шагу 1 с бо́льшим <math>i</math>.

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размером <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в последовательном (наиболее быстром) варианте требуется:

* <math>O(l)</math> сложений,
* <math>O(l)</math> умножений.

Умножения и сложения составляют ''основную часть алгоритма''.

При классификации по последовательной сложности, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам <math>O(l)</math>.

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

Опишем [[глоссарий#Граф алгоритма|граф алгоритма]]<ref>Воеводин В.В. Математические основы параллельных вычислений// М.: Изд. Моск. ун-та, 1991. 345 с.</ref><ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. – СПб.: БХВ - Петербург, 2002. – 608 с.</ref><ref>Фролов А.В.. Принципы построения и описание языка Сигма. Препринт ОВМ АН N 236. М.: ОВМ АН СССР, 1989.</ref> как аналитически, так и в виде рисунка.

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

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

* <math>i</math> — меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math> - элемент ''входных данных'', а именно <math>AN[IA_{i}+j-1]</math>.
* <math>b</math> - элемент ''входных данных'', а именно <math>b[IA_{i}+j-1]</math>.

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

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция <math>a + b</math>.
Естественно введённые координаты области таковы:
* <math>i</math> - меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> - меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math>:
** при <math>j = 1</math> - результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j)</math>;
** при <math>j > 1</math> - результат срабатывания операции, соответствующей вершине из второй группы, с координатами <math>(i, j - 1)</math>;
* <math>b</math> — результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j + 1)</math>.

Результат срабатывания операции:
* при <math>j < k - 1</math> является ''промежуточным данным'' алгоритма;
* при <math>j = k - 1</math> является ''выходным данным'' <math>c_{i}</math>.

Описанный граф можно посмотреть на рис.1. Здесь вершины первой группы обозначены красным цветом и отмечены знаком умножения, вершины второй - зелёным цветом и знаком сложения. Вершины, соответствующие входным данным обозначены белым цветом и выходным - синим.
[[file:Bliznalg.png|thumb|center|1000px|Рисунок 1. Граф алгоритма умножения разреженной матрицы на вектор]]

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размерности <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в параллельном варианте требуется последовательно выполнить следующие ярусы:

* Не более чем <math>m</math> сложений и умножений (<math>n</math> вычислений в каждом из ярусов)

При классификации по высоте ЯПФ, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам со сложностью <math>O(m)</math>. При классификации по ширине ЯПФ его сложность будет <math>O(n)</math>.

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

'''Входные данные''': разреженная матрица общего вида <math>A</math> размерности <math>n \times m</math>, хранимая в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>. Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> размерности <math>m \times 1</math>.

'''Объём входных данных''': <math>2l+m+n+1</math>, где <math>l</math> - количество ненулевых элементов в матрице <math>A</math>.

'''Выходные данные''': заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

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

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

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

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

Пусть <math>l</math> - количество ненулевых элементов матрицы <math>A</math> размерности <math>n \times m</math>. Пусть <math>x</math> - объем памяти, используемый для хранения значения элемента матрицы, <math>y</math> - объём памяти, используемый для хранения номера столбца или строки. В таком случае для хранения матрицы в стандартном представлении нам потребуется объем памяти, равный <math>x \cdot n \cdot m</math>, для хранения в формате '''RR(C)''' - <math>y(n + 1) + (x + y)l</math>. Таким образом хранение в формате '''RR(C)''' не является эффективным для матриц, в которых <math>l > \frac{xnm - y(n+1)}{x+y}</math>.

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

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

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

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

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

Параллельная реализация алгоритма заключается в следующем:

# Каждый процессор считывает входные данные из файла, зависящего от его номера. Данные имеют вид: вектор <math>b</math> и набор определённых строк матрицы <math>A</math> в формате '''RR(C)U''' в зависимости от номера процессора и их числа;
# Процессоры проводят вычисления значений вектора <math>c</math> в зависимости от имеющихся данных;
# Все процессоры отправляют результаты вычисления процессору, выбранному главным, и главный процессор выводит результат вычислений.

<div class="mw-collapsible mw-collapsed" style="width:100%">
Текст использованной в экспериментах реализации (язык ''С++''):
<div class="mw-collapsible-content">
<source lang="c++">
#include <mpi.h>
#include <memory>
#include <iostream>
#include <vector>
#include <sstream>
#include <fstream>
#include <string>
#include <iterator>

typedef std::shared_ptr<std::vector<std::vector<int> > > MyData;

MyData ReadData(const std::string& data_path) {
std::ifstream file_stream;
MyData retval(new std::vector<std::vector<int> >());
file_stream.open(data_path);

while (!file_stream.eof()) {
std::string str;
std::getline(file_stream, str);

std::istringstream iss(str);
auto temp_1 = (std::istream_iterator<std::string>(iss));
auto temp_2 = (std::istream_iterator<std::string>());

std::vector<std::string> coordinates{ temp_1, temp_2};
retval->push_back(std::vector<int>());
for (auto& e : coordinates) {
retval->back().push_back(std::stoi(e));
}
}

return retval;
}

// input: vector b, vector ia, vector ja, vector an
int main(int argc, char** argv){
MPI_Init(&argc, &argv);
int pid, np;
MPI_Status *s = new MPI_Status;
MPI_Comm_rank(MPI_COMM_WORLD, &pid);
MPI_Comm_size(MPI_COMM_WORLD, &np);
if (argc == 2){
int n;
int indx = 0;
int stp;
double strttime = MPI_Wtime();
std::vector<int> b;
std::vector<int> ia;
std::vector<int> ja;
std::vector<int> an;
auto data = ReadData("data_" + std::to_string(static_cast<long long>(pid)) + ".txt");
b = (*data)[0];
ia = (*data)[1];
ja = (*data)[2];
an = (*data)[3];
n = (*data)[0].size();
std::vector<int> c;
stp = n / np + ((n % np > pid) ? 1 : 0);
if (pid == 0){
c.resize(n, 0);
}
else{
c.resize(stp, 0);
}
for (int i = 0; i < stp; i++){
int strt = ia[i] - ia[0];
int lstr = ia[i + 1] - ia[i];
for (int j = 0; j < lstr; j++){
c[i] += an[strt + j] * b[ja[strt + j]];
}
}
if (pid == 0){
for (int i = 1; i < np; i++){
indx += n / np + ((n % np > i - 1) ? 1 : 0);
stp = n / np + ((n % np > i) ? 1 : 0);
MPI_Recv(&c[indx], stp, MPI_INT, i, 0, MPI_COMM_WORLD, s);
}
}
else{
MPI_Send(&c[0], stp, MPI_INT, 0, 0, MPI_COMM_WORLD);
}
if (pid == 0){
for (int e : c) {
std::cout << e << "\n";
}
double endtime = MPI_Wtime();
std::cout << "Success! Time = " << endtime - strttime << "\n";
}
}
MPI_Finalize();
return 0;
}
</source>
</div></div>

<div class="mw-collapsible mw-collapsed" style="width:100%">
Для формирования входных данных использовался следующий алгоритм (язык ''Python''):
<div class="mw-collapsible-content">
<source lang="python">
from scipy import sparse as sp
from numpy.random import randint
from os import mkdir
from os.path import join as jn

n = 10000
np = [1, 2, 4, 8, 16, 32, 64, 128]

a = sp.csr_matrix(randint(0, 2, (n, n)))
b = randint(1, 5, n)
i = 0

for j in np:
mkdir('data_' + str(j))
indx = 0
for i in range(0, j):
stp = n / j + (1 if (n % j > i) else 0)
ael = a.indptr[indx + stp] - a.indptr[indx]
strt = a.indptr[indx]
with open(jn('data_' + str(j), 'data_' + str(i) + '.txt'), 'w') as fout:

for e in b:
fout.write('{0} '.format(e))
fout.write('\n')

s = a.indptr[indx:indx + stp + 1]
for e in s:
fout.write('{0} '.format(e))
fout.write('\n')

s = a.indices[strt:strt + ael]
for e in s:
fout.write('{0} '.format(e))
fout.write('\n')

s = a.data[strt:strt + ael]
for e in s:
fout.write('{0} '.format(e))
fout.write('\n')

indx = indx + n / j + (1 if (n % j > i) else 0)
</source>
</div></div>

Проведём исследование масштабируемости параллельной реализации алгоритма умножения разреженной матрицы на вектор. Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета]. Входные данные формировались на персональном компьютере в силу того, что интерпретатор на суперкомпьютере "Ломоносов" не удовлетворял нужным требованиям, и потом отправлялись на суперкомпьютер для последующей обработки.

Программа была собрана на узле компиляции суперкомпьютера "Ломоносов", с помощью компилятора ''intel/15.0.090'' и компилятора ''openmpi/1.6.5-icc'', на языке ''С++11''.

<div class="mw-collapsible mw-collapsed" style="width:100%">
Сборка производилась с помощью ''CMakeLists.txt'', его содержание прилагается:
<div class="mw-collapsible-content">
<pre>
cmake_minimum_required(VERSION 2.8)

project(task1)

set(CMAKE_CXX_STANDARD 11)

set(CXX_STANDARD_REQUIRED)

set(CMAKE_C_COMPILER mpicc)
set(CMAKE_CXX_COMPILER mpicxx)

find_package(MPI REQUIRED)

include_directories(${MPI_INCLUDE_PATH})

SET(CMAKE_CXX_COMPILER mpicc)

if(MPI_COMPILE_FLAGS)
set_target_properties(task1 PROPERTIES
COMPILE_FLAGS "${MPI_COMPILE_FLAGS}")
endif()

set(CMAKE_CXX_FLAGS "-std=c++11 -fpermissive " ${MPI_COMPILE_FLAGS})

set(SOURCE_EXE task1.cpp)

add_executable(task1 ${SOURCE_EXE})

target_link_libraries(task1)
</pre>
</div></div>

Запуск производился на вычислительных узлах суперкомпьютера "Ломоносов".

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

* число процессоров [1 : 128] по степеням 2;
* размер матрицы [1000 : 10000] с шагом 1000.

[[file:Blizntime.png|thumb|center|1000px|Рисунок 2. Время работы программы в зависимости от количества процессоров и размера матрицы]]

Можно заметить, что при небольшом количестве входных данных, и большом количестве процессоров эффективность распараллеливания падает до нуля, поскольку время вычисления элементов вектора <math>c</math> становится несоизмеримо малым по сравнению с временем, затраченным на пересылку в пункте (3).

[[file:Efficiency(paral).png|thumb|center|1000px|Рисунок 4. Эффективность распараллеливания в зависимости от количества процессоров и размера матрицы]]

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

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

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

Существующие реализации:

SciPy [https://docs.scipy.org/doc/scipy-0.18.1/reference/index.html],

MatLab [https://www.mathworks.com/help/matlab/math/sparse-matrix-operations.html],

Intel MKL [https://software.intel.com/en-us/articles/intel-math-kernel-library-inspector-executor-sparse-blas-routines].

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

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

2016-12-02T13:04:34Z

Blizn: /* Пункт 1.1.2 */

--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK) К Вашей работе есть несколько замечаний по содержанию.

== Пункт 1.1 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

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

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

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

- Если первое определение подходит только для “теоретического анализа”, то чем лучше третье?

- Второе определение, по-моему, не совсем корректно – оно слишком строгое, не понятно, что за типичный случай, почему именно используется привязка к строкам матрицы, почему именно 10 и т.д. Есть ли какие-то ссылки на литературу, где такое определение использовалось для анализа или для практических задач? Нужно пояснить смысл такого определения.

'''В качестве теоретической основы использовался Писсанецки, ссылка на него указана выше в статье. Текст использовался именно оттуда, ничего своего я не придумывала. Почему именно 10? Потому что, как было сказано, НЕЛЬЗЯ дать строгого определения тому, начиная с какого количества элементов матрица перестаёт быть плотной и начинает считаться разреженной. А значит, что нельзя сказать, что запрещено определить матрицу именно так. По этой же причине ни одно определение не хуже и не лучше, они просто даны разными людьми в попытках дать более строгое определение, чем просто "много нулей".'''

== Пункт 1.1.1.1 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

'''В данном формате вместо одного двумерного массива, используются три одномерных.'''

Плотную матрицу можно представить и, например, в виде одномерного массива. Тогда получается обычный формат хранения лучше?

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

== Пункт 1.1.1.2 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

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

Хорошо бы привести примеры матричных операций, для которых неупорядоченное представление дает выигрыш, по сравнению с упорядоченным.

== Пункт 1.1.2 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

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

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

'''Это просто примеры, и рассмотрение их значимости и примечательности не относится к теме разреженных матриц.'''

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

Достоинство этих процедур, по сравнению с какими? В некоторых итерационных методах, например, требуется также умножение и транспонированной матрицы на вектор.

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

== Пункт 1.6 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

'''Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размером <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в последовательном (наиболее быстром) варианте требуется:'''

''' <math>l</math> сложений,'''

''' <math>l</math> умножений.'''

Что здесь понимается как «наиболее быстрый вариант»? Есть ли какие-то более медленные альтернативы? Оценка <math>l</math> сложений похоже не совсем правильная. Например, сколько нужно сложений для матрицы с одним ненулевым элементом в алгоритме 1.5?

== Пункт 1.8 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

Можно ли записать параллельный алгоритм, использующий больше чем n процессоров, где n - число строк(столбцов)?

== Пункт 1.10 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

'''Таким образом хранение в формате RR(C) не является эффективным для матриц, в которых <math>l > \frac{xnm - y(n+1)}{x+y}</math>.'''

Нужно уточнить по какому критерию сравнивается «эффективность». Просто занимает меньше памяти? Или, например, сравнивается скорость доступа к памяти или время выполнения матричных операций?

== Пункт 2.4 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

Нужно явно написать в тексте, что рассматривался целочисленный алгоритм. Почему не вещественное матрично-векторное умножение? Приводимые оценки для числа операций алгоритма (п.1.6, 1.8) разве учитывают вспомогательные целочисленные операции, например, для организации циклов?

'''размер матрицы [1000 : 10000] с шагом 1000.'''

Здесь размер матрицы – это число ненулевых элементов? Нужно привести и размер матрицы, и число ненулевых элементов.

Какая структура матрицы, которая использовалась в экспериментах? Какова доля операций чтения из файла в экспериментах?

== Статья [[Участник:Blizn/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор.]] ==

=== Отсутствующие части ===
* Нет информации в разделе 2.7. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:47, 27 октября 2016 (MSK)
* Не заполнен раздел 2.4 описания. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:27, 16 ноября 2016 (MSK)

=== Замечания по тексту ===
* В разделе 1.4 не нужно дублировать написанное в разделе 1.3, а требуется описание алгоритма на верхнем уровне. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:47, 27 октября 2016 (MSK)
** Замечание не исправлено. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:04, 2 ноября 2016 (MSK)
* В разделе 2.4 не приведены все параметры запуска теста - какой компилятор, с какими опциями использовался, какие версии библиотек, на каких узлах проводился запуск и т.д. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 11:09, 30 ноября 2016 (MSK)
* В разделе 2.4 не приведён сам текст использованной в экспериментах реализации алгоритма. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 11:09, 30 ноября 2016 (MSK)

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

2016-12-02T12:54:08Z

Blizn: /* Пункт 1.1.1.1 */

--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK) К Вашей работе есть несколько замечаний по содержанию.

== Пункт 1.1 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

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

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

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

- Если первое определение подходит только для “теоретического анализа”, то чем лучше третье?

- Второе определение, по-моему, не совсем корректно – оно слишком строгое, не понятно, что за типичный случай, почему именно используется привязка к строкам матрицы, почему именно 10 и т.д. Есть ли какие-то ссылки на литературу, где такое определение использовалось для анализа или для практических задач? Нужно пояснить смысл такого определения.

'''В качестве теоретической основы использовался Писсанецки, ссылка на него указана выше в статье. Текст использовался именно оттуда, ничего своего я не придумывала. Почему именно 10? Потому что, как было сказано, НЕЛЬЗЯ дать строгого определения тому, начиная с какого количества элементов матрица перестаёт быть плотной и начинает считаться разреженной. А значит, что нельзя сказать, что запрещено определить матрицу именно так. По этой же причине ни одно определение не хуже и не лучше, они просто даны разными людьми в попытках дать более строгое определение, чем просто "много нулей".'''

== Пункт 1.1.1.1 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

'''В данном формате вместо одного двумерного массива, используются три одномерных.'''

Плотную матрицу можно представить и, например, в виде одномерного массива. Тогда получается обычный формат хранения лучше?

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

== Пункт 1.1.1.2 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

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

Хорошо бы привести примеры матричных операций, для которых неупорядоченное представление дает выигрыш, по сравнению с упорядоченным.

== Пункт 1.1.2 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

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

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

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

Достоинство этих процедур, по сравнению с какими? В некоторых итерационных методах, например, требуется также умножение и транспонированной матрицы на вектор.

== Пункт 1.6 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

'''Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размером <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в последовательном (наиболее быстром) варианте требуется:'''

''' <math>l</math> сложений,'''

''' <math>l</math> умножений.'''

Что здесь понимается как «наиболее быстрый вариант»? Есть ли какие-то более медленные альтернативы? Оценка <math>l</math> сложений похоже не совсем правильная. Например, сколько нужно сложений для матрицы с одним ненулевым элементом в алгоритме 1.5?

== Пункт 1.8 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

Можно ли записать параллельный алгоритм, использующий больше чем n процессоров, где n - число строк(столбцов)?

== Пункт 1.10 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

'''Таким образом хранение в формате RR(C) не является эффективным для матриц, в которых <math>l > \frac{xnm - y(n+1)}{x+y}</math>.'''

Нужно уточнить по какому критерию сравнивается «эффективность». Просто занимает меньше памяти? Или, например, сравнивается скорость доступа к памяти или время выполнения матричных операций?

== Пункт 2.4 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

Нужно явно написать в тексте, что рассматривался целочисленный алгоритм. Почему не вещественное матрично-векторное умножение? Приводимые оценки для числа операций алгоритма (п.1.6, 1.8) разве учитывают вспомогательные целочисленные операции, например, для организации циклов?

'''размер матрицы [1000 : 10000] с шагом 1000.'''

Здесь размер матрицы – это число ненулевых элементов? Нужно привести и размер матрицы, и число ненулевых элементов.

Какая структура матрицы, которая использовалась в экспериментах? Какова доля операций чтения из файла в экспериментах?

== Статья [[Участник:Blizn/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор.]] ==

=== Отсутствующие части ===
* Нет информации в разделе 2.7. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:47, 27 октября 2016 (MSK)
* Не заполнен раздел 2.4 описания. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:27, 16 ноября 2016 (MSK)

=== Замечания по тексту ===
* В разделе 1.4 не нужно дублировать написанное в разделе 1.3, а требуется описание алгоритма на верхнем уровне. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:47, 27 октября 2016 (MSK)
** Замечание не исправлено. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:04, 2 ноября 2016 (MSK)
* В разделе 2.4 не приведены все параметры запуска теста - какой компилятор, с какими опциями использовался, какие версии библиотек, на каких узлах проводился запуск и т.д. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 11:09, 30 ноября 2016 (MSK)
* В разделе 2.4 не приведён сам текст использованной в экспериментах реализации алгоритма. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 11:09, 30 ноября 2016 (MSK)

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

2016-12-02T12:52:14Z

Blizn: /* Пункт 1.1 */

--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK) К Вашей работе есть несколько замечаний по содержанию.

== Пункт 1.1 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

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

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

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

- Если первое определение подходит только для “теоретического анализа”, то чем лучше третье?

- Второе определение, по-моему, не совсем корректно – оно слишком строгое, не понятно, что за типичный случай, почему именно используется привязка к строкам матрицы, почему именно 10 и т.д. Есть ли какие-то ссылки на литературу, где такое определение использовалось для анализа или для практических задач? Нужно пояснить смысл такого определения.

'''В качестве теоретической основы использовался Писсанецки, ссылка на него указана выше в статье. Текст использовался именно оттуда, ничего своего я не придумывала. Почему именно 10? Потому что, как было сказано, НЕЛЬЗЯ дать строгого определения тому, начиная с какого количества элементов матрица перестаёт быть плотной и начинает считаться разреженной. А значит, что нельзя сказать, что запрещено определить матрицу именно так. По этой же причине ни одно определение не хуже и не лучше, они просто даны разными людьми в попытках дать более строгое определение, чем просто "много нулей".'''

== Пункт 1.1.1.1 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

'''В данном формате вместо одного двумерного массива, используются три одномерных.'''

Плотную матрицу можно представить и, например, в виде одномерного массива. Тогда получается обычный формат хранения лучше?

== Пункт 1.1.1.2 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

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

Хорошо бы привести примеры матричных операций, для которых неупорядоченное представление дает выигрыш, по сравнению с упорядоченным.

== Пункт 1.1.2 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

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

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

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

Достоинство этих процедур, по сравнению с какими? В некоторых итерационных методах, например, требуется также умножение и транспонированной матрицы на вектор.

== Пункт 1.6 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

'''Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размером <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в последовательном (наиболее быстром) варианте требуется:'''

''' <math>l</math> сложений,'''

''' <math>l</math> умножений.'''

Что здесь понимается как «наиболее быстрый вариант»? Есть ли какие-то более медленные альтернативы? Оценка <math>l</math> сложений похоже не совсем правильная. Например, сколько нужно сложений для матрицы с одним ненулевым элементом в алгоритме 1.5?

== Пункт 1.8 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

Можно ли записать параллельный алгоритм, использующий больше чем n процессоров, где n - число строк(столбцов)?

== Пункт 1.10 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

'''Таким образом хранение в формате RR(C) не является эффективным для матриц, в которых <math>l > \frac{xnm - y(n+1)}{x+y}</math>.'''

Нужно уточнить по какому критерию сравнивается «эффективность». Просто занимает меньше памяти? Или, например, сравнивается скорость доступа к памяти или время выполнения матричных операций?

== Пункт 2.4 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

Нужно явно написать в тексте, что рассматривался целочисленный алгоритм. Почему не вещественное матрично-векторное умножение? Приводимые оценки для числа операций алгоритма (п.1.6, 1.8) разве учитывают вспомогательные целочисленные операции, например, для организации циклов?

'''размер матрицы [1000 : 10000] с шагом 1000.'''

Здесь размер матрицы – это число ненулевых элементов? Нужно привести и размер матрицы, и число ненулевых элементов.

Какая структура матрицы, которая использовалась в экспериментах? Какова доля операций чтения из файла в экспериментах?

== Статья [[Участник:Blizn/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор.]] ==

=== Отсутствующие части ===
* Нет информации в разделе 2.7. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:47, 27 октября 2016 (MSK)
* Не заполнен раздел 2.4 описания. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:27, 16 ноября 2016 (MSK)

=== Замечания по тексту ===
* В разделе 1.4 не нужно дублировать написанное в разделе 1.3, а требуется описание алгоритма на верхнем уровне. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:47, 27 октября 2016 (MSK)
** Замечание не исправлено. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:04, 2 ноября 2016 (MSK)
* В разделе 2.4 не приведены все параметры запуска теста - какой компилятор, с какими опциями использовался, какие версии библиотек, на каких узлах проводился запуск и т.д. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 11:09, 30 ноября 2016 (MSK)
* В разделе 2.4 не приведён сам текст использованной в экспериментах реализации алгоритма. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 11:09, 30 ноября 2016 (MSK)

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

2016-11-30T22:29:47Z

Blizn:

{{Assignment}}

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>O(l)</math>
| pf_height = <math>O(m)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>2l+m+n+1</math>
| output_data = <math>n</math>
}}
Выполнила: [[Участник:Blizn|И.В. Близнякова]] (611 группа).

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

== Общее описание алгоритма<ref>С.Писсанецки. Технология разреженных матриц. - М.: Мир, 1988.</ref> ==
'''Разрежённая матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается '''''плотной'''''.

Среди специалистов нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:
* есть <math>O(n)</math>. Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;
* в каждой строке не превышает 10 в типичном случае;
* ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.
* таково, что для данного алгоритма и вычислительной системы имеет смысл извлекать выгоду из наличия в ней нулей.

=== Хранение разреженной матрицы ===
==== Формат RR(C)O ====
Рассмотрим сначала формат '''RR(C)O'''. Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Ordered"'' (строчное представление, полное и упорядоченное). В данном формате вместо одного двумерного массива, используются три одномерных. Значения ненулевых элементов матрицы и соответствующие им столбцовые индексы хранятся в этом формате по строкам в двух массивах <math>AN</math> и <math>JA</math>. Массив указателей <math>IA</math>, используется для ссылки на компоненты массивов <math>AN</math> и <math>JA</math>, с которых начинается описание очередной строки. Последняя компонента массива <math>IA</math> содержит указатель первой свободной компоненты в массивах <math>AN</math> и <math>JA</math>, т.е. равна числу ненулевых элементов матрицы, увеличенному на единицу. Здесь уместно привести пример.

Рассмотрим матрицу <math>A</math>:
:<math>\begin{pmatrix}
0 & 0 & 0 & 2 & 0 \\
1 & 0 & 3 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 \\
0 & 6 & 0 & 0 & 0 \\
0 & 0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
тогда ее представление в формате '''RR(C)O''' будет иметь вид:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 1 3 2 3 ]
AN = [ 2 1 3 6 4 ]
Т.е. массив <math>AN</math> содержит все не нулевые элементы исходной матрицы <math>A</math>, массив <math>JA</math> номер столбца в котором находится соответствующий элемент из <math>AN</math> и наконец массив <math>IA</math> содержит номер с которого начинается описание элементов в массивах <math>JA</math> и <math>AN</math>. Таким образом информация об элементах 2-ой строки матрицы хранится в элементах с <math>IA[2] = 2</math> по <math>IA[3] - 1 = 3</math> включительно массивов <math>JA</math> и <math>AN</math>. Можно обратить внимание, что <math>IA[3] = IA[4] = 4</math>, а это означает, что 3-я строка матрицы <math>A</math> нулевая.

В общем случае описание <math>r</math>-й строки матрицы A хранится в компонентах с <math>IA[r]</math> до <math>IA[r + 1] - 1</math> включительно массивов <math>AN</math> и <math>JA</math>. Если <math>IA[r + 1] = IA[r]</math>, то это означает, что <math>r</math>-я строка нулевая. Количество элементов в массиве <math>IA</math> на единицу больше, чем число строк исходной матрицы, а количество элементов в массивах <math>JA</math> и <math>AN</math> равно числу ненулевых элементов исходной матрицы.

Данный способ представления называют ''полным'', поскольку представлена вся матрица <math>A</math>, ''упорядоченным'', поскольку элементы каждой строки матрицы <math>A</math> хранятся в соответствии с возрастанием столбцовых индексов, и строчным, поскольку информация о матрице <math>A</math> указывается по строкам.

Массивы <math>IA</math> и <math>JA</math> представляют портрет (структуру) матрицы <math>A</math>, задаваемый как множество списков смежности ассоциированного с <math>A</math> графа. Если алгоритм, реализующий какую-либо операцию над разреженными матрицами, разбит на этапы символической обработки, на котором определяется портрет результирующей матрицы, и численной обработки, на котором определяются значения элементов результирующей матрицы, то массивы <math>IA</math> и <math>JA</math> заполняются на первом этапе, а массив <math>AN</math> - на втором.

==== Формат RR(C)U ====

Рассмотрим теперь формат '''RR(C)U'''.

Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Unordered"'' (строчное представление, полное, но неупорядоченное). Формат '''RR(C)U''' отличается от '''RR(C)O''' тем, что в данном случае соблюдается упорядоченность строк, но внутри каждой строки элементы исходных матриц могут храниться в произвольном порядке. Для матрицы <math>A</math> нашего примера вполне можно было бы использовать и строчное представление, полное, но неупорядоченное такое:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 3 1 2 3 ]
AN = [ 2 1 3 6 4 ]
Такие неупорядоченные представления могут быть очень удобны в практических вычислениях. Результаты большинства матричных операций получаются неупорядоченными, а их упорядочение стоило бы значительных затрат машинного времени. В то же время, за немногими исключениями, алгоритмы для разреженных матриц не требуют, чтобы их представления были упорядоченными.

==== Замечания ====

Несколько замечаний по поводу рассмотренных форматов представления:
# Очевидно, что представление матрицы в формате '''RR(C)O''' так же является и представлением в формате '''RR(C)U''', но не наоборот.
# Из представления матрицы в формате '''RR(C)''' нельзя получить информацию о точном количестве столбцов исходной матрицы.
# Целесообразно (в вопросе экономии памяти) использовать представления '''RR(C)''' в случае, если матрица содержит значительное число нулевых элементов.

=== Умножение разреженной матрицы на вектор ===

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

Мы рассмотрим умножение разреженной матрицы общего вида, хранимой в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math> на заполненный вектор-столбец.

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

Исходные данные: разреженная матрица общего вида <math>A</math> с элементами <math>a_{ij}</math> (<math>i = 1,...,n</math> и <math>j = 1,...,m</math>). Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> (<math>j =1,...,m</math>).

Вычисляемые данные: заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

Формулы метода:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

где <math>l_{i}</math> - количество ненулевых элементов строки <math>i</math> матрицы <math>A</math>, <math>j(k)</math> - индекс <math>k</math>-го ненулевого элемента матрицы <math>A</math>.

== Вычислительное ядро алгоритма ==
Вычислительное ядро последовательной версии умножения разреженной матрицы на вектор можно составить из множественных (всего их <math>n</math>) вычислений скалярных произведений строк матрицы:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>.

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

Как записано и в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют множественные (всего <math>n</math>) вычисления сумм:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

которые могут вычисляться в произвольном порядке.

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

Далее предполагаем, что разреженная матрица общего вида <math>A</math> хранится в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>.
Последовательность исполнения метода следующая:

Выполнять для <math>i</math> от <math>1</math> до <math>n</math>
# <math>c_{i} = 0</math>
# <math>IAA = IA[i]</math>
# <math>IAB = IA[i + 1] - 1</math>
# <math>c_{i} = \sum\limits_{k = IAA}^{IAB} AN[k]b_{JA[k]}</math>.
После этого (если <math>i \le n</math>) происходит переход к шагу 1 с бо́льшим <math>i</math>.

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размером <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в последовательном (наиболее быстром) варианте требуется:

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

Умножения и сложения составляют ''основную часть алгоритма''.

При классификации по последовательной сложности, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам <math>O(l)</math>.

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

Опишем [[глоссарий#Граф алгоритма|граф алгоритма]]<ref>Воеводин В.В. Математические основы параллельных вычислений// М.: Изд. Моск. ун-та, 1991. 345 с.</ref><ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. – СПб.: БХВ - Петербург, 2002. – 608 с.</ref><ref>Фролов А.В.. Принципы построения и описание языка Сигма. Препринт ОВМ АН N 236. М.: ОВМ АН СССР, 1989.</ref> как аналитически, так и в виде рисунка.

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

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

* <math>i</math> — меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math> - элемент ''входных данных'', а именно <math>AN[IA_{i}+j-1]</math>.
* <math>b</math> - элемент ''входных данных'', а именно <math>b[IA_{i}+j-1]</math>.

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

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция <math>a + b</math>.
Естественно введённые координаты области таковы:
* <math>i</math> - меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> - меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math>:
** при <math>j = 1</math> - результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j)</math>;
** при <math>j > 1</math> - результат срабатывания операции, соответствующей вершине из второй группы, с координатами <math>(i, j - 1)</math>;
* <math>b</math> — результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j + 1)</math>.

Результат срабатывания операции:
* при <math>j < k - 1</math> является ''промежуточным данным'' алгоритма;
* при <math>j = k - 1</math> является ''выходным данным'' <math>c_{i}</math>.

Описанный граф можно посмотреть на рис.1. Здесь вершины первой группы обозначены красным цветом и отмечены знаком умножения, вершины второй - зелёным цветом и знаком сложения. Вершины, соответствующие входным данным обозначены белым цветом и выходным - синим.
[[file:Bliznalg.png|thumb|center|1000px|Рисунок 1. Граф алгоритма умножения разреженной матрицы на вектор]]

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размерности <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в параллельном варианте требуется последовательно выполнить следующие ярусы:

* Не более чем <math>m</math> сложений и умножений (<math>n</math> вычислений в каждом из ярусов)

При классификации по высоте ЯПФ, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам со сложностью <math>O(m)</math>. При классификации по ширине ЯПФ его сложность будет <math>O(n)</math>.

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

'''Входные данные''': разреженная матрица общего вида <math>A</math> размерности <math>n \times m</math>, хранимая в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>. Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> размерности <math>m \times 1</math>.

'''Объём входных данных''': <math>2l+m+n+1</math>, где <math>l</math> - количество ненулевых элементов в матрице <math>A</math>.

'''Выходные данные''': заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

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

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

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

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

Пусть <math>l</math> - количество ненулевых элементов матрицы <math>A</math> размерности <math>n \times m</math>. Пусть <math>x</math> - объем памяти, используемый для хранения значения элемента матрицы, <math>y</math> - объём памяти, используемый для хранения номера столбца или строки. В таком случае для хранения матрицы в стандартном представлении нам потребуется объем памяти, равный <math>x \cdot n \cdot m</math>, для хранения в формате '''RR(C)''' - <math>y(n + 1) + (x + y)l</math>. Таким образом хранение в формате '''RR(C)''' не является эффективным для матриц, в которых <math>l > \frac{xnm - y(n+1)}{x+y}</math>.

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

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

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

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

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

Параллельная реализация алгоритма заключается в следующем:

# Каждый процессор считывает входные данные из файла, зависящего от его номера. Данные имеют вид: вектор <math>b</math> и набор определённых строк матрицы <math>A</math> в формате '''RR(C)U''' в зависимости от номера процессора и их числа;
# Процессоры проводят вычисления значений вектора <math>c</math> в зависимости от имеющихся данных;
# Все процессоры отправляют результаты вычисления процессору, выбранному главным, и главный процессор выводит результат вычислений.

<div class="mw-collapsible mw-collapsed" style="width:100%">
Текст использованной в экспериментах реализации (язык ''С++''):
<div class="mw-collapsible-content">
<source lang="c++">
#include <mpi.h>
#include <memory>
#include <iostream>
#include <vector>
#include <sstream>
#include <fstream>
#include <string>
#include <iterator>

typedef std::shared_ptr<std::vector<std::vector<int> > > MyData;

MyData ReadData(const std::string& data_path) {
std::ifstream file_stream;
MyData retval(new std::vector<std::vector<int> >());
file_stream.open(data_path);

while (!file_stream.eof()) {
std::string str;
std::getline(file_stream, str);

std::istringstream iss(str);
auto temp_1 = (std::istream_iterator<std::string>(iss));
auto temp_2 = (std::istream_iterator<std::string>());

std::vector<std::string> coordinates{ temp_1, temp_2};
retval->push_back(std::vector<int>());
for (auto& e : coordinates) {
retval->back().push_back(std::stoi(e));
}
}

return retval;
}

// input: vector b, vector ia, vector ja, vector an
int main(int argc, char** argv){
MPI_Init(&argc, &argv);
int pid, np;
MPI_Status *s = new MPI_Status;
MPI_Comm_rank(MPI_COMM_WORLD, &pid);
MPI_Comm_size(MPI_COMM_WORLD, &np);
if (argc == 2){
int n;
int indx = 0;
int stp;
double strttime = MPI_Wtime();
std::vector<int> b;
std::vector<int> ia;
std::vector<int> ja;
std::vector<int> an;
auto data = ReadData("data_" + std::to_string(static_cast<long long>(pid)) + ".txt");
b = (*data)[0];
ia = (*data)[1];
ja = (*data)[2];
an = (*data)[3];
n = (*data)[0].size();
std::vector<int> c;
stp = n / np + ((n % np > pid) ? 1 : 0);
if (pid == 0){
c.resize(n, 0);
}
else{
c.resize(stp, 0);
}
for (int i = 0; i < stp; i++){
int strt = ia[i] - ia[0];
int lstr = ia[i + 1] - ia[i];
for (int j = 0; j < lstr; j++){
c[i] += an[strt + j] * b[ja[strt + j]];
}
}
if (pid == 0){
for (int i = 1; i < np; i++){
indx += n / np + ((n % np > i - 1) ? 1 : 0);
stp = n / np + ((n % np > i) ? 1 : 0);
MPI_Recv(&c[indx], stp, MPI_INT, i, 0, MPI_COMM_WORLD, s);
}
}
else{
MPI_Send(&c[0], stp, MPI_INT, 0, 0, MPI_COMM_WORLD);
}
if (pid == 0){
for (int e : c) {
std::cout << e << "\n";
}
double endtime = MPI_Wtime();
std::cout << "Success! Time = " << endtime - strttime << "\n";
}
}
MPI_Finalize();
return 0;
}
</source>
</div></div>

<div class="mw-collapsible mw-collapsed" style="width:100%">
Для формирования входных данных использовался следующий алгоритм (язык ''Python''):
<div class="mw-collapsible-content">
<source lang="python">
from scipy import sparse as sp
from numpy.random import randint
from os import mkdir
from os.path import join as jn

n = 10000
np = [1, 2, 4, 8, 16, 32, 64, 128]

a = sp.csr_matrix(randint(0, 2, (n, n)))
b = randint(1, 5, n)
i = 0

for j in np:
mkdir('data_' + str(j))
indx = 0
for i in range(0, j):
stp = n / j + (1 if (n % j > i) else 0)
ael = a.indptr[indx + stp] - a.indptr[indx]
strt = a.indptr[indx]
with open(jn('data_' + str(j), 'data_' + str(i) + '.txt'), 'w') as fout:

for e in b:
fout.write('{0} '.format(e))
fout.write('\n')

s = a.indptr[indx:indx + stp + 1]
for e in s:
fout.write('{0} '.format(e))
fout.write('\n')

s = a.indices[strt:strt + ael]
for e in s:
fout.write('{0} '.format(e))
fout.write('\n')

s = a.data[strt:strt + ael]
for e in s:
fout.write('{0} '.format(e))
fout.write('\n')

indx = indx + n / j + (1 if (n % j > i) else 0)
</source>
</div></div>

Проведём исследование масштабируемости параллельной реализации алгоритма умножения разреженной матрицы на вектор. Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета]. Входные данные формировались на персональном компьютере в силу того, что интерпретатор на суперкомпьютере "Ломоносов" не удовлетворял нужным требованиям, и потом отправлялись на суперкомпьютер для последующей обработки.

Программа была собрана на узле компиляции суперкомпьютера "Ломоносов", с помощью компилятора ''intel/15.0.090'' и компилятора ''openmpi/1.6.5-icc'', на языке ''С++11''.

<div class="mw-collapsible mw-collapsed" style="width:100%">
Сборка производилась с помощью ''CMakeLists.txt'', его содержание прилагается:
<div class="mw-collapsible-content">
<pre>
cmake_minimum_required(VERSION 2.8)

project(task1)

set(CMAKE_CXX_STANDARD 11)

set(CXX_STANDARD_REQUIRED)

set(CMAKE_C_COMPILER mpicc)
set(CMAKE_CXX_COMPILER mpicxx)

find_package(MPI REQUIRED)

include_directories(${MPI_INCLUDE_PATH})

SET(CMAKE_CXX_COMPILER mpicc)

if(MPI_COMPILE_FLAGS)
set_target_properties(task1 PROPERTIES
COMPILE_FLAGS "${MPI_COMPILE_FLAGS}")
endif()

set(CMAKE_CXX_FLAGS "-std=c++11 -fpermissive " ${MPI_COMPILE_FLAGS})

set(SOURCE_EXE task1.cpp)

add_executable(task1 ${SOURCE_EXE})

target_link_libraries(task1)
</pre>
</div></div>

Запуск производился на вычислительных узлах суперкомпьютера "Ломоносов".

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

* число процессоров [1 : 128] по степеням 2;
* размер матрицы [1000 : 10000] с шагом 1000.

[[file:Blizntime.png|thumb|center|1000px|Рисунок 2. Время работы программы в зависимости от количества процессоров и размера матрицы]]

Можно заметить, что при небольшом количестве входных данных, и большом количестве процессоров эффективность распараллеливания падает до нуля, поскольку время вычисления элементов вектора <math>c</math> становится несоизмеримо малым по сравнению с временем, затраченным на пересылку в пункте (3).

[[file:Efficiency(paral).png|thumb|center|1000px|Рисунок 4. Эффективность распараллеливания в зависимости от количества процессоров и размера матрицы]]

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

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

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

Существующие реализации:

SciPy [https://docs.scipy.org/doc/scipy-0.18.1/reference/index.html],

MatLab [https://www.mathworks.com/help/matlab/math/sparse-matrix-operations.html],

Intel MKL [https://software.intel.com/en-us/articles/intel-math-kernel-library-inspector-executor-sparse-blas-routines].

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

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

2016-11-30T22:28:26Z

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

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>O(l)</math>
| pf_height = <math>O(m)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>2l+m+n+1</math>
| output_data = <math>n</math>
}}
Выполнила: [[Участник:Blizn|И.В. Близнякова]] (611 группа).

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

== Общее описание алгоритма<ref>С.Писсанецки. Технология разреженных матриц. - М.: Мир, 1988.</ref> ==
'''Разрежённая матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается '''''плотной'''''.

Среди специалистов нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:
* есть <math>O(n)</math>. Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;
* в каждой строке не превышает 10 в типичном случае;
* ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.
* таково, что для данного алгоритма и вычислительной системы имеет смысл извлекать выгоду из наличия в ней нулей.

=== Хранение разреженной матрицы ===
==== Формат RR(C)O ====
Рассмотрим сначала формат '''RR(C)O'''. Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Ordered"'' (строчное представление, полное и упорядоченное). В данном формате вместо одного двумерного массива, используются три одномерных. Значения ненулевых элементов матрицы и соответствующие им столбцовые индексы хранятся в этом формате по строкам в двух массивах <math>AN</math> и <math>JA</math>. Массив указателей <math>IA</math>, используется для ссылки на компоненты массивов <math>AN</math> и <math>JA</math>, с которых начинается описание очередной строки. Последняя компонента массива <math>IA</math> содержит указатель первой свободной компоненты в массивах <math>AN</math> и <math>JA</math>, т.е. равна числу ненулевых элементов матрицы, увеличенному на единицу. Здесь уместно привести пример.

Рассмотрим матрицу <math>A</math>:
:<math>\begin{pmatrix}
0 & 0 & 0 & 2 & 0 \\
1 & 0 & 3 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 \\
0 & 6 & 0 & 0 & 0 \\
0 & 0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
тогда ее представление в формате '''RR(C)O''' будет иметь вид:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 1 3 2 3 ]
AN = [ 2 1 3 6 4 ]
Т.е. массив <math>AN</math> содержит все не нулевые элементы исходной матрицы <math>A</math>, массив <math>JA</math> номер столбца в котором находится соответствующий элемент из <math>AN</math> и наконец массив <math>IA</math> содержит номер с которого начинается описание элементов в массивах <math>JA</math> и <math>AN</math>. Таким образом информация об элементах 2-ой строки матрицы хранится в элементах с <math>IA[2] = 2</math> по <math>IA[3] - 1 = 3</math> включительно массивов <math>JA</math> и <math>AN</math>. Можно обратить внимание, что <math>IA[3] = IA[4] = 4</math>, а это означает, что 3-я строка матрицы <math>A</math> нулевая.

В общем случае описание <math>r</math>-й строки матрицы A хранится в компонентах с <math>IA[r]</math> до <math>IA[r + 1] - 1</math> включительно массивов <math>AN</math> и <math>JA</math>. Если <math>IA[r + 1] = IA[r]</math>, то это означает, что <math>r</math>-я строка нулевая. Количество элементов в массиве <math>IA</math> на единицу больше, чем число строк исходной матрицы, а количество элементов в массивах <math>JA</math> и <math>AN</math> равно числу ненулевых элементов исходной матрицы.

Данный способ представления называют ''полным'', поскольку представлена вся матрица <math>A</math>, ''упорядоченным'', поскольку элементы каждой строки матрицы <math>A</math> хранятся в соответствии с возрастанием столбцовых индексов, и строчным, поскольку информация о матрице <math>A</math> указывается по строкам.

Массивы <math>IA</math> и <math>JA</math> представляют портрет (структуру) матрицы <math>A</math>, задаваемый как множество списков смежности ассоциированного с <math>A</math> графа. Если алгоритм, реализующий какую-либо операцию над разреженными матрицами, разбит на этапы символической обработки, на котором определяется портрет результирующей матрицы, и численной обработки, на котором определяются значения элементов результирующей матрицы, то массивы <math>IA</math> и <math>JA</math> заполняются на первом этапе, а массив <math>AN</math> - на втором.

==== Формат RR(C)U ====

Рассмотрим теперь формат '''RR(C)U'''.

Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Unordered"'' (строчное представление, полное, но неупорядоченное). Формат '''RR(C)U''' отличается от '''RR(C)O''' тем, что в данном случае соблюдается упорядоченность строк, но внутри каждой строки элементы исходных матриц могут храниться в произвольном порядке. Для матрицы <math>A</math> нашего примера вполне можно было бы использовать и строчное представление, полное, но неупорядоченное такое:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 3 1 2 3 ]
AN = [ 2 1 3 6 4 ]
Такие неупорядоченные представления могут быть очень удобны в практических вычислениях. Результаты большинства матричных операций получаются неупорядоченными, а их упорядочение стоило бы значительных затрат машинного времени. В то же время, за немногими исключениями, алгоритмы для разреженных матриц не требуют, чтобы их представления были упорядоченными.

==== Замечания ====

Несколько замечаний по поводу рассмотренных форматов представления:
# Очевидно, что представление матрицы в формате '''RR(C)O''' так же является и представлением в формате '''RR(C)U''', но не наоборот.
# Из представления матрицы в формате '''RR(C)''' нельзя получить информацию о точном количестве столбцов исходной матрицы.
# Целесообразно (в вопросе экономии памяти) использовать представления '''RR(C)''' в случае, если матрица содержит значительное число нулевых элементов.

=== Умножение разреженной матрицы на вектор ===

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

Мы рассмотрим умножение разреженной матрицы общего вида, хранимой в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math> на заполненный вектор-столбец.

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

Исходные данные: разреженная матрица общего вида <math>A</math> с элементами <math>a_{ij}</math> (<math>i = 1,...,n</math> и <math>j = 1,...,m</math>). Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> (<math>j =1,...,m</math>).

Вычисляемые данные: заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

Формулы метода:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

где <math>l_{i}</math> - количество ненулевых элементов строки <math>i</math> матрицы <math>A</math>, <math>j(k)</math> - индекс <math>k</math>-го ненулевого элемента матрицы <math>A</math>.

== Вычислительное ядро алгоритма ==
Вычислительное ядро последовательной версии умножения разреженной матрицы на вектор можно составить из множественных (всего их <math>n</math>) вычислений скалярных произведений строк матрицы:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>.

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

Как записано и в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют множественные (всего <math>n</math>) вычисления сумм:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

которые могут вычисляться в произвольном порядке.

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

Далее предполагаем, что разреженная матрица общего вида <math>A</math> хранится в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>.
Последовательность исполнения метода следующая:

Выполнять для <math>i</math> от <math>1</math> до <math>n</math>
# <math>c_{i} = 0</math>
# <math>IAA = IA[i]</math>
# <math>IAB = IA[i + 1] - 1</math>
# <math>c_{i} = \sum\limits_{k = IAA}^{IAB} AN[k]b_{JA[k]}</math>.
После этого (если <math>i \le n</math>) происходит переход к шагу 1 с бо́льшим <math>i</math>.

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размером <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в последовательном (наиболее быстром) варианте требуется:

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

Умножения и сложения составляют ''основную часть алгоритма''.

При классификации по последовательной сложности, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам <math>O(l)</math>.

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

Опишем [[глоссарий#Граф алгоритма|граф алгоритма]]<ref>Воеводин В.В. Математические основы параллельных вычислений// М.: Изд. Моск. ун-та, 1991. 345 с.</ref><ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. – СПб.: БХВ - Петербург, 2002. – 608 с.</ref><ref>Фролов А.В.. Принципы построения и описание языка Сигма. Препринт ОВМ АН N 236. М.: ОВМ АН СССР, 1989.</ref> как аналитически, так и в виде рисунка.

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

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

* <math>i</math> — меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math> - элемент ''входных данных'', а именно <math>AN[IA_{i}+j-1]</math>.
* <math>b</math> - элемент ''входных данных'', а именно <math>b[IA_{i}+j-1]</math>.

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

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция <math>a + b</math>.
Естественно введённые координаты области таковы:
* <math>i</math> - меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> - меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math>:
** при <math>j = 1</math> - результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j)</math>;
** при <math>j > 1</math> - результат срабатывания операции, соответствующей вершине из второй группы, с координатами <math>(i, j - 1)</math>;
* <math>b</math> — результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j + 1)</math>.

Результат срабатывания операции:
* при <math>j < k - 1</math> является ''промежуточным данным'' алгоритма;
* при <math>j = k - 1</math> является ''выходным данным'' <math>c_{i}</math>.

Описанный граф можно посмотреть на рис.1. Здесь вершины первой группы обозначены красным цветом и отмечены знаком умножения, вершины второй - зелёным цветом и знаком сложения. Вершины, соответствующие входным данным обозначены белым цветом и выходным - синим.
[[file:Bliznalg.png|thumb|center|1000px|Рисунок 1. Граф алгоритма умножения разреженной матрицы на вектор]]

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размерности <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в параллельном варианте требуется последовательно выполнить следующие ярусы:

* Не более чем <math>m</math> сложений и умножений (<math>n</math> вычислений в каждом из ярусов)

При классификации по высоте ЯПФ, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам со сложностью <math>O(m)</math>. При классификации по ширине ЯПФ его сложность будет <math>O(n)</math>.

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

'''Входные данные''': разреженная матрица общего вида <math>A</math> размерности <math>n \times m</math>, хранимая в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>. Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> размерности <math>m \times 1</math>.

'''Объём входных данных''': <math>2l+m+n+1</math>, где <math>l</math> - количество ненулевых элементов в матрице <math>A</math>.

'''Выходные данные''': заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

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

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

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

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

Пусть <math>l</math> - количество ненулевых элементов матрицы <math>A</math> размерности <math>n \times m</math>. Пусть <math>x</math> - объем памяти, используемый для хранения значения элемента матрицы, <math>y</math> - объём памяти, используемый для хранения номера столбца или строки. В таком случае для хранения матрицы в стандартном представлении нам потребуется объем памяти, равный <math>x \cdot n \cdot m</math>, для хранения в формате '''RR(C)''' - <math>y(n + 1) + (x + y)l</math>. Таким образом хранение в формате '''RR(C)''' не является эффективным для матриц, в которых <math>l > \frac{xnm - y(n+1)}{x+y}</math>.

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

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

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

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

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

Параллельная реализация алгоритма заключается в следующем:

# Каждый процессор считывает входные данные из файла, зависящего от его номера. Данные имеют вид: вектор <math>b</math> и набор определённых строк матрицы <math>A</math> в формате '''RR(C)U''' в зависимости от номера процессора и их числа;
# Процессоры проводят вычисления значений вектора <math>c</math> в зависимости от имеющихся данных;
# Все процессоры отправляют результаты вычисления процессору, выбранному главным, и главный процессор выводит результат вычислений.

<div class="mw-collapsible mw-collapsed" style="width:100%">
Текст использованной в экспериментах реализации (язык ''С++''):
<div class="mw-collapsible-content">
<source lang="c++">
#include <mpi.h>
#include <memory>
#include <iostream>
#include <vector>
#include <sstream>
#include <fstream>
#include <string>
#include <iterator>

typedef std::shared_ptr<std::vector<std::vector<int> > > MyData;

MyData ReadData(const std::string& data_path) {
std::ifstream file_stream;
MyData retval(new std::vector<std::vector<int> >());
file_stream.open(data_path);

while (!file_stream.eof()) {
std::string str;
std::getline(file_stream, str);

std::istringstream iss(str);
auto temp_1 = (std::istream_iterator<std::string>(iss));
auto temp_2 = (std::istream_iterator<std::string>());

std::vector<std::string> coordinates{ temp_1, temp_2};
retval->push_back(std::vector<int>());
for (auto& e : coordinates) {
retval->back().push_back(std::stoi(e));
}
}

return retval;
}

// input: vector b, vector ia, vector ja, vector an
int main(int argc, char** argv){
MPI_Init(&argc, &argv);
int pid, np;
MPI_Status *s = new MPI_Status;
MPI_Comm_rank(MPI_COMM_WORLD, &pid);
MPI_Comm_size(MPI_COMM_WORLD, &np);
if (argc == 2){
int n;
int indx = 0;
int stp;
double strttime = MPI_Wtime();
std::vector<int> b;
std::vector<int> ia;
std::vector<int> ja;
std::vector<int> an;
auto data = ReadData("data_" + std::to_string(static_cast<long long>(pid)) + ".txt");
b = (*data)[0];
ia = (*data)[1];
ja = (*data)[2];
an = (*data)[3];
n = (*data)[0].size();
std::vector<int> c;
stp = n / np + ((n % np > pid) ? 1 : 0);
if (pid == 0){
c.resize(n, 0);
}
else{
c.resize(stp, 0);
}
for (int i = 0; i < stp; i++){
int strt = ia[i] - ia[0];
int lstr = ia[i + 1] - ia[i];
for (int j = 0; j < lstr; j++){
c[i] += an[strt + j] * b[ja[strt + j]];
}
}
if (pid == 0){
for (int i = 1; i < np; i++){
indx += n / np + ((n % np > i - 1) ? 1 : 0);
stp = n / np + ((n % np > i) ? 1 : 0);
MPI_Recv(&c[indx], stp, MPI_INT, i, 0, MPI_COMM_WORLD, s);
}
}
else{
MPI_Send(&c[0], stp, MPI_INT, 0, 0, MPI_COMM_WORLD);
}
if (pid == 0){
for (int e : c) {
std::cout << e << "\n";
}
double endtime = MPI_Wtime();
std::cout << "Success! Time = " << endtime - strttime << "\n";
}
}
MPI_Finalize();
return 0;
}
</source>
</div></div>

<div class="mw-collapsible mw-collapsed" style="width:100%">
Для формирования входных данных использовался следующий алгоритм (язык ''Python''):
<div class="mw-collapsible-content">
<source lang="python">
from scipy import sparse as sp
from numpy.random import randint
from os import mkdir
from os.path import join as jn

n = 10000
np = [1, 2, 4, 8, 16, 32, 64, 128]

a = sp.csr_matrix(randint(0, 2, (n, n)))
b = randint(1, 5, n)
i = 0

for j in np:
mkdir('data_' + str(j))
indx = 0
for i in range(0, j):
stp = n / j + (1 if (n % j > i) else 0)
ael = a.indptr[indx + stp] - a.indptr[indx]
strt = a.indptr[indx]
with open(jn('data_' + str(j), 'data_' + str(i) + '.txt'), 'w') as fout:

for e in b:
fout.write('{0} '.format(e))
fout.write('\n')

s = a.indptr[indx:indx + stp + 1]
for e in s:
fout.write('{0} '.format(e))
fout.write('\n')

s = a.indices[strt:strt + ael]
for e in s:
fout.write('{0} '.format(e))
fout.write('\n')

s = a.data[strt:strt + ael]
for e in s:
fout.write('{0} '.format(e))
fout.write('\n')

indx = indx + n / j + (1 if (n % j > i) else 0)
</source>
</div></div>

Проведём исследование масштабируемости параллельной реализации алгоритма умножения разреженной матрицы на вектор. Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета]. Входные данные формировались на персональном компьютере в силу того, что интерпретатор на суперкомпьютере "Ломоносов" не удовлетворял нужным требованиям, и потом отправлялись на суперкомпьютер для последующей обработки.

Программа была собрана на узле компиляции суперкомпьютера "Ломоносов", с помощью компилятора ''intel/15.0.090'' и компилятора ''openmpi/1.6.5-icc'', на языке ''С++11''.

<div class="mw-collapsible mw-collapsed" style="width:100%">
Сборка производилась с помощью ''CMakeLists.txt'', его содержание прилагается:
<div class="mw-collapsible-content">
<pre>
cmake_minimum_required(VERSION 2.8)

project(task1)

set(CMAKE_CXX_STANDARD 11)

set(CXX_STANDARD_REQUIRED)

set(CMAKE_C_COMPILER mpicc)
set(CMAKE_CXX_COMPILER mpicxx)

find_package(MPI REQUIRED)

include_directories(${MPI_INCLUDE_PATH})

SET(CMAKE_CXX_COMPILER mpicc)

if(MPI_COMPILE_FLAGS)
set_target_properties(task1 PROPERTIES
COMPILE_FLAGS "${MPI_COMPILE_FLAGS}")
endif()

set(CMAKE_CXX_FLAGS "-std=c++11 -fpermissive " ${MPI_COMPILE_FLAGS})

set(SOURCE_EXE task1.cpp)

add_executable(task1 ${SOURCE_EXE})

target_link_libraries(task1)
</pre>
</div></div>

Запуск производился на вычислительных узлах суперкомпьютера "Ломоносов".

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

* число процессоров [1 : 128] по степеням 2;
* размер матрицы [1000 : 10000] с шагом 1000.

[[file:Blizntime.png|thumb|center|1000px|Рисунок 2. Время работы программы в зависимости от количества процессоров и размера матрицы]]

Можно заметить, что при небольшом количестве входных данных, и большом количестве процессоров эффективность распараллеливания падает до нуля, поскольку время вычисления элементов вектора <math>c</math> становится несоизмеримо малым по сравнению с временем, затраченным на пересылку в пункте (3).

[[file:Efficiency(paral).png|thumb|center|1000px|Рисунок 4. Эффективность распараллеливания в зависимости от количества процессоров и размера матрицы]]

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

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

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

Существующие реализации:

SciPy [https://docs.scipy.org/doc/scipy-0.18.1/reference/index.html],

MatLab [https://www.mathworks.com/help/matlab/math/sparse-matrix-operations.html],

Intel MKL [https://software.intel.com/en-us/articles/intel-math-kernel-library-inspector-executor-sparse-blas-routines].

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

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

2016-11-30T21:11:52Z

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

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>O(l)</math>
| pf_height = <math>O(m)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>2l+m+n+1</math>
| output_data = <math>n</math>
}}
Выполнила: [[Участник:Blizn|И.В. Близнякова]] (611 группа).

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

== Общее описание алгоритма<ref>С.Писсанецки. Технология разреженных матриц. - М.: Мир, 1988.</ref> ==
'''Разрежённая матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается '''''плотной'''''.

Среди специалистов нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:
* есть <math>O(n)</math>. Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;
* в каждой строке не превышает 10 в типичном случае;
* ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.
* таково, что для данного алгоритма и вычислительной системы имеет смысл извлекать выгоду из наличия в ней нулей.

=== Хранение разреженной матрицы ===
==== Формат RR(C)O ====
Рассмотрим сначала формат '''RR(C)O'''. Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Ordered"'' (строчное представление, полное и упорядоченное). В данном формате вместо одного двумерного массива, используются три одномерных. Значения ненулевых элементов матрицы и соответствующие им столбцовые индексы хранятся в этом формате по строкам в двух массивах <math>AN</math> и <math>JA</math>. Массив указателей <math>IA</math>, используется для ссылки на компоненты массивов <math>AN</math> и <math>JA</math>, с которых начинается описание очередной строки. Последняя компонента массива <math>IA</math> содержит указатель первой свободной компоненты в массивах <math>AN</math> и <math>JA</math>, т.е. равна числу ненулевых элементов матрицы, увеличенному на единицу. Здесь уместно привести пример.

Рассмотрим матрицу <math>A</math>:
:<math>\begin{pmatrix}
0 & 0 & 0 & 2 & 0 \\
1 & 0 & 3 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 \\
0 & 6 & 0 & 0 & 0 \\
0 & 0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
тогда ее представление в формате '''RR(C)O''' будет иметь вид:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 1 3 2 3 ]
AN = [ 2 1 3 6 4 ]
Т.е. массив <math>AN</math> содержит все не нулевые элементы исходной матрицы <math>A</math>, массив <math>JA</math> номер столбца в котором находится соответствующий элемент из <math>AN</math> и наконец массив <math>IA</math> содержит номер с которого начинается описание элементов в массивах <math>JA</math> и <math>AN</math>. Таким образом информация об элементах 2-ой строки матрицы хранится в элементах с <math>IA[2] = 2</math> по <math>IA[3] - 1 = 3</math> включительно массивов <math>JA</math> и <math>AN</math>. Можно обратить внимание, что <math>IA[3] = IA[4] = 4</math>, а это означает, что 3-я строка матрицы <math>A</math> нулевая.

В общем случае описание <math>r</math>-й строки матрицы A хранится в компонентах с <math>IA[r]</math> до <math>IA[r + 1] - 1</math> включительно массивов <math>AN</math> и <math>JA</math>. Если <math>IA[r + 1] = IA[r]</math>, то это означает, что <math>r</math>-я строка нулевая. Количество элементов в массиве <math>IA</math> на единицу больше, чем число строк исходной матрицы, а количество элементов в массивах <math>JA</math> и <math>AN</math> равно числу ненулевых элементов исходной матрицы.

Данный способ представления называют ''полным'', поскольку представлена вся матрица <math>A</math>, ''упорядоченным'', поскольку элементы каждой строки матрицы <math>A</math> хранятся в соответствии с возрастанием столбцовых индексов, и строчным, поскольку информация о матрице <math>A</math> указывается по строкам.

Массивы <math>IA</math> и <math>JA</math> представляют портрет (структуру) матрицы <math>A</math>, задаваемый как множество списков смежности ассоциированного с <math>A</math> графа. Если алгоритм, реализующий какую-либо операцию над разреженными матрицами, разбит на этапы символической обработки, на котором определяется портрет результирующей матрицы, и численной обработки, на котором определяются значения элементов результирующей матрицы, то массивы <math>IA</math> и <math>JA</math> заполняются на первом этапе, а массив <math>AN</math> - на втором.

==== Формат RR(C)U ====

Рассмотрим теперь формат '''RR(C)U'''.

Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Unordered"'' (строчное представление, полное, но неупорядоченное). Формат '''RR(C)U''' отличается от '''RR(C)O''' тем, что в данном случае соблюдается упорядоченность строк, но внутри каждой строки элементы исходных матриц могут храниться в произвольном порядке. Для матрицы <math>A</math> нашего примера вполне можно было бы использовать и строчное представление, полное, но неупорядоченное такое:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 3 1 2 3 ]
AN = [ 2 1 3 6 4 ]
Такие неупорядоченные представления могут быть очень удобны в практических вычислениях. Результаты большинства матричных операций получаются неупорядоченными, а их упорядочение стоило бы значительных затрат машинного времени. В то же время, за немногими исключениями, алгоритмы для разреженных матриц не требуют, чтобы их представления были упорядоченными.

==== Замечания ====

Несколько замечаний по поводу рассмотренных форматов представления:
# Очевидно, что представление матрицы в формате '''RR(C)O''' так же является и представлением в формате '''RR(C)U''', но не наоборот.
# Из представления матрицы в формате '''RR(C)''' нельзя получить информацию о точном количестве столбцов исходной матрицы.
# Целесообразно (в вопросе экономии памяти) использовать представления '''RR(C)''' в случае, если матрица содержит значительное число нулевых элементов.

=== Умножение разреженной матрицы на вектор ===

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

Мы рассмотрим умножение разреженной матрицы общего вида, хранимой в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math> на заполненный вектор-столбец.

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

Исходные данные: разреженная матрица общего вида <math>A</math> с элементами <math>a_{ij}</math> (<math>i = 1,...,n</math> и <math>j = 1,...,m</math>). Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> (<math>j =1,...,m</math>).

Вычисляемые данные: заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

Формулы метода:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

где <math>l_{i}</math> - количество ненулевых элементов строки <math>i</math> матрицы <math>A</math>, <math>j(k)</math> - индекс <math>k</math>-го ненулевого элемента матрицы <math>A</math>.

== Вычислительное ядро алгоритма ==
Вычислительное ядро последовательной версии умножения разреженной матрицы на вектор можно составить из множественных (всего их <math>n</math>) вычислений скалярных произведений строк матрицы:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>.

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

Как записано и в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют множественные (всего <math>n</math>) вычисления сумм:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

которые могут вычисляться в произвольном порядке.

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

Далее предполагаем, что разреженная матрица общего вида <math>A</math> хранится в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>.
Последовательность исполнения метода следующая:

Выполнять для <math>i</math> от <math>1</math> до <math>n</math>
# <math>c_{i} = 0</math>
# <math>IAA = IA[i]</math>
# <math>IAB = IA[i + 1] - 1</math>
# <math>c_{i} = \sum\limits_{k = IAA}^{IAB} AN[k]b_{JA[k]}</math>.
После этого (если <math>i \le n</math>) происходит переход к шагу 1 с бо́льшим <math>i</math>.

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размером <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в последовательном (наиболее быстром) варианте требуется:

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

Умножения и сложения составляют ''основную часть алгоритма''.

При классификации по последовательной сложности, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам <math>O(l)</math>.

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

Опишем [[глоссарий#Граф алгоритма|граф алгоритма]]<ref>Воеводин В.В. Математические основы параллельных вычислений// М.: Изд. Моск. ун-та, 1991. 345 с.</ref><ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. – СПб.: БХВ - Петербург, 2002. – 608 с.</ref><ref>Фролов А.В.. Принципы построения и описание языка Сигма. Препринт ОВМ АН N 236. М.: ОВМ АН СССР, 1989.</ref> как аналитически, так и в виде рисунка.

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

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

* <math>i</math> — меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math> - элемент ''входных данных'', а именно <math>AN[IA_{i}+j-1]</math>.
* <math>b</math> - элемент ''входных данных'', а именно <math>b[IA_{i}+j-1]</math>.

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

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция <math>a + b</math>.
Естественно введённые координаты области таковы:
* <math>i</math> - меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> - меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math>:
** при <math>j = 1</math> - результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j)</math>;
** при <math>j > 1</math> - результат срабатывания операции, соответствующей вершине из второй группы, с координатами <math>(i, j - 1)</math>;
* <math>b</math> — результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j + 1)</math>.

Результат срабатывания операции:
* при <math>j < k - 1</math> является ''промежуточным данным'' алгоритма;
* при <math>j = k - 1</math> является ''выходным данным'' <math>c_{i}</math>.

Описанный граф можно посмотреть на рис.1. Здесь вершины первой группы обозначены красным цветом и отмечены знаком умножения, вершины второй - зелёным цветом и знаком сложения. Вершины, соответствующие входным данным обозначены белым цветом и выходным - синим.
[[file:Bliznalg.png|thumb|center|1000px|Рисунок 1. Граф алгоритма умножения разреженной матрицы на вектор]]

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размерности <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в параллельном варианте требуется последовательно выполнить следующие ярусы:

* Не более чем <math>m</math> сложений и умножений (<math>n</math> вычислений в каждом из ярусов)

При классификации по высоте ЯПФ, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам со сложностью <math>O(m)</math>. При классификации по ширине ЯПФ его сложность будет <math>O(n)</math>.

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

'''Входные данные''': разреженная матрица общего вида <math>A</math> размерности <math>n \times m</math>, хранимая в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>. Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> размерности <math>m \times 1</math>.

'''Объём входных данных''': <math>2l+m+n+1</math>, где <math>l</math> - количество ненулевых элементов в матрице <math>A</math>.

'''Выходные данные''': заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

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

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

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

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

Пусть <math>l</math> - количество ненулевых элементов матрицы <math>A</math> размерности <math>n \times m</math>. Пусть <math>x</math> - объем памяти, используемый для хранения значения элемента матрицы, <math>y</math> - объём памяти, используемый для хранения номера столбца или строки. В таком случае для хранения матрицы в стандартном представлении нам потребуется объем памяти, равный <math>x \cdot n \cdot m</math>, для хранения в формате '''RR(C)''' - <math>y(n + 1) + (x + y)l</math>. Таким образом хранение в формате '''RR(C)''' не является эффективным для матриц, в которых <math>l > \frac{xnm - y(n+1)}{x+y}</math>.

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

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

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

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

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

Параллельная реализация алгоритма заключается в следующем:

# Каждый процессор считывает входные данные из файла, зависящего от его номера. Данные имеют вид: вектор <math>b</math> и набор определённых строк матрицы <math>A</math> в формате '''RR(C)U''' в зависимости от номера процессора и их числа;
# Процессоры проводят вычисления значений вектора <math>c</math> в зависимости от имеющихся данных;
# Все процессоры отправляют результаты вычисления процессору, выбранному главным, и главный процессор выводит результат вычислений.

<div class="mw-collapsible mw-collapsed" style="width:100%">
Текст использованной в экспериментах реализации (язык ''С++''):
<div class="mw-collapsible-content">
<source lang="c++">
#include <mpi.h>
#include <memory>
#include <iostream>
#include <vector>
#include <sstream>
#include <fstream>
#include <string>
#include <iterator>

typedef std::shared_ptr<std::vector<std::vector<int> > > MyData;

MyData ReadData(const std::string& data_path) {
std::ifstream file_stream;
MyData retval(new std::vector<std::vector<int> >());
file_stream.open(data_path);

while (!file_stream.eof()) {
std::string str;
std::getline(file_stream, str);

std::istringstream iss(str);
auto temp_1 = (std::istream_iterator<std::string>(iss));
auto temp_2 = (std::istream_iterator<std::string>());

std::vector<std::string> coordinates{ temp_1, temp_2};
retval->push_back(std::vector<int>());
for (auto& e : coordinates) {
retval->back().push_back(std::stoi(e));
}
}

return retval;
}

// input: vector b, vector ia, vector ja, vector an
int main(int argc, char** argv){
MPI_Init(&argc, &argv);
int pid, np;
MPI_Status *s = new MPI_Status;
MPI_Comm_rank(MPI_COMM_WORLD, &pid);
MPI_Comm_size(MPI_COMM_WORLD, &np);
if (argc == 2){
int n;
int indx = 0;
int stp;
double strttime = MPI_Wtime();
std::vector<int> b;
std::vector<int> ia;
std::vector<int> ja;
std::vector<int> an;
auto data = ReadData("data_" + std::to_string(static_cast<long long>(pid)) + ".txt");
b = (*data)[0];
ia = (*data)[1];
ja = (*data)[2];
an = (*data)[3];
n = (*data)[0].size();
std::vector<int> c;
stp = n / np + ((n % np > pid) ? 1 : 0);
if (pid == 0){
c.resize(n, 0);
}
else{
c.resize(stp, 0);
}
for (int i = 0; i < stp; i++){
int strt = ia[i] - ia[0];
int lstr = ia[i + 1] - ia[i];
for (int j = 0; j < lstr; j++){
c[i] += an[strt + j] * b[ja[strt + j]];
}
}
if (pid == 0){
for (int i = 1; i < np; i++){
indx += n / np + ((n % np > i - 1) ? 1 : 0);
stp = n / np + ((n % np > i) ? 1 : 0);
MPI_Recv(&c[indx], stp, MPI_INT, i, 0, MPI_COMM_WORLD, s);
}
}
else{
MPI_Send(&c[0], stp, MPI_INT, 0, 0, MPI_COMM_WORLD);
}
if (pid == 0){
for (int e : c) {
std::cout << e << "\n";
}
double endtime = MPI_Wtime();
std::cout << "Success! Time = " << endtime - strttime << "\n";
}
}
MPI_Finalize();
return 0;
}
</source>
</div></div>

<div class="mw-collapsible mw-collapsed" style="width:100%">
Для формирования входных данных использовался следующий алгоритм (язык ''Python''):
<div class="mw-collapsible-content">
<source lang="python">
from scipy import sparse as sp
from numpy.random import randint
from os import mkdir
from os.path import join as jn

n = 10000
np = [1, 2, 4, 8, 16, 32, 64, 128]

a = sp.csr_matrix(randint(0, 2, (n, n)))
b = randint(1, 5, n)
i = 0

for j in np:
mkdir('data_' + str(j))
indx = 0
for i in range(0, j):
stp = n / j + (1 if (n % j > i) else 0)
ael = a.indptr[indx + stp] - a.indptr[indx]
strt = a.indptr[indx]
with open(jn('data_' + str(j), 'data_' + str(i) + '.txt'), 'w') as fout:

for e in b:
fout.write('{0} '.format(e))
fout.write('\n')

s = a.indptr[indx:indx + stp + 1]
for e in s:
fout.write('{0} '.format(e))
fout.write('\n')

s = a.indices[strt:strt + ael]
for e in s:
fout.write('{0} '.format(e))
fout.write('\n')

s = a.data[strt:strt + ael]
for e in s:
fout.write('{0} '.format(e))
fout.write('\n')

indx = indx + n / j + (1 if (n % j > i) else 0)
</source>
</div></div>

Проведём исследование масштабируемости параллельной реализации алгоритма умножения разреженной матрицы на вектор. Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета]. Входные данные формировались на персональном компьютере в силу того, что интерпретатор на суперкомпьютере "Ломоносов" не удовлетворял нужным требованиям, и потом отправлялись на суперкомпьютер для последующей обработки.

Программа была собрана на узле компиляции суперкомпьютера "Ломоносов", с помощью компилятора ''intel-15'' и компилятора ''openmpi-1.6.5-icc'', на языке ''С++11''.

<div class="mw-collapsible mw-collapsed" style="width:100%">
Сборка производилась с помощью ''CMakeLists.txt'', его содержание прилагается:
<div class="mw-collapsible-content">
<pre>
</pre>
</div></div>

Запуск производился на вычислительных узлах суперкомпьютера "Ломоносов".

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

* число процессоров [1 : 128] по степеням 2;
* размер матрицы [1000 : 10000] с шагом 1000.

[[file:Blizntime.png|thumb|center|1000px|Рисунок 2. Время работы программы в зависимости от количества процессоров и размера матрицы]]

Можно заметить, что при небольшом количестве входных данных, и большом количестве процессоров эффективность распараллеливания падает до нуля, поскольку время вычисления элементов вектора <math>c</math> становится несоизмеримо малым по сравнению с временем, затраченным на пересылку в пункте (3).

[[file:Efficiency(paral).png|thumb|center|1000px|Рисунок 4. Эффективность распараллеливания в зависимости от количества процессоров и размера матрицы]]

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

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

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

Существующие реализации:

SciPy [https://docs.scipy.org/doc/scipy-0.18.1/reference/index.html],

MatLab [https://www.mathworks.com/help/matlab/math/sparse-matrix-operations.html],

Intel MKL [https://software.intel.com/en-us/articles/intel-math-kernel-library-inspector-executor-sparse-blas-routines].

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

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

2016-11-30T19:23:08Z

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

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>O(l)</math>
| pf_height = <math>O(m)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>2l+m+n+1</math>
| output_data = <math>n</math>
}}
Выполнила: [[Участник:Blizn|И.В. Близнякова]] (611 группа).

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

== Общее описание алгоритма<ref>С.Писсанецки. Технология разреженных матриц. - М.: Мир, 1988.</ref> ==
'''Разрежённая матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается '''''плотной'''''.

Среди специалистов нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:
* есть <math>O(n)</math>. Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;
* в каждой строке не превышает 10 в типичном случае;
* ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.
* таково, что для данного алгоритма и вычислительной системы имеет смысл извлекать выгоду из наличия в ней нулей.

=== Хранение разреженной матрицы ===
==== Формат RR(C)O ====
Рассмотрим сначала формат '''RR(C)O'''. Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Ordered"'' (строчное представление, полное и упорядоченное). В данном формате вместо одного двумерного массива, используются три одномерных. Значения ненулевых элементов матрицы и соответствующие им столбцовые индексы хранятся в этом формате по строкам в двух массивах <math>AN</math> и <math>JA</math>. Массив указателей <math>IA</math>, используется для ссылки на компоненты массивов <math>AN</math> и <math>JA</math>, с которых начинается описание очередной строки. Последняя компонента массива <math>IA</math> содержит указатель первой свободной компоненты в массивах <math>AN</math> и <math>JA</math>, т.е. равна числу ненулевых элементов матрицы, увеличенному на единицу. Здесь уместно привести пример.

Рассмотрим матрицу <math>A</math>:
:<math>\begin{pmatrix}
0 & 0 & 0 & 2 & 0 \\
1 & 0 & 3 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 \\
0 & 6 & 0 & 0 & 0 \\
0 & 0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
тогда ее представление в формате '''RR(C)O''' будет иметь вид:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 1 3 2 3 ]
AN = [ 2 1 3 6 4 ]
Т.е. массив <math>AN</math> содержит все не нулевые элементы исходной матрицы <math>A</math>, массив <math>JA</math> номер столбца в котором находится соответствующий элемент из <math>AN</math> и наконец массив <math>IA</math> содержит номер с которого начинается описание элементов в массивах <math>JA</math> и <math>AN</math>. Таким образом информация об элементах 2-ой строки матрицы хранится в элементах с <math>IA[2] = 2</math> по <math>IA[3] - 1 = 3</math> включительно массивов <math>JA</math> и <math>AN</math>. Можно обратить внимание, что <math>IA[3] = IA[4] = 4</math>, а это означает, что 3-я строка матрицы <math>A</math> нулевая.

В общем случае описание <math>r</math>-й строки матрицы A хранится в компонентах с <math>IA[r]</math> до <math>IA[r + 1] - 1</math> включительно массивов <math>AN</math> и <math>JA</math>. Если <math>IA[r + 1] = IA[r]</math>, то это означает, что <math>r</math>-я строка нулевая. Количество элементов в массиве <math>IA</math> на единицу больше, чем число строк исходной матрицы, а количество элементов в массивах <math>JA</math> и <math>AN</math> равно числу ненулевых элементов исходной матрицы.

Данный способ представления называют ''полным'', поскольку представлена вся матрица <math>A</math>, ''упорядоченным'', поскольку элементы каждой строки матрицы <math>A</math> хранятся в соответствии с возрастанием столбцовых индексов, и строчным, поскольку информация о матрице <math>A</math> указывается по строкам.

Массивы <math>IA</math> и <math>JA</math> представляют портрет (структуру) матрицы <math>A</math>, задаваемый как множество списков смежности ассоциированного с <math>A</math> графа. Если алгоритм, реализующий какую-либо операцию над разреженными матрицами, разбит на этапы символической обработки, на котором определяется портрет результирующей матрицы, и численной обработки, на котором определяются значения элементов результирующей матрицы, то массивы <math>IA</math> и <math>JA</math> заполняются на первом этапе, а массив <math>AN</math> - на втором.

==== Формат RR(C)U ====

Рассмотрим теперь формат '''RR(C)U'''.

Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Unordered"'' (строчное представление, полное, но неупорядоченное). Формат '''RR(C)U''' отличается от '''RR(C)O''' тем, что в данном случае соблюдается упорядоченность строк, но внутри каждой строки элементы исходных матриц могут храниться в произвольном порядке. Для матрицы <math>A</math> нашего примера вполне можно было бы использовать и строчное представление, полное, но неупорядоченное такое:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 3 1 2 3 ]
AN = [ 2 1 3 6 4 ]
Такие неупорядоченные представления могут быть очень удобны в практических вычислениях. Результаты большинства матричных операций получаются неупорядоченными, а их упорядочение стоило бы значительных затрат машинного времени. В то же время, за немногими исключениями, алгоритмы для разреженных матриц не требуют, чтобы их представления были упорядоченными.

==== Замечания ====

Несколько замечаний по поводу рассмотренных форматов представления:
# Очевидно, что представление матрицы в формате '''RR(C)O''' так же является и представлением в формате '''RR(C)U''', но не наоборот.
# Из представления матрицы в формате '''RR(C)''' нельзя получить информацию о точном количестве столбцов исходной матрицы.
# Целесообразно (в вопросе экономии памяти) использовать представления '''RR(C)''' в случае, если матрица содержит значительное число нулевых элементов.

=== Умножение разреженной матрицы на вектор ===

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

Мы рассмотрим умножение разреженной матрицы общего вида, хранимой в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math> на заполненный вектор-столбец.

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

Исходные данные: разреженная матрица общего вида <math>A</math> с элементами <math>a_{ij}</math> (<math>i = 1,...,n</math> и <math>j = 1,...,m</math>). Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> (<math>j =1,...,m</math>).

Вычисляемые данные: заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

Формулы метода:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

где <math>l_{i}</math> - количество ненулевых элементов строки <math>i</math> матрицы <math>A</math>, <math>j(k)</math> - индекс <math>k</math>-го ненулевого элемента матрицы <math>A</math>.

== Вычислительное ядро алгоритма ==
Вычислительное ядро последовательной версии умножения разреженной матрицы на вектор можно составить из множественных (всего их <math>n</math>) вычислений скалярных произведений строк матрицы:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>.

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

Как записано и в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют множественные (всего <math>n</math>) вычисления сумм:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

которые могут вычисляться в произвольном порядке.

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

Далее предполагаем, что разреженная матрица общего вида <math>A</math> хранится в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>.
Последовательность исполнения метода следующая:

Выполнять для <math>i</math> от <math>1</math> до <math>n</math>
# <math>c_{i} = 0</math>
# <math>IAA = IA[i]</math>
# <math>IAB = IA[i + 1] - 1</math>
# <math>c_{i} = \sum\limits_{k = IAA}^{IAB} AN[k]b_{JA[k]}</math>.
После этого (если <math>i \le n</math>) происходит переход к шагу 1 с бо́льшим <math>i</math>.

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размером <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в последовательном (наиболее быстром) варианте требуется:

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

Умножения и сложения составляют ''основную часть алгоритма''.

При классификации по последовательной сложности, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам <math>O(l)</math>.

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

Опишем [[глоссарий#Граф алгоритма|граф алгоритма]]<ref>Воеводин В.В. Математические основы параллельных вычислений// М.: Изд. Моск. ун-та, 1991. 345 с.</ref><ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. – СПб.: БХВ - Петербург, 2002. – 608 с.</ref><ref>Фролов А.В.. Принципы построения и описание языка Сигма. Препринт ОВМ АН N 236. М.: ОВМ АН СССР, 1989.</ref> как аналитически, так и в виде рисунка.

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

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

* <math>i</math> — меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math> - элемент ''входных данных'', а именно <math>AN[IA_{i}+j-1]</math>.
* <math>b</math> - элемент ''входных данных'', а именно <math>b[IA_{i}+j-1]</math>.

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

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция <math>a + b</math>.
Естественно введённые координаты области таковы:
* <math>i</math> - меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> - меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math>:
** при <math>j = 1</math> - результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j)</math>;
** при <math>j > 1</math> - результат срабатывания операции, соответствующей вершине из второй группы, с координатами <math>(i, j - 1)</math>;
* <math>b</math> — результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j + 1)</math>.

Результат срабатывания операции:
* при <math>j < k - 1</math> является ''промежуточным данным'' алгоритма;
* при <math>j = k - 1</math> является ''выходным данным'' <math>c_{i}</math>.

Описанный граф можно посмотреть на рис.1. Здесь вершины первой группы обозначены красным цветом и отмечены знаком умножения, вершины второй - зелёным цветом и знаком сложения. Вершины, соответствующие входным данным обозначены белым цветом и выходным - синим.
[[file:Bliznalg.png|thumb|center|1000px|Рисунок 1. Граф алгоритма умножения разреженной матрицы на вектор]]

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размерности <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в параллельном варианте требуется последовательно выполнить следующие ярусы:

* Не более чем <math>m</math> сложений и умножений (<math>n</math> вычислений в каждом из ярусов)

При классификации по высоте ЯПФ, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам со сложностью <math>O(m)</math>. При классификации по ширине ЯПФ его сложность будет <math>O(n)</math>.

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

'''Входные данные''': разреженная матрица общего вида <math>A</math> размерности <math>n \times m</math>, хранимая в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>. Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> размерности <math>m \times 1</math>.

'''Объём входных данных''': <math>2l+m+n+1</math>, где <math>l</math> - количество ненулевых элементов в матрице <math>A</math>.

'''Выходные данные''': заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

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

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

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

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

Пусть <math>l</math> - количество ненулевых элементов матрицы <math>A</math> размерности <math>n \times m</math>. Пусть <math>x</math> - объем памяти, используемый для хранения значения элемента матрицы, <math>y</math> - объём памяти, используемый для хранения номера столбца или строки. В таком случае для хранения матрицы в стандартном представлении нам потребуется объем памяти, равный <math>x \cdot n \cdot m</math>, для хранения в формате '''RR(C)''' - <math>y(n + 1) + (x + y)l</math>. Таким образом хранение в формате '''RR(C)''' не является эффективным для матриц, в которых <math>l > \frac{xnm - y(n+1)}{x+y}</math>.

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

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

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

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

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

Параллельная реализация алгоритма заключается в следующем:

# Каждый процессор считывает входные данные из файла, зависящего от его номера. Данные имеют вид: вектор <math>b</math> и набор определённых строк матрицы <math>A</math> в формате '''RR(C)U''' в зависимости от номера процессора и их числа;
# Процессоры проводят вычисления значений вектора <math>c</math> в зависимости от имеющихся данных;
# Все процессоры отправляют результаты вычисления процессору, выбранному главным, и главный процессор выводит результат вычислений.

<div class="mw-collapsible mw-collapsed" style="width:100%">
Текст использованной в экспериментах реализации (язык С++):
<div class="mw-collapsible-content">
<source lang="c++">
#include <mpi.h>
#include <memory>
#include <iostream>
#include <vector>
#include <sstream>
#include <fstream>
#include <string>
#include <iterator>

typedef std::shared_ptr<std::vector<std::vector<int> > > MyData;

MyData ReadData(const std::string& data_path) {
std::ifstream file_stream;
MyData retval(new std::vector<std::vector<int> >());
file_stream.open(data_path);

while (!file_stream.eof()) {
std::string str;
std::getline(file_stream, str);

std::istringstream iss(str);
auto temp_1 = (std::istream_iterator<std::string>(iss));
auto temp_2 = (std::istream_iterator<std::string>());

std::vector<std::string> coordinates{ temp_1, temp_2};
retval->push_back(std::vector<int>());
for (auto& e : coordinates) {
retval->back().push_back(std::stoi(e));
}
}

return retval;
}

// input: vector b, vector ia, vector ja, vector an
int main(int argc, char** argv){
MPI_Init(&argc, &argv);
int pid, np;
MPI_Status *s = new MPI_Status;
MPI_Comm_rank(MPI_COMM_WORLD, &pid);
MPI_Comm_size(MPI_COMM_WORLD, &np);
if (argc == 2){
int n;
int indx = 0;
int stp;
double strttime = MPI_Wtime();
std::vector<int> b;
std::vector<int> ia;
std::vector<int> ja;
std::vector<int> an;
auto data = ReadData("data_" + std::to_string(static_cast<long long>(pid)) + ".txt");
b = (*data)[0];
ia = (*data)[1];
ja = (*data)[2];
an = (*data)[3];
n = (*data)[0].size();
std::vector<int> c;
stp = n / np + ((n % np > pid) ? 1 : 0);
if (pid == 0){
c.resize(n, 0);
}
else{
c.resize(stp, 0);
}
for (int i = 0; i < stp; i++){
int strt = ia[i] - ia[0];
int lstr = ia[i + 1] - ia[i];
for (int j = 0; j < lstr; j++){
c[i] += an[strt + j] * b[ja[strt + j]];
}
}
if (pid == 0){
for (int i = 1; i < np; i++){
indx += n / np + ((n % np > i - 1) ? 1 : 0);
stp = n / np + ((n % np > i) ? 1 : 0);
MPI_Recv(&c[indx], stp, MPI_INT, i, 0, MPI_COMM_WORLD, s);
}
}
else{
MPI_Send(&c[0], stp, MPI_INT, 0, 0, MPI_COMM_WORLD);
}
if (pid == 0){
for (int e : c) {
std::cout << e << "\n";
}
double endtime = MPI_Wtime();
std::cout << "Success! Time = " << endtime - strttime << "\n";
}
}
MPI_Finalize();
return 0;
}
</source>
</div></div>

<div class="mw-collapsible mw-collapsed" style="width:100%">
Для формирования входных данных использовался следующий алгоритм (язык Python):
<div class="mw-collapsible-content">
<source lang="python">
from scipy import sparse as sp
from numpy.random import randint
from os import mkdir
from os.path import join as jn

n = 10000
np = [1, 2, 4, 8, 16, 32, 64, 128]

a = sp.csr_matrix(randint(0, 2, (n, n)))
b = randint(1, 5, n)
i = 0

for j in np:
mkdir('data_' + str(j))
indx = 0
for i in range(0, j):
stp = n / j + (1 if (n % j > i) else 0)
ael = a.indptr[indx + stp] - a.indptr[indx]
strt = a.indptr[indx]
with open(jn('data_' + str(j), 'data_' + str(i) + '.txt'), 'w') as fout:

for e in b:
fout.write('{0} '.format(e))
fout.write('\n')

s = a.indptr[indx:indx + stp + 1]
for e in s:
fout.write('{0} '.format(e))
fout.write('\n')

s = a.indices[strt:strt + ael]
for e in s:
fout.write('{0} '.format(e))
fout.write('\n')

s = a.data[strt:strt + ael]
for e in s:
fout.write('{0} '.format(e))
fout.write('\n')

indx = indx + n / j + (1 if (n % j > i) else 0)
</source>
</div></div>

Проведём исследование масштабируемости параллельной реализации алгоритма умножения разреженной матрицы на вектор. Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета]. Входные данные формировались на персональном компьютере в силу того, что интерпретатор на суперкомпьютере "Ломоносов" не удовлетворял нужным требованиям, и потом отправлялись на суперкомпьютер для последующей обработки.

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

* число процессоров [1 : 128] по степеням 2;
* размер матрицы [1000 : 10000] с шагом 1000.

[[file:Blizntime.png|thumb|center|1000px|Рисунок 2. Время работы программы в зависимости от количества процессоров и размера матрицы]]

Можно заметить, что при небольшом количестве входных данных, и большом количестве процессоров эффективность распараллеливания падает до нуля, поскольку время вычисления элементов вектора <math>c</math> становится несоизмеримо малым по сравнению с временем, затраченным на пересылку в пункте (3).

[[file:Efficiency(paral).png|thumb|center|1000px|Рисунок 4. Эффективность распараллеливания в зависимости от количества процессоров и размера матрицы]]

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

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

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

Существующие реализации:

SciPy [https://docs.scipy.org/doc/scipy-0.18.1/reference/index.html],

MatLab [https://www.mathworks.com/help/matlab/math/sparse-matrix-operations.html],

Intel MKL [https://software.intel.com/en-us/articles/intel-math-kernel-library-inspector-executor-sparse-blas-routines].

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

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

2016-11-30T13:37:49Z

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

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>O(l)</math>
| pf_height = <math>O(m)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>2l+m+n+1</math>
| output_data = <math>n</math>
}}
Выполнила: [[Участник:Blizn|И.В. Близнякова]] (611 группа).

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

== Общее описание алгоритма<ref>С.Писсанецки. Технология разреженных матриц. - М.: Мир, 1988.</ref> ==
'''Разрежённая матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается '''''плотной'''''.

Среди специалистов нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:
* есть <math>O(n)</math>. Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;
* в каждой строке не превышает 10 в типичном случае;
* ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.
* таково, что для данного алгоритма и вычислительной системы имеет смысл извлекать выгоду из наличия в ней нулей.

=== Хранение разреженной матрицы ===
==== Формат RR(C)O ====
Рассмотрим сначала формат '''RR(C)O'''. Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Ordered"'' (строчное представление, полное и упорядоченное). В данном формате вместо одного двумерного массива, используются три одномерных. Значения ненулевых элементов матрицы и соответствующие им столбцовые индексы хранятся в этом формате по строкам в двух массивах <math>AN</math> и <math>JA</math>. Массив указателей <math>IA</math>, используется для ссылки на компоненты массивов <math>AN</math> и <math>JA</math>, с которых начинается описание очередной строки. Последняя компонента массива <math>IA</math> содержит указатель первой свободной компоненты в массивах <math>AN</math> и <math>JA</math>, т.е. равна числу ненулевых элементов матрицы, увеличенному на единицу. Здесь уместно привести пример.

Рассмотрим матрицу <math>A</math>:
:<math>\begin{pmatrix}
0 & 0 & 0 & 2 & 0 \\
1 & 0 & 3 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 \\
0 & 6 & 0 & 0 & 0 \\
0 & 0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
тогда ее представление в формате '''RR(C)O''' будет иметь вид:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 1 3 2 3 ]
AN = [ 2 1 3 6 4 ]
Т.е. массив <math>AN</math> содержит все не нулевые элементы исходной матрицы <math>A</math>, массив <math>JA</math> номер столбца в котором находится соответствующий элемент из <math>AN</math> и наконец массив <math>IA</math> содержит номер с которого начинается описание элементов в массивах <math>JA</math> и <math>AN</math>. Таким образом информация об элементах 2-ой строки матрицы хранится в элементах с <math>IA[2] = 2</math> по <math>IA[3] - 1 = 3</math> включительно массивов <math>JA</math> и <math>AN</math>. Можно обратить внимание, что <math>IA[3] = IA[4] = 4</math>, а это означает, что 3-я строка матрицы <math>A</math> нулевая.

В общем случае описание <math>r</math>-й строки матрицы A хранится в компонентах с <math>IA[r]</math> до <math>IA[r + 1] - 1</math> включительно массивов <math>AN</math> и <math>JA</math>. Если <math>IA[r + 1] = IA[r]</math>, то это означает, что <math>r</math>-я строка нулевая. Количество элементов в массиве <math>IA</math> на единицу больше, чем число строк исходной матрицы, а количество элементов в массивах <math>JA</math> и <math>AN</math> равно числу ненулевых элементов исходной матрицы.

Данный способ представления называют ''полным'', поскольку представлена вся матрица <math>A</math>, ''упорядоченным'', поскольку элементы каждой строки матрицы <math>A</math> хранятся в соответствии с возрастанием столбцовых индексов, и строчным, поскольку информация о матрице <math>A</math> указывается по строкам.

Массивы <math>IA</math> и <math>JA</math> представляют портрет (структуру) матрицы <math>A</math>, задаваемый как множество списков смежности ассоциированного с <math>A</math> графа. Если алгоритм, реализующий какую-либо операцию над разреженными матрицами, разбит на этапы символической обработки, на котором определяется портрет результирующей матрицы, и численной обработки, на котором определяются значения элементов результирующей матрицы, то массивы <math>IA</math> и <math>JA</math> заполняются на первом этапе, а массив <math>AN</math> - на втором.

==== Формат RR(C)U ====

Рассмотрим теперь формат '''RR(C)U'''.

Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Unordered"'' (строчное представление, полное, но неупорядоченное). Формат '''RR(C)U''' отличается от '''RR(C)O''' тем, что в данном случае соблюдается упорядоченность строк, но внутри каждой строки элементы исходных матриц могут храниться в произвольном порядке. Для матрицы <math>A</math> нашего примера вполне можно было бы использовать и строчное представление, полное, но неупорядоченное такое:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 3 1 2 3 ]
AN = [ 2 1 3 6 4 ]
Такие неупорядоченные представления могут быть очень удобны в практических вычислениях. Результаты большинства матричных операций получаются неупорядоченными, а их упорядочение стоило бы значительных затрат машинного времени. В то же время, за немногими исключениями, алгоритмы для разреженных матриц не требуют, чтобы их представления были упорядоченными.

==== Замечания ====

Несколько замечаний по поводу рассмотренных форматов представления:
# Очевидно, что представление матрицы в формате '''RR(C)O''' так же является и представлением в формате '''RR(C)U''', но не наоборот.
# Из представления матрицы в формате '''RR(C)''' нельзя получить информацию о точном количестве столбцов исходной матрицы.
# Целесообразно (в вопросе экономии памяти) использовать представления '''RR(C)''' в случае, если матрица содержит значительное число нулевых элементов.

=== Умножение разреженной матрицы на вектор ===

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

Мы рассмотрим умножение разреженной матрицы общего вида, хранимой в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math> на заполненный вектор-столбец.

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

Исходные данные: разреженная матрица общего вида <math>A</math> с элементами <math>a_{ij}</math> (<math>i = 1,...,n</math> и <math>j = 1,...,m</math>). Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> (<math>j =1,...,m</math>).

Вычисляемые данные: заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

Формулы метода:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

где <math>l_{i}</math> - количество ненулевых элементов строки <math>i</math> матрицы <math>A</math>, <math>j(k)</math> - индекс <math>k</math>-го ненулевого элемента матрицы <math>A</math>.

== Вычислительное ядро алгоритма ==
Вычислительное ядро последовательной версии умножения разреженной матрицы на вектор можно составить из множественных (всего их <math>n</math>) вычислений скалярных произведений строк матрицы:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>.

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

Как записано и в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют множественные (всего <math>n</math>) вычисления сумм:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

которые могут вычисляться в произвольном порядке.

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

Далее предполагаем, что разреженная матрица общего вида <math>A</math> хранится в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>.
Последовательность исполнения метода следующая:

Выполнять для <math>i</math> от <math>1</math> до <math>n</math>
# <math>c_{i} = 0</math>
# <math>IAA = IA[i]</math>
# <math>IAB = IA[i + 1] - 1</math>
# <math>c_{i} = \sum\limits_{k = IAA}^{IAB} AN[k]b_{JA[k]}</math>.
После этого (если <math>i \le n</math>) происходит переход к шагу 1 с бо́льшим <math>i</math>.

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размером <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в последовательном (наиболее быстром) варианте требуется:

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

Умножения и сложения составляют ''основную часть алгоритма''.

При классификации по последовательной сложности, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам <math>O(l)</math>.

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

Опишем [[глоссарий#Граф алгоритма|граф алгоритма]]<ref>Воеводин В.В. Математические основы параллельных вычислений// М.: Изд. Моск. ун-та, 1991. 345 с.</ref><ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. – СПб.: БХВ - Петербург, 2002. – 608 с.</ref><ref>Фролов А.В.. Принципы построения и описание языка Сигма. Препринт ОВМ АН N 236. М.: ОВМ АН СССР, 1989.</ref> как аналитически, так и в виде рисунка.

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

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

* <math>i</math> — меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math> - элемент ''входных данных'', а именно <math>AN[IA_{i}+j-1]</math>.
* <math>b</math> - элемент ''входных данных'', а именно <math>b[IA_{i}+j-1]</math>.

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

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция <math>a + b</math>.
Естественно введённые координаты области таковы:
* <math>i</math> - меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> - меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math>:
** при <math>j = 1</math> - результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j)</math>;
** при <math>j > 1</math> - результат срабатывания операции, соответствующей вершине из второй группы, с координатами <math>(i, j - 1)</math>;
* <math>b</math> — результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j + 1)</math>.

Результат срабатывания операции:
* при <math>j < k - 1</math> является ''промежуточным данным'' алгоритма;
* при <math>j = k - 1</math> является ''выходным данным'' <math>c_{i}</math>.

Описанный граф можно посмотреть на рис.1. Здесь вершины первой группы обозначены красным цветом и отмечены знаком умножения, вершины второй - зелёным цветом и знаком сложения. Вершины, соответствующие входным данным обозначены белым цветом и выходным - синим.
[[file:Bliznalg.png|thumb|center|1000px|Рисунок 1. Граф алгоритма умножения разреженной матрицы на вектор]]

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размерности <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в параллельном варианте требуется последовательно выполнить следующие ярусы:

* Не более чем <math>m</math> сложений и умножений (<math>n</math> вычислений в каждом из ярусов)

При классификации по высоте ЯПФ, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам со сложностью <math>O(m)</math>. При классификации по ширине ЯПФ его сложность будет <math>O(n)</math>.

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

'''Входные данные''': разреженная матрица общего вида <math>A</math> размерности <math>n \times m</math>, хранимая в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>. Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> размерности <math>m \times 1</math>.

'''Объём входных данных''': <math>2l+m+n+1</math>, где <math>l</math> - количество ненулевых элементов в матрице <math>A</math>.

'''Выходные данные''': заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

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

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

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

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

Пусть <math>l</math> - количество ненулевых элементов матрицы <math>A</math> размерности <math>n \times m</math>. Пусть <math>x</math> - объем памяти, используемый для хранения значения элемента матрицы, <math>y</math> - объём памяти, используемый для хранения номера столбца или строки. В таком случае для хранения матрицы в стандартном представлении нам потребуется объем памяти, равный <math>x \cdot n \cdot m</math>, для хранения в формате '''RR(C)''' - <math>y(n + 1) + (x + y)l</math>. Таким образом хранение в формате '''RR(C)''' не является эффективным для матриц, в которых <math>l > \frac{xnm - y(n+1)}{x+y}</math>.

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

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

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

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

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

Параллельная реализация алгоритма заключается в следующем:

# Каждый процессор считывает входные данные из файла, зависящего от его номера. Данные имеют вид: вектор <math>b</math> и набор определённых строк матрицы <math>A</math> в формате '''RR(C)U''' в зависимости от номера процессора и их числа;
# Процессоры проводят вычисления значений вектора <math>c</math> в зависимости от имеющихся данных;
# Все процессоры отправляют результаты вычисления процессору, выбранному главным, и главный процессор выводит результат вычислений.

<div class="mw-collapsible mw-collapsed" style="width:100%">
Текст использованной в экспериментах реализации (язык С++):
<div class="mw-collapsible-content">
<source lang="c++">
#include <mpi.h>
#include <memory>
#include <iostream>
#include <vector>
#include <sstream>
#include <fstream>
#include <string>
#include <iterator>

typedef std::shared_ptr<std::vector<std::vector<int> > > MyData;

MyData ReadData(const std::string& data_path) {
std::ifstream file_stream;
MyData retval(new std::vector<std::vector<int> >());
file_stream.open(data_path);

while (!file_stream.eof()) {
std::string str;
std::getline(file_stream, str);

std::istringstream iss(str);
auto temp_1 = (std::istream_iterator<std::string>(iss));
auto temp_2 = (std::istream_iterator<std::string>());

std::vector<std::string> coordinates{ temp_1, temp_2};
retval->push_back(std::vector<int>());
for (auto& e : coordinates) {
retval->back().push_back(std::stoi(e));
}
}

return retval;
}

// input: vector b, vector ia, vector ja, vector an
int main(int argc, char** argv){
MPI_Init(&argc, &argv);
int pid, np;
MPI_Status *s = new MPI_Status;
MPI_Comm_rank(MPI_COMM_WORLD, &pid);
MPI_Comm_size(MPI_COMM_WORLD, &np);
if (argc == 2){
int n;
int indx = 0;
int stp;
double strttime = MPI_Wtime();
std::vector<int> b;
std::vector<int> ia;
std::vector<int> ja;
std::vector<int> an;
auto data = ReadData("data_" + std::to_string(static_cast<long long>(pid)) + ".txt");
b = (*data)[0];
ia = (*data)[1];
ja = (*data)[2];
an = (*data)[3];
n = (*data)[0].size();
std::vector<int> c;
stp = n / np + ((n % np > pid) ? 1 : 0);
if (pid == 0){
c.resize(n, 0);
}
else{
c.resize(stp, 0);
}
for (int i = 0; i < stp; i++){
int strt = ia[i] - ia[0];
int lstr = ia[i + 1] - ia[i];
for (int j = 0; j < lstr; j++){
c[i] += an[strt + j] * b[ja[strt + j]];
}
}
if (pid == 0){
for (int i = 1; i < np; i++){
indx += n / np + ((n % np > i - 1) ? 1 : 0);
stp = n / np + ((n % np > i) ? 1 : 0);
MPI_Recv(&c[indx], stp, MPI_INT, i, 0, MPI_COMM_WORLD, s);
}
}
else{
MPI_Send(&c[0], stp, MPI_INT, 0, 0, MPI_COMM_WORLD);
}
if (pid == 0){
for (int e : c) {
std::cout << e << "\n";
}
double endtime = MPI_Wtime();
std::cout << "Success! Time = " << endtime - strttime << "\n";
}
}
MPI_Finalize();
return 0;
}
</source>
</div></div>

<div class="mw-collapsible mw-collapsed" style="width:100%">
Для формирования входных данных использовался следующий алгоритм (язык Python):
<div class="mw-collapsible-content">
<source lang="python">
from scipy import sparse as sp
from numpy.random import randint
from os import mkdir
from os.path import join as jn

n = 10000
np = [1, 2, 4, 8, 16, 32, 64, 128]

a = sp.csr_matrix(randint(0, 2, (n, n)))
b = randint(1, 5, n)
i = 0

for j in np:
mkdir('data_' + str(j))
indx = 0
for i in range(0, j):
stp = n / j + (1 if (n % j > i) else 0)
ael = a.indptr[indx + stp] - a.indptr[indx]
strt = a.indptr[indx]
with open(jn('data_' + str(j), 'data_' + str(i) + '.txt'), 'w') as fout:

for e in b:
fout.write('{0} '.format(e))
fout.write('\n')

s = a.indptr[indx:indx + stp + 1]
for e in s:
fout.write('{0} '.format(e))
fout.write('\n')

s = a.indices[strt:strt + ael]
for e in s:
fout.write('{0} '.format(e))
fout.write('\n')

s = a.data[strt:strt + ael]
for e in s:
fout.write('{0} '.format(e))
fout.write('\n')

indx = indx + n / j + (1 if (n % j > i) else 0)
</source>
</div></div>

Проведём исследование масштабируемости параллельной реализации алгоритма умножения разреженной матрицы на вектор. Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета]. Входные данные формировались на персональном компьютере в силу того, что компилятор на суперкомпьютере "Ломоносов" не удовлетворял нужным требованиям, и потом отправлялись на суперкомпьютер для последующей обработки.

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

* число процессоров [1 : 128] по степеням 2;
* размер матрицы [1000 : 10000] с шагом 1000.

[[file:Blizntime.png|thumb|center|1000px|Рисунок 2. Время работы программы в зависимости от количества процессоров и размера матрицы]]

Можно заметить, что при небольшом количестве входных данных, и большом количестве процессоров эффективность распараллеливания падает до нуля, поскольку время вычисления элементов вектора <math>c</math> становится несоизмеримо малым по сравнению с временем, затраченным на пересылку в пункте (3).

[[file:Efficiency(paral).png|thumb|center|1000px|Рисунок 4. Эффективность распараллеливания в зависимости от количества процессоров и размера матрицы]]

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

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

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

Существующие реализации:

SciPy [https://docs.scipy.org/doc/scipy-0.18.1/reference/index.html],

MatLab [https://www.mathworks.com/help/matlab/math/sparse-matrix-operations.html],

Intel MKL [https://software.intel.com/en-us/articles/intel-math-kernel-library-inspector-executor-sparse-blas-routines].

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

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

2016-11-30T13:34:42Z

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

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>O(l)</math>
| pf_height = <math>O(m)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>2l+m+n+1</math>
| output_data = <math>n</math>
}}
Выполнила: [[Участник:Blizn|И.В. Близнякова]] (611 группа).

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

== Общее описание алгоритма<ref>С.Писсанецки. Технология разреженных матриц. - М.: Мир, 1988.</ref> ==
'''Разрежённая матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается '''''плотной'''''.

Среди специалистов нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:
* есть <math>O(n)</math>. Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;
* в каждой строке не превышает 10 в типичном случае;
* ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.
* таково, что для данного алгоритма и вычислительной системы имеет смысл извлекать выгоду из наличия в ней нулей.

=== Хранение разреженной матрицы ===
==== Формат RR(C)O ====
Рассмотрим сначала формат '''RR(C)O'''. Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Ordered"'' (строчное представление, полное и упорядоченное). В данном формате вместо одного двумерного массива, используются три одномерных. Значения ненулевых элементов матрицы и соответствующие им столбцовые индексы хранятся в этом формате по строкам в двух массивах <math>AN</math> и <math>JA</math>. Массив указателей <math>IA</math>, используется для ссылки на компоненты массивов <math>AN</math> и <math>JA</math>, с которых начинается описание очередной строки. Последняя компонента массива <math>IA</math> содержит указатель первой свободной компоненты в массивах <math>AN</math> и <math>JA</math>, т.е. равна числу ненулевых элементов матрицы, увеличенному на единицу. Здесь уместно привести пример.

Рассмотрим матрицу <math>A</math>:
:<math>\begin{pmatrix}
0 & 0 & 0 & 2 & 0 \\
1 & 0 & 3 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 \\
0 & 6 & 0 & 0 & 0 \\
0 & 0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
тогда ее представление в формате '''RR(C)O''' будет иметь вид:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 1 3 2 3 ]
AN = [ 2 1 3 6 4 ]
Т.е. массив <math>AN</math> содержит все не нулевые элементы исходной матрицы <math>A</math>, массив <math>JA</math> номер столбца в котором находится соответствующий элемент из <math>AN</math> и наконец массив <math>IA</math> содержит номер с которого начинается описание элементов в массивах <math>JA</math> и <math>AN</math>. Таким образом информация об элементах 2-ой строки матрицы хранится в элементах с <math>IA[2] = 2</math> по <math>IA[3] - 1 = 3</math> включительно массивов <math>JA</math> и <math>AN</math>. Можно обратить внимание, что <math>IA[3] = IA[4] = 4</math>, а это означает, что 3-я строка матрицы <math>A</math> нулевая.

В общем случае описание <math>r</math>-й строки матрицы A хранится в компонентах с <math>IA[r]</math> до <math>IA[r + 1] - 1</math> включительно массивов <math>AN</math> и <math>JA</math>. Если <math>IA[r + 1] = IA[r]</math>, то это означает, что <math>r</math>-я строка нулевая. Количество элементов в массиве <math>IA</math> на единицу больше, чем число строк исходной матрицы, а количество элементов в массивах <math>JA</math> и <math>AN</math> равно числу ненулевых элементов исходной матрицы.

Данный способ представления называют ''полным'', поскольку представлена вся матрица <math>A</math>, ''упорядоченным'', поскольку элементы каждой строки матрицы <math>A</math> хранятся в соответствии с возрастанием столбцовых индексов, и строчным, поскольку информация о матрице <math>A</math> указывается по строкам.

Массивы <math>IA</math> и <math>JA</math> представляют портрет (структуру) матрицы <math>A</math>, задаваемый как множество списков смежности ассоциированного с <math>A</math> графа. Если алгоритм, реализующий какую-либо операцию над разреженными матрицами, разбит на этапы символической обработки, на котором определяется портрет результирующей матрицы, и численной обработки, на котором определяются значения элементов результирующей матрицы, то массивы <math>IA</math> и <math>JA</math> заполняются на первом этапе, а массив <math>AN</math> - на втором.

==== Формат RR(C)U ====

Рассмотрим теперь формат '''RR(C)U'''.

Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Unordered"'' (строчное представление, полное, но неупорядоченное). Формат '''RR(C)U''' отличается от '''RR(C)O''' тем, что в данном случае соблюдается упорядоченность строк, но внутри каждой строки элементы исходных матриц могут храниться в произвольном порядке. Для матрицы <math>A</math> нашего примера вполне можно было бы использовать и строчное представление, полное, но неупорядоченное такое:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 3 1 2 3 ]
AN = [ 2 1 3 6 4 ]
Такие неупорядоченные представления могут быть очень удобны в практических вычислениях. Результаты большинства матричных операций получаются неупорядоченными, а их упорядочение стоило бы значительных затрат машинного времени. В то же время, за немногими исключениями, алгоритмы для разреженных матриц не требуют, чтобы их представления были упорядоченными.

==== Замечания ====

Несколько замечаний по поводу рассмотренных форматов представления:
# Очевидно, что представление матрицы в формате '''RR(C)O''' так же является и представлением в формате '''RR(C)U''', но не наоборот.
# Из представления матрицы в формате '''RR(C)''' нельзя получить информацию о точном количестве столбцов исходной матрицы.
# Целесообразно (в вопросе экономии памяти) использовать представления '''RR(C)''' в случае, если матрица содержит значительное число нулевых элементов.

=== Умножение разреженной матрицы на вектор ===

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

Мы рассмотрим умножение разреженной матрицы общего вида, хранимой в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math> на заполненный вектор-столбец.

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

Исходные данные: разреженная матрица общего вида <math>A</math> с элементами <math>a_{ij}</math> (<math>i = 1,...,n</math> и <math>j = 1,...,m</math>). Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> (<math>j =1,...,m</math>).

Вычисляемые данные: заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

Формулы метода:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

где <math>l_{i}</math> - количество ненулевых элементов строки <math>i</math> матрицы <math>A</math>, <math>j(k)</math> - индекс <math>k</math>-го ненулевого элемента матрицы <math>A</math>.

== Вычислительное ядро алгоритма ==
Вычислительное ядро последовательной версии умножения разреженной матрицы на вектор можно составить из множественных (всего их <math>n</math>) вычислений скалярных произведений строк матрицы:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>.

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

Как записано и в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют множественные (всего <math>n</math>) вычисления сумм:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

которые могут вычисляться в произвольном порядке.

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

Далее предполагаем, что разреженная матрица общего вида <math>A</math> хранится в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>.
Последовательность исполнения метода следующая:

Выполнять для <math>i</math> от <math>1</math> до <math>n</math>
# <math>c_{i} = 0</math>
# <math>IAA = IA[i]</math>
# <math>IAB = IA[i + 1] - 1</math>
# <math>c_{i} = \sum\limits_{k = IAA}^{IAB} AN[k]b_{JA[k]}</math>.
После этого (если <math>i \le n</math>) происходит переход к шагу 1 с бо́льшим <math>i</math>.

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размером <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в последовательном (наиболее быстром) варианте требуется:

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

Умножения и сложения составляют ''основную часть алгоритма''.

При классификации по последовательной сложности, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам <math>O(l)</math>.

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

Опишем [[глоссарий#Граф алгоритма|граф алгоритма]]<ref>Воеводин В.В. Математические основы параллельных вычислений// М.: Изд. Моск. ун-та, 1991. 345 с.</ref><ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. – СПб.: БХВ - Петербург, 2002. – 608 с.</ref><ref>Фролов А.В.. Принципы построения и описание языка Сигма. Препринт ОВМ АН N 236. М.: ОВМ АН СССР, 1989.</ref> как аналитически, так и в виде рисунка.

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

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

* <math>i</math> — меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math> - элемент ''входных данных'', а именно <math>AN[IA_{i}+j-1]</math>.
* <math>b</math> - элемент ''входных данных'', а именно <math>b[IA_{i}+j-1]</math>.

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

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция <math>a + b</math>.
Естественно введённые координаты области таковы:
* <math>i</math> - меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> - меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math>:
** при <math>j = 1</math> - результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j)</math>;
** при <math>j > 1</math> - результат срабатывания операции, соответствующей вершине из второй группы, с координатами <math>(i, j - 1)</math>;
* <math>b</math> — результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j + 1)</math>.

Результат срабатывания операции:
* при <math>j < k - 1</math> является ''промежуточным данным'' алгоритма;
* при <math>j = k - 1</math> является ''выходным данным'' <math>c_{i}</math>.

Описанный граф можно посмотреть на рис.1. Здесь вершины первой группы обозначены красным цветом и отмечены знаком умножения, вершины второй - зелёным цветом и знаком сложения. Вершины, соответствующие входным данным обозначены белым цветом и выходным - синим.
[[file:Bliznalg.png|thumb|center|1000px|Рисунок 1. Граф алгоритма умножения разреженной матрицы на вектор]]

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размерности <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в параллельном варианте требуется последовательно выполнить следующие ярусы:

* Не более чем <math>m</math> сложений и умножений (<math>n</math> вычислений в каждом из ярусов)

При классификации по высоте ЯПФ, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам со сложностью <math>O(m)</math>. При классификации по ширине ЯПФ его сложность будет <math>O(n)</math>.

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

'''Входные данные''': разреженная матрица общего вида <math>A</math> размерности <math>n \times m</math>, хранимая в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>. Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> размерности <math>m \times 1</math>.

'''Объём входных данных''': <math>2l+m+n+1</math>, где <math>l</math> - количество ненулевых элементов в матрице <math>A</math>.

'''Выходные данные''': заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

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

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

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

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

Пусть <math>l</math> - количество ненулевых элементов матрицы <math>A</math> размерности <math>n \times m</math>. Пусть <math>x</math> - объем памяти, используемый для хранения значения элемента матрицы, <math>y</math> - объём памяти, используемый для хранения номера столбца или строки. В таком случае для хранения матрицы в стандартном представлении нам потребуется объем памяти, равный <math>x \cdot n \cdot m</math>, для хранения в формате '''RR(C)''' - <math>y(n + 1) + (x + y)l</math>. Таким образом хранение в формате '''RR(C)''' не является эффективным для матриц, в которых <math>l > \frac{xnm - y(n+1)}{x+y}</math>.

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

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

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

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

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

Параллельная реализация алгоритма заключается в следующем:

# Каждый процессор считывает входные данные из файла, зависящего от его номера. Данные имеют вид: вектор <math>b</math> и набор определённых строк матрицы <math>A</math> в формате '''RR(C)U''' в зависимости от номера процессора и их числа;
# Процессоры проводят вычисления значений вектора <math>c</math> в зависимости от имеющихся данных;
# Все процессоры отправляют результаты вычисления процессору, выбранному главным, и главный процессор выводит результат вычислений.

<div class="mw-collapsible mw-collapsed" style="width:100%">
Текст использованной в экспериментах реализации (язык С++):
<div class="mw-collapsible-content">
<source lang="c++">
#include <mpi.h>
#include <memory>
#include <iostream>
#include <vector>
#include <sstream>
#include <fstream>
#include <string>
#include <iterator>

typedef std::shared_ptr<std::vector<std::vector<int> > > MyData;

MyData ReadData(const std::string& data_path) {
std::ifstream file_stream;
MyData retval(new std::vector<std::vector<int> >());
file_stream.open(data_path);

while (!file_stream.eof()) {
std::string str;
std::getline(file_stream, str);

std::istringstream iss(str);
auto temp_1 = (std::istream_iterator<std::string>(iss));
auto temp_2 = (std::istream_iterator<std::string>());

std::vector<std::string> coordinates{ temp_1, temp_2};
retval->push_back(std::vector<int>());
for (auto& e : coordinates) {
retval->back().push_back(std::stoi(e));
}
}

return retval;
}

// input: vector b, vector ia, vector ja, vector an
int main(int argc, char** argv){
MPI_Init(&argc, &argv);
int pid, np;
MPI_Status *s = new MPI_Status;
MPI_Comm_rank(MPI_COMM_WORLD, &pid);
MPI_Comm_size(MPI_COMM_WORLD, &np);
if (argc == 2){
int n;
int indx = 0;
int stp;
double strttime = MPI_Wtime();
std::vector<int> b;
std::vector<int> ia;
std::vector<int> ja;
std::vector<int> an;
auto data = ReadData("data_" + std::to_string(static_cast<long long>(pid)) + ".txt");
b = (*data)[0];
ia = (*data)[1];
ja = (*data)[2];
an = (*data)[3];
n = (*data)[0].size();
std::vector<int> c;
stp = n / np + ((n % np > pid) ? 1 : 0);
if (pid == 0){
c.resize(n, 0);
}
else{
c.resize(stp, 0);
}
for (int i = 0; i < stp; i++){
int strt = ia[i] - ia[0];
int lstr = ia[i + 1] - ia[i];
for (int j = 0; j < lstr; j++){
c[i] += an[strt + j] * b[ja[strt + j]];
}
}
if (pid == 0){
for (int i = 1; i < np; i++){
indx += n / np + ((n % np > i - 1) ? 1 : 0);
stp = n / np + ((n % np > i) ? 1 : 0);
MPI_Recv(&c[indx], stp, MPI_INT, i, 0, MPI_COMM_WORLD, s);
}
}
else{
MPI_Send(&c[0], stp, MPI_INT, 0, 0, MPI_COMM_WORLD);
}
if (pid == 0){
for (int e : c) {
std::cout << e << "\n";
}
double endtime = MPI_Wtime();
std::cout << "Success! Time = " << endtime - strttime << "\n";
}
}
MPI_Finalize();
return 0;
}
</source>
</div></div>

<div class="mw-collapsible mw-collapsed" style="width:100%">
Для формирования входных данных использовался следующий алгоритм (язык Python):
<div class="mw-collapsible-content">
<source lang="python">
from scipy import sparse as sp
from numpy.random import randint
from os import mkdir
from os.path import join as jn

n = 10000
np = [1, 2, 4, 8, 16, 32, 64, 128]

a = sp.csr_matrix(randint(0, 2, (n, n)))
b = randint(1, 5, n)
i = 0

for j in np:
mkdir('data_' + str(j))
indx = 0
for i in range(0, j):
stp = n / j + (1 if (n % j > i) else 0)
ael = a.indptr[indx + stp] - a.indptr[indx]
strt = a.indptr[indx]
with open(jn('data_' + str(j), 'data_' + str(i) + '.txt'), 'w') as fout:

for e in b:
fout.write('{0} '.format(e))
fout.write('\n')

s = a.indptr[indx:indx + stp + 1]
for e in s:
fout.write('{0} '.format(e))
fout.write('\n')

s = a.indices[strt:strt + ael]
for e in s:
fout.write('{0} '.format(e))
fout.write('\n')

s = a.data[strt:strt + ael]
for e in s:
fout.write('{0} '.format(e))
fout.write('\n')

indx = indx + n / j + (1 if (n % j > i) else 0)
</source>
</div></div>

Проведём исследование масштабируемости параллельной реализации алгоритма умножения разреженной матрицы на вектор. Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

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

* число процессоров [1 : 128] по степеням 2;
* размер матрицы [1000 : 10000] с шагом 1000.

[[file:Blizntime.png|thumb|center|1000px|Рисунок 2. Время работы программы в зависимости от количества процессоров и размера матрицы]]

Можно заметить, что при небольшом количестве входных данных, и большом количестве процессоров эффективность распараллеливания падает до нуля, поскольку время вычисления элементов вектора <math>c</math> становится несоизмеримо малым по сравнению с временем, затраченным на пересылку в пункте (3).

[[file:Efficiency(paral).png|thumb|center|1000px|Рисунок 4. Эффективность распараллеливания в зависимости от количества процессоров и размера матрицы]]

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

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

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

Существующие реализации:

SciPy [https://docs.scipy.org/doc/scipy-0.18.1/reference/index.html],

MatLab [https://www.mathworks.com/help/matlab/math/sparse-matrix-operations.html],

Intel MKL [https://software.intel.com/en-us/articles/intel-math-kernel-library-inspector-executor-sparse-blas-routines].

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

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

2016-11-29T22:21:22Z

Blizn:

{{Assignment}}

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>O(l)</math>
| pf_height = <math>O(m)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>2l+m+n+1</math>
| output_data = <math>n</math>
}}
Выполнила: [[Участник:Blizn|И.В. Близнякова]] (611 группа).

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

== Общее описание алгоритма<ref>С.Писсанецки. Технология разреженных матриц. - М.: Мир, 1988.</ref> ==
'''Разрежённая матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается '''''плотной'''''.

Среди специалистов нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:
* есть <math>O(n)</math>. Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;
* в каждой строке не превышает 10 в типичном случае;
* ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.
* таково, что для данного алгоритма и вычислительной системы имеет смысл извлекать выгоду из наличия в ней нулей.

=== Хранение разреженной матрицы ===
==== Формат RR(C)O ====
Рассмотрим сначала формат '''RR(C)O'''. Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Ordered"'' (строчное представление, полное и упорядоченное). В данном формате вместо одного двумерного массива, используются три одномерных. Значения ненулевых элементов матрицы и соответствующие им столбцовые индексы хранятся в этом формате по строкам в двух массивах <math>AN</math> и <math>JA</math>. Массив указателей <math>IA</math>, используется для ссылки на компоненты массивов <math>AN</math> и <math>JA</math>, с которых начинается описание очередной строки. Последняя компонента массива <math>IA</math> содержит указатель первой свободной компоненты в массивах <math>AN</math> и <math>JA</math>, т.е. равна числу ненулевых элементов матрицы, увеличенному на единицу. Здесь уместно привести пример.

Рассмотрим матрицу <math>A</math>:
:<math>\begin{pmatrix}
0 & 0 & 0 & 2 & 0 \\
1 & 0 & 3 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 \\
0 & 6 & 0 & 0 & 0 \\
0 & 0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
тогда ее представление в формате '''RR(C)O''' будет иметь вид:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 1 3 2 3 ]
AN = [ 2 1 3 6 4 ]
Т.е. массив <math>AN</math> содержит все не нулевые элементы исходной матрицы <math>A</math>, массив <math>JA</math> номер столбца в котором находится соответствующий элемент из <math>AN</math> и наконец массив <math>IA</math> содержит номер с которого начинается описание элементов в массивах <math>JA</math> и <math>AN</math>. Таким образом информация об элементах 2-ой строки матрицы хранится в элементах с <math>IA[2] = 2</math> по <math>IA[3] - 1 = 3</math> включительно массивов <math>JA</math> и <math>AN</math>. Можно обратить внимание, что <math>IA[3] = IA[4] = 4</math>, а это означает, что 3-я строка матрицы <math>A</math> нулевая.

В общем случае описание <math>r</math>-й строки матрицы A хранится в компонентах с <math>IA[r]</math> до <math>IA[r + 1] - 1</math> включительно массивов <math>AN</math> и <math>JA</math>. Если <math>IA[r + 1] = IA[r]</math>, то это означает, что <math>r</math>-я строка нулевая. Количество элементов в массиве <math>IA</math> на единицу больше, чем число строк исходной матрицы, а количество элементов в массивах <math>JA</math> и <math>AN</math> равно числу ненулевых элементов исходной матрицы.

Данный способ представления называют ''полным'', поскольку представлена вся матрица <math>A</math>, ''упорядоченным'', поскольку элементы каждой строки матрицы <math>A</math> хранятся в соответствии с возрастанием столбцовых индексов, и строчным, поскольку информация о матрице <math>A</math> указывается по строкам.

Массивы <math>IA</math> и <math>JA</math> представляют портрет (структуру) матрицы <math>A</math>, задаваемый как множество списков смежности ассоциированного с <math>A</math> графа. Если алгоритм, реализующий какую-либо операцию над разреженными матрицами, разбит на этапы символической обработки, на котором определяется портрет результирующей матрицы, и численной обработки, на котором определяются значения элементов результирующей матрицы, то массивы <math>IA</math> и <math>JA</math> заполняются на первом этапе, а массив <math>AN</math> - на втором.

==== Формат RR(C)U ====

Рассмотрим теперь формат '''RR(C)U'''.

Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Unordered"'' (строчное представление, полное, но неупорядоченное). Формат '''RR(C)U''' отличается от '''RR(C)O''' тем, что в данном случае соблюдается упорядоченность строк, но внутри каждой строки элементы исходных матриц могут храниться в произвольном порядке. Для матрицы <math>A</math> нашего примера вполне можно было бы использовать и строчное представление, полное, но неупорядоченное такое:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 3 1 2 3 ]
AN = [ 2 1 3 6 4 ]
Такие неупорядоченные представления могут быть очень удобны в практических вычислениях. Результаты большинства матричных операций получаются неупорядоченными, а их упорядочение стоило бы значительных затрат машинного времени. В то же время, за немногими исключениями, алгоритмы для разреженных матриц не требуют, чтобы их представления были упорядоченными.

==== Замечания ====

Несколько замечаний по поводу рассмотренных форматов представления:
# Очевидно, что представление матрицы в формате '''RR(C)O''' так же является и представлением в формате '''RR(C)U''', но не наоборот.
# Из представления матрицы в формате '''RR(C)''' нельзя получить информацию о точном количестве столбцов исходной матрицы.
# Целесообразно (в вопросе экономии памяти) использовать представления '''RR(C)''' в случае, если матрица содержит значительное число нулевых элементов.

=== Умножение разреженной матрицы на вектор ===

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

Мы рассмотрим умножение разреженной матрицы общего вида, хранимой в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math> на заполненный вектор-столбец.

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

Исходные данные: разреженная матрица общего вида <math>A</math> с элементами <math>a_{ij}</math> (<math>i = 1,...,n</math> и <math>j = 1,...,m</math>). Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> (<math>j =1,...,m</math>).

Вычисляемые данные: заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

Формулы метода:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

где <math>l_{i}</math> - количество ненулевых элементов строки <math>i</math> матрицы <math>A</math>, <math>j(k)</math> - индекс <math>k</math>-го ненулевого элемента матрицы <math>A</math>.

== Вычислительное ядро алгоритма ==
Вычислительное ядро последовательной версии умножения разреженной матрицы на вектор можно составить из множественных (всего их <math>n</math>) вычислений скалярных произведений строк матрицы:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>.

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

Как записано и в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют множественные (всего <math>n</math>) вычисления сумм:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

которые могут вычисляться в произвольном порядке.

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

Далее предполагаем, что разреженная матрица общего вида <math>A</math> хранится в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>.
Последовательность исполнения метода следующая:

Выполнять для <math>i</math> от <math>1</math> до <math>n</math>
# <math>c_{i} = 0</math>
# <math>IAA = IA[i]</math>
# <math>IAB = IA[i + 1] - 1</math>
# <math>c_{i} = \sum\limits_{k = IAA}^{IAB} AN[k]b_{JA[k]}</math>.
После этого (если <math>i \le n</math>) происходит переход к шагу 1 с бо́льшим <math>i</math>.

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размером <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в последовательном (наиболее быстром) варианте требуется:

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

Умножения и сложения составляют ''основную часть алгоритма''.

При классификации по последовательной сложности, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам <math>O(l)</math>.

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

Опишем [[глоссарий#Граф алгоритма|граф алгоритма]]<ref>Воеводин В.В. Математические основы параллельных вычислений// М.: Изд. Моск. ун-та, 1991. 345 с.</ref><ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. – СПб.: БХВ - Петербург, 2002. – 608 с.</ref><ref>Фролов А.В.. Принципы построения и описание языка Сигма. Препринт ОВМ АН N 236. М.: ОВМ АН СССР, 1989.</ref> как аналитически, так и в виде рисунка.

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

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

* <math>i</math> — меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math> - элемент ''входных данных'', а именно <math>AN[IA_{i}+j-1]</math>.
* <math>b</math> - элемент ''входных данных'', а именно <math>b[IA_{i}+j-1]</math>.

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

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция <math>a + b</math>.
Естественно введённые координаты области таковы:
* <math>i</math> - меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> - меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math>:
** при <math>j = 1</math> - результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j)</math>;
** при <math>j > 1</math> - результат срабатывания операции, соответствующей вершине из второй группы, с координатами <math>(i, j - 1)</math>;
* <math>b</math> — результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j + 1)</math>.

Результат срабатывания операции:
* при <math>j < k - 1</math> является ''промежуточным данным'' алгоритма;
* при <math>j = k - 1</math> является ''выходным данным'' <math>c_{i}</math>.

Описанный граф можно посмотреть на рис.1. Здесь вершины первой группы обозначены красным цветом и отмечены знаком умножения, вершины второй - зелёным цветом и знаком сложения. Вершины, соответствующие входным данным обозначены белым цветом и выходным - синим.
[[file:Bliznalg.png|thumb|center|1000px|Рисунок 1. Граф алгоритма умножения разреженной матрицы на вектор]]

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размерности <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в параллельном варианте требуется последовательно выполнить следующие ярусы:

* Не более чем <math>m</math> сложений и умножений (<math>n</math> вычислений в каждом из ярусов)

При классификации по высоте ЯПФ, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам со сложностью <math>O(m)</math>. При классификации по ширине ЯПФ его сложность будет <math>O(n)</math>.

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

'''Входные данные''': разреженная матрица общего вида <math>A</math> размерности <math>n \times m</math>, хранимая в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>. Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> размерности <math>m \times 1</math>.

'''Объём входных данных''': <math>2l+m+n+1</math>, где <math>l</math> - количество ненулевых элементов в матрице <math>A</math>.

'''Выходные данные''': заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

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

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

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

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

Пусть <math>l</math> - количество ненулевых элементов матрицы <math>A</math> размерности <math>n \times m</math>. Пусть <math>x</math> - объем памяти, используемый для хранения значения элемента матрицы, <math>y</math> - объём памяти, используемый для хранения номера столбца или строки. В таком случае для хранения матрицы в стандартном представлении нам потребуется объем памяти, равный <math>x \cdot n \cdot m</math>, для хранения в формате '''RR(C)''' - <math>y(n + 1) + (x + y)l</math>. Таким образом хранение в формате '''RR(C)''' не является эффективным для матриц, в которых <math>l > \frac{xnm - y(n+1)}{x+y}</math>.

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

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

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

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

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

Параллельная реализация алгоритма заключается в следующем:

# Каждый процессор считывает входные данные из файла, зависящего от его номера. Данные имеют вид: вектор <math>b</math> и набор определённых строк матрицы <math>A</math> в формате '''RR(C)U''' в зависимости от номера процессора и их числа;
# Процессоры проводят вычисления значений вектора <math>c</math> в зависимости от имеющихся данных;
# Все процессоры отправляют результаты вычисления процессору, выбранному главным, и главный процессор выводит результат вычислений.

Проведём исследование масштабируемости параллельной реализации алгоритма умножения разреженной матрицы на вектор. Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

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

* число процессоров [1 : 128] по степеням 2;
* размер матрицы [1000 : 10000] с шагом 1000.

[[file:Blizntime.png|thumb|center|1000px|Рисунок 2. Время работы программы в зависимости от количества процессоров и размера матрицы]]

Можно заметить, что при небольшом количестве входных данных, и большом количестве процессоров эффективность распараллеливания падает до нуля, поскольку время вычисления элементов вектора <math>c</math> становится несоизмеримо малым по сравнению с временем, затраченным на пересылку в пункте (3).

[[file:Efficiency(paral).png|thumb|center|1000px|Рисунок 4. Эффективность распараллеливания в зависимости от количества процессоров и размера матрицы]]

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

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

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

Существующие реализации:

SciPy [https://docs.scipy.org/doc/scipy-0.18.1/reference/index.html],

MatLab [https://www.mathworks.com/help/matlab/math/sparse-matrix-operations.html],

Intel MKL [https://software.intel.com/en-us/articles/intel-math-kernel-library-inspector-executor-sparse-blas-routines].

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

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

2016-11-29T22:19:34Z

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

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>O(l)</math>
| pf_height = <math>O(m)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>2l+m+n+1</math>
| output_data = <math>n</math>
}}
Выполнила: [[Участник:Blizn|И.В. Близнякова]] (611 группа).

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

== Общее описание алгоритма<ref>С.Писсанецки. Технология разреженных матриц. - М.: Мир, 1988.</ref> ==
'''Разрежённая матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается '''''плотной'''''.

Среди специалистов нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:
* есть <math>O(n)</math>. Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;
* в каждой строке не превышает 10 в типичном случае;
* ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.
* таково, что для данного алгоритма и вычислительной системы имеет смысл извлекать выгоду из наличия в ней нулей.

=== Хранение разреженной матрицы ===
==== Формат RR(C)O ====
Рассмотрим сначала формат '''RR(C)O'''. Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Ordered"'' (строчное представление, полное и упорядоченное). В данном формате вместо одного двумерного массива, используются три одномерных. Значения ненулевых элементов матрицы и соответствующие им столбцовые индексы хранятся в этом формате по строкам в двух массивах <math>AN</math> и <math>JA</math>. Массив указателей <math>IA</math>, используется для ссылки на компоненты массивов <math>AN</math> и <math>JA</math>, с которых начинается описание очередной строки. Последняя компонента массива <math>IA</math> содержит указатель первой свободной компоненты в массивах <math>AN</math> и <math>JA</math>, т.е. равна числу ненулевых элементов матрицы, увеличенному на единицу. Здесь уместно привести пример.

Рассмотрим матрицу <math>A</math>:
:<math>\begin{pmatrix}
0 & 0 & 0 & 2 & 0 \\
1 & 0 & 3 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 \\
0 & 6 & 0 & 0 & 0 \\
0 & 0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
тогда ее представление в формате '''RR(C)O''' будет иметь вид:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 1 3 2 3 ]
AN = [ 2 1 3 6 4 ]
Т.е. массив <math>AN</math> содержит все не нулевые элементы исходной матрицы <math>A</math>, массив <math>JA</math> номер столбца в котором находится соответствующий элемент из <math>AN</math> и наконец массив <math>IA</math> содержит номер с которого начинается описание элементов в массивах <math>JA</math> и <math>AN</math>. Таким образом информация об элементах 2-ой строки матрицы хранится в элементах с <math>IA[2] = 2</math> по <math>IA[3] - 1 = 3</math> включительно массивов <math>JA</math> и <math>AN</math>. Можно обратить внимание, что <math>IA[3] = IA[4] = 4</math>, а это означает, что 3-я строка матрицы <math>A</math> нулевая.

В общем случае описание <math>r</math>-й строки матрицы A хранится в компонентах с <math>IA[r]</math> до <math>IA[r + 1] - 1</math> включительно массивов <math>AN</math> и <math>JA</math>. Если <math>IA[r + 1] = IA[r]</math>, то это означает, что <math>r</math>-я строка нулевая. Количество элементов в массиве <math>IA</math> на единицу больше, чем число строк исходной матрицы, а количество элементов в массивах <math>JA</math> и <math>AN</math> равно числу ненулевых элементов исходной матрицы.

Данный способ представления называют ''полным'', поскольку представлена вся матрица <math>A</math>, ''упорядоченным'', поскольку элементы каждой строки матрицы <math>A</math> хранятся в соответствии с возрастанием столбцовых индексов, и строчным, поскольку информация о матрице <math>A</math> указывается по строкам.

Массивы <math>IA</math> и <math>JA</math> представляют портрет (структуру) матрицы <math>A</math>, задаваемый как множество списков смежности ассоциированного с <math>A</math> графа. Если алгоритм, реализующий какую-либо операцию над разреженными матрицами, разбит на этапы символической обработки, на котором определяется портрет результирующей матрицы, и численной обработки, на котором определяются значения элементов результирующей матрицы, то массивы <math>IA</math> и <math>JA</math> заполняются на первом этапе, а массив <math>AN</math> - на втором.

==== Формат RR(C)U ====

Рассмотрим теперь формат '''RR(C)U'''.

Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Unordered"'' (строчное представление, полное, но неупорядоченное). Формат '''RR(C)U''' отличается от '''RR(C)O''' тем, что в данном случае соблюдается упорядоченность строк, но внутри каждой строки элементы исходных матриц могут храниться в произвольном порядке. Для матрицы <math>A</math> нашего примера вполне можно было бы использовать и строчное представление, полное, но неупорядоченное такое:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 3 1 2 3 ]
AN = [ 2 1 3 6 4 ]
Такие неупорядоченные представления могут быть очень удобны в практических вычислениях. Результаты большинства матричных операций получаются неупорядоченными, а их упорядочение стоило бы значительных затрат машинного времени. В то же время, за немногими исключениями, алгоритмы для разреженных матриц не требуют, чтобы их представления были упорядоченными.

==== Замечания ====

Несколько замечаний по поводу рассмотренных форматов представления:
# Очевидно, что представление матрицы в формате '''RR(C)O''' так же является и представлением в формате '''RR(C)U''', но не наоборот.
# Из представления матрицы в формате '''RR(C)''' нельзя получить информацию о точном количестве столбцов исходной матрицы.
# Целесообразно (в вопросе экономии памяти) использовать представления '''RR(C)''' в случае, если матрица содержит значительное число нулевых элементов.

=== Умножение разреженной матрицы на вектор ===

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

Мы рассмотрим умножение разреженной матрицы общего вида, хранимой в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math> на заполненный вектор-столбец.

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

Исходные данные: разреженная матрица общего вида <math>A</math> с элементами <math>a_{ij}</math> (<math>i = 1,...,n</math> и <math>j = 1,...,m</math>). Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> (<math>j =1,...,m</math>).

Вычисляемые данные: заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

Формулы метода:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

где <math>l_{i}</math> - количество ненулевых элементов строки <math>i</math> матрицы <math>A</math>, <math>j(k)</math> - индекс <math>k</math>-го ненулевого элемента матрицы <math>A</math>.

== Вычислительное ядро алгоритма ==
Вычислительное ядро последовательной версии умножения разреженной матрицы на вектор можно составить из множественных (всего их <math>n</math>) вычислений скалярных произведений строк матрицы:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>.

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

Как записано и в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют множественные (всего <math>n</math>) вычисления сумм:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

которые могут вычисляться в произвольном порядке.

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

Далее предполагаем, что разреженная матрица общего вида <math>A</math> хранится в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>.
Последовательность исполнения метода следующая:

Выполнять для <math>i</math> от <math>1</math> до <math>n</math>
# <math>c_{i} = 0</math>
# <math>IAA = IA[i]</math>
# <math>IAB = IA[i + 1] - 1</math>
# <math>c_{i} = \sum\limits_{k = IAA}^{IAB} AN[k]b_{JA[k]}</math>.
После этого (если <math>i \le n</math>) происходит переход к шагу 1 с бо́льшим <math>i</math>.

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размером <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в последовательном (наиболее быстром) варианте требуется:

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

Умножения и сложения составляют ''основную часть алгоритма''.

При классификации по последовательной сложности, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам <math>O(l)</math>.

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

Опишем [[глоссарий#Граф алгоритма|граф алгоритма]]<ref>Воеводин В.В. Математические основы параллельных вычислений// М.: Изд. Моск. ун-та, 1991. 345 с.</ref><ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. – СПб.: БХВ - Петербург, 2002. – 608 с.</ref><ref>Фролов А.В.. Принципы построения и описание языка Сигма. Препринт ОВМ АН N 236. М.: ОВМ АН СССР, 1989.</ref> как аналитически, так и в виде рисунка.

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

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

* <math>i</math> — меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math> - элемент ''входных данных'', а именно <math>AN[IA_{i}+j-1]</math>.
* <math>b</math> - элемент ''входных данных'', а именно <math>b[IA_{i}+j-1]</math>.

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

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция <math>a + b</math>.
Естественно введённые координаты области таковы:
* <math>i</math> - меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> - меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math>:
** при <math>j = 1</math> - результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j)</math>;
** при <math>j > 1</math> - результат срабатывания операции, соответствующей вершине из второй группы, с координатами <math>(i, j - 1)</math>;
* <math>b</math> — результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j + 1)</math>.

Результат срабатывания операции:
* при <math>j < k - 1</math> является ''промежуточным данным'' алгоритма;
* при <math>j = k - 1</math> является ''выходным данным'' <math>c_{i}</math>.

Описанный граф можно посмотреть на рис.1. Здесь вершины первой группы обозначены красным цветом и отмечены знаком умножения, вершины второй - зелёным цветом и знаком сложения. Вершины, соответствующие входным данным обозначены белым цветом и выходным - синим.
[[file:Bliznalg.png|thumb|center|1000px|Рисунок 1. Граф алгоритма умножения разреженной матрицы на вектор]]

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размерности <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в параллельном варианте требуется последовательно выполнить следующие ярусы:

* Не более чем <math>m</math> сложений и умножений (<math>n</math> вычислений в каждом из ярусов)

При классификации по высоте ЯПФ, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам со сложностью <math>O(m)</math>. При классификации по ширине ЯПФ его сложность будет <math>O(n)</math>.

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

'''Входные данные''': разреженная матрица общего вида <math>A</math> размерности <math>n \times m</math>, хранимая в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>. Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> размерности <math>m \times 1</math>.

'''Объём входных данных''': <math>2l+m+n+1</math>, где <math>l</math> - количество ненулевых элементов в матрице <math>A</math>.

'''Выходные данные''': заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

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

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

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

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

Пусть <math>l</math> - количество ненулевых элементов матрицы <math>A</math> размерности <math>n \times m</math>. Пусть <math>x</math> - объем памяти, используемый для хранения значения элемента матрицы, <math>y</math> - объём памяти, используемый для хранения номера столбца или строки. В таком случае для хранения матрицы в стандартном представлении нам потребуется объем памяти, равный <math>x \cdot n \cdot m</math>, для хранения в формате '''RR(C)''' - <math>y(n + 1) + (x + y)l</math>. Таким образом хранение в формате '''RR(C)''' не является эффективным для матриц, в которых <math>l > \frac{xnm - y(n+1)}{x+y}</math>.

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

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

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

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

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

Параллельная реализация алгоритма заключается в следующем:

# Каждый процессор считывает входные данные из файла, зависящего от его номера. Данные имеют вид: вектор <math>b</math> и набор определённых строк матрицы <math>A</math> в формате '''RR(C)U''' в зависимости от номера процессора и их числа;
# Процессоры проводят вычисления значений вектора <math>c</math> в зависимости от имеющихся данных;
# Все процессоры отправляют результаты вычисления процессору, выбранному главным, и главный процессор выводит результат вычислений.

Проведём исследование масштабируемости параллельной реализации алгоритма умножения разреженной матрицы на вектор. Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

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

* число процессоров [1 : 128] по степеням 2;
* размер матрицы [1000 : 10000] с шагом 1000.

[[file:Blizntime.png|thumb|center|1000px|Рисунок 2. Время работы программы в зависимости от количества процессоров и размера матрицы]]

Можно заметить, что при небольшом количестве входных данных, и большом количестве процессоров эффективность распараллеливания падает до нуля, поскольку время вычисления элементов вектора <math>c</math> становится несоизмеримо малым по сравнению с временем, затраченным на пересылку в пункте (3).

[[file:Efficiency(paral).png|thumb|center|1000px|Рисунок 4. Эффективность распараллеливания в зависимости от количества процессоров и размера матрицы]]

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

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

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

Существующие реализации:

SciPy [https://docs.scipy.org/doc/scipy-0.18.1/reference/index.html],

MatLab [https://www.mathworks.com/help/matlab/math/sparse-matrix-operations.html],

Intel MKL [https://software.intel.com/en-us/articles/intel-math-kernel-library-inspector-executor-sparse-blas-routines].

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

Файл:Blizntime.png

2016-11-29T21:27:55Z

Blizn:

Файл:Efficiency(paral).png

2016-11-29T21:26:09Z

Blizn:

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

2016-11-29T20:11:59Z

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

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>O(l)</math>
| pf_height = <math>O(m)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>2l+m+n+1</math>
| output_data = <math>n</math>
}}
Выполнила: [[Участник:Blizn|И.В. Близнякова]] (611 группа).

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

== Общее описание алгоритма<ref>С.Писсанецки. Технология разреженных матриц. - М.: Мир, 1988.</ref> ==
'''Разрежённая матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается '''''плотной'''''.

Среди специалистов нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:
* есть <math>O(n)</math>. Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;
* в каждой строке не превышает 10 в типичном случае;
* ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.
* таково, что для данного алгоритма и вычислительной системы имеет смысл извлекать выгоду из наличия в ней нулей.

=== Хранение разреженной матрицы ===
==== Формат RR(C)O ====
Рассмотрим сначала формат '''RR(C)O'''. Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Ordered"'' (строчное представление, полное и упорядоченное). В данном формате вместо одного двумерного массива, используются три одномерных. Значения ненулевых элементов матрицы и соответствующие им столбцовые индексы хранятся в этом формате по строкам в двух массивах <math>AN</math> и <math>JA</math>. Массив указателей <math>IA</math>, используется для ссылки на компоненты массивов <math>AN</math> и <math>JA</math>, с которых начинается описание очередной строки. Последняя компонента массива <math>IA</math> содержит указатель первой свободной компоненты в массивах <math>AN</math> и <math>JA</math>, т.е. равна числу ненулевых элементов матрицы, увеличенному на единицу. Здесь уместно привести пример.

Рассмотрим матрицу <math>A</math>:
:<math>\begin{pmatrix}
0 & 0 & 0 & 2 & 0 \\
1 & 0 & 3 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 \\
0 & 6 & 0 & 0 & 0 \\
0 & 0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
тогда ее представление в формате '''RR(C)O''' будет иметь вид:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 1 3 2 3 ]
AN = [ 2 1 3 6 4 ]
Т.е. массив <math>AN</math> содержит все не нулевые элементы исходной матрицы <math>A</math>, массив <math>JA</math> номер столбца в котором находится соответствующий элемент из <math>AN</math> и наконец массив <math>IA</math> содержит номер с которого начинается описание элементов в массивах <math>JA</math> и <math>AN</math>. Таким образом информация об элементах 2-ой строки матрицы хранится в элементах с <math>IA[2] = 2</math> по <math>IA[3] - 1 = 3</math> включительно массивов <math>JA</math> и <math>AN</math>. Можно обратить внимание, что <math>IA[3] = IA[4] = 4</math>, а это означает, что 3-я строка матрицы <math>A</math> нулевая.

В общем случае описание <math>r</math>-й строки матрицы A хранится в компонентах с <math>IA[r]</math> до <math>IA[r + 1] - 1</math> включительно массивов <math>AN</math> и <math>JA</math>. Если <math>IA[r + 1] = IA[r]</math>, то это означает, что <math>r</math>-я строка нулевая. Количество элементов в массиве <math>IA</math> на единицу больше, чем число строк исходной матрицы, а количество элементов в массивах <math>JA</math> и <math>AN</math> равно числу ненулевых элементов исходной матрицы.

Данный способ представления называют ''полным'', поскольку представлена вся матрица <math>A</math>, ''упорядоченным'', поскольку элементы каждой строки матрицы <math>A</math> хранятся в соответствии с возрастанием столбцовых индексов, и строчным, поскольку информация о матрице <math>A</math> указывается по строкам.

Массивы <math>IA</math> и <math>JA</math> представляют портрет (структуру) матрицы <math>A</math>, задаваемый как множество списков смежности ассоциированного с <math>A</math> графа. Если алгоритм, реализующий какую-либо операцию над разреженными матрицами, разбит на этапы символической обработки, на котором определяется портрет результирующей матрицы, и численной обработки, на котором определяются значения элементов результирующей матрицы, то массивы <math>IA</math> и <math>JA</math> заполняются на первом этапе, а массив <math>AN</math> - на втором.

==== Формат RR(C)U ====

Рассмотрим теперь формат '''RR(C)U'''.

Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Unordered"'' (строчное представление, полное, но неупорядоченное). Формат '''RR(C)U''' отличается от '''RR(C)O''' тем, что в данном случае соблюдается упорядоченность строк, но внутри каждой строки элементы исходных матриц могут храниться в произвольном порядке. Для матрицы <math>A</math> нашего примера вполне можно было бы использовать и строчное представление, полное, но неупорядоченное такое:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 3 1 2 3 ]
AN = [ 2 1 3 6 4 ]
Такие неупорядоченные представления могут быть очень удобны в практических вычислениях. Результаты большинства матричных операций получаются неупорядоченными, а их упорядочение стоило бы значительных затрат машинного времени. В то же время, за немногими исключениями, алгоритмы для разреженных матриц не требуют, чтобы их представления были упорядоченными.

==== Замечания ====

Несколько замечаний по поводу рассмотренных форматов представления:
# Очевидно, что представление матрицы в формате '''RR(C)O''' так же является и представлением в формате '''RR(C)U''', но не наоборот.
# Из представления матрицы в формате '''RR(C)''' нельзя получить информацию о точном количестве столбцов исходной матрицы.
# Целесообразно (в вопросе экономии памяти) использовать представления '''RR(C)''' в случае, если матрица содержит значительное число нулевых элементов.

=== Умножение разреженной матрицы на вектор ===

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

Мы рассмотрим умножение разреженной матрицы общего вида, хранимой в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math> на заполненный вектор-столбец.

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

Исходные данные: разреженная матрица общего вида <math>A</math> с элементами <math>a_{ij}</math> (<math>i = 1,...,n</math> и <math>j = 1,...,m</math>). Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> (<math>j =1,...,m</math>).

Вычисляемые данные: заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

Формулы метода:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

где <math>l_{i}</math> - количество ненулевых элементов строки <math>i</math> матрицы <math>A</math>, <math>j(k)</math> - индекс <math>k</math>-го ненулевого элемента матрицы <math>A</math>.

== Вычислительное ядро алгоритма ==
Вычислительное ядро последовательной версии умножения разреженной матрицы на вектор можно составить из множественных (всего их <math>n</math>) вычислений скалярных произведений строк матрицы:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>.

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

Как записано и в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют множественные (всего <math>n</math>) вычисления сумм:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

которые могут вычисляться в произвольном порядке.

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

Далее предполагаем, что разреженная матрица общего вида <math>A</math> хранится в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>.
Последовательность исполнения метода следующая:

Выполнять для <math>i</math> от <math>1</math> до <math>n</math>
# <math>c_{i} = 0</math>
# <math>IAA = IA[i]</math>
# <math>IAB = IA[i + 1] - 1</math>
# <math>c_{i} = \sum\limits_{k = IAA}^{IAB} AN[k]b_{JA[k]}</math>.
После этого (если <math>i \le n</math>) происходит переход к шагу 1 с бо́льшим <math>i</math>.

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размером <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в последовательном (наиболее быстром) варианте требуется:

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

Умножения и сложения составляют ''основную часть алгоритма''.

При классификации по последовательной сложности, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам <math>O(l)</math>.

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

Опишем [[глоссарий#Граф алгоритма|граф алгоритма]]<ref>Воеводин В.В. Математические основы параллельных вычислений// М.: Изд. Моск. ун-та, 1991. 345 с.</ref><ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. – СПб.: БХВ - Петербург, 2002. – 608 с.</ref><ref>Фролов А.В.. Принципы построения и описание языка Сигма. Препринт ОВМ АН N 236. М.: ОВМ АН СССР, 1989.</ref> как аналитически, так и в виде рисунка.

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

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

* <math>i</math> — меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math> - элемент ''входных данных'', а именно <math>AN[IA_{i}+j-1]</math>.
* <math>b</math> - элемент ''входных данных'', а именно <math>b[IA_{i}+j-1]</math>.

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

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция <math>a + b</math>.
Естественно введённые координаты области таковы:
* <math>i</math> - меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> - меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math>:
** при <math>j = 1</math> - результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j)</math>;
** при <math>j > 1</math> - результат срабатывания операции, соответствующей вершине из второй группы, с координатами <math>(i, j - 1)</math>;
* <math>b</math> — результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j + 1)</math>.

Результат срабатывания операции:
* при <math>j < k - 1</math> является ''промежуточным данным'' алгоритма;
* при <math>j = k - 1</math> является ''выходным данным'' <math>c_{i}</math>.

Описанный граф можно посмотреть на рис.1. Здесь вершины первой группы обозначены красным цветом и отмечены знаком умножения, вершины второй - зелёным цветом и знаком сложения. Вершины, соответствующие входным данным обозначены белым цветом и выходным - синим.
[[file:Bliznalg.png|thumb|center|1000px|Рисунок 1. Граф алгоритма умножения разреженной матрицы на вектор]]

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размерности <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в параллельном варианте требуется последовательно выполнить следующие ярусы:

* Не более чем <math>m</math> сложений и умножений (<math>n</math> вычислений в каждом из ярусов)

При классификации по высоте ЯПФ, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам со сложностью <math>O(m)</math>. При классификации по ширине ЯПФ его сложность будет <math>O(n)</math>.

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

'''Входные данные''': разреженная матрица общего вида <math>A</math> размерности <math>n \times m</math>, хранимая в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>. Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> размерности <math>m \times 1</math>.

'''Объём входных данных''': <math>2l+m+n+1</math>, где <math>l</math> - количество ненулевых элементов в матрице <math>A</math>.

'''Выходные данные''': заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

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

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

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

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

Пусть <math>l</math> - количество ненулевых элементов матрицы <math>A</math> размерности <math>n \times m</math>. Пусть <math>x</math> - объем памяти, используемый для хранения значения элемента матрицы, <math>y</math> - объём памяти, используемый для хранения номера столбца или строки. В таком случае для хранения матрицы в стандартном представлении нам потребуется объем памяти, равный <math>x \cdot n \cdot m</math>, для хранения в формате '''RR(C)''' - <math>y(n + 1) + (x + y)l</math>. Таким образом хранение в формате '''RR(C)''' не является эффективным для матриц, в которых <math>l > \frac{xnm - y(n+1)}{x+y}</math>.

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

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

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

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

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

Параллельная реализация алгоритма заключается в следующем:

# Каждый процессор считывает входные данные из файла, зависящего от его номера. Данные имеют вид: вектор <math>b</math> и набор определённых строк матрицы <math>A</math> в формате '''RR(C)U''' в зависимости от номера процессора и их числа;
# Процессоры проводят вычисления значений вектора <math>c</math> в зависимости от имеющихся данных;
# Все процессоры отправляют результаты вычисления процессору, выбранному главным, и главный процессор выводит результат вычислений.

Проведём исследование масштабируемости параллельной реализации алгоритма умножения разреженной матрицы на вектор. Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

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

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

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

Существующие реализации:

SciPy [https://docs.scipy.org/doc/scipy-0.18.1/reference/index.html],

MatLab [https://www.mathworks.com/help/matlab/math/sparse-matrix-operations.html],

Intel MKL [https://software.intel.com/en-us/articles/intel-math-kernel-library-inspector-executor-sparse-blas-routines].

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

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

2016-11-28T00:04:57Z

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

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>O(l)</math>
| pf_height = <math>O(m)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>2l+m+n+1</math>
| output_data = <math>n</math>
}}
Выполнила: [[Участник:Blizn|И.В. Близнякова]] (611 группа).

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

== Общее описание алгоритма<ref>С.Писсанецки. Технология разреженных матриц. - М.: Мир, 1988.</ref> ==
'''Разрежённая матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается '''''плотной'''''.

Среди специалистов нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:
* есть <math>O(n)</math>. Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;
* в каждой строке не превышает 10 в типичном случае;
* ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.
* таково, что для данного алгоритма и вычислительной системы имеет смысл извлекать выгоду из наличия в ней нулей.

=== Хранение разреженной матрицы ===
==== Формат RR(C)O ====
Рассмотрим сначала формат '''RR(C)O'''. Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Ordered"'' (строчное представление, полное и упорядоченное). В данном формате вместо одного двумерного массива, используются три одномерных. Значения ненулевых элементов матрицы и соответствующие им столбцовые индексы хранятся в этом формате по строкам в двух массивах <math>AN</math> и <math>JA</math>. Массив указателей <math>IA</math>, используется для ссылки на компоненты массивов <math>AN</math> и <math>JA</math>, с которых начинается описание очередной строки. Последняя компонента массива <math>IA</math> содержит указатель первой свободной компоненты в массивах <math>AN</math> и <math>JA</math>, т.е. равна числу ненулевых элементов матрицы, увеличенному на единицу. Здесь уместно привести пример.

Рассмотрим матрицу <math>A</math>:
:<math>\begin{pmatrix}
0 & 0 & 0 & 2 & 0 \\
1 & 0 & 3 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 \\
0 & 6 & 0 & 0 & 0 \\
0 & 0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
тогда ее представление в формате '''RR(C)O''' будет иметь вид:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 1 3 2 3 ]
AN = [ 2 1 3 6 4 ]
Т.е. массив <math>AN</math> содержит все не нулевые элементы исходной матрицы <math>A</math>, массив <math>JA</math> номер столбца в котором находится соответствующий элемент из <math>AN</math> и наконец массив <math>IA</math> содержит номер с которого начинается описание элементов в массивах <math>JA</math> и <math>AN</math>. Таким образом информация об элементах 2-ой строки матрицы хранится в элементах с <math>IA[2] = 2</math> по <math>IA[3] - 1 = 3</math> включительно массивов <math>JA</math> и <math>AN</math>. Можно обратить внимание, что <math>IA[3] = IA[4] = 4</math>, а это означает, что 3-я строка матрицы <math>A</math> нулевая.

В общем случае описание <math>r</math>-й строки матрицы A хранится в компонентах с <math>IA[r]</math> до <math>IA[r + 1] - 1</math> включительно массивов <math>AN</math> и <math>JA</math>. Если <math>IA[r + 1] = IA[r]</math>, то это означает, что <math>r</math>-я строка нулевая. Количество элементов в массиве <math>IA</math> на единицу больше, чем число строк исходной матрицы, а количество элементов в массивах <math>JA</math> и <math>AN</math> равно числу ненулевых элементов исходной матрицы.

Данный способ представления называют ''полным'', поскольку представлена вся матрица <math>A</math>, ''упорядоченным'', поскольку элементы каждой строки матрицы <math>A</math> хранятся в соответствии с возрастанием столбцовых индексов, и строчным, поскольку информация о матрице <math>A</math> указывается по строкам.

Массивы <math>IA</math> и <math>JA</math> представляют портрет (структуру) матрицы <math>A</math>, задаваемый как множество списков смежности ассоциированного с <math>A</math> графа. Если алгоритм, реализующий какую-либо операцию над разреженными матрицами, разбит на этапы символической обработки, на котором определяется портрет результирующей матрицы, и численной обработки, на котором определяются значения элементов результирующей матрицы, то массивы <math>IA</math> и <math>JA</math> заполняются на первом этапе, а массив <math>AN</math> - на втором.

==== Формат RR(C)U ====

Рассмотрим теперь формат '''RR(C)U'''.

Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Unordered"'' (строчное представление, полное, но неупорядоченное). Формат '''RR(C)U''' отличается от '''RR(C)O''' тем, что в данном случае соблюдается упорядоченность строк, но внутри каждой строки элементы исходных матриц могут храниться в произвольном порядке. Для матрицы <math>A</math> нашего примера вполне можно было бы использовать и строчное представление, полное, но неупорядоченное такое:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 3 1 2 3 ]
AN = [ 2 1 3 6 4 ]
Такие неупорядоченные представления могут быть очень удобны в практических вычислениях. Результаты большинства матричных операций получаются неупорядоченными, а их упорядочение стоило бы значительных затрат машинного времени. В то же время, за немногими исключениями, алгоритмы для разреженных матриц не требуют, чтобы их представления были упорядоченными.

==== Замечания ====

Несколько замечаний по поводу рассмотренных форматов представления:
# Очевидно, что представление матрицы в формате '''RR(C)O''' так же является и представлением в формате '''RR(C)U''', но не наоборот.
# Из представления матрицы в формате '''RR(C)''' нельзя получить информацию о точном количестве столбцов исходной матрицы.
# Целесообразно (в вопросе экономии памяти) использовать представления '''RR(C)''' в случае, если матрица содержит значительное число нулевых элементов.

=== Умножение разреженной матрицы на вектор ===

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

Мы рассмотрим умножение разреженной матрицы общего вида, хранимой в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math> на заполненный вектор-столбец.

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

Исходные данные: разреженная матрица общего вида <math>A</math> с элементами <math>a_{ij}</math> (<math>i = 1,...,n</math> и <math>j = 1,...,m</math>). Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> (<math>j =1,...,m</math>).

Вычисляемые данные: заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

Формулы метода:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

где <math>l_{i}</math> - количество ненулевых элементов строки <math>i</math> матрицы <math>A</math>, <math>j(k)</math> - индекс <math>k</math>-го ненулевого элемента матрицы <math>A</math>.

== Вычислительное ядро алгоритма ==
Вычислительное ядро последовательной версии умножения разреженной матрицы на вектор можно составить из множественных (всего их <math>n</math>) вычислений скалярных произведений строк матрицы:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>.

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

Как записано и в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют множественные (всего <math>n</math>) вычисления сумм:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

которые могут вычисляться в произвольном порядке.

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

Далее предполагаем, что разреженная матрица общего вида <math>A</math> хранится в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>.
Последовательность исполнения метода следующая:

Выполнять для <math>i</math> от <math>1</math> до <math>n</math>
# <math>c_{i} = 0</math>
# <math>IAA = IA[i]</math>
# <math>IAB = IA[i + 1] - 1</math>
# <math>c_{i} = \sum\limits_{k = IAA}^{IAB} AN[k]b_{JA[k]}</math>.
После этого (если <math>i \le n</math>) происходит переход к шагу 1 с бо́льшим <math>i</math>.

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размером <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в последовательном (наиболее быстром) варианте требуется:

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

Умножения и сложения составляют ''основную часть алгоритма''.

При классификации по последовательной сложности, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам <math>O(l)</math>.

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

Опишем [[глоссарий#Граф алгоритма|граф алгоритма]]<ref>Воеводин В.В. Математические основы параллельных вычислений// М.: Изд. Моск. ун-та, 1991. 345 с.</ref><ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. – СПб.: БХВ - Петербург, 2002. – 608 с.</ref><ref>Фролов А.В.. Принципы построения и описание языка Сигма. Препринт ОВМ АН N 236. М.: ОВМ АН СССР, 1989.</ref> как аналитически, так и в виде рисунка.

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

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

* <math>i</math> — меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math> - элемент ''входных данных'', а именно <math>AN[IA_{i}+j-1]</math>.
* <math>b</math> - элемент ''входных данных'', а именно <math>b[IA_{i}+j-1]</math>.

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

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция <math>a + b</math>.
Естественно введённые координаты области таковы:
* <math>i</math> - меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> - меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math>:
** при <math>j = 1</math> - результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j)</math>;
** при <math>j > 1</math> - результат срабатывания операции, соответствующей вершине из второй группы, с координатами <math>(i, j - 1)</math>;
* <math>b</math> — результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j + 1)</math>.

Результат срабатывания операции:
* при <math>j < k - 1</math> является ''промежуточным данным'' алгоритма;
* при <math>j = k - 1</math> является ''выходным данным'' <math>c_{i}</math>.

Описанный граф можно посмотреть на рис.1. Здесь вершины первой группы обозначены красным цветом и отмечены знаком умножения, вершины второй - зелёным цветом и знаком сложения. Вершины, соответствующие входным данным обозначены белым цветом и выходным - синим.
[[file:Bliznalg.png|thumb|center|1000px|Рисунок 1. Граф алгоритма умножения разреженной матрицы на вектор]]

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размерности <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в параллельном варианте требуется последовательно выполнить следующие ярусы:

* Не более чем <math>m</math> сложений и умножений (<math>n</math> вычислений в каждом из ярусов)

При классификации по высоте ЯПФ, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам со сложностью <math>O(m)</math>. При классификации по ширине ЯПФ его сложность будет <math>O(n)</math>.

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

'''Входные данные''': разреженная матрица общего вида <math>A</math> размерности <math>n \times m</math>, хранимая в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>. Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> размерности <math>m \times 1</math>.

'''Объём входных данных''': <math>2l+m+n+1</math>, где <math>l</math> - количество ненулевых элементов в матрице <math>A</math>.

'''Выходные данные''': заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

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

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

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

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

Пусть <math>l</math> - количество ненулевых элементов матрицы <math>A</math> размерности <math>n \times m</math>. Пусть <math>x</math> - объем памяти, используемый для хранения значения элемента матрицы, <math>y</math> - объём памяти, используемый для хранения номера столбца или строки. В таком случае для хранения матрицы в стандартном представлении нам потребуется объем памяти, равный <math>x \cdot n \cdot m</math>, для хранения в формате '''RR(C)''' - <math>y(n + 1) + (x + y)l</math>. Таким образом хранение в формате '''RR(C)''' не является эффективным для матриц, в которых <math>l > \frac{xnm - y(n+1)}{x+y}</math>.

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

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

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

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

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

Параллельная реализация алгоритма заключается в следующем:

# Один из процессоров выбирается главным;
# Процессор, выбранный главным (далее - главный процессор), считывает данные: вектор <math>b</math> и разреженную матрицу общего вида <math>A</math>, заданную в формате '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>;
# Главный процессор "разрезает" матрицу по строкам в зависимости от числа процессоров и отправляет другим процессорам набор данных в виде: вектор <math>b</math> и набор определённых строк матрицы <math>A</math>;
# Все процессоры (включая главный) проводят вычисления значений вектора <math>c</math> в зависимости от имеющихся данных;
# Все процессоры отправляют результаты вычисления главному процессору, главный процессор выводит результат вычислений.

Проведём исследование масштабируемости параллельной реализации алгоритма умножения разреженной матрицы на вектор. Исследование ещё проводится на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

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

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

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

Существующие реализации:

SciPy [https://docs.scipy.org/doc/scipy-0.18.1/reference/index.html],

MatLab [https://www.mathworks.com/help/matlab/math/sparse-matrix-operations.html],

Intel MKL [https://software.intel.com/en-us/articles/intel-math-kernel-library-inspector-executor-sparse-blas-routines].

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

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

2016-11-02T13:44:54Z

Blizn:

{{Assignment}}

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>O(l)</math>
| pf_height = <math>O(m)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>2l+m+n+1</math>
| output_data = <math>n</math>
}}
Выполнила: [[Участник:Blizn|И.В. Близнякова]] (611 группа).

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

== Общее описание алгоритма<ref>С.Писсанецки. Технология разреженных матриц. - М.: Мир, 1988.</ref> ==
'''Разрежённая матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается '''''плотной'''''.

Среди специалистов нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:
* есть <math>O(n)</math>. Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;
* в каждой строке не превышает 10 в типичном случае;
* ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.
* таково, что для данного алгоритма и вычислительной системы имеет смысл извлекать выгоду из наличия в ней нулей.

=== Хранение разреженной матрицы ===
==== Формат RR(C)O ====
Рассмотрим сначала формат '''RR(C)O'''. Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Ordered"'' (строчное представление, полное и упорядоченное). В данном формате вместо одного двумерного массива, используются три одномерных. Значения ненулевых элементов матрицы и соответствующие им столбцовые индексы хранятся в этом формате по строкам в двух массивах <math>AN</math> и <math>JA</math>. Массив указателей <math>IA</math>, используется для ссылки на компоненты массивов <math>AN</math> и <math>JA</math>, с которых начинается описание очередной строки. Последняя компонента массива <math>IA</math> содержит указатель первой свободной компоненты в массивах <math>AN</math> и <math>JA</math>, т.е. равна числу ненулевых элементов матрицы, увеличенному на единицу. Здесь уместно привести пример.

Рассмотрим матрицу <math>A</math>:
:<math>\begin{pmatrix}
0 & 0 & 0 & 2 & 0 \\
1 & 0 & 3 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 \\
0 & 6 & 0 & 0 & 0 \\
0 & 0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
тогда ее представление в формате '''RR(C)O''' будет иметь вид:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 1 3 2 3 ]
AN = [ 2 1 3 6 4 ]
Т.е. массив <math>AN</math> содержит все не нулевые элементы исходной матрицы <math>A</math>, массив <math>JA</math> номер столбца в котором находится соответствующий элемент из <math>AN</math> и наконец массив <math>IA</math> содержит номер с которого начинается описание элементов в массивах <math>JA</math> и <math>AN</math>. Таким образом информация об элементах 2-ой строки матрицы хранится в элементах с <math>IA[2] = 2</math> по <math>IA[3] - 1 = 3</math> включительно массивов <math>JA</math> и <math>AN</math>. Можно обратить внимание, что <math>IA[3] = IA[4] = 4</math>, а это означает, что 3-я строка матрицы <math>A</math> нулевая.

В общем случае описание <math>r</math>-й строки матрицы A хранится в компонентах с <math>IA[r]</math> до <math>IA[r + 1] - 1</math> включительно массивов <math>AN</math> и <math>JA</math>. Если <math>IA[r + 1] = IA[r]</math>, то это означает, что <math>r</math>-я строка нулевая. Количество элементов в массиве <math>IA</math> на единицу больше, чем число строк исходной матрицы, а количество элементов в массивах <math>JA</math> и <math>AN</math> равно числу ненулевых элементов исходной матрицы.

Данный способ представления называют ''полным'', поскольку представлена вся матрица <math>A</math>, ''упорядоченным'', поскольку элементы каждой строки матрицы <math>A</math> хранятся в соответствии с возрастанием столбцовых индексов, и строчным, поскольку информация о матрице <math>A</math> указывается по строкам.

Массивы <math>IA</math> и <math>JA</math> представляют портрет (структуру) матрицы <math>A</math>, задаваемый как множество списков смежности ассоциированного с <math>A</math> графа. Если алгоритм, реализующий какую-либо операцию над разреженными матрицами, разбит на этапы символической обработки, на котором определяется портрет результирующей матрицы, и численной обработки, на котором определяются значения элементов результирующей матрицы, то массивы <math>IA</math> и <math>JA</math> заполняются на первом этапе, а массив <math>AN</math> - на втором.

==== Формат RR(C)U ====

Рассмотрим теперь формат '''RR(C)U'''.

Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Unordered"'' (строчное представление, полное, но неупорядоченное). Формат '''RR(C)U''' отличается от '''RR(C)O''' тем, что в данном случае соблюдается упорядоченность строк, но внутри каждой строки элементы исходных матриц могут храниться в произвольном порядке. Для матрицы <math>A</math> нашего примера вполне можно было бы использовать и строчное представление, полное, но неупорядоченное такое:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 3 1 2 3 ]
AN = [ 2 1 3 6 4 ]
Такие неупорядоченные представления могут быть очень удобны в практических вычислениях. Результаты большинства матричных операций получаются неупорядоченными, а их упорядочение стоило бы значительных затрат машинного времени. В то же время, за немногими исключениями, алгоритмы для разреженных матриц не требуют, чтобы их представления были упорядоченными.

==== Замечания ====

Несколько замечаний по поводу рассмотренных форматов представления:
# Очевидно, что представление матрицы в формате '''RR(C)O''' так же является и представлением в формате '''RR(C)U''', но не наоборот.
# Из представления матрицы в формате '''RR(C)''' нельзя получить информацию о точном количестве столбцов исходной матрицы.
# Целесообразно (в вопросе экономии памяти) использовать представления '''RR(C)''' в случае, если матрица содержит значительное число нулевых элементов.

=== Умножение разреженной матрицы на вектор ===

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

Мы рассмотрим умножение разреженной матрицы общего вида, хранимой в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math> на заполненный вектор-столбец.

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

Исходные данные: разреженная матрица общего вида <math>A</math> с элементами <math>a_{ij}</math> (<math>i = 1,...,n</math> и <math>j = 1,...,m</math>). Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> (<math>j =1,...,m</math>).

Вычисляемые данные: заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

Формулы метода:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

где <math>l_{i}</math> - количество ненулевых элементов строки <math>i</math> матрицы <math>A</math>, <math>j(k)</math> - индекс <math>k</math>-го ненулевого элемента матрицы <math>A</math>.

== Вычислительное ядро алгоритма ==
Вычислительное ядро последовательной версии умножения разреженной матрицы на вектор можно составить из множественных (всего их <math>n</math>) вычислений скалярных произведений строк матрицы:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>.

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

Как записано и в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют множественные (всего <math>n</math>) вычисления сумм:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

которые могут вычисляться в произвольном порядке.

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

Далее предполагаем, что разреженная матрица общего вида <math>A</math> хранится в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>.
Последовательность исполнения метода следующая:

Выполнять для <math>i</math> от <math>1</math> до <math>n</math>
# <math>c_{i} = 0</math>
# <math>IAA = IA[i]</math>
# <math>IAB = IA[i + 1] - 1</math>
# <math>c_{i} = \sum\limits_{k = IAA}^{IAB} AN[k]b_{JA[k]}</math>.
После этого (если <math>i \le n</math>) происходит переход к шагу 1 с бо́льшим <math>i</math>.

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размером <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в последовательном (наиболее быстром) варианте требуется:

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

Умножения и сложения составляют ''основную часть алгоритма''.

При классификации по последовательной сложности, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам <math>O(l)</math>.

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

Опишем [[глоссарий#Граф алгоритма|граф алгоритма]]<ref>Воеводин В.В. Математические основы параллельных вычислений// М.: Изд. Моск. ун-та, 1991. 345 с.</ref><ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. – СПб.: БХВ - Петербург, 2002. – 608 с.</ref><ref>Фролов А.В.. Принципы построения и описание языка Сигма. Препринт ОВМ АН N 236. М.: ОВМ АН СССР, 1989.</ref> как аналитически, так и в виде рисунка.

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

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

* <math>i</math> — меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math> - элемент ''входных данных'', а именно <math>AN[IA_{i}+j-1]</math>.
* <math>b</math> - элемент ''входных данных'', а именно <math>b[IA_{i}+j-1]</math>.

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

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция <math>a + b</math>.
Естественно введённые координаты области таковы:
* <math>i</math> - меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> - меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math>:
** при <math>j = 1</math> - результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j)</math>;
** при <math>j > 1</math> - результат срабатывания операции, соответствующей вершине из второй группы, с координатами <math>(i, j - 1)</math>;
* <math>b</math> — результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j + 1)</math>.

Результат срабатывания операции:
* при <math>j < k - 1</math> является ''промежуточным данным'' алгоритма;
* при <math>j = k - 1</math> является ''выходным данным'' <math>c_{i}</math>.

Описанный граф можно посмотреть на рис.1. Здесь вершины первой группы обозначены красным цветом и отмечены знаком умножения, вершины второй - зелёным цветом и знаком сложения. Вершины, соответствующие входным данным обозначены белым цветом и выходным - синим.
[[file:Bliznalg.png|thumb|center|1000px|Рисунок 1. Граф алгоритма умножения разреженной матрицы на вектор]]

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размерности <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в параллельном варианте требуется последовательно выполнить следующие ярусы:

* Не более чем <math>m</math> сложений и умножений (<math>n</math> вычислений в каждом из ярусов)

При классификации по высоте ЯПФ, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам со сложностью <math>O(m)</math>. При классификации по ширине ЯПФ его сложность будет <math>O(n)</math>.

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

'''Входные данные''': разреженная матрица общего вида <math>A</math> размерности <math>n \times m</math>, хранимая в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>. Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> размерности <math>m \times 1</math>.

'''Объём входных данных''': <math>2l+m+n+1</math>, где <math>l</math> - количество ненулевых элементов в матрице <math>A</math>.

'''Выходные данные''': заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

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

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

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

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

Пусть <math>l</math> - количество ненулевых элементов матрицы <math>A</math> размерности <math>n \times m</math>. Пусть <math>x</math> - объем памяти, используемый для хранения значения элемента матрицы, <math>y</math> - объём памяти, используемый для хранения номера столбца или строки. В таком случае для хранения матрицы в стандартном представлении нам потребуется объем памяти, равный <math>x \cdot n \cdot m</math>, для хранения в формате '''RR(C)''' - <math>y(n + 1) + (x + y)l</math>. Таким образом хранение в формате '''RR(C)''' не является эффективным для матриц, в которых <math>l > \frac{xnm - y(n+1)}{x+y}</math>.

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

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

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

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

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

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

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

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

Существующие реализации:

SciPy [https://docs.scipy.org/doc/scipy-0.18.1/reference/index.html],

MatLab [https://www.mathworks.com/help/matlab/math/sparse-matrix-operations.html],

Intel MKL [https://software.intel.com/en-us/articles/intel-math-kernel-library-inspector-executor-sparse-blas-routines].

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

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

2016-11-02T13:42:49Z

Blizn: /* Макроструктура алгоритма */

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>O(l)</math>
| pf_height = <math>O(m)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>2l+m+n+1</math>
| output_data = <math>n</math>
}}
Выполнила: [[Участник:Blizn|И.В. Близнякова]] (611 группа).

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

== Общее описание алгоритма<ref>С.Писсанецки. Технология разреженных матриц. - М.: Мир, 1988.</ref> ==
'''Разрежённая матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается '''''плотной'''''.

Среди специалистов нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:
* есть <math>O(n)</math>. Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;
* в каждой строке не превышает 10 в типичном случае;
* ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.
* таково, что для данного алгоритма и вычислительной системы имеет смысл извлекать выгоду из наличия в ней нулей.

=== Хранение разреженной матрицы ===
==== Формат RR(C)O ====
Рассмотрим сначала формат '''RR(C)O'''. Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Ordered"'' (строчное представление, полное и упорядоченное). В данном формате вместо одного двумерного массива, используются три одномерных. Значения ненулевых элементов матрицы и соответствующие им столбцовые индексы хранятся в этом формате по строкам в двух массивах <math>AN</math> и <math>JA</math>. Массив указателей <math>IA</math>, используется для ссылки на компоненты массивов <math>AN</math> и <math>JA</math>, с которых начинается описание очередной строки. Последняя компонента массива <math>IA</math> содержит указатель первой свободной компоненты в массивах <math>AN</math> и <math>JA</math>, т.е. равна числу ненулевых элементов матрицы, увеличенному на единицу. Здесь уместно привести пример.

Рассмотрим матрицу <math>A</math>:
:<math>\begin{pmatrix}
0 & 0 & 0 & 2 & 0 \\
1 & 0 & 3 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 \\
0 & 6 & 0 & 0 & 0 \\
0 & 0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
тогда ее представление в формате '''RR(C)O''' будет иметь вид:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 1 3 2 3 ]
AN = [ 2 1 3 6 4 ]
Т.е. массив <math>AN</math> содержит все не нулевые элементы исходной матрицы <math>A</math>, массив <math>JA</math> номер столбца в котором находится соответствующий элемент из <math>AN</math> и наконец массив <math>IA</math> содержит номер с которого начинается описание элементов в массивах <math>JA</math> и <math>AN</math>. Таким образом информация об элементах 2-ой строки матрицы хранится в элементах с <math>IA[2] = 2</math> по <math>IA[3] - 1 = 3</math> включительно массивов <math>JA</math> и <math>AN</math>. Можно обратить внимание, что <math>IA[3] = IA[4] = 4</math>, а это означает, что 3-я строка матрицы <math>A</math> нулевая.

В общем случае описание <math>r</math>-й строки матрицы A хранится в компонентах с <math>IA[r]</math> до <math>IA[r + 1] - 1</math> включительно массивов <math>AN</math> и <math>JA</math>. Если <math>IA[r + 1] = IA[r]</math>, то это означает, что <math>r</math>-я строка нулевая. Количество элементов в массиве <math>IA</math> на единицу больше, чем число строк исходной матрицы, а количество элементов в массивах <math>JA</math> и <math>AN</math> равно числу ненулевых элементов исходной матрицы.

Данный способ представления называют ''полным'', поскольку представлена вся матрица <math>A</math>, ''упорядоченным'', поскольку элементы каждой строки матрицы <math>A</math> хранятся в соответствии с возрастанием столбцовых индексов, и строчным, поскольку информация о матрице <math>A</math> указывается по строкам.

Массивы <math>IA</math> и <math>JA</math> представляют портрет (структуру) матрицы <math>A</math>, задаваемый как множество списков смежности ассоциированного с <math>A</math> графа. Если алгоритм, реализующий какую-либо операцию над разреженными матрицами, разбит на этапы символической обработки, на котором определяется портрет результирующей матрицы, и численной обработки, на котором определяются значения элементов результирующей матрицы, то массивы <math>IA</math> и <math>JA</math> заполняются на первом этапе, а массив <math>AN</math> - на втором.

==== Формат RR(C)U ====

Рассмотрим теперь формат '''RR(C)U'''.

Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Unordered"'' (строчное представление, полное, но неупорядоченное). Формат '''RR(C)U''' отличается от '''RR(C)O''' тем, что в данном случае соблюдается упорядоченность строк, но внутри каждой строки элементы исходных матриц могут храниться в произвольном порядке. Для матрицы <math>A</math> нашего примера вполне можно было бы использовать и строчное представление, полное, но неупорядоченное такое:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 3 1 2 3 ]
AN = [ 2 1 3 6 4 ]
Такие неупорядоченные представления могут быть очень удобны в практических вычислениях. Результаты большинства матричных операций получаются неупорядоченными, а их упорядочение стоило бы значительных затрат машинного времени. В то же время, за немногими исключениями, алгоритмы для разреженных матриц не требуют, чтобы их представления были упорядоченными.

==== Замечания ====

Несколько замечаний по поводу рассмотренных форматов представления:
# Очевидно, что представление матрицы в формате '''RR(C)O''' так же является и представлением в формате '''RR(C)U''', но не наоборот.
# Из представления матрицы в формате '''RR(C)''' нельзя получить информацию о точном количестве столбцов исходной матрицы.
# Целесообразно (в вопросе экономии памяти) использовать представления '''RR(C)''' в случае, если матрица содержит значительное число нулевых элементов.

=== Умножение разреженной матрицы на вектор ===

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

Мы рассмотрим умножение разреженной матрицы общего вида, хранимой в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math> на заполненный вектор-столбец.

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

Исходные данные: разреженная матрица общего вида <math>A</math> с элементами <math>a_{ij}</math> (<math>i = 1,...,n</math> и <math>j = 1,...,m</math>). Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> (<math>j =1,...,m</math>).

Вычисляемые данные: заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

Формулы метода:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

где <math>l_{i}</math> - количество ненулевых элементов строки <math>i</math> матрицы <math>A</math>, <math>j(k)</math> - индекс <math>k</math>-го ненулевого элемента матрицы <math>A</math>.

== Вычислительное ядро алгоритма ==
Вычислительное ядро последовательной версии умножения разреженной матрицы на вектор можно составить из множественных (всего их <math>n</math>) вычислений скалярных произведений строк матрицы:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>.

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

Как записано и в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют множественные (всего <math>n</math>) вычисления сумм:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

которые могут вычисляться в произвольном порядке.

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

Далее предполагаем, что разреженная матрица общего вида <math>A</math> хранится в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>.
Последовательность исполнения метода следующая:

Выполнять для <math>i</math> от <math>1</math> до <math>n</math>
# <math>c_{i} = 0</math>
# <math>IAA = IA[i]</math>
# <math>IAB = IA[i + 1] - 1</math>
# <math>c_{i} = \sum\limits_{k = IAA}^{IAB} AN[k]b_{JA[k]}</math>.
После этого (если <math>i \le n</math>) происходит переход к шагу 1 с бо́льшим <math>i</math>.

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размером <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в последовательном (наиболее быстром) варианте требуется:

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

Умножения и сложения составляют ''основную часть алгоритма''.

При классификации по последовательной сложности, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам <math>O(l)</math>.

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

Опишем [[глоссарий#Граф алгоритма|граф алгоритма]]<ref>Воеводин В.В. Математические основы параллельных вычислений// М.: Изд. Моск. ун-та, 1991. 345 с.</ref><ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. – СПб.: БХВ - Петербург, 2002. – 608 с.</ref><ref>Фролов А.В.. Принципы построения и описание языка Сигма. Препринт ОВМ АН N 236. М.: ОВМ АН СССР, 1989.</ref> как аналитически, так и в виде рисунка.

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

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

* <math>i</math> — меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math> - элемент ''входных данных'', а именно <math>AN[IA_{i}+j-1]</math>.
* <math>b</math> - элемент ''входных данных'', а именно <math>b[IA_{i}+j-1]</math>.

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

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция <math>a + b</math>.
Естественно введённые координаты области таковы:
* <math>i</math> - меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> - меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math>:
** при <math>j = 1</math> - результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j)</math>;
** при <math>j > 1</math> - результат срабатывания операции, соответствующей вершине из второй группы, с координатами <math>(i, j - 1)</math>;
* <math>b</math> — результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j + 1)</math>.

Результат срабатывания операции:
* при <math>j < k - 1</math> является ''промежуточным данным'' алгоритма;
* при <math>j = k - 1</math> является ''выходным данным'' <math>c_{i}</math>.

Описанный граф можно посмотреть на рис.1. Здесь вершины первой группы обозначены красным цветом и отмечены знаком умножения, вершины второй - зелёным цветом и знаком сложения. Вершины, соответствующие входным данным обозначены белым цветом и выходным - синим.
[[file:Bliznalg.png|thumb|center|1000px|Рисунок 1. Граф алгоритма умножения разреженной матрицы на вектор]]

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размерности <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в параллельном варианте требуется последовательно выполнить следующие ярусы:

* Не более чем <math>m</math> сложений и умножений (<math>n</math> вычислений в каждом из ярусов)

При классификации по высоте ЯПФ, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам со сложностью <math>O(m)</math>. При классификации по ширине ЯПФ его сложность будет <math>O(n)</math>.

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

'''Входные данные''': разреженная матрица общего вида <math>A</math> размерности <math>n \times m</math>, хранимая в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>. Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> размерности <math>m \times 1</math>.

'''Объём входных данных''': <math>2l+m+n+1</math>, где <math>l</math> - количество ненулевых элементов в матрице <math>A</math>.

'''Выходные данные''': заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

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

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

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

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

Пусть <math>l</math> - количество ненулевых элементов матрицы <math>A</math> размерности <math>n \times m</math>. Пусть <math>x</math> - объем памяти, используемый для хранения значения элемента матрицы, <math>y</math> - объём памяти, используемый для хранения номера столбца или строки. В таком случае для хранения матрицы в стандартном представлении нам потребуется объем памяти, равный <math>x \cdot n \cdot m</math>, для хранения в формате '''RR(C)''' - <math>y(n + 1) + (x + y)l</math>. Таким образом хранение в формате '''RR(C)''' не является эффективным для матриц, в которых <math>l > \frac{xnm - y(n+1)}{x+y}</math>.

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

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

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

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

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

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

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

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

Существующие реализации:

SciPy [https://docs.scipy.org/doc/scipy-0.18.1/reference/index.html],

MatLab [https://www.mathworks.com/help/matlab/math/sparse-matrix-operations.html],

Intel MKL [https://software.intel.com/en-us/articles/intel-math-kernel-library-inspector-executor-sparse-blas-routines].

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

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

2016-11-01T20:59:41Z

Blizn:

{{Assignment}}

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>O(l)</math>
| pf_height = <math>O(m)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>2l+m+n+1</math>
| output_data = <math>n</math>
}}
Выполнила: [[Участник:Blizn|И.В. Близнякова]] (611 группа).

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

== Общее описание алгоритма<ref>С.Писсанецки. Технология разреженных матриц. - М.: Мир, 1988.</ref> ==
'''Разрежённая матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается '''''плотной'''''.

Среди специалистов нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:
* есть <math>O(n)</math>. Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;
* в каждой строке не превышает 10 в типичном случае;
* ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.
* таково, что для данного алгоритма и вычислительной системы имеет смысл извлекать выгоду из наличия в ней нулей.

=== Хранение разреженной матрицы ===
==== Формат RR(C)O ====
Рассмотрим сначала формат '''RR(C)O'''. Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Ordered"'' (строчное представление, полное и упорядоченное). В данном формате вместо одного двумерного массива, используются три одномерных. Значения ненулевых элементов матрицы и соответствующие им столбцовые индексы хранятся в этом формате по строкам в двух массивах <math>AN</math> и <math>JA</math>. Массив указателей <math>IA</math>, используется для ссылки на компоненты массивов <math>AN</math> и <math>JA</math>, с которых начинается описание очередной строки. Последняя компонента массива <math>IA</math> содержит указатель первой свободной компоненты в массивах <math>AN</math> и <math>JA</math>, т.е. равна числу ненулевых элементов матрицы, увеличенному на единицу. Здесь уместно привести пример.

Рассмотрим матрицу <math>A</math>:
:<math>\begin{pmatrix}
0 & 0 & 0 & 2 & 0 \\
1 & 0 & 3 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 \\
0 & 6 & 0 & 0 & 0 \\
0 & 0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
тогда ее представление в формате '''RR(C)O''' будет иметь вид:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 1 3 2 3 ]
AN = [ 2 1 3 6 4 ]
Т.е. массив <math>AN</math> содержит все не нулевые элементы исходной матрицы <math>A</math>, массив <math>JA</math> номер столбца в котором находится соответствующий элемент из <math>AN</math> и наконец массив <math>IA</math> содержит номер с которого начинается описание элементов в массивах <math>JA</math> и <math>AN</math>. Таким образом информация об элементах 2-ой строки матрицы хранится в элементах с <math>IA[2] = 2</math> по <math>IA[3] - 1 = 3</math> включительно массивов <math>JA</math> и <math>AN</math>. Можно обратить внимание, что <math>IA[3] = IA[4] = 4</math>, а это означает, что 3-я строка матрицы <math>A</math> нулевая.

В общем случае описание <math>r</math>-й строки матрицы A хранится в компонентах с <math>IA[r]</math> до <math>IA[r + 1] - 1</math> включительно массивов <math>AN</math> и <math>JA</math>. Если <math>IA[r + 1] = IA[r]</math>, то это означает, что <math>r</math>-я строка нулевая. Количество элементов в массиве <math>IA</math> на единицу больше, чем число строк исходной матрицы, а количество элементов в массивах <math>JA</math> и <math>AN</math> равно числу ненулевых элементов исходной матрицы.

Данный способ представления называют ''полным'', поскольку представлена вся матрица <math>A</math>, ''упорядоченным'', поскольку элементы каждой строки матрицы <math>A</math> хранятся в соответствии с возрастанием столбцовых индексов, и строчным, поскольку информация о матрице <math>A</math> указывается по строкам.

Массивы <math>IA</math> и <math>JA</math> представляют портрет (структуру) матрицы <math>A</math>, задаваемый как множество списков смежности ассоциированного с <math>A</math> графа. Если алгоритм, реализующий какую-либо операцию над разреженными матрицами, разбит на этапы символической обработки, на котором определяется портрет результирующей матрицы, и численной обработки, на котором определяются значения элементов результирующей матрицы, то массивы <math>IA</math> и <math>JA</math> заполняются на первом этапе, а массив <math>AN</math> - на втором.

==== Формат RR(C)U ====

Рассмотрим теперь формат '''RR(C)U'''.

Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Unordered"'' (строчное представление, полное, но неупорядоченное). Формат '''RR(C)U''' отличается от '''RR(C)O''' тем, что в данном случае соблюдается упорядоченность строк, но внутри каждой строки элементы исходных матриц могут храниться в произвольном порядке. Для матрицы <math>A</math> нашего примера вполне можно было бы использовать и строчное представление, полное, но неупорядоченное такое:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 3 1 2 3 ]
AN = [ 2 1 3 6 4 ]
Такие неупорядоченные представления могут быть очень удобны в практических вычислениях. Результаты большинства матричных операций получаются неупорядоченными, а их упорядочение стоило бы значительных затрат машинного времени. В то же время, за немногими исключениями, алгоритмы для разреженных матриц не требуют, чтобы их представления были упорядоченными.

==== Замечания ====

Несколько замечаний по поводу рассмотренных форматов представления:
# Очевидно, что представление матрицы в формате '''RR(C)O''' так же является и представлением в формате '''RR(C)U''', но не наоборот.
# Из представления матрицы в формате '''RR(C)''' нельзя получить информацию о точном количестве столбцов исходной матрицы.
# Целесообразно (в вопросе экономии памяти) использовать представления '''RR(C)''' в случае, если матрица содержит значительное число нулевых элементов.

=== Умножение разреженной матрицы на вектор ===

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

Мы рассмотрим умножение разреженной матрицы общего вида, хранимой в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math> на заполненный вектор-столбец.

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

Исходные данные: разреженная матрица общего вида <math>A</math> с элементами <math>a_{ij}</math> (<math>i = 1,...,n</math> и <math>j = 1,...,m</math>). Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> (<math>j =1,...,m</math>).

Вычисляемые данные: заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

Формулы метода:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

где <math>l_{i}</math> - количество ненулевых элементов строки <math>i</math> матрицы <math>A</math>, <math>j(k)</math> - индекс <math>k</math>-го ненулевого элемента матрицы <math>A</math>.

== Вычислительное ядро алгоритма ==
Вычислительное ядро последовательной версии умножения разреженной матрицы на вектор можно составить из множественных (всего их <math>n</math>) вычислений скалярных произведений строк матрицы:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>.

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

Как записано и в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют множественные (всего <math>n</math>) вычисления сумм:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} x_{i,j=j(k)}</math>,

где <math>x_{i,j=j(k)} = a_{i,j=j(k)}b_{j=j(k)}</math>.

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

Далее предполагаем, что разреженная матрица общего вида <math>A</math> хранится в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>.
Последовательность исполнения метода следующая:

Выполнять для <math>i</math> от <math>1</math> до <math>n</math>
# <math>c_{i} = 0</math>
# <math>IAA = IA[i]</math>
# <math>IAB = IA[i + 1] - 1</math>
# <math>c_{i} = \sum\limits_{k = IAA}^{IAB} AN[k]b_{JA[k]}</math>.
После этого (если <math>i \le n</math>) происходит переход к шагу 1 с бо́льшим <math>i</math>.

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размером <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в последовательном (наиболее быстром) варианте требуется:

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

Умножения и сложения составляют ''основную часть алгоритма''.

При классификации по последовательной сложности, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам <math>O(l)</math>.

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

Опишем [[глоссарий#Граф алгоритма|граф алгоритма]]<ref>Воеводин В.В. Математические основы параллельных вычислений// М.: Изд. Моск. ун-та, 1991. 345 с.</ref><ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. – СПб.: БХВ - Петербург, 2002. – 608 с.</ref><ref>Фролов А.В.. Принципы построения и описание языка Сигма. Препринт ОВМ АН N 236. М.: ОВМ АН СССР, 1989.</ref> как аналитически, так и в виде рисунка.

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

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

* <math>i</math> — меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math> - элемент ''входных данных'', а именно <math>AN[IA_{i}+j-1]</math>.
* <math>b</math> - элемент ''входных данных'', а именно <math>b[IA_{i}+j-1]</math>.

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

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция <math>a + b</math>.
Естественно введённые координаты области таковы:
* <math>i</math> - меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> - меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math>:
** при <math>j = 1</math> - результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j)</math>;
** при <math>j > 1</math> - результат срабатывания операции, соответствующей вершине из второй группы, с координатами <math>(i, j - 1)</math>;
* <math>b</math> — результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j + 1)</math>.

Результат срабатывания операции:
* при <math>j < k - 1</math> является ''промежуточным данным'' алгоритма;
* при <math>j = k - 1</math> является ''выходным данным'' <math>c_{i}</math>.

Описанный граф можно посмотреть на рис.1. Здесь вершины первой группы обозначены красным цветом и отмечены знаком умножения, вершины второй - зелёным цветом и знаком сложения. Вершины, соответствующие входным данным обозначены белым цветом и выходным - синим.
[[file:Bliznalg.png|thumb|center|1000px|Рисунок 1. Граф алгоритма умножения разреженной матрицы на вектор]]

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размерности <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в параллельном варианте требуется последовательно выполнить следующие ярусы:

* Не более чем <math>m</math> сложений и умножений (<math>n</math> вычислений в каждом из ярусов)

При классификации по высоте ЯПФ, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам со сложностью <math>O(m)</math>. При классификации по ширине ЯПФ его сложность будет <math>O(n)</math>.

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

'''Входные данные''': разреженная матрица общего вида <math>A</math> размерности <math>n \times m</math>, хранимая в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>. Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> размерности <math>m \times 1</math>.

'''Объём входных данных''': <math>2l+m+n+1</math>, где <math>l</math> - количество ненулевых элементов в матрице <math>A</math>.

'''Выходные данные''': заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

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

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

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

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

Пусть <math>l</math> - количество ненулевых элементов матрицы <math>A</math> размерности <math>n \times m</math>. Пусть <math>x</math> - объем памяти, используемый для хранения значения элемента матрицы, <math>y</math> - объём памяти, используемый для хранения номера столбца или строки. В таком случае для хранения матрицы в стандартном представлении нам потребуется объем памяти, равный <math>x \cdot n \cdot m</math>, для хранения в формате '''RR(C)''' - <math>y(n + 1) + (x + y)l</math>. Таким образом хранение в формате '''RR(C)''' не является эффективным для матриц, в которых <math>l > \frac{xnm - y(n+1)}{x+y}</math>.

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

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

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

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

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

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

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

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

Существующие реализации:

SciPy [https://docs.scipy.org/doc/scipy-0.18.1/reference/index.html],

MatLab [https://www.mathworks.com/help/matlab/math/sparse-matrix-operations.html],

Intel MKL [https://software.intel.com/en-us/articles/intel-math-kernel-library-inspector-executor-sparse-blas-routines].

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

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

2016-11-01T20:59:22Z

Blizn: /* Макроструктура алгоритма */

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>O(l)</math>
| pf_height = <math>O(m)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>2l+m+n+1</math>
| output_data = <math>n</math>
}}
Выполнила: [[Участник:Blizn|И.В. Близнякова]] (611 группа).

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

== Общее описание алгоритма<ref>С.Писсанецки. Технология разреженных матриц. - М.: Мир, 1988.</ref> ==
'''Разрежённая матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается '''''плотной'''''.

Среди специалистов нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:
* есть <math>O(n)</math>. Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;
* в каждой строке не превышает 10 в типичном случае;
* ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.
* таково, что для данного алгоритма и вычислительной системы имеет смысл извлекать выгоду из наличия в ней нулей.

=== Хранение разреженной матрицы ===
==== Формат RR(C)O ====
Рассмотрим сначала формат '''RR(C)O'''. Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Ordered"'' (строчное представление, полное и упорядоченное). В данном формате вместо одного двумерного массива, используются три одномерных. Значения ненулевых элементов матрицы и соответствующие им столбцовые индексы хранятся в этом формате по строкам в двух массивах <math>AN</math> и <math>JA</math>. Массив указателей <math>IA</math>, используется для ссылки на компоненты массивов <math>AN</math> и <math>JA</math>, с которых начинается описание очередной строки. Последняя компонента массива <math>IA</math> содержит указатель первой свободной компоненты в массивах <math>AN</math> и <math>JA</math>, т.е. равна числу ненулевых элементов матрицы, увеличенному на единицу. Здесь уместно привести пример.

Рассмотрим матрицу <math>A</math>:
:<math>\begin{pmatrix}
0 & 0 & 0 & 2 & 0 \\
1 & 0 & 3 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 \\
0 & 6 & 0 & 0 & 0 \\
0 & 0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
тогда ее представление в формате '''RR(C)O''' будет иметь вид:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 1 3 2 3 ]
AN = [ 2 1 3 6 4 ]
Т.е. массив <math>AN</math> содержит все не нулевые элементы исходной матрицы <math>A</math>, массив <math>JA</math> номер столбца в котором находится соответствующий элемент из <math>AN</math> и наконец массив <math>IA</math> содержит номер с которого начинается описание элементов в массивах <math>JA</math> и <math>AN</math>. Таким образом информация об элементах 2-ой строки матрицы хранится в элементах с <math>IA[2] = 2</math> по <math>IA[3] - 1 = 3</math> включительно массивов <math>JA</math> и <math>AN</math>. Можно обратить внимание, что <math>IA[3] = IA[4] = 4</math>, а это означает, что 3-я строка матрицы <math>A</math> нулевая.

В общем случае описание <math>r</math>-й строки матрицы A хранится в компонентах с <math>IA[r]</math> до <math>IA[r + 1] - 1</math> включительно массивов <math>AN</math> и <math>JA</math>. Если <math>IA[r + 1] = IA[r]</math>, то это означает, что <math>r</math>-я строка нулевая. Количество элементов в массиве <math>IA</math> на единицу больше, чем число строк исходной матрицы, а количество элементов в массивах <math>JA</math> и <math>AN</math> равно числу ненулевых элементов исходной матрицы.

Данный способ представления называют ''полным'', поскольку представлена вся матрица <math>A</math>, ''упорядоченным'', поскольку элементы каждой строки матрицы <math>A</math> хранятся в соответствии с возрастанием столбцовых индексов, и строчным, поскольку информация о матрице <math>A</math> указывается по строкам.

Массивы <math>IA</math> и <math>JA</math> представляют портрет (структуру) матрицы <math>A</math>, задаваемый как множество списков смежности ассоциированного с <math>A</math> графа. Если алгоритм, реализующий какую-либо операцию над разреженными матрицами, разбит на этапы символической обработки, на котором определяется портрет результирующей матрицы, и численной обработки, на котором определяются значения элементов результирующей матрицы, то массивы <math>IA</math> и <math>JA</math> заполняются на первом этапе, а массив <math>AN</math> - на втором.

==== Формат RR(C)U ====

Рассмотрим теперь формат '''RR(C)U'''.

Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Unordered"'' (строчное представление, полное, но неупорядоченное). Формат '''RR(C)U''' отличается от '''RR(C)O''' тем, что в данном случае соблюдается упорядоченность строк, но внутри каждой строки элементы исходных матриц могут храниться в произвольном порядке. Для матрицы <math>A</math> нашего примера вполне можно было бы использовать и строчное представление, полное, но неупорядоченное такое:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 3 1 2 3 ]
AN = [ 2 1 3 6 4 ]
Такие неупорядоченные представления могут быть очень удобны в практических вычислениях. Результаты большинства матричных операций получаются неупорядоченными, а их упорядочение стоило бы значительных затрат машинного времени. В то же время, за немногими исключениями, алгоритмы для разреженных матриц не требуют, чтобы их представления были упорядоченными.

==== Замечания ====

Несколько замечаний по поводу рассмотренных форматов представления:
# Очевидно, что представление матрицы в формате '''RR(C)O''' так же является и представлением в формате '''RR(C)U''', но не наоборот.
# Из представления матрицы в формате '''RR(C)''' нельзя получить информацию о точном количестве столбцов исходной матрицы.
# Целесообразно (в вопросе экономии памяти) использовать представления '''RR(C)''' в случае, если матрица содержит значительное число нулевых элементов.

=== Умножение разреженной матрицы на вектор ===

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

Мы рассмотрим умножение разреженной матрицы общего вида, хранимой в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math> на заполненный вектор-столбец.

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

Исходные данные: разреженная матрица общего вида <math>A</math> с элементами <math>a_{ij}</math> (<math>i = 1,...,n</math> и <math>j = 1,...,m</math>). Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> (<math>j =1,...,m</math>).

Вычисляемые данные: заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

Формулы метода:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

где <math>l_{i}</math> - количество ненулевых элементов строки <math>i</math> матрицы <math>A</math>, <math>j(k)</math> - индекс <math>k</math>-го ненулевого элемента матрицы <math>A</math>.

== Вычислительное ядро алгоритма ==
Вычислительное ядро последовательной версии умножения разреженной матрицы на вектор можно составить из множественных (всего их <math>n</math>) вычислений скалярных произведений строк матрицы:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>.

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

Как записано и в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют множественные (всего <math>n</math>) вычисления сумм:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} x_{i,j=j(k)}</math>,

где <math>x_{i,j=j(k)} = a_{i,j=j(k)}b_{j=j(k)}</math>.

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

Далее предполагаем, что разреженная матрица общего вида <math>A</math> хранится в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>.
Последовательность исполнения метода следующая:

Выполнять для <math>i</math> от <math>1</math> до <math>n</math>
# <math>c_{i} = 0</math>
# <math>IAA = IA[i]</math>
# <math>IAB = IA[i + 1] - 1</math>
# <math>c_{i} = \sum\limits_{k = IAA}^{IAB} AN[k]b_{JA[k]}</math>.
После этого (если <math>i \le n</math>) происходит переход к шагу 1 с бо́льшим <math>i</math>.

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размером <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в последовательном (наиболее быстром) варианте требуется:

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

Умножения и сложения составляют ''основную часть алгоритма''.

При классификации по последовательной сложности, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам <math>O(l)</math>.

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

Опишем [[глоссарий#Граф алгоритма|граф алгоритма]]<ref>Воеводин В.В. Математические основы параллельных вычислений// М.: Изд. Моск. ун-та, 1991. 345 с.</ref><ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. – СПб.: БХВ - Петербург, 2002. – 608 с.</ref><ref>Фролов А.В.. Принципы построения и описание языка Сигма. Препринт ОВМ АН N 236. М.: ОВМ АН СССР, 1989.</ref> как аналитически, так и в виде рисунка.

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

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

* <math>i</math> — меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math> - элемент ''входных данных'', а именно <math>AN[IA_{i}+j-1]</math>.
* <math>b</math> - элемент ''входных данных'', а именно <math>b[IA_{i}+j-1]</math>.

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

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция <math>a + b</math>.
Естественно введённые координаты области таковы:
* <math>i</math> - меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> - меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math>:
** при <math>j = 1</math> - результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j)</math>;
** при <math>j > 1</math> - результат срабатывания операции, соответствующей вершине из второй группы, с координатами <math>(i, j - 1)</math>;
* <math>b</math> — результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j + 1)</math>.

Результат срабатывания операции:
* при <math>j < k - 1</math> является ''промежуточным данным'' алгоритма;
* при <math>j = k - 1</math> является ''выходным данным'' <math>c_{i}</math>.

Описанный граф можно посмотреть на рис.1. Здесь вершины первой группы обозначены красным цветом и отмечены знаком умножения, вершины второй - зелёным цветом и знаком сложения. Вершины, соответствующие входным данным обозначены белым цветом и выходным - синим.
[[file:Bliznalg.png|thumb|center|1000px|Рисунок 1. Граф алгоритма умножения разреженной матрицы на вектор]]

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размерности <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в параллельном варианте требуется последовательно выполнить следующие ярусы:

* Не более чем <math>m</math> сложений и умножений (<math>n</math> вычислений в каждом из ярусов)

При классификации по высоте ЯПФ, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам со сложностью <math>O(m)</math>. При классификации по ширине ЯПФ его сложность будет <math>O(n)</math>.

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

'''Входные данные''': разреженная матрица общего вида <math>A</math> размерности <math>n \times m</math>, хранимая в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>. Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> размерности <math>m \times 1</math>.

'''Объём входных данных''': <math>2l+m+n+1</math>, где <math>l</math> - количество ненулевых элементов в матрице <math>A</math>.

'''Выходные данные''': заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

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

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

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

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

Пусть <math>l</math> - количество ненулевых элементов матрицы <math>A</math> размерности <math>n \times m</math>. Пусть <math>x</math> - объем памяти, используемый для хранения значения элемента матрицы, <math>y</math> - объём памяти, используемый для хранения номера столбца или строки. В таком случае для хранения матрицы в стандартном представлении нам потребуется объем памяти, равный <math>x \cdot n \cdot m</math>, для хранения в формате '''RR(C)''' - <math>y(n + 1) + (x + y)l</math>. Таким образом хранение в формате '''RR(C)''' не является эффективным для матриц, в которых <math>l > \frac{xnm - y(n+1)}{x+y}</math>.

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

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

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

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

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

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

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

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

Существующие реализации:

SciPy [https://docs.scipy.org/doc/scipy-0.18.1/reference/index.html],

MatLab [https://www.mathworks.com/help/matlab/math/sparse-matrix-operations.html],

Intel MKL [https://software.intel.com/en-us/articles/intel-math-kernel-library-inspector-executor-sparse-blas-routines].

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

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

2016-11-01T20:59:03Z

Blizn: /* Макроструктура алгоритма */

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>O(l)</math>
| pf_height = <math>O(m)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>2l+m+n+1</math>
| output_data = <math>n</math>
}}
Выполнила: [[Участник:Blizn|И.В. Близнякова]] (611 группа).

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

== Общее описание алгоритма<ref>С.Писсанецки. Технология разреженных матриц. - М.: Мир, 1988.</ref> ==
'''Разрежённая матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается '''''плотной'''''.

Среди специалистов нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:
* есть <math>O(n)</math>. Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;
* в каждой строке не превышает 10 в типичном случае;
* ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.
* таково, что для данного алгоритма и вычислительной системы имеет смысл извлекать выгоду из наличия в ней нулей.

=== Хранение разреженной матрицы ===
==== Формат RR(C)O ====
Рассмотрим сначала формат '''RR(C)O'''. Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Ordered"'' (строчное представление, полное и упорядоченное). В данном формате вместо одного двумерного массива, используются три одномерных. Значения ненулевых элементов матрицы и соответствующие им столбцовые индексы хранятся в этом формате по строкам в двух массивах <math>AN</math> и <math>JA</math>. Массив указателей <math>IA</math>, используется для ссылки на компоненты массивов <math>AN</math> и <math>JA</math>, с которых начинается описание очередной строки. Последняя компонента массива <math>IA</math> содержит указатель первой свободной компоненты в массивах <math>AN</math> и <math>JA</math>, т.е. равна числу ненулевых элементов матрицы, увеличенному на единицу. Здесь уместно привести пример.

Рассмотрим матрицу <math>A</math>:
:<math>\begin{pmatrix}
0 & 0 & 0 & 2 & 0 \\
1 & 0 & 3 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 \\
0 & 6 & 0 & 0 & 0 \\
0 & 0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
тогда ее представление в формате '''RR(C)O''' будет иметь вид:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 1 3 2 3 ]
AN = [ 2 1 3 6 4 ]
Т.е. массив <math>AN</math> содержит все не нулевые элементы исходной матрицы <math>A</math>, массив <math>JA</math> номер столбца в котором находится соответствующий элемент из <math>AN</math> и наконец массив <math>IA</math> содержит номер с которого начинается описание элементов в массивах <math>JA</math> и <math>AN</math>. Таким образом информация об элементах 2-ой строки матрицы хранится в элементах с <math>IA[2] = 2</math> по <math>IA[3] - 1 = 3</math> включительно массивов <math>JA</math> и <math>AN</math>. Можно обратить внимание, что <math>IA[3] = IA[4] = 4</math>, а это означает, что 3-я строка матрицы <math>A</math> нулевая.

В общем случае описание <math>r</math>-й строки матрицы A хранится в компонентах с <math>IA[r]</math> до <math>IA[r + 1] - 1</math> включительно массивов <math>AN</math> и <math>JA</math>. Если <math>IA[r + 1] = IA[r]</math>, то это означает, что <math>r</math>-я строка нулевая. Количество элементов в массиве <math>IA</math> на единицу больше, чем число строк исходной матрицы, а количество элементов в массивах <math>JA</math> и <math>AN</math> равно числу ненулевых элементов исходной матрицы.

Данный способ представления называют ''полным'', поскольку представлена вся матрица <math>A</math>, ''упорядоченным'', поскольку элементы каждой строки матрицы <math>A</math> хранятся в соответствии с возрастанием столбцовых индексов, и строчным, поскольку информация о матрице <math>A</math> указывается по строкам.

Массивы <math>IA</math> и <math>JA</math> представляют портрет (структуру) матрицы <math>A</math>, задаваемый как множество списков смежности ассоциированного с <math>A</math> графа. Если алгоритм, реализующий какую-либо операцию над разреженными матрицами, разбит на этапы символической обработки, на котором определяется портрет результирующей матрицы, и численной обработки, на котором определяются значения элементов результирующей матрицы, то массивы <math>IA</math> и <math>JA</math> заполняются на первом этапе, а массив <math>AN</math> - на втором.

==== Формат RR(C)U ====

Рассмотрим теперь формат '''RR(C)U'''.

Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Unordered"'' (строчное представление, полное, но неупорядоченное). Формат '''RR(C)U''' отличается от '''RR(C)O''' тем, что в данном случае соблюдается упорядоченность строк, но внутри каждой строки элементы исходных матриц могут храниться в произвольном порядке. Для матрицы <math>A</math> нашего примера вполне можно было бы использовать и строчное представление, полное, но неупорядоченное такое:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 3 1 2 3 ]
AN = [ 2 1 3 6 4 ]
Такие неупорядоченные представления могут быть очень удобны в практических вычислениях. Результаты большинства матричных операций получаются неупорядоченными, а их упорядочение стоило бы значительных затрат машинного времени. В то же время, за немногими исключениями, алгоритмы для разреженных матриц не требуют, чтобы их представления были упорядоченными.

==== Замечания ====

Несколько замечаний по поводу рассмотренных форматов представления:
# Очевидно, что представление матрицы в формате '''RR(C)O''' так же является и представлением в формате '''RR(C)U''', но не наоборот.
# Из представления матрицы в формате '''RR(C)''' нельзя получить информацию о точном количестве столбцов исходной матрицы.
# Целесообразно (в вопросе экономии памяти) использовать представления '''RR(C)''' в случае, если матрица содержит значительное число нулевых элементов.

=== Умножение разреженной матрицы на вектор ===

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

Мы рассмотрим умножение разреженной матрицы общего вида, хранимой в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math> на заполненный вектор-столбец.

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

Исходные данные: разреженная матрица общего вида <math>A</math> с элементами <math>a_{ij}</math> (<math>i = 1,...,n</math> и <math>j = 1,...,m</math>). Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> (<math>j =1,...,m</math>).

Вычисляемые данные: заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

Формулы метода:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

где <math>l_{i}</math> - количество ненулевых элементов строки <math>i</math> матрицы <math>A</math>, <math>j(k)</math> - индекс <math>k</math>-го ненулевого элемента матрицы <math>A</math>.

== Вычислительное ядро алгоритма ==
Вычислительное ядро последовательной версии умножения разреженной матрицы на вектор можно составить из множественных (всего их <math>n</math>) вычислений скалярных произведений строк матрицы:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>.

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

Как записано и в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют множественные (всего <math>n</math>) вычисления сумм:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} x_{i,j=j(k)}</math>,

где <math>x_{i,j=j(k)} = a_{i,j=j(k)}b_{j=j(k)}</math>

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

Далее предполагаем, что разреженная матрица общего вида <math>A</math> хранится в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>.
Последовательность исполнения метода следующая:

Выполнять для <math>i</math> от <math>1</math> до <math>n</math>
# <math>c_{i} = 0</math>
# <math>IAA = IA[i]</math>
# <math>IAB = IA[i + 1] - 1</math>
# <math>c_{i} = \sum\limits_{k = IAA}^{IAB} AN[k]b_{JA[k]}</math>.
После этого (если <math>i \le n</math>) происходит переход к шагу 1 с бо́льшим <math>i</math>.

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размером <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в последовательном (наиболее быстром) варианте требуется:

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

Умножения и сложения составляют ''основную часть алгоритма''.

При классификации по последовательной сложности, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам <math>O(l)</math>.

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

Опишем [[глоссарий#Граф алгоритма|граф алгоритма]]<ref>Воеводин В.В. Математические основы параллельных вычислений// М.: Изд. Моск. ун-та, 1991. 345 с.</ref><ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. – СПб.: БХВ - Петербург, 2002. – 608 с.</ref><ref>Фролов А.В.. Принципы построения и описание языка Сигма. Препринт ОВМ АН N 236. М.: ОВМ АН СССР, 1989.</ref> как аналитически, так и в виде рисунка.

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

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

* <math>i</math> — меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math> - элемент ''входных данных'', а именно <math>AN[IA_{i}+j-1]</math>.
* <math>b</math> - элемент ''входных данных'', а именно <math>b[IA_{i}+j-1]</math>.

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

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция <math>a + b</math>.
Естественно введённые координаты области таковы:
* <math>i</math> - меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> - меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math>:
** при <math>j = 1</math> - результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j)</math>;
** при <math>j > 1</math> - результат срабатывания операции, соответствующей вершине из второй группы, с координатами <math>(i, j - 1)</math>;
* <math>b</math> — результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j + 1)</math>.

Результат срабатывания операции:
* при <math>j < k - 1</math> является ''промежуточным данным'' алгоритма;
* при <math>j = k - 1</math> является ''выходным данным'' <math>c_{i}</math>.

Описанный граф можно посмотреть на рис.1. Здесь вершины первой группы обозначены красным цветом и отмечены знаком умножения, вершины второй - зелёным цветом и знаком сложения. Вершины, соответствующие входным данным обозначены белым цветом и выходным - синим.
[[file:Bliznalg.png|thumb|center|1000px|Рисунок 1. Граф алгоритма умножения разреженной матрицы на вектор]]

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размерности <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в параллельном варианте требуется последовательно выполнить следующие ярусы:

* Не более чем <math>m</math> сложений и умножений (<math>n</math> вычислений в каждом из ярусов)

При классификации по высоте ЯПФ, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам со сложностью <math>O(m)</math>. При классификации по ширине ЯПФ его сложность будет <math>O(n)</math>.

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

'''Входные данные''': разреженная матрица общего вида <math>A</math> размерности <math>n \times m</math>, хранимая в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>. Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> размерности <math>m \times 1</math>.

'''Объём входных данных''': <math>2l+m+n+1</math>, где <math>l</math> - количество ненулевых элементов в матрице <math>A</math>.

'''Выходные данные''': заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

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

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

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

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

Пусть <math>l</math> - количество ненулевых элементов матрицы <math>A</math> размерности <math>n \times m</math>. Пусть <math>x</math> - объем памяти, используемый для хранения значения элемента матрицы, <math>y</math> - объём памяти, используемый для хранения номера столбца или строки. В таком случае для хранения матрицы в стандартном представлении нам потребуется объем памяти, равный <math>x \cdot n \cdot m</math>, для хранения в формате '''RR(C)''' - <math>y(n + 1) + (x + y)l</math>. Таким образом хранение в формате '''RR(C)''' не является эффективным для матриц, в которых <math>l > \frac{xnm - y(n+1)}{x+y}</math>.

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

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

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

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

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

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

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

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

Существующие реализации:

SciPy [https://docs.scipy.org/doc/scipy-0.18.1/reference/index.html],

MatLab [https://www.mathworks.com/help/matlab/math/sparse-matrix-operations.html],

Intel MKL [https://software.intel.com/en-us/articles/intel-math-kernel-library-inspector-executor-sparse-blas-routines].

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

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

2016-11-01T20:51:30Z

Blizn:

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>O(l)</math>
| pf_height = <math>O(m)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>2l+m+n+1</math>
| output_data = <math>n</math>
}}
Выполнила: [[Участник:Blizn|И.В. Близнякова]] (611 группа).

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

== Общее описание алгоритма<ref>С.Писсанецки. Технология разреженных матриц. - М.: Мир, 1988.</ref> ==
'''Разрежённая матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается '''''плотной'''''.

Среди специалистов нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:
* есть <math>O(n)</math>. Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;
* в каждой строке не превышает 10 в типичном случае;
* ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.
* таково, что для данного алгоритма и вычислительной системы имеет смысл извлекать выгоду из наличия в ней нулей.

=== Хранение разреженной матрицы ===
==== Формат RR(C)O ====
Рассмотрим сначала формат '''RR(C)O'''. Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Ordered"'' (строчное представление, полное и упорядоченное). В данном формате вместо одного двумерного массива, используются три одномерных. Значения ненулевых элементов матрицы и соответствующие им столбцовые индексы хранятся в этом формате по строкам в двух массивах <math>AN</math> и <math>JA</math>. Массив указателей <math>IA</math>, используется для ссылки на компоненты массивов <math>AN</math> и <math>JA</math>, с которых начинается описание очередной строки. Последняя компонента массива <math>IA</math> содержит указатель первой свободной компоненты в массивах <math>AN</math> и <math>JA</math>, т.е. равна числу ненулевых элементов матрицы, увеличенному на единицу. Здесь уместно привести пример.

Рассмотрим матрицу <math>A</math>:
:<math>\begin{pmatrix}
0 & 0 & 0 & 2 & 0 \\
1 & 0 & 3 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 \\
0 & 6 & 0 & 0 & 0 \\
0 & 0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
тогда ее представление в формате '''RR(C)O''' будет иметь вид:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 1 3 2 3 ]
AN = [ 2 1 3 6 4 ]
Т.е. массив <math>AN</math> содержит все не нулевые элементы исходной матрицы <math>A</math>, массив <math>JA</math> номер столбца в котором находится соответствующий элемент из <math>AN</math> и наконец массив <math>IA</math> содержит номер с которого начинается описание элементов в массивах <math>JA</math> и <math>AN</math>. Таким образом информация об элементах 2-ой строки матрицы хранится в элементах с <math>IA[2] = 2</math> по <math>IA[3] - 1 = 3</math> включительно массивов <math>JA</math> и <math>AN</math>. Можно обратить внимание, что <math>IA[3] = IA[4] = 4</math>, а это означает, что 3-я строка матрицы <math>A</math> нулевая.

В общем случае описание <math>r</math>-й строки матрицы A хранится в компонентах с <math>IA[r]</math> до <math>IA[r + 1] - 1</math> включительно массивов <math>AN</math> и <math>JA</math>. Если <math>IA[r + 1] = IA[r]</math>, то это означает, что <math>r</math>-я строка нулевая. Количество элементов в массиве <math>IA</math> на единицу больше, чем число строк исходной матрицы, а количество элементов в массивах <math>JA</math> и <math>AN</math> равно числу ненулевых элементов исходной матрицы.

Данный способ представления называют ''полным'', поскольку представлена вся матрица <math>A</math>, ''упорядоченным'', поскольку элементы каждой строки матрицы <math>A</math> хранятся в соответствии с возрастанием столбцовых индексов, и строчным, поскольку информация о матрице <math>A</math> указывается по строкам.

Массивы <math>IA</math> и <math>JA</math> представляют портрет (структуру) матрицы <math>A</math>, задаваемый как множество списков смежности ассоциированного с <math>A</math> графа. Если алгоритм, реализующий какую-либо операцию над разреженными матрицами, разбит на этапы символической обработки, на котором определяется портрет результирующей матрицы, и численной обработки, на котором определяются значения элементов результирующей матрицы, то массивы <math>IA</math> и <math>JA</math> заполняются на первом этапе, а массив <math>AN</math> - на втором.

==== Формат RR(C)U ====

Рассмотрим теперь формат '''RR(C)U'''.

Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Unordered"'' (строчное представление, полное, но неупорядоченное). Формат '''RR(C)U''' отличается от '''RR(C)O''' тем, что в данном случае соблюдается упорядоченность строк, но внутри каждой строки элементы исходных матриц могут храниться в произвольном порядке. Для матрицы <math>A</math> нашего примера вполне можно было бы использовать и строчное представление, полное, но неупорядоченное такое:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 3 1 2 3 ]
AN = [ 2 1 3 6 4 ]
Такие неупорядоченные представления могут быть очень удобны в практических вычислениях. Результаты большинства матричных операций получаются неупорядоченными, а их упорядочение стоило бы значительных затрат машинного времени. В то же время, за немногими исключениями, алгоритмы для разреженных матриц не требуют, чтобы их представления были упорядоченными.

==== Замечания ====

Несколько замечаний по поводу рассмотренных форматов представления:
# Очевидно, что представление матрицы в формате '''RR(C)O''' так же является и представлением в формате '''RR(C)U''', но не наоборот.
# Из представления матрицы в формате '''RR(C)''' нельзя получить информацию о точном количестве столбцов исходной матрицы.
# Целесообразно (в вопросе экономии памяти) использовать представления '''RR(C)''' в случае, если матрица содержит значительное число нулевых элементов.

=== Умножение разреженной матрицы на вектор ===

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

Мы рассмотрим умножение разреженной матрицы общего вида, хранимой в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math> на заполненный вектор-столбец.

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

Исходные данные: разреженная матрица общего вида <math>A</math> с элементами <math>a_{ij}</math> (<math>i = 1,...,n</math> и <math>j = 1,...,m</math>). Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> (<math>j =1,...,m</math>).

Вычисляемые данные: заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

Формулы метода:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

где <math>l_{i}</math> - количество ненулевых элементов строки <math>i</math> матрицы <math>A</math>, <math>j(k)</math> - индекс <math>k</math>-го ненулевого элемента матрицы <math>A</math>.

== Вычислительное ядро алгоритма ==
Вычислительное ядро последовательной версии умножения разреженной матрицы на вектор можно составить из множественных (всего их <math>n</math>) вычислений скалярных произведений строк матрицы:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>.

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

Как записано и в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют множественные (всего <math>n</math>) вычисления сумм:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>.

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

Далее предполагаем, что разреженная матрица общего вида <math>A</math> хранится в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>.
Последовательность исполнения метода следующая:

Выполнять для <math>i</math> от <math>1</math> до <math>n</math>
# <math>c_{i} = 0</math>
# <math>IAA = IA[i]</math>
# <math>IAB = IA[i + 1] - 1</math>
# <math>c_{i} = \sum\limits_{k = IAA}^{IAB} AN[k]b_{JA[k]}</math>.
После этого (если <math>i \le n</math>) происходит переход к шагу 1 с бо́льшим <math>i</math>.

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размером <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в последовательном (наиболее быстром) варианте требуется:

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

Умножения и сложения составляют ''основную часть алгоритма''.

При классификации по последовательной сложности, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам <math>O(l)</math>.

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

Опишем [[глоссарий#Граф алгоритма|граф алгоритма]]<ref>Воеводин В.В. Математические основы параллельных вычислений// М.: Изд. Моск. ун-та, 1991. 345 с.</ref><ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. – СПб.: БХВ - Петербург, 2002. – 608 с.</ref><ref>Фролов А.В.. Принципы построения и описание языка Сигма. Препринт ОВМ АН N 236. М.: ОВМ АН СССР, 1989.</ref> как аналитически, так и в виде рисунка.

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

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

* <math>i</math> — меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math> - элемент ''входных данных'', а именно <math>AN[IA_{i}+j-1]</math>.
* <math>b</math> - элемент ''входных данных'', а именно <math>b[IA_{i}+j-1]</math>.

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

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция <math>a + b</math>.
Естественно введённые координаты области таковы:
* <math>i</math> - меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> - меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math>:
** при <math>j = 1</math> - результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j)</math>;
** при <math>j > 1</math> - результат срабатывания операции, соответствующей вершине из второй группы, с координатами <math>(i, j - 1)</math>;
* <math>b</math> — результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j + 1)</math>.

Результат срабатывания операции:
* при <math>j < k - 1</math> является ''промежуточным данным'' алгоритма;
* при <math>j = k - 1</math> является ''выходным данным'' <math>c_{i}</math>.

Описанный граф можно посмотреть на рис.1. Здесь вершины первой группы обозначены красным цветом и отмечены знаком умножения, вершины второй - зелёным цветом и знаком сложения. Вершины, соответствующие входным данным обозначены белым цветом и выходным - синим.
[[file:Bliznalg.png|thumb|center|1000px|Рисунок 1. Граф алгоритма умножения разреженной матрицы на вектор]]

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размерности <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в параллельном варианте требуется последовательно выполнить следующие ярусы:

* Не более чем <math>m</math> сложений и умножений (<math>n</math> вычислений в каждом из ярусов)

При классификации по высоте ЯПФ, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам со сложностью <math>O(m)</math>. При классификации по ширине ЯПФ его сложность будет <math>O(n)</math>.

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

'''Входные данные''': разреженная матрица общего вида <math>A</math> размерности <math>n \times m</math>, хранимая в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>. Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> размерности <math>m \times 1</math>.

'''Объём входных данных''': <math>2l+m+n+1</math>, где <math>l</math> - количество ненулевых элементов в матрице <math>A</math>.

'''Выходные данные''': заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

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

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

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

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

Пусть <math>l</math> - количество ненулевых элементов матрицы <math>A</math> размерности <math>n \times m</math>. Пусть <math>x</math> - объем памяти, используемый для хранения значения элемента матрицы, <math>y</math> - объём памяти, используемый для хранения номера столбца или строки. В таком случае для хранения матрицы в стандартном представлении нам потребуется объем памяти, равный <math>x \cdot n \cdot m</math>, для хранения в формате '''RR(C)''' - <math>y(n + 1) + (x + y)l</math>. Таким образом хранение в формате '''RR(C)''' не является эффективным для матриц, в которых <math>l > \frac{xnm - y(n+1)}{x+y}</math>.

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

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

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

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

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

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

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

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

Существующие реализации:

SciPy [https://docs.scipy.org/doc/scipy-0.18.1/reference/index.html],

MatLab [https://www.mathworks.com/help/matlab/math/sparse-matrix-operations.html],

Intel MKL [https://software.intel.com/en-us/articles/intel-math-kernel-library-inspector-executor-sparse-blas-routines].

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

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

2016-10-23T20:51:34Z

Blizn:

{{Assignment}}
{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>O(l)</math>
| pf_height = <math>O(m)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>2l+m+n+1</math>
| output_data = <math>n</math>
}}
Выполнила: [[Участник:Blizn|И.В. Близнякова]] (611 группа).

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

== Общее описание алгоритма<ref>С.Писсанецки. Технология разреженных матриц. - М.: Мир, 1988.</ref> ==
'''Разрежённая матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается '''''плотной'''''.

Среди специалистов нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:
* есть <math>O(n)</math>. Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;
* в каждой строке не превышает 10 в типичном случае;
* ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.
* таково, что для данного алгоритма и вычислительной системы имеет смысл извлекать выгоду из наличия в ней нулей.

=== Хранение разреженной матрицы ===
==== Формат RR(C)O ====
Рассмотрим сначала формат '''RR(C)O'''. Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Ordered"'' (строчное представление, полное и упорядоченное). В данном формате вместо одного двумерного массива, используются три одномерных. Значения ненулевых элементов матрицы и соответствующие им столбцовые индексы хранятся в этом формате по строкам в двух массивах <math>AN</math> и <math>JA</math>. Массив указателей <math>IA</math>, используется для ссылки на компоненты массивов <math>AN</math> и <math>JA</math>, с которых начинается описание очередной строки. Последняя компонента массива <math>IA</math> содержит указатель первой свободной компоненты в массивах <math>AN</math> и <math>JA</math>, т.е. равна числу ненулевых элементов матрицы, увеличенному на единицу. Здесь уместно привести пример.

Рассмотрим матрицу <math>A</math>:
:<math>\begin{pmatrix}
0 & 0 & 0 & 2 & 0 \\
1 & 0 & 3 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 \\
0 & 6 & 0 & 0 & 0 \\
0 & 0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
тогда ее представление в формате '''RR(C)O''' будет иметь вид:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 1 3 2 3 ]
AN = [ 2 1 3 6 4 ]
Т.е. массив <math>AN</math> содержит все не нулевые элементы исходной матрицы <math>A</math>, массив <math>JA</math> номер столбца в котором находится соответствующий элемент из <math>AN</math> и наконец массив <math>IA</math> содержит номер с которого начинается описание элементов в массивах <math>JA</math> и <math>AN</math>. Таким образом информация об элементах 2-ой строки матрицы хранится в элементах с <math>IA[2] = 2</math> по <math>IA[3] - 1 = 3</math> включительно массивов <math>JA</math> и <math>AN</math>. Можно обратить внимание, что <math>IA[3] = IA[4] = 4</math>, а это означает, что 3-я строка матрицы <math>A</math> нулевая.

В общем случае описание <math>r</math>-й строки матрицы A хранится в компонентах с <math>IA[r]</math> до <math>IA[r + 1] - 1</math> включительно массивов <math>AN</math> и <math>JA</math>. Если <math>IA[r + 1] = IA[r]</math>, то это означает, что <math>r</math>-я строка нулевая. Количество элементов в массиве <math>IA</math> на единицу больше, чем число строк исходной матрицы, а количество элементов в массивах <math>JA</math> и <math>AN</math> равно числу ненулевых элементов исходной матрицы.

Данный способ представления называют ''полным'', поскольку представлена вся матрица <math>A</math>, ''упорядоченным'', поскольку элементы каждой строки матрицы <math>A</math> хранятся в соответствии с возрастанием столбцовых индексов, и строчным, поскольку информация о матрице <math>A</math> указывается по строкам.

Массивы <math>IA</math> и <math>JA</math> представляют портрет (структуру) матрицы <math>A</math>, задаваемый как множество списков смежности ассоциированного с <math>A</math> графа. Если алгоритм, реализующий какую-либо операцию над разреженными матрицами, разбит на этапы символической обработки, на котором определяется портрет результирующей матрицы, и численной обработки, на котором определяются значения элементов результирующей матрицы, то массивы <math>IA</math> и <math>JA</math> заполняются на первом этапе, а массив <math>AN</math> - на втором.

==== Формат RR(C)U ====

Рассмотрим теперь формат '''RR(C)U'''.

Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Unordered"'' (строчное представление, полное, но неупорядоченное). Формат '''RR(C)U''' отличается от '''RR(C)O''' тем, что в данном случае соблюдается упорядоченность строк, но внутри каждой строки элементы исходных матриц могут храниться в произвольном порядке. Для матрицы <math>A</math> нашего примера вполне можно было бы использовать и строчное представление, полное, но неупорядоченное такое:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 3 1 2 3 ]
AN = [ 2 1 3 6 4 ]
Такие неупорядоченные представления могут быть очень удобны в практических вычислениях. Результаты большинства матричных операций получаются неупорядоченными, а их упорядочение стоило бы значительных затрат машинного времени. В то же время, за немногими исключениями, алгоритмы для разреженных матриц не требуют, чтобы их представления были упорядоченными.

==== Замечания ====

Несколько замечаний по поводу рассмотренных форматов представления:
# Очевидно, что представление матрицы в формате '''RR(C)O''' так же является и представлением в формате '''RR(C)U''', но не наоборот.
# Из представления матрицы в формате '''RR(C)''' нельзя получить информацию о точном количестве столбцов исходной матрицы.
# Целесообразно (в вопросе экономии памяти) использовать представления '''RR(C)''' в случае, если матрица содержит значительное число нулевых элементов.

=== Умножение разреженной матрицы на вектор ===

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

Мы рассмотрим умножение разреженной матрицы общего вида, хранимой в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math> на заполненный вектор-столбец.

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

Исходные данные: разреженная матрица общего вида <math>A</math> с элементами <math>a_{ij}</math> (<math>i = 1,...,n</math> и <math>j = 1,...,m</math>). Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> (<math>j =1,...,m</math>).

Вычисляемые данные: заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

Формулы метода:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

где <math>l_{i}</math> - количество ненулевых элементов строки <math>i</math> матрицы <math>A</math>, <math>j(k)</math> - индекс <math>k</math>-го ненулевого элемента матрицы <math>A</math>.

== Вычислительное ядро алгоритма ==
Вычислительное ядро последовательной версии умножения разреженной матрицы на вектор можно составить из множественных (всего их <math>n</math>) вычислений скалярных произведений строк матрицы:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>.

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

Как записано и в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют множественные (всего <math>n</math>) вычисления сумм:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>.

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

Далее предполагаем, что разреженная матрица общего вида <math>A</math> хранится в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>.
Последовательность исполнения метода следующая:

Выполнять для <math>i</math> от <math>1</math> до <math>n</math>
# <math>c_{i} = 0</math>
# <math>IAA = IA[i]</math>
# <math>IAB = IA[i + 1] - 1</math>
# <math>c_{i} = \sum\limits_{k = IAA}^{IAB} AN[k]b_{JA[k]}</math>.
После этого (если <math>i \le n</math>) происходит переход к шагу 1 с бо́льшим <math>i</math>.

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размером <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в последовательном (наиболее быстром) варианте требуется:

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

Умножения и сложения составляют ''основную часть алгоритма''.

При классификации по последовательной сложности, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам <math>O(l)</math>.

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

Опишем [[глоссарий#Граф алгоритма|граф алгоритма]]<ref>Воеводин В.В. Математические основы параллельных вычислений// М.: Изд. Моск. ун-та, 1991. 345 с.</ref><ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. – СПб.: БХВ - Петербург, 2002. – 608 с.</ref><ref>Фролов А.В.. Принципы построения и описание языка Сигма. Препринт ОВМ АН N 236. М.: ОВМ АН СССР, 1989.</ref> как аналитически, так и в виде рисунка.

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

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

* <math>i</math> — меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math> - элемент ''входных данных'', а именно <math>AN[IA_{i}+j-1]</math>.
* <math>b</math> - элемент ''входных данных'', а именно <math>b[IA_{i}+j-1]</math>.

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

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция <math>a + b</math>.
Естественно введённые координаты области таковы:
* <math>i</math> - меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> - меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math>:
** при <math>j = 1</math> - результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j)</math>;
** при <math>j > 1</math> - результат срабатывания операции, соответствующей вершине из второй группы, с координатами <math>(i, j - 1)</math>;
* <math>b</math> — результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j + 1)</math>.

Результат срабатывания операции:
* при <math>j < k - 1</math> является ''промежуточным данным'' алгоритма;
* при <math>j = k - 1</math> является ''выходным данным'' <math>c_{i}</math>.

Описанный граф можно посмотреть на рис.1. Здесь вершины первой группы обозначены красным цветом и отмечены знаком умножения, вершины второй - зелёным цветом и знаком сложения. Вершины, соответствующие входным данным обозначены белым цветом и выходным - синим.
[[file:Bliznalg.png|thumb|center|1000px|Рисунок 1. Граф алгоритма умножения разреженной матрицы на вектор]]

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размерности <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в параллельном варианте требуется последовательно выполнить следующие ярусы:

* Не более чем <math>m</math> сложений и умножений (<math>n</math> вычислений в каждом из ярусов)

При классификации по высоте ЯПФ, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам со сложностью <math>O(m)</math>. При классификации по ширине ЯПФ его сложность будет <math>O(n)</math>.

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

'''Входные данные''': разреженная матрица общего вида <math>A</math> размерности <math>n \times m</math>, хранимая в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>. Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> размерности <math>m \times 1</math>.

'''Объём входных данных''': <math>2l+m+n+1</math>, где <math>l</math> - количество ненулевых элементов в матрице <math>A</math>.

'''Выходные данные''': заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

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

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

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

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

Пусть <math>l</math> - количество ненулевых элементов матрицы <math>A</math> размерности <math>n \times m</math>. Пусть <math>x</math> - объем памяти, используемый для хранения значения элемента матрицы, <math>y</math> - объём памяти, используемый для хранения номера столбца или строки. В таком случае для хранения матрицы в стандартном представлении нам потребуется объем памяти, равный <math>x \cdot n \cdot m</math>, для хранения в формате '''RR(C)''' - <math>y(n + 1) + (x + y)l</math>. Таким образом хранение в формате '''RR(C)''' не является эффективным для матриц, в которых <math>l > \frac{xnm - y(n+1)}{x+y}</math>.

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

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

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

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

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

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

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

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

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

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

2016-10-23T20:50:22Z

Blizn:

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>O(l)</math>
| pf_height = <math>O(m)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>2l+m+n+1</math>
| output_data = <math>n</math>
}}
Выполнила: [[Участник:Blizn|И.В. Близнякова]] (611 группа).

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

== Общее описание алгоритма<ref>С.Писсанецки. Технология разреженных матриц. - М.: Мир, 1988.</ref> ==
'''Разрежённая матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается '''''плотной'''''.

Среди специалистов нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:
* есть <math>O(n)</math>. Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;
* в каждой строке не превышает 10 в типичном случае;
* ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.
* таково, что для данного алгоритма и вычислительной системы имеет смысл извлекать выгоду из наличия в ней нулей.

=== Хранение разреженной матрицы ===
==== Формат RR(C)O ====
Рассмотрим сначала формат '''RR(C)O'''. Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Ordered"'' (строчное представление, полное и упорядоченное). В данном формате вместо одного двумерного массива, используются три одномерных. Значения ненулевых элементов матрицы и соответствующие им столбцовые индексы хранятся в этом формате по строкам в двух массивах <math>AN</math> и <math>JA</math>. Массив указателей <math>IA</math>, используется для ссылки на компоненты массивов <math>AN</math> и <math>JA</math>, с которых начинается описание очередной строки. Последняя компонента массива <math>IA</math> содержит указатель первой свободной компоненты в массивах <math>AN</math> и <math>JA</math>, т.е. равна числу ненулевых элементов матрицы, увеличенному на единицу. Здесь уместно привести пример.

Рассмотрим матрицу <math>A</math>:
:<math>\begin{pmatrix}
0 & 0 & 0 & 2 & 0 \\
1 & 0 & 3 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 \\
0 & 6 & 0 & 0 & 0 \\
0 & 0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
тогда ее представление в формате '''RR(C)O''' будет иметь вид:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 1 3 2 3 ]
AN = [ 2 1 3 6 4 ]
Т.е. массив <math>AN</math> содержит все не нулевые элементы исходной матрицы <math>A</math>, массив <math>JA</math> номер столбца в котором находится соответствующий элемент из <math>AN</math> и наконец массив <math>IA</math> содержит номер с которого начинается описание элементов в массивах <math>JA</math> и <math>AN</math>. Таким образом информация об элементах 2-ой строки матрицы хранится в элементах с <math>IA[2] = 2</math> по <math>IA[3] - 1 = 3</math> включительно массивов <math>JA</math> и <math>AN</math>. Можно обратить внимание, что <math>IA[3] = IA[4] = 4</math>, а это означает, что 3-я строка матрицы <math>A</math> нулевая.

В общем случае описание <math>r</math>-й строки матрицы A хранится в компонентах с <math>IA[r]</math> до <math>IA[r + 1] - 1</math> включительно массивов <math>AN</math> и <math>JA</math>. Если <math>IA[r + 1] = IA[r]</math>, то это означает, что <math>r</math>-я строка нулевая. Количество элементов в массиве <math>IA</math> на единицу больше, чем число строк исходной матрицы, а количество элементов в массивах <math>JA</math> и <math>AN</math> равно числу ненулевых элементов исходной матрицы.

Данный способ представления называют ''полным'', поскольку представлена вся матрица <math>A</math>, ''упорядоченным'', поскольку элементы каждой строки матрицы <math>A</math> хранятся в соответствии с возрастанием столбцовых индексов, и строчным, поскольку информация о матрице <math>A</math> указывается по строкам.

Массивы <math>IA</math> и <math>JA</math> представляют портрет (структуру) матрицы <math>A</math>, задаваемый как множество списков смежности ассоциированного с <math>A</math> графа. Если алгоритм, реализующий какую-либо операцию над разреженными матрицами, разбит на этапы символической обработки, на котором определяется портрет результирующей матрицы, и численной обработки, на котором определяются значения элементов результирующей матрицы, то массивы <math>IA</math> и <math>JA</math> заполняются на первом этапе, а массив <math>AN</math> - на втором.

==== Формат RR(C)U ====

Рассмотрим теперь формат '''RR(C)U'''.

Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Unordered"'' (строчное представление, полное, но неупорядоченное). Формат '''RR(C)U''' отличается от '''RR(C)O''' тем, что в данном случае соблюдается упорядоченность строк, но внутри каждой строки элементы исходных матриц могут храниться в произвольном порядке. Для матрицы <math>A</math> нашего примера вполне можно было бы использовать и строчное представление, полное, но неупорядоченное такое:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 3 1 2 3 ]
AN = [ 2 1 3 6 4 ]
Такие неупорядоченные представления могут быть очень удобны в практических вычислениях. Результаты большинства матричных операций получаются неупорядоченными, а их упорядочение стоило бы значительных затрат машинного времени. В то же время, за немногими исключениями, алгоритмы для разреженных матриц не требуют, чтобы их представления были упорядоченными.

==== Замечания ====

Несколько замечаний по поводу рассмотренных форматов представления:
# Очевидно, что представление матрицы в формате '''RR(C)O''' так же является и представлением в формате '''RR(C)U''', но не наоборот.
# Из представления матрицы в формате '''RR(C)''' нельзя получить информацию о точном количестве столбцов исходной матрицы.
# Целесообразно (в вопросе экономии памяти) использовать представления '''RR(C)''' в случае, если матрица содержит значительное число нулевых элементов.

=== Умножение разреженной матрицы на вектор ===

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

Мы рассмотрим умножение разреженной матрицы общего вида, хранимой в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math> на заполненный вектор-столбец.

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

Исходные данные: разреженная матрица общего вида <math>A</math> с элементами <math>a_{ij}</math> (<math>i = 1,...,n</math> и <math>j = 1,...,m</math>). Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> (<math>j =1,...,m</math>).

Вычисляемые данные: заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

Формулы метода:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

где <math>l_{i}</math> - количество ненулевых элементов строки <math>i</math> матрицы <math>A</math>, <math>j(k)</math> - индекс <math>k</math>-го ненулевого элемента матрицы <math>A</math>.

== Вычислительное ядро алгоритма ==
Вычислительное ядро последовательной версии умножения разреженной матрицы на вектор можно составить из множественных (всего их <math>n</math>) вычислений скалярных произведений строк матрицы:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>.

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

Как записано и в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют множественные (всего <math>n</math>) вычисления сумм:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>.

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

Далее предполагаем, что разреженная матрица общего вида <math>A</math> хранится в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>.
Последовательность исполнения метода следующая:

Выполнять для <math>i</math> от <math>1</math> до <math>n</math>
# <math>c_{i} = 0</math>
# <math>IAA = IA[i]</math>
# <math>IAB = IA[i + 1] - 1</math>
# <math>c_{i} = \sum\limits_{k = IAA}^{IAB} AN[k]b_{JA[k]}</math>.
После этого (если <math>i \le n</math>) происходит переход к шагу 1 с бо́льшим <math>i</math>.

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размером <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в последовательном (наиболее быстром) варианте требуется:

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

Умножения и сложения составляют ''основную часть алгоритма''.

При классификации по последовательной сложности, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам <math>O(l)</math>.

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

Опишем [[глоссарий#Граф алгоритма|граф алгоритма]]<ref>Воеводин В.В. Математические основы параллельных вычислений// М.: Изд. Моск. ун-та, 1991. 345 с.</ref><ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. – СПб.: БХВ - Петербург, 2002. – 608 с.</ref><ref>Фролов А.В.. Принципы построения и описание языка Сигма. Препринт ОВМ АН N 236. М.: ОВМ АН СССР, 1989.</ref> как аналитически, так и в виде рисунка.

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

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

* <math>i</math> — меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math> - элемент ''входных данных'', а именно <math>AN[IA_{i}+j-1]</math>.
* <math>b</math> - элемент ''входных данных'', а именно <math>b[IA_{i}+j-1]</math>.

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

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция <math>a + b</math>.
Естественно введённые координаты области таковы:
* <math>i</math> - меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> - меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math>:
** при <math>j = 1</math> - результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j)</math>;
** при <math>j > 1</math> - результат срабатывания операции, соответствующей вершине из второй группы, с координатами <math>(i, j - 1)</math>;
* <math>b</math> — результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j + 1)</math>.

Результат срабатывания операции:
* при <math>j < k - 1</math> является ''промежуточным данным'' алгоритма;
* при <math>j = k - 1</math> является ''выходным данным'' <math>c_{i}</math>.

Описанный граф можно посмотреть на рис.1. Здесь вершины первой группы обозначены красным цветом и отмечены знаком умножения, вершины второй - зелёным цветом и знаком сложения. Вершины, соответствующие входным данным обозначены белым цветом и выходным - синим.
[[file:Bliznalg.png|thumb|center|1000px|Рисунок 1. Граф алгоритма умножения разреженной матрицы на вектор]]

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размерности <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в параллельном варианте требуется последовательно выполнить следующие ярусы:

* Не более чем <math>m</math> сложений и умножений (<math>n</math> вычислений в каждом из ярусов)

При классификации по высоте ЯПФ, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам со сложностью <math>O(m)</math>. При классификации по ширине ЯПФ его сложность будет <math>O(n)</math>.

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

'''Входные данные''': разреженная матрица общего вида <math>A</math> размерности <math>n \times m</math>, хранимая в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>. Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> размерности <math>m \times 1</math>.

'''Объём входных данных''': <math>2l+m+n+1</math>, где <math>l</math> - количество ненулевых элементов в матрице <math>A</math>.

'''Выходные данные''': заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

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

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

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

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

Пусть <math>l</math> - количество ненулевых элементов матрицы <math>A</math> размерности <math>n \times m</math>. Пусть <math>x</math> - объем памяти, используемый для хранения значения элемента матрицы, <math>y</math> - объём памяти, используемый для хранения номера столбца или строки. В таком случае для хранения матрицы в стандартном представлении нам потребуется объем памяти, равный <math>x \cdot n \cdot m</math>, для хранения в формате '''RR(C)''' - <math>y(n + 1) + (x + y)l</math>. Таким образом хранение в формате '''RR(C)''' не является эффективным для матриц, в которых <math>l > \frac{xnm - y(n+1)}{x+y}</math>.

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

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

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

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

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

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

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

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

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

Файл:Bliznalg.png

2016-10-23T20:23:07Z

Blizn: Blizn загрузил новую версию Файл:Bliznalg.png

Файл:Bliznalg.png

2016-10-23T20:15:24Z

Blizn: Blizn загрузил новую версию Файл:Bliznalg.png

Файл:Bliznalg.png

2016-10-23T19:54:39Z

Blizn:

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

2016-10-23T19:04:30Z

Blizn:

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

2016-10-23T17:35:36Z

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

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

2016-10-23T17:34:38Z

Blizn:

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

2016-10-23T17:09:40Z

Blizn:

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

2016-10-23T17:09:00Z

Blizn:

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

2016-10-22T20:19:53Z

Blizn:

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>O(nz)</math>
| pf_height = <math>O(n)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>2nz+m+n+1</math>
| output_data = <math>n</math>
}}
Выполнила: [[Участник:Blizn|И.В. Близнякова]] (611 группа).

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

== Общее описание алгоритма ==
'''Разрежённая матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается '''''плотной'''''.<ref>С.Писсанецки. Технология разреженных матриц. - М.: Мир, 1988. 12 с.</ref>

Среди специалистов нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:
* есть <math>O(n)</math>. Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;
* в каждой строке не превышает 10 в типичном случае;
* ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.
* таково, что для данного алгоритма и вычислительной системы имеет смысл извлекать выгоду из наличия в ней нулей.

=== Хранение разреженной матрицы ===
==== Формат RR(C)O ====
Рассмотрим сначала формат '''RR(C)O'''. Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Ordered"'' (строчное представление, полное и упорядоченное). В данном формате вместо одного двумерного массива, используются три одномерных. Значения ненулевых элементов матрицы и соответствующие им столбцовые индексы хранятся в этом формате по строкам в двух массивах <math>AN</math> и <math>JA</math>. Массив указателей <math>IA</math>, используется для ссылки на компоненты массивов <math>AN</math> и <math>JA</math>, с которых начинается описание очередной строки. Последняя компонента массива <math>IA</math> содержит указатель первой свободной компоненты в массивах <math>AN</math> и <math>JA</math>, т.е. равна числу ненулевых элементов матрицы, увеличенному на единицу. Здесь уместно привести пример.

Рассмотрим матрицу <math>A</math>:
:<math>\begin{pmatrix}
0 & 0 & 0 & 2 & 0 \\
1 & 0 & 3 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 \\
0 & 6 & 0 & 0 & 0 \\
0 & 0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
тогда ее представление в формате '''RR(C)O''' будет иметь вид:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 1 3 2 3 ]
AN = [ 2 1 3 6 4 ]
Т.е. массив <math>AN</math> содержит все не нулевые элементы исходной матрицы <math>A</math>, массив <math>JA</math> номер столбца в котором находится соответствующий элемент из <math>AN</math> и наконец массив <math>IA</math> содержит номер с которого начинается описание элементов в массивах <math>JA</math> и <math>AN</math>. Таким образом информация об элементах 2-ой строки матрицы хранится в элементах с <math>IA[2] = 2</math> по <math>IA[3] - 1 = 3</math> включительно массивов <math>JA</math> и <math>AN</math>. Можно обратить внимание, что <math>IA[3] = IA[4] = 4</math>, а это означает, что 3-я строка матрицы <math>A</math> нулевая.

В общем случае описание <math>r</math>-й строки матрицы A хранится в компонентах с <math>IA[r]</math> до <math>IA[r + 1] - 1</math> включительно массивов <math>AN</math> и <math>JA</math>. Если <math>IA[r + 1] = IA[r]</math>, то это означает, что <math>r</math>-я строка нулевая. Количество элементов в массиве <math>IA</math> на единицу больше, чем число строк исходной матрицы, а количество элементов в массивах <math>JA</math> и <math>AN</math> равно числу ненулевых элементов исходной матрицы.

Данный способ представления называют ''полным'', поскольку представлена вся матрица <math>A</math>, ''упорядоченным'', поскольку элементы каждой строки матрицы <math>A</math> хранятся в соответствии с возрастанием столбцовых индексов, и строчным, поскольку информация о матрице <math>A</math> указывается по строкам.

Массивы <math>IA</math> и <math>JA</math> представляют портрет (структуру) матрицы <math>A</math>, задаваемый как множество списков смежности ассоциированного с <math>A</math> графа. Если алгоритм, реализующий какую-либо операцию над разреженными матрицами, разбит на этапы символической обработки, на котором определяется портрет результирующей матрицы, и численной обработки, на котором определяются значения элементов результирующей матрицы, то массивы <math>IA</math> и <math>JA</math> заполняются на первом этапе, а массив <math>AN</math> - на втором.

==== Формат RR(C)U ====

Рассмотрим теперь формат '''RR(C)U'''.

Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Unordered"'' (строчное представление, полное, но неупорядоченное). Формат '''RR(C)U''' отличается от '''RR(C)O''' тем, что в данном случае соблюдается упорядоченность строк, но внутри каждой строки элементы исходных матриц могут храниться в произвольном порядке. Для матрицы <math>A</math> нашего примера вполне можно было бы использовать и строчное представление, полное, но неупорядоченное такое:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 3 1 2 3 ]
AN = [ 2 1 3 6 4 ]
Такие неупорядоченные представления могут быть очень удобны в практических вычислениях. Результаты большинства матричных операций получаются неупорядоченными, а их упорядочение стоило бы значительных затрат машинного времени. В то же время, за немногими исключениями, алгоритмы для разреженных матриц не требуют, чтобы их представления были упорядоченными.

==== Замечания ====

Несколько замечаний по поводу рассмотренных форматов представления:
# Очевидно, что представление матрицы в формате '''RR(C)O''' так же является и представлением в формате '''RR(C)U''', но не наоборот.
# Из представления матрицы в формате '''RR(C)''' нельзя получить информацию о точном количестве столбцов исходной матрицы.
# Целесообразно (в вопросе экономии памяти) использовать представления '''RR(C)''' в случае, если матрица содержит значительное число нулевых элементов.

=== Умножение разреженной матрицы на вектор ===

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

Мы рассмотрим умножение разреженной матрицы общего вида, хранимой в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math> на заполненный вектор-столбец.

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

Исходные данные: разреженная матрица общего вида <math>A</math> с элементами <math>a_{ij}</math> (<math>i = 1,...,n</math> и <math>j = 1,...,m</math>). Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> (<math>j =1,...,m</math>).

Вычисляемые данные: заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

Формулы метода:

<math>c_{i} = \sum\limits_{k = 1}^{nz_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

где <math>nz_{i}</math> - количество ненулевых элементов строки <math>i</math> матрицы <math>A</math>, <math>j(k)</math> - индекс <math>k</math>-го ненулевого элемента матрицы <math>A</math>.

== Вычислительное ядро алгоритма ==
Вычислительное ядро последовательной версии умножения разреженной матрицы на вектор можно составить из множественных (всего их <math>n</math>) вычислений скалярных произведений строк матрицы:

<math>c_{i} = \sum\limits_{k = 1}^{nz_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>.

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

Как записано и в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют множественные (всего <math>n</math>) вычисления сумм:

<math>c_{i} = \sum\limits_{k = 1}^{nz_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>.

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

Далее предполагаем, что разреженная матрица общего вида <math>A</math> хранится в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>.
Последовательность исполнения метода следующая:

Выполнять для <math>i</math> от <math>1</math> до <math>n</math>
# <math>c_{i} = 0</math>
# <math>IAA = IA[i]</math>
# <math>IAB = IA[i + 1] - 1</math>
# <math>c_{i} = \sum\limits_{k = IAA}^{IAB} AN(k)b_{JA(k)}</math>.
После этого (если <math>i \le n</math>) происходит переход к шагу 1 с бо́льшим <math>i</math>.

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размером <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в последовательном (наиболее быстром) варианте требуется:

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

Умножения и сложения составляют ''основную часть алгоритма''.

При классификации по последовательной сложности, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам <math>O(nz)</math>.

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

Опишем [[глоссарий#Граф алгоритма|граф алгоритма]]<ref>Воеводин В.В. Математические основы параллельных вычислений// М.: Изд. Моск. ун-та, 1991. 345 с.</ref><ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. – СПб.: БХВ - Петербург, 2002. – 608 с.</ref><ref>Фролов А.В.. Принципы построения и описание языка Сигма. Препринт ОВМ АН N 236. М.: ОВМ АН СССР, 1989.</ref> как аналитически, так и в виде рисунка.

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

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

* <math>i</math> — меняется в диапазоне от <math>1</math> до <math>n-1</math>, принимая все целочисленные значения;
* <math>j</math> — меняется в диапазоне от <math>i+1</math> до <math>n</math>, принимая все целочисленные значения.

Аргументы операции следующие:
*<math>a</math>:
** при <math>i = 1</math> — элементы ''входных данных'', а именно <math>a_{j1}</math>;
** при <math>i > 1</math> — результат срабатывания операции, соответствующей вершине из третьей группы, с координатами <math>i - 1, j, i - 1</math>;
* <math>b</math> — результат срабатывания операции, соответствующей вершине из первой группы, с координатой <math>i</math>.

Результат срабатывания операции является ''выходным данным'' <math>c_{i}</math>.

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размером <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в параллельном варианте требуется последовательно выполнить следующие ярусы:

*
*

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

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

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

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

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

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

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

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

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

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

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

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

2016-10-22T16:14:14Z

Blizn:

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>O(nz)</math>
| pf_height = <math>O(n)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>2nz+m+n+1</math>
| output_data = <math>n</math>
}}
Выполнила: [[Участник:Blizn|И.В. Близнякова]] (611 группа).

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

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

Среди специалистов нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:
* есть <math>O(n)</math>. Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;
* в каждой строке не превышает 10 в типичном случае;
* ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.
* таково, что для данного алгоритма и вычислительной системы имеет смысл извлекать выгоду из наличия в ней нулей.

=== Хранение разреженной матрицы ===
==== Формат RR(C)O ====
Рассмотрим сначала формат '''RR(C)O'''. Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Ordered"'' (строчное представление, полное и упорядоченное). В данном формате вместо одного двумерного массива, используются три одномерных. Значения ненулевых элементов матрицы и соответствующие им столбцовые индексы хранятся в этом формате по строкам в двух массивах <math>AN</math> и <math>JA</math>. Массив указателей <math>IA</math>, используется для ссылки на компоненты массивов <math>AN</math> и <math>JA</math>, с которых начинается описание очередной строки. Последняя компонента массива <math>IA</math> содержит указатель первой свободной компоненты в массивах <math>AN</math> и <math>JA</math>, т.е. равна числу ненулевых элементов матрицы, увеличенному на единицу. Здесь уместно привести пример.

Рассмотрим матрицу <math>A</math>:
:<math>\begin{pmatrix}
0 & 0 & 0 & 2 & 0 \\
1 & 0 & 3 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 \\
0 & 6 & 0 & 0 & 0 \\
0 & 0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
тогда ее представление в формате '''RR(C)O''' будет иметь вид:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 1 3 2 3 ]
AN = [ 2 1 3 6 4 ]
Т.е. массив <math>AN</math> содержит все не нулевые элементы исходной матрицы <math>A</math>, массив <math>JA</math> номер столбца в котором находится соответствующий элемент из <math>AN</math> и наконец массив <math>IA</math> содержит номер с которого начинается описание элементов в массивах <math>JA</math> и <math>AN</math>. Таким образом информация об элементах 2-ой строки матрицы хранится в элементах с <math>IA[2] = 2</math> по <math>IA[3] - 1 = 3</math> включительно массивов <math>JA</math> и <math>AN</math>. Можно обратить внимание, что <math>IA[3] = IA[4] = 4</math>, а это означает, что 3-я строка матрицы <math>A</math> нулевая.

В общем случае описание <math>r</math>-й строки матрицы A хранится в компонентах с <math>IA[r]</math> до <math>IA[r + 1] - 1</math> включительно массивов <math>AN</math> и <math>JA</math>. Если <math>IA[r + 1] = IA[r]</math>, то это означает, что <math>r</math>-я строка нулевая. Количество элементов в массиве <math>IA</math> на единицу больше, чем число строк исходной матрицы, а количество элементов в массивах <math>JA</math> и <math>AN</math> равно числу ненулевых элементов исходной матрицы.

Данный способ представления называют ''полным'', поскольку представлена вся матрица <math>A</math>, ''упорядоченным'', поскольку элементы каждой строки матрицы <math>A</math> хранятся в соответствии с возрастанием столбцовых индексов, и строчным, поскольку информация о матрице <math>A</math> указывается по строкам.

Массивы <math>IA</math> и <math>JA</math> представляют портрет (структуру) матрицы <math>A</math>, задаваемый как множество списков смежности ассоциированного с <math>A</math> графа. Если алгоритм, реализующий какую-либо операцию над разреженными матрицами, разбит на этапы символической обработки, на котором определяется портрет результирующей матрицы, и численной обработки, на котором определяются значения элементов результирующей матрицы, то массивы <math>IA</math> и <math>JA</math> заполняются на первом этапе, а массив <math>AN</math> - на втором.

==== Формат RR(C)U ====

Рассмотрим теперь формат '''RR(C)U'''.

Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Unordered"'' (строчное представление, полное, но неупорядоченное). Формат '''RR(C)U''' отличается от '''RR(C)O''' тем, что в данном случае соблюдается упорядоченность строк, но внутри каждой строки элементы исходных матриц могут храниться в произвольном порядке. Для матрицы <math>A</math> нашего примера вполне можно было бы использовать и строчное представление, полное, но неупорядоченное такое:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 3 1 2 3 ]
AN = [ 2 1 3 6 4 ]
Такие неупорядоченные представления могут быть очень удобны в практических вычислениях. Результаты большинства матричных операций получаются неупорядоченными, а их упорядочение стоило бы значительных затрат машинного времени. В то же время, за немногими исключениями, алгоритмы для разреженных матриц не требуют, чтобы их представления были упорядоченными.

==== Замечания ====

Несколько замечаний по поводу рассмотренных форматов представления:
# Очевидно, что представление матрицы в формате '''RR(C)O''' так же является и представлением в формате '''RR(C)U''', но не наоборот.
# Из представления матрицы в формате '''RR(C)''' нельзя получить информацию о точном количестве столбцов исходной матрицы.
# Целесообразно (в вопросе экономии памяти) использовать представления '''RR(C)''' в случае, если матрица содержит значительное число нулевых элементов.

=== Умножение разреженной матрицы на вектор ===

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

Мы рассмотрим умножение разреженной матрицы общего вида, хранимой в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math> на заполненный вектор-столбец.

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

Исходные данные: разреженная матрица общего вида <math>A</math> с элементами <math>a_{ij}</math> (<math>i = 1,...,n</math> и <math>j = 1,...,m</math>). Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> (<math>j =1,...,m</math>).

Вычисляемые данные: заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

Формулы метода:

<math>c_{i} = \sum\limits_{k = 1}^{nz_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

где <math>nz_{i}</math> - количество ненулевых элементов строки <math>i</math> матрицы <math>A</math>, <math>j(k)</math> - индекс <math>k</math>-го ненулевого элемента матрицы <math>A</math>.

== Вычислительное ядро алгоритма ==
Вычислительное ядро последовательной версии умножения разреженной матрицы на вектор можно составить из множественных (всего их <math>n</math>) вычислений скалярных произведений строк матрицы:

<math>c_{i} = \sum\limits_{k = 1}^{nz_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>.

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

Как записано и в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют множественные (всего <math>n</math>) вычисления сумм:

<math>c_{i} = \sum\limits_{k = 1}^{nz_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>.

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

Далее предполагаем, что разреженная матрица общего вида <math>A</math> хранится в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>.
Последовательность исполнения метода следующая:

Выполнять для <math>i</math> от <math>1</math> до <math>n</math>
# <math>c_{i} = 0</math>
# <math>IAA = IA[i]</math>
# <math>IAB = IA[i + 1] - 1</math>
# <math>c_{i} = \sum\limits_{k = IAA}^{IAB} AN(k)b_{JA(k)}</math>.
После этого (если <math>i \le n</math>) происходит переход к шагу 1 с бо́льшим <math>i</math>.

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размером <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в последовательном (наиболее быстром) варианте требуется:

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

Умножения и сложения составляют ''основную часть алгоритма''.

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

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

Опишем [[глоссарий#Граф алгоритма|граф алгоритма]]<ref>Воеводин В.В. Математические основы параллельных вычислений// М.: Изд. Моск. ун-та, 1991. 345 с.</ref><ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. – СПб.: БХВ - Петербург, 2002. – 608 с.</ref><ref>Фролов А.В.. Принципы построения и описание языка Сигма. Препринт ОВМ АН N 236. М.: ОВМ АН СССР, 1989.</ref> как аналитически, так и в виде рисунка.

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

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

* <math>i</math> — меняется в диапазоне от <math>1</math> до <math>n-1</math>, принимая все целочисленные значения;
* <math>j</math> — меняется в диапазоне от <math>i+1</math> до <math>n</math>, принимая все целочисленные значения.

Аргументы операции следующие:
*<math>a</math>:
** при <math>i = 1</math> — элементы ''входных данных'', а именно <math>a_{j1}</math>;
** при <math>i > 1</math> — результат срабатывания операции, соответствующей вершине из третьей группы, с координатами <math>i - 1, j, i - 1</math>;
* <math>b</math> — результат срабатывания операции, соответствующей вершине из первой группы, с координатой <math>i</math>.

Результат срабатывания операции является ''выходным данным'' <math>c_{i}</math>.

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

2016-10-22T16:13:30Z

Blizn:

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>O(nz)</math>
| pf_height = <math>O(n)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>2nz+m+n+1</math>
| output_data = <math>n</math>
}}
Выполнила: [[Участник:Blizn|И.В. Близнякова]] (611 группа).

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

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

Среди специалистов нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:
* есть <math>O(n)</math>. Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;
* в каждой строке не превышает 10 в типичном случае;
* ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.
* таково, что для данного алгоритма и вычислительной системы имеет смысл извлекать выгоду из наличия в ней нулей.

=== Хранение разреженной матрицы ===
==== Формат RR(C)O ====
Рассмотрим сначала формат '''RR(C)O'''. Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Ordered"'' (строчное представление, полное и упорядоченное). В данном формате вместо одного двумерного массива, используются три одномерных. Значения ненулевых элементов матрицы и соответствующие им столбцовые индексы хранятся в этом формате по строкам в двух массивах <math>AN</math> и <math>JA</math>. Массив указателей <math>IA</math>, используется для ссылки на компоненты массивов <math>AN</math> и <math>JA</math>, с которых начинается описание очередной строки. Последняя компонента массива <math>IA</math> содержит указатель первой свободной компоненты в массивах <math>AN</math> и <math>JA</math>, т.е. равна числу ненулевых элементов матрицы, увеличенному на единицу. Здесь уместно привести пример.

Рассмотрим матрицу <math>A</math>:
:<math>\begin{pmatrix}
0 & 0 & 0 & 2 & 0 \\
1 & 0 & 3 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 \\
0 & 6 & 0 & 0 & 0 \\
0 & 0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
тогда ее представление в формате '''RR(C)O''' будет иметь вид:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 1 3 2 3 ]
AN = [ 2 1 3 6 4 ]
Т.е. массив <math>AN</math> содержит все не нулевые элементы исходной матрицы <math>A</math>, массив <math>JA</math> номер столбца в котором находится соответствующий элемент из <math>AN</math> и наконец массив <math>IA</math> содержит номер с которого начинается описание элементов в массивах <math>JA</math> и <math>AN</math>. Таким образом информация об элементах 2-ой строки матрицы хранится в элементах с <math>IA[2] = 2</math> по <math>IA[3] - 1 = 3</math> включительно массивов <math>JA</math> и <math>AN</math>. Можно обратить внимание, что <math>IA[3] = IA[4] = 4</math>, а это означает, что 3-я строка матрицы <math>A</math> нулевая.

В общем случае описание <math>r</math>-й строки матрицы A хранится в компонентах с <math>IA[r]</math> до <math>IA[r + 1] - 1</math> включительно массивов <math>AN</math> и <math>JA</math>. Если <math>IA[r + 1] = IA[r]</math>, то это означает, что <math>r</math>-я строка нулевая. Количество элементов в массиве <math>IA</math> на единицу больше, чем число строк исходной матрицы, а количество элементов в массивах <math>JA</math> и <math>AN</math> равно числу ненулевых элементов исходной матрицы.

Данный способ представления называют ''полным'', поскольку представлена вся матрица <math>A</math>, ''упорядоченным'', поскольку элементы каждой строки матрицы <math>A</math> хранятся в соответствии с возрастанием столбцовых индексов, и строчным, поскольку информация о матрице <math>A</math> указывается по строкам.

Массивы <math>IA</math> и <math>JA</math> представляют портрет (структуру) матрицы <math>A</math>, задаваемый как множество списков смежности ассоциированного с <math>A</math> графа. Если алгоритм, реализующий какую-либо операцию над разреженными матрицами, разбит на этапы символической обработки, на котором определяется портрет результирующей матрицы, и численной обработки, на котором определяются значения элементов результирующей матрицы, то массивы <math>IA</math> и <math>JA</math> заполняются на первом этапе, а массив <math>AN</math> - на втором.

==== Формат RR(C)U ====

Рассмотрим теперь формат '''RR(C)U'''.

Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Unordered"'' (строчное представление, полное, но неупорядоченное). Формат '''RR(C)U''' отличается от '''RR(C)O''' тем, что в данном случае соблюдается упорядоченность строк, но внутри каждой строки элементы исходных матриц могут храниться в произвольном порядке. Для матрицы <math>A</math> нашего примера вполне можно было бы использовать и строчное представление, полное, но неупорядоченное такое:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 3 1 2 3 ]
AN = [ 2 1 3 6 4 ]
Такие неупорядоченные представления могут быть очень удобны в практических вычислениях. Результаты большинства матричных операций получаются неупорядоченными, а их упорядочение стоило бы значительных затрат машинного времени. В то же время, за немногими исключениями, алгоритмы для разреженных матриц не требуют, чтобы их представления были упорядоченными.

==== Замечания ====

Несколько замечаний по поводу рассмотренных форматов представления:
# Очевидно, что представление матрицы в формате '''RR(C)O''' так же является и представлением в формате '''RR(C)U''', но не наоборот.
# Из представления матрицы в формате '''RR(C)''' нельзя получить информацию о точном количестве столбцов исходной матрицы.
# Целесообразно (в вопросе экономии памяти) использовать представления '''RR(C)''' в случае, если матрица содержит значительное число нулевых элементов.

=== Умножение разреженной матрицы на вектор ===

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

Мы рассмотрим умножение разреженной матрицы общего вида, хранимой в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math> на заполненный вектор-столбец.

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

Исходные данные: разреженная матрица общего вида <math>A</math> с элементами <math>a_{ij}</math> (<math>i = 1,...,n</math> и <math>j = 1,...,m</math>). Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> (<math>j =1,...,m</math>).

Вычисляемые данные: заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

Формулы метода:

<math>c_{i} = \sum\limits_{k = 1}^{nz_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

где <math>nz_{i}</math> - количество ненулевых элементов строки <math>i</math> матрицы <math>A</math>, <math>j(k)</math> - индекс <math>k</math>-го ненулевого элемента матрицы <math>A</math>.

== Вычислительное ядро алгоритма ==
Вычислительное ядро последовательной версии умножения разреженной матрицы на вектор можно составить из множественных (всего их <math>n</math>) вычислений скалярных произведений строк матрицы:

<math>c_{i} = \sum\limits_{k = 1}^{nz_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>.

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

Как записано и в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют множественные (всего <math>n</math>) вычисления сумм:

<math>c_{i} = \sum\limits_{k = 1}^{nz_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>.

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

Далее предполагаем, что разреженная матрица общего вида <math>A</math> хранится в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>.
Последовательность исполнения метода следующая:

Выполнять для <math>i</math> от <math>1</math> до <math>n</math>
# <math>c_{i} = 0</math>
# <math>IAA = IA[i]</math>
# <math>IAB = IA[i + 1] - 1</math>
# <math>c_{i} = \sum\limits_{k = IAA}^{IAB} AN(k)b_{JA(k)}</math>.
После этого (если <math>i \le n</math>) происходит переход к шагу 1 с бо́льшим <math>i</math>.

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размером <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в последовательном (наиболее быстром) варианте требуется:

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

Умножения и сложения составляют ''основную часть алгоритма''.

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

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

Опишем [[глоссарий#Граф алгоритма|граф алгоритма]]<ref>Воеводин В.В. Математические основы параллельных вычислений// М.: Изд. Моск. ун-та, 1991. 345 с.</ref><ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. – СПб.: БХВ - Петербург, 2002. – 608 с.</ref><ref>Фролов А.В.. Принципы построения и описание языка Сигма. Препринт ОВМ АН N 236. М.: ОВМ АН СССР, 1989.</ref> как аналитически, так и в виде рисунка.

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

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

* <math>i</math> — меняется в диапазоне от <math>1</math> до <math>n-1</math>, принимая все целочисленные значения;
* <math>j</math> — меняется в диапазоне от <math>i+1</math> до <math>n</math>, принимая все целочисленные значения.

Аргументы операции следующие:
*<math>a</math>:
** при <math>i = 1</math> — элементы ''входных данных'', а именно <math>a_{j1}</math>;
** при <math>i > 1</math> — результат срабатывания операции, соответствующей вершине из третьей группы, с координатами <math>i - 1, j, i - 1</math>;
* <math>b</math> — результат срабатывания операции, соответствующей вершине из первой группы, с координатой <math>i</math>.

Результат срабатывания операции является ''выходным данным'' <math>с_{i}</math>.

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

2016-10-22T16:13:03Z

Blizn:

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>O(nz)</math>
| pf_height = <math>O(n)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>2nz+m+n+1</math>
| output_data = <math>n</math>
}}
Выполнила: [[Участник:Blizn|И.В. Близнякова]] (611 группа).

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

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

Среди специалистов нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:
* есть <math>O(n)</math>. Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;
* в каждой строке не превышает 10 в типичном случае;
* ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.
* таково, что для данного алгоритма и вычислительной системы имеет смысл извлекать выгоду из наличия в ней нулей.

=== Хранение разреженной матрицы ===
==== Формат RR(C)O ====
Рассмотрим сначала формат '''RR(C)O'''. Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Ordered"'' (строчное представление, полное и упорядоченное). В данном формате вместо одного двумерного массива, используются три одномерных. Значения ненулевых элементов матрицы и соответствующие им столбцовые индексы хранятся в этом формате по строкам в двух массивах <math>AN</math> и <math>JA</math>. Массив указателей <math>IA</math>, используется для ссылки на компоненты массивов <math>AN</math> и <math>JA</math>, с которых начинается описание очередной строки. Последняя компонента массива <math>IA</math> содержит указатель первой свободной компоненты в массивах <math>AN</math> и <math>JA</math>, т.е. равна числу ненулевых элементов матрицы, увеличенному на единицу. Здесь уместно привести пример.

Рассмотрим матрицу <math>A</math>:
:<math>\begin{pmatrix}
0 & 0 & 0 & 2 & 0 \\
1 & 0 & 3 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 \\
0 & 6 & 0 & 0 & 0 \\
0 & 0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
тогда ее представление в формате '''RR(C)O''' будет иметь вид:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 1 3 2 3 ]
AN = [ 2 1 3 6 4 ]
Т.е. массив <math>AN</math> содержит все не нулевые элементы исходной матрицы <math>A</math>, массив <math>JA</math> номер столбца в котором находится соответствующий элемент из <math>AN</math> и наконец массив <math>IA</math> содержит номер с которого начинается описание элементов в массивах <math>JA</math> и <math>AN</math>. Таким образом информация об элементах 2-ой строки матрицы хранится в элементах с <math>IA[2] = 2</math> по <math>IA[3] - 1 = 3</math> включительно массивов <math>JA</math> и <math>AN</math>. Можно обратить внимание, что <math>IA[3] = IA[4] = 4</math>, а это означает, что 3-я строка матрицы <math>A</math> нулевая.

В общем случае описание <math>r</math>-й строки матрицы A хранится в компонентах с <math>IA[r]</math> до <math>IA[r + 1] - 1</math> включительно массивов <math>AN</math> и <math>JA</math>. Если <math>IA[r + 1] = IA[r]</math>, то это означает, что <math>r</math>-я строка нулевая. Количество элементов в массиве <math>IA</math> на единицу больше, чем число строк исходной матрицы, а количество элементов в массивах <math>JA</math> и <math>AN</math> равно числу ненулевых элементов исходной матрицы.

Данный способ представления называют ''полным'', поскольку представлена вся матрица <math>A</math>, ''упорядоченным'', поскольку элементы каждой строки матрицы <math>A</math> хранятся в соответствии с возрастанием столбцовых индексов, и строчным, поскольку информация о матрице <math>A</math> указывается по строкам.

Массивы <math>IA</math> и <math>JA</math> представляют портрет (структуру) матрицы <math>A</math>, задаваемый как множество списков смежности ассоциированного с <math>A</math> графа. Если алгоритм, реализующий какую-либо операцию над разреженными матрицами, разбит на этапы символической обработки, на котором определяется портрет результирующей матрицы, и численной обработки, на котором определяются значения элементов результирующей матрицы, то массивы <math>IA</math> и <math>JA</math> заполняются на первом этапе, а массив <math>AN</math> - на втором.

==== Формат RR(C)U ====

Рассмотрим теперь формат '''RR(C)U'''.

Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Unordered"'' (строчное представление, полное, но неупорядоченное). Формат '''RR(C)U''' отличается от '''RR(C)O''' тем, что в данном случае соблюдается упорядоченность строк, но внутри каждой строки элементы исходных матриц могут храниться в произвольном порядке. Для матрицы <math>A</math> нашего примера вполне можно было бы использовать и строчное представление, полное, но неупорядоченное такое:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 3 1 2 3 ]
AN = [ 2 1 3 6 4 ]
Такие неупорядоченные представления могут быть очень удобны в практических вычислениях. Результаты большинства матричных операций получаются неупорядоченными, а их упорядочение стоило бы значительных затрат машинного времени. В то же время, за немногими исключениями, алгоритмы для разреженных матриц не требуют, чтобы их представления были упорядоченными.

==== Замечания ====

Несколько замечаний по поводу рассмотренных форматов представления:
# Очевидно, что представление матрицы в формате '''RR(C)O''' так же является и представлением в формате '''RR(C)U''', но не наоборот.
# Из представления матрицы в формате '''RR(C)''' нельзя получить информацию о точном количестве столбцов исходной матрицы.
# Целесообразно (в вопросе экономии памяти) использовать представления '''RR(C)''' в случае, если матрица содержит значительное число нулевых элементов.

=== Умножение разреженной матрицы на вектор ===

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

Мы рассмотрим умножение разреженной матрицы общего вида, хранимой в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math> на заполненный вектор-столбец.

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

Исходные данные: разреженная матрица общего вида <math>A</math> с элементами <math>a_{ij}</math> (<math>i = 1,...,n</math> и <math>j = 1,...,m</math>). Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> (<math>j =1,...,m</math>).

Вычисляемые данные: заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

Формулы метода:

<math>c_{i} = \sum\limits_{k = 1}^{nz_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

где <math>nz_{i}</math> - количество ненулевых элементов строки <math>i</math> матрицы <math>A</math>, <math>j(k)</math> - индекс <math>k</math>-го ненулевого элемента матрицы <math>A</math>.

== Вычислительное ядро алгоритма ==
Вычислительное ядро последовательной версии умножения разреженной матрицы на вектор можно составить из множественных (всего их <math>n</math>) вычислений скалярных произведений строк матрицы:

<math>c_{i} = \sum\limits_{k = 1}^{nz_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>.

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

Как записано и в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют множественные (всего <math>n</math>) вычисления сумм:

<math>c_{i} = \sum\limits_{k = 1}^{nz_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>.

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

Далее предполагаем, что разреженная матрица общего вида <math>A</math> хранится в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>.
Последовательность исполнения метода следующая:

Выполнять для <math>i</math> от <math>1</math> до <math>n</math>
# <math>c_{i} = 0</math>
# <math>IAA = IA[i]</math>
# <math>IAB = IA[i + 1] - 1</math>
# <math>c_{i} = \sum\limits_{k = IAA}^{IAB} AN(k)b_{JA(k)}</math>.
После этого (если <math>i \le n</math>) происходит переход к шагу 1 с бо́льшим <math>i</math>.

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

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размером <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в последовательном (наиболее быстром) варианте требуется:

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

Умножения и сложения составляют ''основную часть алгоритма''.

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

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

Опишем [[глоссарий#Граф алгоритма|граф алгоритма]]<ref>Воеводин В.В. Математические основы параллельных вычислений// М.: Изд. Моск. ун-та, 1991. 345 с.</ref><ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. – СПб.: БХВ - Петербург, 2002. – 608 с.</ref><ref>Фролов А.В.. Принципы построения и описание языка Сигма. Препринт ОВМ АН N 236. М.: ОВМ АН СССР, 1989.</ref> как аналитически, так и в виде рисунка.

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

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

* <math>i</math> — меняется в диапазоне от <math>1</math> до <math>n-1</math>, принимая все целочисленные значения;
* <math>j</math> — меняется в диапазоне от <math>i+1</math> до <math>n</math>, принимая все целочисленные значения.

Аргументы операции следующие:
*<math>a</math>:
** при <math>i = 1</math> — элементы ''входных данных'', а именно <math>a_{j1}</math>;
** при <math>i > 1</math> — результат срабатывания операции, соответствующей вершине из третьей группы, с координатами <math>i - 1, j, i - 1</math>;
* <math>b</math> — результат срабатывания операции, соответствующей вершине из первой группы, с координатой <math>i</math>.

Результат срабатывания операции является ''выходным данным'' <math>с_{i}</math>.

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

2016-10-22T13:43:17Z

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

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nz</math>
| pf_height = <math>O(n)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>2nz+m+n+1</math>
| output_data = <math>n</math>
}}
Выполнила: [[Участник:Blizn|И.В. Близнякова]] (611 группа).

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

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

Среди специалистов нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:
* есть <math>O(n)</math>. Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;
* в каждой строке не превышает 10 в типичном случае;
* ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.
* таково, что для данного алгоритма и вычислительной системы имеет смысл извлекать выгоду из наличия в ней нулей.

=== Хранение разреженной матрицы ===
==== Формат RR(C)O ====
Рассмотрим сначала формат '''RR(C)O'''. Сокращенное название данного формата происходит от английского словосочетания "Row - wise Representation Complete and Ordered" (строчное представление, полное и упорядоченное). В данном формате вместо одного двумерного массива, используются три одномерных. Значения ненулевых элементов матрицы и соответствующие им столбцовые индексы хранятся в этом формате по строкам в двух массивах <math>AN</math> и <math>JA</math>. Массив указателей <math>IA</math>, используется для ссылки на компоненты массивов <math>AN</math> и <math>JA</math>, с которых начинается описание очередной строки. Последняя компонента массива <math>IA</math> содержит указатель первой свободной компоненты в массивах <math>AN</math> и <math>JA</math>, т.е. равна числу ненулевых элементов матрицы, увеличенному на единицу. Здесь уместно привести пример.

Рассмотрим матрицу <math>A</math>:
:<math>\begin{pmatrix}
0 & 0 & 0 & 2 & 0 \\
1 & 0 & 3 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 \\
0 & 6 & 0 & 0 & 0 \\
0 & 0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
тогда ее представление в формате '''RR(C)O''' будет иметь вид:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 1 3 2 3 ]
AN = [ 2 1 3 6 4 ]
Т.е. массив <math>AN</math> содержит все не нулевые элементы исходной матрицы <math>A</math>, массив <math>JA</math> номер столбца в котором находится соответствующий элемент из <math>AN</math> и наконец массив <math>IA</math> содержит номер с которого начинается описание элементов в массивах <math>JA</math> и <math>AN</math>. Таким образом информация об элементах 2-ой строки матрицы хранится в элементах с <math>IA[2] = 2</math> по <math>IA[3] - 1 = 3</math> включительно массивов <math>JA</math> и <math>AN</math>. Можно обратить внимание, что <math>IA[3] = IA[4] = 4</math>, а это означает, что 3-я строка матрицы <math>A</math> нулевая.

В общем случае описание <math>r</math>-й строки матрицы A хранится в компонентах с <math>IA[r]</math> до <math>IA[r + 1] - 1</math> включительно массивов <math>AN</math> и <math>JA</math>. Если <math>IA[r + 1] = IA[r]</math>, то это означает, что <math>r</math>-я строка нулевая. Количество элементов в массиве <math>IA</math> на единицу больше, чем число строк исходной матрицы, а количество элементов в массивах <math>JA</math> и <math>AN</math> равно числу ненулевых элементов исходной матрицы.

Данный способ представления называют ''полным'', поскольку представлена вся матрица <math>A</math>, ''упорядоченным'', поскольку элементы каждой строки матрицы <math>A</math> хранятся в соответствии с возрастанием столбцовых индексов, и строчным, поскольку информация о матрице <math>A</math> указывается по строкам.

Массивы <math>IA</math> и <math>JA</math> представляют портрет (структуру) матрицы <math>A</math>, задаваемый как множество списков смежности ассоциированного с <math>A</math> графа. Если алгоритм, реализующий какую-либо операцию над разреженными матрицами, разбит на этапы символической обработки, на котором определяется портрет результирующей матрицы, и численной обработки, на котором определяются значения элементов результирующей матрицы, то массивы <math>IA</math> и <math>JA</math> заполняются на первом этапе, а массив <math>AN</math> - на втором.

==== Формат RR(C)U ====

Рассмотрим теперь формат '''RR(C)U'''.

Сокращенное название данного формата происходит от английского словосочетания "Row - wise Representation Complete and Unordered" (строчное представление, полное, но неупорядоченное). Формат '''RR(C)U''' отличается от '''RR(C)O''' тем, что в данном случае соблюдается упорядоченность строк, но внутри каждой строки элементы исходных матриц могут храниться в произвольном порядке. Для матрицы <math>A</math> нашего примера вполне можно было бы использовать и строчное представление, полное, но неупорядоченное такое:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 3 1 2 3 ]
AN = [ 2 1 3 6 4 ]
Такие неупорядоченные представления могут быть очень удобны в практических вычислениях. Результаты большинства матричных операций получаются неупорядоченными, а их упорядочение стоило бы значительных затрат машинного времени. В то же время, за немногими исключениями, алгоритмы для разреженных матриц не требуют, чтобы их представления были упорядоченными.

==== Замечания ====

Несколько замечаний по поводу рассмотренных форматов представления:
# Очевидно, что представление матрицы в формате '''RR(C)O''' так же является и представлением в формате '''RR(C)U''', но не наоборот.
# Из представления матрицы в формате '''RR(C)''' нельзя получить информацию о точном количестве столбцов исходной матрицы.
# Целесообразно (в вопросе экономии памяти) использовать представления '''RR(C)''' в случае, если матрица содержит значительное число нулевых элементов.

=== Умножение разреженной матрицы на вектор ===

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

Мы рассмотрим умножение разреженной матрицы общего вида, хранимой в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math> на заполненный вектор-столбец.

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

Исходные данные: разреженная матрица общего вида <math>A</math> с элементами <math>a_{ij}</math> (<math>i = 1,...,n</math> и <math>j = 1,...,m</math>). Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> (<math>j =1,...,m</math>).

Вычисляемые данные: заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

Формулы метода:

<math>c_{i} = \sum\limits_{k = 1}^{nz_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

где <math>nz_{i}</math> - количество ненулевых элементов строки <math>i</math> матрицы <math>A</math>, <math>j(k)</math> - индекс <math>k</math>-го ненулевого элемента матрицы <math>A</math>.

Участник:Blizn

2016-10-22T13:21:07Z

Blizn:

Близнякова Ирина Валерьевна, 611 группа.

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

2016-10-22T13:20:42Z

Blizn: Blizn переименовал страницу [[Участник:Близнякова Ирина/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы н…

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nz</math>
| pf_height = <math>O(n)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>2nz+m+n+1</math>
| output_data = <math>n</math>
}}
Выполнила: [[Участник:Blizn|И.В. Близнякова]] (611 группа).

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

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

Среди специалистов нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:
* есть <math>O(n)</math>. Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;
* в каждой строке не превышает 10 в типичном случае;
* ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.
* таково, что для данного алгоритма и вычислительной системы имеет смысл извлекать выгоду из наличия в ней нулей.

=== Хранение разреженной матрицы ===
==== Формат RR(C)O ====
Рассмотрим сначала формат '''RR(C)O'''. Сокращенное название данного формата происходит от английского словосочетания "Row - wise Representation Complete and Ordered" (строчное представление, полное и упорядоченное). В данном формате вместо одного двумерного массива, используются три одномерных. Значения ненулевых элементов матрицы и соответствующие им столбцовые индексы хранятся в этом формате по строкам в двух массивах <math>AN</math> и <math>JA</math>. Массив указателей <math>IA</math>, используется для ссылки на компоненты массивов <math>AN</math> и <math>JA</math>, с которых начинается описание очередной строки. Последняя компонента массива <math>IA</math> содержит указатель первой свободной компоненты в массивах <math>AN</math> и <math>JA</math>, т.е. равна числу ненулевых элементов матрицы, увеличенному на единицу. Здесь уместно привести пример.

Рассмотрим матрицу <math>A</math>:
:<math>\begin{pmatrix}
0 & 0 & 0 & 2 & 0 \\
1 & 0 & 3 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 \\
0 & 6 & 0 & 0 & 0 \\
0 & 0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
тогда ее представление в формате '''RR(C)O''' будет иметь вид:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 1 3 2 3 ]
AN = [ 2 1 3 6 4 ]
Т.е. массив <math>AN</math> содержит все не нулевые элементы исходной матрицы <math>A</math>, массив <math>JA</math> номер столбца в котором находится соответствующий элемент из <math>AN</math> и наконец массив <math>IA</math> содержит номер с которого начинается описание элементов в массивах <math>JA</math> и <math>AN</math>. Таким образом информация об элементах 2-ой строки матрицы хранится в элементах с <math>IA[2] = 2</math> по <math>IA[3] - 1 = 3</math> включительно массивов <math>JA</math> и <math>AN</math>. Можно обратить внимание, что <math>IA[3] = IA[4] = 4</math>, а это означает, что 3-я строка матрицы <math>A</math> нулевая.

В общем случае описание <math>r</math>-й строки матрицы A хранится в компонентах с <math>IA[r]</math> до <math>IA[r + 1] - 1</math> включительно массивов <math>AN</math> и <math>JA</math>. Если <math>IA[r + 1] = IA[r]</math>, то это означает, что <math>r</math>-я строка нулевая. Количество элементов в массиве <math>IA</math> на единицу больше, чем число строк исходной матрицы, а количество элементов в массивах <math>JA</math> и <math>AN</math> равно числу ненулевых элементов исходной матрицы.

Данный способ представления называют ''полным'', поскольку представлена вся матрица <math>A</math>, ''упорядоченным'', поскольку элементы каждой строки матрицы <math>A</math> хранятся в соответствии с возрастанием столбцовых индексов, и строчным, поскольку информация о матрице <math>A</math> указывается по строкам.

Массивы <math>IA</math> и <math>JA</math> представляют портрет (структуру) матрицы <math>A</math>, задаваемый как множество списков смежности ассоциированного с <math>A</math> графа. Если алгоритм, реализующий какую-либо операцию над разреженными матрицами, разбит на этапы символической обработки, на котором определяется портрет результирующей матрицы, и численной обработки, на котором определяются значения элементов результирующей матрицы, то массивы <math>IA</math> и <math>JA</math> заполняются на первом этапе, а массив <math>AN</math> - на втором.

==== Формат RR(C)U ====

Рассмотрим теперь формат '''RR(C)U'''.

Сокращенное название данного формата происходит от английского словосочетания "Row - wise Representation Complete and Unordered" (строчное представление, полное, но неупорядоченное). Формат '''RR(C)U''' отличается от '''RR(C)O''' тем, что в данном случае соблюдается упорядоченность строк, но внутри каждой строки элементы исходных матриц могут храниться в произвольном порядке. Для матрицы <math>A</math> нашего примера вполне можно было бы использовать и строчное представление, полное, но неупорядоченное такое:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 3 1 2 3 ]
AN = [ 2 1 3 6 4 ]
Такие неупорядоченные представления могут быть очень удобны в практических вычислениях. Результаты большинства матричных операций получаются неупорядоченными, а их упорядочение стоило бы значительных затрат машинного времени. В то же время, за немногими исключениями, алгоритмы для разреженных матриц не требуют, чтобы их представления были упорядоченными.

==== Замечания ====

Несколько замечаний по поводу рассмотренных форматов представления:
# Очевидно, что представление матрицы в формате '''RR(C)O''' так же является и представлением в формате '''RR(C)U''', но не наоборот.
# Из представления матрицы в формате '''RR(C)''' нельзя получить информацию о точном количестве столбцов исходной матрицы.
# Целесообразно (в вопросе экономии памяти) использовать представления '''RR(C)''' в случае, если матрица содержит значительное число нулевых элементов.

=== Умножение разреженной матрицы на вектор ===

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

Мы рассмотрим умножение разреженной матрицы общего вида, хранимой в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math> на заполненный вектор-столбец.

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

Исходные данные: разреженная матрица общего вида <math>A</math> с элементами <math>a_{ij}</math>, <math>i = 1,...,n</math> и <math>j = 1,...,m</math>. Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math>, <math>j =1,...,m</math>.
Вычисляемые данные:

Участник:Blizn

2016-10-22T13:18:57Z

Blizn: Создана пустая страница

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

2016-10-22T13:15:58Z

Blizn:

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nz</math>
| pf_height = <math>O(n)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>2nz+m+n+1</math>
| output_data = <math>n</math>
}}
Выполнила: [[Участник:Blizn|И.В. Близнякова]] (611 группа).

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

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

Среди специалистов нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:
* есть <math>O(n)</math>. Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;
* в каждой строке не превышает 10 в типичном случае;
* ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.
* таково, что для данного алгоритма и вычислительной системы имеет смысл извлекать выгоду из наличия в ней нулей.

=== Хранение разреженной матрицы ===
==== Формат RR(C)O ====
Рассмотрим сначала формат '''RR(C)O'''. Сокращенное название данного формата происходит от английского словосочетания "Row - wise Representation Complete and Ordered" (строчное представление, полное и упорядоченное). В данном формате вместо одного двумерного массива, используются три одномерных. Значения ненулевых элементов матрицы и соответствующие им столбцовые индексы хранятся в этом формате по строкам в двух массивах <math>AN</math> и <math>JA</math>. Массив указателей <math>IA</math>, используется для ссылки на компоненты массивов <math>AN</math> и <math>JA</math>, с которых начинается описание очередной строки. Последняя компонента массива <math>IA</math> содержит указатель первой свободной компоненты в массивах <math>AN</math> и <math>JA</math>, т.е. равна числу ненулевых элементов матрицы, увеличенному на единицу. Здесь уместно привести пример.

Рассмотрим матрицу <math>A</math>:
:<math>\begin{pmatrix}
0 & 0 & 0 & 2 & 0 \\
1 & 0 & 3 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 \\
0 & 6 & 0 & 0 & 0 \\
0 & 0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
тогда ее представление в формате '''RR(C)O''' будет иметь вид:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 1 3 2 3 ]
AN = [ 2 1 3 6 4 ]
Т.е. массив <math>AN</math> содержит все не нулевые элементы исходной матрицы <math>A</math>, массив <math>JA</math> номер столбца в котором находится соответствующий элемент из <math>AN</math> и наконец массив <math>IA</math> содержит номер с которого начинается описание элементов в массивах <math>JA</math> и <math>AN</math>. Таким образом информация об элементах 2-ой строки матрицы хранится в элементах с <math>IA[2] = 2</math> по <math>IA[3] - 1 = 3</math> включительно массивов <math>JA</math> и <math>AN</math>. Можно обратить внимание, что <math>IA[3] = IA[4] = 4</math>, а это означает, что 3-я строка матрицы <math>A</math> нулевая.

В общем случае описание <math>r</math>-й строки матрицы A хранится в компонентах с <math>IA[r]</math> до <math>IA[r + 1] - 1</math> включительно массивов <math>AN</math> и <math>JA</math>. Если <math>IA[r + 1] = IA[r]</math>, то это означает, что <math>r</math>-я строка нулевая. Количество элементов в массиве <math>IA</math> на единицу больше, чем число строк исходной матрицы, а количество элементов в массивах <math>JA</math> и <math>AN</math> равно числу ненулевых элементов исходной матрицы.

Данный способ представления называют ''полным'', поскольку представлена вся матрица <math>A</math>, ''упорядоченным'', поскольку элементы каждой строки матрицы <math>A</math> хранятся в соответствии с возрастанием столбцовых индексов, и строчным, поскольку информация о матрице <math>A</math> указывается по строкам.

Массивы <math>IA</math> и <math>JA</math> представляют портрет (структуру) матрицы <math>A</math>, задаваемый как множество списков смежности ассоциированного с <math>A</math> графа. Если алгоритм, реализующий какую-либо операцию над разреженными матрицами, разбит на этапы символической обработки, на котором определяется портрет результирующей матрицы, и численной обработки, на котором определяются значения элементов результирующей матрицы, то массивы <math>IA</math> и <math>JA</math> заполняются на первом этапе, а массив <math>AN</math> - на втором.

==== Формат RR(C)U ====

Рассмотрим теперь формат '''RR(C)U'''.

Сокращенное название данного формата происходит от английского словосочетания "Row - wise Representation Complete and Unordered" (строчное представление, полное, но неупорядоченное). Формат '''RR(C)U''' отличается от '''RR(C)O''' тем, что в данном случае соблюдается упорядоченность строк, но внутри каждой строки элементы исходных матриц могут храниться в произвольном порядке. Для матрицы <math>A</math> нашего примера вполне можно было бы использовать и строчное представление, полное, но неупорядоченное такое:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 3 1 2 3 ]
AN = [ 2 1 3 6 4 ]
Такие неупорядоченные представления могут быть очень удобны в практических вычислениях. Результаты большинства матричных операций получаются неупорядоченными, а их упорядочение стоило бы значительных затрат машинного времени. В то же время, за немногими исключениями, алгоритмы для разреженных матриц не требуют, чтобы их представления были упорядоченными.

==== Замечания ====

Несколько замечаний по поводу рассмотренных форматов представления:
# Очевидно, что представление матрицы в формате '''RR(C)O''' так же является и представлением в формате '''RR(C)U''', но не наоборот.
# Из представления матрицы в формате '''RR(C)''' нельзя получить информацию о точном количестве столбцов исходной матрицы.
# Целесообразно (в вопросе экономии памяти) использовать представления '''RR(C)''' в случае, если матрица содержит значительное число нулевых элементов.

=== Умножение разреженной матрицы на вектор ===

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

Мы рассмотрим умножение разреженной матрицы общего вида, хранимой в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math> на заполненный вектор-столбец.

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

Исходные данные: разреженная матрица общего вида <math>A</math> с элементами <math>a_{ij}</math>, <math>i = 1,...,n</math> и <math>j = 1,...,m</math>. Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math>, <math>j =1,...,m</math>.
Вычисляемые данные:

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

2016-10-22T10:05:47Z

Blizn: Blizn переименовал страницу [[Участник:Иванов Иван/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на век…

ыыы

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

2016-10-22T10:05:29Z

Blizn: Blizn переименовал страницу Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор. 2 в [[Участник:Ива…

ыыы

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

2016-10-22T09:58:35Z

Blizn: Новая страница: «ыыы»

ыыы