Math object

CMakeLists.txt

@@ -1,4 +1,4 @@
-# указывайте последнюю доступную вам версию CMake
+# указывайте последнюю доступную вам версию CMake
 
 cmake_minimum_required(VERSION 3.14)
 set(CMAKE_CXX_STANDARD 14)
@@ -14,6 +14,24 @@ include(cmake/function.cmake)         # подхватываем функции,
 								      # и для создания исполняемого проекта в отдельные функции
 
 add_subdirectory(lib_easy_example)    # подключаем дополнительный CMakeLists.txt из подкаталога с именем lib_easy_example
+
+add_subdirectory(lib_vector)
+add_subdirectory(lib_math_vector)
+add_subdirectory(lib_matrix)
+add_subdirectory(lib_triangle_matrix)
+
+add_subdirectory(lib_point)
+add_subdirectory(lib_point3d)
+add_subdirectory(lib_circle)
+add_subdirectory(lib_sphere)
+
+add_subdirectory(lib_dsu)
+
+add_subdirectory(lib_algoritm)
+
+
+
+
 add_subdirectory(main)                # подключаем дополнительный CMakeLists.txt из подкаталога с именем main
 
 option(BTEST "build test?" ON)        # указываем подключаем ли google-тесты (ON или YES) или нет (OFF или NO)
@@ -23,6 +41,4 @@ if(BTEST)                             # если тесты подключены
     add_subdirectory("third_party/gtest" EXCLUDE_FROM_ALL)
     enable_testing()
     add_subdirectory(tests)
-endif()
-
-
+endif()

lib_algoritm/CMakeLists.txt

@@ -0,0 +1 @@
+create_project_lib(Algoritm)

lib_algoritm/algoritm.h

@@ -0,0 +1,55 @@
+#pragma once
+#include "../lib_matrix/matrix.h"
+#include <random>
+#include <utility> 
+template <class T>
+std::pair<size_t, size_t> find_min_neighbor_coords(const Matrix<T>& matrix, size_t x, size_t y) {
+    T min_val = matrix[x][y];
+    size_t min_x = x;
+    size_t min_y = y;
+    if (x > 0 && matrix[x - 1][y] < min_val) {
+        min_val = matrix[x - 1][y];
+        min_x = x - 1;
+        min_y = y;
+    }
+    if (x < matrix.getM() - 1 && matrix[x + 1][y] < min_val) {
+        min_val = matrix[x + 1][y];
+        min_x = x + 1;
+        min_y = y;
+    }
+    if (y > 0 && matrix[x][y - 1] < min_val) {
+        min_val = matrix[x][y - 1];
+        min_x = x;
+        min_y = y - 1;
+    }
+    if (y < matrix.getN() - 1 && matrix[x][y + 1] < min_val) {
+        min_val = matrix[x][y + 1];
+        min_x = x;
+        min_y = y + 1;
+    }
+    return { min_x, min_y };
+}
+size_t getRandomIndex(size_t max) {
+    std::random_device rd;
+    std::mt19937 gen(rd());
+    std::uniform_int_distribution<size_t> dist(0, max - 1);
+    return dist(gen);
+}
+template <class T>
+T find_local_minimum(const Matrix<T>& matrix) {
+    size_t x = getRandomIndex(matrix.getM());
+    size_t y = getRandomIndex(matrix.getN());
+
+    while (true) {
+        std::pair<size_t, size_t> min_coords = find_min_neighbor_coords(matrix, x, y);
+        size_t new_x = min_coords.first;
+        size_t new_y = min_coords.second;
+
+        if (new_x == x && new_y == y) {
+            return matrix[x][y];
+        }
+
+        x = new_x;
+        y = new_y;
+    }
+}

lib_circle/circle.h

