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

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

2016-11-10T20:10:44Z

Sander:

= Пункт 1.7 =
'''принято'''

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

= Литература =
'''принято'''

См. именование пункта в шаблоне.

= Пункт 1.2 =
Это определение пространства Крылова?
Не совсем понятно описание алгоритма, если не знаешь, о чем речь

= Пункт 1.3 =
Он достаточно длинный. Посмотрите описания готовых алгоритмов на алговики. Псевдокод здесь не читается, ядро должно лучше восприниматься

= Пункт 1.4 =
Если макроструктура это указанные 3 пункта, то нужно пояснить, почему именно пункт 1 является ядром. Он самый ресурсоемкий?

= Пункт 1.7 =
Почему это основной ресурс. Это основная операция в алгоритме? Требуются пояснения

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

2016-11-10T20:00:07Z

Sander:

= Вклад =
'''принято''' Необходимо явно указать вклад каждого соавтора.

= Пункт 1 =
'''принято''' Все пункты должны именоваться строго по шаблону. например, первый уровень - просто: "Свойства и структура алгоритмов"

= Пункт 1.7 =
Если рисунок заимствован, надо дать ссылку на источник

'''требуется уточнить:''' рисунок собственный или откуда-то взят?

= Пункт 2 =
'''принято''' Аналогично, именование пункта д.б. по шаблону.

Основной вопрос. Ядро это все-таки умножение матрицы или строки матрицы? Соответственно под это нужно подстраивать и остальной текст, потому что можно понять и так, и так.

Обсуждение участницы:Trrufina

2016-11-10T19:56:10Z

Sander:

= Пункт 1.7 =
'''принято'''
Необходимо пояснить строение графа, он далек от классического инф. графа.
Что такое зеленый прямоугольник с "Х"?
Что вообще представляют собой элементы на схеме и стрелки?
Думается, лучше перерисовать, т.к. на этапе проверки математики алгоритма такой рисунок точно не пройдет...

Хорошая работа. Один маленький вопрос

= Пункт 1.2 =
Наиболее удобный CSR. Почему?

И, конечно, хорошо бы действительно пересчитать на однородном кластере, сделать соответствующие диаграммы, приложить код (на algowiki есть git-репозиторий).
Обратитесь к организаторам, может быть, все это возможно устроить?

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

2016-11-06T19:44:29Z

Sander:

Добрый день. Начал проверять статью и оставил следующие заметки

= 1.2 =
На мой взгляд, нужны определения
span?
l2-норма?

= 1.2.1 =
Вот я читаю этот раздел как человек со стороны и вижу много формул. Почему они именно такие? В чем суть этого алгоритма?

= 1.2.2 =
Новые определения

Затем я остановился, и у меня главные вопрос. Возможно ли сделать статью такой, чтобы для ее прочтения не требовалось обращаться к куче дополнительных источников? Вот я человек со стороны, хотя и заканчивал мехмат. Я могу разобраться со всем написанным здесь, но для этого мне придется гуглить кучу материалов. Но, насколько я понимаю, цель таких статей - быть более полными.

Можете или добавить объяснений или возразить мне. В любом случае, пока с прочтением остановился, жду ответа или исправление (а лучше и того, и другого)

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

2016-11-06T19:33:27Z

Sander:

= Вклад =
'''принято''' Необходимо явно указать вклад каждого соавтора.

= Пункт 1.7 =
'''принято''' Если рисунок заимствован, надо дать ссылку на источник.
Рисунок не заимствован.

----

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

= Пункт 1.1 =
Разреженная матрица, будучи множеством чисел, не имеющим регулярности, '''не может быть представлена в памяти машины тем же простым способом, что и полная матрица'''. Поэтому возникает необходимость дополнительно хранить индексную информацию, указывающую расположение каждого элемента в регулярном массиве.

Что означает фраза, выделенная жирным? Или как-то переформулируйте утверждение, оно не понятно

'''Однако многие схемы хранения допускают определенную долю нулей, и алгоритм обрабатывает их, как если бы они не были нулями.'''
Тоже непонятно

= Пункт 1.1.1.1 =
Поставьте определение ленточной матрицы в начало. Потому что, начиная читать первую фразу, сначала задаешься вопросом, что это такое

= Пункт 1.1.1.2 =
'''Кроме того, схема является статической, потому что включение нового элемента, лежащего вне оболочки, требует изменения всей структуры (если только не используются записи переменной длины).'''
Также нужны пояснения

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

= Пункт 1.3 =
Почему вычислительное ядро только последовательной версии?
Вычислительное ядро (computational kernel) алгоритма - это часть алгоритма, на которую приходится основное время его работы.

= Пункт 1.4 =
Наверное, вопрос в том, что алгоритм делает помимо запуска вычислительных ядер?

= Пункт 1.5 =
Как была выбрана форма хранения матрицы? Это нужно прокомментировать

= Пункт 1.7 =
Правильно я понимаю, что на рисунке изображено вычисление всего произведения матрицы на вектор? Аналогичные блоки для разных строк. А разве не должен быть рисунок, изображающий ядро (то есть произведение одной строки на вектор)?
(я не уверен, поэтому спрашиваю. Возможно, это как-то надо лучше подписать)

= Пункт 2.4 =
Пока пустой?

Участник:Sander

2016-11-06T19:23:56Z

Sander:

