From b7a25d4523d3a10c11fcca5da053043631e55a58 Mon Sep 17 00:00:00 2001
From: AlenaK13 <kruglovatm@mail.ru>
Date: Sat, 28 Feb 2026 00:37:03 +0300
Subject: [PATCH 01/11] init

---
 .../common/include/common.hpp                 | 22 +++++
 .../info.json                                 |  9 ++
 .../seq/include/ops_seq.hpp                   | 22 +++++
 .../seq/report.md                             |  0
 .../seq/src/ops_seq.cpp                       | 96 +++++++++++++++++++
 .../settings.json                             | 10 ++
 .../tests/functional/main.cpp                 | 95 ++++++++++++++++++
 .../tests/performance/main.cpp                | 64 +++++++++++++
 8 files changed, 318 insertions(+)
 create mode 100644 tasks/kruglova_a_conjugate_gradient_sle/common/include/common.hpp
 create mode 100644 tasks/kruglova_a_conjugate_gradient_sle/info.json
 create mode 100644 tasks/kruglova_a_conjugate_gradient_sle/seq/include/ops_seq.hpp
 create mode 100644 tasks/kruglova_a_conjugate_gradient_sle/seq/report.md
 create mode 100644 tasks/kruglova_a_conjugate_gradient_sle/seq/src/ops_seq.cpp
 create mode 100644 tasks/kruglova_a_conjugate_gradient_sle/settings.json
 create mode 100644 tasks/kruglova_a_conjugate_gradient_sle/tests/functional/main.cpp
 create mode 100644 tasks/kruglova_a_conjugate_gradient_sle/tests/performance/main.cpp

