Week 10

.clang-tidy

@@ -3,7 +3,8 @@ Checks:     '
     readability*,
     google*,
     misc-const-correctness,
-    -readability-identifier-length
+    -readability-identifier-length,
+    -readability-else-after-return
             '
 CheckOptions:
   - key: readability-identifier-naming.NamespaceCase

CMakeLists.txt

@@ -49,7 +49,7 @@ function(cpp_test SOURCE_NAME)
 endfunction(cpp_test)
 
 ##### subdirectories #####
-set(DIRS week-W week-1 week-2 week-3 week-4 week-5 week-6 week-7 week-8 week-9)
+set(DIRS week-W week-2 week-3 week-4 week-5 week-6 week-7 week-8 week-9 week-10)
 foreach(DIR ${DIRS})
     add_subdirectory(${DIR})
 endforeach()

week-10/CMakeLists.txt

@@ -0,0 +1,4 @@
+set(DIRS task-07-01)
+foreach(DIR ${DIRS})
+    add_subdirectory(${DIR})
+endforeach()

week-10/task-07-01/CMakeLists.txt

@@ -0,0 +1,3 @@
+include_directories(include)
+
+add_subdirectory(test)

week-10/task-07-01/include/quadratic-equation.hpp

@@ -0,0 +1,27 @@
+#pragma once
+#include <cmath>
+#include <stdexcept>
+#include <utility>
+#include <variant>
+
+namespace math {
+
+std::variant<std::monostate, double, std::pair<double, double>> quadratic_equation_solution(
+    double a, double b, double c) {
+    if (a == 0.0) {
+        throw std::invalid_argument("Coefficient 'a' should not be 0");
+    }
+    const double d_squared = b * b - 4 * a * c;
+    if (d_squared < 0) {
+        return std::variant<std::monostate, double, std::pair<double, double>>{};
+    } else if (d_squared == 0) {
+        return std::variant<std::monostate, double, std::pair<double, double>>{
+            std::in_place_type<double>, -b / (2 * a)};
+    } else {
+        const double d = std::sqrt(d_squared);
+        return std::variant<std::monostate, double, std::pair<double, double>>{
+            std::in_place_type<std::pair<double, double>>, (-b - d) / 2 * a, (-b + d) / 2 * a};
+    }
+}
+
+}  // namespace math

week-10/task-07-01/test/CMakeLists.txt

@@ -0,0 +1 @@
+cpp_test(test-07-01.cpp)

week-10/task-07-01/test/test-07-01.cpp

@@ -0,0 +1,44 @@
+#include "gtest/gtest.h"
+#include "quadratic-equation.hpp"
+
+using math::quadratic_equation_solution;
+
+TEST(QuadraticEquationSolutionTest, NoSolutions) {
+    auto result = quadratic_equation_solution(1.0, 0.0, 1.0);
+    ASSERT_TRUE(std::holds_alternative<std::monostate>(result));
+}
+
+TEST(QuadraticEquationSolutionTest, OneSolution) {
+    auto result = quadratic_equation_solution(1.0, -2.0, 1.0);  // NOLINT
+    ASSERT_TRUE(std::holds_alternative<double>(result));
+    const double solution = std::get<double>(result);
+    EXPECT_DOUBLE_EQ(solution, 1.0);
+}
+
+TEST(QuadraticEquationSolutionTest, OneSolution2) {
+    auto result = quadratic_equation_solution(1.0, -4.0, 4.0);  // NOLINT
+    ASSERT_TRUE(std::holds_alternative<double>(result));
+    const double solution = std::get<double>(result);
+    EXPECT_DOUBLE_EQ(solution, 2.0);
+}
+
+TEST(QuadraticEquationSolutionTest, TwoSolutionsDistinct) {
+    auto result = quadratic_equation_solution(1.0, -3.0, 2.0);  // NOLINT
+    ASSERT_TRUE((std::holds_alternative<std::pair<double, double>>(result)));
+    auto solutions = std::get<std::pair<double, double>>(result);
+
+    EXPECT_DOUBLE_EQ(solutions.first, 1.0);
+    EXPECT_DOUBLE_EQ(solutions.second, 2.0);
+}
+
+TEST(QuadraticEquationSolutionTest, LinearEquation) {
+    EXPECT_THROW(quadratic_equation_solution(0.0, 2.0, -4.0);, std::invalid_argument);  // NOLINT
+}
+
+TEST(QuadraticEquationSolutionTest, ZeroCoefficientCase) {
+    EXPECT_THROW(quadratic_equation_solution(0.0, 0.0, 1.0);, std::invalid_argument);
+}
+
+TEST(QuadraticEquationSolutionTest, AllZeroCoefficients) {
+    EXPECT_THROW(quadratic_equation_solution(0.0, 0.0, 0.0);, std::invalid_argument);
+}