[http://istina.msu.ru/profile/Sander/ Смирнов Александр Владимирович], д.ф.-м.н, заведующий лаборатории Математического моделирования Научно-исследовательского вычислительного центра Московского государственного университета имени М.В.Ломоносова

Однокубитное преобразование вектора-состояния

2015-12-22T13:13:31Z

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

{{algorithm
| name = Однокубитное преобразование вектора-состояния
| serial_complexity = <math>3 \cdot 2^n</math>
| pf_height = <math>2</math>
| pf_width = <math>2^{n+1}</math>
| input_data = <math>2^n+4</math>
| output_data = <math>2^n</math>
}}

Основные авторы описания: [[Участник:Chernyavskiy|А.Ю.Чернявский]], [[Участник:VadimVV|Вад.В.Воеводин]] ([[#Описание локальности данных и вычислений|раздел 2.2]])

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

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

''Алгоритм производит моделирование действия однокубитного квантового вентиля на вектор-состояние.''
<ref>[[http://sqi.cs.msu.su/store/storage/jpvtv20_algebraic_tools.pdf|Кронберг Д. А., Ожигов Ю. И., Чернявский А. Ю. Алгебраический аппарат квантовой информатики.]]</ref>
<ref>[[http://sqi.cs.msu.su/files/book_v01.pdf|Корж О. В., Чернявский А. Ю. Практикум по суперкомпьютерным технологиям и квантовым вычислениям 3 курс.]] </ref>
<ref>Preskill J. Lecture notes for physics 229: Quantum information and computation //California Institute of Technology. – 1998.</ref>
<ref>Нильсен М., Чанг И. Квантовые вычисления и квантовая информация. – М : Мир, 2006.</ref>
Данный алгоритм обычно является подпрограммой и многократно применяется к различным кубитам одного состояния (например при моделировании квантовых алгоритмов или анализе квантовой запутанности). Особенностью алгоритма, как и большинства алгоритмов квантовой инфоорматики, является экспоненциальный рост объема данных в зависимости от основного параметра - числа кубитов, что приводит к необходимости суперкомпьютерной реализации для решения важных практических задач.

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

'''Исходные данные:'''

Целочисленные параметры <math>n - </math> число кубитов (необязательно) и <math>k -</math> номер кубита, над которым производится преобразование.

Комплексная матрица <math>U = \begin{pmatrix}
u_{00} & u_{01}\\
u_{10} & u_{11}
\end{pmatrix}</math> однокубитного преобразования размера <math>2 \times 2.</math>

Комплексный вектор <math>v</math> размерности <math>2^n,</math> задающий начальное состояние многокубитной системы.

'''Вычисляемые данные:''' комплексный вектор <math>w</math> размерности <math>2^n,</math> соответствующий состоянию после преобразования.

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

Состояние после действия преобразования <math>U</math> на <math>k-</math>й кубит имеет вид <math>v_{out} = I_{2^{k-1}}\otimes U \otimes I_{2^{n-k}},</math> где <math>I_{j} - </math> единичная матрица размерности <math>j,</math> а <math>\otimes - </math> тензорное произведение (произведение Кронекера).

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

:<math>
w_{i_1i_2\ldots i_k \ldots i_n} = \sum\limits_{j_k=0}^1 u_{i_k j} v_{i_1i_2\ldots j_k \ldots i_n} = u_{i_k 0} v_{i_1i_2\ldots 0_k \ldots i_n} + u_{i_k 1} v_{i_1i_2\ldots 1_k \ldots i_n}
</math>

Индекс-кортеж <math>i_1i_2\ldots i_n</math> представляет собой двоичную запись индекса элемента в массиве.

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

Вычислительное ядро алгоритма представляет собой независимое вычисление всех <math>2^n</math> элементов вектора <math>w.</math> Вычисление каждого элемента требует две операции умножения и одну операцию сложения. Кроме того необходимо вычислять индексы типа <math>i_1i_2\ldots 0_k \ldots i_n,</math> а также значение бита <math>i_k,</math> что требует побитовых операций.

=== Макроструктура алгоритма ===
Как записано и в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют независимые вычсиления элементов выходного вектора.

=== Схема реализации последовательного алгоритма ===
Для индекса <math>i</math> от <math>0</math> до <math>2^n-1</math>
#Вычислить элемент <math>i_k</math> двоичного представления индекса <math>i.</math>
#Вычислить индексы <math>j</math> имеющие двоичные представления <math>i_1i_2\ldots \overline{i_k} \ldots i_n,</math> где крышка означает обращение бита.
#Вычислить <math>w_i = u_{i_k i_k}\cdot v_{i} + u_{i_k \overline{i_k}}\cdot v_j.</math>

=== Последовательная сложность алгоритма ===
Алгоритм требует:
# <math>2^{n+1}</math> операций умножения комплексных чисел;
# <math>2^n</math> операций сложения комплексных чисел;
# <math>2^n</math> операций получения значения <math>k</math>-го бита числа;
# <math>2^n</math> операций изменения значения <math>k</math>-го бита числа.
Отметим, что данный алгоритм обычно применяется много раз подряд, в связи с чем вычисления, связанные с побитовыми операциями (3-4), могут однократно проводиться в начале алгоритма. Кроме того, от них можно избавиться, пользуясь сложением и логическим умножением с числом <math>2^k,</math> которое сохраняется для всего алгоритма.

=== Информационный граф ===
Представим рисунки графов алгоритма для случая <math>n=3, k=1</math> (рис.1) и <math>n=3, k=2</math> (рис.2). На графах не представлены матрицы преобразования <math>U,</math> в связи с тем, что их размер при больших <math>n</math> много меньше, нежели размеры входного и выходного векторов. На Рис.3 изображена основная операция, представляемая на Рис.1 и Рис.2 оранжевым цветом.

Отображение графа со входными и выходными данных, а также "свёрнутой" тройной операцией удобно для понимания локальности обращений к памяти.
Отметим, что структура графа (а именно обращение к входным данным) сильно зависит от параметра <math>k.</math>
[[file:OneQubitVectorTransform1.png|thumb|center|800px|Рисунок 1. Граф алгоритма для <math>n=3, k=1</math> без отображения матрицы преобразования <math>U.</math> ]]
[[file:OneQubitVectorTransform.png|thumb|center|800px|Рисунок 2. Граф алгоритма для <math>n=3, k=2</math> без отображения матрицы преобразования <math>U.</math> ]]
[[file:q_operation.png|thumb|center|300px|Рисунок 3. Граф основной операции.]]

=== Ресурс параллелизма алгоритма ===
Как видно из информационного графа, прямой алгоритм моделирования однокубитного преобразования обладает высочайшей степенью параллелизма. Все операции вычисления элементов нового вектора-состояния могут быть произведены параллельно. Для вычисления одного элемента необходимо выполнить две операции умножения и одну операцию сложения, операции умножения, в свою очередь, также могут быть выполнены параллельно.
Таким образом, необходимо выполнение двух ярусов: одного, состоящего из <math>2^{n+1}</math> умножений и другого, состоящего из <math>2^n</math> сложений.

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

* Комплексный вектор состояния <math>u</math> длины <math>2^n.</math> Обычно нормирован на единицу.
* Унитарная матрица <math>U</math> порядка <math>2</math>.
* Номер кубита <math>q</math>.

'''Выходные данные:'''
* Комплексный вектор состояния <math>w</math> длины <math>2^n</math>.

'''Объем входных данных:''' <math>2^n+4</math> комплексных чисел и <math>1</math> целочисленный параметр.

'''Объем выходных данных:''' <math>2^n</math> комплексных чисел.

=== Свойства алгоритма ===
Соотношение последовательной и параллельной сложности является ''экспоненциальным'' (эксмпонента переходит в константу).

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

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
На языке C функцию однокубитного преобразования можно записать следующим образом:

<source lang="C">
void OneQubitEvolution(complexd *in, complexd *out, complexd U[2][2], int nqubits, int q)
{
//n - число кубитов
//q - номер кубита для преобразования

int shift = nqubits-q;
//Все биты нулевые, кроме соответствующего позиции преобразуемого кубита
int pow2q=1<<(shift);

int N=1<<nqubits;
for (int i=0; i<N; i++)
{
//Обнуления меняющегося бита
int i0 = i & ~pow2q;

//Установка меняющегося бита
int i1 = i | pow2q;

//Получение значения меняющегося бита
int iq = (i & pow2q) >> shift;

out[i] = U[iq][0] * in[i0] + U[iq][1] *in[i1];
}
}
</source>

Отметим, что существенная часть вычислений и логики кода приходится на битовые операции, однако, этого можно избежать: однокубитное преобразование в большинстве случаев является лишь подпрограммой и применяется к разным кубитам большое число раз. В свою очередь, вычисляемые при помощи битовых операций индексы i0, i1 и iq зависят лишь от параметров количества кубитов n и номера кубита q. Число кубитов обычно фиксировано, соответственно, можно вычислить эти индексы заранее для всех q от 1 до n. Для хранения потребуется лишь массив целочисленных переменных линейного размера 3n в то время, как обрабатываемые данные имеют экспоненциальный размер. Очевидно, что такая оптимизация критически необходима при реализации алгоритма на вычислительных устройствах или языках программирования с отсутствием быстрых битовых операций (примером может служить среда Matlab).

=== Локальность данных и вычислений ===
К сожалению, в противовес идеальной возможности параллелизации алгоритма, практические реализации обладают очень плохой локальностью.

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

Однако, преобразование одного кубита в прикладных задачах является лишь подпрограммой и применяется многократно с различными параметрами q. Как видно из математического описания и Рис. 1-2, это полностью исключает возможность добиться локальности обращений к данным.

==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====

[[file:qubit_1.png|thumb|center|700px|Рисунок 1. Однокубитное преобразование вектора-состояния. Общий профиль обращений в память]]

На рис. 1 представлен профиль обращений в память для вычисления однокубитного преобразования вектора-состояния. Данный профиль состоит из обращений к трем массивам, фрагменты для отдельных массивов выделены на рис. 1 зеленым цветом. Из общего профиля можно увидеть, что обращения редко используются повторно, по крайней мере в случае фрагментов 2 и 3. При этом обращения к близко расположенным друг к другу данным выполняются рядом. Рассмотрим выделенные фрагменты поближе.

Отдельно фрагмент 1 представлен на рис. 2. Видно, что данный массив состоит всего из 4-х элементов, к которым постоянно выполняются обращения. Такой фрагмент обладает очень высокой локальностью, поскольку постоянно используются ранее запрошенные данные.

Далее, рассмотрим фрагмент 2 (рис. 3). Здесь все еще проще – выполняется обычный последовательный перебор всех элементов массива. Такой фрагмент обладает высокой пространственной локальностью, однако очень низкой временной (данные не используются повторно).

[[file:qubit_2.png|thumb|center|500px|Рисунок 2. Фрагмент 1 (профиль обращений к первому массиву)]]

[[file:qubit_3.png|thumb|center|500px|Рисунок 3. Фрагмент 2 (профиль обращений ко второму массиву)]]

Наиболее интересным представляется фрагмент 3. Его небольшой фрагмент, выделенный на рис. 1 желтым, представлен на рис. 4. Однако при ближайшем рассмотрении оказывается, что данный фрагмент тоже просто устроен, хотя и немного сложнее предыдущих.

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

[[file:qubit_4.png|thumb|center|500px|Рисунок 4. Небольшая часть фрагмента 3, выделенная на рис. 1 желтым]]

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

===== Количественная оценка локальности =====

Основной фрагмент реализации, на основе которого были получены количественные оценки, приведен [http://git.parallel.ru/shvets.pavel.srcc/locality/blob/master/benchmarks/qubit_evolution/qubit_evolution.h здесь] (функция Kernel). Условия запуска описаны [http://git.parallel.ru/shvets.pavel.srcc/locality/blob/master/README.md здесь].

Первая оценка выполняется на основе характеристики daps, которая оценивает число выполненных обращений (чтений и записей) в память в секунду. Данная характеристика является аналогом оценки flops применительно к работе с памятью и является в большей степени оценкой производительности взаимодействия с памятью, чем оценкой локальности. Однако она служит хорошим источником информации, в том числе для сравнения с результатами по следующей характеристике cvg.

На рисунке 5 приведены значения daps для реализаций распространенных алгоритмов, отсортированные по возрастанию (чем больше daps, тем в общем случае выше производительность). Можно увидеть, что производительность работы с памятью для этой программы высока – значение daps примерно на уровне теста Linpack. Видимо, низкая временная локальность в данном случае компенсируется высокой пространственной локальностью.

[[file:qubit_daps.png|thumb|center|700px|Рисунок 5. Сравнение значений оценки daps]]

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

На рисунке 6 приведены значения cvg для того же набора реализаций, отсортированные по убыванию (чем меньше cvg, тем в общем случае выше локальность). Можно увидеть, что, в отличие от daps, cvg оценивает локальность данной программы как достаточно низкую. В частности, значение cvg для Linpack заметно меньше, в то время как значения daps практически совпадали.

Одна из возможных причин этого – влияние арифметических операций. Может получиться, что данные из памяти не будут запрашиваться, пока арифметические операции не будут выполнены; это приводит к простою подсистемы памяти. Соответственно, если в одной программе таких операций нет, а в другой - есть, то daps в первом случае будет выше. При этом cvg не поменяется, поскольку эта оценка не зависит от времени выполнения.

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

[[file:qubit_cvg.png|thumb|center|700px|Рисунок 6. Сравнение значений оценки cvg]]

=== Возможные способы и особенности параллельной реализации алгоритма ===
Основной способ параллельной реализации очевиден - необходимо распараллеливание основного цикла (параллельное вычисление различных компонент выходного вектора-состояния) и, желательно, операций умножения. На машинах с общей памятью такой вариант распараллеливания приводит к ускорению, близкому к максимально-возможному.
Однако, данный способ сталкивается с проблемами локальности данных. Анализируя математическая описание и информационные графы алгоритма легко видеть, что при использовании большого числа узлов с собственной памятью количество необходимых пересылок между узлами становится сопоставимым с количеством вычислений, что приводит к существенной потере эффективности. Возможны разные пути частичного решения этой проблемы, например, кэширование или использование парадигмы программирования SHMEM, однако, столь сильная нелокальность использования данных всё равно не позволяет добиться хорошей эффективности.

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

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

* число процессоров [4 : 512] со значениями степени двойки;
* число кубитов [16;32] с шагом 2.

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

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

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

[[file:Qbit perf.png|thumb|center|700px|Рисунок 7. Параллельная реализация алгоритма. Изменение производительности в зависимости от числа процессоров и числа кубитов.]]
[[file:Qbit eff.png|thumb|center|700px|Рисунок 8. Параллельная реализация алгоритма. Изменение эффективности в зависимости от числа процессоров и числа кубитов.]]

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

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

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

== Литература ==
<references />

[[Категория:Статьи в работе]]

Однокубитное преобразование вектора-состояния

2015-12-22T13:10:20Z

Sander: /* Локальность данных и вычислений */

{{algorithm
| name = Однокубитное преобразование вектора-состояния
| serial_complexity = <math>3 \cdot 2^n</math>
| pf_height = <math>2</math>
| pf_width = <math>2^{n+1}</math>
| input_data = <math>2^n+4</math>
| output_data = <math>2^n</math>
}}

Основные авторы описания: [[Участник:Chernyavskiy|А.Ю.Чернявский]], [[Участник:VadimVV|Вад.В.Воеводин]] ([[#Описание локальности данных и вычислений|раздел 2.2]])

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

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

''Алгоритм производит моделирование действия однокубитного квантового вентиля на вектор-состояние.''
<ref>[[http://sqi.cs.msu.su/store/storage/jpvtv20_algebraic_tools.pdf|Кронберг Д. А., Ожигов Ю. И., Чернявский А. Ю. Алгебраический аппарат квантовой информатики.]]</ref>
<ref>[[http://sqi.cs.msu.su/files/book_v01.pdf|Корж О. В., Чернявский А. Ю. Практикум по суперкомпьютерным технологиям и квантовым вычислениям 3 курс.]] </ref>
<ref>Preskill J. Lecture notes for physics 229: Quantum information and computation //California Institute of Technology. – 1998.</ref>
<ref>Нильсен М., Чанг И. Квантовые вычисления и квантовая информация. – М : Мир, 2006.</ref>
Данный алгоритм обычно является подпрограммой и многократно применяется к различным кубитам одного состояния (например при моделировании квантовых алгоритмов или анализе квантовой запутанности). Особенностью алгоритма, как и большинства алгоритмов квантовой инфоорматики, является экспоненциальный рост объема данных в зависимости от основного параметра - числа кубитов, что приводит к необходимости суперкомпьютерной реализации для решения важных практических задач.

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

'''Исходные данные:'''

Целочисленные параметры <math>n - </math> число кубитов (необязательно) и <math>k -</math> номер кубита, над которым производится преобразование.

Комплексная матрица <math>U = \begin{pmatrix}
u_{00} & u_{01}\\
u_{10} & u_{11}
\end{pmatrix}</math> однокубитного преобразования размера <math>2 \times 2.</math>

Комплексный вектор <math>v</math> размерности <math>2^n,</math> задающий начальное состояние многокубитной системы.

'''Вычисляемые данные:''' комплексный вектор <math>w</math> размерности <math>2^n,</math> соответствующий состоянию после преобразования.

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

Состояние после действия преобразования <math>U</math> на <math>k-</math>й кубит имеет вид <math>v_{out} = I_{2^{k-1}}\otimes U \otimes I_{2^{n-k}},</math> где <math>I_{j} - </math> единичная матрица размерности <math>j,</math> а <math>\otimes - </math> тензорное произведение (произведение Кронекера).

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

:<math>
w_{i_1i_2\ldots i_k \ldots i_n} = \sum\limits_{j_k=0}^1 u_{i_k j} v_{i_1i_2\ldots j_k \ldots i_n} = u_{i_k 0} v_{i_1i_2\ldots 0_k \ldots i_n} + u_{i_k 1} v_{i_1i_2\ldots 1_k \ldots i_n}
</math>

Индекс-кортеж <math>i_1i_2\ldots i_n</math> представляет собой двоичную запись индекса элемента в массиве.

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

Вычислительное ядро алгоритма представляет собой независимое вычисление всех <math>2^n</math> элементов вектора <math>w.</math> Вычисление каждого элемента требует две операции умножения и одну операцию сложения. Кроме того необходимо вычислять индексы типа <math>i_1i_2\ldots 0_k \ldots i_n,</math> а также значение бита <math>i_k,</math> что требует побитовых операций.

=== Макроструктура алгоритма ===
Как записано и в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют независимые вычсиления элементов выходного вектора.

=== Схема реализации последовательного алгоритма ===
Для индекса <math>i</math> от <math>0</math> до <math>2^n-1</math>
#Вычислить элемент <math>i_k</math> двоичного представления индекса <math>i.</math>
#Вычислить индексы <math>j</math> имеющие двоичные представления <math>i_1i_2\ldots \overline{i_k} \ldots i_n,</math> где крышка означает обращение бита.
#Вычислить <math>w_i = u_{i_k i_k}\cdot v_{i} + u_{i_k \overline{i_k}}\cdot v_j.</math>

=== Последовательная сложность алгоритма ===
Алгоритм требует:
# <math>2^{n+1}</math> операций умножения комплексных чисел;
# <math>2^n</math> операций сложения комплексных чисел;
# <math>2^n</math> операций получения значения <math>k</math>-го бита числа;
# <math>2^n</math> операций изменения значения <math>k</math>-го бита числа.
Отметим, что данный алгоритм обычно применяется много раз подряд, в связи с чем вычисления, связанные с побитовыми операциями (3-4), могут однократно проводиться в начале алгоритма. Кроме того, от них можно избавиться, пользуясь сложением и логическим умножением с числом <math>2^k,</math> которое сохраняется для всего алгоритма.

=== Информационный граф ===
Представим рисунки графов алгоритма для случая <math>n=3, k=1</math> (рис.1) и <math>n=3, k=2</math> (рис.2). На графах не представлены матрицы преобразования <math>U,</math> в связи с тем, что их размер при больших <math>n</math> много меньше, нежели размеры входного и выходного векторов. На Рис.3 изображена основная операция, представляемая на Рис.1 и Рис.2 оранжевым цветом.

Отображение графа со входными и выходными данных, а также "свёрнутой" тройной операцией удобно для понимания локальности обращений к памяти.
Отметим, что структура графа (а именно обращение к входным данным) сильно зависит от параметра <math>k.</math>
[[file:OneQubitVectorTransform1.png|thumb|center|800px|Рисунок 1. Граф алгоритма для <math>n=3, k=1</math> без отображения матрицы преобразования <math>U.</math> ]]
[[file:OneQubitVectorTransform.png|thumb|center|800px|Рисунок 2. Граф алгоритма для <math>n=3, k=2</math> без отображения матрицы преобразования <math>U.</math> ]]
[[file:q_operation.png|thumb|center|300px|Рисунок 3. Граф основной операции.]]

=== Ресурс параллелизма алгоритма ===
Как видно из информационного графа, прямой алгоритм моделирования однокубитного преобразования обладает высочайшей степенью параллелизма. Все операции вычисления элементов нового вектора-состояния могут быть произведены параллельно. Для вычисления одного элемента необходимо выполнить две операции умножения и одну операцию сложения, операции умножения, в свою очередь, также могут быть выполнены параллельно.
Таким образом, необходимо выполнение двух ярусов: одного, состоящего из <math>2^{n+1}</math> умножений и другого, состоящего из <math>2^n</math> сложений.

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

* Комплексный вектор состояния <math>u</math> длины <math>2^n.</math> Обычно нормирован на единицу.
* Унитарная матрица <math>U</math> порядка <math>2</math>.
* Номер кубита <math>q</math>.

'''Выходные данные:'''
* Комплексный вектор состояния <math>w</math> длины <math>2^n</math>.

'''Объем входных данных:''' <math>2^n+4</math> комплексных чисел и <math>1</math> целочисленный параметр.

'''Объем выходных данных:''' <math>2^n</math> комплексных чисел.

=== Свойства алгоритма ===
Соотношение последовательной и параллельной сложности является ''экспоненциальным'' (эксмпонента переходит в константу).

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

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
На языке C функцию однокубитного преобразования можно записать следующим образом:

<source lang="C">
void OneQubitEvolution(complexd *in, complexd *out, complexd U[2][2], int nqubits, int q)
{
//n - число кубитов
//q - номер кубита для преобразования

int shift = nqubits-q;
//Все биты нулевые, кроме соответствующего позиции преобразуемого кубита
int pow2q=1<<(shift);

int N=1<<nqubits;
for (int i=0; i<N; i++)
{
//Обнуления меняющегося бита
int i0 = i & ~pow2q;

//Установка меняющегося бита
int i1 = i | pow2q;

//Получение значения меняющегося бита
int iq = (i & pow2q) >> shift;

out[i] = U[iq][0] * in[i0] + U[iq][1] *in[i1];
}
}
</source>

Отметим, что существенная часть вычислений и логики кода приходится на битовые операции, однако, этого можно избежать: однокубитное преобразование в большинстве случаев является лишь подпрограммой и применяется к разным кубитам большое число раз. В свою очередь, вычисляемые при помощи битовых операций индексы i0, i1 и iq зависят лишь от параметров количества кубитов n и номера кубита q. Число кубитов обычно фиксировано, соответственно, можно вычислить эти индексы заранее для всех q от 1 до n. Для хранения потребуется лишь массив целочисленных переменных линейного размера 3n в то время, как обрабатываемые данные имеют экспоненциальный размер. Очевидно, что такая оптимизация критически необходима при реализации алгоритма на вычислительных устройствах или языках программирования с отсутствием быстрых битовых операций (примером может служить среда Matlab).

=== Локальность данных и вычислений ===
К сожалению, в противовес идеальной возможности параллелизации алгоритма, практические реализации обладают очень плохой локальностью.

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

Однако, преобразование одного кубита в прикладных задачах является лишь подпрограммой и применяется многократно с различными параметрами q. Как видно из математического описания и Рис. 1-2, это полностью исключает возможность добиться локальности обращений к данным.

==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====

[[file:qubit_1.png|thumb|center|700px|Рисунок 1. Однокубитное преобразование вектора-состояния. Общий профиль обращений в память]]

На рис. 1 представлен профиль обращений в память для вычисления однокубитного преобразования вектора-состояния. Данный профиль состоит из обращений к трем массивам, фрагменты для отдельных массивов выделены на рис. 1 зеленым цветом. Из общего профиля можно увидеть, что обращения редко используются повторно, по крайней мере в случае фрагментов 2 и 3. При этом обращения к близко расположенным друг к другу данным выполняются рядом. Рассмотрим выделенные фрагменты поближе.

Отдельно фрагмент 1 представлен на рис. 2. Видно, что данный массив состоит всего из 4-х элементов, к которым постоянно выполняются обращения. Такой фрагмент обладает очень высокой локальностью, поскольку постоянно используются ранее запрошенные данные.

Далее, рассмотрим фрагмент 2 (рис. 3). Здесь все еще проще – выполняется обычный последовательный перебор всех элементов массива. Такой фрагмент обладает высокой пространственной локальностью, однако очень низкой временной (данные не используются повторно).

[[file:qubit_2.png|thumb|center|500px|Рисунок 2. Фрагмент 1 (профиль обращений к первому массиву)]]

[[file:qubit_3.png|thumb|center|500px|Рисунок 3. Фрагмент 2 (профиль обращений ко второму массиву)]]

Наиболее интересным представляется фрагмент 3. Его небольшой фрагмент, выделенный на рис. 1 желтым, представлен на рис. 4. Однако при ближайшем рассмотрении оказывается, что данный фрагмент тоже просто устроен, хотя и немного сложнее предыдущих.

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

[[file:qubit_4.png|thumb|center|500px|Рисунок 4. Небольшая часть фрагмента 3, выделенная на рис. 1 желтым]]

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

===== Количественная оценка локальности =====

Основной фрагмент реализации, на основе которого были получены количественные оценки, приведен [http://git.parallel.ru/shvets.pavel.srcc/locality/blob/master/benchmarks/qubit_evolution/qubit_evolution.h здесь] (функция Kernel). Условия запуска описаны [http://git.parallel.ru/shvets.pavel.srcc/locality/blob/master/README.md здесь].

Первая оценка выполняется на основе характеристики daps, которая оценивает число выполненных обращений (чтений и записей) в память в секунду. Данная характеристика является аналогом оценки flops применительно к работе с памятью и является в большей степени оценкой производительности взаимодействия с памятью, чем оценкой локальности. Однако она служит хорошим источником информации, в том числе для сравнения с результатами по следующей характеристике cvg.

На рисунке 5 приведены значения daps для реализаций распространенных алгоритмов, отсортированные по возрастанию (чем больше daps, тем в общем случае выше производительность). Можно увидеть, что производительность работы с памятью для этой программы высока – значение daps примерно на уровне теста Linpack. Видимо, низкая временная локальность в данном случае компенсируется высокой пространственной локальностью.

[[file:qubit_daps.png|thumb|center|700px|Рисунок 5. Сравнение значений оценки daps]]

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

На рисунке 6 приведены значения cvg для того же набора реализаций, отсортированные по убыванию (чем меньше cvg, тем в общем случае выше локальность). Можно увидеть, что, в отличие от daps, cvg оценивает локальность данной программы как достаточно низкую. В частности, значение cvg для Linpack заметно меньше, в то время как значения daps практически совпадали.

Одна из возможных причин этого – влияние арифметических операций. Может получиться, что данные из памяти не будут запрашиваться, пока арифметические операции не будут выполнены; это приводит к простою подсистемы памяти. Соответственно, если в одной программе таких операций нет, а в другой - есть, то daps в первом случае будет выше. При этом cvg не поменяется, поскольку эта оценка не зависит от времени выполнения.

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

[[file:qubit_cvg.png|thumb|center|700px|Рисунок 6. Сравнение значений оценки cvg]]

=== Возможные способы и особенности параллельной реализации алгоритма ===
Основной способ параллельной реализации очевиден - необходимо распараллеливание основного цикла (параллельное вычисление различных компонент выходного вектора-состояния) и, желательно, операций умножения. На машинах с общей памятью такой вариант распараллеливания приводит к ускорению, близкому к максимально-возможному.
Однако, данный способ сталкивается с проблемами локальности данных. Анализируя математическая описание и информационные графы алгоритма легко видеть, что при использовании большого числа узлов с собственной памятью количество необходимых пересылок между узлами становится сопоставимым с количеством вычислений, что приводит к существенной потере эффективности. Возможны разные пути частичного решения этой проблемы, например, кэширование или использование парадигмы программирования SHMEM, однако, столь сильная нелокальность использования данных всё равно не позволяет получить хорошей эффективности.

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

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

* число процессоров [4 : 512] со значениями степени двойки;
* число кубитов [16;32] с шагом 2.

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

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

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

[[file:Qbit perf.png|thumb|center|700px|Рисунок 7. Параллельная реализация алгоритма. Изменение производительности в зависимости от числа процессоров и числа кубитов.]]
[[file:Qbit eff.png|thumb|center|700px|Рисунок 8. Параллельная реализация алгоритма. Изменение эффективности в зависимости от числа процессоров и числа кубитов.]]

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

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

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

== Литература ==
<references />

[[Категория:Статьи в работе]]

Однокубитное преобразование вектора-состояния

2015-12-22T13:05:02Z

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

{{algorithm
| name = Однокубитное преобразование вектора-состояния
| serial_complexity = <math>3 \cdot 2^n</math>
| pf_height = <math>2</math>
| pf_width = <math>2^{n+1}</math>
| input_data = <math>2^n+4</math>
| output_data = <math>2^n</math>
}}

Основные авторы описания: [[Участник:Chernyavskiy|А.Ю.Чернявский]], [[Участник:VadimVV|Вад.В.Воеводин]] ([[#Описание локальности данных и вычислений|раздел 2.2]])

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

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

''Алгоритм производит моделирование действия однокубитного квантового вентиля на вектор-состояние.''
<ref>[[http://sqi.cs.msu.su/store/storage/jpvtv20_algebraic_tools.pdf|Кронберг Д. А., Ожигов Ю. И., Чернявский А. Ю. Алгебраический аппарат квантовой информатики.]]</ref>
<ref>[[http://sqi.cs.msu.su/files/book_v01.pdf|Корж О. В., Чернявский А. Ю. Практикум по суперкомпьютерным технологиям и квантовым вычислениям 3 курс.]] </ref>
<ref>Preskill J. Lecture notes for physics 229: Quantum information and computation //California Institute of Technology. – 1998.</ref>
<ref>Нильсен М., Чанг И. Квантовые вычисления и квантовая информация. – М : Мир, 2006.</ref>
Данный алгоритм обычно является подпрограммой и многократно применяется к различным кубитам одного состояния (например при моделировании квантовых алгоритмов или анализе квантовой запутанности). Особенностью алгоритма, как и большинства алгоритмов квантовой инфоорматики, является экспоненциальный рост объема данных в зависимости от основного параметра - числа кубитов, что приводит к необходимости суперкомпьютерной реализации для решения важных практических задач.

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

'''Исходные данные:'''

Целочисленные параметры <math>n - </math> число кубитов (необязательно) и <math>k -</math> номер кубита, над которым производится преобразование.

Комплексная матрица <math>U = \begin{pmatrix}
u_{00} & u_{01}\\
u_{10} & u_{11}
\end{pmatrix}</math> однокубитного преобразования размера <math>2 \times 2.</math>

Комплексный вектор <math>v</math> размерности <math>2^n,</math> задающий начальное состояние многокубитной системы.

'''Вычисляемые данные:''' комплексный вектор <math>w</math> размерности <math>2^n,</math> соответствующий состоянию после преобразования.

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

Состояние после действия преобразования <math>U</math> на <math>k-</math>й кубит имеет вид <math>v_{out} = I_{2^{k-1}}\otimes U \otimes I_{2^{n-k}},</math> где <math>I_{j} - </math> единичная матрица размерности <math>j,</math> а <math>\otimes - </math> тензорное произведение (произведение Кронекера).

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

:<math>
w_{i_1i_2\ldots i_k \ldots i_n} = \sum\limits_{j_k=0}^1 u_{i_k j} v_{i_1i_2\ldots j_k \ldots i_n} = u_{i_k 0} v_{i_1i_2\ldots 0_k \ldots i_n} + u_{i_k 1} v_{i_1i_2\ldots 1_k \ldots i_n}
</math>

Индекс-кортеж <math>i_1i_2\ldots i_n</math> представляет собой двоичную запись индекса элемента в массиве.

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

Вычислительное ядро алгоритма представляет собой независимое вычисление всех <math>2^n</math> элементов вектора <math>w.</math> Вычисление каждого элемента требует две операции умножения и одну операцию сложения. Кроме того необходимо вычислять индексы типа <math>i_1i_2\ldots 0_k \ldots i_n,</math> а также значение бита <math>i_k,</math> что требует побитовых операций.

=== Макроструктура алгоритма ===
Как записано и в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют независимые вычсиления элементов выходного вектора.

=== Схема реализации последовательного алгоритма ===
Для индекса <math>i</math> от <math>0</math> до <math>2^n-1</math>
#Вычислить элемент <math>i_k</math> двоичного представления индекса <math>i.</math>
#Вычислить индексы <math>j</math> имеющие двоичные представления <math>i_1i_2\ldots \overline{i_k} \ldots i_n,</math> где крышка означает обращение бита.
#Вычислить <math>w_i = u_{i_k i_k}\cdot v_{i} + u_{i_k \overline{i_k}}\cdot v_j.</math>

=== Последовательная сложность алгоритма ===
Алгоритм требует:
# <math>2^{n+1}</math> операций умножения комплексных чисел;
# <math>2^n</math> операций сложения комплексных чисел;
# <math>2^n</math> операций получения значения <math>k</math>-го бита числа;
# <math>2^n</math> операций изменения значения <math>k</math>-го бита числа.
Отметим, что данный алгоритм обычно применяется много раз подряд, в связи с чем вычисления, связанные с побитовыми операциями (3-4), могут однократно проводиться в начале алгоритма. Кроме того, от них можно избавиться, пользуясь сложением и логическим умножением с числом <math>2^k,</math> которое сохраняется для всего алгоритма.

=== Информационный граф ===
Представим рисунки графов алгоритма для случая <math>n=3, k=1</math> (рис.1) и <math>n=3, k=2</math> (рис.2). На графах не представлены матрицы преобразования <math>U,</math> в связи с тем, что их размер при больших <math>n</math> много меньше, нежели размеры входного и выходного векторов. На Рис.3 изображена основная операция, представляемая на Рис.1 и Рис.2 оранжевым цветом.

Отображение графа со входными и выходными данных, а также "свёрнутой" тройной операцией удобно для понимания локальности обращений к памяти.
Отметим, что структура графа (а именно обращение к входным данным) сильно зависит от параметра <math>k.</math>
[[file:OneQubitVectorTransform1.png|thumb|center|800px|Рисунок 1. Граф алгоритма для <math>n=3, k=1</math> без отображения матрицы преобразования <math>U.</math> ]]
[[file:OneQubitVectorTransform.png|thumb|center|800px|Рисунок 2. Граф алгоритма для <math>n=3, k=2</math> без отображения матрицы преобразования <math>U.</math> ]]
[[file:q_operation.png|thumb|center|300px|Рисунок 3. Граф основной операции.]]

=== Ресурс параллелизма алгоритма ===
Как видно из информационного графа, прямой алгоритм моделирования однокубитного преобразования обладает высочайшей степенью параллелизма. Все операции вычисления элементов нового вектора-состояния могут быть произведены параллельно. Для вычисления одного элемента необходимо выполнить две операции умножения и одну операцию сложения, операции умножения, в свою очередь, также могут быть выполнены параллельно.
Таким образом, необходимо выполнение двух ярусов: одного, состоящего из <math>2^{n+1}</math> умножений и другого, состоящего из <math>2^n</math> сложений.

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

* Комплексный вектор состояния <math>u</math> длины <math>2^n.</math> Обычно нормирован на единицу.
* Унитарная матрица <math>U</math> порядка <math>2</math>.
* Номер кубита <math>q</math>.

'''Выходные данные:'''
* Комплексный вектор состояния <math>w</math> длины <math>2^n</math>.

'''Объем входных данных:''' <math>2^n+4</math> комплексных чисел и <math>1</math> целочисленный параметр.

'''Объем выходных данных:''' <math>2^n</math> комплексных чисел.

=== Свойства алгоритма ===
Соотношение последовательной и параллельной сложности является ''экспоненциальным'' (эксмпонента переходит в константу).

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

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
На языке C функцию однокубитного преобразования можно записать следующим образом:

<source lang="C">
void OneQubitEvolution(complexd *in, complexd *out, complexd U[2][2], int nqubits, int q)
{
//n - число кубитов
//q - номер кубита для преобразования

int shift = nqubits-q;
//Все биты нулевые, кроме соответствующего позиции преобразуемого кубита
int pow2q=1<<(shift);

int N=1<<nqubits;
for (int i=0; i<N; i++)
{
//Обнуления меняющегося бита
int i0 = i & ~pow2q;

//Установка меняющегося бита
int i1 = i | pow2q;

//Получение значения меняющегося бита
int iq = (i & pow2q) >> shift;

out[i] = U[iq][0] * in[i0] + U[iq][1] *in[i1];
}
}
</source>

Отметим, что существенная часть вычислений и логики кода приходится на битовые операции, однако, этого можно избежать: однокубитное преобразование в большинстве случаев является лишь подпрограммой и применяется к разным кубитам большое число раз. В свою очередь, вычисляемые при помощи битовых операций индексы i0, i1 и iq зависят лишь от параметров количества кубитов n и номера кубита q. Число кубитов обычно фиксировано, соответственно, можно вычислить эти индексы заранее для всех q от 1 до n. Для хранения потребуется лишь массив целочисленных переменных линейного размера 3n в то время, как обрабатываемые данные имеют экспоненциальный размер. Очевидно, что такая оптимизация критически необходима при реализации алгоритма на вычислительных устройствах или языках программирования с отсутствием быстрых битовых операций (примером может служить среда Matlab).

=== Локальность данных и вычислений ===
К сожалению, в потивовес идельной возможности параллелизации алгоритма, он обладает очень плохой локальностью.

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

Однако, преобразование одного кубита в прикладных задачах является лишь подпрограммой и применяется многократно с различными параметрами q. Как видно из математического описания и Рис. 1-2, это полностью исключает возможность добиться локальности обращений к данным.

==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====

[[file:qubit_1.png|thumb|center|700px|Рисунок 1. Однокубитное преобразование вектора-состояния. Общий профиль обращений в память]]

На рис. 1 представлен профиль обращений в память для вычисления однокубитного преобразования вектора-состояния. Данный профиль состоит из обращений к трем массивам, фрагменты для отдельных массивов выделены на рис. 1 зеленым цветом. Из общего профиля можно увидеть, что обращения редко используются повторно, по крайней мере в случае фрагментов 2 и 3. При этом обращения к близко расположенным друг к другу данным выполняются рядом. Рассмотрим выделенные фрагменты поближе.

Отдельно фрагмент 1 представлен на рис. 2. Видно, что данный массив состоит всего из 4-х элементов, к которым постоянно выполняются обращения. Такой фрагмент обладает очень высокой локальностью, поскольку постоянно переиспользуются запрошенные ранее данные.

Далее рассмотрим фрагмент 2 (рис. 3). Здесь все еще проще – выполняется обычный последовательный перебор всех элементов массива. Такой фрагмент обладает высокой пространственной локальностью, однако очень низкой временной (данные просто не используются повторно).

[[file:qubit_2.png|thumb|center|500px|Рисунок 2. Фрагмент 1 (профиль обращений к первому массиву)]]

[[file:qubit_3.png|thumb|center|500px|Рисунок 3. Фрагмент 2 (профиль обращений ко второму массиву)]]

Наиболее интересным представляется фрагмент 3. Его небольшой фрагмент, выделенный на рис. 1 желтым, представлен на рис. 4. Однако при ближайшем рассмотрении оказывается, что данный фрагмент тоже просто устроен, хотя и немного сложнее предыдущих.

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

[[file:qubit_4.png|thumb|center|500px|Рисунок 4. Небольшая часть фрагмента 3, выделенная на рис. 1 желтым]]

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

===== Количественная оценка локальности =====

Основной фрагмент реализации, на основе которого были получены количественные оценки, приведен [http://git.parallel.ru/shvets.pavel.srcc/locality/blob/master/benchmarks/qubit_evolution/qubit_evolution.h здесь] (функция Kernel). Условия запуска описаны [http://git.parallel.ru/shvets.pavel.srcc/locality/blob/master/README.md здесь].

Первая оценка выполняется на основе характеристики daps, которая оценивает число выполненных обращений (чтений и записей) в память в секунду. Данная характеристика является аналогом оценки flops применительно к работе с памятью и является в большей степени оценкой производительности взаимодействия с памятью, чем оценкой локальности. Однако она служит хорошим источником информации, в том числе для сравнения с результатами по следующей характеристике cvg.

На рисунке 5 приведены значения daps для реализаций распространенных алгоритмов, отсортированные по возрастанию (чем больше daps, тем в общем случае выше производительность). Можно увидеть, что производительность работы с памятью для этой программы высока – значение daps примерно на уровне теста Linpack. Видимо, низкая временная локальность в данном случае компенсируется высокой пространственной локальностью.

[[file:qubit_daps.png|thumb|center|700px|Рисунок 5. Сравнение значений оценки daps]]

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

На рисунке 6 приведены значения cvg для того же набора реализаций, отсортированные по убыванию (чем меньше cvg, тем в общем случае выше локальность). Можно увидеть, что, в отличие от daps, cvg оценивает локальность данной программы как достаточно низкую. В частности, значение cvg для Linpack заметно меньше, в то время как значения daps практически совпадали.

Одна из возможных причин этого – влияние арифметических операций. Может получиться, что данные из памяти не будут запрашиваться, пока арифметические операции не будут выполнены; это приводит к простою подсистемы памяти. Соответственно, если в одной программе таких операций нет, а в другой - есть, то daps в первом случае будет выше. При этом cvg не поменяется, поскольку эта оценка не зависит от времени выполнения.

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

[[file:qubit_cvg.png|thumb|center|700px|Рисунок 6. Сравнение значений оценки cvg]]

=== Возможные способы и особенности параллельной реализации алгоритма ===
Основной способ параллельной реализации очевиден - необходимо распараллеливание основного цикла (параллельное вычисление различных компонент выходного вектора-состояния) и, желательно, операций умножения. На машинах с общей памятью такой вариант распараллеливания приводит к ускорению, близкому к максимально-возможному.
Однако, данный способ сталкивается с проблемами локальности данных. Анализируя математическая описание и информационные графы алгоритма легко видеть, что при использовании большого числа узлов с собственной памятью количество необходимых пересылок между узлами становится сопоставимым с количеством вычислений, что приводит к существенной потере эффективности. Возможны разные пути частичного решения этой проблемы, например, кэширование или использование парадигмы программирования SHMEM, однако, столь сильная нелокальность использования данных всё равно не позволяет получить хорошей эффективности.

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

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

* число процессоров [4 : 512] со значениями степени двойки;
* число кубитов [16;32] с шагом 2.

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

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

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

[[file:Qbit perf.png|thumb|center|700px|Рисунок 7. Параллельная реализация алгоритма. Изменение производительности в зависимости от числа процессоров и числа кубитов.]]
[[file:Qbit eff.png|thumb|center|700px|Рисунок 8. Параллельная реализация алгоритма. Изменение эффективности в зависимости от числа процессоров и числа кубитов.]]

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

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

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

== Литература ==
<references />

[[Категория:Статьи в работе]]

Однокубитное преобразование вектора-состояния

2015-12-22T13:04:10Z

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

{{algorithm
| name = Однокубитное преобразование вектора-состояния
| serial_complexity = <math>3 \cdot 2^n</math>
| pf_height = <math>2</math>
| pf_width = <math>2^{n+1}</math>
| input_data = <math>2^n+4</math>
| output_data = <math>2^n</math>
}}

Основные авторы описания: [[Участник:Chernyavskiy|А.Ю.Чернявский]], [[Участник:VadimVV|Вад.В.Воеводин]] ([[#Описание локальности данных и вычислений|раздел 2.2]])

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

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

''Алгоритм производит моделирование действия однокубитного квантового вентиля на вектор-состояние.''
<ref>[[http://sqi.cs.msu.su/store/storage/jpvtv20_algebraic_tools.pdf|Кронберг Д. А., Ожигов Ю. И., Чернявский А. Ю. Алгебраический аппарат квантовой информатики.]]</ref>
<ref>[[http://sqi.cs.msu.su/files/book_v01.pdf|Корж О. В., Чернявский А. Ю. Практикум по суперкомпьютерным технологиям и квантовым вычислениям 3 курс.]] </ref>
<ref>Preskill J. Lecture notes for physics 229: Quantum information and computation //California Institute of Technology. – 1998.</ref>
<ref>Нильсен М., Чанг И. Квантовые вычисления и квантовая информация. – М : Мир, 2006.</ref>
Данный алгоритм обычно является подпрограммой и многократно применяется к различным кубитам одного состояния (например при моделировании квантовых алгоритмов или анализе квантовой запутанности). Особенностью алгоритма, как и большинства алгоритмов квантовой инфоорматики, является экспоненциальный рост объема данных в зависимости от основного параметра - числа кубитов, что приводит к необходимости суперкомпьютерной реализации для решения важных практических задач.

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

'''Исходные данные:'''

Целочисленные параметры <math>n - </math> число кубитов (необязательно) и <math>k -</math> номер кубита, над которым производится преобразование.

Комплексная матрица <math>U = \begin{pmatrix}
u_{00} & u_{01}\\
u_{10} & u_{11}
\end{pmatrix}</math> однокубитного преобразования размера <math>2 \times 2.</math>

Комплексный вектор <math>v</math> размерности <math>2^n,</math> задающий начальное состояние многокубитной системы.

'''Вычисляемые данные:''' комплексный вектор <math>w</math> размерности <math>2^n,</math> соответствующий состоянию после преобразования.

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

Состояние после действия преобразования <math>U</math> на <math>k-</math>й кубит имеет вид <math>v_{out} = I_{2^{k-1}}\otimes U \otimes I_{2^{n-k}},</math> где <math>I_{j} - </math> единичная матрица размерности <math>j,</math> а <math>\otimes - </math> тензорное произведение (произведение Кронекера).

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

:<math>
w_{i_1i_2\ldots i_k \ldots i_n} = \sum\limits_{j_k=0}^1 u_{i_k j} v_{i_1i_2\ldots j_k \ldots i_n} = u_{i_k 0} v_{i_1i_2\ldots 0_k \ldots i_n} + u_{i_k 1} v_{i_1i_2\ldots 1_k \ldots i_n}
</math>

Индекс-кортеж <math>i_1i_2\ldots i_n</math> представляет собой двоичную запись индекса элемента в массиве.

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

Вычислительное ядро алгоритма представляет собой независимое вычисление всех <math>2^n</math> элементов вектора <math>w.</math> Вычисление каждого элемента требует две операции умножения и одну операцию сложения. Кроме того необходимо вычислять индексы типа <math>i_1i_2\ldots 0_k \ldots i_n,</math> а также значение бита <math>i_k,</math> что требует побитовых операций.

=== Макроструктура алгоритма ===
Как записано и в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют независимые вычсиления элементов выходного вектора.

=== Схема реализации последовательного алгоритма ===
Для индекса <math>i</math> от <math>0</math> до <math>2^n-1</math>
#Вычислить элемент <math>i_k</math> двоичного представления индекса <math>i.</math>
#Вычислить индексы <math>j</math> имеющие двоичные представления <math>i_1i_2\ldots \overline{i_k} \ldots i_n,</math> где крышка означает обращение бита.
#Вычислить <math>w_i = u_{i_k i_k}\cdot v_{i} + u_{i_k \overline{i_k}}\cdot v_j.</math>

=== Последовательная сложность алгоритма ===
Алгоритм требует:
# <math>2^{n+1}</math> операций умножения комплексных чисел;
# <math>2^n</math> операций сложения комплексных чисел;
# <math>2^n</math> операций получения значения <math>k</math>-го бита числа;
# <math>2^n</math> операций изменения значения <math>k</math>-го бита числа.
Отметим, что данный алгоритм обычно применяется много раз подряд, в связи с чем вычисления, связанные с побитовыми операциями (3-4), могут однократно проводиться в начале алгоритма. Кроме того, от них можно избавиться, пользуясь сложением и логическим умножением с числом <math>2^k,</math> которое сохраняется для всего алгоритма.

=== Информационный граф ===
Представим рисунки графов алгоритма для случая <math>n=3, k=1</math> (рис.1) и <math>k=2</math> (рис.2). На графах не представлены матрицы преобразования <math>U,</math> в связи с тем, что их размер при больших <math>n</math> много меньше, нежели размеры входного и выходного векторов. На Рис.3 изображена основная операция, представляемая на Рис.1 и Рис.2 оранжевым.

Отображение графа со входными и выходными данных, а также "свёрнутой" тройной операцией удобно для понимания локальности обращений к памяти.
Отметим, что структура графа (а именно обращение к входным данным) сильно зависит от параметра <math>k.</math>
[[file:OneQubitVectorTransform1.png|thumb|center|800px|Рисунок 1. Граф алгоритма для <math>n=3, k=1</math> без отображения матрицы преобразования <math>U.</math> ]]
[[file:OneQubitVectorTransform.png|thumb|center|800px|Рисунок 2. Граф алгоритма для <math>n=3, k=2</math> без отображения матрицы преобразования <math>U.</math> ]]
[[file:q_operation.png|thumb|center|300px|Рисунок 3. Граф основной операции.]]

=== Ресурс параллелизма алгоритма ===
Как видно из информационного графа, прямой алгоритм моделирования однокубитного преобразования обладает высочайшей степенью параллелизма. Все операции вычисления элементов нового вектора-состояния могут быть произведены параллельно. Для вычисления одного элемента необходимо выполнить две операции умножения и одну операцию сложения, операции умножения, в свою очередь, также могут быть выполнены параллельно.
Таким образом, необходимо выполнение двух ярусов: одного, состоящего из <math>2^{n+1}</math> умножений и другого, состоящего из <math>2^n</math> сложений.

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

* Комплексный вектор состояния <math>u</math> длины <math>2^n.</math> Обычно нормирован на единицу.
* Унитарная матрица <math>U</math> порядка <math>2</math>.
* Номер кубита <math>q</math>.

'''Выходные данные:'''
* Комплексный вектор состояния <math>w</math> длины <math>2^n</math>.

'''Объем входных данных:''' <math>2^n+4</math> комплексных чисел и <math>1</math> целочисленный параметр.

'''Объем выходных данных:''' <math>2^n</math> комплексных чисел.

=== Свойства алгоритма ===
Соотношение последовательной и параллельной сложности является ''экспоненциальным'' (эксмпонента переходит в константу).

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

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
На языке C функцию однокубитного преобразования можно записать следующим образом:

<source lang="C">
void OneQubitEvolution(complexd *in, complexd *out, complexd U[2][2], int nqubits, int q)
{
//n - число кубитов
//q - номер кубита для преобразования

int shift = nqubits-q;
//Все биты нулевые, кроме соответствующего позиции преобразуемого кубита
int pow2q=1<<(shift);

int N=1<<nqubits;
for (int i=0; i<N; i++)
{
//Обнуления меняющегося бита
int i0 = i & ~pow2q;

//Установка меняющегося бита
int i1 = i | pow2q;

//Получение значения меняющегося бита
int iq = (i & pow2q) >> shift;

out[i] = U[iq][0] * in[i0] + U[iq][1] *in[i1];
}
}
</source>

Отметим, что существенная часть вычислений и логики кода приходится на битовые операции, однако, этого можно избежать: однокубитное преобразование в большинстве случаев является лишь подпрограммой и применяется к разным кубитам большое число раз. В свою очередь, вычисляемые при помощи битовых операций индексы i0, i1 и iq зависят лишь от параметров количества кубитов n и номера кубита q. Число кубитов обычно фиксировано, соответственно, можно вычислить эти индексы заранее для всех q от 1 до n. Для хранения потребуется лишь массив целочисленных переменных линейного размера 3n в то время, как обрабатываемые данные имеют экспоненциальный размер. Очевидно, что такая оптимизация критически необходима при реализации алгоритма на вычислительных устройствах или языках программирования с отсутствием быстрых битовых операций (примером может служить среда Matlab).

=== Локальность данных и вычислений ===
К сожалению, в потивовес идельной возможности параллелизации алгоритма, он обладает очень плохой локальностью.

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

Однако, преобразование одного кубита в прикладных задачах является лишь подпрограммой и применяется многократно с различными параметрами q. Как видно из математического описания и Рис. 1-2, это полностью исключает возможность добиться локальности обращений к данным.

==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====

[[file:qubit_1.png|thumb|center|700px|Рисунок 1. Однокубитное преобразование вектора-состояния. Общий профиль обращений в память]]

На рис. 1 представлен профиль обращений в память для вычисления однокубитного преобразования вектора-состояния. Данный профиль состоит из обращений к трем массивам, фрагменты для отдельных массивов выделены на рис. 1 зеленым цветом. Из общего профиля можно увидеть, что обращения редко используются повторно, по крайней мере в случае фрагментов 2 и 3. При этом обращения к близко расположенным друг к другу данным выполняются рядом. Рассмотрим выделенные фрагменты поближе.

Отдельно фрагмент 1 представлен на рис. 2. Видно, что данный массив состоит всего из 4-х элементов, к которым постоянно выполняются обращения. Такой фрагмент обладает очень высокой локальностью, поскольку постоянно переиспользуются запрошенные ранее данные.

Далее рассмотрим фрагмент 2 (рис. 3). Здесь все еще проще – выполняется обычный последовательный перебор всех элементов массива. Такой фрагмент обладает высокой пространственной локальностью, однако очень низкой временной (данные просто не используются повторно).

[[file:qubit_2.png|thumb|center|500px|Рисунок 2. Фрагмент 1 (профиль обращений к первому массиву)]]

[[file:qubit_3.png|thumb|center|500px|Рисунок 3. Фрагмент 2 (профиль обращений ко второму массиву)]]

Наиболее интересным представляется фрагмент 3. Его небольшой фрагмент, выделенный на рис. 1 желтым, представлен на рис. 4. Однако при ближайшем рассмотрении оказывается, что данный фрагмент тоже просто устроен, хотя и немного сложнее предыдущих.

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

[[file:qubit_4.png|thumb|center|500px|Рисунок 4. Небольшая часть фрагмента 3, выделенная на рис. 1 желтым]]

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

===== Количественная оценка локальности =====

Основной фрагмент реализации, на основе которого были получены количественные оценки, приведен [http://git.parallel.ru/shvets.pavel.srcc/locality/blob/master/benchmarks/qubit_evolution/qubit_evolution.h здесь] (функция Kernel). Условия запуска описаны [http://git.parallel.ru/shvets.pavel.srcc/locality/blob/master/README.md здесь].

Первая оценка выполняется на основе характеристики daps, которая оценивает число выполненных обращений (чтений и записей) в память в секунду. Данная характеристика является аналогом оценки flops применительно к работе с памятью и является в большей степени оценкой производительности взаимодействия с памятью, чем оценкой локальности. Однако она служит хорошим источником информации, в том числе для сравнения с результатами по следующей характеристике cvg.

На рисунке 5 приведены значения daps для реализаций распространенных алгоритмов, отсортированные по возрастанию (чем больше daps, тем в общем случае выше производительность). Можно увидеть, что производительность работы с памятью для этой программы высока – значение daps примерно на уровне теста Linpack. Видимо, низкая временная локальность в данном случае компенсируется высокой пространственной локальностью.

[[file:qubit_daps.png|thumb|center|700px|Рисунок 5. Сравнение значений оценки daps]]

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

На рисунке 6 приведены значения cvg для того же набора реализаций, отсортированные по убыванию (чем меньше cvg, тем в общем случае выше локальность). Можно увидеть, что, в отличие от daps, cvg оценивает локальность данной программы как достаточно низкую. В частности, значение cvg для Linpack заметно меньше, в то время как значения daps практически совпадали.

Одна из возможных причин этого – влияние арифметических операций. Может получиться, что данные из памяти не будут запрашиваться, пока арифметические операции не будут выполнены; это приводит к простою подсистемы памяти. Соответственно, если в одной программе таких операций нет, а в другой - есть, то daps в первом случае будет выше. При этом cvg не поменяется, поскольку эта оценка не зависит от времени выполнения.

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

[[file:qubit_cvg.png|thumb|center|700px|Рисунок 6. Сравнение значений оценки cvg]]

=== Возможные способы и особенности параллельной реализации алгоритма ===
Основной способ параллельной реализации очевиден - необходимо распараллеливание основного цикла (параллельное вычисление различных компонент выходного вектора-состояния) и, желательно, операций умножения. На машинах с общей памятью такой вариант распараллеливания приводит к ускорению, близкому к максимально-возможному.
Однако, данный способ сталкивается с проблемами локальности данных. Анализируя математическая описание и информационные графы алгоритма легко видеть, что при использовании большого числа узлов с собственной памятью количество необходимых пересылок между узлами становится сопоставимым с количеством вычислений, что приводит к существенной потере эффективности. Возможны разные пути частичного решения этой проблемы, например, кэширование или использование парадигмы программирования SHMEM, однако, столь сильная нелокальность использования данных всё равно не позволяет получить хорошей эффективности.

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

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

* число процессоров [4 : 512] со значениями степени двойки;
* число кубитов [16;32] с шагом 2.

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

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

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

[[file:Qbit perf.png|thumb|center|700px|Рисунок 7. Параллельная реализация алгоритма. Изменение производительности в зависимости от числа процессоров и числа кубитов.]]
[[file:Qbit eff.png|thumb|center|700px|Рисунок 8. Параллельная реализация алгоритма. Изменение эффективности в зависимости от числа процессоров и числа кубитов.]]

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

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

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

== Литература ==
<references />

[[Категория:Статьи в работе]]

Однокубитное преобразование вектора-состояния

2015-12-22T12:53:38Z

Sander: /* Математическое описание алгоритма */

{{algorithm
| name = Однокубитное преобразование вектора-состояния
| serial_complexity = <math>3 \cdot 2^n</math>
| pf_height = <math>2</math>
| pf_width = <math>2^{n+1}</math>
| input_data = <math>2^n+4</math>
| output_data = <math>2^n</math>
}}

Основные авторы описания: [[Участник:Chernyavskiy|А.Ю.Чернявский]], [[Участник:VadimVV|Вад.В.Воеводин]] ([[#Описание локальности данных и вычислений|раздел 2.2]])

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

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

''Алгоритм производит моделирование действия однокубитного квантового вентиля на вектор-состояние.''
<ref>[[http://sqi.cs.msu.su/store/storage/jpvtv20_algebraic_tools.pdf|Кронберг Д. А., Ожигов Ю. И., Чернявский А. Ю. Алгебраический аппарат квантовой информатики.]]</ref>
<ref>[[http://sqi.cs.msu.su/files/book_v01.pdf|Корж О. В., Чернявский А. Ю. Практикум по суперкомпьютерным технологиям и квантовым вычислениям 3 курс.]] </ref>
<ref>Preskill J. Lecture notes for physics 229: Quantum information and computation //California Institute of Technology. – 1998.</ref>
<ref>Нильсен М., Чанг И. Квантовые вычисления и квантовая информация. – М : Мир, 2006.</ref>
Данный алгоритм обычно является подпрограммой и многократно применяется к различным кубитам одного состояния (например при моделировании квантовых алгоритмов или анализе квантовой запутанности). Особенностью алгоритма, как и большинства алгоритмов квантовой инфоорматики, является экспоненциальный рост объема данных в зависимости от основного параметра - числа кубитов, что приводит к необходимости суперкомпьютерной реализации для решения важных практических задач.

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

'''Исходные данные:'''

Целочисленные параметры <math>n - </math> число кубитов (необязательно) и <math>k -</math> номер кубита, над которым производится преобразование.

Комплексная матрица <math>U = \begin{pmatrix}
u_{00} & u_{01}\\
u_{10} & u_{11}
\end{pmatrix}</math> однокубитного преобразования размера <math>2 \times 2.</math>

Комплексный вектор <math>v</math> размерности <math>2^n,</math> задающий начальное состояние многокубитной системы.

'''Вычисляемые данные:''' комплексный вектор <math>w</math> размерности <math>2^n,</math> соответствующий состоянию после преобразования.

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

Состояние после действия преобразования <math>U</math> на <math>k-</math>й кубит имеет вид <math>v_{out} = I_{2^{k-1}}\otimes U \otimes I_{2^{n-k}},</math> где <math>I_{j} - </math> единичная матрица размерности <math>j,</math> а <math>\otimes - </math> тензорное произведение (произведение Кронекера).

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

:<math>
w_{i_1i_2\ldots i_k \ldots i_n} = \sum\limits_{j_k=0}^1 u_{i_k j} v_{i_1i_2\ldots j_k \ldots i_n} = u_{i_k 0} v_{i_1i_2\ldots 0_k \ldots i_n} + u_{i_k 1} v_{i_1i_2\ldots 1_k \ldots i_n}
</math>

Индекс-кортеж <math>i_1i_2\ldots i_n</math> представляет собой двоичную запись индекса элемента в массиве.

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

Вычислительное ядро алгоритма представляет собой независимое вычисление всех <math>2^n</math> элементов вектора <math>w.</math> Вычисление каждого элемента требует две операции умножения и одну операцию сложения. Кроме того необходимо вычислять индексы типа <math>i_1i_2\ldots 0_k \ldots i_n,</math> а также значение бита <math>i_k,</math> что требует побитовых операций.

=== Макроструктура алгоритма ===
Как записано и в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют независимые вычсиления элементов выходного вектора.

=== Схема реализации последовательного алгоритма ===
Для индекса <math>i</math> от <math>0</math> до <math>2^n-1</math>
#Вычислить элемент <math>i_k</math> двоичного представления индекса <math>i.</math>
#Вычислить индексы <math>j</math> имеющие двоичные представления <math>i_1i_2\ldots \overline{i_k} \ldots i_n,</math> где крышка означает обращение бита.
#Вычислить <math>w_i = u_{i_k i_k}\cdot v_{i} + u_{i_k \overline{i_k}}\cdot v_j.</math>

=== Последовательная сложность алгоритма ===
Алгоритм требует:
# <math>2^{n+1}</math> операций умножения комплексных чисел;
# <math>2^n</math> операций сложения комплексных чисел;
# <math>2^n</math> операций получения значения <math>k</math>-го бита числа;
# <math>2^n</math> операций изменения значения <math>k</math>-го бита числа.
Отметим, что данный алгоритм обычно применяется много раз подряд, в связи с чем вычисления, связанные с побитовыми операциями (3-4), могут единожды проводиться в начале алгоритма. Кроме того, от них можно избавиться, пользуясь сложением и логическим умножением с числом <math>2^k,</math> которое сохраняется для всего алгоритма.

=== Информационный граф ===
Представим рисунки графов алгоритма для случая <math>n=3, k=1</math> (рис.1) и <math>k=2</math> (рис.2). На графах не представлены матрицы преобразования <math>U,</math> в связи с тем, что их размер при больших <math>n</math> много меньше, нежели размеры входного и выходного векторов. На Рис.3 изображена основная операция, представляемая на Рис.1 и Рис.2 оранжевым.

Отображение графа со входными и выходными данных, а также "свёрнутой" тройной операцией удобно для понимания локальности обращений к памяти.
Отметим, что структура графа (а именно обращение к входным данным) сильно зависит от параметра <math>k.</math>
[[file:OneQubitVectorTransform1.png|thumb|center|800px|Рисунок 1. Граф алгоритма для <math>n=3, k=1</math> без отображения матрицы преобразования <math>U.</math> ]]
[[file:OneQubitVectorTransform.png|thumb|center|800px|Рисунок 2. Граф алгоритма для <math>n=3, k=2</math> без отображения матрицы преобразования <math>U.</math> ]]
[[file:q_operation.png|thumb|center|300px|Рисунок 3. Граф основной операции.]]

=== Ресурс параллелизма алгоритма ===
Как видно из информационного графа, прямой алгоритм моделирования однокубитного преобразования обладает высочайшей степенью параллелизма. Все операции вычисления элементов нового вектора-состояния могут быть произведены параллельно. Для вычисления одного элемента необходимо выполнить две операции умножения и одну операцию сложения, операции умножения, в свою очередь, также могут быть выполнены параллельно.
Таким образом, необходимо выполнение двух ярусов: одного, состоящего из <math>2^{n+1}</math> умножений и другого, состоящего из <math>2^n</math> сложений.

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

* Комплексный вектор состояния <math>u</math> длины <math>2^n.</math> Обычно нормирован на единицу.
* Унитарная матрица <math>U</math> порядка <math>2</math>.
* Номер кубита <math>q</math>.

'''Выходные данные:'''
* Комплексный вектор состояния <math>w</math> длины <math>2^n</math>.

'''Объем входных данных:''' <math>2^n+4</math> комплексных чисел и <math>1</math> целочисленный параметр.

'''Объем выходных данных:''' <math>2^n</math> комплексных чисел.

=== Свойства алгоритма ===
Соотношение последовательной и параллельной сложности является ''экспоненциальным'' (эксмпонента переходит в константу).

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

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
На языке C функцию однокубитного преобразования можно записать следующим образом:

<source lang="C">
void OneQubitEvolution(complexd *in, complexd *out, complexd U[2][2], int nqubits, int q)
{
//n - число кубитов
//q - номер кубита для преобразования

int shift = nqubits-q;
//Все биты нулевые, кроме соответствующего позиции преобразуемого кубита
int pow2q=1<<(shift);

int N=1<<nqubits;
for (int i=0; i<N; i++)
{
//Обнуления меняющегося бита
int i0 = i & ~pow2q;

//Установка меняющегося бита
int i1 = i | pow2q;

//Получение значения меняющегося бита
int iq = (i & pow2q) >> shift;

out[i] = U[iq][0] * in[i0] + U[iq][1] *in[i1];
}
}
</source>

Отметим, что существенная часть вычислений и логики кода приходится на битовые операции, однако, этого можно избежать: однокубитное преобразование в большинстве случаев является лишь подпрограммой и применяется к разным кубитам большое число раз. В свою очередь, вычисляемые при помощи битовых операций индексы i0, i1 и iq зависят лишь от параметров количества кубитов n и номера кубита q. Число кубитов обычно фиксировано, соответственно, можно вычислить эти индексы заранее для всех q от 1 до n. Для хранения потребуется лишь массив целочисленных переменных линейного размера 3n в то время, как обрабатываемые данные имеют экспоненциальный размер. Очевидно, что такая оптимизация критически необходима при реализации алгоритма на вычислительных устройствах или языках программирования с отсутствием быстрых битовых операций (примером может служить среда Matlab).

=== Локальность данных и вычислений ===
К сожалению, в потивовес идельной возможности параллелизации алгоритма, он обладает очень плохой локальностью.

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

Однако, преобразование одного кубита в прикладных задачах является лишь подпрограммой и применяется многократно с различными параметрами q. Как видно из математического описания и Рис. 1-2, это полностью исключает возможность добиться локальности обращений к данным.

==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====

[[file:qubit_1.png|thumb|center|700px|Рисунок 1. Однокубитное преобразование вектора-состояния. Общий профиль обращений в память]]

На рис. 1 представлен профиль обращений в память для вычисления однокубитного преобразования вектора-состояния. Данный профиль состоит из обращений к трем массивам, фрагменты для отдельных массивов выделены на рис. 1 зеленым цветом. Из общего профиля можно увидеть, что обращения редко используются повторно, по крайней мере в случае фрагментов 2 и 3. При этом обращения к близко расположенным друг к другу данным выполняются рядом. Рассмотрим выделенные фрагменты поближе.

Отдельно фрагмент 1 представлен на рис. 2. Видно, что данный массив состоит всего из 4-х элементов, к которым постоянно выполняются обращения. Такой фрагмент обладает очень высокой локальностью, поскольку постоянно переиспользуются запрошенные ранее данные.

Далее рассмотрим фрагмент 2 (рис. 3). Здесь все еще проще – выполняется обычный последовательный перебор всех элементов массива. Такой фрагмент обладает высокой пространственной локальностью, однако очень низкой временной (данные просто не используются повторно).

[[file:qubit_2.png|thumb|center|500px|Рисунок 2. Фрагмент 1 (профиль обращений к первому массиву)]]

[[file:qubit_3.png|thumb|center|500px|Рисунок 3. Фрагмент 2 (профиль обращений ко второму массиву)]]

Наиболее интересным представляется фрагмент 3. Его небольшой фрагмент, выделенный на рис. 1 желтым, представлен на рис. 4. Однако при ближайшем рассмотрении оказывается, что данный фрагмент тоже просто устроен, хотя и немного сложнее предыдущих.

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

[[file:qubit_4.png|thumb|center|500px|Рисунок 4. Небольшая часть фрагмента 3, выделенная на рис. 1 желтым]]

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

===== Количественная оценка локальности =====

Основной фрагмент реализации, на основе которого были получены количественные оценки, приведен [http://git.parallel.ru/shvets.pavel.srcc/locality/blob/master/benchmarks/qubit_evolution/qubit_evolution.h здесь] (функция Kernel). Условия запуска описаны [http://git.parallel.ru/shvets.pavel.srcc/locality/blob/master/README.md здесь].

Первая оценка выполняется на основе характеристики daps, которая оценивает число выполненных обращений (чтений и записей) в память в секунду. Данная характеристика является аналогом оценки flops применительно к работе с памятью и является в большей степени оценкой производительности взаимодействия с памятью, чем оценкой локальности. Однако она служит хорошим источником информации, в том числе для сравнения с результатами по следующей характеристике cvg.

На рисунке 5 приведены значения daps для реализаций распространенных алгоритмов, отсортированные по возрастанию (чем больше daps, тем в общем случае выше производительность). Можно увидеть, что производительность работы с памятью для этой программы высока – значение daps примерно на уровне теста Linpack. Видимо, низкая временная локальность в данном случае компенсируется высокой пространственной локальностью.

[[file:qubit_daps.png|thumb|center|700px|Рисунок 5. Сравнение значений оценки daps]]

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

На рисунке 6 приведены значения cvg для того же набора реализаций, отсортированные по убыванию (чем меньше cvg, тем в общем случае выше локальность). Можно увидеть, что, в отличие от daps, cvg оценивает локальность данной программы как достаточно низкую. В частности, значение cvg для Linpack заметно меньше, в то время как значения daps практически совпадали.

Одна из возможных причин этого – влияние арифметических операций. Может получиться, что данные из памяти не будут запрашиваться, пока арифметические операции не будут выполнены; это приводит к простою подсистемы памяти. Соответственно, если в одной программе таких операций нет, а в другой - есть, то daps в первом случае будет выше. При этом cvg не поменяется, поскольку эта оценка не зависит от времени выполнения.

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

[[file:qubit_cvg.png|thumb|center|700px|Рисунок 6. Сравнение значений оценки cvg]]

=== Возможные способы и особенности параллельной реализации алгоритма ===
Основной способ параллельной реализации очевиден - необходимо распараллеливание основного цикла (параллельное вычисление различных компонент выходного вектора-состояния) и, желательно, операций умножения. На машинах с общей памятью такой вариант распараллеливания приводит к ускорению, близкому к максимально-возможному.
Однако, данный способ сталкивается с проблемами локальности данных. Анализируя математическая описание и информационные графы алгоритма легко видеть, что при использовании большого числа узлов с собственной памятью количество необходимых пересылок между узлами становится сопоставимым с количеством вычислений, что приводит к существенной потере эффективности. Возможны разные пути частичного решения этой проблемы, например, кэширование или использование парадигмы программирования SHMEM, однако, столь сильная нелокальность использования данных всё равно не позволяет получить хорошей эффективности.

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

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

* число процессоров [4 : 512] со значениями степени двойки;
* число кубитов [16;32] с шагом 2.

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

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

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

[[file:Qbit perf.png|thumb|center|700px|Рисунок 7. Параллельная реализация алгоритма. Изменение производительности в зависимости от числа процессоров и числа кубитов.]]
[[file:Qbit eff.png|thumb|center|700px|Рисунок 8. Параллельная реализация алгоритма. Изменение эффективности в зависимости от числа процессоров и числа кубитов.]]

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

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

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

== Литература ==
<references />

[[Категория:Статьи в работе]]

Однокубитное преобразование вектора-состояния

2015-12-22T12:52:47Z

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

{{algorithm
| name = Однокубитное преобразование вектора-состояния
| serial_complexity = <math>3 \cdot 2^n</math>
| pf_height = <math>2</math>
| pf_width = <math>2^{n+1}</math>
| input_data = <math>2^n+4</math>
| output_data = <math>2^n</math>
}}

Основные авторы описания: [[Участник:Chernyavskiy|А.Ю.Чернявский]], [[Участник:VadimVV|Вад.В.Воеводин]] ([[#Описание локальности данных и вычислений|раздел 2.2]])

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

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

''Алгоритм производит моделирование действия однокубитного квантового вентиля на вектор-состояние.''
<ref>[[http://sqi.cs.msu.su/store/storage/jpvtv20_algebraic_tools.pdf|Кронберг Д. А., Ожигов Ю. И., Чернявский А. Ю. Алгебраический аппарат квантовой информатики.]]</ref>
<ref>[[http://sqi.cs.msu.su/files/book_v01.pdf|Корж О. В., Чернявский А. Ю. Практикум по суперкомпьютерным технологиям и квантовым вычислениям 3 курс.]] </ref>
<ref>Preskill J. Lecture notes for physics 229: Quantum information and computation //California Institute of Technology. – 1998.</ref>
<ref>Нильсен М., Чанг И. Квантовые вычисления и квантовая информация. – М : Мир, 2006.</ref>
Данный алгоритм обычно является подпрограммой и многократно применяется к различным кубитам одного состояния (например при моделировании квантовых алгоритмов или анализе квантовой запутанности). Особенностью алгоритма, как и большинства алгоритмов квантовой инфоорматики, является экспоненциальный рост объема данных в зависимости от основного параметра - числа кубитов, что приводит к необходимости суперкомпьютерной реализации для решения важных практических задач.

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

'''Исходные данные:'''

Целочисленные параметры <math>n - </math> число кубитов (необязательно) и <math>k -</math> номер кубита, над которым производится преобразование.

Комплексная матрица <math>U = \begin{pmatrix}
u_{00} & u_{01}\\
u_{10} & u_{11}
\end{pmatrix}</math> однокубитного преобразования размера <math>2 \times 2.</math>

Комплексный вектор <math>v</math> размерности <math>2^n,</math> задающей начальное состояние многокубитной системы.

'''Вычисляемые данные:''' комплексный вектор <math>w</math> размерности <math>2^n,</math> соответствующий состоянию после преобразования.

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

Состояние после действия преобразования <math>U</math> на <math>k-</math>й кубит имеет вид <math>v_{out} = I_{2^{k-1}}\otimes U \otimes I_{2^{n-k}},</math> где <math>I_{j} - </math> единичная матрица размерности <math>j,</math> а <math>\otimes - </math> тензорное произведение (произведение Кронекера).

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

:<math>
w_{i_1i_2\ldots i_k \ldots i_n} = \sum\limits_{j_k=0}^1 u_{i_k j} v_{i_1i_2\ldots j_k \ldots i_n} = u_{i_k 0} v_{i_1i_2\ldots 0_k \ldots i_n} + u_{i_k 1} v_{i_1i_2\ldots 1_k \ldots i_n}
</math>

Индекс-кортеж <math>i_1i_2\ldots i_n</math> представляет собой двоичную запись индекса элемента в массиве.

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

Вычислительное ядро алгоритма представляет собой независимое вычисление всех <math>2^n</math> элементов вектора <math>w.</math> Вычисление каждого элемента требует две операции умножения и одну операцию сложения. Кроме того необходимо вычислять индексы типа <math>i_1i_2\ldots 0_k \ldots i_n,</math> а также значение бита <math>i_k,</math> что требует побитовых операций.

=== Макроструктура алгоритма ===
Как записано и в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют независимые вычсиления элементов выходного вектора.

=== Схема реализации последовательного алгоритма ===
Для индекса <math>i</math> от <math>0</math> до <math>2^n-1</math>
#Вычислить элемент <math>i_k</math> двоичного представления индекса <math>i.</math>
#Вычислить индексы <math>j</math> имеющие двоичные представления <math>i_1i_2\ldots \overline{i_k} \ldots i_n,</math> где крышка означает обращение бита.
#Вычислить <math>w_i = u_{i_k i_k}\cdot v_{i} + u_{i_k \overline{i_k}}\cdot v_j.</math>

=== Последовательная сложность алгоритма ===
Алгоритм требует:
# <math>2^{n+1}</math> операций умножения комплексных чисел;
# <math>2^n</math> операций сложения комплексных чисел;
# <math>2^n</math> операций получения значения <math>k</math>-го бита числа;
# <math>2^n</math> операций изменения значения <math>k</math>-го бита числа.
Отметим, что данный алгоритм обычно применяется много раз подряд, в связи с чем вычисления, связанные с побитовыми операциями (3-4), могут единожды проводиться в начале алгоритма. Кроме того, от них можно избавиться, пользуясь сложением и логическим умножением с числом <math>2^k,</math> которое сохраняется для всего алгоритма.

=== Информационный граф ===
Представим рисунки графов алгоритма для случая <math>n=3, k=1</math> (рис.1) и <math>k=2</math> (рис.2). На графах не представлены матрицы преобразования <math>U,</math> в связи с тем, что их размер при больших <math>n</math> много меньше, нежели размеры входного и выходного векторов. На Рис.3 изображена основная операция, представляемая на Рис.1 и Рис.2 оранжевым.

Отображение графа со входными и выходными данных, а также "свёрнутой" тройной операцией удобно для понимания локальности обращений к памяти.
Отметим, что структура графа (а именно обращение к входным данным) сильно зависит от параметра <math>k.</math>
[[file:OneQubitVectorTransform1.png|thumb|center|800px|Рисунок 1. Граф алгоритма для <math>n=3, k=1</math> без отображения матрицы преобразования <math>U.</math> ]]
[[file:OneQubitVectorTransform.png|thumb|center|800px|Рисунок 2. Граф алгоритма для <math>n=3, k=2</math> без отображения матрицы преобразования <math>U.</math> ]]
[[file:q_operation.png|thumb|center|300px|Рисунок 3. Граф основной операции.]]

=== Ресурс параллелизма алгоритма ===
Как видно из информационного графа, прямой алгоритм моделирования однокубитного преобразования обладает высочайшей степенью параллелизма. Все операции вычисления элементов нового вектора-состояния могут быть произведены параллельно. Для вычисления одного элемента необходимо выполнить две операции умножения и одну операцию сложения, операции умножения, в свою очередь, также могут быть выполнены параллельно.
Таким образом, необходимо выполнение двух ярусов: одного, состоящего из <math>2^{n+1}</math> умножений и другого, состоящего из <math>2^n</math> сложений.

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

* Комплексный вектор состояния <math>u</math> длины <math>2^n.</math> Обычно нормирован на единицу.
* Унитарная матрица <math>U</math> порядка <math>2</math>.
* Номер кубита <math>q</math>.

'''Выходные данные:'''
* Комплексный вектор состояния <math>w</math> длины <math>2^n</math>.

'''Объем входных данных:''' <math>2^n+4</math> комплексных чисел и <math>1</math> целочисленный параметр.

'''Объем выходных данных:''' <math>2^n</math> комплексных чисел.

=== Свойства алгоритма ===
Соотношение последовательной и параллельной сложности является ''экспоненциальным'' (эксмпонента переходит в константу).

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

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
На языке C функцию однокубитного преобразования можно записать следующим образом:

<source lang="C">
void OneQubitEvolution(complexd *in, complexd *out, complexd U[2][2], int nqubits, int q)
{
//n - число кубитов
//q - номер кубита для преобразования

int shift = nqubits-q;
//Все биты нулевые, кроме соответствующего позиции преобразуемого кубита
int pow2q=1<<(shift);

int N=1<<nqubits;
for (int i=0; i<N; i++)
{
//Обнуления меняющегося бита
int i0 = i & ~pow2q;

//Установка меняющегося бита
int i1 = i | pow2q;

//Получение значения меняющегося бита
int iq = (i & pow2q) >> shift;

out[i] = U[iq][0] * in[i0] + U[iq][1] *in[i1];
}
}
</source>

Отметим, что существенная часть вычислений и логики кода приходится на битовые операции, однако, этого можно избежать: однокубитное преобразование в большинстве случаев является лишь подпрограммой и применяется к разным кубитам большое число раз. В свою очередь, вычисляемые при помощи битовых операций индексы i0, i1 и iq зависят лишь от параметров количества кубитов n и номера кубита q. Число кубитов обычно фиксировано, соответственно, можно вычислить эти индексы заранее для всех q от 1 до n. Для хранения потребуется лишь массив целочисленных переменных линейного размера 3n в то время, как обрабатываемые данные имеют экспоненциальный размер. Очевидно, что такая оптимизация критически необходима при реализации алгоритма на вычислительных устройствах или языках программирования с отсутствием быстрых битовых операций (примером может служить среда Matlab).

=== Локальность данных и вычислений ===
К сожалению, в потивовес идельной возможности параллелизации алгоритма, он обладает очень плохой локальностью.

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

Однако, преобразование одного кубита в прикладных задачах является лишь подпрограммой и применяется многократно с различными параметрами q. Как видно из математического описания и Рис. 1-2, это полностью исключает возможность добиться локальности обращений к данным.

==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====

[[file:qubit_1.png|thumb|center|700px|Рисунок 1. Однокубитное преобразование вектора-состояния. Общий профиль обращений в память]]

На рис. 1 представлен профиль обращений в память для вычисления однокубитного преобразования вектора-состояния. Данный профиль состоит из обращений к трем массивам, фрагменты для отдельных массивов выделены на рис. 1 зеленым цветом. Из общего профиля можно увидеть, что обращения редко используются повторно, по крайней мере в случае фрагментов 2 и 3. При этом обращения к близко расположенным друг к другу данным выполняются рядом. Рассмотрим выделенные фрагменты поближе.

Отдельно фрагмент 1 представлен на рис. 2. Видно, что данный массив состоит всего из 4-х элементов, к которым постоянно выполняются обращения. Такой фрагмент обладает очень высокой локальностью, поскольку постоянно переиспользуются запрошенные ранее данные.

Далее рассмотрим фрагмент 2 (рис. 3). Здесь все еще проще – выполняется обычный последовательный перебор всех элементов массива. Такой фрагмент обладает высокой пространственной локальностью, однако очень низкой временной (данные просто не используются повторно).

[[file:qubit_2.png|thumb|center|500px|Рисунок 2. Фрагмент 1 (профиль обращений к первому массиву)]]

[[file:qubit_3.png|thumb|center|500px|Рисунок 3. Фрагмент 2 (профиль обращений ко второму массиву)]]

Наиболее интересным представляется фрагмент 3. Его небольшой фрагмент, выделенный на рис. 1 желтым, представлен на рис. 4. Однако при ближайшем рассмотрении оказывается, что данный фрагмент тоже просто устроен, хотя и немного сложнее предыдущих.

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

[[file:qubit_4.png|thumb|center|500px|Рисунок 4. Небольшая часть фрагмента 3, выделенная на рис. 1 желтым]]

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

===== Количественная оценка локальности =====

Основной фрагмент реализации, на основе которого были получены количественные оценки, приведен [http://git.parallel.ru/shvets.pavel.srcc/locality/blob/master/benchmarks/qubit_evolution/qubit_evolution.h здесь] (функция Kernel). Условия запуска описаны [http://git.parallel.ru/shvets.pavel.srcc/locality/blob/master/README.md здесь].

Первая оценка выполняется на основе характеристики daps, которая оценивает число выполненных обращений (чтений и записей) в память в секунду. Данная характеристика является аналогом оценки flops применительно к работе с памятью и является в большей степени оценкой производительности взаимодействия с памятью, чем оценкой локальности. Однако она служит хорошим источником информации, в том числе для сравнения с результатами по следующей характеристике cvg.

На рисунке 5 приведены значения daps для реализаций распространенных алгоритмов, отсортированные по возрастанию (чем больше daps, тем в общем случае выше производительность). Можно увидеть, что производительность работы с памятью для этой программы высока – значение daps примерно на уровне теста Linpack. Видимо, низкая временная локальность в данном случае компенсируется высокой пространственной локальностью.

[[file:qubit_daps.png|thumb|center|700px|Рисунок 5. Сравнение значений оценки daps]]

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

На рисунке 6 приведены значения cvg для того же набора реализаций, отсортированные по убыванию (чем меньше cvg, тем в общем случае выше локальность). Можно увидеть, что, в отличие от daps, cvg оценивает локальность данной программы как достаточно низкую. В частности, значение cvg для Linpack заметно меньше, в то время как значения daps практически совпадали.

Одна из возможных причин этого – влияние арифметических операций. Может получиться, что данные из памяти не будут запрашиваться, пока арифметические операции не будут выполнены; это приводит к простою подсистемы памяти. Соответственно, если в одной программе таких операций нет, а в другой - есть, то daps в первом случае будет выше. При этом cvg не поменяется, поскольку эта оценка не зависит от времени выполнения.

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

[[file:qubit_cvg.png|thumb|center|700px|Рисунок 6. Сравнение значений оценки cvg]]

=== Возможные способы и особенности параллельной реализации алгоритма ===
Основной способ параллельной реализации очевиден - необходимо распараллеливание основного цикла (параллельное вычисление различных компонент выходного вектора-состояния) и, желательно, операций умножения. На машинах с общей памятью такой вариант распараллеливания приводит к ускорению, близкому к максимально-возможному.
Однако, данный способ сталкивается с проблемами локальности данных. Анализируя математическая описание и информационные графы алгоритма легко видеть, что при использовании большого числа узлов с собственной памятью количество необходимых пересылок между узлами становится сопоставимым с количеством вычислений, что приводит к существенной потере эффективности. Возможны разные пути частичного решения этой проблемы, например, кэширование или использование парадигмы программирования SHMEM, однако, столь сильная нелокальность использования данных всё равно не позволяет получить хорошей эффективности.

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

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

* число процессоров [4 : 512] со значениями степени двойки;
* число кубитов [16;32] с шагом 2.

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

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

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

[[file:Qbit perf.png|thumb|center|700px|Рисунок 7. Параллельная реализация алгоритма. Изменение производительности в зависимости от числа процессоров и числа кубитов.]]
[[file:Qbit eff.png|thumb|center|700px|Рисунок 8. Параллельная реализация алгоритма. Изменение эффективности в зависимости от числа процессоров и числа кубитов.]]

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

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

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

== Литература ==
<references />

[[Категория:Статьи в работе]]

Обсуждение:Однокубитное преобразование вектора-состояния

2015-12-22T12:52:06Z

Sander: Новая страница: «Ссылки на литературу в однокубитном преобразовании не работают»

Ссылки на литературу в однокубитном преобразовании не работают

Участник:Sander

2015-03-27T09:02:10Z

Sander:

[http://istina.msu.ru/profile/Sander/ Смирнов Александр Владимирович], д.ф.-м.н, вед.н.с. лаборатории Информационных систем математических наук Научно-исследовательского вычислительного центра Московского государственного университета имени М.В.Ломоносова

Классификация алгоритмов

2015-02-09T14:56:42Z

Sander:

== Векторные операции ==

# [[Суммирование сдваиванием]]
# [[Равномерная норма вектора, вещественная версия, последовательно-параллельный вариант]]
# [[Скалярное произведение векторов, вещественная версия, последовательно-параллельный вариант]]
# [[Последовательно-параллельный метод суммирования]]

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

# [[Умножение плотной матрицы на вектор]]

== Матричные операции ==

# [[Умножение плотных матриц]]

== Разложения матриц ==

=== Треугольные разложения ===

# [[Метод Холецкого (нахождение симметричного треугольного разложения)]]

=== Унитарно-треугольные разложения ===

# [[Метод Гивенса (вращений) QR-разложения матрицы]]
# [[Метод Хаусхолдера (отражений) QR-разложения матрицы]]

=== Разложения на унитарные и хессенберговы матрицы ===

# [[Метод Хаусхолдера (отражений) приведения матрицы к хессенберговой (двухдиагональной) форме]]

=== Разложения на унитарные и диагональные матрицы ===

# [[Спектральное разложение (нахождение собственных значений и векторов)]]
# [[Сингулярное разложение (нахождение сингулярных значений и векторов)]]

== Решение систем линейных уравнений ==

# [[High Performance Conjugate Gradient (HPCG) benchmark]]
# [[Linpack benchmark]]
# [[Метод Гаусса решения СЛАУ (прямой ход)]]
# [[Метод Гаусса решения СЛАУ (обратный ход)]]

== Тесты производительности компьютеров ==

# [[High Performance Conjugate Gradient (HPCG) benchmark]]
# [[Linpack benchmark]]

== Преобразование Фурье ==

# [[Быстрое преобразование Фурье для степеней двойки]]

== Численные методы интегрирования ==

# [[Квадратурные_(кубатурные)_методы_численного_интегрирования_по_отрезку_(многомерному_кубу)#Математическое описание|Метод прямоугольников]]
# [[Квадратурные_(кубатурные)_методы_численного_интегрирования_по_отрезку_(многомерному_кубу)#Математическое описание|Метод трапеций]]
# [[Квадратурные_(кубатурные)_методы_численного_интегрирования_по_отрезку_(многомерному_кубу)#Математическое описание|Метод парабол (метод Симпсона)]]
# [[Квадратурные_(кубатурные)_методы_численного_интегрирования_по_отрезку_(многомерному_кубу)#Математическое описание|Метод Гаусса]]

== Алгоритмы на графах ==

# [[Алгоритм вычисления кратчайшего пути во взвешенном графе]]
# [[Алгоритм обхода графа]]

== Алгоритмы поиска ==

# [[Двоичный поиск - находит элемент в отсортированном списке]], <math>O(log(n))</math>

== Алгоритмы сортировки ==

# [[Сортировка с помощью двоичного дерева]]
# [[Сортировка пузырьком]]
# [[Сортировка слиянием (последовательный и параллельный варианты)]]

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

# [[Поиск диаметра множества точек]]
# [[Построение выпуклой оболочки набора точек]]
# [[Триангуляция Делоне]]
# [[Диаграмма Вороного]]
# [[Принадлежность точки многоугольнику]]
# [[Пересечения выпуклых многоугольников]] - трудоёмкость <math>O(n_1 + n_2)</math>
# [[Пересечение звёздных многоугольников]] - трудоёмкость <math>O(n_1 * n_2)</math>

== Компьютерная графика ==

# [[Алгоритмы построения отрезка - алгоритмы для аппроксимации отрезка на дискретной графической поверхности]]
# [[Алгоритм определения видимых частей трёхмерной сцены]]
# [[Трассировка лучей - рендеринг реалистичных изображений]]
# [[Глобальное освещение - рассматривает прямое освещение и отражение от других объектов]]

== Криптографические алгоритмы ==

== Нейронные сети ==

== Алгоритмы оптимизации ==

# [[Линейное программирование]]
# [[Симплекс-метод]]
# [[Метод ветвей и границ (последовательный и параллельный варианты)]]
# [[Генетические алгоритмы]]
# [[Муравьиные алгоритмы]]
# [[Комбинированные алгоритмы]]
# [[Нахождение экстремума функции]]

== Алгоритмы теории игр ==

== Алгоритмы моделирования квантовых систем ==

=== Алгоритмы моделирования квантовых вычислений ===
#[[Однокубитное преобразование вектора-состояния]]
== Другие алгоритмы ==

[[en:Algorithm classification]]

Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)

2015-01-23T18:15:15Z

Sander: /* Существующие реализации алгоритма */

== Описание свойств и структуры алгоритма ==

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

Численное интегрирование — приближенное вычисление значения определенного интеграла. Допустим, нам дана функция <math>f(x)</math>, определенная на отрезке или многомерном кубе, и возможность получать ее численное значение в любой из точек области определения за фиксированное время. Задача — вычислить определенный интеграл данной функции по заданной области и дать оценку погрешности вычисления.

Исторически численное интегрирование также называлось численной квадратурой, а многомерное — кубатурой. Большая советская энциклопедия определяет слово «квадратура» следующим способом: (лат. quadratura — придание квадратной формы), 1) число квадратных единиц в площади данной фигуры. 2) Построение квадрата, равновеликого данной фигуре. 3) Вычисление площади или интеграла.

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

К данному типу относятся одномерные метод прямоугольников, метод трапеций, метод парабол (метод Симпсона), метод Гаусса, метод Гаусса-Кронрода. Часть перечисленных методов обобщается и для многомерного случая. Обобщенно все эти методы называются квадратурными. В многомерном случае они также могут называться кубатурными (это слово не несет никаких дополнительных смыслов). Также говорится, что перечисленные методы используют квадратурные (кубатурные) формулы.

Подходы, в которых область делится на не равные друг другу отрезки (кубы), называются адаптивными и не рассматриваются к данной статье.

Все перечисленные выше методы, а также подобные им могут быть объединены следующим образом: область интегрирования содержит <math>M</math> точек, в каждой из которых необходимо вычислить подынтегральное выражение и помножить ее на весовой коэффициент, затем данные числа складываются, и полученная сумма и представляет собой результат интегрирования. Погрешность интегрирования оценивается ровно таким же образом.

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

Исходные данные: функция <math>f</math> от <math>n</math> переменных, границы области интегрирования, представляющей собой многомерный куб (по каждой из осей интегрирования заданы минимальное и максимальное значение координаты), максимальное число <math>M</math> точек, в которых можно вычислить функцию <math>f</math>.

Вычисляемые данные: число, представляющее собой приближенное значение интеграла и, если это позволяет выбранный метод, число, представляющее собой оценку погрешности.
По количеству точек <math>M</math> и методу интегрирования определяются размеры прямоугольных параллелепипедов, на которые разбивается область интегрирования. В каждом из параллелепипедов в зависимости от выбора метода определяются свои точки для вычисления функции <math>f</math> и весовые коэффициенты.

Наибольшее разнообразие выбора методов достигается в одномерном случае.

''Метод прямоугольников'': функция для заданного отрезка приближается константной функцией, тем самым, интеграл приближается значением функции в одной точке. Обычно в качестве этой точки используется граница отрезка или, лучше, его середина.
: <math>\int\limits_a^b f(x)\,dx \approx f((a+b)/2) * (b-a)</math>

''Метод трапеций''<nowiki>:</nowiki> <math>f(x)</math> приближается линейной функцией, тем самым, интеграл приближается усредненным значением по краям отрезка:
: <math>\int\limits_a^b f(x)\,dx \approx (f(a) + f(b)) * (b-a)/2</math>

''Метод парабол (метод Симпсона)''<nowiki>:</nowiki> <math>f(x)</math> приближается параболой, пересекающей график функции на краях отрезка и в его середине:
: <math>\int\limits_a^b f(x)\,dx \approx \frac{b-a}{6}\left(f(a)+4f\left(\frac{a+b}{2}\right)+f(b)\right)</math>

''Метод Гаусса''<nowiki>:</nowiki> <math>f(x)</math> приближается прямой как в методе трапеций, однако в качестве точек выбираются не концы отрезка, что позволяет увеличить точность:
: <math>\int\limits_a^b f(x)\,dx \approx \frac{b-a}{2}\left(f\left(\frac{a+b}{2} - \frac{b-a}{2\sqrt{3}} \right)+f\left(\frac{a+b}{2} + \frac{b-a}{2\sqrt{3}} \right) \right)</math>

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

Так или иначе, на подготовительной стадии определяется M наборов координат <math>{x_{1,i}, … x_{n,i}}</math>, где <math>i</math> меняется от <math>1</math> до <math>M</math>, в которых будет вычисляться функция <math>f</math> и набор весовых коэффициентов <math>с_i</math>, на которые будет умножаться значение функции, после чего управление передается вычислительному ядру алгоритма.

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

Вычислительное ядро последовательной версии любого из квадратурных методов численного интегрирования представляет собой вычисление суммы
: <math>\sum \limits_1^M c_i f(x_{1,i}, … x_{n,i}) </math>
Поскольку время, требуемое на операции сложения и умножения в реальных примерах представляют собой о малое от времени, затрачиваемого на вычисление функции <math>f</math>, для производительности становится совершенно неважно, каким способом осуществлять сложение и умножение.

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

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

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

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

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

Время, затрачиваемое на вычисление функции растет примерно как <math>t*M</math>, где <math>t</math> — время, требуемое на вычислении функции <math>f</math>, а <math>M</math> — количество точек, в которых вычисляется функция <math>f</math>. Тем самым, алгоритм является линейным относительно количества точек интегрирования.

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

Опишем граф алгоритма как аналитически, так и в виде рисунка.

Граф алгоритма состоит из трех групп вершин. Вершины на верхнем ярусе берут в качестве входных данных координаты и вычисляют по ним значение функции <math>f</math>. Вершины на втором ярусе умножают полученное значение на соответствующий весовой коэффициент. Вершины на третьем ярусе поочередно складывают полученные значения; результат относится к выходным данным.

[[Image:Cubature.png|center|thumb|700px|Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)]]

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

Для вычисления интеграла функции методом кубатур требуется последовательно выполнить следующие ярусы:

- Вычисление исходной функции <math>f</math>, производящееся независимо для различных точек и выполняющееся за близкое к константному время <math>t</math> — основная часть алгоритма.

- Умножение полученных результатов на соответствующие весовые коэффициенты

- Сложение полученных результатов.

В общем случае время, затрачиваемое на сложение или умножение пренебрежимо мало по сравнением со временем необходимым на вычисление функции <math>f</math>, а все вычисления функции <math>f</math> могут производиться на различных узлах, тем самым, задача вычисления интеграла методом кубатур идеально поддается параллельной реализации. Однако при значительном увеличении количества узлов (в случае, когда оно становится сравнимым с количеством точек, в которых вычисляется функция), ресурс параллелизма может быть ограничен накладными расходами,такими как передача исходного выражения на каждый из вычислительных узлов.

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

=== Описание входных и выходных данных ===

Входными данными для алгоритма являются размерность <math>n</math>, границы интегрирования (два массива длины <math>n</math>), ограничение <math>M</math> на количество точек интегрирования, выбор метода интегрирования и функция <math>f</math> — подынтегральное выражение. Она обычно задается в виде функции, написанной на используемом языке программирования или же в строковом виде, если реализация алгоритма имеет встроенный аналог компилятора, работающий с используемым классом функций.

К входным данными для вычислительного ядра алгоритма относится функция <math>f</math> и массив длины <math>M</math>, содержащий точки, в которых должно быть произведено вычисление.

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

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

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

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

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

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

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

В простейшем варианте вычислительное ядро метода на Фортране можно записать так:

<source lang="fortran">
double::res
DO I = 1, M
double::a = f(x(I))
res = res + a
END DO
</source>

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

Локальность операций существенно определяется реализацией вычисления функции <math>f</math>. Если рассматривать ее вычисление как «черный ящик», то становится совершенно невозможным заботиться об эффективном использовании кэша процессора.

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

Самым естественным способом реализации параллельного алгоритма является независимое вычислении функции <math>f</math> в различных точках разными узлами. При этом это может быть реализовано как при помощи технологии threads при запуске на одном узле, так и, например, при помощи MPI. Головной узел передает определение функции <math>f</math>, и затем раздает подчиненным узлам точки, в которых должна вычисляться функция. Для оптимизации процесса возможно передавать сразу наборы точек.

Также представляется возможным одновременное вычисление нескольких значений функции одним узлом, однако такой подход требует адаптации самого алгоритма вычисления функции <math>f</math> и не всегда является применимым. Например, использование команд типа AVX для микропроцессоров позволяет выполнять по 4 сложения или умножения за такт работы процессора, однако так могут складываться лишь расположенные последовательно вещественные числа типа. Но использование подобных ускорений или, скажем, перевод алгоритма на использование графических процессоров, безусловно требует модификации самого алгоритма вычисления функции <math>f</math> и уточнения класса функций, для которых будет применяться данная реализация.

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

Теоретические оценки показывают, что алгоритм должен быть превосходно масштабируем. Для демонстрации этого утверждения на примере в НИВЦ МГУ был создана реализация алгоритма интегрирования методом прямоугольников. В качестве тестового примера рассматривалось трехмерное интегрирование. Поскольку в задачи не входила оценка сложности вычисления той или иной функции от трех переменных, было выбрано простейшее подынтегральное выражение, <math>x_1^2+x_2^2+x_3^3</math>. Однако такая функция является слишком простой и нетипичной для тех примеров, на которых обычно применяется алгоритм. Поэтому для демонстрации масштабируемости алгоритма на достаточно сложных примерах в вычисление функции в одной точке была заложена пауза длительностью в 0.01 секунды (для типичных примеров длительность может существенно превышать это время, однако и оно оказалось достаточным для проведения демонстрации).

Алгоритм в качестве метода распараллеливания использует технологию MPI. Тесты проводились на суперкомпьютере [http://parallel.ru/cluster/superinfo Ломоносов]. Для демонстрации оказалось достаточным провести тесты с количеством процессоров до 64 (с шагом 8). Для количества точек, в которых вычислялась функция, была введена логарифмическая шкала (от 100 до миллиона с шагом умножения на 10). Причина введения такой шкалы состоит в том, что в настоящих примерах требуется вычислять функцию не меньше, чем в ста тысячах точек и может доходить до миллиарда, а провал эффективности наблюдается лишь при существенно меньших количествах точек интегрирования. При таком подходе не представлялось возможным измерять производительность в гигафлопсах; в качестве показателя производительности использовалось количество точек, в которых была вычислена функция.

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

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

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации численного интегрирования в зависимости от изменяемых параметров запуска.

[[file:Масштабируемость численного интегрирования методом прямоугольников. Производительность.svg|thumb|center|600px|Рисунок 1. Параллельная реализация интегрирования методом прямоугольников. Изменение производительности в зависимости от числа процессоров и количества вычисляемых точек.]]
[[file:Масштабируемость численного интегрирования методом прямоугольников. Эффективность.svg|thumb|center|600px|Рисунок 2. Параллельная реализация интегрирования методом прямоугольников. Изменение эффективности в зависимости от числа процессоров и количества вычисляемых точек.]]

При полученных данных не представляется осмысленным выводить средние оценки изменения эффективности по тем или иным осям. Эффективность задачи существенно зависит от того, превышает ли количество вычисляемых точек количество процессоров (хотя бы на порядок). В таком случае эффективность реализации стремится к единице. А поскольку в реальных примерах сложно представить, чтобы количество используемых процессоров могло сравняться с количеством вычисляемых точек, делается вывод, что алгоритм, как и предполагалось согласно теоретическим оценкам, идеально масштабируем.

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

Так как мы рассматриваем вычисление функции как абстрактно устроенную и неизвестную нам процедуру, то представляется невозможным прокомментировать эффективность работы алгоритма с памятью или иные близкие характеристики. Как показали результаты предыдущего параграфа, алгоритм проявляет себя крайне эффективно в случае, когда количество вычисляемых точек становится существенно больше числа задействованных процессоров, а время вычисления функции не меньше одной сотой секунды. Соответственно представляет интерес зафиксировать количество вычисляемых точек (например, числом 10000) и изучить зависимость эффективности от числа процессоров (как и ранее, до 64 с шагом 8) и времени вычисления функции в одной точке (от <math>10^{-5}</math> секунды до <math>101 \cdot 10^{-5}</math> с шагом <math>10^{-4}</math>).

[[file:Масштабируемость численного интегрирования методом прямоугольников. Эффективность 2.svg|thumb|center|600px|Рисунок 3. Параллельная реализация интегрирования методом прямоугольников. Изменение эффективности в зависимости от числа процессоров и времени вычисления функции.]]

Данный эксперимент показывает, что действительно при малом времени вычисления функции в одной точке эффективность алгоритма резко падает (до 2.02% в некоторых случаях). Это объясняется тем, что накладные расходы на организацию MPI-вычислений начинают доминировать. Однако при времени вычисления функции превышающим <math>3 \cdot 10^{-4}</math> эффективность резко возрастает и становится близкой к единице.

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

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

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

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

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

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

Реализация алгоритма доступна по адресу [http://git.algowiki-project.org/Sander/numerical_integration/tree/master]

Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)

2014-12-03T21:02:18Z

Sander: /* Описание ресурса параллелизма алгоритма */

== Описание свойств и структуры алгоритма ==

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

Численное интегрирование — приближенное вычисление значения определенного интеграла. Допустим, нам дана функция <math>f(x)</math>, определенная на отрезке или многомерном кубе, и возможность получать ее численное значение в любой из точек области определения за фиксированное время. Задача — вычислить определенный интеграл данной функции по заданной области и дать оценку погрешности вычисления.

Исторически численное интегрирование также называлось численной квадратурой, а многомерное — кубатурой. Большая советская энциклопедия определяет слово «квадратура» следующим способом: (лат. quadratura — придание квадратной формы), 1) число квадратных единиц в площади данной фигуры. 2) Построение квадрата, равновеликого данной фигуре. 3) Вычисление площади или интеграла.

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

К данному типу относятся одномерные метод прямоугольников, метод трапеций, метод парабол (метод Симпсона), метод Гаусса, метод Гаусса-Кронрода. Часть перечисленных методов обобщается и для многомерного случая. Обобщенно все эти методы называются квадратурными. В многомерном случае они также могут называться кубатурными (это слово не несет никаких дополнительных смыслов). Также говорится, что перечисленные методы используют квадратурные (кубатурные) формулы.

Подходы, в которых область делится на не равные друг другу отрезки (кубы), называются адаптивными и не рассматриваются к данной статье.

Все перечисленные выше методы, а также подобные им могут быть объединены следующим образом: область интегрирования содержит <math>M</math> точек, в каждой из которых необходимо вычислить подынтегральное выражение и помножить ее на весовой коэффициент, затем данные числа складываются, и полученная сумма и представляет собой результат интегрирования. Погрешность интегрирования оценивается ровно таким же образом.

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

Исходные данные: функция <math>f</math> от <math>n</math> переменных, границы области интегрирования, представляющей собой многомерный куб (по каждой из осей интегрирования заданы минимальное и максимальное значение координаты), максимальное число <math>M</math> точек, в которых можно вычислить функцию <math>f</math>.

Вычисляемые данные: число, представляющее собой приближенное значение интеграла и, если это позволяет выбранный метод, число, представляющее собой оценку погрешности.
По количеству точек <math>M</math> и методу интегрирования определяются размеры прямоугольных параллелепипедов, на которые разбивается область интегрирования. В каждом из параллелепипедов в зависимости от выбора метода определяются свои точки для вычисления функции <math>f</math> и весовые коэффициенты.

Наибольшее разнообразие выбора методов достигается в одномерном случае.

''Метод прямоугольников'': функция для заданного отрезка приближается константной функцией, тем самым, интеграл приближается значением функции в одной точке. Обычно в качестве этой точки используется граница отрезка или, лучше, его середина.
: <math>\int\limits_a^b f(x)\,dx \approx f((a+b)/2) * (b-a)</math>

''Метод трапеций''<nowiki>:</nowiki> <math>f(x)</math> приближается линейной функцией, тем самым, интеграл приближается усредненным значением по краям отрезка:
: <math>\int\limits_a^b f(x)\,dx \approx (f(a) + f(b)) * (b-a)/2</math>

''Метод парабол (метод Симпсона)''<nowiki>:</nowiki> <math>f(x)</math> приближается параболой, пересекающей график функции на краях отрезка и в его середине:
: <math>\int\limits_a^b f(x)\,dx \approx \frac{b-a}{6}\left(f(a)+4f\left(\frac{a+b}{2}\right)+f(b)\right)</math>

''Метод Гаусса''<nowiki>:</nowiki> <math>f(x)</math> приближается прямой как в методе трапеций, однако в качестве точек выбираются не концы отрезка, что позволяет увеличить точность:
: <math>\int\limits_a^b f(x)\,dx \approx \frac{b-a}{2}\left(f\left(\frac{a+b}{2} - \frac{b-a}{2\sqrt{3}} \right)+f\left(\frac{a+b}{2} + \frac{b-a}{2\sqrt{3}} \right) \right)</math>

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

Так или иначе, на подготовительной стадии определяется M наборов координат <math>{x_{1,i}, … x_{n,i}}</math>, где <math>i</math> меняется от <math>1</math> до <math>M</math>, в которых будет вычисляться функция <math>f</math> и набор весовых коэффициентов <math>с_i</math>, на которые будет умножаться значение функции, после чего управление передается вычислительному ядру алгоритма.

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

Вычислительное ядро последовательной версии любого из квадратурных методов численного интегрирования представляет собой вычисление суммы
: <math>\sum \limits_1^M c_i f(x_{1,i}, … x_{n,i}) </math>
Поскольку время, требуемое на операции сложения и умножения в реальных примерах представляют собой о малое от времени, затрачиваемого на вычисление функции <math>f</math>, для производительности становится совершенно неважно, каким способом осуществлять сложение и умножение.

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

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

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

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

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

Время, затрачиваемое на вычисление функции растет примерно как <math>t*M</math>, где <math>t</math> — время, требуемое на вычислении функции <math>f</math>, а <math>M</math> — количество точек, в которых вычисляется функция <math>f</math>. Тем самым, алгоритм является линейным относительно количества точек интегрирования.

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

Опишем граф алгоритма как аналитически, так и в виде рисунка.

Граф алгоритма состоит из трех групп вершин. Вершины на верхнем ярусе берут в качестве входных данных координаты и вычисляют по ним значение функции <math>f</math>. Вершины на втором ярусе умножают полученное значение на соответствующий весовой коэффициент. Вершины на третьем ярусе поочередно складывают полученные значения; результат относится к выходным данным.

[[Image:cubature.svg|center|thumb|640px|Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)]]

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

Для вычисления интеграла функции методом кубатур требуется последовательно выполнить следующие ярусы:

- Вычисление исходной функции <math>f</math>, производящееся независимо для различных точек и выполняющееся за близкое к константному время <math>t</math> — основная часть алгоритма.

- Умножение полученных результатов на соответствующие весовые коэффициенты

- Сложение полученных результатов.

В общем случае время, затрачиваемое на сложение или умножение пренебрежимо мало по сравнением со временем необходимым на вычисление функции <math>f</math>, а все вычисления функции <math>f</math> могут производиться на различных узлах, тем самым, задача вычисления интеграла методом кубатур идеально поддается параллельной реализации. Однако при значительном увеличении количества узлов (в случае, когда оно становится сравнимым с количеством точек, в которых вычисляется функция), ресурс параллелизма может быть ограничен накладными расходами,такими как передача исходного выражения на каждый из вычислительных узлов.

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

=== Описание входных и выходных данных ===

Входными данными для алгоритма являются размерность <math>n</math>, границы интегрирования (два массива длины <math>n</math>), ограничение <math>M</math> на количество точек интегрирования, выбор метода интегрирования и функция <math>f</math> — подынтегральное выражение. Она обычно задается в виде функции, написанной на используемом языке программирования или же в строковом виде, если реализация алгоритма имеет встроенный аналог компилятора, работающий с используемым классом функций.

К входным данными для вычислительного ядра алгоритма относится функция <math>f</math> и массив длины <math>M</math>, содержащий точки, в которых должно быть произведено вычисление.

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

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

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

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

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

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

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

В простейшем варианте вычислительное ядро метода на Фортране можно записать так:

<source lang="fortran">
double::res
DO I = 1, M
double::a = f(x(I))
res = res + a
END DO
</source>

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

Локальность операций существенно определяется реализацией вычисления функции <math>f</math>. Если рассматривать ее вычисление как «черный ящик», то становится совершенно невозможным заботиться об эффективном использовании кэша процессора.

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

Самым естественным способом реализации параллельного алгоритма является независимое вычислении функции <math>f</math> в различных точках разными узлами. При этом это может быть реализовано как при помощи технологии threads при запуске на одном узле, так и, например, при помощи MPI. Головной узел передает определение функции <math>f</math>, и затем раздает подчиненным узлам точки, в которых должна вычисляться функция. Для оптимизации процесса возможно передавать сразу наборы точек.

Также представляется возможным одновременное вычисление нескольких значений функции одним узлом, однако такой подход требует адаптации самого алгоритма вычисления функции <math>f</math> и не всегда является применимым. Например, использование команд типа AVX для микропроцессоров позволяет выполнять по 4 сложения или умножения за такт работы процессора, однако так могут складываться лишь расположенные последовательно вещественные числа типа. Но использование подобных ускорений или, скажем, перевод алгоритма на использование графических процессоров, безусловно требует модификации самого алгоритма вычисления функции <math>f</math> и уточнения класса функций, для которых будет применяться данная реализация.

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

Теоретические оценки показывают, что алгоритм должен быть превосходно масштабируем. Для демонстрации этого утверждения на примере в НИВЦ МГУ был создана реализация алгоритма интегрирования методом прямоугольников. В качестве тестового примера рассматривалось трехмерное интегрирование. Поскольку в задачи не входила оценка сложности вычисления той или иной функции от трех переменных, было выбрано простейшее подынтегральное выражение, <math>x_1^2+x_2^2+x_3^3</math>. Однако такая функция является слишком простой и нетипичной для тех примеров, на которых обычно применяется алгоритм. Поэтому для демонстрации масштабируемости алгоритма на достаточно сложных примерах в вычисление функции в одной точке была заложена пауза длительностью в 0.01 секунды (для типичных примеров длительность может существенно превышать это время, однако и оно оказалось достаточным для проведения демонстрации).

Алгоритм в качестве метода распараллеливания использует технологию MPI. Тесты проводились на суперкомпьютере [http://parallel.ru/cluster/superinfo Ломоносов]. Для демонстрации оказалось достаточным провести тесты с количеством процессоров до 64 (с шагом 8). Для количества точек, в которых вычислялась функция, была введена логарифмическая шкала (от 100 до миллиона с шагом умножения на 10). Причина введения такой шкалы состоит в том, что в настоящих примерах требуется вычислять функцию не меньше, чем в ста тысячах точек и может доходить до миллиарда, а провал эффективности наблюдается лишь при существенно меньших количествах точек интегрирования. При таком подходе не представлялось возможным измерять производительность в гигафлопсах; в качестве показателя производительности использовалось количество точек, в которых была вычислена функция.

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

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

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации численного интегрирования в зависимости от изменяемых параметров запуска.

[[file:Масштабируемость численного интегрирования методом прямоугольников. Производительность.svg|thumb|center|600px|Рисунок 1. Параллельная реализация интегрирования методом прямоугольников. Изменение производительности в зависимости от числа процессоров и количества вычисляемых точек.]]
[[file:Масштабируемость численного интегрирования методом прямоугольников. Эффективность.svg|thumb|center|600px|Рисунок 2. Параллельная реализация интегрирования методом прямоугольников. Изменение эффективности в зависимости от числа процессоров и количества вычисляемых точек.]]

При полученных данных не представляется осмысленным выводить средние оценки изменения эффективности по тем или иным осям. Эффективность задачи существенно зависит от того, превышает ли количество вычисляемых точек количество процессоров (хотя бы на порядок). В таком случае эффективность реализации стремится к единице. А поскольку в реальных примерах сложно представить, чтобы количество используемых процессоров могло сравняться с количеством вычисляемых точек, делается вывод, что алгоритм, как и предполагалось согласно теоретическим оценкам, идеально масштабируем.

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

Так как мы рассматриваем вычисление функции как абстрактно устроенную и неизвестную нам процедуру, то представляется невозможным прокомментировать эффективность работы алгоритма с памятью или иные близкие характеристики. Как показали результаты предыдущего параграфа, алгоритм проявляет себя крайне эффективно в случае, когда количество вычисляемых точек становится существенно больше числа задействованных процессоров, а время вычисления функции не меньше одной сотой секунды. Соответственно представляет интерес зафиксировать количество вычисляемых точек (например, числом 10000) и изучить зависимость эффективности от числа процессоров (как и ранее, до 64 с шагом 8) и времени вычисления функции в одной точке (от <math>10^{-5}</math> секунды до <math>101 \cdot 10^{-5}</math> с шагом <math>10^{-4}</math>).

[[file:Масштабируемость численного интегрирования методом прямоугольников. Эффективность 2.svg|thumb|center|600px|Рисунок 3. Параллельная реализация интегрирования методом прямоугольников. Изменение эффективности в зависимости от числа процессоров и времени вычисления функции.]]

Данный эксперимент показывает, что действительно при малом времени вычисления функции в одной точке эффективность алгоритма резко падает (до 2.02% в некоторых случаях). Это объясняется тем, что накладные расходы на организацию MPI-вычислений начинают доминировать. Однако при времени вычисления функции превышающим <math>3 \cdot 10^{-4}</math> эффективность резко возрастает и становится близкой к единице.

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

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

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

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

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

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

Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)

2014-12-03T21:01:31Z

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

== Описание свойств и структуры алгоритма ==

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

Численное интегрирование — приближенное вычисление значения определенного интеграла. Допустим, нам дана функция <math>f(x)</math>, определенная на отрезке или многомерном кубе, и возможность получать ее численное значение в любой из точек области определения за фиксированное время. Задача — вычислить определенный интеграл данной функции по заданной области и дать оценку погрешности вычисления.

Исторически численное интегрирование также называлось численной квадратурой, а многомерное — кубатурой. Большая советская энциклопедия определяет слово «квадратура» следующим способом: (лат. quadratura — придание квадратной формы), 1) число квадратных единиц в площади данной фигуры. 2) Построение квадрата, равновеликого данной фигуре. 3) Вычисление площади или интеграла.

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

К данному типу относятся одномерные метод прямоугольников, метод трапеций, метод парабол (метод Симпсона), метод Гаусса, метод Гаусса-Кронрода. Часть перечисленных методов обобщается и для многомерного случая. Обобщенно все эти методы называются квадратурными. В многомерном случае они также могут называться кубатурными (это слово не несет никаких дополнительных смыслов). Также говорится, что перечисленные методы используют квадратурные (кубатурные) формулы.

Подходы, в которых область делится на не равные друг другу отрезки (кубы), называются адаптивными и не рассматриваются к данной статье.

Все перечисленные выше методы, а также подобные им могут быть объединены следующим образом: область интегрирования содержит <math>M</math> точек, в каждой из которых необходимо вычислить подынтегральное выражение и помножить ее на весовой коэффициент, затем данные числа складываются, и полученная сумма и представляет собой результат интегрирования. Погрешность интегрирования оценивается ровно таким же образом.

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

Исходные данные: функция <math>f</math> от <math>n</math> переменных, границы области интегрирования, представляющей собой многомерный куб (по каждой из осей интегрирования заданы минимальное и максимальное значение координаты), максимальное число <math>M</math> точек, в которых можно вычислить функцию <math>f</math>.

Вычисляемые данные: число, представляющее собой приближенное значение интеграла и, если это позволяет выбранный метод, число, представляющее собой оценку погрешности.
По количеству точек <math>M</math> и методу интегрирования определяются размеры прямоугольных параллелепипедов, на которые разбивается область интегрирования. В каждом из параллелепипедов в зависимости от выбора метода определяются свои точки для вычисления функции <math>f</math> и весовые коэффициенты.

Наибольшее разнообразие выбора методов достигается в одномерном случае.

''Метод прямоугольников'': функция для заданного отрезка приближается константной функцией, тем самым, интеграл приближается значением функции в одной точке. Обычно в качестве этой точки используется граница отрезка или, лучше, его середина.
: <math>\int\limits_a^b f(x)\,dx \approx f((a+b)/2) * (b-a)</math>

''Метод трапеций''<nowiki>:</nowiki> <math>f(x)</math> приближается линейной функцией, тем самым, интеграл приближается усредненным значением по краям отрезка:
: <math>\int\limits_a^b f(x)\,dx \approx (f(a) + f(b)) * (b-a)/2</math>

''Метод парабол (метод Симпсона)''<nowiki>:</nowiki> <math>f(x)</math> приближается параболой, пересекающей график функции на краях отрезка и в его середине:
: <math>\int\limits_a^b f(x)\,dx \approx \frac{b-a}{6}\left(f(a)+4f\left(\frac{a+b}{2}\right)+f(b)\right)</math>

''Метод Гаусса''<nowiki>:</nowiki> <math>f(x)</math> приближается прямой как в методе трапеций, однако в качестве точек выбираются не концы отрезка, что позволяет увеличить точность:
: <math>\int\limits_a^b f(x)\,dx \approx \frac{b-a}{2}\left(f\left(\frac{a+b}{2} - \frac{b-a}{2\sqrt{3}} \right)+f\left(\frac{a+b}{2} + \frac{b-a}{2\sqrt{3}} \right) \right)</math>

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

Так или иначе, на подготовительной стадии определяется M наборов координат <math>{x_{1,i}, … x_{n,i}}</math>, где <math>i</math> меняется от <math>1</math> до <math>M</math>, в которых будет вычисляться функция <math>f</math> и набор весовых коэффициентов <math>с_i</math>, на которые будет умножаться значение функции, после чего управление передается вычислительному ядру алгоритма.

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

Вычислительное ядро последовательной версии любого из квадратурных методов численного интегрирования представляет собой вычисление суммы
: <math>\sum \limits_1^M c_i f(x_{1,i}, … x_{n,i}) </math>
Поскольку время, требуемое на операции сложения и умножения в реальных примерах представляют собой о малое от времени, затрачиваемого на вычисление функции <math>f</math>, для производительности становится совершенно неважно, каким способом осуществлять сложение и умножение.

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

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

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

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

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

Время, затрачиваемое на вычисление функции растет примерно как <math>t*M</math>, где <math>t</math> — время, требуемое на вычислении функции <math>f</math>, а <math>M</math> — количество точек, в которых вычисляется функция <math>f</math>. Тем самым, алгоритм является линейным относительно количества точек интегрирования.

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

Опишем граф алгоритма как аналитически, так и в виде рисунка.

Граф алгоритма состоит из трех групп вершин. Вершины на верхнем ярусе берут в качестве входных данных координаты и вычисляют по ним значение функции <math>f</math>. Вершины на втором ярусе умножают полученное значение на соответствующий весовой коэффициент. Вершины на третьем ярусе поочередно складывают полученные значения; результат относится к выходным данным.

[[Image:cubature.svg|center|thumb|640px|Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)]]

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

Для вычисления интеграла функции методом кубатур требуется последовательно выполнить следующие ярусы:
- Вычисление исходной функции <math>f</math>, производящееся независимо для различных точек и выполняющееся за близкое к константному время <math>t</math> — основная часть алгоритма.
- Умножение полученных результатов на соответствующие весовые коэффициенты
- Сложение полученных результатов.

В общем случае время, затрачиваемое на сложение или умножение пренебрежимо мало по сравнением со временем необходимым на вычисление функции <math>f</math>, а все вычисления функции <math>f</math> могут производиться на различных узлах, тем самым, задача вычисления интеграла методом кубатур идеально поддается параллельной реализации. Однако при значительном увеличении количества узлов (в случае, когда оно становится сравнимым с количеством точек, в которых вычисляется функция), ресурс параллелизма может быть ограничен накладными расходами,такими как передача исходного выражения на каждый из вычислительных узлов.

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

=== Описание входных и выходных данных ===

Входными данными для алгоритма являются размерность <math>n</math>, границы интегрирования (два массива длины <math>n</math>), ограничение <math>M</math> на количество точек интегрирования, выбор метода интегрирования и функция <math>f</math> — подынтегральное выражение. Она обычно задается в виде функции, написанной на используемом языке программирования или же в строковом виде, если реализация алгоритма имеет встроенный аналог компилятора, работающий с используемым классом функций.

К входным данными для вычислительного ядра алгоритма относится функция <math>f</math> и массив длины <math>M</math>, содержащий точки, в которых должно быть произведено вычисление.

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

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

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

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

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

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

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

В простейшем варианте вычислительное ядро метода на Фортране можно записать так:

<source lang="fortran">
double::res
DO I = 1, M
double::a = f(x(I))
res = res + a
END DO
</source>

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

Локальность операций существенно определяется реализацией вычисления функции <math>f</math>. Если рассматривать ее вычисление как «черный ящик», то становится совершенно невозможным заботиться об эффективном использовании кэша процессора.

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

Самым естественным способом реализации параллельного алгоритма является независимое вычислении функции <math>f</math> в различных точках разными узлами. При этом это может быть реализовано как при помощи технологии threads при запуске на одном узле, так и, например, при помощи MPI. Головной узел передает определение функции <math>f</math>, и затем раздает подчиненным узлам точки, в которых должна вычисляться функция. Для оптимизации процесса возможно передавать сразу наборы точек.

Также представляется возможным одновременное вычисление нескольких значений функции одним узлом, однако такой подход требует адаптации самого алгоритма вычисления функции <math>f</math> и не всегда является применимым. Например, использование команд типа AVX для микропроцессоров позволяет выполнять по 4 сложения или умножения за такт работы процессора, однако так могут складываться лишь расположенные последовательно вещественные числа типа. Но использование подобных ускорений или, скажем, перевод алгоритма на использование графических процессоров, безусловно требует модификации самого алгоритма вычисления функции <math>f</math> и уточнения класса функций, для которых будет применяться данная реализация.

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

Теоретические оценки показывают, что алгоритм должен быть превосходно масштабируем. Для демонстрации этого утверждения на примере в НИВЦ МГУ был создана реализация алгоритма интегрирования методом прямоугольников. В качестве тестового примера рассматривалось трехмерное интегрирование. Поскольку в задачи не входила оценка сложности вычисления той или иной функции от трех переменных, было выбрано простейшее подынтегральное выражение, <math>x_1^2+x_2^2+x_3^3</math>. Однако такая функция является слишком простой и нетипичной для тех примеров, на которых обычно применяется алгоритм. Поэтому для демонстрации масштабируемости алгоритма на достаточно сложных примерах в вычисление функции в одной точке была заложена пауза длительностью в 0.01 секунды (для типичных примеров длительность может существенно превышать это время, однако и оно оказалось достаточным для проведения демонстрации).

Алгоритм в качестве метода распараллеливания использует технологию MPI. Тесты проводились на суперкомпьютере [http://parallel.ru/cluster/superinfo Ломоносов]. Для демонстрации оказалось достаточным провести тесты с количеством процессоров до 64 (с шагом 8). Для количества точек, в которых вычислялась функция, была введена логарифмическая шкала (от 100 до миллиона с шагом умножения на 10). Причина введения такой шкалы состоит в том, что в настоящих примерах требуется вычислять функцию не меньше, чем в ста тысячах точек и может доходить до миллиарда, а провал эффективности наблюдается лишь при существенно меньших количествах точек интегрирования. При таком подходе не представлялось возможным измерять производительность в гигафлопсах; в качестве показателя производительности использовалось количество точек, в которых была вычислена функция.

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

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

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации численного интегрирования в зависимости от изменяемых параметров запуска.

[[file:Масштабируемость численного интегрирования методом прямоугольников. Производительность.svg|thumb|center|600px|Рисунок 1. Параллельная реализация интегрирования методом прямоугольников. Изменение производительности в зависимости от числа процессоров и количества вычисляемых точек.]]
[[file:Масштабируемость численного интегрирования методом прямоугольников. Эффективность.svg|thumb|center|600px|Рисунок 2. Параллельная реализация интегрирования методом прямоугольников. Изменение эффективности в зависимости от числа процессоров и количества вычисляемых точек.]]

При полученных данных не представляется осмысленным выводить средние оценки изменения эффективности по тем или иным осям. Эффективность задачи существенно зависит от того, превышает ли количество вычисляемых точек количество процессоров (хотя бы на порядок). В таком случае эффективность реализации стремится к единице. А поскольку в реальных примерах сложно представить, чтобы количество используемых процессоров могло сравняться с количеством вычисляемых точек, делается вывод, что алгоритм, как и предполагалось согласно теоретическим оценкам, идеально масштабируем.

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

Так как мы рассматриваем вычисление функции как абстрактно устроенную и неизвестную нам процедуру, то представляется невозможным прокомментировать эффективность работы алгоритма с памятью или иные близкие характеристики. Как показали результаты предыдущего параграфа, алгоритм проявляет себя крайне эффективно в случае, когда количество вычисляемых точек становится существенно больше числа задействованных процессоров, а время вычисления функции не меньше одной сотой секунды. Соответственно представляет интерес зафиксировать количество вычисляемых точек (например, числом 10000) и изучить зависимость эффективности от числа процессоров (как и ранее, до 64 с шагом 8) и времени вычисления функции в одной точке (от <math>10^{-5}</math> секунды до <math>101 \cdot 10^{-5}</math> с шагом <math>10^{-4}</math>).

[[file:Масштабируемость численного интегрирования методом прямоугольников. Эффективность 2.svg|thumb|center|600px|Рисунок 3. Параллельная реализация интегрирования методом прямоугольников. Изменение эффективности в зависимости от числа процессоров и времени вычисления функции.]]

Данный эксперимент показывает, что действительно при малом времени вычисления функции в одной точке эффективность алгоритма резко падает (до 2.02% в некоторых случаях). Это объясняется тем, что накладные расходы на организацию MPI-вычислений начинают доминировать. Однако при времени вычисления функции превышающим <math>3 \cdot 10^{-4}</math> эффективность резко возрастает и становится близкой к единице.

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

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

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

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

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

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

Файл:Масштабируемость численного интегрирования методом прямоугольников. Эффективность 2.svg

2014-12-03T21:00:36Z

Sander: Sander загружена новая версия «Файл:Масштабируемость численного интегрирования методом прямоугольников. Эффективность 2.svg»

Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)

2014-12-03T20:59:33Z

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

== Описание свойств и структуры алгоритма ==

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

Численное интегрирование — приближенное вычисление значения определенного интеграла. Допустим, нам дана функция <math>f(x)</math>, определенная на отрезке или многомерном кубе, и возможность получать ее численное значение в любой из точек области определения за фиксированное время. Задача — вычислить определенный интеграл данной функции по заданной области и дать оценку погрешности вычисления.

Исторически численное интегрирование также называлось численной квадратурой, а многомерное — кубатурой. Большая советская энциклопедия определяет слово «квадратура» следующим способом: (лат. quadratura — придание квадратной формы), 1) число квадратных единиц в площади данной фигуры. 2) Построение квадрата, равновеликого данной фигуре. 3) Вычисление площади или интеграла.

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

К данному типу относятся одномерные метод прямоугольников, метод трапеций, метод парабол (метод Симпсона), метод Гаусса, метод Гаусса-Кронрода. Часть перечисленных методов обобщается и для многомерного случая. Обобщенно все эти методы называются квадратурными. В многомерном случае они также могут называться кубатурными (это слово не несет никаких дополнительных смыслов). Также говорится, что перечисленные методы используют квадратурные (кубатурные) формулы.

Подходы, в которых область делится на не равные друг другу отрезки (кубы), называются адаптивными и не рассматриваются к данной статье.

Все перечисленные выше методы, а также подобные им могут быть объединены следующим образом: область интегрирования содержит <math>M</math> точек, в каждой из которых необходимо вычислить подынтегральное выражение и помножить ее на весовой коэффициент, затем данные числа складываются, и полученная сумма и представляет собой результат интегрирования. Погрешность интегрирования оценивается ровно таким же образом.

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

Исходные данные: функция <math>f</math> от <math>n</math> переменных, границы области интегрирования, представляющей собой многомерный куб (по каждой из осей интегрирования заданы минимальное и максимальное значение координаты), максимальное число <math>M</math> точек, в которых можно вычислить функцию <math>f</math>.

Вычисляемые данные: число, представляющее собой приближенное значение интеграла и, если это позволяет выбранный метод, число, представляющее собой оценку погрешности.
По количеству точек <math>M</math> и методу интегрирования определяются размеры прямоугольных параллелепипедов, на которые разбивается область интегрирования. В каждом из параллелепипедов в зависимости от выбора метода определяются свои точки для вычисления функции <math>f</math> и весовые коэффициенты.

Наибольшее разнообразие выбора методов достигается в одномерном случае.

''Метод прямоугольников'': функция для заданного отрезка приближается константной функцией, тем самым, интеграл приближается значением функции в одной точке. Обычно в качестве этой точки используется граница отрезка или, лучше, его середина.
: <math>\int\limits_a^b f(x)\,dx \approx f((a+b)/2) * (b-a)</math>

''Метод трапеций''<nowiki>:</nowiki> <math>f(x)</math> приближается линейной функцией, тем самым, интеграл приближается усредненным значением по краям отрезка:
: <math>\int\limits_a^b f(x)\,dx \approx (f(a) + f(b)) * (b-a)/2</math>

''Метод парабол (метод Симпсона)''<nowiki>:</nowiki> <math>f(x)</math> приближается параболой, пересекающей график функции на краях отрезка и в его середине:
: <math>\int\limits_a^b f(x)\,dx \approx \frac{b-a}{6}\left(f(a)+4f\left(\frac{a+b}{2}\right)+f(b)\right)</math>

''Метод Гаусса''<nowiki>:</nowiki> <math>f(x)</math> приближается прямой как в методе трапеций, однако в качестве точек выбираются не концы отрезка, что позволяет увеличить точность:
: <math>\int\limits_a^b f(x)\,dx \approx \frac{b-a}{2}\left(f\left(\frac{a+b}{2} - \frac{b-a}{2\sqrt{3}} \right)+f\left(\frac{a+b}{2} + \frac{b-a}{2\sqrt{3}} \right) \right)</math>

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

Так или иначе, на подготовительной стадии определяется M наборов координат <math>{x_{1,i}, … x_{n,i}}</math>, где <math>i</math> меняется от <math>1</math> до <math>M</math>, в которых будет вычисляться функция <math>f</math> и набор весовых коэффициентов <math>с_i</math>, на которые будет умножаться значение функции, после чего управление передается вычислительному ядру алгоритма.

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

Вычислительное ядро последовательной версии любого из квадратурных методов численного интегрирования представляет собой вычисление суммы
: <math>\sum \limits_1^M c_i f(x_{1,i}, … x_{n,i}) </math>
Поскольку время, требуемое на операции сложения и умножения в реальных примерах представляют собой о малое от времени, затрачиваемого на вычисление функции <math>f</math>, для производительности становится совершенно неважно, каким способом осуществлять сложение и умножение.

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

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

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

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

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

Время, затрачиваемое на вычисление функции растет примерно как <math>t*M</math>, где <math>t</math> — время, требуемое на вычислении функции <math>f</math>, а <math>M</math> — количество точек, в которых вычисляется функция <math>f</math>. Тем самым, алгоритм является линейным относительно количества точек интегрирования.

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

Опишем граф алгоритма как аналитически, так и в виде рисунка.

Граф алгоритма состоит из трех групп вершин. Вершины на верхнем ярусе берут в качестве входных данных координаты и вычисляют по ним значение функции <math>f</math>. Вершины на втором ярусе умножают полученное значение на соответствующий весовой коэффициент. Вершины на третьем ярусе поочередно складывают полученные значения; результат относится к выходным данным.

[[Image:cubature.svg|center|thumb|640px|Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)]]

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

Для вычисления интеграла функции методом кубатур требуется последовательно выполнить следующие ярусы:
- Вычисление исходной функции <math>f</math>, производящееся независимо для различных точек и выполняющееся за близкое к константному время <math>t</math> — основная часть алгоритма.
- Умножение полученных результатов на соответствующие весовые коэффициенты
- Сложение полученных результатов.

В общем случае время, затрачиваемое на сложение или умножение пренебрежимо мало по сравнением со временем необходимым на вычисление функции <math>f</math>, а все вычисления функции <math>f</math> могут производиться на различных узлах, тем самым, задача вычисления интеграла методом кубатур идеально поддается параллельной реализации. Однако при значительном увеличении количества узлов (в случае, когда оно становится сравнимым с количеством точек, в которых вычисляется функция), ресурс параллелизма может быть ограничен накладными расходами,такими как передача исходного выражения на каждый из вычислительных узлов.

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

=== Описание входных и выходных данных ===

Входными данными для алгоритма являются размерность <math>n</math>, границы интегрирования (два массива длины <math>n</math>), ограничение <math>M</math> на количество точек интегрирования, выбор метода интегрирования и функция <math>f</math> — подынтегральное выражение. Она обычно задается в виде функции, написанной на используемом языке программирования или же в строковом виде, если реализация алгоритма имеет встроенный аналог компилятора, работающий с используемым классом функций.

К входным данными для вычислительного ядра алгоритма относится функция <math>f</math> и массив длины <math>M</math>, содержащий точки, в которых должно быть произведено вычисление.

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

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

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

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

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

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

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

В простейшем варианте вычислительное ядро метода на Фортране можно записать так:

<source lang="fortran">
double::res
DO I = 1, M
double::a = f(x(I))
res = res + a
END DO
</source>

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

Локальность операций существенно определяется реализацией вычисления функции <math>f</math>. Если рассматривать ее вычисление как «черный ящик», то становится совершенно невозможным заботиться об эффективном использовании кэша процессора.

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

Самым естественным способом реализации параллельного алгоритма является независимое вычислении функции <math>f</math> в различных точках разными узлами. При этом это может быть реализовано как при помощи технологии threads при запуске на одном узле, так и, например, при помощи MPI. Головной узел передает определение функции <math>f</math>, и затем раздает подчиненным узлам точки, в которых должна вычисляться функция. Для оптимизации процесса возможно передавать сразу наборы точек.

Также представляется возможным одновременное вычисление нескольких значений функции одним узлом, однако такой подход требует адаптации самого алгоритма вычисления функции <math>f</math> и не всегда является применимым. Например, использование команд типа AVX для микропроцессоров позволяет выполнять по 4 сложения или умножения за такт работы процессора, однако так могут складываться лишь расположенные последовательно вещественные числа типа. Но использование подобных ускорений или, скажем, перевод алгоритма на использование графических процессоров, безусловно требует модификации самого алгоритма вычисления функции <math>f</math> и уточнения класса функций, для которых будет применяться данная реализация.

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

Теоретические оценки показывают, что алгоритм должен быть превосходно масштабируем. Для демонстрации этого утверждения на примере в НИВЦ МГУ был создана реализация алгоритма интегрирования методом прямоугольников. В качестве тестового примера рассматривалось трехмерное интегрирование. Поскольку в задачи не входила оценка сложности вычисления той или иной функции от трех переменных, было выбрано простейшее подынтегральное выражение, <math>x_1^2+x_2^2+x_3^3</math>. Однако такая функция является слишком простой и нетипичной для тех примеров, на которых обычно применяется алгоритм. Поэтому для демонстрации масштабируемости алгоритма на достаточно сложных примерах в вычисление функции в одной точке была заложена пауза длительностью в 0.01 секунды (для типичных примеров длительность может существенно превышать это время, однако и оно оказалось достаточным для проведения демонстрации).

Алгоритм в качестве метода распараллеливания использует технологию MPI. Тесты проводились на суперкомпьютере [http://parallel.ru/cluster/superinfo Ломоносов]. Для демонстрации оказалось достаточным провести тесты с количеством процессоров до 64 (с шагом 8). Для количества точек, в которых вычислялась функция, была введена логарифмическая шкала (от 100 до миллиона с шагом умножения на 10). Причина введения такой шкалы состоит в том, что в настоящих примерах требуется вычислять функцию не меньше, чем в ста тысячах точек и может доходить до миллиарда, а провал эффективности наблюдается лишь при существенно меньших количествах точек интегрирования. При таком подходе не представлялось возможным измерять производительность в гигафлопсах; в качестве показателя производительности использовалось количество точек, в которых была вычислена функция.

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

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

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации численного интегрирования в зависимости от изменяемых параметров запуска.

[[file:Масштабируемость численного интегрирования методом прямоугольников. Производительность.svg|thumb|center|600px|Рисунок 1. Параллельная реализация интегрирования методом прямоугольников. Изменение производительности в зависимости от числа процессоров и количества вычисляемых точек.]]
[[file:Масштабируемость численного интегрирования методом прямоугольников. Эффективность.svg|thumb|center|600px|Рисунок 2. Параллельная реализация интегрирования методом прямоугольников. Изменение эффективности в зависимости от числа процессоров и количества вычисляемых точек.]]

При полученных данных не представляется осмысленным выводить средние оценки изменения эффективности по тем или иным осям. Эффективность задачи существенно зависит от того, превышает ли количество вычисляемых точек количество процессоров (хотя бы на порядок). В таком случае эффективность реализации стремится к единице. А поскольку в реальных примерах сложно представить, чтобы количество используемых процессоров могло сравняться с количеством вычисляемых точек, делается вывод, что алгоритм, как и предполагалось согласно теоретическим оценкам, идеально масштабируем.

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

Так как мы рассматриваем вычисление функции как абстрактно устроенную и неизвестную нам процедуру, то представляется невозможным прокомментировать эффективность работы алгоритма с памятью или иные близкие характеристики. Как показали результаты предыдущего параграфа, алгоритм проявляет себя крайне эффективно в случае, когда количество вычисляемых точек становится существенно больше числа задействованных процессоров, а время вычисления функции не меньше одной сотой секунды. Соответственно представляет интерес зафиксировать количество вычисляемых точек (например, числом 10000) и изучить зависимость эффективности от числа процессоров (как и ранее, до 64 с шагом 8) и времени вычисления функции в одной точке (от <math>10^{-5}</math> секунды до <math>101 10^{-5}</math> с шагом <math>10^{-4}</math>).

[[file:Масштабируемость численного интегрирования методом прямоугольников. Эффективность 2.svg|thumb|center|600px|Рисунок 3. Параллельная реализация интегрирования методом прямоугольников. Изменение эффективности в зависимости от числа процессоров и времени вычисления функции.]]

Данный эксперимент показывает, что действительно при малом времени вычисления функции в одной точке эффективность алгоритма резко падает (до 2.02% в некоторых случаях). Это объясняется тем, что накладные расходы на организацию MPI-вычислений начинают доминировать. Однако при времени вычисления функции превышающим <math>3 10^{-4}</math> эффективность резко возрастает и становится близкой к единице.

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

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

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

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

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

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

Файл:Масштабируемость численного интегрирования методом прямоугольников. Эффективность 2.svg

2014-12-03T20:51:27Z

Sander:

Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)

2014-12-03T20:51:09Z

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

== Описание свойств и структуры алгоритма ==

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

Численное интегрирование — приближенное вычисление значения определенного интеграла. Допустим, нам дана функция <math>f(x)</math>, определенная на отрезке или многомерном кубе, и возможность получать ее численное значение в любой из точек области определения за фиксированное время. Задача — вычислить определенный интеграл данной функции по заданной области и дать оценку погрешности вычисления.

Исторически численное интегрирование также называлось численной квадратурой, а многомерное — кубатурой. Большая советская энциклопедия определяет слово «квадратура» следующим способом: (лат. quadratura — придание квадратной формы), 1) число квадратных единиц в площади данной фигуры. 2) Построение квадрата, равновеликого данной фигуре. 3) Вычисление площади или интеграла.

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

К данному типу относятся одномерные метод прямоугольников, метод трапеций, метод парабол (метод Симпсона), метод Гаусса, метод Гаусса-Кронрода. Часть перечисленных методов обобщается и для многомерного случая. Обобщенно все эти методы называются квадратурными. В многомерном случае они также могут называться кубатурными (это слово не несет никаких дополнительных смыслов). Также говорится, что перечисленные методы используют квадратурные (кубатурные) формулы.

Подходы, в которых область делится на не равные друг другу отрезки (кубы), называются адаптивными и не рассматриваются к данной статье.

Все перечисленные выше методы, а также подобные им могут быть объединены следующим образом: область интегрирования содержит <math>M</math> точек, в каждой из которых необходимо вычислить подынтегральное выражение и помножить ее на весовой коэффициент, затем данные числа складываются, и полученная сумма и представляет собой результат интегрирования. Погрешность интегрирования оценивается ровно таким же образом.

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

Исходные данные: функция <math>f</math> от <math>n</math> переменных, границы области интегрирования, представляющей собой многомерный куб (по каждой из осей интегрирования заданы минимальное и максимальное значение координаты), максимальное число <math>M</math> точек, в которых можно вычислить функцию <math>f</math>.

Вычисляемые данные: число, представляющее собой приближенное значение интеграла и, если это позволяет выбранный метод, число, представляющее собой оценку погрешности.
По количеству точек <math>M</math> и методу интегрирования определяются размеры прямоугольных параллелепипедов, на которые разбивается область интегрирования. В каждом из параллелепипедов в зависимости от выбора метода определяются свои точки для вычисления функции <math>f</math> и весовые коэффициенты.

Наибольшее разнообразие выбора методов достигается в одномерном случае.

''Метод прямоугольников'': функция для заданного отрезка приближается константной функцией, тем самым, интеграл приближается значением функции в одной точке. Обычно в качестве этой точки используется граница отрезка или, лучше, его середина.
: <math>\int\limits_a^b f(x)\,dx \approx f((a+b)/2) * (b-a)</math>

''Метод трапеций''<nowiki>:</nowiki> <math>f(x)</math> приближается линейной функцией, тем самым, интеграл приближается усредненным значением по краям отрезка:
: <math>\int\limits_a^b f(x)\,dx \approx (f(a) + f(b)) * (b-a)/2</math>

''Метод парабол (метод Симпсона)''<nowiki>:</nowiki> <math>f(x)</math> приближается параболой, пересекающей график функции на краях отрезка и в его середине:
: <math>\int\limits_a^b f(x)\,dx \approx \frac{b-a}{6}\left(f(a)+4f\left(\frac{a+b}{2}\right)+f(b)\right)</math>

''Метод Гаусса''<nowiki>:</nowiki> <math>f(x)</math> приближается прямой как в методе трапеций, однако в качестве точек выбираются не концы отрезка, что позволяет увеличить точность:
: <math>\int\limits_a^b f(x)\,dx \approx \frac{b-a}{2}\left(f\left(\frac{a+b}{2} - \frac{b-a}{2\sqrt{3}} \right)+f\left(\frac{a+b}{2} + \frac{b-a}{2\sqrt{3}} \right) \right)</math>

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

Так или иначе, на подготовительной стадии определяется M наборов координат <math>{x_{1,i}, … x_{n,i}}</math>, где <math>i</math> меняется от <math>1</math> до <math>M</math>, в которых будет вычисляться функция <math>f</math> и набор весовых коэффициентов <math>с_i</math>, на которые будет умножаться значение функции, после чего управление передается вычислительному ядру алгоритма.

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

Вычислительное ядро последовательной версии любого из квадратурных методов численного интегрирования представляет собой вычисление суммы
: <math>\sum \limits_1^M c_i f(x_{1,i}, … x_{n,i}) </math>
Поскольку время, требуемое на операции сложения и умножения в реальных примерах представляют собой о малое от времени, затрачиваемого на вычисление функции <math>f</math>, для производительности становится совершенно неважно, каким способом осуществлять сложение и умножение.

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

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

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

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

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

Время, затрачиваемое на вычисление функции растет примерно как <math>t*M</math>, где <math>t</math> — время, требуемое на вычислении функции <math>f</math>, а <math>M</math> — количество точек, в которых вычисляется функция <math>f</math>. Тем самым, алгоритм является линейным относительно количества точек интегрирования.

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

Опишем граф алгоритма как аналитически, так и в виде рисунка.

Граф алгоритма состоит из трех групп вершин. Вершины на верхнем ярусе берут в качестве входных данных координаты и вычисляют по ним значение функции <math>f</math>. Вершины на втором ярусе умножают полученное значение на соответствующий весовой коэффициент. Вершины на третьем ярусе поочередно складывают полученные значения; результат относится к выходным данным.

[[Image:cubature.svg|center|thumb|640px|Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)]]

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

Для вычисления интеграла функции методом кубатур требуется последовательно выполнить следующие ярусы:
- Вычисление исходной функции <math>f</math>, производящееся независимо для различных точек и выполняющееся за близкое к константному время <math>t</math> — основная часть алгоритма.
- Умножение полученных результатов на соответствующие весовые коэффициенты
- Сложение полученных результатов.

В общем случае время, затрачиваемое на сложение или умножение пренебрежимо мало по сравнением со временем необходимым на вычисление функции <math>f</math>, а все вычисления функции <math>f</math> могут производиться на различных узлах, тем самым, задача вычисления интеграла методом кубатур идеально поддается параллельной реализации. Однако при значительном увеличении количества узлов (в случае, когда оно становится сравнимым с количеством точек, в которых вычисляется функция), ресурс параллелизма может быть ограничен накладными расходами,такими как передача исходного выражения на каждый из вычислительных узлов.

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

=== Описание входных и выходных данных ===

Входными данными для алгоритма являются размерность <math>n</math>, границы интегрирования (два массива длины <math>n</math>), ограничение <math>M</math> на количество точек интегрирования, выбор метода интегрирования и функция <math>f</math> — подынтегральное выражение. Она обычно задается в виде функции, написанной на используемом языке программирования или же в строковом виде, если реализация алгоритма имеет встроенный аналог компилятора, работающий с используемым классом функций.

К входным данными для вычислительного ядра алгоритма относится функция <math>f</math> и массив длины <math>M</math>, содержащий точки, в которых должно быть произведено вычисление.

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

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

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

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

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

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

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

В простейшем варианте вычислительное ядро метода на Фортране можно записать так:

<source lang="fortran">
double::res
DO I = 1, M
double::a = f(x(I))
res = res + a
END DO
</source>

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

Локальность операций существенно определяется реализацией вычисления функции <math>f</math>. Если рассматривать ее вычисление как «черный ящик», то становится совершенно невозможным заботиться об эффективном использовании кэша процессора.

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

Самым естественным способом реализации параллельного алгоритма является независимое вычислении функции <math>f</math> в различных точках разными узлами. При этом это может быть реализовано как при помощи технологии threads при запуске на одном узле, так и, например, при помощи MPI. Головной узел передает определение функции <math>f</math>, и затем раздает подчиненным узлам точки, в которых должна вычисляться функция. Для оптимизации процесса возможно передавать сразу наборы точек.

Также представляется возможным одновременное вычисление нескольких значений функции одним узлом, однако такой подход требует адаптации самого алгоритма вычисления функции <math>f</math> и не всегда является применимым. Например, использование команд типа AVX для микропроцессоров позволяет выполнять по 4 сложения или умножения за такт работы процессора, однако так могут складываться лишь расположенные последовательно вещественные числа типа. Но использование подобных ускорений или, скажем, перевод алгоритма на использование графических процессоров, безусловно требует модификации самого алгоритма вычисления функции <math>f</math> и уточнения класса функций, для которых будет применяться данная реализация.

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

Теоретические оценки показывают, что алгоритм должен быть превосходно масштабируем. Для демонстрации этого утверждения на примере в НИВЦ МГУ был создана реализация алгоритма интегрирования методом прямоугольников. В качестве тестового примера рассматривалось трехмерное интегрирование. Поскольку в задачи не входила оценка сложности вычисления той или иной функции от трех переменных, было выбрано простейшее подынтегральное выражение, <math>x_1^2+x_2^2+x_3^3</math>. Однако такая функция является слишком простой и нетипичной для тех примеров, на которых обычно применяется алгоритм. Поэтому для демонстрации масштабируемости алгоритма на достаточно сложных примерах в вычисление функции в одной точке была заложена пауза длительностью в 0.01 секунды (для типичных примеров длительность может существенно превышать это время, однако и оно оказалось достаточным для проведения демонстрации).

Алгоритм в качестве метода распараллеливания использует технологию MPI. Тесты проводились на суперкомпьютере [http://parallel.ru/cluster/superinfo Ломоносов]. Для демонстрации оказалось достаточным провести тесты с количеством процессоров до 64 (с шагом 8). Для количества точек, в которых вычислялась функция, была введена логарифмическая шкала (от 100 до миллиона с шагом умножения на 10). Причина введения такой шкалы состоит в том, что в настоящих примерах требуется вычислять функцию не меньше, чем в ста тысячах точек и может доходить до миллиарда, а провал эффективности наблюдается лишь при существенно меньших количествах точек интегрирования. При таком подходе не представлялось возможным измерять производительность в гигафлопсах; в качестве показателя производительности использовалось количество точек, в которых была вычислена функция.

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

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

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации численного интегрирования в зависимости от изменяемых параметров запуска.

[[file:Масштабируемость численного интегрирования методом прямоугольников. Производительность.svg|thumb|center|600px|Рисунок 1. Параллельная реализация интегрирования методом прямоугольников. Изменение производительности в зависимости от числа процессоров и количества вычисляемых точек.]]
[[file:Масштабируемость численного интегрирования методом прямоугольников. Эффективность.svg|thumb|center|600px|Рисунок 2. Параллельная реализация интегрирования методом прямоугольников. Изменение эффективности в зависимости от числа процессоров и количества вычисляемых точек.]]

При полученных данных не представляется осмысленным выводить средние оценки изменения эффективности по тем или иным осям. Эффективность задачи существенно зависит от того, превышает ли количество вычисляемых точек количество процессоров (хотя бы на порядок). В таком случае эффективность реализации стремится к единице. А поскольку в реальных примерах сложно представить, чтобы количество используемых процессоров могло сравняться с количеством вычисляемых точек, делается вывод, что алгоритм, как и предполагалось согласно теоретическим оценкам, идеально масштабируем.

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

Так как мы рассматриваем вычисление функции как абстрактно устроенную и неизвестную нам процедуру, то представляется невозможным прокомментировать эффективность работы алгоритма с памятью или иные близкие характеристики. Как показали результаты предыдущего параграфа, алгоритм проявляет себя крайне эффективно в случае, когда количество вычисляемых точек становится существенно больше числа задействованных процессоров, а время вычисления функции не меньше одной сотой секунды. Соответственно представляет интерес зафиксировать количество вычисляемых точек (например, числом 10000) и изучить зависимость эффективности от числа процессоров (как и ранее, до 64 с шагом 8) и времени вычисления функции в одной точке (от <math>10^{-5}</math> секунды до <math>101 10^{-5}</math> с шагом <math>10^{-4}</math>).

[[file:Масштабируемость численного интегрирования методом прямоугольников. Эффективность 2.svg|thumb|center|600px|Рисунок 3. Параллельная реализация интегрирования методом прямоугольников. Изменение эффективности в зависимости от числа процессоров и времени вычисления функции.]]

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

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

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

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

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

Файл:Масштабируемость численного интегрирования методом прямоугольников. Производительность.svg

2014-12-03T20:46:29Z

Sander: Sander загружена новая версия «Файл:Масштабируемость численного интегрирования методом прямоугольников. Производительность.svg»

Файл:Масштабируемость численного интегрирования методом прямоугольников. Эффективность.svg

2014-12-03T20:45:37Z

Sander: Sander загружена новая версия «Файл:Масштабируемость численного интегрирования методом прямоугольников. Эффективность.svg»

Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)

2014-12-03T16:49:01Z

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

== Описание свойств и структуры алгоритма ==

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

Численное интегрирование — приближенное вычисление значения определенного интеграла. Допустим, нам дана функция <math>f(x)</math>, определенная на отрезке или многомерном кубе, и возможность получать ее численное значение в любой из точек области определения за фиксированное время. Задача — вычислить определенный интеграл данной функции по заданной области и дать оценку погрешности вычисления.

Исторически численное интегрирование также называлось численной квадратурой, а многомерное — кубатурой. Большая советская энциклопедия определяет слово «квадратура» следующим способом: (лат. quadratura — придание квадратной формы), 1) число квадратных единиц в площади данной фигуры. 2) Построение квадрата, равновеликого данной фигуре. 3) Вычисление площади или интеграла.

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

К данному типу относятся одномерные метод прямоугольников, метод трапеций, метод парабол (метод Симпсона), метод Гаусса, метод Гаусса-Кронрода. Часть перечисленных методов обобщается и для многомерного случая. Обобщенно все эти методы называются квадратурными. В многомерном случае они также могут называться кубатурными (это слово не несет никаких дополнительных смыслов). Также говорится, что перечисленные методы используют квадратурные (кубатурные) формулы.

Подходы, в которых область делится на не равные друг другу отрезки (кубы), называются адаптивными и не рассматриваются к данной статье.

Все перечисленные выше методы, а также подобные им могут быть объединены следующим образом: область интегрирования содержит <math>M</math> точек, в каждой из которых необходимо вычислить подынтегральное выражение и помножить ее на весовой коэффициент, затем данные числа складываются, и полученная сумма и представляет собой результат интегрирования. Погрешность интегрирования оценивается ровно таким же образом.

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

Исходные данные: функция <math>f</math> от <math>n</math> переменных, границы области интегрирования, представляющей собой многомерный куб (по каждой из осей интегрирования заданы минимальное и максимальное значение координаты), максимальное число <math>M</math> точек, в которых можно вычислить функцию <math>f</math>.

Вычисляемые данные: число, представляющее собой приближенное значение интеграла и, если это позволяет выбранный метод, число, представляющее собой оценку погрешности.
По количеству точек <math>M</math> и методу интегрирования определяются размеры прямоугольных параллелепипедов, на которые разбивается область интегрирования. В каждом из параллелепипедов в зависимости от выбора метода определяются свои точки для вычисления функции <math>f</math> и весовые коэффициенты.

Наибольшее разнообразие выбора методов достигается в одномерном случае.

''Метод прямоугольников'': функция для заданного отрезка приближается константной функцией, тем самым, интеграл приближается значением функции в одной точке. Обычно в качестве этой точки используется граница отрезка или, лучше, его середина.
: <math>\int\limits_a^b f(x)\,dx \approx f((a+b)/2) * (b-a)</math>

''Метод трапеций''<nowiki>:</nowiki> <math>f(x)</math> приближается линейной функцией, тем самым, интеграл приближается усредненным значением по краям отрезка:
: <math>\int\limits_a^b f(x)\,dx \approx (f(a) + f(b)) * (b-a)/2</math>

''Метод парабол (метод Симпсона)''<nowiki>:</nowiki> <math>f(x)</math> приближается параболой, пересекающей график функции на краях отрезка и в его середине:
: <math>\int\limits_a^b f(x)\,dx \approx \frac{b-a}{6}\left(f(a)+4f\left(\frac{a+b}{2}\right)+f(b)\right)</math>

''Метод Гаусса''<nowiki>:</nowiki> <math>f(x)</math> приближается прямой как в методе трапеций, однако в качестве точек выбираются не концы отрезка, что позволяет увеличить точность:
: <math>\int\limits_a^b f(x)\,dx \approx \frac{b-a}{2}\left(f\left(\frac{a+b}{2} - \frac{b-a}{2\sqrt{3}} \right)+f\left(\frac{a+b}{2} + \frac{b-a}{2\sqrt{3}} \right) \right)</math>

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

Так или иначе, на подготовительной стадии определяется M наборов координат <math>{x_{1,i}, … x_{n,i}}</math>, где <math>i</math> меняется от <math>1</math> до <math>M</math>, в которых будет вычисляться функция <math>f</math> и набор весовых коэффициентов <math>с_i</math>, на которые будет умножаться значение функции, после чего управление передается вычислительному ядру алгоритма.

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

Вычислительное ядро последовательной версии любого из квадратурных методов численного интегрирования представляет собой вычисление суммы
: <math>\sum \limits_1^M c_i f(x_{1,i}, … x_{n,i}) </math>
Поскольку время, требуемое на операции сложения и умножения в реальных примерах представляют собой о малое от времени, затрачиваемого на вычисление функции <math>f</math>, для производительности становится совершенно неважно, каким способом осуществлять сложение и умножение.

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

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

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

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

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

Время, затрачиваемое на вычисление функции растет примерно как <math>t*M</math>, где <math>t</math> — время, требуемое на вычислении функции <math>f</math>, а <math>M</math> — количество точек, в которых вычисляется функция <math>f</math>. Тем самым, алгоритм является линейным относительно количества точек интегрирования.

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

Опишем граф алгоритма как аналитически, так и в виде рисунка.

Граф алгоритма состоит из трех групп вершин. Вершины на верхнем ярусе берут в качестве входных данных координаты и вычисляют по ним значение функции <math>f</math>. Вершины на втором ярусе умножают полученное значение на соответствующий весовой коэффициент. Вершины на третьем ярусе поочередно складывают полученные значения; результат относится к выходным данным.

[[Image:cubature.svg|center|thumb|640px|Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)]]

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

Для вычисления интеграла функции методом кубатур требуется последовательно выполнить следующие ярусы:
- Вычисление исходной функции <math>f</math>, производящееся независимо для различных точек и выполняющееся за близкое к константному время <math>t</math> — основная часть алгоритма.
- Умножение полученных результатов на соответствующие весовые коэффициенты
- Сложение полученных результатов.

В общем случае время, затрачиваемое на сложение или умножение пренебрежимо мало по сравнением со временем необходимым на вычисление функции <math>f</math>, а все вычисления функции <math>f</math> могут производиться на различных узлах, тем самым, задача вычисления интеграла методом кубатур идеально поддается параллельной реализации. Однако при значительном увеличении количества узлов (в случае, когда оно становится сравнимым с количеством точек, в которых вычисляется функция), ресурс параллелизма может быть ограничен накладными расходами,такими как передача исходного выражения на каждый из вычислительных узлов.

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

=== Описание входных и выходных данных ===

Входными данными для алгоритма являются размерность <math>n</math>, границы интегрирования (два массива длины <math>n</math>), ограничение <math>M</math> на количество точек интегрирования, выбор метода интегрирования и функция <math>f</math> — подынтегральное выражение. Она обычно задается в виде функции, написанной на используемом языке программирования или же в строковом виде, если реализация алгоритма имеет встроенный аналог компилятора, работающий с используемым классом функций.

К входным данными для вычислительного ядра алгоритма относится функция <math>f</math> и массив длины <math>M</math>, содержащий точки, в которых должно быть произведено вычисление.

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

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

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

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

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

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

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

В простейшем варианте вычислительное ядро метода на Фортране можно записать так:

<source lang="fortran">
double::res
DO I = 1, M
double::a = f(x(I))
res = res + a
END DO
</source>

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

Локальность операций существенно определяется реализацией вычисления функции <math>f</math>. Если рассматривать ее вычисление как «черный ящик», то становится совершенно невозможным заботиться об эффективном использовании кэша процессора.

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

Самым естественным способом реализации параллельного алгоритма является независимое вычислении функции <math>f</math> в различных точках разными узлами. При этом это может быть реализовано как при помощи технологии threads при запуске на одном узле, так и, например, при помощи MPI. Головной узел передает определение функции <math>f</math>, и затем раздает подчиненным узлам точки, в которых должна вычисляться функция. Для оптимизации процесса возможно передавать сразу наборы точек.

Также представляется возможным одновременное вычисление нескольких значений функции одним узлом, однако такой подход требует адаптации самого алгоритма вычисления функции <math>f</math> и не всегда является применимым. Например, использование команд типа AVX для микропроцессоров позволяет выполнять по 4 сложения или умножения за такт работы процессора, однако так могут складываться лишь расположенные последовательно вещественные числа типа. Но использование подобных ускорений или, скажем, перевод алгоритма на использование графических процессоров, безусловно требует модификации самого алгоритма вычисления функции <math>f</math> и уточнения класса функций, для которых будет применяться данная реализация.

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

Теоретические оценки показывают, что алгоритм должен быть превосходно масштабируем. Для демонстрации этого утверждения на примере в НИВЦ МГУ был создана реализация алгоритма интегрирования методом прямоугольников. В качестве тестового примера рассматривалось трехмерное интегрирование. Поскольку в задачи не входила оценка сложности вычисления той или иной функции от трех переменных, было выбрано простейшее подынтегральное выражение, <math>x_1^2+x_2^2+x_3^3</math>. Однако такая функция является слишком простой и нетипичной для тех примеров, на которых обычно применяется алгоритм. Поэтому для демонстрации масштабируемости алгоритма на достаточно сложных примерах в вычисление функции в одной точке была заложена пауза длительностью в 0.01 секунды (для типичных примеров длительность может существенно превышать это время, однако и оно оказалось достаточным для проведения демонстрации).

Алгоритм в качестве метода распараллеливания использует технологию MPI. Тесты проводились на суперкомпьютере [http://parallel.ru/cluster/superinfo Ломоносов]. Для демонстрации оказалось достаточным провести тесты с количеством процессоров до 64 (с шагом 8). Для количества точек, в которых вычислялась функция, была введена логарифмическая шкала (от 100 до миллиона с шагом умножения на 10). Причина введения такой шкалы состоит в том, что в настоящих примерах требуется вычислять функцию не меньше, чем в ста тысячах точек и может доходить до миллиарда, а провал эффективности наблюдается лишь при существенно меньших количествах точек интегрирования. При таком подходе не представлялось возможным измерять производительность в гигафлопсах; в качестве показателя производительности использовалось количество точек, в которых была вычислена функция.

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

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

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации численного интегрирования в зависимости от изменяемых параметров запуска.

[[file:Масштабируемость численного интегрирования методом прямоугольников. Производительность.svg|thumb|center|600px|Рисунок 1. Параллельная реализация интегрирования методом прямоугольников. Изменение производительности в зависимости от числа процессоров и количества вычисляемых точек.]]
[[file:Масштабируемость численного интегрирования методом прямоугольников. Эффективность.svg|thumb|center|600px|Рисунок 2. Параллельная реализация интегрирования методом прямоугольников. Изменение эффективности в зависимости от числа процессоров и количества вычисляемых точек.]]

При полученных данных не представляется осмысленным выводить средние оценки изменения эффективности по тем или иным осям. Эффективность задачи существенно зависит от того, превышает ли количество вычисляемых точек количество процессоров (хотя бы на порядок). В таком случае эффективность реализации стремится к единице. А поскольку в реальных примерах сложно представить, чтобы количество используемых процессоров могло сравняться с количеством вычисляемых точек, делается вывод, что алгоритм, как и предполагалось согласно теоретическим оценкам, идеально масштабируем.

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

Так как мы рассматриваем вычисление функции как абстрактно устроенную и неизвестную нам процедуру, то представляется невозможным прокомментировать эффективность работы алгоритма с памятью или иные близкие характеристики. Как показали результаты предыдущего параграфа, алгоритм проявляет себя крайне эффективно в случае, когда количество вычисляемых точек становится существенно больше числа задействованных процессоров, а время вычисления функции не меньше одной сотой секунды. Соответственно представляет интерес зафиксировать количество вычисляемых точек (например, числом 10000) и изучить зависимость эффективности от числа процессоров (как и ранее, до 64 с шагом 8) и времени вычисления функции в одной точке (от ??????????)

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

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

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

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

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

Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)

2014-12-03T10:23:08Z

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

== Описание свойств и структуры алгоритма ==

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

Численное интегрирование — приближенное вычисление значения определенного интеграла. Допустим, нам дана функция <math>f(x)</math>, определенная на отрезке или многомерном кубе, и возможность получать ее численное значение в любой из точек области определения за фиксированное время. Задача — вычислить определенный интеграл данной функции по заданной области и дать оценку погрешности вычисления.

Исторически численное интегрирование также называлось численной квадратурой, а многомерное — кубатурой. Большая советская энциклопедия определяет слово «квадратура» следующим способом: (лат. quadratura — придание квадратной формы), 1) число квадратных единиц в площади данной фигуры. 2) Построение квадрата, равновеликого данной фигуре. 3) Вычисление площади или интеграла.

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

К данному типу относятся одномерные метод прямоугольников, метод трапеций, метод парабол (метод Симпсона), метод Гаусса, метод Гаусса-Кронрода. Часть перечисленных методов обобщается и для многомерного случая. Обобщенно все эти методы называются квадратурными. В многомерном случае они также могут называться кубатурными (это слово не несет никаких дополнительных смыслов). Также говорится, что перечисленные методы используют квадратурные (кубатурные) формулы.

Подходы, в которых область делится на не равные друг другу отрезки (кубы), называются адаптивными и не рассматриваются к данной статье.

Все перечисленные выше методы, а также подобные им могут быть объединены следующим образом: область интегрирования содержит <math>M</math> точек, в каждой из которых необходимо вычислить подынтегральное выражение и помножить ее на весовой коэффициент, затем данные числа складываются, и полученная сумма и представляет собой результат интегрирования. Погрешность интегрирования оценивается ровно таким же образом.

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

Исходные данные: функция <math>f</math> от <math>n</math> переменных, границы области интегрирования, представляющей собой многомерный куб (по каждой из осей интегрирования заданы минимальное и максимальное значение координаты), максимальное число <math>M</math> точек, в которых можно вычислить функцию <math>f</math>.

Вычисляемые данные: число, представляющее собой приближенное значение интеграла и, если это позволяет выбранный метод, число, представляющее собой оценку погрешности.
По количеству точек <math>M</math> и методу интегрирования определяются размеры прямоугольных параллелепипедов, на которые разбивается область интегрирования. В каждом из параллелепипедов в зависимости от выбора метода определяются свои точки для вычисления функции <math>f</math> и весовые коэффициенты.

Наибольшее разнообразие выбора методов достигается в одномерном случае.

''Метод прямоугольников'': функция для заданного отрезка приближается константной функцией, тем самым, интеграл приближается значением функции в одной точке. Обычно в качестве этой точки используется граница отрезка или, лучше, его середина.
: <math>\int\limits_a^b f(x)\,dx \approx f((a+b)/2) * (b-a)</math>

''Метод трапеций''<nowiki>:</nowiki> <math>f(x)</math> приближается линейной функцией, тем самым, интеграл приближается усредненным значением по краям отрезка:
: <math>\int\limits_a^b f(x)\,dx \approx (f(a) + f(b)) * (b-a)/2</math>

''Метод парабол (метод Симпсона)''<nowiki>:</nowiki> <math>f(x)</math> приближается параболой, пересекающей график функции на краях отрезка и в его середине:
: <math>\int\limits_a^b f(x)\,dx \approx \frac{b-a}{6}\left(f(a)+4f\left(\frac{a+b}{2}\right)+f(b)\right)</math>

''Метод Гаусса''<nowiki>:</nowiki> <math>f(x)</math> приближается прямой как в методе трапеций, однако в качестве точек выбираются не концы отрезка, что позволяет увеличить точность:
: <math>\int\limits_a^b f(x)\,dx \approx \frac{b-a}{2}\left(f\left(\frac{a+b}{2} - \frac{b-a}{2\sqrt{3}} \right)+f\left(\frac{a+b}{2} + \frac{b-a}{2\sqrt{3}} \right) \right)</math>

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

Так или иначе, на подготовительной стадии определяется M наборов координат <math>{x_{1,i}, … x_{n,i}}</math>, где <math>i</math> меняется от <math>1</math> до <math>M</math>, в которых будет вычисляться функция <math>f</math> и набор весовых коэффициентов <math>с_i</math>, на которые будет умножаться значение функции, после чего управление передается вычислительному ядру алгоритма.

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

Вычислительное ядро последовательной версии любого из квадратурных методов численного интегрирования представляет собой вычисление суммы
: <math>\sum \limits_1^M c_i f(x_{1,i}, … x_{n,i}) </math>
Поскольку время, требуемое на операции сложения и умножения в реальных примерах представляют собой о малое от времени, затрачиваемого на вычисление функции <math>f</math>, для производительности становится совершенно неважно, каким способом осуществлять сложение и умножение.

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

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

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

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

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

Время, затрачиваемое на вычисление функции растет примерно как <math>t*M</math>, где <math>t</math> — время, требуемое на вычислении функции <math>f</math>, а <math>M</math> — количество точек, в которых вычисляется функция <math>f</math>. Тем самым, алгоритм является линейным относительно количества точек интегрирования.

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

Опишем граф алгоритма как аналитически, так и в виде рисунка.

Граф алгоритма состоит из трех групп вершин. Вершины на верхнем ярусе берут в качестве входных данных координаты и вычисляют по ним значение функции <math>f</math>. Вершины на втором ярусе умножают полученное значение на соответствующий весовой коэффициент. Вершины на третьем ярусе поочередно складывают полученные значения; результат относится к выходным данным.

[[Image:cubature.svg|center|thumb|640px|Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)]]

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

Для вычисления интеграла функции методом кубатур требуется последовательно выполнить следующие ярусы:
- Вычисление исходной функции <math>f</math>, производящееся независимо для различных точек и выполняющееся за близкое к константному время <math>t</math> — основная часть алгоритма.
- Умножение полученных результатов на соответствующие весовые коэффициенты
- Сложение полученных результатов.

В общем случае время, затрачиваемое на сложение или умножение пренебрежимо мало по сравнением со временем необходимым на вычисление функции <math>f</math>, а все вычисления функции <math>f</math> могут производиться на различных узлах, тем самым, задача вычисления интеграла методом кубатур идеально поддается параллельной реализации. Однако при значительном увеличении количества узлов (в случае, когда оно становится сравнимым с количеством точек, в которых вычисляется функция), ресурс параллелизма может быть ограничен накладными расходами,такими как передача исходного выражения на каждый из вычислительных узлов.

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

=== Описание входных и выходных данных ===

Входными данными для алгоритма являются размерность <math>n</math>, границы интегрирования (два массива длины <math>n</math>), ограничение <math>M</math> на количество точек интегрирования, выбор метода интегрирования и функция <math>f</math> — подынтегральное выражение. Она обычно задается в виде функции, написанной на используемом языке программирования или же в строковом виде, если реализация алгоритма имеет встроенный аналог компилятора, работающий с используемым классом функций.

К входным данными для вычислительного ядра алгоритма относится функция <math>f</math> и массив длины <math>M</math>, содержащий точки, в которых должно быть произведено вычисление.

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

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

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

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

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

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

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

В простейшем варианте вычислительное ядро метода на Фортране можно записать так:

<source lang="fortran">
double::res
DO I = 1, M
double::a = f(x(I))
res = res + a
END DO
</source>

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

Локальность операций существенно определяется реализацией вычисления функции <math>f</math>. Если рассматривать ее вычисление как «черный ящик», то становится совершенно невозможным заботиться об эффективном использовании кэша процессора.

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

Самым естественным способом реализации параллельного алгоритма является независимое вычислении функции <math>f</math> в различных точках разными узлами. При этом это может быть реализовано как при помощи технологии threads при запуске на одном узле, так и, например, при помощи MPI. Головной узел передает определение функции <math>f</math>, и затем раздает подчиненным узлам точки, в которых должна вычисляться функция. Для оптимизации процесса возможно передавать сразу наборы точек.

Также представляется возможным одновременное вычисление нескольких значений функции одним узлом, однако такой подход требует адаптации самого алгоритма вычисления функции <math>f</math> и не всегда является применимым. Например, использование команд типа AVX для микропроцессоров позволяет выполнять по 4 сложения или умножения за такт работы процессора, однако так могут складываться лишь расположенные последовательно вещественные числа типа. Но использование подобных ускорений или, скажем, перевод алгоритма на использование графических процессоров, безусловно требует модификации самого алгоритма вычисления функции <math>f</math> и уточнения класса функций, для которых будет применяться данная реализация.

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

Теоретические оценки показывают, что алгоритм должен быть превосходно масштабируем. Для демонстрации этого утверждения на примере в НИВЦ МГУ был создана реализация алгоритма интегрирования методом прямоугольников. В качестве тестового примера рассматривалось трехмерное интегрирование. Поскольку в задачи не входила оценка сложности вычисления той или иной функции от трех переменных, было выбрано простейшее подынтегральное выражение, <math>x_1^2+x_2^2+x_3^3</math>. Однако такая функция является слишком простой и нетипичной для тех примеров, на которых обычно применяется алгоритм. Поэтому для демонстрации масштабируемости алгоритма на достаточно сложных примерах в вычисление функции в одной точке была заложена пауза длительностью в 0.01 секунды (для типичных примеров длительность может существенно превышать это время, однако и оно оказалось достаточным для проведения демонстрации).

Алгоритм в качестве метода распараллеливания использует технологию MPI. Тесты проводились на суперкомпьютере [http://parallel.ru/cluster/superinfo Ломоносов]. Для демонстрации оказалось достаточным провести тесты с количеством процессоров до 64 (с шагом 8). Для количества точек, в которых вычислялась функция, была введена логарифмическая шкала (от 100 до миллиона с шагом умножения на 10). Причина введения такой шкалы состоит в том, что в настоящих примерах требуется вычислять функцию не меньше, чем в ста тысячах точек и может доходить до миллиарда, а провал эффективности наблюдается лишь при существенно меньших количествах точек интегрирования. При таком подходе не представлялось возможным измерять производительность в гигафлопсах; в качестве показателя производительности использовалось количество точек, в которых была вычислена функция.

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

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

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации численного интегрирования в зависимости от изменяемых параметров запуска.

[[file:Масштабируемость численного интегрирования методом прямоугольников. Производительность.svg|thumb|center|600px|Рисунок 1. Параллельная реализация интегрирования методом прямоугольников. Изменение производительности в зависимости от числа процессоров и количества вычисляемых точек.]]
[[file:Масштабируемость численного интегрирования методом прямоугольников. Эффективность.svg|thumb|center|600px|Рисунок 2. Параллельная реализация интегрирования методом прямоугольников. Изменение эффективности в зависимости от числа процессоров и количества вычисляемых точек.]]

При полученных данных не представляется осмысленным выводить средние оценки изменения эффективности по тем или иным осям. Эффективность задачи существенно зависит от того, превышает ли количество вычисляемых точек количество процессоров (хотя бы на порядок). В таком случае эффективность реализации стремится к единице. А поскольку в реальных примерах сложно представить, чтобы количество используемых процессоров могло сравняться с количеством вычисляемых точек, делается вывод, что алгоритм, как и предполагалось согласно теоретическим оценкам, идеально масштабируем.

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

'''????? нам нужна модельная реализация?'''

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

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

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

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

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

Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)

2014-12-03T10:13:41Z

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

== Описание свойств и структуры алгоритма ==

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

Численное интегрирование — приближенное вычисление значения определенного интеграла. Допустим, нам дана функция <math>f(x)</math>, определенная на отрезке или многомерном кубе, и возможность получать ее численное значение в любой из точек области определения за фиксированное время. Задача — вычислить определенный интеграл данной функции по заданной области и дать оценку погрешности вычисления.

Исторически численное интегрирование также называлось численной квадратурой, а многомерное — кубатурой. Большая советская энциклопедия определяет слово «квадратура» следующим способом: (лат. quadratura — придание квадратной формы), 1) число квадратных единиц в площади данной фигуры. 2) Построение квадрата, равновеликого данной фигуре. 3) Вычисление площади или интеграла.

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

К данному типу относятся одномерные метод прямоугольников, метод трапеций, метод парабол (метод Симпсона), метод Гаусса, метод Гаусса-Кронрода. Часть перечисленных методов обобщается и для многомерного случая. Обобщенно все эти методы называются квадратурными. В многомерном случае они также могут называться кубатурными (это слово не несет никаких дополнительных смыслов). Также говорится, что перечисленные методы используют квадратурные (кубатурные) формулы.

Подходы, в которых область делится на не равные друг другу отрезки (кубы), называются адаптивными и не рассматриваются к данной статье.

Все перечисленные выше методы, а также подобные им могут быть объединены следующим образом: область интегрирования содержит <math>M</math> точек, в каждой из которых необходимо вычислить подынтегральное выражение и помножить ее на весовой коэффициент, затем данные числа складываются, и полученная сумма и представляет собой результат интегрирования. Погрешность интегрирования оценивается ровно таким же образом.

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

Исходные данные: функция <math>f</math> от <math>n</math> переменных, границы области интегрирования, представляющей собой многомерный куб (по каждой из осей интегрирования заданы минимальное и максимальное значение координаты), максимальное число <math>M</math> точек, в которых можно вычислить функцию <math>f</math>.

Вычисляемые данные: число, представляющее собой приближенное значение интеграла и, если это позволяет выбранный метод, число, представляющее собой оценку погрешности.
По количеству точек <math>M</math> и методу интегрирования определяются размеры прямоугольных параллелепипедов, на которые разбивается область интегрирования. В каждом из параллелепипедов в зависимости от выбора метода определяются свои точки для вычисления функции <math>f</math> и весовые коэффициенты.

Наибольшее разнообразие выбора методов достигается в одномерном случае.

''Метод прямоугольников'': функция для заданного отрезка приближается константной функцией, тем самым, интеграл приближается значением функции в одной точке. Обычно в качестве этой точки используется граница отрезка или, лучше, его середина.
: <math>\int\limits_a^b f(x)\,dx \approx f((a+b)/2) * (b-a)</math>

''Метод трапеций''<nowiki>:</nowiki> <math>f(x)</math> приближается линейной функцией, тем самым, интеграл приближается усредненным значением по краям отрезка:
: <math>\int\limits_a^b f(x)\,dx \approx (f(a) + f(b)) * (b-a)/2</math>

''Метод парабол (метод Симпсона)''<nowiki>:</nowiki> <math>f(x)</math> приближается параболой, пересекающей график функции на краях отрезка и в его середине:
: <math>\int\limits_a^b f(x)\,dx \approx \frac{b-a}{6}\left(f(a)+4f\left(\frac{a+b}{2}\right)+f(b)\right)</math>

''Метод Гаусса''<nowiki>:</nowiki> <math>f(x)</math> приближается прямой как в методе трапеций, однако в качестве точек выбираются не концы отрезка, что позволяет увеличить точность:
: <math>\int\limits_a^b f(x)\,dx \approx \frac{b-a}{2}\left(f\left(\frac{a+b}{2} - \frac{b-a}{2\sqrt{3}} \right)+f\left(\frac{a+b}{2} + \frac{b-a}{2\sqrt{3}} \right) \right)</math>

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

Так или иначе, на подготовительной стадии определяется M наборов координат <math>{x_{1,i}, … x_{n,i}}</math>, где <math>i</math> меняется от <math>1</math> до <math>M</math>, в которых будет вычисляться функция <math>f</math> и набор весовых коэффициентов <math>с_i</math>, на которые будет умножаться значение функции, после чего управление передается вычислительному ядру алгоритма.

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

Вычислительное ядро последовательной версии любого из квадратурных методов численного интегрирования представляет собой вычисление суммы
: <math>\sum \limits_1^M c_i f(x_{1,i}, … x_{n,i}) </math>
Поскольку время, требуемое на операции сложения и умножения в реальных примерах представляют собой о малое от времени, затрачиваемого на вычисление функции <math>f</math>, для производительности становится совершенно неважно, каким способом осуществлять сложение и умножение.

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

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

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

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

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

Время, затрачиваемое на вычисление функции растет примерно как <math>t*M</math>, где <math>t</math> — время, требуемое на вычислении функции <math>f</math>, а <math>M</math> — количество точек, в которых вычисляется функция <math>f</math>. Тем самым, алгоритм является линейным относительно количества точек интегрирования.

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

Опишем граф алгоритма как аналитически, так и в виде рисунка.

Граф алгоритма состоит из трех групп вершин. Вершины на верхнем ярусе берут в качестве входных данных координаты и вычисляют по ним значение функции <math>f</math>. Вершины на втором ярусе умножают полученное значение на соответствующий весовой коэффициент. Вершины на третьем ярусе поочередно складывают полученные значения; результат относится к выходным данным.

[[Image:cubature.svg|center|thumb|640px|Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)]]

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

Для вычисления интеграла функции методом кубатур требуется последовательно выполнить следующие ярусы:
- Вычисление исходной функции <math>f</math>, производящееся независимо для различных точек и выполняющееся за близкое к константному время <math>t</math> — основная часть алгоритма.
- Умножение полученных результатов на соответствующие весовые коэффициенты
- Сложение полученных результатов.

В общем случае время, затрачиваемое на сложение или умножение пренебрежимо мало по сравнением со временем необходимым на вычисление функции <math>f</math>, а все вычисления функции <math>f</math> могут производиться на различных узлах, тем самым, задача вычисления интеграла методом кубатур идеально поддается параллельной реализации. Однако при значительном увеличении количества узлов (в случае, когда оно становится сравнимым с количеством точек, в которых вычисляется функция), ресурс параллелизма может быть ограничен накладными расходами,такими как передача исходного выражения на каждый из вычислительных узлов.

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

=== Описание входных и выходных данных ===

Входными данными для алгоритма являются размерность <math>n</math>, границы интегрирования (два массива длины <math>n</math>), ограничение <math>M</math> на количество точек интегрирования, выбор метода интегрирования и функция <math>f</math> — подынтегральное выражение. Она обычно задается в виде функции, написанной на используемом языке программирования или же в строковом виде, если реализация алгоритма имеет встроенный аналог компилятора, работающий с используемым классом функций.

К входным данными для вычислительного ядра алгоритма относится функция <math>f</math> и массив длины <math>M</math>, содержащий точки, в которых должно быть произведено вычисление.

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

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

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

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

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

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

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

В простейшем варианте вычислительное ядро метода на Фортране можно записать так:

<source lang="fortran">
double::res
DO I = 1, M
double::a = f(x(I))
res = res + a
END DO
</source>

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

Локальность операций существенно определяется реализацией вычисления функции <math>f</math>. Если рассматривать ее вычисление как «черный ящик», то становится совершенно невозможным заботиться об эффективном использовании кэша процессора.

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

Самым естественным способом реализации параллельного алгоритма является независимое вычислении функции <math>f</math> в различных точках разными узлами. При этом это может быть реализовано как при помощи технологии threads при запуске на одном узле, так и, например, при помощи MPI. Головной узел передает определение функции <math>f</math>, и затем раздает подчиненным узлам точки, в которых должна вычисляться функция. Для оптимизации процесса возможно передавать сразу наборы точек.

Также представляется возможным одновременное вычисление нескольких значений функции одним узлом, однако такой подход требует адаптации самого алгоритма вычисления функции <math>f</math> и не всегда является применимым. Например, использование команд типа AVX для микропроцессоров позволяет выполнять по 4 сложения или умножения за такт работы процессора, однако так могут складываться лишь расположенные последовательно вещественные числа типа. Но использование подобных ускорений или, скажем, перевод алгоритма на использование графических процессоров, безусловно требует модификации самого алгоритма вычисления функции <math>f</math> и уточнения класса функций, для которых будет применяться данная реализация.

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

Теоретические оценки показывают, что алгоритм должен быть превосходно масштабируем. Для демонстрации этого утверждения на примере в НИВЦ МГУ был создана реализация алгоритма интегрирования методом прямоугольников. В качестве тестового примера рассматривалось трехмерное интегрирование. Поскольку в задачи не входила оценка сложности вычисления той или иной функции от трех переменных, было выбрано простейшее подынтегральное выражение, <math>x_1^2+x_2^2+x_3^3</math>. Однако такая функция является слишком простой и нетипичной для тех примеров, на которых обычно применяется алгоритм. Поэтому для демонстрации масштабируемости алгоритма на достаточно сложных примерах в вычисление функции в одной точке была заложена пауза длительностью в 0.01 секунды (для типичных примеров длительность может существенно превышать это время, однако и оно оказалось достаточным для проведения демонстрации).

Алгоритм в качестве метода распараллеливания использует технологию MPI. Тесты проводились на суперкомпьютере [http://parallel.ru/cluster/superinfo Ломоносов]. Для демонстрации оказалось достаточным провести тесты с количеством процессоров до 64 (с шагом 8). Для количества точек, в которых вычислялась функция, была введена логарифмическая шкала (от 100 до миллиона с шагом умножения на 10). Причина введения такой шкалы состоит в том, что в настоящих примерах требуется вычислять функцию не меньше, чем в ста тысячах точек и может доходить до миллиарда, а провал эффективности наблюдается лишь при существенно меньших количествах точек интегрирования. При таком подходе не представлялось возможным измерять производительность в гигафлопсах; в качестве показателя производительности использовалось количество точек, в которых была вычислена функция.

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

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

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации численного интегрирования в зависимости от изменяемых параметров запуска.

[[file:Масштабируемость численного интегрирования методом прямоугольников. Производительность.svg|thumb|center|600px|Рисунок 1. Параллельная реализация интегрирования методом прямоугольников. Изменение производительности в зависимости от числа процессоров и количества вычисляемых точек.]]
[[file:Масштабируемость численного интегрирования методом прямоугольников. Эффективность.svg|thumb|center|600px|Рисунок 2. Параллельная реализация интегрирования методом прямоугольников. Изменение эффективности в зависимости от числа процессоров и количества вычисляемых точек.]]

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

'''????? нам нужна модельная реализация?'''

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

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

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

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

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

Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)

2014-12-03T10:11:16Z

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

== Описание свойств и структуры алгоритма ==

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

Численное интегрирование — приближенное вычисление значения определенного интеграла. Допустим, нам дана функция <math>f(x)</math>, определенная на отрезке или многомерном кубе, и возможность получать ее численное значение в любой из точек области определения за фиксированное время. Задача — вычислить определенный интеграл данной функции по заданной области и дать оценку погрешности вычисления.

Исторически численное интегрирование также называлось численной квадратурой, а многомерное — кубатурой. Большая советская энциклопедия определяет слово «квадратура» следующим способом: (лат. quadratura — придание квадратной формы), 1) число квадратных единиц в площади данной фигуры. 2) Построение квадрата, равновеликого данной фигуре. 3) Вычисление площади или интеграла.

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

К данному типу относятся одномерные метод прямоугольников, метод трапеций, метод парабол (метод Симпсона), метод Гаусса, метод Гаусса-Кронрода. Часть перечисленных методов обобщается и для многомерного случая. Обобщенно все эти методы называются квадратурными. В многомерном случае они также могут называться кубатурными (это слово не несет никаких дополнительных смыслов). Также говорится, что перечисленные методы используют квадратурные (кубатурные) формулы.

Подходы, в которых область делится на не равные друг другу отрезки (кубы), называются адаптивными и не рассматриваются к данной статье.

Все перечисленные выше методы, а также подобные им могут быть объединены следующим образом: область интегрирования содержит <math>M</math> точек, в каждой из которых необходимо вычислить подынтегральное выражение и помножить ее на весовой коэффициент, затем данные числа складываются, и полученная сумма и представляет собой результат интегрирования. Погрешность интегрирования оценивается ровно таким же образом.

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

Исходные данные: функция <math>f</math> от <math>n</math> переменных, границы области интегрирования, представляющей собой многомерный куб (по каждой из осей интегрирования заданы минимальное и максимальное значение координаты), максимальное число <math>M</math> точек, в которых можно вычислить функцию <math>f</math>.

Вычисляемые данные: число, представляющее собой приближенное значение интеграла и, если это позволяет выбранный метод, число, представляющее собой оценку погрешности.
По количеству точек <math>M</math> и методу интегрирования определяются размеры прямоугольных параллелепипедов, на которые разбивается область интегрирования. В каждом из параллелепипедов в зависимости от выбора метода определяются свои точки для вычисления функции <math>f</math> и весовые коэффициенты.

Наибольшее разнообразие выбора методов достигается в одномерном случае.

''Метод прямоугольников'': функция для заданного отрезка приближается константной функцией, тем самым, интеграл приближается значением функции в одной точке. Обычно в качестве этой точки используется граница отрезка или, лучше, его середина.
: <math>\int\limits_a^b f(x)\,dx \approx f((a+b)/2) * (b-a)</math>

''Метод трапеций''<nowiki>:</nowiki> <math>f(x)</math> приближается линейной функцией, тем самым, интеграл приближается усредненным значением по краям отрезка:
: <math>\int\limits_a^b f(x)\,dx \approx (f(a) + f(b)) * (b-a)/2</math>

''Метод парабол (метод Симпсона)''<nowiki>:</nowiki> <math>f(x)</math> приближается параболой, пересекающей график функции на краях отрезка и в его середине:
: <math>\int\limits_a^b f(x)\,dx \approx \frac{b-a}{6}\left(f(a)+4f\left(\frac{a+b}{2}\right)+f(b)\right)</math>

''Метод Гаусса''<nowiki>:</nowiki> <math>f(x)</math> приближается прямой как в методе трапеций, однако в качестве точек выбираются не концы отрезка, что позволяет увеличить точность:
: <math>\int\limits_a^b f(x)\,dx \approx \frac{b-a}{2}\left(f\left(\frac{a+b}{2} - \frac{b-a}{2\sqrt{3}} \right)+f\left(\frac{a+b}{2} + \frac{b-a}{2\sqrt{3}} \right) \right)</math>

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

Так или иначе, на подготовительной стадии определяется M наборов координат <math>{x_{1,i}, … x_{n,i}}</math>, где <math>i</math> меняется от <math>1</math> до <math>M</math>, в которых будет вычисляться функция <math>f</math> и набор весовых коэффициентов <math>с_i</math>, на которые будет умножаться значение функции, после чего управление передается вычислительному ядру алгоритма.

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

Вычислительное ядро последовательной версии любого из квадратурных методов численного интегрирования представляет собой вычисление суммы
: <math>\sum \limits_1^M c_i f(x_{1,i}, … x_{n,i}) </math>
Поскольку время, требуемое на операции сложения и умножения в реальных примерах представляют собой о малое от времени, затрачиваемого на вычисление функции <math>f</math>, для производительности становится совершенно неважно, каким способом осуществлять сложение и умножение.

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

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

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

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

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

Время, затрачиваемое на вычисление функции растет примерно как <math>t*M</math>, где <math>t</math> — время, требуемое на вычислении функции <math>f</math>, а <math>M</math> — количество точек, в которых вычисляется функция <math>f</math>. Тем самым, алгоритм является линейным относительно количества точек интегрирования.

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

Опишем граф алгоритма как аналитически, так и в виде рисунка.

Граф алгоритма состоит из трех групп вершин. Вершины на верхнем ярусе берут в качестве входных данных координаты и вычисляют по ним значение функции <math>f</math>. Вершины на втором ярусе умножают полученное значение на соответствующий весовой коэффициент. Вершины на третьем ярусе поочередно складывают полученные значения; результат относится к выходным данным.

[[Image:cubature.svg|center|thumb|640px|Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)]]

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

Для вычисления интеграла функции методом кубатур требуется последовательно выполнить следующие ярусы:
- Вычисление исходной функции <math>f</math>, производящееся независимо для различных точек и выполняющееся за близкое к константному время <math>t</math> — основная часть алгоритма.
- Умножение полученных результатов на соответствующие весовые коэффициенты
- Сложение полученных результатов.

В общем случае время, затрачиваемое на сложение или умножение пренебрежимо мало по сравнением со временем необходимым на вычисление функции <math>f</math>, а все вычисления функции <math>f</math> могут производиться на различных узлах, тем самым, задача вычисления интеграла методом кубатур идеально поддается параллельной реализации. Однако при значительном увеличении количества узлов (в случае, когда оно становится сравнимым с количеством точек, в которых вычисляется функция), ресурс параллелизма может быть ограничен накладными расходами,такими как передача исходного выражения на каждый из вычислительных узлов.

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

=== Описание входных и выходных данных ===

Входными данными для алгоритма являются размерность <math>n</math>, границы интегрирования (два массива длины <math>n</math>), ограничение <math>M</math> на количество точек интегрирования, выбор метода интегрирования и функция <math>f</math> — подынтегральное выражение. Она обычно задается в виде функции, написанной на используемом языке программирования или же в строковом виде, если реализация алгоритма имеет встроенный аналог компилятора, работающий с используемым классом функций.

К входным данными для вычислительного ядра алгоритма относится функция <math>f</math> и массив длины <math>M</math>, содержащий точки, в которых должно быть произведено вычисление.

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

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

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

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

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

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

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

В простейшем варианте вычислительное ядро метода на Фортране можно записать так:

<source lang="fortran">
double::res
DO I = 1, M
double::a = f(x(I))
res = res + a
END DO
</source>

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

Локальность операций существенно определяется реализацией вычисления функции <math>f</math>. Если рассматривать ее вычисление как «черный ящик», то становится совершенно невозможным заботиться об эффективном использовании кэша процессора.

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

Самым естественным способом реализации параллельного алгоритма является независимое вычислении функции <math>f</math> в различных точках разными узлами. При этом это может быть реализовано как при помощи технологии threads при запуске на одном узле, так и, например, при помощи MPI. Головной узел передает определение функции <math>f</math>, и затем раздает подчиненным узлам точки, в которых должна вычисляться функция. Для оптимизации процесса возможно передавать сразу наборы точек.

Также представляется возможным одновременное вычисление нескольких значений функции одним узлом, однако такой подход требует адаптации самого алгоритма вычисления функции <math>f</math> и не всегда является применимым. Например, использование команд типа AVX для микропроцессоров позволяет выполнять по 4 сложения или умножения за такт работы процессора, однако так могут складываться лишь расположенные последовательно вещественные числа типа. Но использование подобных ускорений или, скажем, перевод алгоритма на использование графических процессоров, безусловно требует модификации самого алгоритма вычисления функции <math>f</math> и уточнения класса функций, для которых будет применяться данная реализация.

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

Теоретические оценки показывают, что алгоритм должен быть превосходно масштабируем. Для демонстрации этого утверждения на примере в НИВЦ МГУ был создана реализация алгоритма интегрирования методом прямоугольников. В качестве тестового примера рассматривалось трехмерное интегрирование. Поскольку в задачи не входила оценка сложности вычисления той или иной функции от трех переменных, было выбрано простейшее подынтегральное выражение, <math>x_1^2+x_2^2+x_3^3</math>. Однако такая функция является слишком простой и нетипичной для тех примеров, на которых обычно применяется алгоритм. Поэтому для демонстрации масштабируемости алгоритма на достаточно сложных примерах в вычисление функции в одной точке была заложена пауза длительностью в 0.01 секунды (для типичных примеров длительность может существенно превышать это время, однако и оно оказалось достаточным для проведения демонстрации).

Алгоритм в качестве метода распараллеливания использует технологию MPI. Тесты проводились на суперкомпьютере [http://parallel.ru/cluster/superinfo Ломоносов]. Для демонстрации оказалось достаточным провести тесты с количеством процессоров до 64 (с шагом 8). Для количества точек, в которых вычислялась функция, была введена логарифмическая шкала (от 100 до миллиона с шагом умножения на 10). Причина введения такой шкалы состоит в том, что в настоящих примерах требуется вычислять функцию не меньше, чем в ста тысячах точек и может доходить до миллиарда, а провал эффективности наблюдается лишь при существенно меньших количествах точек интегрирования.

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

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

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации численного интегрирования в зависимости от изменяемых параметров запуска.

[[file:Масштабируемость численного интегрирования методом прямоугольников. Производительность.svg|thumb|center|600px|Рисунок 1. Параллельная реализация интегрирования методом прямоугольников. Изменение производительности в зависимости от числа процессоров и количества вычисляемых точек.]]
[[file:Масштабируемость численного интегрирования методом прямоугольников. Эффективность.svg|thumb|center|600px|Рисунок 2. Параллельная реализация интегрирования методом прямоугольников. Изменение эффективности в зависимости от числа процессоров и количества вычисляемых точек.]]

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

'''????? нам нужна модельная реализация?'''

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

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

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

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

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

Файл:Масштабируемость численного интегрирования методом прямоугольников. Эффективность.svg

2014-12-03T10:10:17Z

Sander:

Файл:Масштабируемость численного интегрирования методом прямоугольников. Производительность.svg

2014-12-03T10:09:53Z

Sander:

Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)

2014-12-03T10:09:28Z

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

== Описание свойств и структуры алгоритма ==

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

Численное интегрирование — приближенное вычисление значения определенного интеграла. Допустим, нам дана функция <math>f(x)</math>, определенная на отрезке или многомерном кубе, и возможность получать ее численное значение в любой из точек области определения за фиксированное время. Задача — вычислить определенный интеграл данной функции по заданной области и дать оценку погрешности вычисления.

Исторически численное интегрирование также называлось численной квадратурой, а многомерное — кубатурой. Большая советская энциклопедия определяет слово «квадратура» следующим способом: (лат. quadratura — придание квадратной формы), 1) число квадратных единиц в площади данной фигуры. 2) Построение квадрата, равновеликого данной фигуре. 3) Вычисление площади или интеграла.

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

К данному типу относятся одномерные метод прямоугольников, метод трапеций, метод парабол (метод Симпсона), метод Гаусса, метод Гаусса-Кронрода. Часть перечисленных методов обобщается и для многомерного случая. Обобщенно все эти методы называются квадратурными. В многомерном случае они также могут называться кубатурными (это слово не несет никаких дополнительных смыслов). Также говорится, что перечисленные методы используют квадратурные (кубатурные) формулы.

Подходы, в которых область делится на не равные друг другу отрезки (кубы), называются адаптивными и не рассматриваются к данной статье.

Все перечисленные выше методы, а также подобные им могут быть объединены следующим образом: область интегрирования содержит <math>M</math> точек, в каждой из которых необходимо вычислить подынтегральное выражение и помножить ее на весовой коэффициент, затем данные числа складываются, и полученная сумма и представляет собой результат интегрирования. Погрешность интегрирования оценивается ровно таким же образом.

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

Исходные данные: функция <math>f</math> от <math>n</math> переменных, границы области интегрирования, представляющей собой многомерный куб (по каждой из осей интегрирования заданы минимальное и максимальное значение координаты), максимальное число <math>M</math> точек, в которых можно вычислить функцию <math>f</math>.

Вычисляемые данные: число, представляющее собой приближенное значение интеграла и, если это позволяет выбранный метод, число, представляющее собой оценку погрешности.
По количеству точек <math>M</math> и методу интегрирования определяются размеры прямоугольных параллелепипедов, на которые разбивается область интегрирования. В каждом из параллелепипедов в зависимости от выбора метода определяются свои точки для вычисления функции <math>f</math> и весовые коэффициенты.

Наибольшее разнообразие выбора методов достигается в одномерном случае.

''Метод прямоугольников'': функция для заданного отрезка приближается константной функцией, тем самым, интеграл приближается значением функции в одной точке. Обычно в качестве этой точки используется граница отрезка или, лучше, его середина.
: <math>\int\limits_a^b f(x)\,dx \approx f((a+b)/2) * (b-a)</math>

''Метод трапеций''<nowiki>:</nowiki> <math>f(x)</math> приближается линейной функцией, тем самым, интеграл приближается усредненным значением по краям отрезка:
: <math>\int\limits_a^b f(x)\,dx \approx (f(a) + f(b)) * (b-a)/2</math>

''Метод парабол (метод Симпсона)''<nowiki>:</nowiki> <math>f(x)</math> приближается параболой, пересекающей график функции на краях отрезка и в его середине:
: <math>\int\limits_a^b f(x)\,dx \approx \frac{b-a}{6}\left(f(a)+4f\left(\frac{a+b}{2}\right)+f(b)\right)</math>

''Метод Гаусса''<nowiki>:</nowiki> <math>f(x)</math> приближается прямой как в методе трапеций, однако в качестве точек выбираются не концы отрезка, что позволяет увеличить точность:
: <math>\int\limits_a^b f(x)\,dx \approx \frac{b-a}{2}\left(f\left(\frac{a+b}{2} - \frac{b-a}{2\sqrt{3}} \right)+f\left(\frac{a+b}{2} + \frac{b-a}{2\sqrt{3}} \right) \right)</math>

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

Так или иначе, на подготовительной стадии определяется M наборов координат <math>{x_{1,i}, … x_{n,i}}</math>, где <math>i</math> меняется от <math>1</math> до <math>M</math>, в которых будет вычисляться функция <math>f</math> и набор весовых коэффициентов <math>с_i</math>, на которые будет умножаться значение функции, после чего управление передается вычислительному ядру алгоритма.

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

Вычислительное ядро последовательной версии любого из квадратурных методов численного интегрирования представляет собой вычисление суммы
: <math>\sum \limits_1^M c_i f(x_{1,i}, … x_{n,i}) </math>
Поскольку время, требуемое на операции сложения и умножения в реальных примерах представляют собой о малое от времени, затрачиваемого на вычисление функции <math>f</math>, для производительности становится совершенно неважно, каким способом осуществлять сложение и умножение.

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

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

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

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

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

Время, затрачиваемое на вычисление функции растет примерно как <math>t*M</math>, где <math>t</math> — время, требуемое на вычислении функции <math>f</math>, а <math>M</math> — количество точек, в которых вычисляется функция <math>f</math>. Тем самым, алгоритм является линейным относительно количества точек интегрирования.

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

Опишем граф алгоритма как аналитически, так и в виде рисунка.

Граф алгоритма состоит из трех групп вершин. Вершины на верхнем ярусе берут в качестве входных данных координаты и вычисляют по ним значение функции <math>f</math>. Вершины на втором ярусе умножают полученное значение на соответствующий весовой коэффициент. Вершины на третьем ярусе поочередно складывают полученные значения; результат относится к выходным данным.

[[Image:cubature.svg|center|thumb|640px|Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)]]

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

Для вычисления интеграла функции методом кубатур требуется последовательно выполнить следующие ярусы:
- Вычисление исходной функции <math>f</math>, производящееся независимо для различных точек и выполняющееся за близкое к константному время <math>t</math> — основная часть алгоритма.
- Умножение полученных результатов на соответствующие весовые коэффициенты
- Сложение полученных результатов.

В общем случае время, затрачиваемое на сложение или умножение пренебрежимо мало по сравнением со временем необходимым на вычисление функции <math>f</math>, а все вычисления функции <math>f</math> могут производиться на различных узлах, тем самым, задача вычисления интеграла методом кубатур идеально поддается параллельной реализации. Однако при значительном увеличении количества узлов (в случае, когда оно становится сравнимым с количеством точек, в которых вычисляется функция), ресурс параллелизма может быть ограничен накладными расходами,такими как передача исходного выражения на каждый из вычислительных узлов.

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

=== Описание входных и выходных данных ===

Входными данными для алгоритма являются размерность <math>n</math>, границы интегрирования (два массива длины <math>n</math>), ограничение <math>M</math> на количество точек интегрирования, выбор метода интегрирования и функция <math>f</math> — подынтегральное выражение. Она обычно задается в виде функции, написанной на используемом языке программирования или же в строковом виде, если реализация алгоритма имеет встроенный аналог компилятора, работающий с используемым классом функций.

К входным данными для вычислительного ядра алгоритма относится функция <math>f</math> и массив длины <math>M</math>, содержащий точки, в которых должно быть произведено вычисление.

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

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

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

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

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

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

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

В простейшем варианте вычислительное ядро метода на Фортране можно записать так:

<source lang="fortran">
double::res
DO I = 1, M
double::a = f(x(I))
res = res + a
END DO
</source>

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

Локальность операций существенно определяется реализацией вычисления функции <math>f</math>. Если рассматривать ее вычисление как «черный ящик», то становится совершенно невозможным заботиться об эффективном использовании кэша процессора.

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

Самым естественным способом реализации параллельного алгоритма является независимое вычислении функции <math>f</math> в различных точках разными узлами. При этом это может быть реализовано как при помощи технологии threads при запуске на одном узле, так и, например, при помощи MPI. Головной узел передает определение функции <math>f</math>, и затем раздает подчиненным узлам точки, в которых должна вычисляться функция. Для оптимизации процесса возможно передавать сразу наборы точек.

Также представляется возможным одновременное вычисление нескольких значений функции одним узлом, однако такой подход требует адаптации самого алгоритма вычисления функции <math>f</math> и не всегда является применимым. Например, использование команд типа AVX для микропроцессоров позволяет выполнять по 4 сложения или умножения за такт работы процессора, однако так могут складываться лишь расположенные последовательно вещественные числа типа. Но использование подобных ускорений или, скажем, перевод алгоритма на использование графических процессоров, безусловно требует модификации самого алгоритма вычисления функции <math>f</math> и уточнения класса функций, для которых будет применяться данная реализация.

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

Теоретические оценки показывают, что алгоритм должен быть превосходно масштабируем. Для демонстрации этого утверждения на примере в НИВЦ МГУ был создана реализация алгоритма интегрирования методом прямоугольников. В качестве тестового примера рассматривалось трехмерное интегрирование. Поскольку в задачи не входила оценка сложности вычисления той или иной функции от трех переменных, было выбрано простейшее подынтегральное выражение, <math>x_1^2+x_2^2+x_3^3</math>. Однако такая функция является слишком простой и нетипичной для тех примеров, на которых обычно применяется алгоритм. Поэтому для демонстрации масштабируемости алгоритма на достаточно сложных примерах в вычисление функции в одной точке была заложена пауза длительностью в 0.01 секунды (для типичных примеров длительность может существенно превышать это время, однако и оно оказалось достаточным для проведения демонстрации).

Алгоритм в качестве метода распараллеливания использует технологию MPI. Тесты проводились на суперкомпьютере [http://parallel.ru/cluster/superinfo Ломоносов]. Для демонстрации оказалось достаточным провести тесты с количеством процессоров до 64 (с шагом 8). Для количества точек, в которых вычислялась функция, была введена логарифмическая шкала (от 100 до миллиона с шагом умножения на 10). Причина введения такой шкалы состоит в том, что в настоящих примерах требуется вычислять функцию не меньше, чем в ста тысячах точек и может доходить до миллиарда, а провал эффективности наблюдается лишь при существенно меньших количествах точек интегрирования.

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

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

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации численного интегрирования в зависимости от изменяемых параметров запуска.

[[file:Масштабируемость численного интегрирования методом прямоугольников. Производительность.svg|thumb|center|680px|Рисунок 1. Параллельная реализация интегрирования методом прямоугольников. Изменение производительности в зависимости от числа процессоров и количества вычисляемых точек.]]
[[file:Масштабируемость численного интегрирования методом прямоугольников. Эффективность.svg|thumb|center|680px|Рисунок 2. Параллельная реализация интегрирования методом прямоугольников. Изменение эффективности в зависимости от числа процессоров и количества вычисляемых точек.]]

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

'''????? нам нужна модельная реализация?'''

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

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

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

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

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

Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)

2014-12-03T10:09:05Z

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

== Описание свойств и структуры алгоритма ==

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

Численное интегрирование — приближенное вычисление значения определенного интеграла. Допустим, нам дана функция <math>f(x)</math>, определенная на отрезке или многомерном кубе, и возможность получать ее численное значение в любой из точек области определения за фиксированное время. Задача — вычислить определенный интеграл данной функции по заданной области и дать оценку погрешности вычисления.

Исторически численное интегрирование также называлось численной квадратурой, а многомерное — кубатурой. Большая советская энциклопедия определяет слово «квадратура» следующим способом: (лат. quadratura — придание квадратной формы), 1) число квадратных единиц в площади данной фигуры. 2) Построение квадрата, равновеликого данной фигуре. 3) Вычисление площади или интеграла.

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

К данному типу относятся одномерные метод прямоугольников, метод трапеций, метод парабол (метод Симпсона), метод Гаусса, метод Гаусса-Кронрода. Часть перечисленных методов обобщается и для многомерного случая. Обобщенно все эти методы называются квадратурными. В многомерном случае они также могут называться кубатурными (это слово не несет никаких дополнительных смыслов). Также говорится, что перечисленные методы используют квадратурные (кубатурные) формулы.

Подходы, в которых область делится на не равные друг другу отрезки (кубы), называются адаптивными и не рассматриваются к данной статье.

Все перечисленные выше методы, а также подобные им могут быть объединены следующим образом: область интегрирования содержит <math>M</math> точек, в каждой из которых необходимо вычислить подынтегральное выражение и помножить ее на весовой коэффициент, затем данные числа складываются, и полученная сумма и представляет собой результат интегрирования. Погрешность интегрирования оценивается ровно таким же образом.

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

Исходные данные: функция <math>f</math> от <math>n</math> переменных, границы области интегрирования, представляющей собой многомерный куб (по каждой из осей интегрирования заданы минимальное и максимальное значение координаты), максимальное число <math>M</math> точек, в которых можно вычислить функцию <math>f</math>.

Вычисляемые данные: число, представляющее собой приближенное значение интеграла и, если это позволяет выбранный метод, число, представляющее собой оценку погрешности.
По количеству точек <math>M</math> и методу интегрирования определяются размеры прямоугольных параллелепипедов, на которые разбивается область интегрирования. В каждом из параллелепипедов в зависимости от выбора метода определяются свои точки для вычисления функции <math>f</math> и весовые коэффициенты.

Наибольшее разнообразие выбора методов достигается в одномерном случае.

''Метод прямоугольников'': функция для заданного отрезка приближается константной функцией, тем самым, интеграл приближается значением функции в одной точке. Обычно в качестве этой точки используется граница отрезка или, лучше, его середина.
: <math>\int\limits_a^b f(x)\,dx \approx f((a+b)/2) * (b-a)</math>

''Метод трапеций''<nowiki>:</nowiki> <math>f(x)</math> приближается линейной функцией, тем самым, интеграл приближается усредненным значением по краям отрезка:
: <math>\int\limits_a^b f(x)\,dx \approx (f(a) + f(b)) * (b-a)/2</math>

''Метод парабол (метод Симпсона)''<nowiki>:</nowiki> <math>f(x)</math> приближается параболой, пересекающей график функции на краях отрезка и в его середине:
: <math>\int\limits_a^b f(x)\,dx \approx \frac{b-a}{6}\left(f(a)+4f\left(\frac{a+b}{2}\right)+f(b)\right)</math>

''Метод Гаусса''<nowiki>:</nowiki> <math>f(x)</math> приближается прямой как в методе трапеций, однако в качестве точек выбираются не концы отрезка, что позволяет увеличить точность:
: <math>\int\limits_a^b f(x)\,dx \approx \frac{b-a}{2}\left(f\left(\frac{a+b}{2} - \frac{b-a}{2\sqrt{3}} \right)+f\left(\frac{a+b}{2} + \frac{b-a}{2\sqrt{3}} \right) \right)</math>

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

Так или иначе, на подготовительной стадии определяется M наборов координат <math>{x_{1,i}, … x_{n,i}}</math>, где <math>i</math> меняется от <math>1</math> до <math>M</math>, в которых будет вычисляться функция <math>f</math> и набор весовых коэффициентов <math>с_i</math>, на которые будет умножаться значение функции, после чего управление передается вычислительному ядру алгоритма.

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

Вычислительное ядро последовательной версии любого из квадратурных методов численного интегрирования представляет собой вычисление суммы
: <math>\sum \limits_1^M c_i f(x_{1,i}, … x_{n,i}) </math>
Поскольку время, требуемое на операции сложения и умножения в реальных примерах представляют собой о малое от времени, затрачиваемого на вычисление функции <math>f</math>, для производительности становится совершенно неважно, каким способом осуществлять сложение и умножение.

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

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

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

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

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

Время, затрачиваемое на вычисление функции растет примерно как <math>t*M</math>, где <math>t</math> — время, требуемое на вычислении функции <math>f</math>, а <math>M</math> — количество точек, в которых вычисляется функция <math>f</math>. Тем самым, алгоритм является линейным относительно количества точек интегрирования.

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

Опишем граф алгоритма как аналитически, так и в виде рисунка.

Граф алгоритма состоит из трех групп вершин. Вершины на верхнем ярусе берут в качестве входных данных координаты и вычисляют по ним значение функции <math>f</math>. Вершины на втором ярусе умножают полученное значение на соответствующий весовой коэффициент. Вершины на третьем ярусе поочередно складывают полученные значения; результат относится к выходным данным.

[[Image:cubature.svg|center|thumb|640px|Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)]]

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

Для вычисления интеграла функции методом кубатур требуется последовательно выполнить следующие ярусы:
- Вычисление исходной функции <math>f</math>, производящееся независимо для различных точек и выполняющееся за близкое к константному время <math>t</math> — основная часть алгоритма.
- Умножение полученных результатов на соответствующие весовые коэффициенты
- Сложение полученных результатов.

В общем случае время, затрачиваемое на сложение или умножение пренебрежимо мало по сравнением со временем необходимым на вычисление функции <math>f</math>, а все вычисления функции <math>f</math> могут производиться на различных узлах, тем самым, задача вычисления интеграла методом кубатур идеально поддается параллельной реализации. Однако при значительном увеличении количества узлов (в случае, когда оно становится сравнимым с количеством точек, в которых вычисляется функция), ресурс параллелизма может быть ограничен накладными расходами,такими как передача исходного выражения на каждый из вычислительных узлов.

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

=== Описание входных и выходных данных ===

Входными данными для алгоритма являются размерность <math>n</math>, границы интегрирования (два массива длины <math>n</math>), ограничение <math>M</math> на количество точек интегрирования, выбор метода интегрирования и функция <math>f</math> — подынтегральное выражение. Она обычно задается в виде функции, написанной на используемом языке программирования или же в строковом виде, если реализация алгоритма имеет встроенный аналог компилятора, работающий с используемым классом функций.

К входным данными для вычислительного ядра алгоритма относится функция <math>f</math> и массив длины <math>M</math>, содержащий точки, в которых должно быть произведено вычисление.

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

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

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

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

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

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

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

В простейшем варианте вычислительное ядро метода на Фортране можно записать так:

<source lang="fortran">
double::res
DO I = 1, M
double::a = f(x(I))
res = res + a
END DO
</source>

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

Локальность операций существенно определяется реализацией вычисления функции <math>f</math>. Если рассматривать ее вычисление как «черный ящик», то становится совершенно невозможным заботиться об эффективном использовании кэша процессора.

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

Самым естественным способом реализации параллельного алгоритма является независимое вычислении функции <math>f</math> в различных точках разными узлами. При этом это может быть реализовано как при помощи технологии threads при запуске на одном узле, так и, например, при помощи MPI. Головной узел передает определение функции <math>f</math>, и затем раздает подчиненным узлам точки, в которых должна вычисляться функция. Для оптимизации процесса возможно передавать сразу наборы точек.

Также представляется возможным одновременное вычисление нескольких значений функции одним узлом, однако такой подход требует адаптации самого алгоритма вычисления функции <math>f</math> и не всегда является применимым. Например, использование команд типа AVX для микропроцессоров позволяет выполнять по 4 сложения или умножения за такт работы процессора, однако так могут складываться лишь расположенные последовательно вещественные числа типа. Но использование подобных ускорений или, скажем, перевод алгоритма на использование графических процессоров, безусловно требует модификации самого алгоритма вычисления функции <math>f</math> и уточнения класса функций, для которых будет применяться данная реализация.

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

Теоретические оценки показывают, что алгоритм должен быть превосходно масштабируем. Для демонстрации этого утверждения на примере в НИВЦ МГУ был создана реализация алгоритма интегрирования методом прямоугольников. В качестве тестового примера рассматривалось трехмерное интегрирование. Поскольку в задачи не входила оценка сложности вычисления той или иной функции от трех переменных, было выбрано простейшее подынтегральное выражение, <math>x_1^2+x_2^2+x_3^3</math>. Однако такая функция является слишком простой и нетипичной для тех примеров, на которых обычно применяется алгоритм. Поэтому для демонстрации масштабируемости алгоритма на достаточно сложных примерах в вычисление функции в одной точке была заложена пауза длительностью в 0.01 секунды (для типичных примеров длительность может существенно превышать это время, однако и оно оказалось достаточным для проведения демонстрации).

Алгоритм в качестве метода распараллеливания использует технологию MPI. Тесты проводились на суперкомпьютере [http://parallel.ru/cluster/superinfo Ломоносов]. Для демонстрации оказалось достаточным провести тесты с количеством процессоров до 64 (с шагом 8). Для количества точек, в которых вычислялась функция, была введена логарифмическая шкала (от 100 до миллиона с шагом умножения на 10). Причина введения такой шкалы состоит в том, что в настоящих примерах требуется вычислять функцию не меньше, чем в ста тысячах точек и может доходить до миллиарда, а провал эффективности наблюдается лишь при существенно меньших количествах точек интегрирования.

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

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

На следующих рисунках приведены графики [[Глоссарий#Производительность|производительности]] и эффективности выбранной реализации численного интегрирования в зависимости от изменяемых параметров запуска.

[[file:Масштабируемость численного интегрирования методом прямоугольников. Производительность.png|thumb|center|680px|Рисунок 1. Параллельная реализация интегрирования методом прямоугольников. Изменение производительности в зависимости от числа процессоров и количества вычисляемых точек.]]
[[file:Масштабируемость численного интегрирования методом прямоугольников. Эффективность.png|thumb|center|680px|Рисунок 2. Параллельная реализация интегрирования методом прямоугольников. Изменение эффективности в зависимости от числа процессоров и количества вычисляемых точек.]]

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

'''????? нам нужна модельная реализация?'''

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

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

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

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

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

Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)

2014-11-26T13:02:48Z

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

== Описание свойств и структуры алгоритма ==

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

Численное интегрирование — приближенное вычисление значения определенного интеграла. Допустим, нам дана функция <math>f(x)</math>, определенная на отрезке или многомерном кубе, и возможность получать ее численное значение в любой из точек области определения за фиксированное время. Задача — вычислить определенный интеграл данной функции по заданной области и дать оценку погрешности вычисления.

Исторически численное интегрирование также называлось численной квадратурой, а многомерное — кубатурой. Большая советская энциклопедия определяет слово «квадратура» следующим способом: (лат. quadratura — придание квадратной формы), 1) число квадратных единиц в площади данной фигуры. 2) Построение квадрата, равновеликого данной фигуре. 3) Вычисление площади или интеграла.

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

К данному типу относятся одномерные метод прямоугольников, метод трапеций, метод парабол (метод Симпсона), метод Гаусса, метод Гаусса-Кронрода. Часть перечисленных методов обобщается и для многомерного случая. Обобщенно все эти методы называются квадратурными. В многомерном случае они также могут называться кубатурными (это слово не несет никаких дополнительных смыслов). Также говорится, что перечисленные методы используют квадратурные (кубатурные) формулы.

Подходы, в которых область делится на не равные друг другу отрезки (кубы), называются адаптивными и не рассматриваются к данной статье.

Все перечисленные выше методы, а также подобные им могут быть объединены следующим образом: область интегрирования содержит <math>M</math> точек, в каждой из которых необходимо вычислить подынтегральное выражение и помножить ее на весовой коэффициент, затем данные числа складываются, и полученная сумма и представляет собой результат интегрирования. Погрешность интегрирования оценивается ровно таким же образом.

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

Исходные данные: функция <math>f</math> от <math>n</math> переменных, границы области интегрирования, представляющей собой многомерный куб (по каждой из осей интегрирования заданы минимальное и максимальное значение координаты), максимальное число <math>M</math> точек, в которых можно вычислить функцию <math>f</math>.

Вычисляемые данные: число, представляющее собой приближенное значение интеграла и, если это позволяет выбранный метод, число, представляющее собой оценку погрешности.
По количеству точек <math>M</math> и методу интегрирования определяются размеры прямоугольных параллелепипедов, на которые разбивается область интегрирования. В каждом из параллелепипедов в зависимости от выбора метода определяются свои точки для вычисления функции <math>f</math> и весовые коэффициенты.

Наибольшее разнообразие выбора методов достигается в одномерном случае.

''Метод прямоугольников'': функция для заданного отрезка приближается константной функцией, тем самым, интеграл приближается значением функции в одной точке. Обычно в качестве этой точки используется граница отрезка или, лучше, его середина.
: <math>\int\limits_a^b f(x)\,dx \approx f((a+b)/2) * (b-a)</math>

''Метод трапеций''<nowiki>:</nowiki> <math>f(x)</math> приближается линейной функцией, тем самым, интеграл приближается усредненным значением по краям отрезка:
: <math>\int\limits_a^b f(x)\,dx \approx (f(a) + f(b)) * (b-a)/2</math>

''Метод парабол (метод Симпсона)''<nowiki>:</nowiki> <math>f(x)</math> приближается параболой, пересекающей график функции на краях отрезка и в его середине:
: <math>\int\limits_a^b f(x)\,dx \approx \frac{b-a}{6}\left(f(a)+4f\left(\frac{a+b}{2}\right)+f(b)\right)</math>

''Метод Гаусса''<nowiki>:</nowiki> <math>f(x)</math> приближается прямой как в методе трапеций, однако в качестве точек выбираются не концы отрезка, что позволяет увеличить точность:
: <math>\int\limits_a^b f(x)\,dx \approx \frac{b-a}{2}\left(f\left(\frac{a+b}{2} - \frac{b-a}{2\sqrt{3}} \right)+f\left(\frac{a+b}{2} + \frac{b-a}{2\sqrt{3}} \right) \right)</math>

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

Так или иначе, на подготовительной стадии определяется M наборов координат <math>{x_{1,i}, … x_{n,i}}</math>, где <math>i</math> меняется от <math>1</math> до <math>M</math>, в которых будет вычисляться функция <math>f</math> и набор весовых коэффициентов <math>с_i</math>, на которые будет умножаться значение функции, после чего управление передается вычислительному ядру алгоритма.

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

Вычислительное ядро последовательной версии любого из квадратурных методов численного интегрирования представляет собой вычисление суммы
: <math>\sum \limits_1^M c_i f(x_{1,i}, … x_{n,i}) </math>
Поскольку время, требуемое на операции сложения и умножения в реальных примерах представляют собой о малое от времени, затрачиваемого на вычисление функции <math>f</math>, для производительности становится совершенно неважно, каким способом осуществлять сложение и умножение.

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

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

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

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

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

Время, затрачиваемое на вычисление функции растет примерно как <math>t*M</math>, где <math>t</math> — время, требуемое на вычислении функции <math>f</math>, а <math>M</math> — количество точек, в которых вычисляется функция <math>f</math>. Тем самым, алгоритм является линейным относительно количества точек интегрирования.

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

Опишем граф алгоритма как аналитически, так и в виде рисунка.

Граф алгоритма состоит из трех групп вершин. Вершины на верхнем ярусе берут в качестве входных данных координаты и вычисляют по ним значение функции <math>f</math>. Вершины на втором ярусе умножают полученное значение на соответствующий весовой коэффициент. Вершины на третьем ярусе поочередно складывают полученные значения; результат относится к выходным данным.

[[Image:cubature.svg|center|thumb|640px|Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)]]

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

Для вычисления интеграла функции методом кубатур требуется последовательно выполнить следующие ярусы:
- Вычисление исходной функции <math>f</math>, производящееся независимо для различных точек и выполняющееся за близкое к константному время <math>t</math> — основная часть алгоритма.
- Умножение полученных результатов на соответствующие весовые коэффициенты
- Сложение полученных результатов.

В общем случае время, затрачиваемое на сложение или умножение пренебрежимо мало по сравнением со временем необходимым на вычисление функции <math>f</math>, а все вычисления функции <math>f</math> могут производиться на различных узлах, тем самым, задача вычисления интеграла методом кубатур идеально поддается параллельной реализации. Однако при значительном увеличении количества узлов (в случае, когда оно становится сравнимым с количеством точек, в которых вычисляется функция), ресурс параллелизма может быть ограничен накладными расходами,такими как передача исходного выражения на каждый из вычислительных узлов.

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

=== Описание входных и выходных данных ===

Входными данными для алгоритма являются размерность <math>n</math>, границы интегрирования (два массива длины <math>n</math>), ограничение <math>M</math> на количество точек интегрирования, выбор метода интегрирования и функция <math>f</math> — подынтегральное выражение. Она обычно задается в виде функции, написанной на используемом языке программирования или же в строковом виде, если реализация алгоритма имеет встроенный аналог компилятора, работающий с используемым классом функций.

К входным данными для вычислительного ядра алгоритма относится функция <math>f</math> и массив длины <math>M</math>, содержащий точки, в которых должно быть произведено вычисление.

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

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

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

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

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

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

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

В простейшем варианте вычислительное ядро метода на Фортране можно записать так:

<source lang="fortran">
double::res
DO I = 1, M
double::a = f(x(I))
res = res + a
END DO
</source>

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

Локальность операций существенно определяется реализацией вычисления функции <math>f</math>. Если рассматривать ее вычисление как «черный ящик», то становится совершенно невозможным заботиться об эффективном использовании кэша процессора.

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

Самым естественным способом реализации параллельного алгоритма является независимое вычислении функции <math>f</math> в различных точках разными узлами. При этом это может быть реализовано как при помощи технологии threads при запуске на одном узле, так и, например, при помощи MPI. Головной узел передает определение функции <math>f</math>, и затем раздает подчиненным узлам точки, в которых должна вычисляться функция. Для оптимизации процесса возможно передавать сразу наборы точек.

Также представляется возможным одновременное вычисление нескольких значений функции одним узлом, однако такой подход требует адаптации самого алгоритма вычисления функции <math>f</math> и не всегда является применимым. Например, использование команд типа AVX для микропроцессоров позволяет выполнять по 4 сложения или умножения за такт работы процессора, однако так могут складываться лишь расположенные последовательно вещественные числа типа. Но использование подобных ускорений или, скажем, перевод алгоритма на использование графических процессоров, безусловно требует модификации самого алгоритма вычисления функции <math>f</math> и уточнения класса функций, для которых будет применяться данная реализация.

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

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

'''????? нам нужна модельная реализация?'''

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

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

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

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

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

Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)

2014-11-26T13:01:04Z

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

== Описание свойств и структуры алгоритма ==

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

Численное интегрирование — приближенное вычисление значения определенного интеграла. Допустим, нам дана функция <math>f(x)</math>, определенная на отрезке или многомерном кубе, и возможность получать ее численное значение в любой из точек области определения за фиксированное время. Задача — вычислить определенный интеграл данной функции по заданной области и дать оценку погрешности вычисления.

Исторически численное интегрирование также называлось численной квадратурой, а многомерное — кубатурой. Большая советская энциклопедия определяет слово «квадратура» следующим способом: (лат. quadratura — придание квадратной формы), 1) число квадратных единиц в площади данной фигуры. 2) Построение квадрата, равновеликого данной фигуре. 3) Вычисление площади или интеграла.

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