diff --git a/tasks/kruglova_a_conjugate_gradient_sle/common/include/common.hpp b/tasks/kruglova_a_conjugate_gradient_sle/common/include/common.hpp
new file mode 100644
index 0000000000..ffc9b4add8
--- /dev/null
+++ b/tasks/kruglova_a_conjugate_gradient_sle/common/include/common.hpp
@@ -0,0 +1,22 @@
+#pragma once
+
+#include <string>
+#include <tuple>
+#include <vector>
+
+#include "task/include/task.hpp"
+
+namespace kruglova_a_conjugate_gradient_sle {
+
+struct SLEInput {
+  int size;
+  std::vector<double> A;
+  std::vector<double> b;
+};
+
+using InType = SLEInput;
+using OutType = std::vector<double>;
+using TestType = std::tuple<int, std::string>;
+using BaseTask = ppc::task::Task<InType, OutType>;
+
+}  // namespace kruglova_a_conjugate_gradient_sle
diff --git a/tasks/kruglova_a_conjugate_gradient_sle/info.json b/tasks/kruglova_a_conjugate_gradient_sle/info.json
new file mode 100644
index 0000000000..07492a209b
--- /dev/null
+++ b/tasks/kruglova_a_conjugate_gradient_sle/info.json
@@ -0,0 +1,9 @@
+{
+  "student": {
+    "first_name": "first_name_t",
+    "group_number": "2222222_t",
+    "last_name": "last_name_t",
+    "middle_name": "middle_name_t",
+    "task_number": "1"
+  }
+}
diff --git a/tasks/kruglova_a_conjugate_gradient_sle/seq/include/ops_seq.hpp b/tasks/kruglova_a_conjugate_gradient_sle/seq/include/ops_seq.hpp
new file mode 100644
index 0000000000..88fcd0dba6
--- /dev/null
+++ b/tasks/kruglova_a_conjugate_gradient_sle/seq/include/ops_seq.hpp
@@ -0,0 +1,22 @@
+#pragma once
+
+#include "kruglova_a_conjugate_gradient_sle/common/include/common.hpp"
+#include "task/include/task.hpp"
+
+namespace kruglova_a_conjugate_gradient_sle {
+
+class KruglovaAConjGradSleSEQ : public BaseTask {
+ public:
+  static constexpr ppc::task::TypeOfTask GetStaticTypeOfTask() {
+    return ppc::task::TypeOfTask::kSEQ;
+  }
+  explicit KruglovaAConjGradSleSEQ(const InType &in);
+
+ private:
+  bool ValidationImpl() override;
+  bool PreProcessingImpl() override;
+  bool RunImpl() override;
+  bool PostProcessingImpl() override;
+};
+
+}  // namespace kruglova_a_conjugate_gradient_sle
diff --git a/tasks/kruglova_a_conjugate_gradient_sle/seq/report.md b/tasks/kruglova_a_conjugate_gradient_sle/seq/report.md
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/tasks/kruglova_a_conjugate_gradient_sle/seq/src/ops_seq.cpp b/tasks/kruglova_a_conjugate_gradient_sle/seq/src/ops_seq.cpp
new file mode 100644
index 0000000000..16b25068bf
--- /dev/null
+++ b/tasks/kruglova_a_conjugate_gradient_sle/seq/src/ops_seq.cpp
@@ -0,0 +1,96 @@
+#include "kruglova_a_conjugate_gradient_sle/seq/include/ops_seq.hpp"
+
+#include <cmath>
+#include <vector>
+
+namespace kruglova_a_conjugate_gradient_sle {
+
+KruglovaAConjGradSleSEQ::KruglovaAConjGradSleSEQ(const InType &in) {
+  SetTypeOfTask(GetStaticTypeOfTask());
+  GetInput() = in;
+}
+
+bool KruglovaAConjGradSleSEQ::ValidationImpl() {
+  const auto &in = GetInput();
+  if (in.size <= 0) {
+    return false;
+  }
+
+  if (in.A.size() != static_cast<size_t>(in.size * in.size)) {
+    return false;
+  }
+  if (in.b.size() != static_cast<size_t>(in.size)) {
+    return false;
+  }
+  return true;
+}
+
+bool KruglovaAConjGradSleSEQ::PreProcessingImpl() {
+  GetOutput().assign(GetInput().size, 0.0);
+  return true;
+}
+
+bool KruglovaAConjGradSleSEQ::RunImpl() {
+  const auto &A = GetInput().A;
+  const auto &b = GetInput().b;
+  int n = GetInput().size;
+  auto &x = GetOutput();
+
+  std::vector<double> r = b;
+  std::vector<double> p = r;
+  std::vector<double> Ap(n, 0.0);
+
+  double rsold = 0.0;
+  for (int i = 0; i < n; ++i) {
+    rsold += r[i] * r[i];
+  }
+
+  const double tolerance = 1e-8;
+
+  for (int iter = 0; iter < n * 2; ++iter) {
+    for (int i = 0; i < n; ++i) {
+      Ap[i] = 0.0;
+      for (int j = 0; j < n; ++j) {
+        Ap[i] += A[i * n + j] * p[j];
+      }
+    }
+
+    double pAp = 0.0;
+    for (int i = 0; i < n; ++i) {
+      pAp += p[i] * Ap[i];
+    }
+
+    if (pAp == 0.0) {
+      break;
+    }
+
+    double alpha = rsold / pAp;
+
+    for (int i = 0; i < n; ++i) {
+      x[i] += alpha * p[i];
+      r[i] -= alpha * Ap[i];
+    }
+
+    double rsnew = 0.0;
+    for (int i = 0; i < n; ++i) {
+      rsnew += r[i] * r[i];
+    }
+
+    if (std::sqrt(rsnew) < tolerance) {
+      break;
+    }
+
+    for (int i = 0; i < n; ++i) {
+      p[i] = r[i] + (rsnew / rsold) * p[i];
+    }
+    rsold = rsnew;
+  }
+
+  return true;
+}
+
+bool KruglovaAConjGradSleSEQ::PostProcessingImpl() {
+  return true;
+}
+
+}  // namespace kruglova_a_conjugate_gradient_sle
diff --git a/tasks/kruglova_a_conjugate_gradient_sle/settings.json b/tasks/kruglova_a_conjugate_gradient_sle/settings.json
new file mode 100644
index 0000000000..0be0208fc6
--- /dev/null
+++ b/tasks/kruglova_a_conjugate_gradient_sle/settings.json
@@ -0,0 +1,10 @@
+{
+  "tasks": {
+    "all": "enabled",
+    "omp": "enabled",
+    "seq": "enabled",
+    "stl": "enabled",
+    "tbb": "enabled"
+  },
+  "tasks_type": "threads"
+}
diff --git a/tasks/kruglova_a_conjugate_gradient_sle/tests/functional/main.cpp b/tasks/kruglova_a_conjugate_gradient_sle/tests/functional/main.cpp
new file mode 100644
index 0000000000..95b51f6043
--- /dev/null
+++ b/tasks/kruglova_a_conjugate_gradient_sle/tests/functional/main.cpp
@@ -0,0 +1,95 @@
+#include <gtest/gtest.h>
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <string>
+#include <tuple>
+#include <vector>
+
+#include "kruglova_a_conjugate_gradient_sle/common/include/common.hpp"
+#include "kruglova_a_conjugate_gradient_sle/seq/include/ops_seq.hpp"
+#include "util/include/func_test_util.hpp"
+
+namespace kruglova_a_conjugate_gradient_sle {
+
+class KruglovaAFuncTestAConjGradSle : public ppc::util::BaseRunFuncTests<InType, OutType, TestType> {
+ public:
+  static std::string PrintTestParam(const TestType &test_param) {
+    return std::get<1>(test_param) + "_" + std::to_string(std::get<0>(test_param));
+  }
+
+ protected:
+  void SetUp() override {
+    TestType params = std::get<static_cast<std::size_t>(ppc::util::GTestParamIndex::kTestParams)>(GetParam());
+    int size = std::get<0>(params);
+    std::string type = std::get<1>(params);
+
+    input_data_.size = size;
+    input_data_.A.assign(size * size, 0.0);
+    input_data_.b.assign(size, 0.0);
+
+    if (type == "Identity") {
+      for (int i = 0; i < size; ++i) {
+        input_data_.A[i * size + i] = 1.0;
+        input_data_.b[i] = static_cast<double>(i + 1);
+      }
+    } else if (type == "Diagonal") {
+      for (int i = 0; i < size; ++i) {
+        input_data_.A[i * size + i] = static_cast<double>(i + 1) * 10.0;
+        input_data_.b[i] = input_data_.A[i * size + i];
+      }
+    } else {
+      for (int i = 0; i < size; ++i) {
+        double sum = 0.0;
+        for (int j = 0; j < size; ++j) {
+          if (i != j) {
+            double val = static_cast<double>((i + j) % 5 + 1);
+            input_data_.A[i * size + j] = input_data_.A[j * size + i] = val;
+            sum += val;
+          }
+        }
+        input_data_.A[i * size + i] = sum + 10.0;
+        input_data_.b[i] = static_cast<double>(i % 3 + 1);
+      }
+    }
+  }
+
+  bool CheckTestOutputData(OutType &output_data) final {
+    int n = input_data_.size;
+    double max_err = 0.0;
+    for (int i = 0; i < n; ++i) {
+      double ax = 0.0;
+      for (int j = 0; j < n; ++j) {
+        ax += input_data_.A[i * n + j] * output_data[j];
+      }
+      max_err = std::max(max_err, std::abs(ax - input_data_.b[i]));
+    }
+    return max_err < 1e-4;
+  }
+
+  InType GetTestInputData() final {
+    return input_data_;
+  }
+
+ private:
+  InType input_data_;
+};
+
+TEST_P(KruglovaAFuncTestAConjGradSle, SolveSystem) {
+  ExecuteTest(GetParam());
+}
+
+const std::array<TestType, 6> kTestParam = {std::make_tuple(1, "Size1"),    std::make_tuple(3, "Identity"),
+                                            std::make_tuple(5, "Diagonal"), std::make_tuple(10, "Size10"),
+                                            std::make_tuple(50, "Size50"),  std::make_tuple(101, "OddSize")};
+
+const auto kTestTasksList = std::tuple_cat(ppc::util::AddFuncTask<KruglovaAConjGradSleSEQ, InType>(
+    kTestParam, PPC_SETTINGS_kruglova_a_conjugate_gradient_sle));
+
+const auto kGtestValues = ppc::util::ExpandToValues(kTestTasksList);
+const auto kPerfTestName = KruglovaAFuncTestAConjGradSle::PrintFuncTestName<KruglovaAFuncTestAConjGradSle>;
+
+INSTANTIATE_TEST_SUITE_P(SleSolverTests, KruglovaAFuncTestAConjGradSle, kGtestValues, kPerfTestName);
+
+}  // namespace kruglova_a_conjugate_gradient_sle
diff --git a/tasks/kruglova_a_conjugate_gradient_sle/tests/performance/main.cpp b/tasks/kruglova_a_conjugate_gradient_sle/tests/performance/main.cpp
new file mode 100644
index 0000000000..c2608dbd52
--- /dev/null
+++ b/tasks/kruglova_a_conjugate_gradient_sle/tests/performance/main.cpp
@@ -0,0 +1,64 @@
+#include <gtest/gtest.h>
+
+#include <vector>
+
+#include "kruglova_a_conjugate_gradient_sle/common/include/common.hpp"
+#include "kruglova_a_conjugate_gradient_sle/seq/include/ops_seq.hpp"
+#include "util/include/perf_test_util.hpp"
+
+namespace kruglova_a_conjugate_gradient_sle {
+
+class KruglovaAPerfTestAConjGradSle : public ppc::util::BaseRunPerfTests<InType, OutType> {
+ protected:
+  const int kSize = 2000;
+  InType input_data_{};
+
+  void SetUp() override {
+    input_data_.size = kSize;
+    input_data_.A.resize(kSize * kSize);
+    input_data_.b.resize(kSize);
+
+    for (int i = 0; i < kSize; ++i) {
+      for (int j = 0; j < kSize; ++j) {
+        if (i == j) {
+          input_data_.A[i * kSize + j] = static_cast<double>(kSize + 10);
+        } else {
+          input_data_.A[i * kSize + j] = 1.0;
+        }
+      }
+      input_data_.b[i] = static_cast<double>(i % 10 + 1);
+    }
+  }
+
+  bool CheckTestOutputData(OutType &output_data) final {
+    return output_data.size() == static_cast<size_t>(kSize);
+  }
+
+  InType GetTestInputData() final {
+    return input_data_;
+  }
+};
+
+TEST_P(KruglovaAPerfTestAConjGradSle, RunPerfPipeline) {
+  ExecuteTest(GetParam());
+}
+
+TEST_P(KruglovaAPerfTestAConjGradSle, RunPerfTask) {
+  ExecuteTest(GetParam());
+}
+
+namespace {
+
+const auto kAllPerfTasks = ppc::util::MakeAllPerfTasks<InType, KruglovaAConjGradSleSEQ
+
+                                                       >(PPC_SETTINGS_kruglova_a_conjugate_gradient_sle);
+
+const auto kGtestValues = ppc::util::TupleToGTestValues(kAllPerfTasks);
+
+const auto kPerfTestName = KruglovaAPerfTestAConjGradSle::CustomPerfTestName;
+
+INSTANTIATE_TEST_SUITE_P(SequentialPerformance, KruglovaAPerfTestAConjGradSle, kGtestValues, kPerfTestName);
+
+}  // namespace
+
+}  // namespace kruglova_a_conjugate_gradient_sle

