Белов Егор Алексеевич. 3823Б1ПР2. ST-2. Ветка b55

.gitignore

@@ -0,0 +1,19 @@
+/build*
+docs/build*
+/xml
+docs/xml
+out
+mpich
+cmake-build-*
+.idea/
+.vs/
+.vscode/
+scripts/variants*.csv
+scripts/variants*.xlsx
+*venv*
+sln/
+CMakeSettings.json
+.DS_Store
+.cache
+install
+*.pyc

include/circle.h

@@ -1,7 +1,33 @@
 // Copyright 2022 UNN-CS
 #ifndef INCLUDE_CIRCLE_H_
 #define INCLUDE_CIRCLE_H_
-#include <cstdint>
 
+#include <cmath>
+#include <stdexcept>
+
+class Circle {
+ private:
+  double radius;
+  double ference;
+  double area;
+
+  static constexpr double PI = 3.1415;
+
+ public:
+  explicit Circle(double r);
+
+  void setRadius(double r);
+  void setFerence(double f);
+  void setArea(double a);
+
+  double getRadius() const;
+  double getFerence() const;
+  double getArea() const;
+
+ private:
+  void updateFromRadius();
+  void updateFromFerence();
+  void updateFromArea();
+};
 
 #endif  // INCLUDE_CIRCLE_H_

include/tasks.h

@@ -0,0 +1,10 @@
+// Copyright 2025 UNN-CS
+#ifndef INCLUDE_TASKS_H_
+#define INCLUDE_TASKS_H_
+
+#include "circle.h"
+
+double earthEndRope();
+double calculateMaterialPrice();
+
+#endif  // INCLUDE_TASKS_H_

src/CMakeLists.txt

@@ -1,6 +1,6 @@
 set(header_path "${${PROJECT_NAME}_SOURCE_DIR}/include")