К данному типу относятся одномерные метод прямоугольников, метод трапеций, метод парабол (метод Симпсона), метод Гаусса, метод Гаусса-Кронрода. Часть перечисленных методов обобщается и для многомерного случая. Обобщенно все эти методы называются квадратурными. В многомерном случае они также могут называться кубатурными (это слово не несет никаких дополнительных смыслов). Также говорится, что перечисленные методы используют квадратурные (кубатурные) формулы.

Подходы, в которых область делится на не равные друг другу отрезки (кубы), называются адаптивными и не рассматриваются к данной статье.

Все перечисленные выше методы, а также подобные им могут быть объединены следующим образом: область интегрирования содержит <math>M</math> точек, в каждой из которых необходимо вычислить подынтегральное выражение и помножить ее на весовой коэффициент, затем данные числа складываются, и полученная сумма и представляет собой результат интегрирования. Погрешность интегрирования оценивается ровно таким же образом.

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

Исходные данные: функция <math>f</math> от <math>n</math> переменных, границы области интегрирования, представляющей собой многомерный куб (по каждой из осей интегрирования заданы минимальное и максимальное значение координаты), максимальное число <math>M</math> точек, в которых можно вычислить функцию <math>f</math>.

Вычисляемые данные: число, представляющее собой приближенное значение интеграла и, если это позволяет выбранный метод, число, представляющее собой оценку погрешности.
По количеству точек <math>M</math> и методу интегрирования определяются размеры прямоугольных параллелепипедов, на которые разбивается область интегрирования. В каждом из параллелепипедов в зависимости от выбора метода определяются свои точки для вычисления функции <math>f</math> и весовые коэффициенты.

