Тельнов Анатолий. Технология SEQ-MPI. Алгоритм глобального поиска (Стронгина) для одномерных задач оптимизации. Распараллеливание по характеристикам. Вариант 11 (#148)

## Описание

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

---

## Чек-лист

- [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, являются точными и достоверными

---------

Co-authored-by: mollycooddle <toolya.telnoff@yandex.ru>

Author: mollycooddle

tasks/telnov_strongin_algorithm/common/include/common.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <string>
+#include <tuple>
+
+#include "task/include/task.hpp"
+
+namespace telnov_strongin_algorithm {
+
+struct StronginInput {
+  double a;
+  double b;
+  double eps;
+};
+
+using InType = StronginInput;
+using OutType = double;
+using TestType = std::tuple<int, std::string>;
+using BaseTask = ppc::task::Task<InType, OutType>;
+
+}  // namespace telnov_strongin_algorithm

tasks/telnov_strongin_algorithm/info.json

@@ -0,0 +1,9 @@
+{
+  "student": {
+    "first_name": "Анатолий",
+    "last_name": "Тельнов",
+    "middle_name": "Викторович",
+    "group_number": "3823Б1ФИ2",
+    "task_number": "11"
+  }
+}

tasks/telnov_strongin_algorithm/mpi/include/ops_mpi.hpp

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "task/include/task.hpp"
+#include "telnov_strongin_algorithm/common/include/common.hpp"
+
+namespace telnov_strongin_algorithm {
+
+class TelnovStronginAlgorithmMPI : public BaseTask {
+ public:
+  static constexpr ppc::task::TypeOfTask GetStaticTypeOfTask() {
+    return ppc::task::TypeOfTask::kMPI;
+  }
+  explicit TelnovStronginAlgorithmMPI(const InType &in);
+
+ private:
+  bool ValidationImpl() override;
+  bool PreProcessingImpl() override;
+  bool RunImpl() override;
+  bool PostProcessingImpl() override;
+};
+
+}  // namespace telnov_strongin_algorithm

tasks/telnov_strongin_algorithm/mpi/src/ops_mpi.cpp

@@ -0,0 +1,116 @@
+#include "telnov_strongin_algorithm/mpi/include/ops_mpi.hpp"
+
+#include <mpi.h>
+
+#include <algorithm>
+#include <cmath>
+#include <cstddef>
+#include <vector>
+
+#include "telnov_strongin_algorithm/common/include/common.hpp"
+
+namespace telnov_strongin_algorithm {
+
+struct MaxData {
+  double value{};
+  int index{};
+};
+
+TelnovStronginAlgorithmMPI::TelnovStronginAlgorithmMPI(const InType &in) {
+  SetTypeOfTask(GetStaticTypeOfTask());
+  GetInput() = in;
+  GetOutput() = 0;
+}
+
+bool TelnovStronginAlgorithmMPI::ValidationImpl() {
+  const auto &in = GetInput();
+  return (in.eps > 0.0) && (in.b > in.a);
+}
+
+bool TelnovStronginAlgorithmMPI::PreProcessingImpl() {
+  return true;
+}
+
+bool TelnovStronginAlgorithmMPI::RunImpl() {
+  int rank = 0;
+  int size = 1;
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+  MPI_Comm_size(MPI_COMM_WORLD, &size);
+
+  const auto &in = GetInput();
+  const double eps = in.eps;
+
+  auto f = [](double x) { return ((x - 1.0) * (x - 1.0)) + 1.0; };
+
+  std::vector<double> x_vals{in.a, in.b};
+  std::vector<double> f_vals{f(in.a), f(in.b)};
+
+  const double r = 2.0;
+  const int k_max_iters = 100;
+  int iter = 0;
+
+  while ((x_vals.back() - x_vals.front()) > eps && iter < k_max_iters) {
+    ++iter;
+
+    double m = 0.0;
+    for (std::size_t i = 1; i < x_vals.size(); ++i) {
+      const double dx = x_vals[i] - x_vals[i - 1];
+      const double df = std::abs(f_vals[i] - f_vals[i - 1]);
+      m = std::max(m, df / dx);
+    }
+    m = std::max(m, 1.0);
+
+    MaxData local_data;
+    local_data.value = -1e9;
+    local_data.index = 1;
+
+    for (std::size_t i = static_cast<std::size_t>(rank) + 1; i < x_vals.size(); i += static_cast<std::size_t>(size)) {
+      const double dx = x_vals[i] - x_vals[i - 1];
+      const double df = f_vals[i] - f_vals[i - 1];
+
+      const double r_val = (r * dx) + ((df * df) / (r * dx)) - (2.0 * (f_vals[i] + f_vals[i - 1]));
+
+      if (r_val > local_data.value) {
+        local_data.value = r_val;
+        local_data.index = static_cast<int>(i);
+      }
+    }
+
+    MaxData global_data{};
+    MPI_Allreduce(&local_data, &global_data, 1, MPI_DOUBLE_INT, MPI_MAXLOC, MPI_COMM_WORLD);
+
+    if (rank != 0) {
+      int n = 0;
+      MPI_Bcast(&n, 1, MPI_INT, 0, MPI_COMM_WORLD);
+      x_vals.resize(static_cast<std::size_t>(n));
+      f_vals.resize(static_cast<std::size_t>(n));
+      MPI_Bcast(x_vals.data(), n, MPI_DOUBLE, 0, MPI_COMM_WORLD);
+      MPI_Bcast(f_vals.data(), n, MPI_DOUBLE, 0, MPI_COMM_WORLD);
+      continue;
+    }
+
+    const int idx = global_data.index;
+    const double mid = 0.5 * (x_vals[idx] + x_vals[idx - 1]);
+
+    double new_x = mid - ((f_vals[idx] - f_vals[idx - 1]) / (2.0 * m));
+
+    new_x = std::clamp(new_x, x_vals[idx - 1], x_vals[idx]);
+
+    x_vals.insert(x_vals.begin() + idx, new_x);
+    f_vals.insert(f_vals.begin() + idx, f(new_x));
+
+    int n = static_cast<int>(x_vals.size());
+    MPI_Bcast(&n, 1, MPI_INT, 0, MPI_COMM_WORLD);
+    MPI_Bcast(x_vals.data(), n, MPI_DOUBLE, 0, MPI_COMM_WORLD);
+    MPI_Bcast(f_vals.data(), n, MPI_DOUBLE, 0, MPI_COMM_WORLD);
+  }
+
+  GetOutput() = *std::ranges::min_element(f_vals);
+  return true;
+}
+
+bool TelnovStronginAlgorithmMPI::PostProcessingImpl() {
+  return true;
+}
+
+}  // namespace telnov_strongin_algorithm