@@ -0,0 +1,24 @@
+#pragma once
+#include "../lib_point/point.h"
+#include <cmath>
+class Circle : public Point {
+private:
+    int _radius;
+public:
+    Circle(int x, int y, int radius) : Point(x,y), _radius(radius) {}
+    Circle(Point coord_center, int radius)
+        : Point(coord_center.getX(), coord_center.getY()), _radius(radius) {}
+    Circle(const Circle& other) = default;
+    int getR() const {
+        return _radius;
+    }
+    void setR(int r) {
+        _radius = r;
+    }
+    bool operator == (const Circle& other) const {
+        return _x == other._x && _y == other._y && _radius == other._radius;
+    }
+    bool operator != (const Circle& other) const{
+        return !(*this == other);
+    }
+};

lib_math_vector/math_vector.cpp

@@ -0,0 +1 @@
+#include "math_vector.h"

lib_math_vector/math_vector.h

@@ -0,0 +1,193 @@
+#pragma once
+#include <stdexcept> 
+#include "../lib_vector/vector.h"
+template <class T>
+class MathVector:public Tvector<T> {
+protected:
+    size_t _start_index = 0;
+public:
+    MathVector();
+    MathVector(size_t size);
+    MathVector(size_t size, size_t start_index);
+    MathVector(T* data, size_t size);
+    MathVector(T* data, size_t size, size_t start_index);
+    MathVector(const MathVector<T>& other);
+    virtual ~MathVector();
+
+    size_t get_start_index() const { 
+        return _start_index; 
+    }
+    void set_start_index(size_t index) { 
+        _start_index = index; 
+    }
+
+    T& at(size_t index);
+    const T& at(size_t index) const;
+
+    MathVector<T> operator * (T value) const;
+    MathVector<T> operator / (T value) const;
+
+    MathVector<T>& operator *= (T value);
+    MathVector<T>& operator /= (T value);
+
+    MathVector<T> operator + (const MathVector<T>& vector) const;
+    MathVector<T> operator - (const MathVector<T>& vector) const;
+    T operator * (const MathVector<T>& vector) const;
+
+    MathVector<T>& operator += (const MathVector<T>& vector);
+    MathVector<T>& operator -= (const MathVector<T>& vector);
+    MathVector<T>& operator=(const MathVector<T>& other);
+    template<typename U>
+    friend std::ostream& operator<<(std::ostream&, const MathVector<U>& vector);
+
+    T& operator[](size_t index);
+    const T& operator[](size_t index) const;
+};
+template<class T>
+MathVector<T>::MathVector() : Tvector<T>() {}
+template <class T>
+MathVector<T>::MathVector(size_t size) : Tvector<T>(size) {}
+template <class T>
+MathVector<T>::MathVector(size_t size, size_t start_index) : Tvector<T>(size), _start_index(start_index) {}
+template <class T>
+MathVector<T>::MathVector(T* data, size_t size) : Tvector<T>(data, size) {} 
+template <class T>
+MathVector<T>::MathVector(T* data, size_t size, size_t start_index) : 
+    Tvector<T>(data, size), _start_index(start_index) {}
+template <class T>
+MathVector<T>::MathVector(const MathVector<T>& other) : 
+    Tvector<T>(other), _start_index(other._start_index) {}
+template <class T>
+MathVector<T>::~MathVector() = default;
+template <class T>
+MathVector<T> MathVector<T>::operator * (T value) const {
+    MathVector<T> result(this->get_size());
+    for (size_t i = 0; i < this->get_size(); ++i) {
+        result[i] = (*this)[i] * value;
+    }
+    return result;
+}
+template <class T>
+MathVector<T> MathVector<T>::operator / (T value) const {
+    if (value == 0) {
+        throw std::logic_error("Can't divide by zero!");
+    }
+    MathVector<T> result(this->get_size());
+    for (size_t i = 0; i < this->get_size(); ++i) {
+        result[i] = (*this)[i] / value;
+    }
+    return result;
+}
+template <class T>
+MathVector<T>& MathVector<T>::operator *= (T value) {
+    for (size_t i = 0; i < this->get_size(); ++i) {
+        (*this)[i] *= value;
+   }
+    return *this;
+}
+template <class T>
+MathVector<T>& MathVector<T>::operator /= (T value) {
+    if (value == 0) {
+        throw std::logic_error("Can't divide by zero!");
+    }
+    for (size_t i = 0; i < this->get_size(); ++i) {
+        (*this)[i] /= value;
+    }
+    return *this;
+}
+template<class T>
+MathVector<T> MathVector<T>::operator + (const MathVector<T>& vector) const {
+    if (this->get_size() != vector.get_size()) {
+        throw std::logic_error("Vectors must have the same dimension");
+    }
+    MathVector<T> result(this->get_size());
+    for (size_t i = 0; i < this->get_size(); ++i) {
+        result[i] = (*this)[i] + vector[i];
+    }
+    return result;
+}
+template<class T>
+MathVector<T> MathVector<T>::operator - (const MathVector<T>& vector) const {
+    if (this->get_size() != vector.get_size()) {
+        throw std::logic_error("Vectors must have the same dimension");
+    }
+    MathVector<T> result(this->get_size());
+    for (size_t i = 0; i < this->get_size(); ++i) {
+        result[i] = (*this)[i] - vector[i];
+    }
+    return result;
+}
+template<class T>
+T MathVector<T>::operator * (const MathVector<T>& vector) const {
+    if (this->get_size() != vector.get_size()) {
+        throw std::logic_error("Vectors must have the same dimension");
+    }
+    T result{};
+    for (size_t i = 0; i < this->get_size(); ++i) {
+        result += (*this)[i] * vector[i];
+    }
+    return result;
+}
+template<class T>
+MathVector<T>& MathVector<T>::operator += (const MathVector<T>& vector)  {
+    if (this->get_size() != vector.get_size()) {
+        throw std::logic_error("Vectors must have the same dimension");
+    }
+    for (size_t i = 0; i < this->get_size(); ++i) { 
+        (*this)[i] += vector[i];
+    }
+    return *this;
+}
+template<class T>
+MathVector<T>& MathVector<T>::operator -= (const MathVector<T>& vector) {
+    if (this->get_size() != vector.get_size()) {
+        throw std::logic_error("Vectors must have the same dimension");
+    }
+    for (size_t i = 0; i < this->get_size(); ++i) {
+        (*this)[i] -= vector[i];
+    }
+    return *this;
+}
+template <class T>
+MathVector<T>& MathVector<T>::operator=(const MathVector<T>& other) {
+    if (this != &other) {
+        Tvector<T>::operator=(other);
+        _start_index = other._start_index;
+    }
+    return *this;
+}
+template <class T>
+T& MathVector<T>::operator[](size_t index) {
+    return this->Tvector<T>::operator[](index - _start_index);
+}
+template <class T>
+const T& MathVector<T>::operator[](size_t index) const {
+    return this->Tvector<T>::operator[](index - _start_index);
+}
+template <class T>
+T& MathVector<T>::at(size_t index) {
+    if (index < _start_index || index >= _start_index + this->get_size()) {
+        throw std::logic_error("MathVector index out of range");
+    }
+    return this->Tvector<T>::operator[](index - _start_index);
+}
+template <class T>
+const T& MathVector<T>::at(size_t index) const {
+    if (index < _start_index || index >= _start_index + this->get_size()) {
+        throw std::logic_error("MathVector index out of range");
+    }
+    return this->Tvector<T>::operator[](index - _start_index);
+}
+
+template <class U>
+std::ostream& operator<<(std::ostream& out, const MathVector<U>& vector) {
+    out << "[";
+    for (size_t i = 0; i < vector.get_size(); ++i) {
+        out << vector[i];
+        if (i < vector.get_size() - 1) {
+            out << ", ";
+        }
+    }
+    out << "]";
+    return out;
+}

lib_matrix/CMakeLists.txt

@@ -0,0 +1 @@
+create_project_lib(Matrix)