Ашихмин Даниил. Технология SEQ-MPI. Вычисление многомерных интегралов с использованием многошаговой схемы (метод Симпсона). Вариант 9. (#292)

## Описание
- **Задача**: Вычисление многомерных интегралов с использованием
многошаговой схемы (метод Симпсона).
- **Вариант**: 9.
- **Технология**: SEQ, MPI.
- **Описание** вашей реализации и отчёта.  
В работе реализован метод численного интегрирования по правилу Симпсона
для многомерных функций. Реализованы последовательная и параллельная
версии алгоритма. Параллельная реализация выполнена с использованием MPI
с распределением задач между процессами, при этом вычисления
организованы по блокам для каждого процесса. В отчёте приведены описание
алгоритма, структура кода, псевдокод, проверка корректности результатов
и анализ производительности.
---

## Чек-лист

- [x] **Статус CI**: Все CI-задачи (сборка, тесты, генерация отчёта)
успешно проходят на моей ветке в моем форке
- [x] **Директория и именование задачи**: Я создал директорию с именем
`<фамилия>_<первая_буква_имени>_<короткое_название_задачи>`
- [x] **Полное описание задачи**: Я предоставил полное описание задачи в
теле pull request
- [x] **clang-format**: Мои изменения успешно проходят `clang-format`
локально в моем форке (нет ошибок форматирования)
- [x] **clang-tidy**: Мои изменения успешно проходят `clang-tidy`
локально в моем форке (нет предупреждений/ошибок)
- [x] **Функциональные тесты**: Все функциональные тесты успешно
проходят локально на моей машине
- [x] **Тесты производительности**: Все тесты производительности успешно
проходят локально на моей машине
- [x] **Ветка**: Я работаю в ветке, названной точно так же, как
директория моей задачи (например, `nesterov_a_vector_sum`), а не в
`master`
- [x] **Правдивое содержание**: Я подтверждаю, что все сведения,
указанные в этом pull request, являются точными и достоверными

Author: AshihDaniil

tasks/ashihmin_d_calculate_integrals_by_simpson/common/include/common.hpp

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <string>
+#include <tuple>
+#include <vector>
+
+#include "task/include/task.hpp"
+
+namespace ashihmin_d_calculate_integrals_by_simpson {
+
+struct SimpsonInput {
+  std::vector<double> left_bounds;
+  std::vector<double> right_bounds;
+  int partitions{};
+};
+
+using InType = SimpsonInput;
+using OutType = double;
+using TestType = std::tuple<int, std::string>;
+using BaseTask = ppc::task::Task<InType, OutType>;
+
+}  // namespace ashihmin_d_calculate_integrals_by_simpson

tasks/ashihmin_d_calculate_integrals_by_simpson/info.json

@@ -0,0 +1,9 @@
+{
+  "student": {
+    "first_name": "Даниил",
+    "last_name": "Ашихмин",
+    "middle_name": "Викторович",
+    "group_number": "3823Б1ФИ2",
+    "task_number": "3"
+  }
+}

tasks/ashihmin_d_calculate_integrals_by_simpson/mpi/include/ops_mpi.hpp

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <vector>
+
+#include "ashihmin_d_calculate_integrals_by_simpson/common/include/common.hpp"
+#include "task/include/task.hpp"
+
+namespace ashihmin_d_calculate_integrals_by_simpson {
+
+class AshihminDCalculateIntegralsBySimpsonMPI : public BaseTask {
+ public:
+  static constexpr ppc::task::TypeOfTask GetStaticTypeOfTask() {
+    return ppc::task::TypeOfTask::kMPI;
+  }
+  explicit AshihminDCalculateIntegralsBySimpsonMPI(const InType &in);
+
+ private:
+  bool ValidationImpl() override;
+  bool PreProcessingImpl() override;
+  bool RunImpl() override;
+  bool PostProcessingImpl() override;
+
+  static double IntegrandFunction(const std::vector<double> &coordinates);
+};
+
+}  // namespace ashihmin_d_calculate_integrals_by_simpson

tasks/ashihmin_d_calculate_integrals_by_simpson/mpi/src/ops_mpi.cpp

@@ -0,0 +1,165 @@
+#include "ashihmin_d_calculate_integrals_by_simpson/mpi/include/ops_mpi.hpp"
+
+#include <mpi.h>
+
+#include <algorithm>
+#include <cmath>
+#include <cstddef>
+#include <vector>
+
+#include "ashihmin_d_calculate_integrals_by_simpson/common/include/common.hpp"
+
+namespace ashihmin_d_calculate_integrals_by_simpson {
+
+namespace {
+
+double Function(const std::vector<double> &coordinates) {
+  double total = 0.0;
+  for (double value : coordinates) {
+    total += value * value;
+  }
+  return total;
+}
+
+double CalculateWeightCoefficient(const std::vector<int> &indices, int partitions) {
+  double weight_coefficient = 1.0;
+  for (int node_index : indices) {
+    if (node_index == 0 || node_index == partitions) {
+      weight_coefficient *= 1.0;
+    } else if (node_index % 2 == 0) {
+      weight_coefficient *= 2.0;
+    } else {
+      weight_coefficient *= 4.0;
+    }
+  }
+  return weight_coefficient;
+}
+
+std::vector<double> CalculatePoint(const std::vector<int> &indices, const std::vector<double> &step_sizes,
+                                   const std::vector<double> &left_bounds) {
+  std::vector<double> point(indices.size());
+  for (std::size_t dim = 0; dim < indices.size(); ++dim) {
+    point[dim] = left_bounds[dim] + (indices[dim] * step_sizes[dim]);
+  }
+  return point;
+}
+
+double ComputeLocalSum(int start_index, int end_index, int dimensions, int partitions,
+                       const std::vector<double> &step_sizes, const std::vector<double> &left_bounds) {
+  double local_sum = 0.0;
+
+  std::vector<int> indices(static_cast<std::size_t>(dimensions), 0);
+
+  for (int first_index = start_index; first_index <= end_index; ++first_index) {
+    indices[0] = first_index;
+
+    int inner_points_count = 1;
+    for (int dim = 1; dim < dimensions; ++dim) {
+      inner_points_count *= (partitions + 1);
+    }
+
+    for (int inner_index = 0; inner_index < inner_points_count; ++inner_index) {
+      int temp_index = inner_index;
+      for (int dim = 1; dim < dimensions; ++dim) {
+        indices[dim] = temp_index % (partitions + 1);
+        temp_index /= (partitions + 1);
+      }
+
+      const double weight = CalculateWeightCoefficient(indices, partitions);
+      const auto point = CalculatePoint(indices, step_sizes, left_bounds);
+      local_sum += weight * Function(point);
+    }
+  }
+
+  return local_sum;
+}
+
+}  // namespace
+
+AshihminDCalculateIntegralsBySimpsonMPI::AshihminDCalculateIntegralsBySimpsonMPI(const InType &input) {
+  SetTypeOfTask(GetStaticTypeOfTask());
+  GetInput() = input;
+  GetOutput() = 0.0;
+}
+
+bool AshihminDCalculateIntegralsBySimpsonMPI::ValidationImpl() {
+  const auto &input = GetInput();
+  if (input.left_bounds.size() != input.right_bounds.size()) {
+    return false;
+  }
+  if (input.partitions <= 0 || input.partitions % 2 != 0) {
+    return false;
+  }
+  for (std::size_t index = 0; index < input.left_bounds.size(); ++index) {
+    if (input.right_bounds[index] <= input.left_bounds[index]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool AshihminDCalculateIntegralsBySimpsonMPI::PreProcessingImpl() {
+  GetOutput() = 0.0;
+  return true;
+}
+
+double AshihminDCalculateIntegralsBySimpsonMPI::IntegrandFunction(const std::vector<double> &coordinates) {
+  return Function(coordinates);
+}
+
+bool AshihminDCalculateIntegralsBySimpsonMPI::RunImpl() {
+  int process_rank = 0;
+  int process_count = 1;
+  MPI_Comm_rank(MPI_COMM_WORLD, &process_rank);
+  MPI_Comm_size(MPI_COMM_WORLD, &process_count);
+
+  const auto &input = GetInput();
+  const int dimensions = static_cast<int>(input.left_bounds.size());
+  const int partitions = input.partitions;
+
+  if (dimensions == 0) {
+    GetOutput() = 0.0;
+    return true;
+  }
+
+  std::vector<double> step_sizes(static_cast<std::size_t>(dimensions));
+  for (int dim = 0; dim < dimensions; ++dim) {
+    step_sizes[static_cast<std::size_t>(dim)] = (input.right_bounds[dim] - input.left_bounds[dim]) / partitions;
+  }
+
+  const int total_nodes = partitions + 1;
+  const int chunk_size = total_nodes / process_count;
+  const int remainder = total_nodes % process_count;
+
+  int start_index = (process_rank * chunk_size) + std::min(process_rank, remainder);
+  int end_index = start_index + chunk_size - 1;
+  if (process_rank < remainder) {
+    end_index += 1;
+  }
+
+  double local_sum = 0.0;
+  if (start_index <= end_index) {
+    local_sum = ComputeLocalSum(start_index, end_index, dimensions, partitions, step_sizes, input.left_bounds);
+  }
+
+  double global_sum = 0.0;
+  MPI_Reduce(&local_sum, &global_sum, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
+
+  double volume_element = 1.0;
+  for (double step : step_sizes) {
+    volume_element *= step;
+  }
+
+  if (process_rank == 0) {
+    GetOutput() = global_sum * volume_element / std::pow(3.0, dimensions);
+  }
+
+  MPI_Bcast(&GetOutput(), 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
+  return true;
+}
+
+bool AshihminDCalculateIntegralsBySimpsonMPI::PostProcessingImpl() {
+  return true;
+}
+
+}  // namespace ashihmin_d_calculate_integrals_by_simpson

tasks/ashihmin_d_calculate_integrals_by_simpson/report.md

@@ -0,0 +1,158 @@
+# Отчёт
+--------------------------------------------------------------------------
+
+## Численное вычисление многомерных интегралов методом Симпсона
+
+Студент: Ашихмин Даниил  
+Группа: 3823Б1ФИ2  
+
+Технология: SEQ-MPI
+
+--------------------------------------------------------------------------
+
+## Введение
+В данной работе реализуется алгоритм численного вычисления многомерных интегралов методом Симпсона. Рассматривается последовательная и параллельная (MPI) реализации. Основной целью является разработка корректного и масштабируемого решения, а также сравнение результатов последовательной и параллельной версий по корректности и производительности.
+
+--------------------------------------------------------------------------
+
+## Постановка задачи
+Требуется вычислить значение определённого многомерного интеграла на прямоугольной области с использованием метода Симпсона.
+
+Входные данные:
+
+· Количество разбиений partitions по каждой размерности (чётное число)
+· Вектор левых границ left_bounds и правых границ right_bounds (жёстко задаются для всех размерностей в коде)
+· Функция Function(coordinates) - многомерная функция, значение которой требуется проинтегрировать
+
+Выходные данные:
+
+· Численное значение интеграла  
+
+Требования:
+
+· Корректная работа при любой размерности интеграла  
+· Использование метода Симпсона  
+· Поддержка параллельной реализации с применением MPI  
+· Корректное воспроизведение результата в последовательной версии  
+
+--------------------------------------------------------------------------
+
+## Базовый алгоритм (последовательный)
+Последовательная версия алгоритма выполняет следующие шаги:
+
+· Формируется равномерная сетка по каждой размерности  
+· Вычисляются шаги интегрирования  
+· Для каждой точки сетки вычисляется значение подынтегральной функции  
+· К значению функции применяется вес, соответствующий методу Симпсона  
+· Производится суммирование всех взвешенных значений  
+· Итоговый результат умножается на коэффициент, зависящий от шагов интегрирования  
+
+--------------------------------------------------------------------------
+
+## Схема распараллеливания (MPI)
+Параллельная версия использует разбиение вычислений по процессам.
+
+Распределение данных:
+
+· Полный диапазон индексов сетки по первому измерению разбивается между процессами
+· Каждый процесс обрабатывает свой поддиапазон точек, используя ComputeLocalSum
+· Локальные суммы объединяются через MPI_Reduce, итоговое значение рассылается всем процессам через MPI_Bcast 
+
+Схема взаимодействия процессов:
+
+· Используются только MPI_Comm_rank, MPI_Comm_size, MPI_Reduce и MPI_Bcast
+
+--------------------------------------------------------------------------
+
+## Детали реализации
+Структура кода:
+
+· common.hpp - общие структуры данных и вспомогательные функции  
+· ops_seq.hpp / ops_seq.cpp - последовательная реализация метода Симпсона  
+· ops_mpi.hpp / ops_mpi.cpp - параллельная MPI-реализация  
+· tests/functional/main.cpp - функциональные тесты  
+· tests/performance/main.cpp - тесты производительности  
+
+Особенности реализации:
+
+· Корректная работа с произвольной размерностью интеграла
+· Проверка корректности входных параметров
+· Аккуратная работа с индексами сетки и распределением точек между процессами
+· Локальная сумма рассчитывается только по точкам, назначенным текущему процессу
+
+Основные вспомогательные функции:
+
+· Генерация координат точки по индексам  
+· Вычисление веса точки по методу Симпсона  
+· Преобразование индексов в линейный диапазон  
+
+--------------------------------------------------------------------------
+
+## Экспериментальная установка
+Аппаратное обеспечение:
+
+· CPU - AMD Ryzen 5 3500X (3.6 - 4.1 GHz, 6 ядер)  
+· RAM - 16 ГБ  
+
+Программное обеспечение:
+
+· OS - Windows 11 Pro x64  
+· MPI - Microsoft MPI 10.1.1  
+· Компилятор - MSVC 19.x  
+· Система сборки - CMake  
+· Конфигурация - Release  
+
+Параметры запуска:
+
+· PPC_NUM_PROC = 4  
+· PPC_NUM_THREADS = 1  
+
+--------------------------------------------------------------------------
+
+## Результаты и обсуждение
+
+## Проверка корректности
+Функциональные тесты проверяют:
+
+· Корректность вычисления интеграла в последовательной версии  
+· Совпадение результатов последовательной и MPI-версий  
+· Корректную работу при различных размерностях  
+
+Результаты:
+
+· Все функциональные тесты пройдены успешно  
+· Полученные значения совпадают в пределах допустимой погрешности  
+
+## Производительность
+
+Результаты тестов производительности метода Симпсона представлены в таблице:
+| Mode   | Count | Time (s) | Speed-up | Efficiency |
+|--------|-------|----------|----------|------------|
+| seq    | 1     | 0.0103   | 1.00     | 100%       |
+| mpi    | 2     | 0.0060   | 1.72     | 86%        |
+| mpi    | 4     | 0.0038   | 2.71     | 68%        |
+
+Тесты производительности показывают:
+
+· Ускорение вычислений при увеличении числа процессов  
+· Корректную масштабируемость алгоритма  
+· Отсутствие деградации производительности на малых размерностях  
+
+--------------------------------------------------------------------------
+
+## Заключение
+В ходе выполнения работы был реализован алгоритм численного вычисления многомерных интегралов методом Симпсона в последовательном и параллельном вариантах.
+
+Достигнутые результаты:
+
+· Реализован корректный алгоритм метода Симпсона  
+· Создана MPI-версия с распределением вычислений по процессам  
+· Подтверждена корректность результатов с помощью тестирования  
+· Проведён анализ производительности  
+
+--------------------------------------------------------------------------
+
+## References
+· MPI Standard - https://www.mpi-forum.org/docs/  
+· Microsoft MPI Documentation - https://learn.microsoft.com/message-passing-interface  
+· cppreference.com - https://en.cppreference.com