Наибольшее разнообразие выбора методов достигается в одномерном случае.

''Метод прямоугольников'': функция для заданного отрезка приближается константной функцией, тем самым, интеграл приближается значением функции в одной точке. Обычно в качестве этой точки используется граница отрезка или, лучше, его середина.
: <math>\int\limits_a^b f(x)\,dx \approx f((a+b)/2) * (b-a)</math>

''Метод трапеций''<nowiki>:</nowiki> <math>f(x)</math> приближается линейной функцией, тем самым, интеграл приближается усредненным значением по краям отрезка:
: <math>\int\limits_a^b f(x)\,dx \approx (f(a) + f(b)) * (b-a)/2</math>

''Метод парабол (метод Симпсона)''<nowiki>:</nowiki> <math>f(x)</math> приближается параболой, пересекающей график функции на краях отрезка и в его середине:
: <math>\int\limits_a^b f(x)\,dx \approx \frac{b-a}{6}\left(f(a)+4f\left(\frac{a+b}{2}\right)+f(b)\right)</math>

''Метод Гаусса''<nowiki>:</nowiki> <math>f(x)</math> приближается прямой как в методе трапеций, однако в качестве точек выбираются не концы отрезка, что позволяет увеличить точность:
: <math>\int\limits_a^b f(x)\,dx \approx \frac{b-a}{2}\left(f\left(\frac{a+b}{2} - \frac{b-a}{2\sqrt{3}} \right)+f\left(\frac{a+b}{2} + \frac{b-a}{2\sqrt{3}} \right) \right)</math>

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

