diff --git a/CMakeLists.txt b/CMakeLists.txt index 2ed05fc1..4c972104 100644 --- a/CMakeLists.txt +++ b/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() \ No newline at end of file diff --git a/lib_algoritm/CMakeLists.txt b/lib_algoritm/CMakeLists.txt new file mode 100644 index 00000000..b0cc27ac --- /dev/null +++ b/lib_algoritm/CMakeLists.txt @@ -0,0 +1 @@ +create_project_lib(Algoritm) \ No newline at end of file diff --git a/lib_algoritm/algoritm.h b/lib_algoritm/algoritm.h new file mode 100644 index 00000000..8f69bcb9 --- /dev/null +++ b/lib_algoritm/algoritm.h @@ -0,0 +1,55 @@ +#pragma once +#include "../lib_matrix/matrix.h" +#include +#include +template +std::pair find_min_neighbor_coords(const Matrix& 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 dist(0, max - 1); + return dist(gen); +} +template +T find_local_minimum(const Matrix& matrix) { + size_t x = getRandomIndex(matrix.getM()); + size_t y = getRandomIndex(matrix.getN()); + + while (true) { + std::pair 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; + } +} diff --git a/lib_circle/circle.h b/lib_circle/circle.h new file mode 100644 index 00000000..fcc110d2 --- /dev/null +++ b/lib_circle/circle.h @@ -0,0 +1,24 @@ +#pragma once +#include "../lib_point/point.h" +#include +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); + } +}; diff --git a/lib_math_vector/math_vector.cpp b/lib_math_vector/math_vector.cpp new file mode 100644 index 00000000..9e86fff9 --- /dev/null +++ b/lib_math_vector/math_vector.cpp @@ -0,0 +1 @@ +#include "math_vector.h" diff --git a/lib_math_vector/math_vector.h b/lib_math_vector/math_vector.h new file mode 100644 index 00000000..c7e80dea --- /dev/null +++ b/lib_math_vector/math_vector.h @@ -0,0 +1,193 @@ +#pragma once +#include +#include "../lib_vector/vector.h" +template +class MathVector:public Tvector { +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& 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 operator * (T value) const; + MathVector operator / (T value) const; + + MathVector& operator *= (T value); + MathVector& operator /= (T value); + + MathVector operator + (const MathVector& vector) const; + MathVector operator - (const MathVector& vector) const; + T operator * (const MathVector& vector) const; + + MathVector& operator += (const MathVector& vector); + MathVector& operator -= (const MathVector& vector); + MathVector& operator=(const MathVector& other); + template + friend std::ostream& operator<<(std::ostream&, const MathVector& vector); + + T& operator[](size_t index); + const T& operator[](size_t index) const; +}; +template +MathVector::MathVector() : Tvector() {} +template +MathVector::MathVector(size_t size) : Tvector(size) {} +template +MathVector::MathVector(size_t size, size_t start_index) : Tvector(size), _start_index(start_index) {} +template +MathVector::MathVector(T* data, size_t size) : Tvector(data, size) {} +template +MathVector::MathVector(T* data, size_t size, size_t start_index) : + Tvector(data, size), _start_index(start_index) {} +template +MathVector::MathVector(const MathVector& other) : + Tvector(other), _start_index(other._start_index) {} +template +MathVector::~MathVector() = default; +template +MathVector MathVector::operator * (T value) const { + MathVector result(this->get_size()); + for (size_t i = 0; i < this->get_size(); ++i) { + result[i] = (*this)[i] * value; + } + return result; +} +template +MathVector MathVector::operator / (T value) const { + if (value == 0) { + throw std::logic_error("Can't divide by zero!"); + } + MathVector result(this->get_size()); + for (size_t i = 0; i < this->get_size(); ++i) { + result[i] = (*this)[i] / value; + } + return result; +} +template +MathVector& MathVector::operator *= (T value) { + for (size_t i = 0; i < this->get_size(); ++i) { + (*this)[i] *= value; + } + return *this; +} +template +MathVector& MathVector::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 +MathVector MathVector::operator + (const MathVector& vector) const { + if (this->get_size() != vector.get_size()) { + throw std::logic_error("Vectors must have the same dimension"); + } + MathVector result(this->get_size()); + for (size_t i = 0; i < this->get_size(); ++i) { + result[i] = (*this)[i] + vector[i]; + } + return result; +} +template +MathVector MathVector::operator - (const MathVector& vector) const { + if (this->get_size() != vector.get_size()) { + throw std::logic_error("Vectors must have the same dimension"); + } + MathVector result(this->get_size()); + for (size_t i = 0; i < this->get_size(); ++i) { + result[i] = (*this)[i] - vector[i]; + } + return result; +} +template +T MathVector::operator * (const MathVector& 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 +MathVector& MathVector::operator += (const MathVector& 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 +MathVector& MathVector::operator -= (const MathVector& 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 +MathVector& MathVector::operator=(const MathVector& other) { + if (this != &other) { + Tvector::operator=(other); + _start_index = other._start_index; + } + return *this; +} +template +T& MathVector::operator[](size_t index) { + return this->Tvector::operator[](index - _start_index); +} +template +const T& MathVector::operator[](size_t index) const { + return this->Tvector::operator[](index - _start_index); +} +template +T& MathVector::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::operator[](index - _start_index); +} +template +const T& MathVector::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::operator[](index - _start_index); +} + +template +std::ostream& operator<<(std::ostream& out, const MathVector& 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; +} diff --git a/lib_matrix/CMakeLists.txt b/lib_matrix/CMakeLists.txt new file mode 100644 index 00000000..91c1bacc --- /dev/null +++ b/lib_matrix/CMakeLists.txt @@ -0,0 +1 @@ +create_project_lib(Matrix) \ No newline at end of file diff --git a/lib_matrix/matrix.h b/lib_matrix/matrix.h new file mode 100644 index 00000000..60f865ff --- /dev/null +++ b/lib_matrix/matrix.h @@ -0,0 +1,189 @@ +#pragma once +#include +#include "../lib_math_vector/math_vector.h" +template class TriangleMatrix; + +template +class Matrix : public MathVector> { +protected: + size_t _M; + size_t _N; + Matrix transpose() const { + Matrix result(_N, _M); + for (size_t i = 0; i < _M; ++i) { + for (size_t j = 0; j < _N; ++j) { + result[j][i] = (*this)[i][j]; + } + } + return result; + } +public: + Matrix(); + Matrix(size_t M, size_t N); + Matrix(T* data, size_t M, size_t N); + Matrix(const Matrix& other); + virtual ~Matrix(); + size_t getM() const noexcept; + size_t getN() const noexcept; + + Matrix operator * (T value) const; + Matrix operator / (T value) const; + + Matrix& operator *= (T value); + Matrix& operator /= (T value); + + Matrix operator + (const Matrix& other_matrix) const; + Matrix operator - (const Matrix& other_matrix) const; + Matrix operator * (const Matrix& other_matrix) const; + + MathVector operator * (const MathVector& vector) const; + + Matrix& operator += (const Matrix& other_matrix); + Matrix& operator -= (const Matrix& other_matrix); + template + friend std::ostream& operator<<(std::ostream&, const Matrix& matrix); + + Matrix& operator=(const Matrix& other); +}; +template +size_t Matrix::getM() const noexcept { + return _M; +} +template +size_t Matrix::getN() const noexcept { + return _N; +} +template +Matrix::Matrix() : MathVector>(), _M(0), _N(0) {} +template +Matrix::Matrix(size_t M, size_t N) : MathVector>(M) { + _M = M; + _N = N; + for (size_t i = 0; i < _M; ++i) { + (*this)[i] = MathVector(_N); + } +} +template +Matrix::Matrix(T* data, size_t M, size_t N) : MathVector>(M) { + _M = M; + _N = N; + for (size_t i = 0; i < _M; ++i) { + (*this)[i] = MathVector(data + i * _N, _N); + } +} +template +Matrix::Matrix(const Matrix& other) : + MathVector>(other), _M(other._M), _N(other._N) {} +template +Matrix::~Matrix() = default; +template +Matrix Matrix::operator * (T value) const { + return Matrix(*this) *= value; +} +template +Matrix Matrix::operator / (T value) const { + if (value == 0) { + throw std::logic_error("Division by zero!"); + } + return Matrix(*this) /= value; +} +template +Matrix& Matrix::operator *= (T value) { + template + Matrix& Matrix::operator *= (T value) { + for (size_t i = 0; i < _M; ++i) { + (*this)[i] *= value; + } + return *this; + } +} +template +Matrix& Matrix::operator /= (T value) { + if (value == 0) { + throw std::logic_error("Division by zero!"); + } + for (size_t i = 0; i < _M; ++i) { + (*this)[i] /= value; + } + return *this; +} +template +Matrix Matrix::operator + (const Matrix& other_matrix) const { + if (_M != other_matrix.getM() || _N != other_matrix.getN()) { + throw std::logic_error("The matrices have different sizes!"); + } + return Matrix(*this) += other_matrix; +} +template +Matrix Matrix::operator - (const Matrix& other_matrix) const { + if (_M != other_matrix.getM() || _N != other_matrix.getN()) { + throw std::logic_error("The matrices have different sizes!"); + } + return Matrix(*this) -= other_matrix; +} +template +Matrix Matrix::operator * (const Matrix& other_matrix) const { + if (_N != other_matrix.getM()) { + throw std::logic_error + ("The sizes of the matrices are not compatible for this operation!"); + } + Matrix result (_M, other_matrix.getN()); + Matrix matrix_t = other_matrix.transpose(); + for (size_t i = 0; i < _M; ++i) { + for (size_t j = 0; j < matrix_t.getM(); ++j) { + result[i][j] = (*this)[i] * matrix_t[j]; + } + } + return result; +} +template +MathVector Matrix::operator * (const MathVector& vector) const { + if (_N != vector.get_size()) { + throw std::logic_error + ("Size of matrix aren't compatible with vector's size for this operation!"); + } + MathVector result(_M); + for (size_t i = 0; i < _M; ++i) { + result[i] = (*this)[i] * vector; + } + return result; +} +template +Matrix& Matrix::operator += (const Matrix& other_matrix) { + if (_M != other_matrix.getM() || _N != other_matrix.getN()) { + throw std::logic_error("The matrices have different sizes!"); + } + for (size_t i = 0; i < _M; ++i) { + (*this)[i] += other_matrix[i]; + } + return *this; +} +template +Matrix& Matrix::operator -= (const Matrix& other_matrix) { + if (_M != other_matrix.getM() || _N != other_matrix.getN()) { + throw std::logic_error("The matrices have different sizes!"); + } + for (size_t i = 0; i < _M; ++i) { + (*this)[i] -= other_matrix[i]; + } + return *this; +} +template +Matrix& Matrix::operator=(const Matrix& other) { + if (this != &other) { + MathVector>::operator=(other); + _M = other._M; + _N = other._N; + } + return *this; +} +template +std::ostream& operator<<(std::ostream& out, const Matrix& matrix) { + for (size_t i = 0; i < matrix.getM(); ++i) { + for (size_t j = 0; j < matrix.getN(); ++j) { + out << matrix[i][j] << "\t"; + } + out << std::endl; + } + return out; +} diff --git a/lib_point/CMakeLists.txt b/lib_point/CMakeLists.txt new file mode 100644 index 00000000..baf8c535 --- /dev/null +++ b/lib_point/CMakeLists.txt @@ -0,0 +1 @@ +create_project_lib(Point) \ No newline at end of file diff --git a/lib_point/point.cpp b/lib_point/point.cpp new file mode 100644 index 00000000..9c3ee02e --- /dev/null +++ b/lib_point/point.cpp @@ -0,0 +1,8 @@ +//#include "point.h" +//#include +//int Point::getDistanceTo(const Point& other) const { +// return static_cast(std::round(std::sqrt( +// std::pow(other.getX() - _x, 2) +// + std::pow(other.getY() - _y, 2 +// )))); +//} diff --git a/lib_point/point.h b/lib_point/point.h new file mode 100644 index 00000000..9fd51c17 --- /dev/null +++ b/lib_point/point.h @@ -0,0 +1,34 @@ +#pragma once +class Point { +protected: + int _x; + int _y; +public: + Point() : _x(0), _y(0) {} + Point(int x, int y) : _x(x), _y(y) {} + Point(const Point& other) = default; + int getX() const { + return _x; + } + int getY() const { + return _y; + } + void setX(int x) { + _x = x; + } + void setY(int y) { + _y = y; + } + void set(int x, int y) { + _x = x; + _y = y; + } + bool operator == (const Point& other) const { + return _x == other._x && _y == other._y; + } + bool operator !=(const Point& other) const { + return !(*this == other); + } + Point& operator=(const Point& other) = default; + int getDistanceTo(const Point& other) const; +}; diff --git a/lib_point3d/CMakeLists.txt b/lib_point3d/CMakeLists.txt new file mode 100644 index 00000000..d2b2f795 --- /dev/null +++ b/lib_point3d/CMakeLists.txt @@ -0,0 +1,2 @@ +create_project_lib(Point3D) +add_depend(Point3D Point lib_point) \ No newline at end of file diff --git a/lib_point3d/point3d.cpp b/lib_point3d/point3d.cpp new file mode 100644 index 00000000..5783e249 --- /dev/null +++ b/lib_point3d/point3d.cpp @@ -0,0 +1,10 @@ +//#include "point3d.h" +//#include +// +//int Point3D::getDistanceTo(const Point3D& other) const { +// return static_cast(std::round(std::sqrt( +// std::pow(other.getX() - _x, 2) + +// std::pow(other.getY() - _y, 2) + +// std::pow(other.getZ() - _z, 2) +// ))); +//} diff --git a/lib_point3d/point3d.h b/lib_point3d/point3d.h new file mode 100644 index 00000000..f572dc4d --- /dev/null +++ b/lib_point3d/point3d.h @@ -0,0 +1,23 @@ +#pragma once +#include "../lib_point/point.h" +class Point3D : public Point { +protected: + int _z; +public: + Point3D() : Point(0,0), _z(0) {} + Point3D(int x, int y, int z): Point(x,y), _z(z){} + Point3D(const Point3D& other) = default; + int getZ() const { + return _z; + } + void setZ(int z) { + _z = z; + } + bool operator == (const Point3D& other) const { + return _x == other._x && _y == other._y && _z == other._z; + } + bool operator != (const Point3D& other) const { + return !(*this == other); + } + int getDistanceTo(const Point3D& other) const; +}; diff --git a/lib_sphere/CMakeLists.txt b/lib_sphere/CMakeLists.txt new file mode 100644 index 00000000..a9f374ad --- /dev/null +++ b/lib_sphere/CMakeLists.txt @@ -0,0 +1,2 @@ +create_project_lib(Sphere) +add_depend(Sphere Point3D lib_point3d) \ No newline at end of file diff --git a/lib_sphere/sphere.cpp b/lib_sphere/sphere.cpp new file mode 100644 index 00000000..bfd06d2d --- /dev/null +++ b/lib_sphere/sphere.cpp @@ -0,0 +1 @@ +//#include "sphere.h" diff --git a/lib_sphere/sphere.h b/lib_sphere/sphere.h new file mode 100644 index 00000000..2f0757b5 --- /dev/null +++ b/lib_sphere/sphere.h @@ -0,0 +1,22 @@ +#pragma once +#include "../lib_point3d/point3d.h" +class Sphere : public Point3D { +private: + int _radius; +public: + Sphere(int x, int y, int z, int radius) : Point3D(x, y, z), _radius(radius) {} + Sphere(Point3D _coord_center, int radius) : Point3D(_coord_center), _radius(radius) {} + Sphere(const Sphere& other) = default; + int getR() const { + return _radius; + } + void setR(int radius) { + _radius = radius; + } + bool operator ==(const Sphere& other) const { + return _x == other._x && _y == other._y && _z == other._z && _radius == other._radius; + } + bool operator != (const Sphere& other) const { + return !(*this == other); + } +}; diff --git a/lib_triangle_matrix/CMakeLists.txt b/lib_triangle_matrix/CMakeLists.txt new file mode 100644 index 00000000..b96150bd --- /dev/null +++ b/lib_triangle_matrix/CMakeLists.txt @@ -0,0 +1 @@ +create_project_lib(TriangleMatrix) \ No newline at end of file diff --git a/lib_triangle_matrix/triangle_matrix.cpp b/lib_triangle_matrix/triangle_matrix.cpp new file mode 100644 index 00000000..96438ea1 --- /dev/null +++ b/lib_triangle_matrix/triangle_matrix.cpp @@ -0,0 +1 @@ +#include "triangle_matrix.h" diff --git a/lib_triangle_matrix/triangle_matrix.h b/lib_triangle_matrix/triangle_matrix.h new file mode 100644 index 00000000..c5cc277b --- /dev/null +++ b/lib_triangle_matrix/triangle_matrix.h @@ -0,0 +1,203 @@ +#pragma once +#include "../lib_matrix/matrix.h" +template +class TriangleMatrix : public Matrix { +public: + TriangleMatrix(); + TriangleMatrix(size_t size); + TriangleMatrix(T* data, size_t size); + TriangleMatrix(const TriangleMatrix& other); + ~TriangleMatrix(); + size_t getSize() const noexcept { + return this->_M; + } + TriangleMatrix operator * (T value) const; + TriangleMatrix operator / (T value) const; + + TriangleMatrix& operator *= (T value); + TriangleMatrix& operator /= (T value); + + MathVector operator * (const MathVector& vector) const; + + TriangleMatrix operator + (const TriangleMatrix& other) const; + TriangleMatrix operator - (const TriangleMatrix& other) const; + TriangleMatrix operator * (const TriangleMatrix& other) const; + + TriangleMatrix& operator += (const TriangleMatrix& other); + TriangleMatrix& operator -= (const TriangleMatrix& other); + TriangleMatrix& operator= (const TriangleMatrix& other); + + template + friend std::ostream& operator<<(std::ostream& out, const TriangleMatrix& matrix); +}; +template +TriangleMatrix::TriangleMatrix() : Matrix() {} +template +TriangleMatrix::TriangleMatrix(size_t size) : Matrix(size, size) { + for (size_t i = 0; i < size; ++i) { + (*this)[i] = MathVector(size - i, i); + } +} +template +TriangleMatrix::TriangleMatrix(T* data, size_t size) : Matrix(size, size) { + size_t data_index = 0; + for (size_t i = 0; i < size; ++i) { + (*this)[i] = MathVector(size - i, i); + for (size_t j = i; j < size; ++j) { + (*this)[i][j] = data[data_index++]; + } + } +} +template +TriangleMatrix::TriangleMatrix(const TriangleMatrix& other) : Matrix(other) {} +template +TriangleMatrix::~TriangleMatrix() = default; +template +TriangleMatrix& TriangleMatrix::operator= (const TriangleMatrix& other) { + if (this != &other) { + Matrix::operator=(other); + } + return *this; +} +template +TriangleMatrix TriangleMatrix::operator * (T value) const { + TriangleMatrix result(this->getSize()); + for (size_t i = 0; i < result.getSize(); ++i) { + for (size_t j = i; j < result.getSize(); ++j) { + result[i][j] = (*this)[i][j] * value; + } + } + return result; +} +template +TriangleMatrix TriangleMatrix::operator / (T value) const { + if (value == 0) { + throw std::logic_error("Division by zero!"); + } + TriangleMatrix result(this->getSize()); + for (size_t i = 0; i < result.getSize(); ++i) { + for (size_t j = i; j < result.getSize(); ++j) { + result[i][j] = (*this)[i][j] / value; + } + } + return result; +} + +template +TriangleMatrix& TriangleMatrix::operator *= (T value) { + for (size_t i = 0; i < this->getSize(); ++i) { + for (size_t j = i; j < this->getSize(); ++j) { + (*this)[i][j] *= value; + } + } + return *this; +} +template +TriangleMatrix& TriangleMatrix::operator /= (T value) { + if (value == 0) { + throw std::logic_error("Division by zero!"); + } + for (size_t i = 0; i < this->getSize(); ++i) { + for (size_t j = i; j < this->getSize(); ++j) { + (*this)[i][j] /= value; + } + } + return *this; +} +template +MathVector TriangleMatrix::operator * (const MathVector& vector) const { + if (this->getSize() != vector.get_size()) { + throw std::logic_error("Matrix columns must equal vector size"); + } + MathVector result(this->getSize()); + for (size_t i = 0; i < this->getSize(); ++i) { + T sum = T(); + for (size_t j = i; j < this->getSize(); ++j) { + sum += (*this)[i][j] * vector[j]; + } + result[i] = sum; + } + return result; +} +template +TriangleMatrix TriangleMatrix::operator + (const TriangleMatrix& other) const { + if (this->getSize() != other.getSize()) { + throw std::logic_error("Matrices must have the same size"); + } + TriangleMatrix result(this->getSize()); + for (size_t i = 0; i < this->getSize(); ++i) { + for (size_t j = i; j < this->getSize(); ++j){ + result[i][j] = (*this)[i][j] + other[i][j]; + } + } + return result; +} +template +TriangleMatrix TriangleMatrix::operator - (const TriangleMatrix& other) const { + if (this->getSize() != other.getSize()) { + throw std::logic_error("Matrices must have the same size"); + } + TriangleMatrix result(this->getSize()); + for (size_t i = 0; i < this->getSize(); ++i) { + for (size_t j = i; j < this->getSize(); ++j){ + result[i][j] = (*this)[i][j] - other[i][j]; + } + } + return result; +} +template +TriangleMatrix& TriangleMatrix::operator += (const TriangleMatrix& other) { + if (this->getSize() != other.getSize()) { + throw std::logic_error("Matrices must have the same size"); + } + for (size_t i = 0; i < this->getSize(); ++i) { + for (size_t j = i; j < this->getSize(); ++j) { + (*this)[i][j] += other[i][j]; + } + } + return *this; +} +template +TriangleMatrix& TriangleMatrix::operator -= (const TriangleMatrix& other) { + if (this->getSize() != other.getSize()) { + throw std::logic_error("Matrices must have the same size"); + } + for (size_t i = 0; i < this->getSize(); ++i) { + for (size_t j = i; j < this->getSize(); ++j) { + (*this)[i][j] -= other[i][j]; + } + } + return *this; +} +template +TriangleMatrix TriangleMatrix::operator * (const TriangleMatrix& other) const { + if (this->getSize() != other.getSize()) { + throw std::logic_error("Matrices must have the same size"); + } + TriangleMatrix result(this->getSize()); + for (size_t i = 0; i < this->getSize(); ++i) { + for (size_t j = i; j < this->getSize(); ++j) { + T sum = T(); + for (size_t k = i; k <= j; ++k) { + sum += (*this)[i][k] * other[k][j]; + } + result[i][j] = sum; + } + } + return result; +} +template +std::ostream& operator<<(std::ostream& out, const TriangleMatrix& matrix) { + for (size_t i = 0; i < matrix.getSize(); ++i) { + for (size_t j = 0; j < matrix.getSize(); ++j) { + if (i <= j) { + out << matrix[i][j] << "\t"; + } + else { + out << "0\t"; + } + } + out << std::endl; + } + return out; +} diff --git a/lib_vector/CMakeLists.txt b/lib_vector/CMakeLists.txt new file mode 100644 index 00000000..293ce152 --- /dev/null +++ b/lib_vector/CMakeLists.txt @@ -0,0 +1 @@ +create_project_lib(Vector) \ No newline at end of file diff --git a/lib_vector/vector.cpp b/lib_vector/vector.cpp new file mode 100644 index 00000000..863a6a8a --- /dev/null +++ b/lib_vector/vector.cpp @@ -0,0 +1 @@ +#include "vector.h" \ No newline at end of file diff --git a/lib_vector/vector.h b/lib_vector/vector.h new file mode 100644 index 00000000..64038b5b --- /dev/null +++ b/lib_vector/vector.h @@ -0,0 +1,694 @@ + // Copyright 2025 Zabytina Julia. All rights reserved. + #pragma once + #include + #include + #include + #include + #include + #include + #include + #include + #include + template + class Tvector { + public: + enum State { + empty, busy, deleted + }; + protected: + static constexpr size_t RESERVE_MEMORY = 15; + static constexpr size_t MAX_PERCENT_DELETED = 15; + + size_t _size; + size_t _capacity; + T* _data; + State* _states; + size_t _deleted; + size_t get_real_position(size_t busy_index) const noexcept; + void resize(size_t new_size); + void resize(size_t new_size, const T& value); + void shrink_to_fit(); + void reserve(size_t new_capacity); + void compact_storage(); + public: + Tvector() noexcept; + Tvector(size_t size); + Tvector(T* data, size_t size); + Tvector(const Tvector& other_vector); + virtual ~Tvector() noexcept; + + inline bool is_empty() const noexcept { + return _size == 0; + } + inline bool is_full() const noexcept { + return _size == _capacity; + } + inline const T* get_data() const noexcept { + return _data; + } + inline T* get_data() noexcept { + return _data; + } + inline const State* get_states() const noexcept { + return _states; + } + inline State* get_states() noexcept { + return _states; + } + inline T& front(); + inline T& back(); + inline const T& front() const; + inline const T& back() const; + size_t get_size() const noexcept { + return _size; + } + size_t get_deleted() const noexcept { + return _deleted; + } + size_t get_capacity() const noexcept { + return _capacity; + } + inline T* begin() const noexcept { + return _data; + } + inline T* end() const noexcept { + return _data + _size; + } + bool operator==(const Tvector& vector) const; + bool operator!=(const Tvector& vector) const; + Tvector& operator=(const Tvector& vector); + inline const T& operator[](size_t index) const; + inline T& operator[](size_t index); + T& at(size_t index); + const T& at(size_t index) const; + void assign(const Tvector& vector); + void clear(); + void emplace(size_t index, const T& value); + void push_front(const T& value); + void insert(const T& value, size_t position); + void push_back(const T& value); + void pop_back(); + void erase(size_t position); + void pop_front(); + + template + friend std::ostream& operator<<(std::ostream&, const Tvector& vector); + template friend void shell_sort(Tvector& object) noexcept; + template friend void shuffle(Tvector& object) noexcept; + template friend size_t find_first_element(const Tvector& object, const U& value); + template friend size_t find_last_element(const Tvector& object, const U& value); + template friend size_t find_count_of_all_suitable_elements(const Tvector& object, const U& value); + }; + + template + size_t Tvector::get_real_position(size_t busy_index) const noexcept { + size_t busy_count = 0; + for (size_t i = 0; i < _size; ++i) { + if (_states[i] == busy) { + if (busy_count == busy_index) { + return i; + } + ++busy_count; + } + } + return _size; + } + template + void Tvector::resize(size_t new_size) { + if (new_size == _size) { + return; + } + else if (new_size < _size) { + for (size_t i = new_size; i < _size; ++i) { + if (_states[i] == State::deleted) { + _deleted--; + } + _data[i].~T(); + _states[i] = State::empty; + } + _size = new_size; + } + else { + size_t new_capacity = new_size + RESERVE_MEMORY; + T* new_data = static_cast(::operator new(new_capacity * sizeof(T))); + State* new_states = new State[new_capacity]; + for (size_t i = new_size; i < new_capacity; ++i) { + new_states[i] = State::empty; + } + try { + for (size_t i = 0; i < _size; ++i) { + new (new_data + i) T(std::move(_data[i])); + new_states[i] = _states[i]; + } + for (size_t i = _size; i < new_size; ++i) { + new (new_data + i) T(); + new_states[i] = State::busy; + } + for (size_t i = 0; i < _size; ++i) { + _data[i].~T(); + } + ::operator delete(_data); + delete[] _states; + + _data = new_data; + _states = new_states; + _capacity = new_capacity; + _size = new_size; + } + catch (...) { + for (size_t i = 0; i < new_size; ++i) { + new_data[i].~T(); + } + ::operator delete(new_data); + delete[] new_states; + throw; + } + } + } + template + void Tvector::resize(size_t new_size, const T& value) { + if (new_size == _size) { + return; + } + else if (new_size < _size) { + for (size_t i = new_size; i < _size; ++i) { + if (_states[i] == State::deleted) { + _deleted--; + } + _data[i].~T(); + _states[i] = State::empty; + } + _size = new_size; + } + else { + size_t new_capacity = new_size + RESERVE_MEMORY; + T* new_data = static_cast(::operator new(new_capacity * sizeof(T))); + State* new_states = new State[new_capacity]; + for (size_t i = new_size; i < new_capacity; ++i) { + new_states[i] = State::empty; + } + try { + for (size_t i = 0; i < _size; ++i) { + new (new_data + i) T(std::move(_data[i])); + new_states[i] = _states[i]; + } + for (size_t i = _size; i < new_size; ++i) { + new (new_data + i) T(value); + new_states[i] = State::busy; + } + for (size_t i = 0; i < _size; ++i) { + _data[i].~T(); + } + ::operator delete(_data); + delete[] _states; + + _data = new_data; + _states = new_states; + _capacity = new_capacity; + _size = new_size; + } + catch (...) { + for (size_t i = 0; i < new_size; ++i) { + new_data[i].~T(); + } + ::operator delete(new_data); + delete[] new_states; + throw; + } + } + } + template + void Tvector::shrink_to_fit() { + if (_size >= _capacity) { + return; + } + else if (_size == 0) { + delete[] _data; + delete[] _states; + _data = nullptr; + _states = nullptr; + _capacity = 0; + _deleted = 0; + } + else { + T* new_data = new T[_size]; + State* new_states = new State[_size]; + for (size_t i = 0; i < _size; ++i) { + new_data[i] = std::move(_data[i]); + new_states[i] = _states[i]; + } + delete[] _data; + delete[] _states; + _data = new_data; + _states = new_states; + _capacity = _size; + } + } + template + void Tvector::reserve(size_t new_capacity) { + if (new_capacity <= _capacity) { + return; + } + T* new_data = new T[new_capacity]; + State* new_states = new State[new_capacity]; + std::fill_n(new_states, new_capacity, State::empty); + for (size_t i = 0; i < _size; ++i) { + new_data[i] = std::move(_data[i]); + new_states[i] = _states[i]; + } + delete[] _data; + delete[] _states; + _data = new_data; + _states = new_states; + _capacity = new_capacity; + } + template + void Tvector::compact_storage() { + size_t busy_count = 0; + for (size_t i = 0; i < _size; ++i) { + if (_states[i] == State::busy) { + busy_count++; + } + } + std::cout << "compact_storage(): busy_count = " << busy_count << "\n"; + size_t new_capacity = busy_count + RESERVE_MEMORY; + T* new_data = new T[new_capacity]; + State* new_states = new State[new_capacity]; + size_t new_index = 0; + for (size_t i = 0; i < _size; ++i) { + if (_states[i] == State::busy) { + new_data[new_index] = std::move(_data[i]); + new_states[new_index] = State::busy; + new_index++; + } + } + for (size_t i = 0; i < _size; ++i) { + if (_states[i] != State::empty) { + _data[i].~T(); + } + } + delete[] _data; + delete[] _states; + _data = new_data; + _states = new_states; + _capacity = new_capacity; + _size = busy_count; + _deleted = 0; + } + template + Tvector::Tvector() noexcept { + _size = 0; + _capacity = 0; + _data = nullptr; + _states = nullptr; + _deleted = 0; + } + template + Tvector::Tvector(size_t size) { + _size = size; + _capacity = size + RESERVE_MEMORY; + _data = new T[_capacity]; + + try { + _states = new State[_capacity]; + } + catch (const std::bad_alloc&) { + delete[] _data; + throw; + } + _deleted = 0; + + for (size_t i = 0; i < _capacity; ++i) { + _states[i] = i < _size ? State::busy : State::empty; + } + } + template + Tvector::Tvector(T* data, size_t size) { + if (size > 0 && data == nullptr) { + throw std::invalid_argument("Null data pointer with non-zero size"); + } + _size = size; + _capacity = _size + RESERVE_MEMORY; + _data = new T[_capacity]; + try { + _states = new State[_capacity]; + } + catch (const std::bad_alloc&) { + delete[] _data; + throw; + } + for (size_t i = 0; i < _capacity; ++i) { + if (i < _size) { + _data[i] = data[i]; + _states[i] = State::busy; + } + else { + _states[i] = State::empty; + } + } + _deleted = 0; + } + template + Tvector::Tvector(const Tvector& other_vector) { + _size = other_vector._size; + _capacity = other_vector._capacity; + _data = nullptr; + _states = nullptr; + try { + _data = new T[_capacity]; + } + catch (const std::bad_alloc&) { + throw; + } + try { + _states = new State[_capacity]; + } + catch (const std::bad_alloc&) { + delete[] _data; + throw; + } + _deleted = other_vector._deleted; + + for (size_t i = 0; i < other_vector._size; ++i) { + _data[i] = other_vector._data[i]; + _states[i] = other_vector._states[i]; + } + for (size_t i = other_vector._size; i < other_vector._capacity; ++i) { + _states[i] = State::empty; + } + } + template + Tvector::~Tvector() noexcept { + delete[] _data; + delete[] _states; + } + template + inline T& Tvector::front() { + if (_size == 0) { + throw std::out_of_range("Vector is empty"); + } + return _data[0]; + } + template + inline T& Tvector::back() { + if (_size == 0) { + throw std::out_of_range("Vector is empty"); + } + return _data[_size - 1]; + } + template + inline const T& Tvector::front() const { + if (_size == 0) { + throw std::out_of_range("Vector is empty"); + } + return _data[0]; + } + template + inline const T& Tvector::back() const { + if (_size == 0) { + throw std::out_of_range("Vector is empty"); + } + return _data[_size - 1]; + } + template + bool Tvector::operator==(const Tvector& vector) const { + if (this->_size != vector._size) + return false; + + for (size_t i = 0; i < _size; ++i) { + if ((*this)[i] != vector[i]) + return false; + } + return true; + } + template + bool Tvector::operator!=(const Tvector& vector) const { + return !(*this == vector); + } + template + Tvector& Tvector::operator=(const Tvector& vector) { + if (this == &vector) { + return *this; + } + T* new_data = new T[vector._capacity]; + State* new_states = new State[vector._capacity]; + for (size_t i = 0; i < vector._size; ++i) { + new_data[i] = vector._data[i]; + new_states[i] = vector._states[i]; + } + for (size_t i = vector._size; i < vector._capacity; ++i) { + new_states[i] = empty; + } + delete[] _data; + delete[] _states; + _data = new_data; + _states = new_states; + _capacity = vector._capacity; + _size = vector._size; + _deleted = vector._deleted; + + return *this; + } + template + inline const T& Tvector::operator[](size_t index) const { + size_t real_index = get_real_position(index); + return _data[real_index]; + } + template + inline T& Tvector::operator[](size_t index) { + size_t real_index = get_real_position(index); + return _data[real_index]; + } + template + T& Tvector::at(size_t index) { + if (index >= _size) { + throw std::out_of_range("Index out of range"); + } + if (_states[index] != busy) { + throw std::logic_error("Element at this index is not available (deleted or empty)"); + } + size_t real_index = get_real_position(index); + return _data[real_index]; + } + template + const T& Tvector::at(size_t index) const { + size_t real_index = get_real_position(index); + return const_cast(this)->at(real_index); + } + template + void Tvector::assign(const Tvector& vector) { + if (this == &vector) { + return; + } + for (size_t i = 0; i < _size; ++i) { + if (_states[i] == State::busy) { + _data[i].~T(); + } + } + delete[] _data; + delete[] _states; + _capacity = vector._capacity; + _size = vector._size; + _deleted = vector._deleted; + + _data = new T[_capacity]; + _states = new State[_capacity]; + for (size_t i = 0; i < _size; ++i) { + if (vector._states[i] == State::busy) { + new (&_data[i]) T(vector._data[i]); + } + _states[i] = vector._states[i]; + } + std::fill(_states + _size, _states + _capacity, State::empty); + } + template + void Tvector::clear() { + for (size_t i = 0; i < _size; ++i) { + if (_states[i] == State::busy) { + _states[i] = State::empty; + } + } + _size = 0; + _deleted = 0; + } + template + void Tvector::emplace(size_t index, const T& value) { + if (index >= _size) { + throw std::out_of_range("Index out of range"); + } + size_t real_index = get_real_position(index); + if (_states[real_index] == State::deleted) { + --_deleted; + } + _data[real_index] = value; + _states[real_index] = State::busy; + } + template + void Tvector::push_front(const T& value) { + if (_size >= _capacity) { + reserve(_capacity + RESERVE_MEMORY); + } + for (size_t i = _size; i > 0; --i) { + _data[i] = std::move(_data[i - 1]); + _states[i] = _states[i - 1]; + } + _data[0] = value; + _states[0] = State::busy; + _size++; + } + template + void Tvector::insert(const T& value, size_t position) { + if (_size == 0) { + resize(RESERVE_MEMORY); + } + if (position >= _size) { + throw std::out_of_range("Insert position out of range"); + } + size_t real_pos = get_real_position(position); + for (size_t i = _size; i > real_pos; --i) { + _data[i] = std::move(_data[i - 1]); + _states[i] = _states[i - 1]; + } + _data[real_pos] = value; + _states[real_pos] = State::busy; + _size++; + } + template + void Tvector::push_back(const T& value) { + if (_size >= _capacity) { + reserve(_capacity + RESERVE_MEMORY); + } + _data[_size] = value; + _states[_size] = State::busy; + _size++; + } + template + void Tvector::pop_back() { + if (_size == 0) { + throw std::out_of_range("Vector has size = 0"); + } + _states[_size - 1] = State::empty; + _size--; + } + template + void Tvector::erase(size_t position) { + if (position >= _size) { + throw std::out_of_range("Invalid position"); + } + size_t real_pos = get_real_position(position); + _states[real_pos] = State::deleted; + _deleted++; + if (_deleted * 100 > _size * MAX_PERCENT_DELETED) { + compact_storage(); + } + } + template + void Tvector::pop_front() { + if (_size == 0) { + throw std::out_of_range("Vector has size = 0"); + } + for (size_t i = 0; i < _size; ++i) { + if (_states[i] == State::busy) { + _states[i] = State::deleted; + _deleted++; + if (_deleted * 100 > _size * MAX_PERCENT_DELETED) { + compact_storage(); + } + return; + } + } + } + + template + std::ostream& operator<<(std::ostream& out, const Tvector& vector) { + out << "["; + bool first = true; + for (size_t i = 0; i < vector._size; ++i) { + if (vector._states[i] == Tvector::State::busy) { + if (!first) out << ", "; + out << vector._data[i]; + first = false; + } + } + out << "]"; + return out; + } + template + void shell_sort(Tvector& object) noexcept { + if (object._size < 2 || object._data == nullptr + || object._states == nullptr) { + return; + } + size_t h = 1; + while (h < object._size / 3) { + h = 3 * h + 1; + } + while (h >= 1) { + for (size_t i = h; i < object._size; ++i) { + for (size_t j = i; j >= h; j -= h) { + size_t previous = j - h; + if (object._data[j] < object._data[previous]) { + std::swap(object._data[j], object._data[previous]); + std::swap(object._states[j], object._states[previous]); + } + else { + break; + } + } + } + h /= 3; + } + } + template + void shuffle(Tvector& object) noexcept { + if (object._size < 2 || object._data == nullptr || object._states == nullptr) { + return; + } + std::random_device rd; + std::mt19937 gen(rd()); + for (size_t i = object._size - 1; i > 0; --i) { + std::uniform_int_distribution dist(0, i); + size_t j = dist(gen); + std::swap(object._data[i], object._data[j]); + std::swap(object._states[i], object._states[j]); + } + } + template + size_t find_first_element(const Tvector& object, const U& value) { + size_t result = 0; + for (size_t i = 0; i < object._size; i++) { + if (object._states[i] == object.State::deleted) { + continue; + } + else if (object._data[i] == value && object._states[i] == object.State::busy) { + return result + 1; + } + result++; + } + return 0; + } + template + size_t find_last_element(const Tvector& object, const U& value) { + size_t last_pos = 0; + size_t current_pos = 0; + for (size_t i = 0; i < object._size; i++) { + if (object._states[i] == object.State::deleted) { + continue; + } + current_pos++; + if (object._data[i] == value && object._states[i] == object.State::busy) { + last_pos = current_pos; + } + } + return last_pos; + } + template + size_t find_count_of_all_suitable_elements(const Tvector& object, const U& value) { + size_t count = 0; + for (size_t i = 0; i < object._size; ++i) { + if (object._data[i] == value && object._states[i] == object.State::busy) { + count++; + } + } + return count; + } diff --git a/main/main.cpp b/main/main.cpp index 217f8971..a5a282bd 100644 --- a/main/main.cpp +++ b/main/main.cpp @@ -1,8 +1,9 @@ -// Copyright 2024 Marina Usova +// Copyright 2024 Julia Zabytia +//#define EASY_EXAMPLE +//#define CIRCLES_AND_SPHERES -#define EASY_EXAMPLE +#define MATRIX #ifdef EASY_EXAMPLE - #include #include #include "../lib_easy_example/easy_example.h" @@ -34,4 +35,363 @@ int main() { return 0; } -#endif // EASY_EXAMPLE +#endif +#ifdef CIRCLES_AND_SPHERES +#include +#include +#include "../lib_sphere/sphere.h" +#include "../lib_circle/circle.h" +#include "../lib_point/point.h" +#include "../lib_point3d/point3d.h" +enum result_of_compare +{ + Equal, + Intersecting, + NotIntersecting, + FirstTouchSecond, + OneInsideOther, + OneInsideOtherTouching +}; +result_of_compare Compare(int d, int r1, int r2, int sum, int diff) { + if (d == 0 && r1 == r2) { + return Equal; + } + if (d > sum) { + return NotIntersecting; + } + if (d == sum) { + return FirstTouchSecond; + } + if (d > diff && d < sum) { + return Intersecting; + } + if (d == diff && d > 0) { + return OneInsideOtherTouching; + } + if (d < diff) { + return OneInsideOther; + } + return result_of_compare::NotIntersecting; +} +result_of_compare CompareCircles(const Circle& circle1, const Circle& circle2) { + int d = circle1.getDistanceTo(circle2); + int r1 = circle1.getR(); + int r2 = circle2.getR(); + int sum = r1 + r2; + int diff = std::abs(r1 - r2); + return Compare(d, r1, r2, sum, diff); +} +result_of_compare CompareSpheres(const Sphere& sphere1, const Sphere& sphere2) { + int d = sphere1.getDistanceTo(sphere2); + int r1 = sphere1.getR(); + int r2 = sphere2.getR(); + int sum = r1 + r2; + int diff = std::abs(r1 - r2); + return Compare(d, r1, r2, sum, diff); +} +int main() { + + Point center1(0, 0); + Circle circle1(center1, 5); + Point center2(6, 0); + Circle circle2(center2, 4); + result_of_compare circle_result = CompareCircles(circle1, circle2); + + switch (circle_result) { + case Equal: + std::cout << "Circles is equal\n"; + break; + case Intersecting: + std::cout << "Circles is intersecting\n"; + break; + case NotIntersecting: + std::cout << "Circles is not intersecting\n"; + break; + case FirstTouchSecond: + std::cout << "First circle touch second circle\n"; + break; + case OneInsideOther: + std::cout << "One circle inside other circle\n"; + break; + case OneInsideOtherTouching: + std::cout << "One circle inside other circle (with touching)\n"; + break; + default: + std::cout << "Unknown result\n"; + break; + } + return 0; +} +#endif +#ifdef MATRIX +#include +#include "../lib_math_vector/math_vector.h" +#include "../lib_matrix/matrix.h" +#include "../lib_triangle_matrix/triangle_matrix.h" + +void printMainMenu() { + std::cout << "==========================================\n"; + std::cout << "| CALCULATOR FOR VARIOUS MATRICES |\n"; + std::cout << "| (REGULAR AND TRIANGULAR) |\n"; + std::cout << "==========================================\n"; + std::cout << "\n"; + std::cout << "MAIN MENU =====\n"; + std::cout << " 1. Matrix addition\n"; + std::cout << " 2. Matrix subtraction\n"; + std::cout << " 3. Matrix multiplication\n"; + std::cout << " 4. Multiply matrix by scalar\n"; + std::cout << " 5. Division by scalar\n"; + std::cout << " 7. Multiply matrix by vector\n"; + std::cout << " 8. Exit\n"; +} + +template +void fillMatrix(Matrix& matrix) { + for (size_t i = 0; i < matrix.getM(); ++i) { + for (size_t j = 0; j < matrix.getN(); ++j) { + T value; + std::cout << "Element [" << i << "][" << j << "]: "; + std::cin >> value; + matrix[i][j] = value; + } + } +} + +template +void fillTriangleMatrix(TriangleMatrix& matrix) { + for (size_t i = 0; i < matrix.getSize(); ++i) { + for (size_t j = i; j < matrix.getSize(); ++j) { + T value; + std::cout << "Element [" << i << "][" << j << "]: "; + std::cin >> value; + matrix[i][j] = value; + } + } +} + +template +void fillVector(MathVector& vector) { + for (size_t i = 0; i < vector.get_size(); ++i) { + T value; + std::cout << "Element [" << i << "]: "; + std::cin >> value; + vector[i] = value; + } +} + +int main() { + setlocale(LC_ALL, "Russian"); + int user_choice; + + do { + printMainMenu(); + std::cout << "Your choice: "; + std::cin >> user_choice; + + if (user_choice == 9) { + break; + } + + int matrix_type; + std::cout << "Choose matrix type:\n"; + std::cout << "1. Regular matrix\n"; + std::cout << "2. Triangular matrix\n"; + std::cin >> matrix_type; + + if (matrix_type == 1) { + // Regular Matrix operations + size_t M, N; + std::cout << "Enter dimensions of matrix 1 (M - rows, N - columns)\n"; + std::cout << "M = "; + std::cin >> M; + std::cout << "N = "; + std::cin >> N; + + Matrix matrix1(M, N); + std::cout << "Enter elements of matrix 1:\n"; + fillMatrix(matrix1); + + switch (user_choice) { + case 1: { + std::cout << "Enter dimensions of matrix 2 (must be " << M << " x " << N << ")\n"; + Matrix matrix2(M, N); + std::cout << "Enter elements of matrix 2:\n"; + fillMatrix(matrix2); + Matrix result = matrix1 + matrix2; + std::cout << "Result:\n" << result; + break; + } + case 2: { + std::cout << "Enter dimensions of matrix 2 (must be " << M << " x " << N << ")\n"; + Matrix matrix2(M, N); + std::cout << "Enter elements of matrix 2:\n"; + fillMatrix(matrix2); + Matrix result = matrix1 - matrix2; + std::cout << "Result:\n" << result; + break; + } + case 3: { + size_t K; + std::cout << "Enter number of columns for matrix 2 (must be " << N << " rows)\n"; + std::cout << "K = "; + std::cin >> K; + Matrix matrix2(N, K); + std::cout << "Enter elements of matrix 2:\n"; + fillMatrix(matrix2); + Matrix result = matrix1 * matrix2; + std::cout << "Result:\n" << result; + break; + } + case 4: { + int scalar; + std::cout << "Enter scalar: "; + std::cin >> scalar; + Matrix result = matrix1 * scalar; + std::cout << "Result:\n" << result; + break; + } + case 5: { + int scalar; + std::cout << "Enter scalar: "; + std::cin >> scalar; + try { + Matrix result = matrix1 / scalar; + std::cout << "Result:\n" << result; + } + catch (const std::exception& e) { + std::cout << "Error: " << e.what() << std::endl; + } + break; + } + case 6: { + size_t size; + std::cout << "Enter vector size (must be " << N << "): "; + std::cin >> size; + if (size != N) { + std::cout << "Error: Vector size must match matrix columns!\n"; + break; + } + MathVector mathvector(size); + std::cout << "Enter vector elements:\n"; + fillVector(mathvector); + try { + MathVector result = matrix1 * mathvector; + std::cout << "Result:\n" << result; + } + catch (const std::exception& e) { + std::cout << "Error: " << e.what() << std::endl; + } + break; + } + default: { + std::cout << "Invalid input! Please try again\n"; + break; + } + } + } + else if (matrix_type == 2) { + // Triangular Matrix operations + size_t size; + std::cout << "Enter size of triangular matrix: "; + std::cin >> size; + + TriangleMatrix matrix1(size); + std::cout << "Enter elements of triangular matrix (only upper triangle):\n"; + fillTriangleMatrix(matrix1); + + switch (user_choice) { + case 1: { + TriangleMatrix matrix2(size); + std::cout << "Enter elements of second triangular matrix:\n"; + fillTriangleMatrix(matrix2); + try { + TriangleMatrix result = matrix1 + matrix2; + std::cout << "Result:\n" << result; + } + catch (const std::exception& e) { + std::cout << "Error: " << e.what() << std::endl; + } + break; + } + case 2: { + TriangleMatrix matrix2(size); + std::cout << "Enter elements of second triangular matrix:\n"; + fillTriangleMatrix(matrix2); + try { + TriangleMatrix result = matrix1 - matrix2; + std::cout << "Result:\n" << result; + } + catch (const std::exception& e) { + std::cout << "Error: " << e.what() << std::endl; + } + break; + } + case 3: { + std::cout << "Matrix multiplication for triangular matrices not implemented in this example\n"; + break; + } + case 4: { + int scalar; + std::cout << "Enter scalar: "; + std::cin >> scalar; + TriangleMatrix result = matrix1 + scalar; + std::cout << "Result:\n" << result; + break; + } + case 5: { + int scalar; + std::cout << "Enter scalar: "; + std::cin >> scalar; + TriangleMatrix result = matrix1 - scalar; + std::cout << "Result:\n" << result; + break; + } + case 6: { + int scalar; + std::cout << "Enter scalar: "; + std::cin >> scalar; + TriangleMatrix result = matrix1 * scalar; + std::cout << "Result:\n" << result; + break; + } + case 7: { + int scalar; + std::cout << "Enter scalar: "; + std::cin >> scalar; + try { + TriangleMatrix result = matrix1 / scalar; + std::cout << "Result:\n" << result; + } + catch (const std::exception& e) { + std::cout << "Error: " << e.what() << std::endl; + } + break; + } + case 8: { + MathVector mathvector(size); + std::cout << "Enter vector elements:\n"; + fillVector(mathvector); + try { + MathVector result = matrix1 * mathvector; + std::cout << "Result:\n" << result; + } + catch (const std::exception& e) { + std::cout << "Error: " << e.what() << std::endl; + } + break; + } + default: { + std::cout << "Invalid input! Please try again\n"; + break; + } + } + } + std::cout << "\nPress Enter to continue..."; + std::cin.ignore(); + std::cin.get(); + system("cls"); + + } while (true); + return 0; +} +#endif diff --git a/tests/test_algoritm.cpp b/tests/test_algoritm.cpp new file mode 100644 index 00000000..ac26dbf0 --- /dev/null +++ b/tests/test_algoritm.cpp @@ -0,0 +1,68 @@ +#include "../lib_algoritm/algoritm.h" +#include +#include +TEST(TestAlgoritmLib, test_for_one_local_min) { + int data[9] = { 1, 20, 30, + 40, 50, 60 , + 70, 80, 90 }; + Matrix matrix(data, 3, 3); + int result = find_local_minimum(matrix); + EXPECT_EQ(result, 1); +} +TEST(TestAlgoritmLib, test_for_many_local_min) { + int data[9] = { 1, 4, 3, + 8, 10, 6 , + 7, 9, 2 }; + Matrix matrix(data, 3, 3); + int result = find_local_minimum(matrix); + EXPECT_TRUE(result == 1 || result == 3 || result == 7 || result == 2); +} +TEST(TestAlgoritmLib, test_top_left_corner_minimum) { + int data[9] = { 1, 3, 4, + 2, 5, 6, + 7, 8, 9 }; + Matrix matrix(data, 3, 3); + int result = find_local_minimum(matrix); + + EXPECT_TRUE(result == 1); +} +TEST(TestAlgoritmLib, test_bottom_right_corner_minimum) { + int data[9] = { 9, 8, 7, + 6, 5, 4, + 3, 2, 1 }; + Matrix matrix(data, 3, 3); + int result = find_local_minimum(matrix); + EXPECT_EQ(result, 1); +} +TEST(TestAlgoritmLib, test_center_minimum) { + int data[9] = { 9, 8, 7, + 6, 1, 5, + 4, 2, 3 }; + Matrix matrix(data, 3, 3); + int result = find_local_minimum(matrix); + EXPECT_EQ(result, 1); +} +TEST(TestAlgoritmLib, test_single_element) { + int data[1] = { 5 }; + Matrix matrix(data, 1, 1); + int result = find_local_minimum(matrix); + EXPECT_EQ(result, 5); +} +TEST(TestAlgoritmLib, test_2x2_matrix) { + int data[4] = { 4, 3, + 1, 2 }; + Matrix matrix(data, 2, 2); + int result = find_local_minimum(matrix); + EXPECT_TRUE(result == 3 || result == 1); +} +TEST(TestAlgoritmLib, test_5x5_matrix) { + int data[25] = { 10, 11, 12, 13, 14, + 15, 16, 1, 17, 18, + 19, 20, 21, 22, 23, + 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33 }; + Matrix matrix(data, 5, 5); + int result = find_local_minimum(matrix); + EXPECT_TRUE(result == 1 || result == 10 || result == 14 || result == 19 + || result == 23 || result == 29 || result == 33); +} diff --git a/tests/test_circles_and_spheres.cpp b/tests/test_circles_and_spheres.cpp new file mode 100644 index 00000000..6ce7739f --- /dev/null +++ b/tests/test_circles_and_spheres.cpp @@ -0,0 +1,242 @@ +// Copyright 2025 Julia Zabytina +#include +#include "../lib_circle/circle.h" +#include "../lib_sphere/sphere.h" + +/* +TEST(TestCircleLib, circle_constructor_of_initialization1) { + // Arrange & Act + Circle circle(1, 1, 5); + // Assert + EXPECT_EQ(circle.getX(), 1); + EXPECT_EQ(circle.getY(), 1); + EXPECT_EQ(circle.getR(), 5); +} +TEST(TestCircleLib, circle_constructor_of_initialization2) { + // Arrange & Act + Circle circle(Point(1, 1), 5); + // Assert + EXPECT_EQ(circle.getX(), 1); + EXPECT_EQ(circle.getY(), 1); + EXPECT_EQ(circle.getR(), 5); +} +TEST(TestCircleLib, circle_copy_constructor) { + // Arrange & Act + Circle circle1(Point(1, 1), 5); + Circle circle2(circle1); + // Assert + EXPECT_TRUE(circle1 == circle2); +} +TEST(TestCircleLib, circle_equal_operator_expect_true) { + // Arrange & Act + Circle circle1(1, 2, 4); + Circle circle2(1, 2, 4); + Circle circle3(5, 6, 8); + // Assert + EXPECT_TRUE(circle1 == circle2); +} +TEST(TestCircleLib, circle_equal_operator_expect_false) { + // Arrange & Act + Circle circle1(1, 2, 4); + Circle circle2(1, 2, 4); + Circle circle3(5, 6, 8); + // Assert + EXPECT_FALSE(circle1 == circle3); +} +TEST(TestCircleLib, circle_not_equal_operator_expect_true) { + // Arrange & Act + Circle circle1(1, 2, 4); + Circle circle2(1, 2, 4); + Circle circle3(5, 6, 8); + // Assert + EXPECT_TRUE(circle1 != circle3); +} +TEST(TestCircleLib, circle_not_equal_operator_expect_false) { + // Arrange & Act + Circle circle1(1, 2, 4); + Circle circle2(1, 2, 4); + Circle circle3(5, 6, 8); + // Assert + EXPECT_FALSE(circle1 != circle2); +} +TEST(TestSphereLib, sphere_constructor_of_initialization1) { + // Arrange & Act + Sphere sphere(2, 3, 5, 7); + // Assert + EXPECT_EQ(sphere.getX(), 2); + EXPECT_EQ(sphere.getY(), 3); + EXPECT_EQ(sphere.getZ(), 5); + EXPECT_EQ(sphere.getR(), 7); +} +TEST(TestSphereLib, sphere_constructor_of_initialization2) { + // Arrange & Act + Sphere sphere(Point3D(2, 8, 9), 3); + // Assert + EXPECT_EQ(sphere.getX(), 2); + EXPECT_EQ(sphere.getY(), 8); + EXPECT_EQ(sphere.getZ(), 9); + EXPECT_EQ(sphere.getR(), 3); +} +TEST(TestSphereLib, sphere_copy_constructor) { + // Arrange & Act + Sphere sphere1(Point3D(1, 1, 1), 5); + Sphere sphere2(sphere1); + // Assert + EXPECT_TRUE(sphere1 == sphere2); +} +TEST(TestSphereLib, sphere_equal_operator_expect_true) { + // Arrange & Act + Sphere sphere1(1, 2, 2, 4); + Sphere sphere2(1, 2, 2, 4); + Sphere sphere3(5, 6, 6, 8); + // Assert + EXPECT_TRUE(sphere1 == sphere2); +} +TEST(TestSphereLib, sphere_equal_operator_expect_false) { + // Arrange & Act + Sphere sphere1(1, 2, 2, 4); + Sphere sphere2(1, 2, 2, 4); + Sphere sphere3(5, 6, 6, 8); + // Assert + EXPECT_FALSE(sphere1 == sphere3); +} +TEST(TestSphereLib, sphere_not_equal_operator_expect_true) { + // Arrange & Act + Sphere sphere1(1, 2, 2, 4); + Sphere sphere2(1, 2, 2, 4); + Sphere sphere3(5, 6, 6, 8); + // Assert + EXPECT_TRUE(sphere1 != sphere3); +} +TEST(TestSphereLib, sphere_not_equal_operator_expect_false) { + // Arrange & Act + Sphere sphere1(1, 2, 2, 4); + Sphere sphere2(1, 2, 2, 4); + Sphere sphere3(5, 6, 6, 8); + // Assert + EXPECT_FALSE(sphere1 != sphere2); +} +TEST(TestPointLib, point_constructor_of_initialization) { + // Arrange & Act + Point point(5, 5); + // Assert + EXPECT_EQ(point.getX(), 5); + EXPECT_EQ(point.getY(), 5); +} +TEST(TestPointLib, point_default_constructor) { + // Arrange & Act + Point point; + // Assert + EXPECT_EQ(point.getX(), 0); + EXPECT_EQ(point.getY(), 0); +} +TEST(TestPointLib, point_copy_constructor) { + // Arrange & Act + Point point1(2, 3); + Point point2(point1); + // Assert + EXPECT_TRUE(point1 == point2); +} +TEST(TestPointLib, point_equal_operator_expect_true) { + // Arrange & Act + Point point1(1, 2); + Point point2(1, 2); + Point point3(5, 6); + // Assert + EXPECT_TRUE(point1 == point2); +} +TEST(TestPointLib, point_equal_operator_expect_false) { + // Arrange & Act + Point point1(1, 2); + Point point2(1, 2); + Point point3(5, 6); + // Assert + EXPECT_FALSE(point1 == point3); +} +TEST(TestPointLib, point_not_equal_operator_expect_true) { + // Arrange & Act + Point point1(1, 2); + Point point2(1, 2); + Point point3(5, 6); + // Assert + EXPECT_TRUE(point1 != point3); +} +TEST(TestPointLib, point_not_equal_operator_expect_false) { + // Arrange & Act + Point point1(1, 2); + Point point2(1, 2); + Point point3(5, 6); + // Assert + EXPECT_FALSE(point1 != point2); +} +TEST(TestPointLib, get_distance_to) { + // Arrange & Act + Point point1(1, 2); + Point point2(5, 6); + // Assert + EXPECT_EQ(point1.getDistanceTo(point2), 6); +} +TEST(TestPoint3DLib, point3d_constructor_of_initialization) { + // Arrange & Act + Point3D point(5, 5, 7); + // Assert + EXPECT_EQ(point.getX(), 5); + EXPECT_EQ(point.getY(), 5); + EXPECT_EQ(point.getZ(), 7); +} +TEST(TestPoint3DLib, point3d_default_constructor) { + // Arrange & Act + Point3D point; + // Assert + EXPECT_EQ(point.getX(), 0); + EXPECT_EQ(point.getY(), 0); + EXPECT_EQ(point.getZ(), 0); +} +TEST(TestPoint3DLib, point3d_copy_constructor) { + // Arrange & Act + Point3D point1(5, 5, 7); + Point3D point2(point1); + // Assert + EXPECT_TRUE(point1 == point2); +} +TEST(TestPoint3DLib, point3d_equal_operator_expect_true) { + // Arrange & Act + Point3D point1(1, 2, 2); + Point3D point2(1, 2, 2); + Point3D point3(5, 6, 6); + // Assert + EXPECT_TRUE(point1 == point2); +} +TEST(TestPoint3DLib, point3d_equal_operator_expect_false) { + // Arrange & Act + Point3D point1(1, 2, 2); + Point3D point2(1, 2, 2); + Point3D point3(5, 6, 6); + // Assert + EXPECT_FALSE(point1 == point3); +} +TEST(TestPoint3DLib, point3d_not_equal_operator_expect_true) { + // Arrange & Act + Point3D point1(1, 2, 2); + Point3D point2(1, 2, 2); + Point3D point3(5, 6, 6); + // Assert + EXPECT_TRUE(point1 != point3); +} +TEST(TestPoint3DLib, point3d_not_equal_operator_expect_false) { + // Arrange & Act + Point3D point1(1, 2, 2); + Point3D point2(1, 2, 2); + Point3D point3(5, 6, 6); + // Assert + EXPECT_FALSE(point1 != point2); +} +TEST(TestPoint3DLib, get_distance_to) { + // Arrange & Act + Point3D point1(1, 2, 3); + Point3D point2(5, 6, 7); + // Assert + EXPECT_EQ(point1.getDistanceTo(point2), 7); +} + +*/ \ No newline at end of file diff --git a/tests/test_math_vector.cpp b/tests/test_math_vector.cpp new file mode 100644 index 00000000..bff4c8e9 --- /dev/null +++ b/tests/test_math_vector.cpp @@ -0,0 +1,350 @@ +// Copyright 2025 Julia Zabytina +#include +#include +#include "../lib_math_vector/math_vector.h" +TEST(TestMathVectorLib, mathvector_default_constructor) { + // Arrange & Act + MathVector vector; + // Assert + EXPECT_TRUE(vector.is_empty()); +} +TEST(TestMathVectorLib, mathvector_constructor_with_size) { + // Arrange & Act + size_t size = 10; + MathVector vector(size); + // Assert + EXPECT_LE(vector.get_size(), vector.get_capacity()); + EXPECT_EQ(vector.get_size(), size); +} +TEST(TestMathVectorLib, mathvector_constructor_with_size_and_start_index) { + // Arrange & Act + size_t size = 10; + size_t start_index = 1; + MathVector vector(size, start_index); + // Assert + EXPECT_LE(vector.get_size(), vector.get_capacity()); + EXPECT_EQ(vector.get_size(), size); + EXPECT_EQ(vector.get_start_index(), start_index); +} +TEST(TestMathVectorLib, mathvector_constructor_with_array_and_size) { + // Arrange & Act + int data[3] = { 1,2,3 }; + size_t size = 3; + MathVector vector(data, size); + // Assert + EXPECT_EQ(vector.get_size(), size); + EXPECT_EQ(vector[0], data[0]); + EXPECT_EQ(vector[1], data[1]); + EXPECT_EQ(vector[2], data[2]); + EXPECT_LE(vector.get_size(), vector.get_capacity()); +} +TEST(TestMathVectorLib, mathvector_constructor_with_array_and_size_and_start_index) { + // Arrange & Act + int data[3] = { 1,2,3 }; + size_t size = 3; + size_t start_index = 1; + MathVector vector(data, size, start_index); + // Assert + EXPECT_EQ(vector.get_start_index(), start_index); + EXPECT_EQ(vector.get_size(), size); + EXPECT_EQ(vector[1], data[0]); + EXPECT_EQ(vector[2], data[1]); + EXPECT_EQ(vector[3], data[2]); + EXPECT_LE(vector.get_size(), vector.get_capacity()); +} +TEST(TestMathVectorLib, mathvector_copy_constructor) { + // Arrange & Act + int data[3] = { 1,2,3 }; + size_t size = 3; + MathVector old_vector(data, size); + MathVector new_vector(old_vector); + // Assert + EXPECT_EQ(old_vector.get_start_index(), new_vector.get_start_index()); + EXPECT_EQ(old_vector, new_vector); +} +TEST(TestMathVectorLib, mathvector_mult_on_value) { + // Arrange & Act + int data[3] = { 1,2,3 }; + size_t size = 3; + int value = 5; + MathVector vector(data, size); + MathVector result; + result = vector * value; + // Assert + EXPECT_EQ(result[0], vector[0] * value); + EXPECT_EQ(result[1], vector[1] * value); + EXPECT_EQ(result[2], vector[2] * value); +} +TEST(TestMathVectorLib, mathvector_div_on_value) { + // Arrange & Act + int data[3] = { 4,8,28 }; + size_t size = 3; + int value = 2; + MathVector vector(data, size); + MathVector result; + result = vector / value; + // Assert + EXPECT_EQ(result[0], vector[0] / value); + EXPECT_EQ(result[1], vector[1] / value); + EXPECT_EQ(result[2], vector[2] / value); +} +TEST(TestMathVectorLib, mathvector_div_on_null_exception) { + // Arrange & Act + int data[3] = { 10, 27, 21 }; + size_t size = 3; + MathVector vector(data, size); + int value = 0; + // Assert + EXPECT_THROW(vector / value, std::logic_error); +} +TEST(TestMathVectorLib, mathvector_mult_assign_on_value) { + // Arrange & Act + int data[3] = { 3, 6, 0 }; + size_t size = 3; + int value = 3; + MathVector vector(data, size); + vector *= value; + // Assert + EXPECT_EQ(vector[0], data[0] * value); + EXPECT_EQ(vector[1], data[1] * value); + EXPECT_EQ(vector[2], data[2] * value); +} +TEST(TestMathVectorLib, mathvector_div_assign_on_value) { + // Arrange & Act + int data[3] = { 4,8,28 }; + size_t size = 3; + int value = 2; + MathVector vector(data, size); + vector /= value; + // Assert + EXPECT_EQ(vector[0], data[0] / value); + EXPECT_EQ(vector[1], data[1] / value); + EXPECT_EQ(vector[2], data[2] / value); +} +TEST(TestMathVectorLib, mathvector_div_assign_on_null_exception) { + // Arrange & Act + int data[3] = { 4,8,28 }; + size_t size = 3; + int value = 0; + MathVector vector(data, size); + // Assert + EXPECT_THROW(vector /= value, std::logic_error); +} +TEST(TestMathVectorLib, mathvector_add_vector) { + // Arrange & Act + int data1[3] = { 4, 7 ,28 }; + size_t size1 = 3; + + int data2[3] = { 5, 0, 100 }; + size_t size2 = 3; + + MathVector vector1(data1, size1); + MathVector vector2(data2, size2); + MathVector result; + result = vector1 + vector2; + // Assert + EXPECT_EQ(result[0], vector1[0] + vector2[0]); + EXPECT_EQ(result[1], vector1[1] + vector2[1]); + EXPECT_EQ(result[2], vector1[2] + vector2[2]); +} +TEST(TestMathVectorLib, mathvector_sub_vector) { + // Arrange & Act + int data1[3] = { 4, 7 ,28 }; + size_t size1 = 3; + + int data2[3] = { 5, 0, 100 }; + size_t size2 = 3; + + MathVector vector1(data1, size1); + MathVector vector2(data2, size2); + MathVector result; + result = vector1 - vector2; + // Assert + EXPECT_EQ(result[0], vector1[0] - vector2[0]); + EXPECT_EQ(result[1], vector1[1] - vector2[1]); + EXPECT_EQ(result[2], vector1[2] - vector2[2]); +} +TEST(TestMathVectorLib, mathvector_scalar_product) { + // Arrange & Act + int data1[3] = { 4, 7 ,28 }; + size_t size1 = 3; + + int data2[3] = { 5, 0, 100 }; + size_t size2 = 3; + + MathVector vector1(data1, size1); + MathVector vector2(data2, size2); + int result = 0; + int scalar_product = + vector1[0] * vector2[0] + + vector1[1] * vector2[1] + + vector1[2] * vector2[2]; + result = vector1 * vector2; + // Assert + EXPECT_EQ(result, scalar_product); +} +TEST(TestMathVectorLib, mathvector_add_for_vectors_with_different_dimension_exception) { + // Arrange & Act + int data1[3] = { 4, 7 ,28 }; + size_t size1 = 3; + + int data2[5] = { 5, 100, 1, 22, 7 }; + size_t size2 = 5; + + MathVector vector1(data1, size1); + MathVector vector2(data2, size2); + + // Assert + EXPECT_THROW(vector1 + vector2, std::logic_error); +} +TEST(TestMathVectorLib, mathvector_sub_for_vectors_with_different_dimension_exception) { + // Arrange & Act + int data1[3] = { 4, 7 ,28 }; + size_t size1 = 3; + + int data2[5] = { 5, 100, 1, 22, 7 }; + size_t size2 = 5; + + MathVector vector1(data1, size1); + MathVector vector2(data2, size2); + + // Assert + EXPECT_THROW(vector1 - vector2, std::logic_error); +} +TEST(TestMathVectorLib, mathvector_scalar_product_for_vectors_with_different_dimension_exception) { + // Arrange & Act + int data1[3] = { 4, 7 ,28 }; + size_t size1 = 3; + + int data2[5] = { 5, 100, 1, 22, 7 }; + size_t size2 = 5; + + MathVector vector1(data1, size1); + MathVector vector2(data2, size2); + + // Assert + EXPECT_THROW(vector1 * vector2, std::logic_error); +} +TEST(TestMathVectorLib, mathvector_add_assign_vector) { + // Arrange & Act + int data1[3] = { 4, 7 ,28 }; + size_t size1 = 3; + + int data2[3] = { 5, 0, 100 }; + size_t size2 = 3; + + MathVector vector1(data1, size1); + MathVector vector2(data2, size2); + vector1 += vector2; + // Assert + EXPECT_EQ(vector1[0], data1[0] + data2[0]); + EXPECT_EQ(vector1[1], data1[1] + data2[1]); + EXPECT_EQ(vector1[2], data1[2] + data2[2]); +} +TEST(TestMathVectorLib, mathvector_sub_assign_vector) { + // Arrange & Act + int data1[3] = { 4, 7 ,28 }; + size_t size1 = 3; + + int data2[3] = { 5, 0, 100 }; + size_t size2 = 3; + + MathVector vector1(data1, size1); + MathVector vector2(data2, size2); + vector1 -= vector2; + // Assert + EXPECT_EQ(vector1[0], data1[0] - data2[0]); + EXPECT_EQ(vector1[1], data1[1] - data2[1]); + EXPECT_EQ(vector1[2], data1[2] - data2[2]); +} +TEST(TestMathVectorLib, mathvector_add_assign_for_vectors_with_different_dimension_exception) { + // Arrange & Act + int data1[3] = { 4, 7 ,28 }; + size_t size1 = 3; + + int data2[5] = { 5, 100, 1, 22, 7 }; + size_t size2 = 5; + + MathVector vector1(data1, size1); + MathVector vector2(data2, size2); + + // Assert + EXPECT_THROW(vector1 += vector2, std::logic_error); +} +TEST(TestMathVectorLib, mathvector_sub_assign_for_vectors_with_different_dimension_exception) { + // Arrange & Act + int data1[3] = { 4, 7 ,28 }; + size_t size1 = 3; + + int data2[5] = { 5, 100, 1, 22, 7 }; + size_t size2 = 5; + + MathVector vector1(data1, size1); + MathVector vector2(data2, size2); + + // Assert + EXPECT_THROW(vector1 -= vector2, std::logic_error); +} +TEST(TestMathVectorLib, mathvector_simple_assignment) { + // Arrange + MathVector vector1(2); + MathVector vector2(2); + vector1[0] = 1; + vector1[1] = 2; + vector2[0] = 3; + vector2[1] = 4; + //Act + vector1 = vector2; + // Assert + EXPECT_EQ(vector1[0], 3); + EXPECT_EQ(vector1[1], 4); +} +TEST(TestMathVectorLib, mathvector_operator_square_brackets) { + // Arrange + size_t size = 5; + size_t start_index = 1; + MathVector vector1(size, start_index); + vector1[1] = 2; + vector1[2] = 3; + vector1[3] = 4; + vector1[4] = 5; + vector1[5] = 6; + //Act & Assert + EXPECT_EQ(vector1[1], 2); + EXPECT_EQ(vector1[2], 3); + EXPECT_EQ(vector1[3], 4); + EXPECT_EQ(vector1[4], 5); + EXPECT_EQ(vector1[5], 6); +} +TEST(TestMathVectorLib, mathvector_at) { + // Arrange + size_t size = 5; + size_t start_index = 2; + MathVector vector1(size, start_index); + vector1[2] = 3; + vector1[3] = 4; + vector1[4] = 5; + vector1[5] = 6; + vector1[6] = 7; + //Act & Assert + EXPECT_EQ(vector1.at(2), 3); + EXPECT_EQ(vector1.at(3), 4); + EXPECT_EQ(vector1.at(4), 5); + EXPECT_EQ(vector1.at(5), 6); + EXPECT_EQ(vector1.at(6), 7); +} +TEST(TestMathVectorLib, mathvector_at_with_exception) { + // Arrange + size_t size = 5; + size_t start_index = 2; + MathVector vector1(size, start_index); + vector1[2] = 3; + vector1[3] = 4; + vector1[4] = 5; + vector1[5] = 6; + vector1[6] = 7; + //Act & Assert + EXPECT_THROW(vector1.at(0), std::logic_error); + EXPECT_THROW(vector1.at(1), std::logic_error); + EXPECT_THROW(vector1.at(7), std::logic_error); +} diff --git a/tests/test_matrix.cpp b/tests/test_matrix.cpp new file mode 100644 index 00000000..90aae44e --- /dev/null +++ b/tests/test_matrix.cpp @@ -0,0 +1,333 @@ +// Copyright 2025 Julia Zabytina +#include +#include +#include "../lib_matrix/matrix.h" + + +TEST(TestMatrixLib, matrix_default_constructor) { + // Arrange & Act + Matrix matrix; + // Assert + EXPECT_EQ(0, matrix.getM()); + EXPECT_EQ(0, matrix.getN()); + EXPECT_TRUE(matrix.is_empty()); +} +TEST(TestMatrixLib, matrix_constructor_with_size) { + // Arrange & Act + size_t M = 100; + size_t N = 100; + Matrix matrix(M, N); + // Assert + EXPECT_EQ(M, matrix.getM()); + EXPECT_EQ(N, matrix.getN()); +} +TEST(TestMatrixLib, matrix_constructor_with_array_and_size) { + // Arrange & Act + size_t M = 2; + size_t N = 2; + int data[4] = { 1, 2, 3, 4 }; + Matrix matrix(data, M, N); + // Assert + EXPECT_EQ(M, matrix.getM()); + EXPECT_EQ(N, matrix.getN()); + EXPECT_EQ(matrix[0][0], data[0]); + EXPECT_EQ(matrix[0][1], data[1]); + EXPECT_EQ(matrix[1][0], data[2]); + EXPECT_EQ(matrix[1][1], data[3]); +} +TEST(TestMatrixLib, matrix_copy_constructor) { + // Arrange & Act + size_t M = 2; + size_t N = 2; + int data[4] = { 1, 2, 3, 4}; + Matrix old_matrix(data, M, N); + Matrix new_matrix(old_matrix); + // Assert + EXPECT_EQ(old_matrix, new_matrix); +} +TEST(TestMatrixLib, matrix_assignment_operator) { + // Arrange + size_t M = 2, N = 2; + int data1[4] = { 1, 2, 3, 4 }; + int data2[4] = { 5, 6, 7, 8 }; + Matrix matrix1(data1, M, N); + Matrix matrix2(data2, M, N); + // Act + matrix1 = matrix2; + // Assert + EXPECT_EQ(matrix1, matrix2); +} +TEST(TestMatrixLib, matrix_mult_value) { + // Arrange + size_t M = 2, N = 2; + int data[4] = { 1, 2, 3, 4 }; + int value = 10; + Matrix matrix(data, M, N); + Matrix result(M, N); + // Act + result = matrix * value; + // Assert + EXPECT_EQ(result[0][0], data[0] * value); + EXPECT_EQ(result[0][1], data[1] * value); + EXPECT_EQ(result[1][0], data[2] * value); + EXPECT_EQ(result[1][1], data[3] * value); +} +TEST(TestMatrixLib, matrix_div_value) { + // Arrange + size_t M = 2, N = 2; + int data[4] = { 2, 2, 10, 4 }; + int value = 2; + Matrix matrix(data, M, N); + Matrix result(M, N); + // Act + result = matrix / value; + // Assert + EXPECT_EQ(result[0][0], data[0] / value); + EXPECT_EQ(result[0][1], data[1] / value); + EXPECT_EQ(result[1][0], data[2] / value); + EXPECT_EQ(result[1][1], data[3] / value); +} +TEST(TestMatrixLib, matrix_div_value_with_exception) { + // Arrange & Act + size_t M = 2, N = 2; + int data[4] = { 1, 2, 3, 4 }; + int value = 0; + Matrix matrix(data, M, N); + // Assert + EXPECT_THROW(matrix / value;, std::logic_error); +} +TEST(TestMatrixLib, matrix_mult_assign_value) { + // Arrange + size_t M = 2, N = 2; + int data[4] = { 2, 2, 10, 4 }; + int value = 2; + Matrix matrix(data, M, N); + // Act + matrix *= value; + // Assert + EXPECT_EQ(matrix[0][0], data[0] * value); + EXPECT_EQ(matrix[0][1], data[1] * value); + EXPECT_EQ(matrix[1][0], data[2] * value); + EXPECT_EQ(matrix[1][1], data[3] * value); +} +TEST(TestMatrixLib, matrix_div_assign_value) { + // Arrange + size_t M = 2, N = 2; + int data[4] = { 2, 2, 10, 4 }; + int value = 2; + Matrix matrix(data, M, N); + // Act + matrix /= value; + // Assert + EXPECT_EQ(matrix[0][0], data[0] / value); + EXPECT_EQ(matrix[0][1], data[1] / value); + EXPECT_EQ(matrix[1][0], data[2] / value); + EXPECT_EQ(matrix[1][1], data[3] / value); +} +TEST(TestMatrixLib, matrix_div_assign_value_with_exception) { + // Arrange & Act + size_t M = 2, N = 2; + int data[4] = { 1, 2, 3, 4 }; + int value = 0; + Matrix matrix(data, M, N); + // Assert + EXPECT_THROW(matrix /= value; , std::logic_error); +} +TEST(TestMatrixLib, matrix_add_matrix) { + // Arrange + size_t M = 2, N = 3; + int data1[6] = { 2, 2, 10, 4, 5, 7 }; + int data2[6] = { 8, 2, 3, 0, 5, 7}; + + Matrix matrix1(data1, M, N); + Matrix matrix2(data2, M, N); + Matrix result(M, N); + // Act + result = matrix1 + matrix2; + // Assert + EXPECT_EQ(result[0][0], data1[0] + data2[0]); + EXPECT_EQ(result[0][1], data1[1] + data2[1]); + EXPECT_EQ(result[0][2], data1[2] + data2[2]); + EXPECT_EQ(result[1][0], data1[3] + data2[3]); + EXPECT_EQ(result[1][1], data1[4] + data2[4]); + EXPECT_EQ(result[1][2], data1[5] + data2[5]); +} +TEST(TestMatrixLib, matrix_sub_matrix) { + // Arrange + size_t M = 2, N = 3; + int data1[6] = { 2, 2, 10, 4, 5, 7 }; + int data2[6] = { 8, 2, 3, 0, 5, 7 }; + + Matrix matrix1(data1, M, N); + Matrix matrix2(data2, M, N); + Matrix result(M, N); + // Act + result = matrix1 - matrix2; + // Assert + EXPECT_EQ(result[0][0], data1[0] - data2[0]); + EXPECT_EQ(result[0][1], data1[1] - data2[1]); + EXPECT_EQ(result[0][2], data1[2] - data2[2]); + EXPECT_EQ(result[1][0], data1[3] - data2[3]); + EXPECT_EQ(result[1][1], data1[4] - data2[4]); + EXPECT_EQ(result[1][2], data1[5] - data2[5]); +} +TEST(TestMatrixLib, matrix_add_matrix_with_exception) { + // Arrange & Act + size_t M1 = 2, N1 = 3; + size_t M2 = 2, N2 = 2; + + int data1[6] = { 2, 2, 10, 4, 5, 7 }; + int data2[4] = { 8, 2, 3, 0 }; + + Matrix matrix1(data1, M1, N1); + Matrix matrix2(data2, M2, N2); + + // Assert + EXPECT_THROW(matrix1 + matrix2, std::logic_error); +} +TEST(TestMatrixLib, matrix_sub_matrix_with_exception) { + // Arrange & Act + size_t M1 = 2, N1 = 3; + size_t M2 = 2, N2 = 2; + + int data1[6] = { 2, 2, 10, 4, 5, 7 }; + int data2[4] = { 8, 2, 3, 0 }; + + Matrix matrix1(data1, M1, N1); + Matrix matrix2(data2, M2, N2); + + // Assert + EXPECT_THROW(matrix1 - matrix2, std::logic_error); +} +TEST(TestMatrixLib, matrix_add_assign_matrix) { + // Arrange + size_t M = 2, N = 3; + int data1[6] = { 2, 2, 10, 4, 5, 7 }; + int data2[6] = { 8, 2, 3, 0, 5, 7 }; + + Matrix matrix1(data1, M, N); + Matrix matrix2(data2, M, N); + // Act + matrix1 += matrix2; + // Assert + EXPECT_EQ(matrix1[0][0], data1[0] + data2[0]); + EXPECT_EQ(matrix1[0][1], data1[1] + data2[1]); + EXPECT_EQ(matrix1[0][2], data1[2] + data2[2]); + EXPECT_EQ(matrix1[1][0], data1[3] + data2[3]); + EXPECT_EQ(matrix1[1][1], data1[4] + data2[4]); + EXPECT_EQ(matrix1[1][2], data1[5] + data2[5]); +} +TEST(TestMatrixLib, matrix_add_assign_matrix_with_exception) { + // Arrange & Act + size_t M1 = 2, N1 = 3; + size_t M2 = 2, N2 = 2; + int data1[6] = { 2, 2, 10, 4, 5, 7 }; + int data2[4] = { 8, 2, 3, 0 }; + Matrix matrix1(data1, M1, N1); + Matrix matrix2(data2, M2, N2); + // Assert + EXPECT_THROW(matrix1 += matrix2, std::logic_error); +} +TEST(TestMatrixLib, matrix_sub_assign_matrix) { + // Arrange + size_t M = 2, N = 3; + int data1[6] = { 2, 2, 10, 4, 5, 7 }; + int data2[6] = { 8, 2, 3, 0, 5, 7 }; + + Matrix matrix1(data1, M, N); + Matrix matrix2(data2, M, N); + // Act + matrix1 -= matrix2; + // Assert + EXPECT_EQ(matrix1[0][0], data1[0] - data2[0]); + EXPECT_EQ(matrix1[0][1], data1[1] - data2[1]); + EXPECT_EQ(matrix1[0][2], data1[2] - data2[2]); + EXPECT_EQ(matrix1[1][0], data1[3] - data2[3]); + EXPECT_EQ(matrix1[1][1], data1[4] - data2[4]); + EXPECT_EQ(matrix1[1][2], data1[5] - data2[5]); +} +TEST(TestMatrixLib, matrix_sub_assign_matrix_with_exception) { + // Arrange & Act + size_t M1 = 2, N1 = 3; + size_t M2 = 2, N2 = 2; + int data1[6] = { 2, 2, 10, 4, 5, 7 }; + int data2[4] = { 8, 2, 3, 0 }; + Matrix matrix1(data1, M1, N1); + Matrix matrix2(data2, M2, N2); + // Assert + EXPECT_THROW(matrix1 -= matrix2, std::logic_error); +} +TEST(TestMatrixLib, matrix_mult_matrix) { + // Arrange + size_t M1 = 2, N1 = 3, M2 = 3, N2 = 2; + + int data1[6] = { 2, 2, 1, 2, 1, 2 }; + int data2[6] = { 3, 2, 2, 1, 3, 2 }; + + Matrix matrix1(data1, M1, N1); + Matrix matrix2(data2, M2, N2); + Matrix result(M1, N2); + // Act + result = matrix1 * matrix2; + // Assert + EXPECT_EQ(result[0][0], 13); + EXPECT_EQ(result[0][1], 8); + EXPECT_EQ(result[1][0], 14); + EXPECT_EQ(result[1][1], 9); +} +TEST(TestMatrixLib, matrix_mult_matrix_with_throw) { + //Arrange & Act + size_t M1 = 2, N1 = 3, M2 = 2, N2 = 2; + + int data1[6] = { 2, 2, 1, 2, 1, 2 }; + int data2[6] = { 3, 2, 2, 1 }; + + Matrix matrix1(data1, M1, N1); + Matrix matrix2(data2, M2, N2); + //Assert + EXPECT_THROW(matrix1 * matrix2, std::logic_error); +} +TEST(TestMatrixLib, matrix_mult_vector) { + // Arrange + size_t M = 2, N = 3, size = 3; + int data1[6] = { 2, 3, 1, 4, 1, 2 }; + int data2[3] = { 2, 2, 2 }; + Matrix matrix(data1, M, N); + MathVector vector(data2, size); + MathVector result(M); + // Act + result = matrix * vector; + // Assert + EXPECT_EQ(result[0], 12); + EXPECT_EQ(result[1], 14); +} +TEST(TestMatrixLib, matrix_mult_vector_with_exception) { + // Arrange & Act + size_t M = 2, N = 3, size = 5; + int data1[6] = { 2, 3, 1, 4, 1, 2 }; + int data2[5] = { 2, 2, 2, 6, 7 }; + Matrix matrix(data1, M, N); + MathVector vector(data2, size); + // Assert + EXPECT_THROW(matrix * vector, std::logic_error); +} +TEST(TestMatrixLib, matrix_simple_assignment) { + // Arrange + Matrix matrix1(2, 2); + Matrix matrix2(2, 2); + matrix1[0][0] = 1; + matrix1[0][1] = 2; + matrix1[1][0] = 3; + matrix1[1][1] = 4; + matrix2[0][0] = 5; + matrix2[0][1] = 6; + matrix2[1][0] = 7; + matrix2[1][1] = 8; + //Act + matrix1 = matrix2; + // + EXPECT_EQ(matrix1[0][0], 5); + EXPECT_EQ(matrix1[0][1], 6); + EXPECT_EQ(matrix1[1][0], 7); + EXPECT_EQ(matrix1[1][1], 8); +} diff --git a/tests/test_stack.cpp b/tests/test_stack.cpp new file mode 100644 index 00000000..09542e10 --- /dev/null +++ b/tests/test_stack.cpp @@ -0,0 +1,167 @@ +// Copyright 2025 Julia Zabytina +//#include +//#include +//#include "../lib_stack/stack.h" +// +//TEST(TestStackLib, stack_constructor_with_size) { +// // Arrange & Act +// size_t size = 10; +// Stack stack(size); +// // Assert +// EXPECT_EQ(stack.getData().get_size(), size); +// EXPECT_EQ(stack.getData().get_capacity(), size+15); +//} +//TEST(TestStackLib, stack_copy_constructor) { +// // Arrange & Act +// size_t size = 10; +// Stack stack1(size); +// Stack stack2(stack1); +// // Assert +// EXPECT_TRUE(stack1 == stack2); +//} +//TEST(TestStackLib, stack_push_element) { +// // Arrange +// size_t size = 10; +// int element = 100; +// Stack stack(size); +// // Act +// stack.push(element); +// // Assert +// EXPECT_EQ(stack.top(), element); +//} +//TEST(TestStackLib, stack_push_element_with_exception) { +// // Arrange +// size_t size = 0; +// int element = 100; +// Stack stack(size); +// // Act +// for (size_t i = 0; i < 15; ++i) { +// stack.push(element); +// } +// // Assert +// EXPECT_THROW(stack.push(element), std::logic_error); +//} +//TEST(TestStackLib, stack_pop_element_with_exception) { +// // Arrange & Act +// size_t size = 0; +// Stack stack(size); +// // Assert +// EXPECT_THROW(stack.pop(), std::logic_error); +//} +//TEST(TestStackLib, stack_pop_element) { +// // Arrange +// size_t size = 10; +// int element1 = 100; +// int element2 = 200; +// int element3 = 300; +// Stack stack(size); +// // Act +// stack.push(element1); +// stack.push(element2); +// stack.push(element3); +// stack.pop(); +// // Assert +// EXPECT_EQ(stack.top(), element2); +//} +//TEST(TestStackLib, stack_is_full) { +// // Arrange +// size_t size = 0; +// int element = 300; +// Stack stack(size); +// // Act +// for (size_t i = 0; i < 15; ++i) { +// stack.push(element); +// } +// // Assert +// EXPECT_TRUE(stack.is_full()); +//} +//TEST(TestStackLib, stack_is_empty) { +// // Arrange +// size_t size = 0; +// Stack stack(size); +// // Assert & Act +// EXPECT_TRUE(stack.is_empty()); +//} +//TEST(TestStackLib, stack_clear) { +// // Arrange +// size_t size = 0; +// int element = 300; +// +// Stack stack(size); +// // Act +// for (size_t i = 0; i < 15; ++i) { +// stack.push(element); +// } +// stack.clear(); +// // Assert +// EXPECT_TRUE(stack.is_empty()); +//} +//TEST(TestStackLib, stack_top) { +// // Arrange +// size_t size = 0; +// int common_element = 100; +// int last_element = 999; +// Stack stack(size); +// // Act +// for (size_t i = 0; i < 14; ++i) { +// stack.push(common_element); +// } +// stack.push(last_element); +// // Assert +// EXPECT_EQ(stack.top(), last_element); +//} +//TEST(TestStackLib, stack_top_with_exception) { +// // Arrange & Act +// size_t size = 0; +// Stack stack(size); +// // Assert +// EXPECT_THROW(stack.top(), std::logic_error); +//} +//TEST(TestStackLib, stack_operator_compare_expect_true) { +// // Arrange & Act +// size_t size = 10; +// Stack stack(size); +// Stack stack_other(size); +// // Assert +// EXPECT_TRUE(stack == stack_other); +//} +//TEST(TestStackLib, stack_operator_compare_expect_false) { +// // Arrange & Act +// size_t size1 = 10; +// size_t size2 = 20; +// Stack stack(size1); +// Stack stack_other(size2); +// // Assert +// EXPECT_FALSE(stack == stack_other); +//} +//TEST(TestStackLib, stack_operator_assign) { +// //Arrange +// size_t size1 = 10; +// size_t size2 = 20; +// Stack stack(size1); +// Stack stack_other(size2); +// //Act +// stack_other.push(100); +// stack_other.push(200); +// stack = stack_other; +// //Assert +// EXPECT_TRUE(stack == stack_other); +// EXPECT_EQ(stack.top(), 200); +//} +//TEST(TestStackLib, stack_operator_not_compare_expect_true) { +// // Arrange & Act +// size_t size = 10; +// Stack stack(size); +// Stack stack_other(size); +// // Assert +// EXPECT_FALSE(stack != stack_other); +//} +//TEST(TestStackLib, stack_operator_not_compare_expect_false) { +// // Arrange & Act +// size_t size1 = 10; +// size_t size2 = 20; +// Stack stack(size1); +// Stack stack_other(size2); +// // Assert +// EXPECT_TRUE(stack != stack_other); +//} diff --git a/tests/test_triangle_matrix.cpp b/tests/test_triangle_matrix.cpp new file mode 100644 index 00000000..8c6bd8ea --- /dev/null +++ b/tests/test_triangle_matrix.cpp @@ -0,0 +1,302 @@ +//Copyright 2025 Julia Zabytina +#include +#include +#include "../lib_triangle_matrix/triangle_matrix.h" +TEST(TestTriangleMatrixLib, tr_matrix_default_constructor) { + // Arrange & Act + TriangleMatrix matrix; + // Assert + EXPECT_EQ(0, matrix.getSize()); + EXPECT_TRUE(matrix.is_empty()); +} +TEST(TestTriangleMatrixLib, tr_matrix_constructor_with_size) { + // Arrange & Act + size_t size = 4; + TriangleMatrix matrix(size); + // Assert + EXPECT_EQ(size, matrix.getSize()); +} +TEST(TestTriangleMatrixLib, tr_matrix_constructor_with_array_and_size) { + // Arrange & Act + size_t size = 3; + int data[6] = { 1, 2, 3, 4, 5, 6 }; + TriangleMatrix matrix(data, size); + // Assert + EXPECT_EQ(size, matrix.getSize()); + EXPECT_EQ(matrix.at(0).at(0), 1); + EXPECT_EQ(matrix.at(0).at(1), 2); + EXPECT_EQ(matrix.at(0).at(2), 3); + EXPECT_EQ(matrix.at(1).at(1), 4); + EXPECT_EQ(matrix.at(1).at(2), 5); + EXPECT_EQ(matrix.at(2).at(2), 6); + EXPECT_THROW(matrix.at(1).at(0), std::logic_error); + EXPECT_THROW(matrix.at(2).at(0), std::logic_error); + EXPECT_THROW(matrix.at(2).at(1), std::logic_error); +} +TEST(TestTriangleMatrixLib, tr_matrix_copy_constructor) { + // Arrange & Act + size_t size = 3; + int data[6] = { 1, 2, 3, 4, 5, 6 }; + TriangleMatrix matrix1(data, size); + TriangleMatrix matrix2(matrix1); + // Assert + EXPECT_EQ(matrix1, matrix2); +} +TEST(TestTriangleMatrixLib, tr_matrix_operator_assignment) { + // Arrange & Act + size_t size = 3; + int data[6] = { 1, 2, 3, 4, 5, 6 }; + TriangleMatrix matrix1(data, size); + TriangleMatrix matrix2; + matrix2 = matrix1; + // Assert + EXPECT_EQ(matrix1, matrix2); +} + +TEST(TestTriangleMatrixLib, tr_matrix_mult_value) { + // Arrange + size_t size = 3; + int data[6] = { 1, 2, 3, 4, 5, 6 }; + int value = 10; + TriangleMatrix matrix(data, size); + Matrix result(size); + //Act + result = matrix * value; + // Assert + EXPECT_EQ(result.at(0).at(0), 10); + EXPECT_EQ(result.at(0).at(1), 20); + EXPECT_EQ(result.at(0).at(2), 30); + EXPECT_EQ(result.at(1).at(1), 40); + EXPECT_EQ(result.at(1).at(2), 50); + EXPECT_EQ(result.at(2).at(2), 60); +} +TEST(TestTriangleMatrixLib, tr_matrix_div_value) { + // Arrange + size_t size = 3; + int data[6] = { 2, 2, 4, 4, 8, 6 }; + int value = 2; + TriangleMatrix matrix(data, size); + Matrix result(size); + //Act + result = matrix / value; + // Assert + EXPECT_EQ(result.at(0).at(0), 1); + EXPECT_EQ(result.at(0).at(1), 1); + EXPECT_EQ(result.at(0).at(2), 2); + EXPECT_EQ(result.at(1).at(1), 2); + EXPECT_EQ(result.at(1).at(2), 4); + EXPECT_EQ(result.at(2).at(2), 3); +} +TEST(TestTriangleMatrixLib, tr_matrix_div_value_with_exception) { + // Arrange & Act + size_t size = 3; + int data[6] = { 2, 2, 4, 4, 8, 6 }; + size_t value = 0; + TriangleMatrix matrix(data, size); + // Assert + EXPECT_THROW(matrix / value, std::logic_error); +} + +TEST(TestTriangleMatrixLib, tr_matrix_mult_assign_value) { + // Arrange & Act + size_t size = 3; + int data[6] = { 1, 2, 3, 4, 5, 6 }; + int value = 10; + TriangleMatrix matrix(data, size); + matrix *= value; + // Assert + EXPECT_EQ(matrix.at(0).at(0), 10); + EXPECT_EQ(matrix.at(0).at(1), 20); + EXPECT_EQ(matrix.at(0).at(2), 30); + EXPECT_EQ(matrix.at(1).at(1), 40); + EXPECT_EQ(matrix.at(1).at(2), 50); + EXPECT_EQ(matrix.at(2).at(2), 60); +} +TEST(TestTriangleMatrixLib, tr_matrix_div_assign_value) { + // Arrange & Act + size_t size = 3; + int data[6] = { 2, 2, 4, 4, 8, 6 }; + int value = 2; + TriangleMatrix matrix(data, size); + matrix /= value; + // Assert + EXPECT_EQ(matrix.at(0).at(0), 1); + EXPECT_EQ(matrix.at(0).at(1), 1); + EXPECT_EQ(matrix.at(0).at(2), 2); + EXPECT_EQ(matrix.at(1).at(1), 2); + EXPECT_EQ(matrix.at(1).at(2), 4); + EXPECT_EQ(matrix.at(2).at(2), 3); +} +TEST(TestTriangleMatrixLib, tr_matrix_add_tr_matrix) { + // Arrange + size_t size = 3; + int data1[6] = { 2, 2, 4, 4, 8, 6 }; + int data2[6] = { 1, 1, 1, 1, 1, 1 }; + + TriangleMatrix matrix1(data1, size); + TriangleMatrix matrix2(data2, size); + TriangleMatrix result(size); + //Act + result = matrix1 + matrix2; + // Assert + EXPECT_EQ(result.at(0).at(0), 3); + EXPECT_EQ(result.at(0).at(1), 3); + EXPECT_EQ(result.at(0).at(2), 5); + EXPECT_EQ(result.at(1).at(1), 5); + EXPECT_EQ(result.at(1).at(2), 9); + EXPECT_EQ(result.at(2).at(2), 7); +} +TEST(TestTriangleMatrixLib, tr_matrix_sub_tr_matrix) { + // Arrange + size_t size = 3; + int data1[6] = { 2, 2, 4, 4, 8, 6 }; + int data2[6] = { 1, 1, 1, 1, 1, 1 }; + + TriangleMatrix matrix1(data1, size); + TriangleMatrix matrix2(data2, size); + TriangleMatrix result(size); + //Act + result = matrix1 - matrix2; + // Assert + EXPECT_EQ(result.at(0).at(0), 1); + EXPECT_EQ(result.at(0).at(1), 1); + EXPECT_EQ(result.at(0).at(2), 3); + EXPECT_EQ(result.at(1).at(1), 3); + EXPECT_EQ(result.at(1).at(2), 7); + EXPECT_EQ(result.at(2).at(2), 5); +} +TEST(TestTriangleMatrixLib, tr_matrix_add_assig_tr_matrix) { + // Arrange & Act + size_t size = 3; + int data1[6] = { 2, 2, 4, 4, 8, 6 }; + int data2[6] = { 1, 1, 1, 1, 1, 1 }; + + TriangleMatrix matrix1(data1, size); + TriangleMatrix matrix2(data2, size); + matrix1 += matrix2; + // Assert + EXPECT_EQ(matrix1.at(0).at(0), 3); + EXPECT_EQ(matrix1.at(0).at(1), 3); + EXPECT_EQ(matrix1.at(0).at(2), 5); + EXPECT_EQ(matrix1.at(1).at(1), 5); + EXPECT_EQ(matrix1.at(1).at(2), 9); + EXPECT_EQ(matrix1.at(2).at(2), 7); +} +TEST(TestTriangleMatrixLib, tr_matrix_sub_assig_tr_matrix) { + // Arrange & Act + size_t size = 3; + int data1[6] = { 2, 2, 4, 4, 8, 6 }; + int data2[6] = { 1, 1, 1, 1, 1, 1 }; + + TriangleMatrix matrix1(data1, size); + TriangleMatrix matrix2(data2, size); + matrix1 -= matrix2; + // Assert + EXPECT_EQ(matrix1.at(0).at(0), 1); + EXPECT_EQ(matrix1.at(0).at(1), 1); + EXPECT_EQ(matrix1.at(0).at(2), 3); + EXPECT_EQ(matrix1.at(1).at(1), 3); + EXPECT_EQ(matrix1.at(1).at(2), 7); + EXPECT_EQ(matrix1.at(2).at(2), 5); +} +TEST(TestTriangleMatrixLib, tr_matrix_add_tr_matrix_with_exception) { + // Arrange & Act + + int data1[6] = { 2, 2, 4, 4, 8, 6 }; + int data2[4] = { 1, 1, 1, 1 }; + + TriangleMatrix matrix1(data1, 3); + TriangleMatrix matrix2(data2, 2); + + // Assert + EXPECT_THROW(matrix1 + matrix2, std::logic_error); +} +TEST(TestTriangleMatrixLib, tr_matrix_sub_tr_matrix_with_exception) { + // Arrange & Act + + int data1[6] = { 2, 2, 4, 4, 8, 6 }; + int data2[4] = { 1, 1, 1, 1 }; + + TriangleMatrix matrix1(data1, 3); + TriangleMatrix matrix2(data2, 2); + + // Assert + EXPECT_THROW(matrix1 - matrix2, std::logic_error); +} +TEST(TestTriangleMatrixLib, tr_matrix_add_assign_tr_matrix_with_exception) { + // Arrange & Act + + int data1[6] = { 2, 2, 4, 4, 8, 6 }; + int data2[4] = { 1, 1, 1, 1 }; + + TriangleMatrix matrix1(data1, 3); + TriangleMatrix matrix2(data2, 2); + + // Assert + EXPECT_THROW(matrix1 += matrix2, std::logic_error); +} +TEST(TestTriangleMatrixLib, tr_matrix_sub_assign_tr_matrix_with_exception) { + // Arrange & Act + + int data1[6] = { 2, 2, 4, 4, 8, 6 }; + int data2[4] = { 1, 1, 1, 1 }; + + TriangleMatrix matrix1(data1, 3); + TriangleMatrix matrix2(data2, 2); + + // Assert + EXPECT_THROW(matrix1 -= matrix2, std::logic_error); +} +TEST(TestTriangleMatrixLib, tr_matrix_mult_vector) { + // Arrange + int data1[6] = { 2, 2, 4, 4, 8, 6 }; + int data2[3] = { 1, 1, 1 }; + + TriangleMatrix matrix(data1, 3); + MathVector vector(data2, 3); + MathVector result(3); + //Act + result = matrix * vector; + // Assert + EXPECT_EQ(result.at(0), 8); + EXPECT_EQ(result.at(1), 12); + EXPECT_EQ(result.at(2), 6); +} +TEST(TestTriangleMatrixLib, tr_matrix_mult_vector_with_exception) { + // Arrange & Act + int data1[6] = { 2, 2, 4, 4, 8, 6 }; + int data2[10] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }; + TriangleMatrix matrix(data1, 3); + MathVector vector(data2, 10); + MathVector result(3); + // Assert + EXPECT_THROW(matrix * vector, std::logic_error); +} +TEST(TestTriangleMatrixLib, tr_matrix_mult_tr_matrix) { + // Arrange + size_t size = 3; + int data1[6] = { 2, 2, 4, 4, 8, 6 }; + int data2[6] = { 1, 1, 1, 1, 1, 1 }; + TriangleMatrix matrix1(data1, size); + TriangleMatrix matrix2(data2, size); + TriangleMatrix result(size); + //Act + result = matrix1 * matrix2; + // Assert + EXPECT_EQ(result.at(0).at(0), 2); + EXPECT_EQ(result.at(0).at(1), 4); + EXPECT_EQ(result.at(0).at(2), 8); + EXPECT_EQ(result.at(1).at(1), 4); + EXPECT_EQ(result.at(1).at(2), 12); + EXPECT_EQ(result.at(2).at(2), 6); +} +TEST(TestTriangleMatrixLib, tr_matrix_mult_tr_matrix_with_exception) { + // Arrange & Act + int data1[6] = { 2, 2, 4, 4, 8, 6 }; + int data2[8] = { 1, 1, 1, 1, 1, 1, 1, 1 }; + TriangleMatrix matrix1(data1, 3); + TriangleMatrix matrix2(data2, 4); + TriangleMatrix result(3); + // Assert + EXPECT_THROW(matrix1 * matrix2, std::logic_error); +} diff --git a/tests/test_vector.cpp b/tests/test_vector.cpp new file mode 100644 index 00000000..e003e79e --- /dev/null +++ b/tests/test_vector.cpp @@ -0,0 +1,519 @@ +// Copyright 2025 Julia Zabytina +#include +#include "../lib_vector/vector.h" +TEST(TestVectorLib, vector_default_constructor) { + // Arrange & Act + Tvector vector; + // Assert + EXPECT_TRUE(vector.is_empty()); +} +TEST(TestVectorLib, vector_constructor_with_size) { + // Arrange & Act + size_t size = 10; + Tvector vector(size); + // Assert + EXPECT_LE(vector.get_size(), vector.get_capacity()); + EXPECT_EQ(vector.get_size(), size); +} +TEST(TestVectorLib, vector_constructor_with_array_and_size) { + // Arrange & Act + int data[3] = { 1,2,3 }; + size_t size = 3; + Tvector vector(data, size); + // Assert + EXPECT_EQ(vector.get_size(), size); + EXPECT_EQ(vector[0], data[0]); + EXPECT_EQ(vector[1], data[1]); + EXPECT_EQ(vector[2], data[2]); + EXPECT_LE(vector.get_size(), vector.get_capacity()); +} +TEST(TestVectorLib, vector_copy_constructor) { + // Arrange & Act + int data[3] = { 1,2,3 }; + size_t size = 3; + Tvector old_vector(data, size); + Tvector new_vector(old_vector); + // Assert + EXPECT_EQ(old_vector, new_vector); +} +TEST(TestVectorLib, is_empty) { + // Arrange + Tvector vector; + // Act + bool actual_result = vector.is_empty(); + // Assert + bool expected_result = true; + EXPECT_EQ(expected_result, actual_result); +} +TEST(TestVectorLib, get_data) { + // Arrange + int data[3] = { 1,2,3 }; + size_t size = 3; + Tvector vector(data, size); + int* data_ptr = data; + bool different_pointers = data_ptr != vector.get_data(); + bool same_data = + data[0] == vector.get_data()[0] + && data[1] == vector.get_data()[1] + && data[2] == vector.get_data()[2]; + // Act + bool actual_result = different_pointers && same_data; + // Assert + bool expected_result = true; + EXPECT_EQ(expected_result, actual_result); +} +TEST(TestVectorLib, front) { + // Arrange + int data[3] = { 1,2,3 }; + size_t size = 3; + Tvector vector(data, size); + // Act + int actual_result = vector.front(); + // Assert + int expected_result = vector.get_data()[0]; + EXPECT_EQ(expected_result, actual_result); +} +TEST(TestVectorLib, back) { + // Arrange + int data[3] = { 1,2,3 }; + size_t size = 3; + Tvector vector(data, size); + // Act + int actual_result = vector.back(); + // Assert + int expected_result = vector.get_data()[vector.get_size() - 1]; + EXPECT_EQ(expected_result, actual_result); +} +TEST(TestVectorLib, get_size) { + // Arrange + int data[3] = { 1,2,3 }; + size_t size = 3; + Tvector vector(data, size); + // Act + size_t actual_result = vector.get_size(); + // Assert + size_t expected_result = size; + EXPECT_EQ(expected_result, actual_result); +} +TEST(TestVectorLib, get_deleted) { + // Arrange + int data[3] = { 1,2,3 }; + size_t size = 3; + size_t deleted = 0; + Tvector vector(data, size); + // Act + size_t actual_result = vector.get_deleted(); + // Assert + size_t expected_result = deleted; + EXPECT_EQ(expected_result, actual_result); +} +TEST(TestVectorLib, get_capacity) { + // Arrange + int data[3] = { 1,2,3 }; + size_t size = 3; + size_t capacity = 18; + Tvector vector(data, size); + // Act + size_t actual_result = vector.get_capacity(); + // Assert + size_t expected_result = capacity; + EXPECT_EQ(expected_result, actual_result); +} +TEST(TestVectorLib, get_begin) { + // Arrange + int data[3] = { 1,2,3 }; + size_t size = 3; + Tvector vector(data, size); + // Act + int* actual_result = vector.begin(); + // Assert + int* expected_result = &(vector.get_data()[0]); + EXPECT_EQ(expected_result, actual_result); +} +TEST(TestVectorLib, get_end) { + // Arrange + int data[3] = { 1,2,3 }; + size_t size = 3; + Tvector vector(data, size); + // Act + int* actual_result = vector.end(); + // Assert + int* expected_result = &(vector.get_data()[0]) + size; + EXPECT_EQ(expected_result, actual_result); +} +TEST(TestVectorLib, comparison_operator_true) { + // Arrange + int data[3] = { 1,2,3 }; + size_t size = 3; + Tvector vector1(data, size); + Tvector vector2(data, size); + // Act + bool actual_result = vector1 == vector2; + // Assert + bool expected_result = true; + EXPECT_EQ(expected_result, actual_result); +} +TEST(TestVectorLib, comparison_operator_false) { + // Arrange + int data1[3] = { 1,2,3 }; + size_t size1 = 3; + int data2[4] = { 1,2,3,4 }; + size_t size2 = 4; + Tvector vector1(data1, size1); + Tvector vector2(data2, size2); + // Act + bool actual_result = vector1 == vector2; + // Assert + bool expected_result = false; + EXPECT_EQ(expected_result, actual_result); +} +TEST(TestVectorLib, not_comparison_operator_true) { + // Arrange + int data1[3] = { 1,2,3 }; + size_t size1 = 3; + int data2[4] = { 1,2,3,4 }; + size_t size2 = 4; + Tvector vector1(data1, size1); + Tvector vector2(data2, size2); + // Act + bool actual_result = vector1 != vector2; + // Assert + bool expected_result = true; + EXPECT_EQ(expected_result, actual_result); +} +TEST(TestVectorLib, not_comparison_operator_false) { + // Arrange + int data[3] = { 1,2,3 }; + size_t size = 3; + Tvector vector1(data, size); + Tvector vector2(data, size); + // Act + bool actual_result = vector1 != vector2; + // Assert + bool expected_result = false; + EXPECT_EQ(expected_result, actual_result); +} +TEST(TestVectorLib, operator_assign) { + // Arrange + int data1[3] = { 1,2,3 }; + size_t size1 = 3; + int data2[4] = { 1,2,3,4 }; + size_t size2 = 4; + Tvector vector1(data1, size1); + Tvector vector2(data2, size2); + vector1 = vector2; + // Act + bool actual_result = vector1 == vector2; + // Assert + bool expected_result = true; + EXPECT_EQ(expected_result, actual_result); +} +TEST(TestVectorLib, operator_staples) { + // Arrange + int data[3] = { 1,2,3 }; + size_t size = 3; + Tvector vector(data, size); + // Act + int actual_result = vector[1]; + // Assert + int expected_result = data[1]; + EXPECT_EQ(expected_result, actual_result); +} +TEST(TestVectorLib, at) { + // Arrange + int data[3] = { 1,2,3 }; + size_t size = 3; + Tvector vector(data, size); + // Act + int actual_result = vector.at(1); + // Assert + int expected_result = data[1]; + EXPECT_EQ(expected_result, actual_result); +} +TEST(TestVectorLib, assign) { + // Arrange + int data[3] = { 1,1,1 }; + size_t size = 3; + Tvector vector1; + Tvector vector2(data, size); + vector1.assign(vector2); + // Act + Tvector actual_result = vector1; + // Assert + Tvector expected_result = vector2; + EXPECT_EQ(expected_result, actual_result); +} +TEST(TestVectorLib, clear) { + // Arrange + int data[3] = { 1, 2, 3 }; + Tvector vector(data, 3); + + // Act + vector.clear(); + + // Assert + EXPECT_EQ(0, vector.get_size()); + EXPECT_EQ(0, vector.get_deleted()); +} +TEST(TestVectorLib, emplace) { + // Arrange + int data[3] = { 1,2,3 }; + size_t size = 3; + Tvector vector(data, size); + vector.emplace(2, 100); + // Act + int actual_result = vector[2]; + // Assert + int expected_result = 100; + EXPECT_EQ(expected_result, actual_result); +} +TEST(TestVectorLib, push_front1) { + // Arrange + int data[3] = { 1,2,3 }; + size_t size = 3; + Tvector vector(data, size); + vector.push_front(200); + // Act + int actual_result = vector[0]; + // Assert + int expected_result = 200; + EXPECT_EQ(expected_result, actual_result); +} +TEST(TestVectorLib, push_front2) { + // Arrange + int data[1] = { 1 }; + size_t size = 1; + Tvector vector(data, size); + for (size_t i = 1; i < 17; ++i) { + vector.push_front(1); + } + // Act + bool actual_result = vector.get_capacity() == 31 + && vector.get_size() == 17; + // Assert + bool expected_result = true; + EXPECT_EQ(expected_result, actual_result); +} +TEST(TestVectorLib, insert1) { + // Arrange + int data[6] = { 1, 2, 3, 4, 5, 6 }; + size_t size = 6; + Tvector vector(data, size); + vector.insert(225, 5); + // Act + int actual_result = vector[5]; + // Assert + int expected_result = 225; + EXPECT_EQ(expected_result, actual_result); +} +TEST(TestVectorLib, insert2) { + // Arrange + size_t size = 10; + Tvector vector(size); + vector.insert(225, 5); + // Act + int actual_result = vector[5]; + // Assert + int expected_result = 225; + EXPECT_EQ(expected_result, actual_result); +} +TEST(TestVectorLib, insert3) { + // Arrange + Tvector vector; + vector.insert(225, 5); + // Act + int actual_result = vector[5]; + // Assert + int expected_result = 225; + EXPECT_EQ(expected_result, actual_result); +} +TEST(TestVectorLib, insert4) { + // Arrange + bool actual_result = true; + int data[5] = { 1, 2, 3, 4, 5 }; + size_t size = 5; + Tvector vector(data, size); + try { + vector.insert(225, 5); + } + catch (...) { + actual_result = false; + } + // Assert + bool expected_result = false; + EXPECT_EQ(expected_result, actual_result); +} +TEST(TestVectorLib, push_back1) { + // Arrange + int data[1] = { 1 }; + size_t size = 1; + Tvector vector(data, size); + for (size_t i = 1; i < 17; ++i) { + vector.push_back(400); + } + // Act + int actual_result = vector[5]; + // Assert + int expected_result = 400; + EXPECT_EQ(expected_result, actual_result); +} +TEST(TestVectorLib, push_back2) { + // Arrange + int data[3] = { 1, 2, 3 }; + size_t size = 3; + Tvector vector(data, size); + vector.push_back(9); + // Act + int actual_result = vector[3]; + // Assert + int expected_result = 9; + EXPECT_EQ(expected_result, actual_result); +} +TEST(TestVectorLib, pop_back1) { + // Arrange + int data[3] = { 1,2,3 }; + size_t size = 3; + Tvector vector(data, size); + vector.pop_back(); + // Act + bool actual_result = vector.get_size() == 2 + && vector[0] == 1 + && vector[1] == 2; + // Assert + bool expected_result = true; + EXPECT_EQ(expected_result, actual_result); +} +TEST(TestVectorLib, pop_back2) { + // Arrange + bool actual_result = true; + Tvector vector; + try { + vector.pop_back(); + } + catch (...) { + actual_result = false; + } + // Assert + bool expected_result = false; + EXPECT_EQ(expected_result, actual_result); +} +TEST(TestVectorLib, erase1) { + // Arrange + int data[15] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }; + size_t size = 15; + Tvector vector(data, size); + vector.erase(1); + vector.erase(1); + // Act + size_t actual_result = vector.get_deleted(); + // Assert + size_t expected_result = 2; + EXPECT_EQ(expected_result, actual_result); +} +TEST(TestVectorLib, erase2) { + // Arrange + int data[15] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }; + size_t size = 15; + Tvector vector(data, size); + vector.erase(1); + vector.erase(1); + vector.erase(1); + // Act + bool actual_result = vector.get_deleted() == 0 + && vector.get_size() == 12 + && vector.get_capacity() == 27; + // Assert + bool expected_result = true; + EXPECT_EQ(expected_result, actual_result); +} +TEST(TestVectorLib, erase3) { + // Arrange + bool actual_result = true; + int data[15] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }; + size_t size = 15; + Tvector vector(data, size); + try { + vector.erase(20); + } + catch (...) { + actual_result = false; + } + // Assert + bool expected_result = false; + EXPECT_EQ(expected_result, actual_result); +} +TEST(TestVectorLib, pop_front1) { + // Arrange + int data[3] = { 1,2,3 }; + size_t size = 3; + Tvector vector(data, size); + vector.pop_front(); + // Act + bool actual_result = vector.get_size() == 2 + && vector[0] == 2 + && vector[1] == 3; + // Assert + bool expected_result = true; + EXPECT_EQ(expected_result, actual_result); +} +TEST(TestVectorLib, pop_front2) { + // Arrange + bool actual_result = true; + Tvector vector; + try { + vector.pop_front(); + } + catch (...) { + actual_result = false; + } + // Assert + bool expected_result = false; + EXPECT_EQ(expected_result, actual_result); +} +TEST(TestVectorLib, sort_of_shell) { + // Arrange + int data[10] = { 1223343, 1546, 8777, 1000, 2, 3, 7, 9, 888, 99 }; + size_t size = 10; + Tvector vector(data, size); + int sorted_data[10] = { 2, 3, 7, 9, 99, 888, 1000, 1546, 8777, 1223343 }; + Tvector sorted_vector(sorted_data, size); + shell_sort(vector); + // Act + Tvector actual_result = vector; + // Assert + Tvector expected_result = sorted_vector; + EXPECT_EQ(expected_result, actual_result); +} +TEST(TestVectorLib, find_first) { + // Arrange + int data[6] = { 1 ,3, 3, 4, 5, 3 }; + size_t size = 6; + Tvector vector(data, size); + // Act + size_t actual_result = find_first_element(vector, 3); + // Assert + size_t expected_result = 2; + EXPECT_EQ(expected_result, actual_result); +} +TEST(TestVectorLib, find_last) { + // Arrange + int data[6] = { 1 ,3, 3, 4, 5, 3 }; + size_t size = 6; + Tvector vector(data, size); + // Act + size_t actual_result = find_last_element(vector, 3); + // Assert + size_t expected_result = 6; + EXPECT_EQ(expected_result, actual_result); +} +TEST(TestVectorLib, find_count_of_suitable_elements) { + // Arrange + int data[8] = { 1 ,3, 3, 4, 5, 3, 3, 7 }; + size_t size = 8; + Tvector vector(data, size); + // Act + size_t actual_result = find_count_of_all_suitable_elements(vector, 3); + // Assert + size_t expected_result = 4; + EXPECT_EQ(expected_result, actual_result); +}