From 47771f17cce2fdddb60190b1732773dc4e273376 Mon Sep 17 00:00:00 2001
From: AlenaK13 <kruglovatm@mail.ru>
Date: Sat, 28 Feb 2026 01:04:26 +0300
Subject: [PATCH 02/11] clang_tidy 1.0

---
 .../seq/src/ops_seq.cpp                         | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/tasks/kruglova_a_conjugate_gradient_sle/seq/src/ops_seq.cpp b/tasks/kruglova_a_conjugate_gradient_sle/seq/src/ops_seq.cpp
index 16b25068bf..6b0c153b36 100644
--- a/tasks/kruglova_a_conjugate_gradient_sle/seq/src/ops_seq.cpp
+++ b/tasks/kruglova_a_conjugate_gradient_sle/seq/src/ops_seq.cpp
@@ -1,6 +1,7 @@
 #include "kruglova_a_conjugate_gradient_sle/seq/include/ops_seq.hpp"
 
 #include <cmath>
+#include <cstddef>
 #include <vector>
 
 namespace kruglova_a_conjugate_gradient_sle {
@@ -38,7 +39,7 @@ bool KruglovaAConjGradSleSEQ::RunImpl() {
 
   std::vector<double> r = b;
   std::vector<double> p = r;
-  std::vector<double> Ap(n, 0.0);
+  std::vector<double> ap(n, 0.0);
 
   double rsold = 0.0;
   for (int i = 0; i < n; ++i) {
@@ -49,26 +50,26 @@ bool KruglovaAConjGradSleSEQ::RunImpl() {
 
   for (int iter = 0; iter < n * 2; ++iter) {
     for (int i = 0; i < n; ++i) {
-      Ap[i] = 0.0;
+      ap[i] = 0.0;
       for (int j = 0; j < n; ++j) {
-        Ap[i] += A[i * n + j] * p[j];
+        ap[i] += A[(i * n) + j] * p[j];
       }
     }
 
-    double pAp = 0.0;
+    double p_ap = 0.0;
     for (int i = 0; i < n; ++i) {
-      pAp += p[i] * Ap[i];
+      p_ap += p[i] * ap[i];
     }
 
-    if (pAp == 0.0) {
+    if (p_ap == 0.0) {
       break;
     }
 
-    double alpha = rsold / pAp;
+    double alpha = rsold / p_ap;
 
     for (int i = 0; i < n; ++i) {
       x[i] += alpha * p[i];
-      r[i] -= alpha * Ap[i];
+      r[i] -= alpha * ap[i];
     }
 
     double rsnew = 0.0;

From 9f54e61957b9c63fe7d70b167bf8c954f7762625 Mon Sep 17 00:00:00 2001
From: AlenaK13 <kruglovatm@mail.ru>
Date: Sat, 28 Feb 2026 01:27:57 +0300
Subject: [PATCH 03/11] clang_tidy 2.0

---
 .../common/include/common.hpp                 |  2 +-
 .../seq/src/ops_seq.cpp                       |  8 ++++----
 .../tests/functional/main.cpp                 |  7 ++++---
 .../tests/performance/main.cpp                | 20 +++++++++----------
 4 files changed, 19 insertions(+), 18 deletions(-)

diff --git a/tasks/kruglova_a_conjugate_gradient_sle/common/include/common.hpp b/tasks/kruglova_a_conjugate_gradient_sle/common/include/common.hpp
index ffc9b4add8..608a8b8654 100644
--- a/tasks/kruglova_a_conjugate_gradient_sle/common/include/common.hpp
+++ b/tasks/kruglova_a_conjugate_gradient_sle/common/include/common.hpp
@@ -9,7 +9,7 @@
 namespace kruglova_a_conjugate_gradient_sle {
 
 struct SLEInput {
-  int size;
+  int size = 0;
   std::vector<double> A;
   std::vector<double> b;
 };
diff --git a/tasks/kruglova_a_conjugate_gradient_sle/seq/src/ops_seq.cpp b/tasks/kruglova_a_conjugate_gradient_sle/seq/src/ops_seq.cpp
index 6b0c153b36..fdfbf61165 100644
--- a/tasks/kruglova_a_conjugate_gradient_sle/seq/src/ops_seq.cpp
+++ b/tasks/kruglova_a_conjugate_gradient_sle/seq/src/ops_seq.cpp
@@ -17,7 +17,7 @@ bool KruglovaAConjGradSleSEQ::ValidationImpl() {
     return false;
   }
 
-  if (in.A.size() != static_cast<size_t>(in.size * in.size)) {
+  if (in.A.size() != static_cast<size_t>(in.size) * static_cast<size_t>(in.size)) {
     return false;
   }
   if (in.b.size() != static_cast<size_t>(in.size)) {
@@ -32,7 +32,7 @@ bool KruglovaAConjGradSleSEQ::PreProcessingImpl() {
 }
 
 bool KruglovaAConjGradSleSEQ::RunImpl() {
-  const auto &A = GetInput().A;
+  const auto &a = GetInput().A;
   const auto &b = GetInput().b;
   int n = GetInput().size;
   auto &x = GetOutput();
@@ -52,7 +52,7 @@ bool KruglovaAConjGradSleSEQ::RunImpl() {
     for (int i = 0; i < n; ++i) {
       ap[i] = 0.0;
       for (int j = 0; j < n; ++j) {
-        ap[i] += A[(i * n) + j] * p[j];
+        ap[i] += a[(i * n) + j] * p[j];
       }
     }
 
@@ -82,7 +82,7 @@ bool KruglovaAConjGradSleSEQ::RunImpl() {
     }
 
     for (int i = 0; i < n; ++i) {
-      p[i] = r[i] + (rsnew / rsold) * p[i];
+      p[i] = r[i] + ((rsnew / rsold) * p[i]);
     }
     rsold = rsnew;
   }
diff --git a/tasks/kruglova_a_conjugate_gradient_sle/tests/functional/main.cpp b/tasks/kruglova_a_conjugate_gradient_sle/tests/functional/main.cpp
index 95b51f6043..1629da765d 100644
--- a/tasks/kruglova_a_conjugate_gradient_sle/tests/functional/main.cpp
+++ b/tasks/kruglova_a_conjugate_gradient_sle/tests/functional/main.cpp
@@ -3,6 +3,7 @@
 #include <algorithm>
 #include <array>
 #include <cmath>
+#include <cstddef>
 #include <string>
 #include <tuple>
 #include <vector>
@@ -26,12 +27,12 @@ class KruglovaAFuncTestAConjGradSle : public ppc::util::BaseRunFuncTests<InType,
     std::string type = std::get<1>(params);
 
     input_data_.size = size;
-    input_data_.A.assign(size * size, 0.0);
+    input_data_.A.assign(static_cast<size_t>(size) * static_cast<size_t>(size), 0.0);
     input_data_.b.assign(size, 0.0);
 
     if (type == "Identity") {
       for (int i = 0; i < size; ++i) {
-        input_data_.A[i * size + i] = 1.0;
+        input_data_.A[(i * size) + i] = 1.0;
         input_data_.b[i] = static_cast<double>(i + 1);
       }
     } else if (type == "Diagonal") {
@@ -44,7 +45,7 @@ class KruglovaAFuncTestAConjGradSle : public ppc::util::BaseRunFuncTests<InType,
         double sum = 0.0;
         for (int j = 0; j < size; ++j) {
           if (i != j) {
-            double val = static_cast<double>((i + j) % 5 + 1);
+            double val = static_cast<double>(((i + j) % 5) + 1);
             input_data_.A[i * size + j] = input_data_.A[j * size + i] = val;
             sum += val;
           }
diff --git a/tasks/kruglova_a_conjugate_gradient_sle/tests/performance/main.cpp b/tasks/kruglova_a_conjugate_gradient_sle/tests/performance/main.cpp
index c2608dbd52..c05e305f7e 100644
--- a/tasks/kruglova_a_conjugate_gradient_sle/tests/performance/main.cpp
+++ b/tasks/kruglova_a_conjugate_gradient_sle/tests/performance/main.cpp
@@ -10,28 +10,28 @@ namespace kruglova_a_conjugate_gradient_sle {
 
 class KruglovaAPerfTestAConjGradSle : public ppc::util::BaseRunPerfTests<InType, OutType> {
  protected:
-  const int kSize = 2000;
+  const int k_size = 2000;
   InType input_data_{};
 
   void SetUp() override {
-    input_data_.size = kSize;
-    input_data_.A.resize(kSize * kSize);
-    input_data_.b.resize(kSize);
+    input_data_.size = k_size;
+    input_data_.A.resize(static_cast<size_t>(k_size) * static_cast<size_t>(k_size));
+    input_data_.b.resize(k_size);
 
-    for (int i = 0; i < kSize; ++i) {
-      for (int j = 0; j < kSize; ++j) {
+    for (int i = 0; i < k_size; ++i) {
+      for (int j = 0; j < k_size; ++j) {
         if (i == j) {
-          input_data_.A[i * kSize + j] = static_cast<double>(kSize + 10);
+          input_data_.A[i * k_size + j] = static_cast<double>(k_size + 10);
         } else {
-          input_data_.A[i * kSize + j] = 1.0;
+          input_data_.A[i * k_size + j] = 1.0;
         }
       }
-      input_data_.b[i] = static_cast<double>(i % 10 + 1);
+      input_data_.b[i] = static_cast<double>((i % 10) + 1);
     }
   }
 
   bool CheckTestOutputData(OutType &output_data) final {
-    return output_data.size() == static_cast<size_t>(kSize);
+    return output_data.size() == static_cast<size_t>(k_size);
   }
 
   InType GetTestInputData() final {

From b43fb1321bc555cc45cdbd941e3f2d1f0f76cd39 Mon Sep 17 00:00:00 2001
From: AlenaK13 <kruglovatm@mail.ru>
Date: Sat, 28 Feb 2026 01:46:38 +0300
Subject: [PATCH 04/11] clang_tidy 3.0

---
 .../seq/src/ops_seq.cpp                              |  1 -
 .../tests/functional/main.cpp                        | 12 ++++++------
 .../tests/performance/main.cpp                       |  1 +
 3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/tasks/kruglova_a_conjugate_gradient_sle/seq/src/ops_seq.cpp b/tasks/kruglova_a_conjugate_gradient_sle/seq/src/ops_seq.cpp
index fdfbf61165..bb4f468f3c 100644
--- a/tasks/kruglova_a_conjugate_gradient_sle/seq/src/ops_seq.cpp
+++ b/tasks/kruglova_a_conjugate_gradient_sle/seq/src/ops_seq.cpp
@@ -1,6 +1,5 @@
 #include "kruglova_a_conjugate_gradient_sle/seq/include/ops_seq.hpp"
 
-#include <cmath>
 #include <cstddef>
 #include <vector>
 
diff --git a/tasks/kruglova_a_conjugate_gradient_sle/tests/functional/main.cpp b/tasks/kruglova_a_conjugate_gradient_sle/tests/functional/main.cpp
index 1629da765d..eeecf0e0d4 100644
--- a/tasks/kruglova_a_conjugate_gradient_sle/tests/functional/main.cpp
+++ b/tasks/kruglova_a_conjugate_gradient_sle/tests/functional/main.cpp
@@ -37,8 +37,8 @@ class KruglovaAFuncTestAConjGradSle : public ppc::util::BaseRunFuncTests<InType,
       }
     } else if (type == "Diagonal") {
       for (int i = 0; i < size; ++i) {
-        input_data_.A[i * size + i] = static_cast<double>(i + 1) * 10.0;
-        input_data_.b[i] = input_data_.A[i * size + i];
+        input_data_.A[(i * size) + i] = static_cast<double>(i + 1) * 10.0;
+        input_data_.b[i] = input_data_.A[(i * size) + i];
       }
     } else {
       for (int i = 0; i < size; ++i) {
@@ -46,12 +46,12 @@ class KruglovaAFuncTestAConjGradSle : public ppc::util::BaseRunFuncTests<InType,
         for (int j = 0; j < size; ++j) {
           if (i != j) {
             double val = static_cast<double>(((i + j) % 5) + 1);
-            input_data_.A[i * size + j] = input_data_.A[j * size + i] = val;
+            input_data_.A[(i * size) + j] = input_data_.A[(j * size) + i] = val;
             sum += val;
           }
         }
-        input_data_.A[i * size + i] = sum + 10.0;
-        input_data_.b[i] = static_cast<double>(i % 3 + 1);
+        input_data_.A[(i * size) + i] = sum + 10.0;
+        input_data_.b[i] = static_cast<double>((i % 3) + 1);
       }
     }
   }
@@ -62,7 +62,7 @@ class KruglovaAFuncTestAConjGradSle : public ppc::util::BaseRunFuncTests<InType,
     for (int i = 0; i < n; ++i) {
       double ax = 0.0;
       for (int j = 0; j < n; ++j) {
-        ax += input_data_.A[i * n + j] * output_data[j];
+        ax += input_data_.A[(i * n) + j] * output_data[j];
       }
       max_err = std::max(max_err, std::abs(ax - input_data_.b[i]));
     }
diff --git a/tasks/kruglova_a_conjugate_gradient_sle/tests/performance/main.cpp b/tasks/kruglova_a_conjugate_gradient_sle/tests/performance/main.cpp
index c05e305f7e..9c6f08a232 100644
--- a/tasks/kruglova_a_conjugate_gradient_sle/tests/performance/main.cpp
+++ b/tasks/kruglova_a_conjugate_gradient_sle/tests/performance/main.cpp
@@ -1,5 +1,6 @@
 #include <gtest/gtest.h>
 
+#include <cstddef>
 #include <vector>
 
 #include "kruglova_a_conjugate_gradient_sle/common/include/common.hpp"

From 07e64b3594f88f1250dc73d0d0519702c030ef4c Mon Sep 17 00:00:00 2001
From: AlenaK13 <kruglovatm@mail.ru>
Date: Sat, 28 Feb 2026 22:38:47 +0300
Subject: [PATCH 05/11] clang_tidy 4.0

---
 .../seq/src/ops_seq.cpp                       | 24 ++++---
 .../tests/functional/main.cpp                 | 71 +++++++++++--------
 .../tests/performance/main.cpp                | 17 +++--
 3 files changed, 65 insertions(+), 47 deletions(-)

diff --git a/tasks/kruglova_a_conjugate_gradient_sle/seq/src/ops_seq.cpp b/tasks/kruglova_a_conjugate_gradient_sle/seq/src/ops_seq.cpp
index bb4f468f3c..260c1381f4 100644
--- a/tasks/kruglova_a_conjugate_gradient_sle/seq/src/ops_seq.cpp
+++ b/tasks/kruglova_a_conjugate_gradient_sle/seq/src/ops_seq.cpp
@@ -1,8 +1,11 @@
 #include "kruglova_a_conjugate_gradient_sle/seq/include/ops_seq.hpp"
 
+#include <cmath>
 #include <cstddef>
 #include <vector>
 
+#include "kruglova_a_conjugate_gradient_sle/common/include/common.hpp"
+
 namespace kruglova_a_conjugate_gradient_sle {
 
 KruglovaAConjGradSleSEQ::KruglovaAConjGradSleSEQ(const InType &in) {
@@ -30,6 +33,16 @@ bool KruglovaAConjGradSleSEQ::PreProcessingImpl() {
   return true;
 }
 
+void matrix_vector_multiply(const std::vector<double> &a, const std::vector<double> &p, std::vector<double> &ap,
+                            int n) {
+  for (int i = 0; i < n; ++i) {
+    ap[i] = 0.0;
+    for (int j = 0; j < n; ++j) {
+      ap[i] += a[(i * n) + j] * p[j];
+    }
+  }
+}
+
 bool KruglovaAConjGradSleSEQ::RunImpl() {
   const auto &a = GetInput().A;
   const auto &b = GetInput().b;
@@ -48,24 +61,18 @@ bool KruglovaAConjGradSleSEQ::RunImpl() {
   const double tolerance = 1e-8;
 
   for (int iter = 0; iter < n * 2; ++iter) {
-    for (int i = 0; i < n; ++i) {
-      ap[i] = 0.0;
-      for (int j = 0; j < n; ++j) {
-        ap[i] += a[(i * n) + j] * p[j];
-      }
-    }
+    matrix_vector_multiply(a, p, ap, n);
 
     double p_ap = 0.0;
     for (int i = 0; i < n; ++i) {
       p_ap += p[i] * ap[i];
     }
 
-    if (p_ap == 0.0) {
+    if (std::abs(p_ap) < 1e-15) {
       break;
     }
 
     double alpha = rsold / p_ap;
-
     for (int i = 0; i < n; ++i) {
       x[i] += alpha * p[i];
       r[i] -= alpha * ap[i];
@@ -85,7 +92,6 @@ bool KruglovaAConjGradSleSEQ::RunImpl() {
     }
     rsold = rsnew;
   }
-
   return true;
 }
 
diff --git a/tasks/kruglova_a_conjugate_gradient_sle/tests/functional/main.cpp b/tasks/kruglova_a_conjugate_gradient_sle/tests/functional/main.cpp
index eeecf0e0d4..c5173bcd1d 100644
--- a/tasks/kruglova_a_conjugate_gradient_sle/tests/functional/main.cpp
+++ b/tasks/kruglova_a_conjugate_gradient_sle/tests/functional/main.cpp
@@ -3,7 +3,6 @@
 #include <algorithm>
 #include <array>
 #include <cmath>
-#include <cstddef>
 #include <string>
 #include <tuple>
 #include <vector>
@@ -21,60 +20,74 @@ class KruglovaAFuncTestAConjGradSle : public ppc::util::BaseRunFuncTests<InType,
   }
 
  protected:
+  // Исправление: Правильное объявление SetUp внутри класса
   void SetUp() override {
     TestType params = std::get<static_cast<std::size_t>(ppc::util::GTestParamIndex::kTestParams)>(GetParam());
     int size = std::get<0>(params);
     std::string type = std::get<1>(params);
 
-    input_data_.size = size;
-    input_data_.A.assign(static_cast<size_t>(size) * static_cast<size_t>(size), 0.0);
-    input_data_.b.assign(size, 0.0);
+    input_data.size = size;
+    input_data.A.assign(static_cast<size_t>(size) * static_cast<size_t>(size), 0.0);
+    input_data.b.assign(size, 0.0);
 
     if (type == "Identity") {
-      for (int i = 0; i < size; ++i) {
-        input_data_.A[(i * size) + i] = 1.0;
-        input_data_.b[i] = static_cast<double>(i + 1);
-      }
+      fill_identity(size);
     } else if (type == "Diagonal") {
-      for (int i = 0; i < size; ++i) {
-        input_data_.A[(i * size) + i] = static_cast<double>(i + 1) * 10.0;
-        input_data_.b[i] = input_data_.A[(i * size) + i];
-      }
+      fill_diagonal(size);
     } else {
-      for (int i = 0; i < size; ++i) {
-        double sum = 0.0;
-        for (int j = 0; j < size; ++j) {
-          if (i != j) {
-            double val = static_cast<double>(((i + j) % 5) + 1);
-            input_data_.A[(i * size) + j] = input_data_.A[(j * size) + i] = val;
-            sum += val;
-          }
-        }
-        input_data_.A[(i * size) + i] = sum + 10.0;
-        input_data_.b[i] = static_cast<double>((i % 3) + 1);
-      }
+      fill_spd(size);
     }
   }
 
   bool CheckTestOutputData(OutType &output_data) final {
-    int n = input_data_.size;
+    int n = input_data.size;
     double max_err = 0.0;
     for (int i = 0; i < n; ++i) {
       double ax = 0.0;
       for (int j = 0; j < n; ++j) {
-        ax += input_data_.A[(i * n) + j] * output_data[j];
+        ax += input_data.A[(i * n) + j] * output_data[j];
       }
-      max_err = std::max(max_err, std::abs(ax - input_data_.b[i]));
+      // Исправление: std::max теперь получит корректные типы
+      max_err = std::max(max_err, std::abs(ax - input_data.b[i]));
     }
     return max_err < 1e-4;
   }
 
   InType GetTestInputData() final {
-    return input_data_;
+    return input_data;
   }
 
  private:
-  InType input_data_;
+  InType input_data;
+
+  void fill_identity(int size) {
+    for (int i = 0; i < size; ++i) {
+      input_data.A[(i * size) + i] = 1.0;
+      input_data.b[i] = static_cast<double>(i + 1);
+    }
+  }
+
+  void fill_diagonal(int size) {
+    for (int i = 0; i < size; ++i) {
+      input_data.A[(i * size) + i] = static_cast<double>(i + 1) * 10.0;
+      input_data.b[i] = input_data.A[(i * size) + i];
+    }
+  }
+
+  void fill_spd(int size) {
+    for (int i = 0; i < size; ++i) {
+      double sum = 0.0;
+      for (int j = 0; j < size; ++j) {
+        if (i != j) {
+          auto val = static_cast<double>(((i + j) % 5) + 1);
+          input_data.A[(i * size) + j] = input_data.A[(j * size) + i] = val;
+          sum += val;
+        }
+      }
+      input_data.A[(i * size) + i] = sum + 10.0;
+      input_data.b[i] = static_cast<double>((i % 3) + 1);
+    }
+  }
 };
 
 TEST_P(KruglovaAFuncTestAConjGradSle, SolveSystem) {
diff --git a/tasks/kruglova_a_conjugate_gradient_sle/tests/performance/main.cpp b/tasks/kruglova_a_conjugate_gradient_sle/tests/performance/main.cpp
index 9c6f08a232..653df3a74a 100644
--- a/tasks/kruglova_a_conjugate_gradient_sle/tests/performance/main.cpp
+++ b/tasks/kruglova_a_conjugate_gradient_sle/tests/performance/main.cpp
@@ -12,22 +12,21 @@ namespace kruglova_a_conjugate_gradient_sle {
 class KruglovaAPerfTestAConjGradSle : public ppc::util::BaseRunPerfTests<InType, OutType> {
  protected:
   const int k_size = 2000;
-  InType input_data_{};
-
+  InType input_data{};
   void SetUp() override {
-    input_data_.size = k_size;
-    input_data_.A.resize(static_cast<size_t>(k_size) * static_cast<size_t>(k_size));
-    input_data_.b.resize(k_size);
+    input_data.size = k_size;
+    input_data.A.resize(static_cast<size_t>(k_size) * static_cast<size_t>(k_size));
+    input_data.b.resize(k_size);
 
     for (int i = 0; i < k_size; ++i) {
       for (int j = 0; j < k_size; ++j) {
         if (i == j) {
-          input_data_.A[i * k_size + j] = static_cast<double>(k_size + 10);
+          input_data.A[(i * k_size) + j] = static_cast<double>(k_size + 10);
         } else {
-          input_data_.A[i * k_size + j] = 1.0;
+          input_data.A[(i * k_size) + j] = 1.0;
         }
       }
-      input_data_.b[i] = static_cast<double>((i % 10) + 1);
+      input_data.b[i] = static_cast<double>((i % 10) + 1);
     }
   }
 
@@ -36,7 +35,7 @@ class KruglovaAPerfTestAConjGradSle : public ppc::util::BaseRunPerfTests<InType,
   }
 
   InType GetTestInputData() final {
-    return input_data_;
+    return input_data;
   }
 };
 

From 8b29355ed26f13d0282d8fe9cb4f4fa5db7d98f1 Mon Sep 17 00:00:00 2001
From: AlenaK13 <kruglovatm@mail.ru>
Date: Sat, 28 Feb 2026 22:50:32 +0300
Subject: [PATCH 06/11] compilations

---
 .../seq/src/ops_seq.cpp                       | 22 ++++++++++---------
 1 file changed, 12 insertions(+), 10 deletions(-)

diff --git a/tasks/kruglova_a_conjugate_gradient_sle/seq/src/ops_seq.cpp b/tasks/kruglova_a_conjugate_gradient_sle/seq/src/ops_seq.cpp
index 260c1381f4..f39e72b918 100644
--- a/tasks/kruglova_a_conjugate_gradient_sle/seq/src/ops_seq.cpp
+++ b/tasks/kruglova_a_conjugate_gradient_sle/seq/src/ops_seq.cpp
@@ -8,6 +8,18 @@
 
 namespace kruglova_a_conjugate_gradient_sle {
 
+namespace {
+void matrix_vector_multiply(const std::vector<double> &a, const std::vector<double> &p, std::vector<double> &ap,
+                            int n) {
+  for (int i = 0; i < n; ++i) {
+    ap[i] = 0.0;
+    for (int j = 0; j < n; ++j) {
+      ap[i] += a[(i * n) + j] * p[j];
+    }
+  }
+}
+}  // namespace
+
 KruglovaAConjGradSleSEQ::KruglovaAConjGradSleSEQ(const InType &in) {
   SetTypeOfTask(GetStaticTypeOfTask());
   GetInput() = in;
@@ -33,16 +45,6 @@ bool KruglovaAConjGradSleSEQ::PreProcessingImpl() {
   return true;
 }
 
-void matrix_vector_multiply(const std::vector<double> &a, const std::vector<double> &p, std::vector<double> &ap,
-                            int n) {
-  for (int i = 0; i < n; ++i) {
-    ap[i] = 0.0;
-    for (int j = 0; j < n; ++j) {
-      ap[i] += a[(i * n) + j] * p[j];
-    }
-  }
-}
-
 bool KruglovaAConjGradSleSEQ::RunImpl() {
   const auto &a = GetInput().A;
   const auto &b = GetInput().b;

From c6ae4c5fdf5e02e097b83eccf8b499e600ac0db9 Mon Sep 17 00:00:00 2001
From: AlenaK13 <kruglovatm@mail.ru>
Date: Sat, 28 Feb 2026 23:08:00 +0300
Subject: [PATCH 07/11] clang_tidy 5.0

---
 .../seq/src/ops_seq.cpp                       |  5 +-
 .../tests/functional/main.cpp                 | 48 ++++++++++---------
 2 files changed, 27 insertions(+), 26 deletions(-)

diff --git a/tasks/kruglova_a_conjugate_gradient_sle/seq/src/ops_seq.cpp b/tasks/kruglova_a_conjugate_gradient_sle/seq/src/ops_seq.cpp
index f39e72b918..cad66b4583 100644
--- a/tasks/kruglova_a_conjugate_gradient_sle/seq/src/ops_seq.cpp
+++ b/tasks/kruglova_a_conjugate_gradient_sle/seq/src/ops_seq.cpp
@@ -9,8 +9,7 @@
 namespace kruglova_a_conjugate_gradient_sle {
 
 namespace {
-void matrix_vector_multiply(const std::vector<double> &a, const std::vector<double> &p, std::vector<double> &ap,
-                            int n) {
+void MatrixVectorMultiply(const std::vector<double> &a, const std::vector<double> &p, std::vector<double> &ap, int n) {
   for (int i = 0; i < n; ++i) {
     ap[i] = 0.0;
     for (int j = 0; j < n; ++j) {
@@ -63,7 +62,7 @@ bool KruglovaAConjGradSleSEQ::RunImpl() {
   const double tolerance = 1e-8;
 
   for (int iter = 0; iter < n * 2; ++iter) {
-    matrix_vector_multiply(a, p, ap, n);
+    MatrixVectorMultiply(a, p, ap, n);
 
     double p_ap = 0.0;
     for (int i = 0; i < n; ++i) {
diff --git a/tasks/kruglova_a_conjugate_gradient_sle/tests/functional/main.cpp b/tasks/kruglova_a_conjugate_gradient_sle/tests/functional/main.cpp
index c5173bcd1d..79fa12127d 100644
--- a/tasks/kruglova_a_conjugate_gradient_sle/tests/functional/main.cpp
+++ b/tasks/kruglova_a_conjugate_gradient_sle/tests/functional/main.cpp
@@ -3,6 +3,7 @@
 #include <algorithm>
 #include <array>
 #include <cmath>
+#include <cstddef>
 #include <string>
 #include <tuple>
 #include <vector>
@@ -20,72 +21,71 @@ class KruglovaAFuncTestAConjGradSle : public ppc::util::BaseRunFuncTests<InType,
   }
 
  protected:
-  // Исправление: Правильное объявление SetUp внутри класса
   void SetUp() override {
     TestType params = std::get<static_cast<std::size_t>(ppc::util::GTestParamIndex::kTestParams)>(GetParam());
     int size = std::get<0>(params);
     std::string type = std::get<1>(params);
 
-    input_data.size = size;
-    input_data.A.assign(static_cast<size_t>(size) * static_cast<size_t>(size), 0.0);
-    input_data.b.assign(size, 0.0);
+    input_data_.size = size;
+    input_data_.A.assign(static_cast<std::size_t>(size) * static_cast<std::size_t>(size), 0.0);
+    input_data_.b.assign(size, 0.0);
 
     if (type == "Identity") {
-      fill_identity(size);
+      FillIdentity(size);
     } else if (type == "Diagonal") {
-      fill_diagonal(size);
+      FillDiagonal(size);
     } else {
-      fill_spd(size);
+      FillSpd(size);
     }
   }
 
   bool CheckTestOutputData(OutType &output_data) final {
-    int n = input_data.size;
+    int n = input_data_.size;
     double max_err = 0.0;
     for (int i = 0; i < n; ++i) {
       double ax = 0.0;
       for (int j = 0; j < n; ++j) {
-        ax += input_data.A[(i * n) + j] * output_data[j];
+        ax += input_data_.A[(static_cast<std::size_t>(i) * n) + j] * output_data[j];
       }
-      // Исправление: std::max теперь получит корректные типы
-      max_err = std::max(max_err, std::abs(ax - input_data.b[i]));
+      max_err = std::max(max_err, std::abs(ax - input_data_.b[i]));
     }
     return max_err < 1e-4;
   }
 
   InType GetTestInputData() final {
-    return input_data;
+    return input_data_;
   }
 
  private:
-  InType input_data;
+  InType input_data_;
 
-  void fill_identity(int size) {
+  void FillIdentity(int size) {
     for (int i = 0; i < size; ++i) {
-      input_data.A[(i * size) + i] = 1.0;
-      input_data.b[i] = static_cast<double>(i + 1);
+      input_data_.A[(static_cast<std::size_t>(i) * size) + i] = 1.0;
+      input_data_.b[i] = static_cast<double>(i + 1);
     }
   }
 
-  void fill_diagonal(int size) {
+  void FillDiagonal(int size) {
     for (int i = 0; i < size; ++i) {
-      input_data.A[(i * size) + i] = static_cast<double>(i + 1) * 10.0;
-      input_data.b[i] = input_data.A[(i * size) + i];
+      input_data_.A[(static_cast<std::size_t>(i) * size) + i] = static_cast<double>(i + 1) * 10.0;
+      input_data_.b[i] = input_data_.A[(static_cast<std::size_t>(i) * size) + i];
     }
   }
 
-  void fill_spd(int size) {
+  void FillSpd(int size) {
     for (int i = 0; i < size; ++i) {
       double sum = 0.0;
       for (int j = 0; j < size; ++j) {
         if (i != j) {
           auto val = static_cast<double>(((i + j) % 5) + 1);
-          input_data.A[(i * size) + j] = input_data.A[(j * size) + i] = val;
+          input_data_.A[(static_cast<std::size_t>(i) * size) + j] = val;
+          input_data_.A[(static_cast<std::size_t>(j) * size) + i] = val;
           sum += val;
         }
       }
-      input_data.A[(i * size) + i] = sum + 10.0;
-      input_data.b[i] = static_cast<double>((i % 3) + 1);
+      input_data_.A[(static_cast<std::size_t>(i) * size) + i] = sum + 10.0;
+      input_data_.b[i] = static_cast<double>((i % 3) + 1);
     }
   }
 };
@@ -94,6 +94,7 @@ TEST_P(KruglovaAFuncTestAConjGradSle, SolveSystem) {
   ExecuteTest(GetParam());
 }
 
+namespace {
 const std::array<TestType, 6> kTestParam = {std::make_tuple(1, "Size1"),    std::make_tuple(3, "Identity"),
                                             std::make_tuple(5, "Diagonal"), std::make_tuple(10, "Size10"),
                                             std::make_tuple(50, "Size50"),  std::make_tuple(101, "OddSize")};
@@ -105,5 +106,6 @@ const auto kGtestValues = ppc::util::ExpandToValues(kTestTasksList);
 const auto kPerfTestName = KruglovaAFuncTestAConjGradSle::PrintFuncTestName<KruglovaAFuncTestAConjGradSle>;
 
 INSTANTIATE_TEST_SUITE_P(SleSolverTests, KruglovaAFuncTestAConjGradSle, kGtestValues, kPerfTestName);
+}  // namespace
 
 }  // namespace kruglova_a_conjugate_gradient_sle

From 51c1e0ea1a1166fc59fb1542bc8c944ac338c720 Mon Sep 17 00:00:00 2001
From: AlenaK13 <kruglovatm@mail.ru>
Date: Sat, 28 Feb 2026 23:24:51 +0300
Subject: [PATCH 08/11] clang_tidy 6.0

---
 .../kruglova_a_conjugate_gradient_sle/tests/functional/main.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tasks/kruglova_a_conjugate_gradient_sle/tests/functional/main.cpp b/tasks/kruglova_a_conjugate_gradient_sle/tests/functional/main.cpp
index 79fa12127d..128f0ff980 100644
--- a/tasks/kruglova_a_conjugate_gradient_sle/tests/functional/main.cpp
+++ b/tasks/kruglova_a_conjugate_gradient_sle/tests/functional/main.cpp
@@ -22,7 +22,7 @@ class KruglovaAFuncTestAConjGradSle : public ppc::util::BaseRunFuncTests<InType,
 
  protected:
   void SetUp() override {
-    TestType params = std::get<static_cast<std::size_t>(ppc::util::GTestParamIndex::kTestParams)>(GetParam());
+    auto params = std::get<static_cast<std::size_t>(ppc::util::GTestParamIndex::kTestParams)>(GetParam());
     int size = std::get<0>(params);
     std::string type = std::get<1>(params);
 

From e1716808c3b98e1252055b64b61d8694217876ae Mon Sep 17 00:00:00 2001
From: AlenaK13 <kruglovatm@mail.ru>
Date: Sat, 28 Feb 2026 23:42:54 +0300
Subject: [PATCH 09/11] clang_tidy 7.0

---
 .../tests/functional/main.cpp                                 | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tasks/kruglova_a_conjugate_gradient_sle/tests/functional/main.cpp b/tasks/kruglova_a_conjugate_gradient_sle/tests/functional/main.cpp
index 128f0ff980..fd02d4656c 100644
--- a/tasks/kruglova_a_conjugate_gradient_sle/tests/functional/main.cpp
+++ b/tasks/kruglova_a_conjugate_gradient_sle/tests/functional/main.cpp
@@ -3,7 +3,7 @@
 #include <algorithm>
 #include <array>
 #include <cmath>
-#include <cstddef>
+#include <cstddef>  // Для std::size_t
 #include <string>
 #include <tuple>
 #include <vector>
@@ -22,7 +22,7 @@ class KruglovaAFuncTestAConjGradSle : public ppc::util::BaseRunFuncTests<InType,
 
  protected:
   void SetUp() override {
-    auto params = std::get<static_cast<std::size_t>(ppc::util::GTestParamIndex::kTestParams)>(GetParam());
+    TestType params = std::get<2>(GetParam());
     int size = std::get<0>(params);
     std::string type = std::get<1>(params);
 

From eceede437b175f2a3918d25443d3a12992aa81bc Mon Sep 17 00:00:00 2001
From: AlenaK13 <kruglovatm@mail.ru>
Date: Sun, 1 Mar 2026 00:50:01 +0300
Subject: [PATCH 10/11] info.json

---
 tasks/kruglova_a_conjugate_gradient_sle/info.json | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/tasks/kruglova_a_conjugate_gradient_sle/info.json b/tasks/kruglova_a_conjugate_gradient_sle/info.json
index 07492a209b..352b495cea 100644
--- a/tasks/kruglova_a_conjugate_gradient_sle/info.json
+++ b/tasks/kruglova_a_conjugate_gradient_sle/info.json
@@ -1,9 +1,9 @@
 {
   "student": {
-    "first_name": "first_name_t",
-    "group_number": "2222222_t",
-    "last_name": "last_name_t",
-    "middle_name": "middle_name_t",
+    "first_name": "Алёна",
+    "group_number": "3823Б1ФИ2",
+    "last_name": "Круглова",
+    "middle_name": "Витальевна",
     "task_number": "1"
   }
 }

From 89a184784a429fcbc8df426c09e1c8cea152e009 Mon Sep 17 00:00:00 2001
From: Nesterov Alexander <nesterov.alexander@outlook.com>
Date: Sat, 7 Mar 2026 22:26:13 +0100
Subject: [PATCH 11/11] Delete
 tasks/kruglova_a_conjugate_gradient_sle/seq/report.md

---
 tasks/kruglova_a_conjugate_gradient_sle/seq/report.md | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 delete mode 100644 tasks/kruglova_a_conjugate_gradient_sle/seq/report.md

diff --git a/tasks/kruglova_a_conjugate_gradient_sle/seq/report.md b/tasks/kruglova_a_conjugate_gradient_sle/seq/report.md
deleted file mode 100644
index e69de29bb2..0000000000