Так или иначе, на подготовительной стадии определяется M наборов координат <math>{x_{1,i}, … x_{n,i}}</math>, где <math>i</math> меняется от <math>1</math> до <math>M</math>, в которых будет вычисляться функция <math>f</math> и набор весовых коэффициентов <math>с_i</math>, на которые будет умножаться значение функции, после чего управление передается вычислительному ядру алгоритма.

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

Вычислительное ядро последовательной версии любого из квадратурных методов численного интегрирования представляет собой вычисление суммы
: <math>\sum \limits_1^M c_i f(x_{1,i}, … x_{n,i}) </math>
Поскольку время, требуемое на операции сложения и умножения в реальных примерах представляют собой о малое от времени, затрачиваемого на вычисление функции <math>f</math>, для производительности становится совершенно неважно, каким способом осуществлять сложение и умножение.

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

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

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

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

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

Время, затрачиваемое на вычисление функции растет примерно как <math>t*M</math>, где <math>t</math> — время, требуемое на вычислении функции <math>f</math>, а <math>M</math> — количество точек, в которых вычисляется функция <math>f</math>. Тем самым, алгоритм является линейным относительно количества точек интегрирования.

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

Опишем граф алгоритма как аналитически, так и в виде рисунка.

Граф алгоритма состоит из трех групп вершин. Вершины на верхнем ярусе берут в качестве входных данных координаты и вычисляют по ним значение функции <math>f</math>. Вершины на втором ярусе умножают полученное значение на соответствующий весовой коэффициент. Вершины на третьем ярусе поочередно складывают полученные значения; результат относится к выходным данным.

