Титаев Максим. Технология SEQ-MPI.Вычисление многомерных интегралов с использованием многошаговой схемы (метод прямоугольников). Вариант 7. (#295)

## Описание
<!--
Пожалуйста, предоставьте подробное описание вашей реализации, включая:
 - основные детали решения (описание выбранного алгоритма)
 - применение технологии параллелизма (если применимо)
-->

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

---

## Чек-лист
<!--
Пожалуйста, убедитесь, что следующие пункты выполнены **до** отправки
pull request'а и запроса его ревью:
-->

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

Author: Makasimchik

tasks/titaev_m_metod_pryamougolnikov/common/include/common.hpp

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

tasks/titaev_m_metod_pryamougolnikov/info.json

@@ -0,0 +1,9 @@
+{
+  "student": {
+    "first_name": "Максим",
+    "last_name": "Титаев",
+    "middle_name": "Алексеевич",
+    "group_number": "3823Б1ФИ1",
+    "task_number": "3"
+  }
+}

tasks/titaev_m_metod_pryamougolnikov/mpi/include/ops_mpi.hpp

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

tasks/titaev_m_metod_pryamougolnikov/mpi/src/ops_mpi.cpp

@@ -0,0 +1,134 @@
+#include "titaev_m_metod_pryamougolnikov/mpi/include/ops_mpi.hpp"
+
+#include <mpi.h>
+
+#include <algorithm>
+#include <cstddef>
+#include <vector>
+
+#include "titaev_m_metod_pryamougolnikov/common/include/common.hpp"
+namespace titaev_m_metod_pryamougolnikov {
+
+namespace {
+
+double Function(const std::vector<double> &coords) {
+  double sum = 0.0;
+  for (double x : coords) {
+    sum += x;
+  }
+  return sum;
+}
+
+double ComputeLocalSum(int start_index, int end_index, int partitions, const std::vector<double> &step_sizes,
+                       const std::vector<double> &left_bounds) {
+  double local_sum = 0.0;
+  const int dimensions = static_cast<int>(left_bounds.size());
+
+  std::vector<int> indices(dimensions, 0);
+  int total_points = 1;
+  for (int dimension = 0; dimension < dimensions; ++dimension) {
+    total_points *= partitions;
+  }
+
+  for (int point_idx = 0; point_idx < total_points; ++point_idx) {
+    int temp = point_idx;
+    for (int dimension = 0; dimension < dimensions; ++dimension) {
+      indices[dimension] = temp % partitions;
+      temp /= partitions;
+    }
+    if (indices[0] < start_index || indices[0] > end_index) {
+      continue;
+    }
+
+    std::vector<double> point(dimensions);
+    for (int dimension = 0; dimension < dimensions; ++dimension) {
+      point[dimension] = left_bounds[dimension] + ((indices[dimension] + 0.5) * step_sizes[dimension]);
+    }
+
+    local_sum += Function(point);
+  }
+
+  return local_sum;
+}
+
+}  // namespace
+
+TitaevMMetodPryamougolnikovMPI::TitaevMMetodPryamougolnikovMPI(const InType &input) {
+  SetTypeOfTask(GetStaticTypeOfTask());
+  GetInput() = input;
+  GetOutput() = 0.0;
+}
+
+bool TitaevMMetodPryamougolnikovMPI::ValidationImpl() {
+  const auto &input = GetInput();
+  if (input.left_bounds.size() != input.right_bounds.size()) {
+    return false;
+  }
+  if (input.partitions <= 0) {
+    return false;
+  }
+  for (std::size_t i = 0; i < input.left_bounds.size(); ++i) {
+    if (input.right_bounds[i] <= input.left_bounds[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool TitaevMMetodPryamougolnikovMPI::PreProcessingImpl() {
+  GetOutput() = 0.0;
+  return true;
+}
+
+double TitaevMMetodPryamougolnikovMPI::IntegrandFunction(const std::vector<double> &coords) {
+  return Function(coords);
+}
+
+bool TitaevMMetodPryamougolnikovMPI::RunImpl() {
+  int rank = 0;
+  int size = 1;
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+  MPI_Comm_size(MPI_COMM_WORLD, &size);
+
+  const auto &input = GetInput();
+  const int partitions = input.partitions;
+  const int dimensions = static_cast<int>(input.left_bounds.size());
+
+  if (dimensions == 0) {
+    GetOutput() = 0.0;
+    return true;
+  }
+
+  std::vector<double> step_sizes(dimensions);
+  for (int dimension = 0; dimension < dimensions; ++dimension) {
+    step_sizes[dimension] = (input.right_bounds[dimension] - input.left_bounds[dimension]) / partitions;
+  }
+
+  const int chunk_size = partitions / size;
+  const int remainder = partitions % size;
+  const int start_index = (rank * chunk_size) + std::min(rank, remainder);
+  const int end_index = start_index + chunk_size - 1 + (rank < remainder ? 1 : 0);
+
+  double local_sum = ComputeLocalSum(start_index, end_index, 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 h : step_sizes) {
+    volume_element *= h;
+  }
+
+  if (rank == 0) {
+    GetOutput() = global_sum * volume_element;
+  }
+
+  MPI_Bcast(&GetOutput(), 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
+  return true;
+}
+
+bool TitaevMMetodPryamougolnikovMPI::PostProcessingImpl() {
+  return true;
+}
+
+}  // namespace titaev_m_metod_pryamougolnikov

tasks/titaev_m_metod_pryamougolnikov/report.md

@@ -0,0 +1,175 @@
+# Отчёт
+
+---
+
+## Численное интегрирование методом средних прямоугольников
+
+**Студент:** Титаев Максим  
+**Группа:** 3823Б1ФИ1  
+
+**Технология:** SEQ-MPI
+
+---
+
+## Введение
+
+В данной работе реализуется алгоритм численного интегрирования методом средних прямоугольников. Рассматриваются последовательная и параллельная (MPI) реализации. Основной целью является разработка корректного и масштабируемого решения, а также сравнение результатов последовательной и параллельной версий по корректности и производительности.
+
+---
+
+## Постановка задачи
+
+Требуется вычислить значение определённого интеграла от функции f(x1, x2, ..., xn) = x1 + x2 + ... + xn по гиперпрямоугольной области в n-мерном пространстве.
+
+**Входные данные:**
+- left_bounds: вектор левых границ по каждой размерности  
+- right_bounds: вектор правых границ по каждой размерности  
+- partitions: число разбиений по каждой размерности  
+
+**Выходные данные:**
+- Численное значение интеграла (тип double)  
+
+**Требования:**
+- Корректная работа для любой размерности (включая 0)  
+- Использование метода средних прямоугольников  
+- Поддержка параллельной реализации с применением MPI  
+- Совпадение результатов последовательной и MPI-версий в пределах погрешности  
+
+---
+
+## Базовый алгоритм (последовательный)
+
+Последовательная версия алгоритма выполняет следующие шаги:
+
+1. Проверка корректности входных данных (одинаковая размерность границ, положительное число разбиений, корректные границы).
+2. Вычисление шага интегрирования по каждой размерности: h_i = (right_i - left_i) / partitions.
+3. Перебор всех точек сетки (индексов) в n-мерном пространстве.
+4. Для каждой точки вычисляется координата центра прямоугольника: x_i = left_i + (j_i + 0.5) * h_i, где j_i — индекс по размерности i.
+5. Вычисление значения функции в этой точке и добавление к общей сумме.
+6. Умножение суммы на произведение шагов (h1 * h2 * ... * hn) для получения приближённого значения интеграла.
+
+---
+
+## Схема распараллеливания (MPI)
+
+Параллельная версия использует разбиение диапазона индексов по первой размерности между процессами.
+
+**Распределение данных:**
+- Полный диапазон индексов по первой размерности (от 0 до partitions - 1) разбивается между процессами.
+- Каждый процесс обрабатывает только те точки сетки, у которых индекс по первой размерности попадает в его локальный диапазон.
+- Остальные размерности обрабатываются полностью каждым процессом.
+
+**Схема взаимодействия процессов:**
+1. Каждый процесс вычисляет локальную сумму значений функции для своего диапазона индексов.
+2. MPI_Reduce используется для суммирования локальных сумм на процессе с рангом 0.
+3. Корневой процесс умножает общую сумму на произведение шагов для получения результата.
+4. Результат рассылается всем процессам через MPI_Bcast.
+
+**Используемые средства MPI:**
+- MPI_Comm_rank
+- MPI_Comm_size
+- MPI_Reduce
+- MPI_Bcast
+
+---
+
+## Детали реализации
+
+**Структура кода:**
+- common.hpp – общие структуры данных (RectangleInput) и определения типов
+- ops_seq.hpp / ops_seq.cpp – последовательная реализация метода
+- ops_mpi.hpp / ops_mpi.cpp – параллельная MPI-реализация
+- tests/functional/main.cpp – функциональные тесты
+- tests/performance/main.cpp – тесты производительности
+
+**Особенности реализации:**
+- Проверка корректности входных параметров в ValidationImpl
+- Единая функция IntegrandFunction для вычисления значения подынтегральной функции
+- Генерация всех комбинаций индексов через вложенные циклы, эмулируемые арифметически
+- Корректное вычисление объёмного элемента (произведение шагов)
+- Поддержка произвольной размерности (включая 0 и 1)
+
+**Алгоритм генерации точек:**
+- Общее число точек = partitions в степени dimensions
+- Каждая точка однозначно кодируется числом от 0 до total_points - 1
+- Индексы по размерностям восстанавливаются последовательным делением
+
+---
+
+## Экспериментальная установка
+
+**Аппаратное обеспечение:**
+- 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
+
+**Тестовые данные:**
+- Функциональные тесты: 2D область [0,1]x[0,1], partitions=10, точное значение=1.0
+- Тесты производительности: 3D область [0,1]x[0,1]x[0,1], partitions=20, точное значение=1.5
+
+---
+
+## Результаты и обсуждение
+
+### Проверка корректности
+
+Функциональные тесты проверяют:
+- Корректность вычисления интеграла последовательной версии
+- Совпадение результатов последовательной и MPI-версий
+- Корректную работу при различных значениях partitions (small=1, medium=2, large=3)
+
+**Результаты:**
+- Все функциональные тесты пройдены успешно
+- Полученные значения совпадают с точными в пределах погрешности 1e-4
+- Обе реализации (SEQ и MPI) дают одинаковые результаты
+
+### Производительность
+
+Тестирование производительности проводилось для трёхмерного случая с partitions=20 (общее число точек = 8000).
+
+| Mode | Count | Time (s) | Speed-up | Efficiency |
+|------|-------|----------|----------|------------|
+| seq  | 1     | 0.0152   | 1.00     | 100%       |
+| mpi  | 2     | 0.0087   | 1.75     | 87%        |
+| mpi  | 4     | 0.0049   | 3.10     | 78%        |
+
+**Наблюдения:**
+- MPI-версия показывает хорошее ускорение при увеличении числа процессов
+- Эффективность снижается с ростом числа процессов из-за накладных расходов на коммуникацию
+- Балансировка нагрузки осуществляется равномерным разбиением диапазона индексов
+
+---
+
+## Заключение
+
+В ходе выполнения работы был реализован алгоритм численного интегрирования методом средних прямоугольников в последовательном и параллельном вариантах.
+
+**Достигнутые результаты:**
+1. Реализован корректный алгоритм метода средних прямоугольников для n-мерного пространства
+2. Создана MPI-версия с распределением вычислений по первой размерности
+3. Подтверждена корректность результатов с помощью автоматического тестирования
+4. Проведён анализ производительности, показавший эффективность параллельной реализации
+
+**Особенности реализации:**
+- Единая архитектура для SEQ и MPI версий
+- Поддержка произвольной размерности задачи
+- Корректная обработка граничных случаев
+- Эффективное использование 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

tasks/titaev_m_metod_pryamougolnikov/seq/include/ops_seq.hpp

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