-set(header ${header_path}/circle.h)
-set(src circle.cpp)
+set(header ${header_path}/circle.h ${header_path}/tasks.h)
+set(src circle.cpp tasks.cpp)
 
 add_library(${PROJECT_NAME} SHARED
   ${header}

src/circle.cpp

@@ -1,4 +1,63 @@
 // Copyright 2022 UNN-CS
 #include <cstdint>
+#include <cmath>
+#include <stdexcept>
 #include "circle.h"
 
+Circle::Circle(double r) {
+  setRadius(r);
+}
+
+void Circle::setRadius(double r) {
+  if (r < 0) {
+    throw std::invalid_argument(
+        "Радиус не может быть отрицательным");
+  }
+  radius = r;
+  updateFromRadius();
+}
+
+void Circle::setFerence(double f) {
+  if (f < 0) {
+    throw std::invalid_argument(
+        "Длина окружности не может быть отрицательной");
+  }
+  ference = f;
+  updateFromFerence();
+}
+
+void Circle::setArea(double a) {
+  if (a < 0) {
+    throw std::invalid_argument(
+        "Площадь не может быть отрицательной");
+  }
+  area = a;
+  updateFromArea();
+}
+
+double Circle::getRadius() const {
+  return radius;
+}
+
+double Circle::getFerence() const {
+  return ference;
+}
+
+double Circle::getArea() const {
+  return area;
+}
+
+void Circle::updateFromRadius() {
+  ference = 2 * PI * radius;
+  area = PI * radius * radius;
+}
+
+void Circle::updateFromFerence() {
+  radius = ference / (2 * PI);
+  area = PI * radius * radius;
+}
+
+void Circle::updateFromArea() {
+  radius = std::sqrt(area / PI);
+  ference = 2 * PI * radius;
+}

src/tasks.cpp

@@ -0,0 +1,27 @@
+// Copyright 2025 UNN-CS
+#include "tasks.h"
+
+double earthEndRope() {
+  constexpr double earth_rad = 6378.1 * 1000.0;
+  Circle new_earth(earth_rad);
+  new_earth.setFerence(new_earth.getFerence() + 1.0);
+
+  return new_earth.getRadius() - earth_rad;
+}
+
+double calculateMaterialPrice() {
+  constexpr double cement_price = 1000.0;
+  constexpr double fence_meter_price = 2000.0;
+  constexpr double pool_rad = 3.0;
+  constexpr double walkway_width = 1.0;
+
+  Circle pool(pool_rad);
+  Circle around_pool(pool_rad + walkway_width);
+  double fence_price = 0.0;
+  double cement_walkway_price = 0.0;
+
+  fence_price = pool.getFerence() * fence_meter_price;
+  cement_walkway_price = (around_pool.getArea() - pool.getArea())
+                         * cement_price;
+  return fence_price + cement_walkway_price;
+}

test/tests.cpp

@@ -1,7 +1,225 @@
 // Copyright 2025 UNN-CS Team
-
 #include <gtest/gtest.h>
 #include <cstdint>
+#include <cmath>
 #include "circle.h"
+#include "tasks.h"
+
+TEST(CircleTest, ConstructorAndGetters) {
+  Circle circle(5.0);
+
+  EXPECT_DOUBLE_EQ(5.0, circle.getRadius());
+  EXPECT_NEAR(2 * 3.1415 * 5.0, circle.getFerence(), 1e-10);
+  EXPECT_NEAR(3.1415 * 25.0, circle.getArea(), 1e-10);
+}
+
+TEST(CircleTest, NegativeRadiusInConstructor) {
+  EXPECT_THROW({
+    Circle circle(-5.0);
+  }, std::invalid_argument);
+}
+
+TEST(CircleTest, ZeroRadius) {
+  Circle circle(0.0);
+
+  EXPECT_DOUBLE_EQ(0.0, circle.getRadius());
+  EXPECT_DOUBLE_EQ(0.0, circle.getFerence());
+  EXPECT_DOUBLE_EQ(0.0, circle.getArea());
+}
+
+TEST(CircleTest, SetRadius) {
+  Circle circle(1.0);
+  circle.setRadius(3.0);
+
+  EXPECT_DOUBLE_EQ(3.0, circle.getRadius());
+  EXPECT_NEAR(2 * 3.1415 * 3.0, circle.getFerence(), 1e-10);
+  EXPECT_NEAR(3.1415 * 9.0, circle.getArea(), 1e-10);
+}
+
+TEST(CircleTest, SetZeroRadius) {
+  Circle circle(1.0);
+
+  EXPECT_NO_THROW(circle.setRadius(0.0););
+
+  EXPECT_DOUBLE_EQ(0.0, circle.getRadius());
+  EXPECT_DOUBLE_EQ(0.0, circle.getFerence());
+  EXPECT_DOUBLE_EQ(0.0, circle.getArea());
+}
+
+TEST(CircleTest, SetNegativeRadius) {
+  Circle circle(1.0);
+
+  EXPECT_THROW({
+    circle.setRadius(-2.0);
+  }, std::invalid_argument);
+
+  EXPECT_DOUBLE_EQ(1.0, circle.getRadius());
+  EXPECT_NEAR(2 * 3.1415, circle.getFerence(), 1e-10);
+  EXPECT_NEAR(3.1415, circle.getArea(), 1e-10);
+}
+
+TEST(CircleTest, SetFerence) {
+  Circle circle(1.0);
+  double newFerence = 10.0;
+  circle.setFerence(newFerence);
+
+  double expectedRadius = newFerence / (2 * 3.1415);
+  double expectedArea = 3.1415 * expectedRadius * expectedRadius;
+
+  EXPECT_NEAR(expectedRadius, circle.getRadius(), 1e-10);
+  EXPECT_DOUBLE_EQ(newFerence, circle.getFerence());
+  EXPECT_NEAR(expectedArea, circle.getArea(), 1e-10);
+}
+
+TEST(CircleTest, SetNegativeFerence) {
+  Circle circle(1.0);
+  double oldFerence = circle.getFerence();
+  double oldRadius = circle.getRadius();
+  double oldArea = circle.getArea();
+
+  EXPECT_THROW({
+    circle.setFerence(-5.0);
+  }, std::invalid_argument);
+
+  EXPECT_DOUBLE_EQ(oldRadius, circle.getRadius());
+  EXPECT_DOUBLE_EQ(oldFerence, circle.getFerence());
+  EXPECT_DOUBLE_EQ(oldArea, circle.getArea());
+}
+
+TEST(CircleTest, SetZeroFerence) {
+  Circle circle(1.0);
+  circle.setFerence(0.0);
+
+  EXPECT_DOUBLE_EQ(0.0, circle.getRadius());
+  EXPECT_DOUBLE_EQ(0.0, circle.getFerence());
+  EXPECT_DOUBLE_EQ(0.0, circle.getArea());
+}
+
+TEST(CircleTest, SetArea) {
+  Circle circle(1.0);
+  double newArea = 50.0;
+  circle.setArea(newArea);
+
+  double expectedRadius = std::sqrt(newArea / 3.1415);
+  double expectedFerence = 2 * 3.1415 * expectedRadius;
+
+  EXPECT_NEAR(expectedRadius, circle.getRadius(), 1e-10);
+  EXPECT_NEAR(expectedFerence, circle.getFerence(), 1e-10);
+  EXPECT_NEAR(newArea, circle.getArea(), 1e-10);
+}
+
+TEST(CircleTest, SetNegativeArea) {
+  Circle circle(1.0);
+  double oldArea = circle.getArea();
+  double oldRadius = circle.getRadius();
+  double oldFerence = circle.getFerence();
+
+  EXPECT_THROW({
+    circle.setArea(-10.0);
+  }, std::invalid_argument);
+
+  EXPECT_DOUBLE_EQ(oldRadius, circle.getRadius());
+  EXPECT_DOUBLE_EQ(oldFerence, circle.getFerence());
+  EXPECT_DOUBLE_EQ(oldArea, circle.getArea());
+}
+
+TEST(CircleTest, SetZeroArea) {
+  Circle circle(1.0);
+  circle.setArea(0.0);
+
+  EXPECT_DOUBLE_EQ(0.0, circle.getRadius());
+  EXPECT_DOUBLE_EQ(0.0, circle.getFerence());
+  EXPECT_DOUBLE_EQ(0.0, circle.getArea());
+}
+
+TEST(CircleTest, SequentialChanges) {
+  Circle circle(2.0);
+
+  circle.setRadius(3.0);
+  EXPECT_NEAR(3.0, circle.getRadius(), 1e-10);
+  EXPECT_NEAR(2 * 3.1415 * 3.0, circle.getFerence(), 1e-10);
+  EXPECT_NEAR(3.1415 * 9.0, circle.getArea(), 1e-10);
+
+  circle.setFerence(20.0);
+  double r = 20.0 / (2 * 3.1415);
+  EXPECT_NEAR(r, circle.getRadius(), 1e-10);
+  EXPECT_NEAR(20.0, circle.getFerence(), 1e-10);
+  EXPECT_NEAR(3.1415 * r * r, circle.getArea(), 1e-10);
+
+  circle.setArea(100.0);
+  r = std::sqrt(100.0 / 3.1415);
+  EXPECT_NEAR(r, circle.getRadius(), 1e-10);
+  EXPECT_NEAR(2 * 3.1415 * r, circle.getFerence(), 1e-10);
+  EXPECT_NEAR(100.0, circle.getArea(), 1e-10);
+}
+
+TEST(CircleTest, FerenceGettingFormula) {
+  Circle circle(4.0);
+
+  EXPECT_NEAR(2 * 3.1415 * circle.getRadius(), circle.getFerence(), 1e-10);
+}
+
+TEST(CircleTest, SquareGettingFormula) {
+  Circle circle(4.0);
+
+  EXPECT_NEAR(3.1415 * circle.getRadius() * circle.getRadius(),
+              circle.getArea(), 1e-10);
+}
+
+TEST(CircleTest, RadiusGettingFormulas) {
+  Circle circle(4.0);
+
+  EXPECT_NEAR(circle.getFerence() / (2 * 3.1415), circle.getRadius(), 1e-10);
+
+  EXPECT_NEAR(std::sqrt(circle.getArea() / 3.1415), circle.getRadius(), 1e-10);
+}
+
+TEST(CircleTest, MathematicalProperties) {
+  Circle circle(3.0);
+
+  EXPECT_NEAR(circle.getFerence() / circle.getRadius(), 2 * 3.1415, 1e-10);
+
+  EXPECT_NEAR(circle.getArea() / (circle.getRadius() * circle.getRadius()),
+              3.1415, 1e-10);
+
+  EXPECT_NEAR(circle.getFerence() * circle.getFerence(),
+              4 * 3.1415 * circle.getArea(), 1e-8);
+}
+
+TEST(CircleTest, LargeNumbers) {
+  double largeRadius = 1e6;
+  Circle circle(largeRadius);
+
+  EXPECT_NEAR(largeRadius, circle.getRadius(), 1e-6);
+  EXPECT_NEAR(2 * 3.1415 * largeRadius, circle.getFerence(), 1e-6);
+  EXPECT_NEAR(3.1415 * largeRadius * largeRadius, circle.getArea(), 1e-6);
+}
+
+TEST(CircleTest, VerySmallNumbers) {
+  double smallRadius = 1e-6;
+  Circle circle(smallRadius);
+
+  EXPECT_NEAR(smallRadius, circle.getRadius(), 1e-12);
+  EXPECT_NEAR(2 * 3.1415 * smallRadius, circle.getFerence(), 1e-12);
+  EXPECT_NEAR(3.1415 * smallRadius * smallRadius, circle.getArea(), 1e-12);
+}
+
+TEST(EarthTaskTest, CorrectCalcTask) {
+  EXPECT_NEAR(earthEndRope(), 0.15916, 1e-5);
+}
+
+TEST(PoolTaskTest, CorrectCalcTask) {
+  EXPECT_NEAR(calculateMaterialPrice(), 59600, 100.0);
+}
+
+TEST(CircleTest, PrecisionWithPI) {
+  Circle circle(1.0);
+
+  EXPECT_NEAR(2 * 3.1415, circle.getFerence(), 1e-10);
 
+  circle.setFerence(6.283);
+  EXPECT_NEAR(1.0, circle.getRadius(), 0.001);
 
+  circle.setRadius(2.0);
+  EXPECT_NEAR(4 * 3.1415, circle.getArea(), 1e-10);
+}