[[Image:cubature.svg|center|thumb|600px|Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)]]

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

Для вычисления интеграла функции методом кубатур требуется последовательно выполнить следующие ярусы:
- Вычисление исходной функции <math>f</math>, производящееся независимо для различных точек и выполняющееся за близкое к константному время <math>t</math> — основная часть алгоритма.
- Умножение полученных результатов на соответствующие весовые коэффициенты
- Сложение полученных результатов.

В общем случае время, затрачиваемое на сложение или умножение пренебрежимо мало по сравнением со временем необходимым на вычисление функции <math>f</math>, а все вычисления функции <math>f</math> могут производиться на различных узлах, тем самым, задача вычисления интеграла методом кубатур идеально поддается параллельной реализации. Однако при значительном увеличении количества узлов (в случае, когда оно становится сравнимым с количеством точек, в которых вычисляется функция), ресурс параллелизма может быть ограничен накладными расходами,такими как передача исходного выражения на каждый из вычислительных узлов.

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

=== Описание входных и выходных данных ===

Входными данными для алгоритма являются размерность <math>n</math>, границы интегрирования (два массива длины <math>n</math>), ограничение <math>M</math> на количество точек интегрирования, выбор метода интегрирования и функция <math>f</math> — подынтегральное выражение. Она обычно задается в виде функции, написанной на используемом языке программирования или же в строковом виде, если реализация алгоритма имеет встроенный аналог компилятора, работающий с используемым классом функций.

