From 9e95812746e363e6c756f3fe87be78b5b9e87a04 Mon Sep 17 00:00:00 2001 From: nastyalabs <112377160+nastyalabs@users.noreply.github.com> Date: Thu, 25 Sep 2025 16:49:51 +0300 Subject: [PATCH 1/8] Add files via upload --- CMakeLists.txt | 37 +++++++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) create mode 100644 CMakeLists.txt diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 000000000..92ed171d3 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,37 @@ +cmake_minimum_required(VERSION 2.8) + +set(PROJECT_NAME matrix) +project(${PROJECT_NAME}) + +# TODO(Kornyakov): not sure if these lines are needed +set(CMAKE_CONFIGURATION_TYPES "Debug;Release" CACHE STRING "Configs" FORCE) +if(NOT CMAKE_BUILD_TYPE) + set(CMAKE_BUILD_TYPE Release) +endif() + +set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib) +set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib) +set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE ${CMAKE_BINARY_DIR}/bin) +set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG ${CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE}) + +#set(MP2_LIBRARY "${PROJECT_NAME}") +set(MP2_CUSTOM "${PROJECT_NAME}") +set(MP2_TESTS "test_${PROJECT_NAME}") +set(MP2_INCLUDE "${CMAKE_CURRENT_SOURCE_DIR}/include") + +include_directories("${MP2_INCLUDE}" gtest) + +# BUILD +add_subdirectory(include) +#add_subdirectory(src) +add_subdirectory(samples) +add_subdirectory(gtest) +add_subdirectory(test) + +# REPORT +message( STATUS "") +message( STATUS "General configuration for ${PROJECT_NAME}") +message( STATUS "======================================") +message( STATUS "") +message( STATUS " Configuration: ${CMAKE_BUILD_TYPE}") +message( STATUS "") \ No newline at end of file From 98d65d85e7463f248110c285443f60c319245816 Mon Sep 17 00:00:00 2001 From: nastyalabs <112377160+nastyalabs@users.noreply.github.com> Date: Thu, 25 Sep 2025 16:50:15 +0300 Subject: [PATCH 2/8] Add files via upload --- include/CMakeLists.txt | 5 +++++ 1 file changed, 5 insertions(+) create mode 100644 include/CMakeLists.txt diff --git a/include/CMakeLists.txt b/include/CMakeLists.txt new file mode 100644 index 000000000..c3c83ffd3 --- /dev/null +++ b/include/CMakeLists.txt @@ -0,0 +1,5 @@ +set(target ${MP2_CUSTOM}) + +file(GLOB hdrs "*.h*") + +add_custom_target(${target} SOURCES ${hdrs}) \ No newline at end of file From d87f1b40132fd0417eb0ec1672f556bb35d2e649 Mon Sep 17 00:00:00 2001 From: nastyalabs <112377160+nastyalabs@users.noreply.github.com> Date: Thu, 25 Sep 2025 16:50:41 +0300 Subject: [PATCH 3/8] Add files via upload --- samples/CMakeLists.txt | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 samples/CMakeLists.txt diff --git a/samples/CMakeLists.txt b/samples/CMakeLists.txt new file mode 100644 index 000000000..ed46fffd5 --- /dev/null +++ b/samples/CMakeLists.txt @@ -0,0 +1,16 @@ +# Get all cpp-files in the current directory +file(GLOB samples_list RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp) + + +foreach(sample_filename ${samples_list}) + # Get file name without extension + get_filename_component(sample ${sample_filename} NAME_WE) + + # Add and configure executable file to be produced + add_executable(${sample} ${sample_filename}) + target_link_libraries(${sample} ${MP2_LIBRARY}) + set_target_properties(${sample} PROPERTIES + OUTPUT_NAME "${sample}" + PROJECT_LABEL "${sample}" + RUNTIME_OUTPUT_DIRECTORY "../") +endforeach() From c3a14dcbbc4c332378b1f8c3eac9654e9bc34f32 Mon Sep 17 00:00:00 2001 From: nastyalabs <112377160+nastyalabs@users.noreply.github.com> Date: Thu, 25 Sep 2025 16:51:07 +0300 Subject: [PATCH 4/8] Add files via upload --- gtest/CMakeLists.txt | 11 +++++++++++ 1 file changed, 11 insertions(+) create mode 100644 gtest/CMakeLists.txt diff --git a/gtest/CMakeLists.txt b/gtest/CMakeLists.txt new file mode 100644 index 000000000..347e4d5c6 --- /dev/null +++ b/gtest/CMakeLists.txt @@ -0,0 +1,11 @@ +set(target "gtest") + +add_library(${target} STATIC gtest-all.cc) + +if((${CMAKE_CXX_COMPILER_ID} MATCHES "GNU" OR + ${CMAKE_CXX_COMPILER_ID} MATCHES "Clang") AND + (${CMAKE_SYSTEM_NAME} MATCHES "Linux")) + set(pthread "-pthread") +endif() + +target_link_libraries(${target} ${pthread}) From fe2f396613024783b14da175e0d9712dcebc761a Mon Sep 17 00:00:00 2001 From: nastyalabs <112377160+nastyalabs@users.noreply.github.com> Date: Thu, 25 Sep 2025 16:51:33 +0300 Subject: [PATCH 5/8] Add files via upload --- test/CMakeLists.txt | 9 +++++++++ 1 file changed, 9 insertions(+) create mode 100644 test/CMakeLists.txt diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt new file mode 100644 index 000000000..cbf55b107 --- /dev/null +++ b/test/CMakeLists.txt @@ -0,0 +1,9 @@ +set(target ${MP2_TESTS}) + +file(GLOB hdrs "*.h*") +file(GLOB srcs "*.cpp") + +include_directories("${CMAKE_CURRENT_SOURCE_DIR}/../3rdparty") + +add_executable(${target} ${srcs} ${hdrs}) +target_link_libraries(${target} gtest ${MP2_LIBRARY}) \ No newline at end of file From dd6e787f17a9abdb55403595db673ef6b9621986 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=92=D0=BE=D0=B4=D0=B5=D0=BD=D0=B5=D0=B5=D0=B2=D0=B0=20?= =?UTF-8?q?=D0=90=D0=BD=D0=B0=D1=81=D1=82=D0=B0=D1=81=D0=B8=D1=8F=20=D0=90?= =?UTF-8?q?=D0=BB=D0=B5=D0=BA=D1=81=D0=B0=D0=BD=D0=B4=D1=80=D0=BE=D0=B2?= =?UTF-8?q?=D0=BD=D0=B0?= Date: Thu, 16 Oct 2025 13:18:42 +0300 Subject: [PATCH 6/8] my_commit --- include/tmatrix.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/tmatrix.h b/include/tmatrix.h index a1eaa2cf2..f810a9d2a 100644 --- a/include/tmatrix.h +++ b/include/tmatrix.h @@ -11,7 +11,7 @@ using namespace std; -const int MAX_VECTOR_SIZE = 100000000; +const int MAX_VECTOR_SIZE = 555555555555550; const int MAX_MATRIX_SIZE = 10000; // Динамический вектор - From 9ea222b988211510f40d24a934384948f1abf3c6 Mon Sep 17 00:00:00 2001 From: nastyalabs <112377160+nastyalabs@users.noreply.github.com> Date: Thu, 16 Oct 2025 13:20:41 +0300 Subject: [PATCH 7/8] Update tmatrix.h --- include/tmatrix.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/tmatrix.h b/include/tmatrix.h index f810a9d2a..a1eaa2cf2 100644 --- a/include/tmatrix.h +++ b/include/tmatrix.h @@ -11,7 +11,7 @@ using namespace std; -const int MAX_VECTOR_SIZE = 555555555555550; +const int MAX_VECTOR_SIZE = 100000000; const int MAX_MATRIX_SIZE = 10000; // Динамический вектор - From 9d2e7c761576871a64375b8d8dd2a574171dc033 Mon Sep 17 00:00:00 2001 From: prokoffed Date: Tue, 9 Dec 2025 17:03:37 +0300 Subject: [PATCH 8/8] =?UTF-8?q?=D0=9B=D0=B0=D0=B1=202:=20=D0=9F=D1=80?= =?UTF-8?q?=D0=BE=D0=BA=D0=BE=D1=84=D1=8C=D0=B5=D0=B2=D0=B0=20=D0=94.?= =?UTF-8?q?=D0=90.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- include/tmatrix.h | 450 +++++++++++++++++++++++++++++------------- test/test_tmatrix.cpp | 145 +++++++++++--- test/test_tvector.cpp | 136 +++++++++---- 3 files changed, 529 insertions(+), 202 deletions(-) diff --git a/include/tmatrix.h b/include/tmatrix.h index a1eaa2cf2..3246c0174 100644 --- a/include/tmatrix.h +++ b/include/tmatrix.h @@ -8,6 +8,8 @@ #define __TDynamicMatrix_H__ #include +#include +#include using namespace std; @@ -20,103 +22,195 @@ template class TDynamicVector { protected: - size_t sz; - T* pMem; + size_t sz; + T* pMem; public: - TDynamicVector(size_t size = 1) : sz(size) - { - if (sz == 0) - throw out_of_range("Vector size should be greater than zero"); - pMem = new T[sz]();// {}; // У типа T д.б. констуктор по умолчанию - } - TDynamicVector(T* arr, size_t s) : sz(s) - { - assert(arr != nullptr && "TDynamicVector ctor requires non-nullptr arg"); - pMem = new T[sz]; - std::copy(arr, arr + sz, pMem); - } - TDynamicVector(const TDynamicVector& v) - { - } - TDynamicVector(TDynamicVector&& v) noexcept - { - } - ~TDynamicVector() - { - } - TDynamicVector& operator=(const TDynamicVector& v) - { - } - TDynamicVector& operator=(TDynamicVector&& v) noexcept - { - } - - size_t size() const noexcept { return sz; } - - // индексация - T& operator[](size_t ind) - { - } - const T& operator[](size_t ind) const - { - } - // индексация с контролем - T& at(size_t ind) - { - } - const T& at(size_t ind) const - { - } - - // сравнение - bool operator==(const TDynamicVector& v) const noexcept - { - } - bool operator!=(const TDynamicVector& v) const noexcept - { - } - - // скалярные операции - TDynamicVector operator+(T val) - { - } - TDynamicVector operator-(T val) - { - } - TDynamicVector operator*(T val) - { - } - - // векторные операции - TDynamicVector operator+(const TDynamicVector& v) - { - } - TDynamicVector operator-(const TDynamicVector& v) - { - } - T operator*(const TDynamicVector& v) noexcept(noexcept(T())) - { - } - - friend void swap(TDynamicVector& lhs, TDynamicVector& rhs) noexcept - { - std::swap(lhs.sz, rhs.sz); - std::swap(lhs.pMem, rhs.pMem); - } - - // ввод/вывод - friend istream& operator>>(istream& istr, TDynamicVector& v) - { - for (size_t i = 0; i < v.sz; i++) - istr >> v.pMem[i]; // требуется оператор>> для типа T - return istr; - } - friend ostream& operator<<(ostream& ostr, const TDynamicVector& v) - { - for (size_t i = 0; i < v.sz; i++) - ostr << v.pMem[i] << ' '; // требуется оператор<< для типа T - return ostr; - } + TDynamicVector(size_t size = 1) : sz(size) + { + if (sz == 0) + throw out_of_range("Vector size should be greater than zero"); + if (sz > MAX_VECTOR_SIZE) + throw out_of_range("Vector size too large"); + pMem = new T[sz](); + } + + TDynamicVector(T* arr, size_t s) : sz(s) + { + assert(arr != nullptr && "TDynamicVector ctor requires non-nullptr arg"); + if (sz > MAX_VECTOR_SIZE) + throw out_of_range("Vector size too large"); + pMem = new T[sz]; + for (size_t i = 0; i < sz; i++) + pMem[i] = arr[i]; + } + + TDynamicVector(const TDynamicVector& v) : sz(v.sz) + { + pMem = new T[sz]; + for (size_t i = 0; i < sz; i++) + pMem[i] = v.pMem[i]; + } + + TDynamicVector(TDynamicVector&& v) noexcept : sz(v.sz), pMem(v.pMem) + { + v.pMem = nullptr; + v.sz = 0; + } + + ~TDynamicVector() + { + delete[] pMem; + } + + TDynamicVector& operator=(const TDynamicVector& v) + { + if (this == &v) return *this; + + if (sz != v.sz) { + delete[] pMem; + sz = v.sz; + pMem = new T[sz]; + } + + for (size_t i = 0; i < sz; i++) + pMem[i] = v.pMem[i]; + + return *this; + } + + TDynamicVector& operator=(TDynamicVector&& v) noexcept + { + if (this != &v) { + delete[] pMem; + sz = v.sz; + pMem = v.pMem; + v.pMem = nullptr; + v.sz = 0; + } + return *this; + } + + size_t size() const noexcept { return sz; } + + // индексация + T& operator[](size_t ind) + { + return pMem[ind]; + } + + const T& operator[](size_t ind) const + { + return pMem[ind]; + } + + // индексация с контролем + T& at(size_t ind) + { + if (ind >= sz) + throw out_of_range("Index out of range"); + return pMem[ind]; + } + + const T& at(size_t ind) const + { + if (ind >= sz) + throw out_of_range("Index out of range"); + return pMem[ind]; + } + + // сравнение + bool operator==(const TDynamicVector& v) const noexcept + { + if (sz != v.sz) return false; + for (size_t i = 0; i < sz; i++) + if (pMem[i] != v.pMem[i]) return false; + return true; + } + + bool operator!=(const TDynamicVector& v) const noexcept + { + return !(*this == v); + } + + // скалярные операции + TDynamicVector operator+(T val) + { + TDynamicVector res(sz); + for (size_t i = 0; i < sz; i++) + res.pMem[i] = pMem[i] + val; + return res; + } + + TDynamicVector operator-(T val) + { + TDynamicVector res(sz); + for (size_t i = 0; i < sz; i++) + res.pMem[i] = pMem[i] - val; + return res; + } + + TDynamicVector operator*(T val) + { + TDynamicVector res(sz); + for (size_t i = 0; i < sz; i++) + res.pMem[i] = pMem[i] * val; + return res; + } + + // векторные операции + TDynamicVector operator+(const TDynamicVector& v) + { + if (sz != v.sz) + throw invalid_argument("Vector sizes don't match for addition"); + + TDynamicVector res(sz); + for (size_t i = 0; i < sz; i++) + res.pMem[i] = pMem[i] + v.pMem[i]; + return res; + } + + TDynamicVector operator-(const TDynamicVector& v) + { + if (sz != v.sz) + throw invalid_argument("Vector sizes don't match for subtraction"); + + TDynamicVector res(sz); + for (size_t i = 0; i < sz; i++) + res.pMem[i] = pMem[i] - v.pMem[i]; + return res; + } + + T operator*(const TDynamicVector& v) noexcept(noexcept(T())) + { + if (sz != v.sz) + throw invalid_argument("Vector sizes don't match for dot product"); + + T res = T(); + for (size_t i = 0; i < sz; i++) + res += pMem[i] * v.pMem[i]; + return res; + } + + friend void swap(TDynamicVector& lhs, TDynamicVector& rhs) noexcept + { + std::swap(lhs.sz, rhs.sz); + std::swap(lhs.pMem, rhs.pMem); + } + + // ввод/вывод + friend istream& operator>>(istream& istr, TDynamicVector& v) + { + for (size_t i = 0; i < v.sz; i++) + istr >> v.pMem[i]; + return istr; + } + + friend ostream& operator<<(ostream& ostr, const TDynamicVector& v) + { + for (size_t i = 0; i < v.sz; i++) + ostr << v.pMem[i] << ' '; + return ostr; + } }; @@ -125,50 +219,128 @@ class TDynamicVector template class TDynamicMatrix : private TDynamicVector> { - using TDynamicVector>::pMem; - using TDynamicVector>::sz; + using TDynamicVector>::pMem; + using TDynamicVector>::sz; public: - TDynamicMatrix(size_t s = 1) : TDynamicVector>(s) - { - for (size_t i = 0; i < sz; i++) - pMem[i] = TDynamicVector(sz); - } - - using TDynamicVector>::operator[]; - - // сравнение - bool operator==(const TDynamicMatrix& m) const noexcept - { - } - - // матрично-скалярные операции - TDynamicMatrix operator*(const T& val) - { - } - - // матрично-векторные операции - TDynamicVector operator*(const TDynamicVector& v) - { - } - - // матрично-матричные операции - TDynamicMatrix operator+(const TDynamicMatrix& m) - { - } - TDynamicMatrix operator-(const TDynamicMatrix& m) - { - } - TDynamicMatrix operator*(const TDynamicMatrix& m) - { - } - - // ввод/вывод - friend istream& operator>>(istream& istr, TDynamicMatrix& v) - { - } - friend ostream& operator<<(ostream& ostr, const TDynamicMatrix& v) - { - } + TDynamicMatrix(size_t s = 1) : TDynamicVector>(s) + { + if (s > MAX_MATRIX_SIZE) + throw out_of_range("Matrix size too large"); + + for (size_t i = 0; i < sz; i++) + pMem[i] = TDynamicVector(sz); + } + + using TDynamicVector>::operator[]; + + size_t size() const noexcept { return sz; } + + TDynamicVector& operator[](size_t row) + { + if (row >= sz) + throw out_of_range("Matrix row index out of range"); + return pMem[row]; + } + + const TDynamicVector& operator[](size_t row) const + { + if (row >= sz) + throw out_of_range("Matrix row index out of range"); + return pMem[row]; + } + + // сравнение + bool operator==(const TDynamicMatrix& m) const noexcept + { + if (sz != m.sz) return false; + for (size_t i = 0; i < sz; i++) + if (pMem[i] != m.pMem[i]) return false; + return true; + } + + bool operator!=(const TDynamicMatrix& m) const noexcept + { + return !(*this == m); + } + + // матрично-скалярные операции + TDynamicMatrix operator*(const T& val) + { + TDynamicMatrix res(sz); + for (size_t i = 0; i < sz; i++) + res[i] = pMem[i] * val; + return res; + } + + // матрично-векторные операции + TDynamicVector operator*(const TDynamicVector& v) + { + if (sz != v.size()) + throw invalid_argument("Matrix and vector sizes don't match for multiplication"); + + TDynamicVector res(sz); + for (size_t i = 0; i < sz; i++) + res[i] = pMem[i] * v; + return res; + } + + // матрично-матричные операции + TDynamicMatrix operator+(const TDynamicMatrix& m) + { + if (sz != m.sz) + throw invalid_argument("Matrix sizes don't match for addition"); + + TDynamicMatrix res(sz); + for (size_t i = 0; i < sz; i++) + res[i] = pMem[i] + m.pMem[i]; + return res; + } + + TDynamicMatrix operator-(const TDynamicMatrix& m) + { + if (sz != m.sz) + throw invalid_argument("Matrix sizes don't match for subtraction"); + + TDynamicMatrix res(sz); + for (size_t i = 0; i < sz; i++) + res[i] = pMem[i] - m.pMem[i]; + return res; + } + + TDynamicMatrix operator*(const TDynamicMatrix& m) + { + if (sz != m.sz) + throw invalid_argument("Matrix sizes don't match for multiplication"); + + TDynamicMatrix res(sz); + for (size_t i = 0; i < sz; i++) { + for (size_t j = 0; j < sz; j++) { + T sum = T(); + for (size_t k = 0; k < sz; k++) + sum += pMem[i][k] * m.pMem[k][j]; + res[i][j] = sum; + } + } + return res; + } + + // ввод/вывод + friend istream& operator>>(istream& istr, TDynamicMatrix& m) + { + for (size_t i = 0; i < m.sz; i++) + istr >> m.pMem[i]; + return istr; + } + + friend ostream& operator<<(ostream& ostr, const TDynamicMatrix& m) + { + for (size_t i = 0; i < m.sz; i++) { + for (size_t j = 0; j < m.sz; j++) + ostr << m.pMem[i][j] << ' '; + ostr << '\n'; + } + return ostr; + } }; #endif diff --git a/test/test_tmatrix.cpp b/test/test_tmatrix.cpp index edaf75ef6..929b81e58 100644 --- a/test/test_tmatrix.cpp +++ b/test/test_tmatrix.cpp @@ -1,111 +1,208 @@ #include "tmatrix.h" - #include TEST(TDynamicMatrix, can_create_matrix_with_positive_length) { - ASSERT_NO_THROW(TDynamicMatrix m(5)); + ASSERT_NO_THROW(TDynamicMatrix m(5)); } TEST(TDynamicMatrix, cant_create_too_large_matrix) { - ASSERT_ANY_THROW(TDynamicMatrix m(MAX_MATRIX_SIZE + 1)); + ASSERT_ANY_THROW(TDynamicMatrix m(MAX_MATRIX_SIZE + 1)); } TEST(TDynamicMatrix, throws_when_create_matrix_with_negative_length) { - ASSERT_ANY_THROW(TDynamicMatrix m(-5)); + ASSERT_ANY_THROW(TDynamicMatrix m(-5)); } TEST(TDynamicMatrix, can_create_copied_matrix) { - TDynamicMatrix m(5); - - ASSERT_NO_THROW(TDynamicMatrix m1(m)); + TDynamicMatrix m(5); + ASSERT_NO_THROW(TDynamicMatrix m1(m)); } TEST(TDynamicMatrix, copied_matrix_is_equal_to_source_one) { - ADD_FAILURE(); + TDynamicMatrix m1(2); + m1[0][0] = 1; m1[0][1] = 2; + m1[1][0] = 3; m1[1][1] = 4; + TDynamicMatrix m2(m1); + EXPECT_EQ(m1, m2); } TEST(TDynamicMatrix, copied_matrix_has_its_own_memory) { - ADD_FAILURE(); + TDynamicMatrix m1(2); + m1[0][0] = 1; m1[0][1] = 2; + m1[1][0] = 3; m1[1][1] = 4; + TDynamicMatrix m2(m1); + m1[0][0] = 10; + EXPECT_NE(m1[0][0], m2[0][0]); } TEST(TDynamicMatrix, can_get_size) { - ADD_FAILURE(); + TDynamicMatrix m(4); + EXPECT_EQ(4, m.size()); } TEST(TDynamicMatrix, can_set_and_get_element) { - ADD_FAILURE(); + TDynamicMatrix m(3); + m[1][1] = 5; + EXPECT_EQ(5, m[1][1]); } TEST(TDynamicMatrix, throws_when_set_element_with_negative_index) { - ADD_FAILURE(); + TDynamicMatrix m(3); + ASSERT_ANY_THROW(m[-1]); } TEST(TDynamicMatrix, throws_when_set_element_with_too_large_index) { - ADD_FAILURE(); + TDynamicMatrix m(3); + ASSERT_ANY_THROW(m[5]); } TEST(TDynamicMatrix, can_assign_matrix_to_itself) { - ADD_FAILURE(); + TDynamicMatrix m(2); + m[0][0] = 1; m[0][1] = 2; + m[1][0] = 3; m[1][1] = 4; + ASSERT_NO_THROW(m = m); + EXPECT_EQ(1, m[0][0]); + EXPECT_EQ(2, m[0][1]); + EXPECT_EQ(3, m[1][0]); + EXPECT_EQ(4, m[1][1]); } TEST(TDynamicMatrix, can_assign_matrices_of_equal_size) { - ADD_FAILURE(); + TDynamicMatrix m1(2), m2(2); + m1[0][0] = 1; m1[0][1] = 2; + m1[1][0] = 3; m1[1][1] = 4; + m2 = m1; + EXPECT_EQ(m1, m2); } TEST(TDynamicMatrix, assign_operator_change_matrix_size) { - ADD_FAILURE(); + TDynamicMatrix m1(2), m2(4); + m1[0][0] = 1; m1[0][1] = 2; + m1[1][0] = 3; m1[1][1] = 4; + m2 = m1; + EXPECT_EQ(2, m2.size()); } TEST(TDynamicMatrix, can_assign_matrices_of_different_size) { - ADD_FAILURE(); + TDynamicMatrix m1(2), m2(4); + m1[0][0] = 1; m1[0][1] = 2; + m1[1][0] = 3; m1[1][1] = 4; + m2 = m1; + EXPECT_EQ(m1, m2); } TEST(TDynamicMatrix, compare_equal_matrices_return_true) { - ADD_FAILURE(); + TDynamicMatrix m1(2), m2(2); + m1[0][0] = 1; m1[0][1] = 2; + m1[1][0] = 3; m1[1][1] = 4; + m2[0][0] = 1; m2[0][1] = 2; + m2[1][0] = 3; m2[1][1] = 4; + EXPECT_TRUE(m1 == m2); } TEST(TDynamicMatrix, compare_matrix_with_itself_return_true) { - ADD_FAILURE(); + TDynamicMatrix m(2); + m[0][0] = 1; m[0][1] = 2; + m[1][0] = 3; m[1][1] = 4; + EXPECT_TRUE(m == m); } TEST(TDynamicMatrix, matrices_with_different_size_are_not_equal) { - ADD_FAILURE(); + TDynamicMatrix m1(2), m2(3); + EXPECT_FALSE(m1 == m2); } TEST(TDynamicMatrix, can_add_matrices_with_equal_size) { - ADD_FAILURE(); + TDynamicMatrix m1(2), m2(2); + m1[0][0] = 1; m1[0][1] = 2; + m1[1][0] = 3; m1[1][1] = 4; + m2[0][0] = 5; m2[0][1] = 6; + m2[1][0] = 7; m2[1][1] = 8; + TDynamicMatrix res = m1 + m2; + EXPECT_EQ(6, res[0][0]); + EXPECT_EQ(8, res[0][1]); + EXPECT_EQ(10, res[1][0]); + EXPECT_EQ(12, res[1][1]); } TEST(TDynamicMatrix, cant_add_matrices_with_not_equal_size) { - ADD_FAILURE(); + TDynamicMatrix m1(2), m2(3); + ASSERT_ANY_THROW(m1 + m2); } TEST(TDynamicMatrix, can_subtract_matrices_with_equal_size) { - ADD_FAILURE(); + TDynamicMatrix m1(2), m2(2); + m1[0][0] = 5; m1[0][1] = 6; + m1[1][0] = 7; m1[1][1] = 8; + m2[0][0] = 1; m2[0][1] = 2; + m2[1][0] = 3; m2[1][1] = 4; + TDynamicMatrix res = m1 - m2; + EXPECT_EQ(4, res[0][0]); + EXPECT_EQ(4, res[0][1]); + EXPECT_EQ(4, res[1][0]); + EXPECT_EQ(4, res[1][1]); } TEST(TDynamicMatrix, cant_subtract_matrixes_with_not_equal_size) { - ADD_FAILURE(); + TDynamicMatrix m1(2), m2(3); + ASSERT_ANY_THROW(m1 - m2); +} + +TEST(TDynamicMatrix, can_multiply_matrices_with_equal_size) +{ + TDynamicMatrix m1(2), m2(2); + m1[0][0] = 1; m1[0][1] = 2; + m1[1][0] = 3; m1[1][1] = 4; + m2[0][0] = 2; m2[0][1] = 0; + m2[1][0] = 1; m2[1][1] = 2; + TDynamicMatrix res = m1 * m2; + EXPECT_EQ(4, res[0][0]); // 1*2 + 2*1 = 2 + 2 = 4 + EXPECT_EQ(4, res[0][1]); // 1*0 + 2*2 = 0 + 4 = 4 + EXPECT_EQ(10, res[1][0]); // 3*2 + 4*1 = 6 + 4 = 10 + EXPECT_EQ(8, res[1][1]); // 3*0 + 4*2 = 0 + 8 = 8 } +TEST(TDynamicMatrix, can_multiply_matrix_by_scalar) +{ + TDynamicMatrix m(2); + m[0][0] = 1; m[0][1] = 2; + m[1][0] = 3; m[1][1] = 4; + TDynamicMatrix res = m * 3; + EXPECT_EQ(3, res[0][0]); + EXPECT_EQ(6, res[0][1]); + EXPECT_EQ(9, res[1][0]); + EXPECT_EQ(12, res[1][1]); +} + +TEST(TDynamicMatrix, can_multiply_matrix_by_vector) +{ + TDynamicMatrix m(2); + TDynamicVector v(2); + m[0][0] = 1; m[0][1] = 2; + m[1][0] = 3; m[1][1] = 4; + v[0] = 2; v[1] = 3; + TDynamicVector res = m * v; + EXPECT_EQ(8, res[0]); // 1*2 + 2*3 = 2 + 6 = 8 + EXPECT_EQ(18, res[1]); // 3*2 + 4*3 = 6 + 12 = 18 +} \ No newline at end of file diff --git a/test/test_tvector.cpp b/test/test_tvector.cpp index 1f7737755..8b9cd9f20 100644 --- a/test/test_tvector.cpp +++ b/test/test_tvector.cpp @@ -1,141 +1,199 @@ #include "tmatrix.h" - #include TEST(TDynamicVector, can_create_vector_with_positive_length) { - ASSERT_NO_THROW(TDynamicVector v(5)); + ASSERT_NO_THROW(TDynamicVector v(5)); } TEST(TDynamicVector, cant_create_too_large_vector) { - ASSERT_ANY_THROW(TDynamicVector v(MAX_VECTOR_SIZE + 1)); + ASSERT_ANY_THROW(TDynamicVector v(MAX_VECTOR_SIZE + 1)); } TEST(TDynamicVector, throws_when_create_vector_with_negative_length) { - ASSERT_ANY_THROW(TDynamicVector v(-5)); + ASSERT_ANY_THROW(TDynamicVector v(-5)); } TEST(TDynamicVector, can_create_copied_vector) { - TDynamicVector v(10); - - ASSERT_NO_THROW(TDynamicVector v1(v)); + TDynamicVector v(10); + ASSERT_NO_THROW(TDynamicVector v1(v)); } TEST(TDynamicVector, copied_vector_is_equal_to_source_one) { - ADD_FAILURE(); + TDynamicVector v(3); + v[0] = 1; v[1] = 2; v[2] = 3; + TDynamicVector v1(v); + EXPECT_EQ(v, v1); } TEST(TDynamicVector, copied_vector_has_its_own_memory) { - ADD_FAILURE(); + TDynamicVector v(3); + v[0] = 1; v[1] = 2; v[2] = 3; + TDynamicVector v1(v); + v[0] = 10; + EXPECT_NE(v[0], v1[0]); } TEST(TDynamicVector, can_get_size) { - TDynamicVector v(4); - - EXPECT_EQ(4, v.size()); + TDynamicVector v(4); + EXPECT_EQ(4, v.size()); } -//TEST(TDynamicVector, can_set_and_get_element) -//{ -// TDynamicVector v(4); -// v[0] = 4; -// -// EXPECT_EQ(4, v[0]); -//} +TEST(TDynamicVector, can_set_and_get_element) +{ + TDynamicVector v(4); + v[0] = 4; + EXPECT_EQ(4, v[0]); +} TEST(TDynamicVector, throws_when_set_element_with_negative_index) { - ADD_FAILURE(); + TDynamicVector v(3); + ASSERT_ANY_THROW(v.at(-1)); } TEST(TDynamicVector, throws_when_set_element_with_too_large_index) { - ADD_FAILURE(); + TDynamicVector v(3); + ASSERT_ANY_THROW(v.at(10)); } TEST(TDynamicVector, can_assign_vector_to_itself) { - ADD_FAILURE(); + TDynamicVector v(3); + v[0] = 1; v[1] = 2; v[2] = 3; + ASSERT_NO_THROW(v = v); + EXPECT_EQ(1, v[0]); + EXPECT_EQ(2, v[1]); + EXPECT_EQ(3, v[2]); } TEST(TDynamicVector, can_assign_vectors_of_equal_size) { - ADD_FAILURE(); + TDynamicVector v1(3), v2(3); + v1[0] = 1; v1[1] = 2; v1[2] = 3; + v2 = v1; + EXPECT_EQ(v1, v2); } TEST(TDynamicVector, assign_operator_change_vector_size) { - ADD_FAILURE(); + TDynamicVector v1(3), v2(5); + v1[0] = 1; v1[1] = 2; v1[2] = 3; + v2 = v1; + EXPECT_EQ(3, v2.size()); } TEST(TDynamicVector, can_assign_vectors_of_different_size) { - ADD_FAILURE(); + TDynamicVector v1(3), v2(5); + v1[0] = 1; v1[1] = 2; v1[2] = 3; + v2 = v1; + EXPECT_EQ(v1, v2); } TEST(TDynamicVector, compare_equal_vectors_return_true) { - ADD_FAILURE(); + TDynamicVector v1(3), v2(3); + v1[0] = 1; v1[1] = 2; v1[2] = 3; + v2[0] = 1; v2[1] = 2; v2[2] = 3; + EXPECT_TRUE(v1 == v2); } TEST(TDynamicVector, compare_vector_with_itself_return_true) { - ADD_FAILURE(); + TDynamicVector v(3); + v[0] = 1; v[1] = 2; v[2] = 3; + EXPECT_TRUE(v == v); } TEST(TDynamicVector, vectors_with_different_size_are_not_equal) { - ADD_FAILURE(); + TDynamicVector v1(3), v2(5); + EXPECT_FALSE(v1 == v2); } TEST(TDynamicVector, can_add_scalar_to_vector) { - ADD_FAILURE(); + TDynamicVector v(3); + v[0] = 1; v[1] = 2; v[2] = 3; + TDynamicVector res = v + 5; + EXPECT_EQ(6, res[0]); + EXPECT_EQ(7, res[1]); + EXPECT_EQ(8, res[2]); } TEST(TDynamicVector, can_subtract_scalar_from_vector) { - ADD_FAILURE(); + TDynamicVector v(3); + v[0] = 5; v[1] = 6; v[2] = 7; + TDynamicVector res = v - 2; + EXPECT_EQ(3, res[0]); + EXPECT_EQ(4, res[1]); + EXPECT_EQ(5, res[2]); } TEST(TDynamicVector, can_multiply_scalar_by_vector) { - ADD_FAILURE(); + TDynamicVector v(3); + v[0] = 1; v[1] = 2; v[2] = 3; + TDynamicVector res = v * 3; + EXPECT_EQ(3, res[0]); + EXPECT_EQ(6, res[1]); + EXPECT_EQ(9, res[2]); } TEST(TDynamicVector, can_add_vectors_with_equal_size) { - ADD_FAILURE(); + TDynamicVector v1(3), v2(3); + v1[0] = 1; v1[1] = 2; v1[2] = 3; + v2[0] = 4; v2[1] = 5; v2[2] = 6; + TDynamicVector res = v1 + v2; + EXPECT_EQ(5, res[0]); + EXPECT_EQ(7, res[1]); + EXPECT_EQ(9, res[2]); } TEST(TDynamicVector, cant_add_vectors_with_not_equal_size) { - ADD_FAILURE(); + TDynamicVector v1(3), v2(5); + ASSERT_ANY_THROW(v1 + v2); } TEST(TDynamicVector, can_subtract_vectors_with_equal_size) { - ADD_FAILURE(); + TDynamicVector v1(3), v2(3); + v1[0] = 5; v1[1] = 7; v1[2] = 9; + v2[0] = 1; v2[1] = 2; v2[2] = 3; + TDynamicVector res = v1 - v2; + EXPECT_EQ(4, res[0]); + EXPECT_EQ(5, res[1]); + EXPECT_EQ(6, res[2]); } TEST(TDynamicVector, cant_subtract_vectors_with_not_equal_size) { - ADD_FAILURE(); + TDynamicVector v1(3), v2(5); + ASSERT_ANY_THROW(v1 - v2); } TEST(TDynamicVector, can_multiply_vectors_with_equal_size) { - ADD_FAILURE(); + TDynamicVector v1(3), v2(3); + v1[0] = 1; v1[1] = 2; v1[2] = 3; + v2[0] = 4; v2[1] = 5; v2[2] = 6; + int res = v1 * v2; + EXPECT_EQ(32, res); // 1*4 + 2*5 + 3*6 = 4 + 10 + 18 = 32 } TEST(TDynamicVector, cant_multiply_vectors_with_not_equal_size) { - ADD_FAILURE(); -} - + TDynamicVector v1(3), v2(5); + ASSERT_ANY_THROW(v1 * v2); +} \ No newline at end of file