К входным данными для вычислительного ядра алгоритма относится функция <math>f</math> и массив длины <math>M</math>, содержащий точки, в которых должно быть произведено вычисление.

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

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

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

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

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

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

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

В простейшем варианте вычислительное ядро метода на Фортране можно записать так:

<source lang="fortran">
double::res
DO I = 1, M
double::a = f(x(I))
res = res + a
END DO
</source>

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

Локальность операций существенно определяется реализацией вычисления функции <math>f</math>. Если рассматривать ее вычисление как «черный ящик», то становится совершенно невозможным заботиться об эффективном использовании кэша процессора.

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

Самым естественным способом реализации параллельного алгоритма является независимое вычислении функции <math>f</math> в различных точках разными узлами. При этом это может быть реализовано как при помощи технологии threads при запуске на одном узле, так и, например, при помощи MPI. Головной узел передает определение функции <math>f</math>, и затем раздает подчиненным узлам точки, в которых должна вычисляться функция. Для оптимизации процесса возможно передавать сразу наборы точек.

Также представляется возможным одновременное вычисление нескольких значений функции одним узлом, однако такой подход требует адаптации самого алгоритма вычисления функции <math>f</math> и не всегда является применимым. Например, использование команд типа AVX для микропроцессоров позволяет выполнять по 4 сложения или умножения за такт работы процессора, однако так могут складываться лишь расположенные последовательно вещественные числа типа. Но использование подобных ускорений или, скажем, перевод алгоритма на использование графических процессоров, безусловно требует модификации самого алгоритма вычисления функции <math>f</math> и уточнения класса функций, для которых будет применяться данная реализация.

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

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

'''????? нам нужна модельная реализация?'''

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

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

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

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

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

Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)

2014-11-26T13:00:41Z

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

== Описание свойств и структуры алгоритма ==

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

Численное интегрирование — приближенное вычисление значения определенного интеграла. Допустим, нам дана функция <math>f(x)</math>, определенная на отрезке или многомерном кубе, и возможность получать ее численное значение в любой из точек области определения за фиксированное время. Задача — вычислить определенный интеграл данной функции по заданной области и дать оценку погрешности вычисления.

Исторически численное интегрирование также называлось численной квадратурой, а многомерное — кубатурой. Большая советская энциклопедия определяет слово «квадратура» следующим способом: (лат. quadratura — придание квадратной формы), 1) число квадратных единиц в площади данной фигуры. 2) Построение квадрата, равновеликого данной фигуре. 3) Вычисление площади или интеграла.

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

К данному типу относятся одномерные метод прямоугольников, метод трапеций, метод парабол (метод Симпсона), метод Гаусса, метод Гаусса-Кронрода. Часть перечисленных методов обобщается и для многомерного случая. Обобщенно все эти методы называются квадратурными. В многомерном случае они также могут называться кубатурными (это слово не несет никаких дополнительных смыслов). Также говорится, что перечисленные методы используют квадратурные (кубатурные) формулы.

Подходы, в которых область делится на не равные друг другу отрезки (кубы), называются адаптивными и не рассматриваются к данной статье.

Все перечисленные выше методы, а также подобные им могут быть объединены следующим образом: область интегрирования содержит <math>M</math> точек, в каждой из которых необходимо вычислить подынтегральное выражение и помножить ее на весовой коэффициент, затем данные числа складываются, и полученная сумма и представляет собой результат интегрирования. Погрешность интегрирования оценивается ровно таким же образом.

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

Исходные данные: функция <math>f</math> от <math>n</math> переменных, границы области интегрирования, представляющей собой многомерный куб (по каждой из осей интегрирования заданы минимальное и максимальное значение координаты), максимальное число <math>M</math> точек, в которых можно вычислить функцию <math>f</math>.

Вычисляемые данные: число, представляющее собой приближенное значение интеграла и, если это позволяет выбранный метод, число, представляющее собой оценку погрешности.
По количеству точек <math>M</math> и методу интегрирования определяются размеры прямоугольных параллелепипедов, на которые разбивается область интегрирования. В каждом из параллелепипедов в зависимости от выбора метода определяются свои точки для вычисления функции <math>f</math> и весовые коэффициенты.

Наибольшее разнообразие выбора методов достигается в одномерном случае.

''Метод прямоугольников'': функция для заданного отрезка приближается константной функцией, тем самым, интеграл приближается значением функции в одной точке. Обычно в качестве этой точки используется граница отрезка или, лучше, его середина.
: <math>\int\limits_a^b f(x)\,dx \approx f((a+b)/2) * (b-a)</math>

''Метод трапеций''<nowiki>:</nowiki> <math>f(x)</math> приближается линейной функцией, тем самым, интеграл приближается усредненным значением по краям отрезка:
: <math>\int\limits_a^b f(x)\,dx \approx (f(a) + f(b)) * (b-a)/2</math>

''Метод парабол (метод Симпсона)''<nowiki>:</nowiki> <math>f(x)</math> приближается параболой, пересекающей график функции на краях отрезка и в его середине:
: <math>\int\limits_a^b f(x)\,dx \approx \frac{b-a}{6}\left(f(a)+4f\left(\frac{a+b}{2}\right)+f(b)\right)</math>

''Метод Гаусса''<nowiki>:</nowiki> <math>f(x)</math> приближается прямой как в методе трапеций, однако в качестве точек выбираются не концы отрезка, что позволяет увеличить точность:
: <math>\int\limits_a^b f(x)\,dx \approx \frac{b-a}{2}\left(f\left(\frac{a+b}{2} - \frac{b-a}{2\sqrt{3}} \right)+f\left(\frac{a+b}{2} + \frac{b-a}{2\sqrt{3}} \right) \right)</math>

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

Так или иначе, на подготовительной стадии определяется M наборов координат <math>{x_{1,i}, … x_{n,i}}</math>, где <math>i</math> меняется от <math>1</math> до <math>M</math>, в которых будет вычисляться функция <math>f</math> и набор весовых коэффициентов <math>с_i</math>, на которые будет умножаться значение функции, после чего управление передается вычислительному ядру алгоритма.

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

Вычислительное ядро последовательной версии любого из квадратурных методов численного интегрирования представляет собой вычисление суммы
: <math>\sum \limits_1^M c_i f(x_{1,i}, … x_{n,i}) </math>
Поскольку время, требуемое на операции сложения и умножения в реальных примерах представляют собой о малое от времени, затрачиваемого на вычисление функции <math>f</math>, для производительности становится совершенно неважно, каким способом осуществлять сложение и умножение.

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

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

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

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

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

Время, затрачиваемое на вычисление функции растет примерно как <math>t*M</math>, где <math>t</math> — время, требуемое на вычислении функции <math>f</math>, а <math>M</math> — количество точек, в которых вычисляется функция <math>f</math>. Тем самым, алгоритм является линейным относительно количества точек интегрирования.

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

Опишем граф алгоритма как аналитически, так и в виде рисунка.

Граф алгоритма состоит из трех групп вершин. Вершины на верхнем ярусе берут в качестве входных данных координаты и вычисляют по ним значение функции <math>f</math>. Вершины на втором ярусе умножают полученное значение на соответствующий весовой коэффициент. Вершины на третьем ярусе поочередно складывают полученные значения; результат относится к выходным данным.

[[Image:cubature.svg|center|thumb|400px|Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)]]

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

Для вычисления интеграла функции методом кубатур требуется последовательно выполнить следующие ярусы:
- Вычисление исходной функции <math>f</math>, производящееся независимо для различных точек и выполняющееся за близкое к константному время <math>t</math> — основная часть алгоритма.
- Умножение полученных результатов на соответствующие весовые коэффициенты
- Сложение полученных результатов.

В общем случае время, затрачиваемое на сложение или умножение пренебрежимо мало по сравнением со временем необходимым на вычисление функции <math>f</math>, а все вычисления функции <math>f</math> могут производиться на различных узлах, тем самым, задача вычисления интеграла методом кубатур идеально поддается параллельной реализации. Однако при значительном увеличении количества узлов (в случае, когда оно становится сравнимым с количеством точек, в которых вычисляется функция), ресурс параллелизма может быть ограничен накладными расходами,такими как передача исходного выражения на каждый из вычислительных узлов.

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

=== Описание входных и выходных данных ===

Входными данными для алгоритма являются размерность <math>n</math>, границы интегрирования (два массива длины <math>n</math>), ограничение <math>M</math> на количество точек интегрирования, выбор метода интегрирования и функция <math>f</math> — подынтегральное выражение. Она обычно задается в виде функции, написанной на используемом языке программирования или же в строковом виде, если реализация алгоритма имеет встроенный аналог компилятора, работающий с используемым классом функций.

К входным данными для вычислительного ядра алгоритма относится функция <math>f</math> и массив длины <math>M</math>, содержащий точки, в которых должно быть произведено вычисление.

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

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

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

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

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

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

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

В простейшем варианте вычислительное ядро метода на Фортране можно записать так:

<source lang="fortran">
double::res
DO I = 1, M
double::a = f(x(I))
res = res + a
END DO
</source>

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

Локальность операций существенно определяется реализацией вычисления функции <math>f</math>. Если рассматривать ее вычисление как «черный ящик», то становится совершенно невозможным заботиться об эффективном использовании кэша процессора.

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

Самым естественным способом реализации параллельного алгоритма является независимое вычислении функции <math>f</math> в различных точках разными узлами. При этом это может быть реализовано как при помощи технологии threads при запуске на одном узле, так и, например, при помощи MPI. Головной узел передает определение функции <math>f</math>, и затем раздает подчиненным узлам точки, в которых должна вычисляться функция. Для оптимизации процесса возможно передавать сразу наборы точек.

Также представляется возможным одновременное вычисление нескольких значений функции одним узлом, однако такой подход требует адаптации самого алгоритма вычисления функции <math>f</math> и не всегда является применимым. Например, использование команд типа AVX для микропроцессоров позволяет выполнять по 4 сложения или умножения за такт работы процессора, однако так могут складываться лишь расположенные последовательно вещественные числа типа. Но использование подобных ускорений или, скажем, перевод алгоритма на использование графических процессоров, безусловно требует модификации самого алгоритма вычисления функции <math>f</math> и уточнения класса функций, для которых будет применяться данная реализация.

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

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

'''????? нам нужна модельная реализация?'''

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

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

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

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

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

Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)

2014-11-26T13:00:24Z

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

== Описание свойств и структуры алгоритма ==

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

Численное интегрирование — приближенное вычисление значения определенного интеграла. Допустим, нам дана функция <math>f(x)</math>, определенная на отрезке или многомерном кубе, и возможность получать ее численное значение в любой из точек области определения за фиксированное время. Задача — вычислить определенный интеграл данной функции по заданной области и дать оценку погрешности вычисления.

Исторически численное интегрирование также называлось численной квадратурой, а многомерное — кубатурой. Большая советская энциклопедия определяет слово «квадратура» следующим способом: (лат. quadratura — придание квадратной формы), 1) число квадратных единиц в площади данной фигуры. 2) Построение квадрата, равновеликого данной фигуре. 3) Вычисление площади или интеграла.

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

К данному типу относятся одномерные метод прямоугольников, метод трапеций, метод парабол (метод Симпсона), метод Гаусса, метод Гаусса-Кронрода. Часть перечисленных методов обобщается и для многомерного случая. Обобщенно все эти методы называются квадратурными. В многомерном случае они также могут называться кубатурными (это слово не несет никаких дополнительных смыслов). Также говорится, что перечисленные методы используют квадратурные (кубатурные) формулы.

Подходы, в которых область делится на не равные друг другу отрезки (кубы), называются адаптивными и не рассматриваются к данной статье.

Все перечисленные выше методы, а также подобные им могут быть объединены следующим образом: область интегрирования содержит <math>M</math> точек, в каждой из которых необходимо вычислить подынтегральное выражение и помножить ее на весовой коэффициент, затем данные числа складываются, и полученная сумма и представляет собой результат интегрирования. Погрешность интегрирования оценивается ровно таким же образом.

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

Исходные данные: функция <math>f</math> от <math>n</math> переменных, границы области интегрирования, представляющей собой многомерный куб (по каждой из осей интегрирования заданы минимальное и максимальное значение координаты), максимальное число <math>M</math> точек, в которых можно вычислить функцию <math>f</math>.

Вычисляемые данные: число, представляющее собой приближенное значение интеграла и, если это позволяет выбранный метод, число, представляющее собой оценку погрешности.
По количеству точек <math>M</math> и методу интегрирования определяются размеры прямоугольных параллелепипедов, на которые разбивается область интегрирования. В каждом из параллелепипедов в зависимости от выбора метода определяются свои точки для вычисления функции <math>f</math> и весовые коэффициенты.

Наибольшее разнообразие выбора методов достигается в одномерном случае.

''Метод прямоугольников'': функция для заданного отрезка приближается константной функцией, тем самым, интеграл приближается значением функции в одной точке. Обычно в качестве этой точки используется граница отрезка или, лучше, его середина.
: <math>\int\limits_a^b f(x)\,dx \approx f((a+b)/2) * (b-a)</math>

''Метод трапеций''<nowiki>:</nowiki> <math>f(x)</math> приближается линейной функцией, тем самым, интеграл приближается усредненным значением по краям отрезка:
: <math>\int\limits_a^b f(x)\,dx \approx (f(a) + f(b)) * (b-a)/2</math>

''Метод парабол (метод Симпсона)''<nowiki>:</nowiki> <math>f(x)</math> приближается параболой, пересекающей график функции на краях отрезка и в его середине:
: <math>\int\limits_a^b f(x)\,dx \approx \frac{b-a}{6}\left(f(a)+4f\left(\frac{a+b}{2}\right)+f(b)\right)</math>

''Метод Гаусса''<nowiki>:</nowiki> <math>f(x)</math> приближается прямой как в методе трапеций, однако в качестве точек выбираются не концы отрезка, что позволяет увеличить точность:
: <math>\int\limits_a^b f(x)\,dx \approx \frac{b-a}{2}\left(f\left(\frac{a+b}{2} - \frac{b-a}{2\sqrt{3}} \right)+f\left(\frac{a+b}{2} + \frac{b-a}{2\sqrt{3}} \right) \right)</math>

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

Так или иначе, на подготовительной стадии определяется M наборов координат <math>{x_{1,i}, … x_{n,i}}</math>, где <math>i</math> меняется от <math>1</math> до <math>M</math>, в которых будет вычисляться функция <math>f</math> и набор весовых коэффициентов <math>с_i</math>, на которые будет умножаться значение функции, после чего управление передается вычислительному ядру алгоритма.

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

Вычислительное ядро последовательной версии любого из квадратурных методов численного интегрирования представляет собой вычисление суммы
: <math>\sum \limits_1^M c_i f(x_{1,i}, … x_{n,i}) </math>
Поскольку время, требуемое на операции сложения и умножения в реальных примерах представляют собой о малое от времени, затрачиваемого на вычисление функции <math>f</math>, для производительности становится совершенно неважно, каким способом осуществлять сложение и умножение.

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

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

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

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

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

Время, затрачиваемое на вычисление функции растет примерно как <math>t*M</math>, где <math>t</math> — время, требуемое на вычислении функции <math>f</math>, а <math>M</math> — количество точек, в которых вычисляется функция <math>f</math>. Тем самым, алгоритм является линейным относительно количества точек интегрирования.

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

Опишем граф алгоритма как аналитически, так и в виде рисунка.

Граф алгоритма состоит из трех групп вершин. Вершины на верхнем ярусе берут в качестве входных данных координаты и вычисляют по ним значение функции <math>f</math>. Вершины на втором ярусе умножают полученное значение на соответствующий весовой коэффициент. Вершины на третьем ярусе поочередно складывают полученные значения; результат относится к выходным данным.

[[Image:cubature.svg|center|thumb|800px|Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)]]

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

Для вычисления интеграла функции методом кубатур требуется последовательно выполнить следующие ярусы:
- Вычисление исходной функции <math>f</math>, производящееся независимо для различных точек и выполняющееся за близкое к константному время <math>t</math> — основная часть алгоритма.
- Умножение полученных результатов на соответствующие весовые коэффициенты
- Сложение полученных результатов.

В общем случае время, затрачиваемое на сложение или умножение пренебрежимо мало по сравнением со временем необходимым на вычисление функции <math>f</math>, а все вычисления функции <math>f</math> могут производиться на различных узлах, тем самым, задача вычисления интеграла методом кубатур идеально поддается параллельной реализации. Однако при значительном увеличении количества узлов (в случае, когда оно становится сравнимым с количеством точек, в которых вычисляется функция), ресурс параллелизма может быть ограничен накладными расходами,такими как передача исходного выражения на каждый из вычислительных узлов.

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

=== Описание входных и выходных данных ===

Входными данными для алгоритма являются размерность <math>n</math>, границы интегрирования (два массива длины <math>n</math>), ограничение <math>M</math> на количество точек интегрирования, выбор метода интегрирования и функция <math>f</math> — подынтегральное выражение. Она обычно задается в виде функции, написанной на используемом языке программирования или же в строковом виде, если реализация алгоритма имеет встроенный аналог компилятора, работающий с используемым классом функций.

К входным данными для вычислительного ядра алгоритма относится функция <math>f</math> и массив длины <math>M</math>, содержащий точки, в которых должно быть произведено вычисление.

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

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

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

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

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

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

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

В простейшем варианте вычислительное ядро метода на Фортране можно записать так:

<source lang="fortran">
double::res
DO I = 1, M
double::a = f(x(I))
res = res + a
END DO
</source>

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

Локальность операций существенно определяется реализацией вычисления функции <math>f</math>. Если рассматривать ее вычисление как «черный ящик», то становится совершенно невозможным заботиться об эффективном использовании кэша процессора.

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

Самым естественным способом реализации параллельного алгоритма является независимое вычислении функции <math>f</math> в различных точках разными узлами. При этом это может быть реализовано как при помощи технологии threads при запуске на одном узле, так и, например, при помощи MPI. Головной узел передает определение функции <math>f</math>, и затем раздает подчиненным узлам точки, в которых должна вычисляться функция. Для оптимизации процесса возможно передавать сразу наборы точек.

Также представляется возможным одновременное вычисление нескольких значений функции одним узлом, однако такой подход требует адаптации самого алгоритма вычисления функции <math>f</math> и не всегда является применимым. Например, использование команд типа AVX для микропроцессоров позволяет выполнять по 4 сложения или умножения за такт работы процессора, однако так могут складываться лишь расположенные последовательно вещественные числа типа. Но использование подобных ускорений или, скажем, перевод алгоритма на использование графических процессоров, безусловно требует модификации самого алгоритма вычисления функции <math>f</math> и уточнения класса функций, для которых будет применяться данная реализация.

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

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

'''????? нам нужна модельная реализация?'''

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

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

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

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

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

Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)

2014-11-26T12:59:23Z

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

== Описание свойств и структуры алгоритма ==

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

Численное интегрирование — приближенное вычисление значения определенного интеграла. Допустим, нам дана функция <math>f(x)</math>, определенная на отрезке или многомерном кубе, и возможность получать ее численное значение в любой из точек области определения за фиксированное время. Задача — вычислить определенный интеграл данной функции по заданной области и дать оценку погрешности вычисления.

Исторически численное интегрирование также называлось численной квадратурой, а многомерное — кубатурой. Большая советская энциклопедия определяет слово «квадратура» следующим способом: (лат. quadratura — придание квадратной формы), 1) число квадратных единиц в площади данной фигуры. 2) Построение квадрата, равновеликого данной фигуре. 3) Вычисление площади или интеграла.

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

К данному типу относятся одномерные метод прямоугольников, метод трапеций, метод парабол (метод Симпсона), метод Гаусса, метод Гаусса-Кронрода. Часть перечисленных методов обобщается и для многомерного случая. Обобщенно все эти методы называются квадратурными. В многомерном случае они также могут называться кубатурными (это слово не несет никаких дополнительных смыслов). Также говорится, что перечисленные методы используют квадратурные (кубатурные) формулы.

Подходы, в которых область делится на не равные друг другу отрезки (кубы), называются адаптивными и не рассматриваются к данной статье.

Все перечисленные выше методы, а также подобные им могут быть объединены следующим образом: область интегрирования содержит <math>M</math> точек, в каждой из которых необходимо вычислить подынтегральное выражение и помножить ее на весовой коэффициент, затем данные числа складываются, и полученная сумма и представляет собой результат интегрирования. Погрешность интегрирования оценивается ровно таким же образом.

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

Исходные данные: функция <math>f</math> от <math>n</math> переменных, границы области интегрирования, представляющей собой многомерный куб (по каждой из осей интегрирования заданы минимальное и максимальное значение координаты), максимальное число <math>M</math> точек, в которых можно вычислить функцию <math>f</math>.

Вычисляемые данные: число, представляющее собой приближенное значение интеграла и, если это позволяет выбранный метод, число, представляющее собой оценку погрешности.
По количеству точек <math>M</math> и методу интегрирования определяются размеры прямоугольных параллелепипедов, на которые разбивается область интегрирования. В каждом из параллелепипедов в зависимости от выбора метода определяются свои точки для вычисления функции <math>f</math> и весовые коэффициенты.

Наибольшее разнообразие выбора методов достигается в одномерном случае.

''Метод прямоугольников'': функция для заданного отрезка приближается константной функцией, тем самым, интеграл приближается значением функции в одной точке. Обычно в качестве этой точки используется граница отрезка или, лучше, его середина.
: <math>\int\limits_a^b f(x)\,dx \approx f((a+b)/2) * (b-a)</math>

''Метод трапеций''<nowiki>:</nowiki> <math>f(x)</math> приближается линейной функцией, тем самым, интеграл приближается усредненным значением по краям отрезка:
: <math>\int\limits_a^b f(x)\,dx \approx (f(a) + f(b)) * (b-a)/2</math>

''Метод парабол (метод Симпсона)''<nowiki>:</nowiki> <math>f(x)</math> приближается параболой, пересекающей график функции на краях отрезка и в его середине:
: <math>\int\limits_a^b f(x)\,dx \approx \frac{b-a}{6}\left(f(a)+4f\left(\frac{a+b}{2}\right)+f(b)\right)</math>

''Метод Гаусса''<nowiki>:</nowiki> <math>f(x)</math> приближается прямой как в методе трапеций, однако в качестве точек выбираются не концы отрезка, что позволяет увеличить точность:
: <math>\int\limits_a^b f(x)\,dx \approx \frac{b-a}{2}\left(f\left(\frac{a+b}{2} - \frac{b-a}{2\sqrt{3}} \right)+f\left(\frac{a+b}{2} + \frac{b-a}{2\sqrt{3}} \right) \right)</math>

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

Так или иначе, на подготовительной стадии определяется M наборов координат <math>{x_{1,i}, … x_{n,i}}</math>, где <math>i</math> меняется от <math>1</math> до <math>M</math>, в которых будет вычисляться функция <math>f</math> и набор весовых коэффициентов <math>с_i</math>, на которые будет умножаться значение функции, после чего управление передается вычислительному ядру алгоритма.

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

Вычислительное ядро последовательной версии любого из квадратурных методов численного интегрирования представляет собой вычисление суммы
: <math>\sum \limits_1^M c_i f(x_{1,i}, … x_{n,i}) </math>
Поскольку время, требуемое на операции сложения и умножения в реальных примерах представляют собой о малое от времени, затрачиваемого на вычисление функции <math>f</math>, для производительности становится совершенно неважно, каким способом осуществлять сложение и умножение.

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

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

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

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

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

Время, затрачиваемое на вычисление функции растет примерно как <math>t*M</math>, где <math>t</math> — время, требуемое на вычислении функции <math>f</math>, а <math>M</math> — количество точек, в которых вычисляется функция <math>f</math>. Тем самым, алгоритм является линейным относительно количества точек интегрирования.

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

Опишем граф алгоритма как аналитически, так и в виде рисунка.

Граф алгоритма состоит из трех групп вершин. Вершины на верхнем ярусе берут в качестве входных данных координаты и вычисляют по ним значение функции <math>f</math>. Вершины на втором ярусе умножают полученное значение на соответствующий весовой коэффициент. Вершины на третьем ярусе поочередно складывают полученные значения; результат относится к выходным данным.

[[Image:cubature.svg]]

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

Для вычисления интеграла функции методом кубатур требуется последовательно выполнить следующие ярусы:
- Вычисление исходной функции <math>f</math>, производящееся независимо для различных точек и выполняющееся за близкое к константному время <math>t</math> — основная часть алгоритма.
- Умножение полученных результатов на соответствующие весовые коэффициенты
- Сложение полученных результатов.

В общем случае время, затрачиваемое на сложение или умножение пренебрежимо мало по сравнением со временем необходимым на вычисление функции <math>f</math>, а все вычисления функции <math>f</math> могут производиться на различных узлах, тем самым, задача вычисления интеграла методом кубатур идеально поддается параллельной реализации. Однако при значительном увеличении количества узлов (в случае, когда оно становится сравнимым с количеством точек, в которых вычисляется функция), ресурс параллелизма может быть ограничен накладными расходами,такими как передача исходного выражения на каждый из вычислительных узлов.

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

=== Описание входных и выходных данных ===

Входными данными для алгоритма являются размерность <math>n</math>, границы интегрирования (два массива длины <math>n</math>), ограничение <math>M</math> на количество точек интегрирования, выбор метода интегрирования и функция <math>f</math> — подынтегральное выражение. Она обычно задается в виде функции, написанной на используемом языке программирования или же в строковом виде, если реализация алгоритма имеет встроенный аналог компилятора, работающий с используемым классом функций.

К входным данными для вычислительного ядра алгоритма относится функция <math>f</math> и массив длины <math>M</math>, содержащий точки, в которых должно быть произведено вычисление.

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

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

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

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

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

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

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

В простейшем варианте вычислительное ядро метода на Фортране можно записать так:

<source lang="fortran">
double::res
DO I = 1, M
double::a = f(x(I))
res = res + a
END DO
</source>

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

Локальность операций существенно определяется реализацией вычисления функции <math>f</math>. Если рассматривать ее вычисление как «черный ящик», то становится совершенно невозможным заботиться об эффективном использовании кэша процессора.

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

Самым естественным способом реализации параллельного алгоритма является независимое вычислении функции <math>f</math> в различных точках разными узлами. При этом это может быть реализовано как при помощи технологии threads при запуске на одном узле, так и, например, при помощи MPI. Головной узел передает определение функции <math>f</math>, и затем раздает подчиненным узлам точки, в которых должна вычисляться функция. Для оптимизации процесса возможно передавать сразу наборы точек.

Также представляется возможным одновременное вычисление нескольких значений функции одним узлом, однако такой подход требует адаптации самого алгоритма вычисления функции <math>f</math> и не всегда является применимым. Например, использование команд типа AVX для микропроцессоров позволяет выполнять по 4 сложения или умножения за такт работы процессора, однако так могут складываться лишь расположенные последовательно вещественные числа типа. Но использование подобных ускорений или, скажем, перевод алгоритма на использование графических процессоров, безусловно требует модификации самого алгоритма вычисления функции <math>f</math> и уточнения класса функций, для которых будет применяться данная реализация.

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

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

'''????? нам нужна модельная реализация?'''

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

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

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

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

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

Файл:Cubature.svg

2014-11-26T12:58:50Z

Sander:

Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)

2014-11-26T12:57:31Z

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

== Описание свойств и структуры алгоритма ==

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

Численное интегрирование — приближенное вычисление значения определенного интеграла. Допустим, нам дана функция <math>f(x)</math>, определенная на отрезке или многомерном кубе, и возможность получать ее численное значение в любой из точек области определения за фиксированное время. Задача — вычислить определенный интеграл данной функции по заданной области и дать оценку погрешности вычисления.

Исторически численное интегрирование также называлось численной квадратурой, а многомерное — кубатурой. Большая советская энциклопедия определяет слово «квадратура» следующим способом: (лат. quadratura — придание квадратной формы), 1) число квадратных единиц в площади данной фигуры. 2) Построение квадрата, равновеликого данной фигуре. 3) Вычисление площади или интеграла.

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

К данному типу относятся одномерные метод прямоугольников, метод трапеций, метод парабол (метод Симпсона), метод Гаусса, метод Гаусса-Кронрода. Часть перечисленных методов обобщается и для многомерного случая. Обобщенно все эти методы называются квадратурными. В многомерном случае они также могут называться кубатурными (это слово не несет никаких дополнительных смыслов). Также говорится, что перечисленные методы используют квадратурные (кубатурные) формулы.

Подходы, в которых область делится на не равные друг другу отрезки (кубы), называются адаптивными и не рассматриваются к данной статье.

Все перечисленные выше методы, а также подобные им могут быть объединены следующим образом: область интегрирования содержит <math>M</math> точек, в каждой из которых необходимо вычислить подынтегральное выражение и помножить ее на весовой коэффициент, затем данные числа складываются, и полученная сумма и представляет собой результат интегрирования. Погрешность интегрирования оценивается ровно таким же образом.

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

Исходные данные: функция <math>f</math> от <math>n</math> переменных, границы области интегрирования, представляющей собой многомерный куб (по каждой из осей интегрирования заданы минимальное и максимальное значение координаты), максимальное число <math>M</math> точек, в которых можно вычислить функцию <math>f</math>.

Вычисляемые данные: число, представляющее собой приближенное значение интеграла и, если это позволяет выбранный метод, число, представляющее собой оценку погрешности.
По количеству точек <math>M</math> и методу интегрирования определяются размеры прямоугольных параллелепипедов, на которые разбивается область интегрирования. В каждом из параллелепипедов в зависимости от выбора метода определяются свои точки для вычисления функции <math>f</math> и весовые коэффициенты.

Наибольшее разнообразие выбора методов достигается в одномерном случае.

''Метод прямоугольников'': функция для заданного отрезка приближается константной функцией, тем самым, интеграл приближается значением функции в одной точке. Обычно в качестве этой точки используется граница отрезка или, лучше, его середина.
: <math>\int\limits_a^b f(x)\,dx \approx f((a+b)/2) * (b-a)</math>

''Метод трапеций''<nowiki>:</nowiki> <math>f(x)</math> приближается линейной функцией, тем самым, интеграл приближается усредненным значением по краям отрезка:
: <math>\int\limits_a^b f(x)\,dx \approx (f(a) + f(b)) * (b-a)/2</math>

''Метод парабол (метод Симпсона)''<nowiki>:</nowiki> <math>f(x)</math> приближается параболой, пересекающей график функции на краях отрезка и в его середине:
: <math>\int\limits_a^b f(x)\,dx \approx \frac{b-a}{6}\left(f(a)+4f\left(\frac{a+b}{2}\right)+f(b)\right)</math>

''Метод Гаусса''<nowiki>:</nowiki> <math>f(x)</math> приближается прямой как в методе трапеций, однако в качестве точек выбираются не концы отрезка, что позволяет увеличить точность:
: <math>\int\limits_a^b f(x)\,dx \approx \frac{b-a}{2}\left(f\left(\frac{a+b}{2} - \frac{b-a}{2\sqrt{3}} \right)+f\left(\frac{a+b}{2} + \frac{b-a}{2\sqrt{3}} \right) \right)</math>

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

Так или иначе, на подготовительной стадии определяется M наборов координат <math>{x_{1,i}, … x_{n,i}}</math>, где <math>i</math> меняется от <math>1</math> до <math>M</math>, в которых будет вычисляться функция <math>f</math> и набор весовых коэффициентов <math>с_i</math>, на которые будет умножаться значение функции, после чего управление передается вычислительному ядру алгоритма.

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

Вычислительное ядро последовательной версии любого из квадратурных методов численного интегрирования представляет собой вычисление суммы
: <math>\sum \limits_1^M c_i f(x_{1,i}, … x_{n,i}) </math>
Поскольку время, требуемое на операции сложения и умножения в реальных примерах представляют собой о малое от времени, затрачиваемого на вычисление функции <math>f</math>, для производительности становится совершенно неважно, каким способом осуществлять сложение и умножение.

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

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

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

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

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

Время, затрачиваемое на вычисление функции растет примерно как <math>t*M</math>, где <math>t</math> — время, требуемое на вычислении функции <math>f</math>, а <math>M</math> — количество точек, в которых вычисляется функция <math>f</math>. Тем самым, алгоритм является линейным относительно количества точек интегрирования.

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

Опишем граф алгоритма как аналитически, так и в виде рисунка.

Граф алгоритма состоит из трех групп вершин. Вершины на верхнем ярусе берут в качестве входных данных координаты и вычисляют по ним значение функции <math>f</math>. Вершины на втором ярусе умножают полученное значение на соответствующий весовой коэффициент. Вершины на третьем ярусе поочередно складывают полученные значения; результат относится к выходным данным.

[[Image:cubature.jpg]]

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

Для вычисления интеграла функции методом кубатур требуется последовательно выполнить следующие ярусы:
- Вычисление исходной функции <math>f</math>, производящееся независимо для различных точек и выполняющееся за близкое к константному время <math>t</math> — основная часть алгоритма.
- Умножение полученных результатов на соответствующие весовые коэффициенты
- Сложение полученных результатов.

В общем случае время, затрачиваемое на сложение или умножение пренебрежимо мало по сравнением со временем необходимым на вычисление функции <math>f</math>, а все вычисления функции <math>f</math> могут производиться на различных узлах, тем самым, задача вычисления интеграла методом кубатур идеально поддается параллельной реализации. Однако при значительном увеличении количества узлов (в случае, когда оно становится сравнимым с количеством точек, в которых вычисляется функция), ресурс параллелизма может быть ограничен накладными расходами,такими как передача исходного выражения на каждый из вычислительных узлов.

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

=== Описание входных и выходных данных ===

Входными данными для алгоритма являются размерность <math>n</math>, границы интегрирования (два массива длины <math>n</math>), ограничение <math>M</math> на количество точек интегрирования, выбор метода интегрирования и функция <math>f</math> — подынтегральное выражение. Она обычно задается в виде функции, написанной на используемом языке программирования или же в строковом виде, если реализация алгоритма имеет встроенный аналог компилятора, работающий с используемым классом функций.

К входным данными для вычислительного ядра алгоритма относится функция <math>f</math> и массив длины <math>M</math>, содержащий точки, в которых должно быть произведено вычисление.

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

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

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

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

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

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

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

В простейшем варианте вычислительное ядро метода на Фортране можно записать так:

<source lang="fortran">
double::res
DO I = 1, M
double::a = f(x(I))
res = res + a
END DO
</source>

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

Локальность операций существенно определяется реализацией вычисления функции <math>f</math>. Если рассматривать ее вычисление как «черный ящик», то становится совершенно невозможным заботиться об эффективном использовании кэша процессора.

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

Самым естественным способом реализации параллельного алгоритма является независимое вычислении функции <math>f</math> в различных точках разными узлами. При этом это может быть реализовано как при помощи технологии threads при запуске на одном узле, так и, например, при помощи MPI. Головной узел передает определение функции <math>f</math>, и затем раздает подчиненным узлам точки, в которых должна вычисляться функция. Для оптимизации процесса возможно передавать сразу наборы точек.

Также представляется возможным одновременное вычисление нескольких значений функции одним узлом, однако такой подход требует адаптации самого алгоритма вычисления функции <math>f</math> и не всегда является применимым. Например, использование команд типа AVX для микропроцессоров позволяет выполнять по 4 сложения или умножения за такт работы процессора, однако так могут складываться лишь расположенные последовательно вещественные числа типа. Но использование подобных ускорений или, скажем, перевод алгоритма на использование графических процессоров, безусловно требует модификации самого алгоритма вычисления функции <math>f</math> и уточнения класса функций, для которых будет применяться данная реализация.

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

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

'''????? нам нужна модельная реализация?'''

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

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

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

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

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

Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)

2014-11-26T09:53:36Z

Sander:

== Описание свойств и структуры алгоритма ==

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

Численное интегрирование — приближенное вычисление значения определенного интеграла. Допустим, нам дана функция <math>f(x)</math>, определенная на отрезке или многомерном кубе, и возможность получать ее численное значение в любой из точек области определения за фиксированное время. Задача — вычислить определенный интеграл данной функции по заданной области и дать оценку погрешности вычисления.

Исторически численное интегрирование также называлось численной квадратурой, а многомерное — кубатурой. Большая советская энциклопедия определяет слово «квадратура» следующим способом: (лат. quadratura — придание квадратной формы), 1) число квадратных единиц в площади данной фигуры. 2) Построение квадрата, равновеликого данной фигуре. 3) Вычисление площади или интеграла.

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

К данному типу относятся одномерные метод прямоугольников, метод трапеций, метод парабол (метод Симпсона), метод Гаусса, метод Гаусса-Кронрода. Часть перечисленных методов обобщается и для многомерного случая. Обобщенно все эти методы называются квадратурными. В многомерном случае они также могут называться кубатурными (это слово не несет никаких дополнительных смыслов). Также говорится, что перечисленные методы используют квадратурные (кубатурные) формулы.

Подходы, в которых область делится на не равные друг другу отрезки (кубы), называются адаптивными и не рассматриваются к данной статье.

Все перечисленные выше методы, а также подобные им могут быть объединены следующим образом: область интегрирования содержит <math>M</math> точек, в каждой из которых необходимо вычислить подынтегральное выражение и помножить ее на весовой коэффициент, затем данные числа складываются, и полученная сумма и представляет собой результат интегрирования. Погрешность интегрирования оценивается ровно таким же образом.

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

Исходные данные: функция <math>f</math> от <math>n</math> переменных, границы области интегрирования, представляющей собой многомерный куб (по каждой из осей интегрирования заданы минимальное и максимальное значение координаты), максимальное число <math>M</math> точек, в которых можно вычислить функцию <math>f</math>.

Вычисляемые данные: число, представляющее собой приближенное значение интеграла и, если это позволяет выбранный метод, число, представляющее собой оценку погрешности.
По количеству точек <math>M</math> и методу интегрирования определяются размеры прямоугольных параллелепипедов, на которые разбивается область интегрирования. В каждом из параллелепипедов в зависимости от выбора метода определяются свои точки для вычисления функции <math>f</math> и весовые коэффициенты.

Наибольшее разнообразие выбора методов достигается в одномерном случае.

''Метод прямоугольников'': функция для заданного отрезка приближается константной функцией, тем самым, интеграл приближается значением функции в одной точке. Обычно в качестве этой точки используется граница отрезка или, лучше, его середина.
: <math>\int\limits_a^b f(x)\,dx \approx f((a+b)/2) * (b-a)</math>

''Метод трапеций''<nowiki>:</nowiki> <math>f(x)</math> приближается линейной функцией, тем самым, интеграл приближается усредненным значением по краям отрезка:
: <math>\int\limits_a^b f(x)\,dx \approx (f(a) + f(b)) * (b-a)/2</math>

''Метод парабол (метод Симпсона)''<nowiki>:</nowiki> <math>f(x)</math> приближается параболой, пересекающей график функции на краях отрезка и в его середине:
: <math>\int\limits_a^b f(x)\,dx \approx \frac{b-a}{6}\left(f(a)+4f\left(\frac{a+b}{2}\right)+f(b)\right)</math>

''Метод Гаусса''<nowiki>:</nowiki> <math>f(x)</math> приближается прямой как в методе трапеций, однако в качестве точек выбираются не концы отрезка, что позволяет увеличить точность:
: <math>\int\limits_a^b f(x)\,dx \approx \frac{b-a}{2}\left(f\left(\frac{a+b}{2} - \frac{b-a}{2\sqrt{3}} \right)+f\left(\frac{a+b}{2} + \frac{b-a}{2\sqrt{3}} \right) \right)</math>

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

Так или иначе, на подготовительной стадии определяется M наборов координат <math>{x_{1,i}, … x_{n,i}}</math>, где <math>i</math> меняется от <math>1</math> до <math>M</math>, в которых будет вычисляться функция <math>f</math> и набор весовых коэффициентов <math>с_i</math>, на которые будет умножаться значение функции, после чего управление передается вычислительному ядру алгоритма.

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

Вычислительное ядро последовательной версии любого из квадратурных методов численного интегрирования представляет собой вычисление суммы
: <math>\sum \limits_1^M c_i f(x_{1,i}, … x_{n,i}) </math>
Поскольку время, требуемое на операции сложения и умножения в реальных примерах представляют собой о малое от времени, затрачиваемого на вычисление функции <math>f</math>, для производительности становится совершенно неважно, каким способом осуществлять сложение и умножение.

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

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

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

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

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

Время, затрачиваемое на вычисление функции растет примерно как <math>t*M</math>, где <math>t</math> — время, требуемое на вычислении функции <math>f</math>, а <math>M</math> — количество точек, в которых вычисляется функция <math>f</math>. Тем самым, алгоритм является линейным относительно количества точек интегрирования.

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

Опишем граф алгоритма как аналитически, так и в виде рисунка.

Граф алгоритма состоит из трех групп вершин. Вершины на верхнем ярусе берут в качестве входных данных координаты и вычисляют по ним значение функции <math>f</math>. Вершины на втором ярусе умножают полученное значение на соответствующий весовой коэффициент. Вершины на третьем ярусе поочередно складывают полученные значения; результат относится к выходным данным.

'''НА ЧЕМ ДЕЛАЕТСЯЯ РИСУНОК???????'''

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

Для вычисления интеграла функции методом кубатур требуется последовательно выполнить следующие ярусы:
- Вычисление исходной функции <math>f</math>, производящееся независимо для различных точек и выполняющееся за близкое к константному время <math>t</math> — основная часть алгоритма.
- Умножение полученных результатов на соответствующие весовые коэффициенты
- Сложение полученных результатов.

В общем случае время, затрачиваемое на сложение или умножение пренебрежимо мало по сравнением со временем необходимым на вычисление функции <math>f</math>, а все вычисления функции <math>f</math> могут производиться на различных узлах, тем самым, задача вычисления интеграла методом кубатур идеально поддается параллельной реализации. Однако при значительном увеличении количества узлов (в случае, когда оно становится сравнимым с количеством точек, в которых вычисляется функция), ресурс параллелизма может быть ограничен накладными расходами,такими как передача исходного выражения на каждый из вычислительных узлов.

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

=== Описание входных и выходных данных ===

Входными данными для алгоритма являются размерность <math>n</math>, границы интегрирования (два массива длины <math>n</math>), ограничение <math>M</math> на количество точек интегрирования, выбор метода интегрирования и функция <math>f</math> — подынтегральное выражение. Она обычно задается в виде функции, написанной на используемом языке программирования или же в строковом виде, если реализация алгоритма имеет встроенный аналог компилятора, работающий с используемым классом функций.

К входным данными для вычислительного ядра алгоритма относится функция <math>f</math> и массив длины <math>M</math>, содержащий точки, в которых должно быть произведено вычисление.

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

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

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

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

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

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

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

В простейшем варианте вычислительное ядро метода на Фортране можно записать так:

<source lang="fortran">
double::res
DO I = 1, M
double::a = f(x(I))
res = res + a
END DO
</source>

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

Локальность операций существенно определяется реализацией вычисления функции <math>f</math>. Если рассматривать ее вычисление как «черный ящик», то становится совершенно невозможным заботиться об эффективном использовании кэша процессора.

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

Самым естественным способом реализации параллельного алгоритма является независимое вычислении функции <math>f</math> в различных точках разными узлами. При этом это может быть реализовано как при помощи технологии threads при запуске на одном узле, так и, например, при помощи MPI. Головной узел передает определение функции <math>f</math>, и затем раздает подчиненным узлам точки, в которых должна вычисляться функция. Для оптимизации процесса возможно передавать сразу наборы точек.

Также представляется возможным одновременное вычисление нескольких значений функции одним узлом, однако такой подход требует адаптации самого алгоритма вычисления функции <math>f</math> и не всегда является применимым. Например, использование команд типа AVX для микропроцессоров позволяет выполнять по 4 сложения или умножения за такт работы процессора, однако так могут складываться лишь расположенные последовательно вещественные числа типа. Но использование подобных ускорений или, скажем, перевод алгоритма на использование графических процессоров, безусловно требует модификации самого алгоритма вычисления функции <math>f</math> и уточнения класса функций, для которых будет применяться данная реализация.

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

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

'''????? нам нужна модельная реализация?'''

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

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

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

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

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

Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)

2014-11-26T08:50:07Z

Sander:

Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)

2014-11-26T08:34:39Z

Sander:

Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)

2014-11-26T08:31:52Z

Sander:

Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)

2014-11-26T08:28:18Z

Sander:

Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)

2014-11-26T08:18:13Z

Sander:

Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)

2014-11-26T08:14:52Z

Sander:

Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)

2014-11-26T08:13:24Z

Sander:

Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)

2014-11-26T08:10:39Z

Sander:

Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)

2014-11-26T08:08:14Z

Sander:

Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)

2014-11-26T08:06:15Z

Sander: