From a4a524137cb84ecbf2e71c24b33b6404411ccdc3 Mon Sep 17 00:00:00 2001
From: VayDiSer <zoooblack7@gmail.com>
Date: Mon, 13 Oct 2025 00:23:36 +0300
Subject: [PATCH 1/4] lab2

---
 include/tmatrix.h     | 458 +++++++++++++++++++++++++++++-------------
 test/test_tmatrix.cpp | 190 +++++++++++++++---
 test/test_tvector.cpp | 228 +++++++++++++++++----
 3 files changed, 676 insertions(+), 200 deletions(-)

diff --git a/include/tmatrix.h b/include/tmatrix.h
index 6c11b2feb..6c1b3d0f9 100644
--- a/include/tmatrix.h
+++ b/include/tmatrix.h
@@ -8,6 +8,8 @@
 #define __TDynamicMatrix_H__
 
 #include <iostream>
+#include <stdexcept>
+#include <cassert>
 
 using namespace std;
 
@@ -20,104 +22,199 @@ template<typename T>
 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
-  {
-      return *this;
-  }
-
-  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-(double val)
-  {
-  }
-  TDynamicVector operator*(double 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 || sz > MAX_VECTOR_SIZE)
+            throw out_of_range("Error!");
+        pMem = new T[sz]();// {}; // У типа T д.б. констуктор по умолчанию
+    }
+
+    TDynamicVector(T* arr, size_t s) : sz(s)
+    {
+        if (arr == nullptr || sz > MAX_VECTOR_SIZE)
+            throw out_of_range("Error!");
+        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[v.sz])
+    {
+        for (size_t i = 0; i < sz; i++)
+            pMem[i] = v.pMem[i];
+    }
+
+    TDynamicVector(TDynamicVector&& v) noexcept : sz(v.sz), pMem(v.pMem)
+    {
+        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("Error!");
+        return pMem[ind];
+    }
+
+    const T& at(size_t ind) const
+    {
+        if (ind >= sz)
+            throw out_of_range("Error!");
+        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("Error!");
+
+        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("Error!");
+
+        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("Error!");
+
+        T sum = T();
+        for (size_t i = 0; i < sz; i++)
+            sum += pMem[i] * v.pMem[i];
+        return sum;
+    }
+
+    friend void swap(TDynamicVector& a, TDynamicVector& b) noexcept
+    {
+        size_t temp_sz = a.sz;
+        a.sz = b.sz;
+        b.sz = temp_sz;
+
+        T* temp_pMem = a.pMem;
+        a.pMem = b.pMem;
+        b.pMem = temp_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;
+    }
 };
 
 
@@ -126,50 +223,129 @@ class TDynamicVector
 template<typename T>
 class TDynamicMatrix : private TDynamicVector<TDynamicVector<T>>
 {
-  using TDynamicVector<TDynamicVector<T>>::pMem;
-  using TDynamicVector<TDynamicVector<T>>::sz;
+    using TDynamicVector<TDynamicVector<T>>::pMem;
+    using TDynamicVector<TDynamicVector<T>>::sz;
 public:
-  TDynamicMatrix(size_t s = 1) : TDynamicVector<TDynamicVector<T>>(s)
-  {
-    for (size_t i = 0; i < sz; i++)
-      pMem[i] = TDynamicVector<T>(sz);
-  }
-
-  using TDynamicVector<TDynamicVector<T>>::operator[];
-
-  // сравнение
-  bool operator==(const TDynamicMatrix& m) const noexcept
-  {
-  }
-
-  // матрично-скалярные операции
-  TDynamicVector<T> operator*(const T& val)
-  {
-  }
-
-  // матрично-векторные операции
-  TDynamicVector<T> operator*(const TDynamicVector<T>& 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<TDynamicVector<T>>(s)
+    {
+        if (s > MAX_MATRIX_SIZE)
+            throw out_of_range("Error!");
+        for (size_t i = 0; i < sz; i++)
+            pMem[i] = TDynamicVector<T>(sz);
+    }
+
+    using TDynamicVector<TDynamicVector<T>>::operator[];
+
+    size_t size() const noexcept { return sz; }
+
+    // индексация с контролем для матрицы
+    TDynamicVector<T>& at(size_t ind)
+    {
+        if (ind >= sz) throw out_of_range("Error!");
+        return pMem[ind];
+    }
+
+    const TDynamicVector<T>& at(size_t ind) const
+    {
+        if (ind >= sz)
+            throw out_of_range("Error!");
+        return pMem[ind];
+    }
+
+    // сравнение
+    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<T> operator*(const TDynamicVector<T>& v)
+    {
+        if (sz != v.size()) throw invalid_argument("Error!");
+
+        TDynamicVector<T> res(sz);
+        for (size_t i = 0; i < sz; i++) {
+            T sum = T();
+            for (size_t j = 0; j < sz; j++)
+                sum += pMem[i][j] * v[j];
+            res[i] = sum;
+        }
+        return res;
+    }
+
+    // матрично-матричные операции
+    TDynamicMatrix operator+(const TDynamicMatrix& m)
+    {
+        if (sz != m.sz)
+            throw invalid_argument("Error!");
+
+        TDynamicMatrix res(sz);
+        for (size_t i = 0; i < sz; i++)
+            res[i] = pMem[i] + m[i];
+        return res;
+    }
+
+    TDynamicMatrix operator-(const TDynamicMatrix& m)
+    {
+        if (sz != m.sz)
+            throw invalid_argument("Error!");
+
+        TDynamicMatrix res(sz);
+        for (size_t i = 0; i < sz; i++)
+            res[i] = pMem[i] - m[i];
+        return res;
+    }
+
+    TDynamicMatrix operator*(const TDynamicMatrix& m)
+    {
+        if (sz != m.sz) throw invalid_argument("Error!");
+
+        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[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] << ' ';
+        }
+        return ostr;
+    }
 };
 
-#endif
+#endif
\ No newline at end of file
diff --git a/test/test_tmatrix.cpp b/test/test_tmatrix.cpp
index edaf75ef6..08dc42dcf 100644
--- a/test/test_tmatrix.cpp
+++ b/test/test_tmatrix.cpp
@@ -4,108 +4,252 @@
 
 TEST(TDynamicMatrix, can_create_matrix_with_positive_length)
 {
-  ASSERT_NO_THROW(TDynamicMatrix<int> m(5));
+	ASSERT_NO_THROW(TDynamicMatrix<int> m(7));
 }
 
 TEST(TDynamicMatrix, cant_create_too_large_matrix)
 {
-  ASSERT_ANY_THROW(TDynamicMatrix<int> m(MAX_MATRIX_SIZE + 1));
+	ASSERT_ANY_THROW(TDynamicMatrix<int> m(MAX_MATRIX_SIZE + 5));
 }
 
 TEST(TDynamicMatrix, throws_when_create_matrix_with_negative_length)
 {
-  ASSERT_ANY_THROW(TDynamicMatrix<int> m(-5));
+	ASSERT_ANY_THROW(TDynamicMatrix<int> m(-7));
 }
 
 TEST(TDynamicMatrix, can_create_copied_matrix)
 {
-  TDynamicMatrix<int> m(5);
-
-  ASSERT_NO_THROW(TDynamicMatrix<int> m1(m));
+	TDynamicMatrix<int> m(6);
+	ASSERT_NO_THROW(TDynamicMatrix<int> m1(m));
 }
 
 TEST(TDynamicMatrix, copied_matrix_is_equal_to_source_one)
 {
-  ADD_FAILURE();
+	TDynamicMatrix<int> m1(3);
+	m1[0][0] = 2; m1[0][1] = 3; m1[0][2] = 1;
+	m1[1][0] = 4; m1[1][1] = 5; m1[1][2] = 6;
+	m1[2][0] = 7; m1[2][1] = 8; m1[2][2] = 9;
+
+	TDynamicMatrix<int> m2(m1);
+	EXPECT_EQ(m1, m2);
 }
 
 TEST(TDynamicMatrix, copied_matrix_has_its_own_memory)
 {
-  ADD_FAILURE();
+	TDynamicMatrix<int> m1(2);
+	m1[0][0] = 5; m1[0][1] = 6;
+	m1[1][0] = 7; m1[1][1] = 8;
+
+	TDynamicMatrix<int> m2(m1);
+	m2[0][0] = 15;
+
+	EXPECT_NE(m1[0][0], m2[0][0]);
+	EXPECT_EQ(5, m1[0][0]);
+	EXPECT_EQ(15, m2[0][0]);
 }
 
 TEST(TDynamicMatrix, can_get_size)
 {
-  ADD_FAILURE();
+	TDynamicMatrix<int> m(5);
+	EXPECT_EQ(5, m.size());
 }
 
 TEST(TDynamicMatrix, can_set_and_get_element)
 {
-  ADD_FAILURE();
+	TDynamicMatrix<int> m(3);
+	m[0][0] = 7;
+	m[1][2] = 15;
+
+	EXPECT_EQ(7, m[0][0]);
+	EXPECT_EQ(15, m[1][2]);
 }
 
 TEST(TDynamicMatrix, throws_when_set_element_with_negative_index)
 {
-  ADD_FAILURE();
+	TDynamicMatrix<int> m(3);
+	ASSERT_ANY_THROW(m.at(-1));
 }
 
 TEST(TDynamicMatrix, throws_when_set_element_with_too_large_index)
 {
-  ADD_FAILURE();
+	TDynamicMatrix<int> m(3);
+	ASSERT_ANY_THROW(m.at(5));
 }
 
 TEST(TDynamicMatrix, can_assign_matrix_to_itself)
 {
-  ADD_FAILURE();
+	TDynamicMatrix<int> m(2);
+	m[0][0] = 5; m[0][1] = 6;
+	m[1][0] = 7; m[1][1] = 8;
+
+	ASSERT_NO_THROW(m = m);
+	EXPECT_EQ(5, m[0][0]);
+	EXPECT_EQ(6, m[0][1]);
+	EXPECT_EQ(7, m[1][0]);
+	EXPECT_EQ(8, m[1][1]);
 }
 
 TEST(TDynamicMatrix, can_assign_matrices_of_equal_size)
 {
-  ADD_FAILURE();
+	TDynamicMatrix<int> m1(2);
+	m1[0][0] = 2; m1[0][1] = 3;
+	m1[1][0] = 4; m1[1][1] = 5;
+
+	TDynamicMatrix<int> m2(2);
+	m2 = m1;
+
+	EXPECT_EQ(m1, m2);
 }
 
 TEST(TDynamicMatrix, assign_operator_change_matrix_size)
 {
-  ADD_FAILURE();
+	TDynamicMatrix<int> m1(2);
+	TDynamicMatrix<int> m2(6);
+
+	m2 = m1;
+
+	EXPECT_EQ(2, m2.size());
 }
 
 TEST(TDynamicMatrix, can_assign_matrices_of_different_size)
 {
-  ADD_FAILURE();
+	TDynamicMatrix<int> m1(2);
+	m1[0][0] = 3; m1[0][1] = 4;
+	m1[1][0] = 5; m1[1][1] = 6;
+
+	TDynamicMatrix<int> m2(5);
+	m2 = m1;
+
+	EXPECT_EQ(m1, m2);
+	EXPECT_EQ(2, m2.size());
 }
 
 TEST(TDynamicMatrix, compare_equal_matrices_return_true)
 {
-  ADD_FAILURE();
+	TDynamicMatrix<int> m1(2);
+	m1[0][0] = 2; m1[0][1] = 3;
+	m1[1][0] = 4; m1[1][1] = 5;
+
+	TDynamicMatrix<int> m2(2);
+	m2[0][0] = 2; m2[0][1] = 3;
+	m2[1][0] = 4; m2[1][1] = 5;
+
+	EXPECT_TRUE(m1 == m2);
 }
 
 TEST(TDynamicMatrix, compare_matrix_with_itself_return_true)
 {
-  ADD_FAILURE();
+	TDynamicMatrix<int> m(2);
+	m[0][0] = 3; m[0][1] = 4;
+	m[1][0] = 5; m[1][1] = 6;
+
+	EXPECT_TRUE(m == m);
 }
 
 TEST(TDynamicMatrix, matrices_with_different_size_are_not_equal)
 {
-  ADD_FAILURE();
+	TDynamicMatrix<int> m1(2);
+	TDynamicMatrix<int> m2(4);
+
+	EXPECT_TRUE(m1 != m2);
 }
 
 TEST(TDynamicMatrix, can_add_matrices_with_equal_size)
 {
-  ADD_FAILURE();
+	TDynamicMatrix<int> m1(2);
+	m1[0][0] = 2; m1[0][1] = 3;
+	m1[1][0] = 4; m1[1][1] = 5;
+
+	TDynamicMatrix<int> m2(2);
+	m2[0][0] = 6; m2[0][1] = 7;
+	m2[1][0] = 8; m2[1][1] = 9;
+
+	TDynamicMatrix<int> m3 = m1 + m2;
+
+	EXPECT_EQ(8, m3[0][0]);
+	EXPECT_EQ(10, m3[0][1]);
+	EXPECT_EQ(12, m3[1][0]);
+	EXPECT_EQ(14, m3[1][1]);
 }
 
 TEST(TDynamicMatrix, cant_add_matrices_with_not_equal_size)
 {
-  ADD_FAILURE();
+	TDynamicMatrix<int> m1(2);
+	TDynamicMatrix<int> m2(4);
+
+	ASSERT_ANY_THROW(m1 + m2);
 }
 
 TEST(TDynamicMatrix, can_subtract_matrices_with_equal_size)
 {
-  ADD_FAILURE();
+	TDynamicMatrix<int> m1(2);
+	m1[0][0] = 8; m1[0][1] = 9;
+	m1[1][0] = 10; m1[1][1] = 11;
+
+	TDynamicMatrix<int> m2(2);
+	m2[0][0] = 2; m2[0][1] = 3;
+	m2[1][0] = 4; m2[1][1] = 5;
+
+	TDynamicMatrix<int> m3 = m1 - m2;
+
+	EXPECT_EQ(6, m3[0][0]);
+	EXPECT_EQ(6, m3[0][1]);
+	EXPECT_EQ(6, m3[1][0]);
+	EXPECT_EQ(6, m3[1][1]);
 }
 
 TEST(TDynamicMatrix, cant_subtract_matrixes_with_not_equal_size)
 {
-  ADD_FAILURE();
+	TDynamicMatrix<int> m1(2);
+	TDynamicMatrix<int> m2(5);
+
+	ASSERT_ANY_THROW(m1 - m2);
+}
+
+TEST(TDynamicMatrix, can_multiply_matrices_with_equal_size)
+{
+	TDynamicMatrix<int> m1(2);
+	m1[0][0] = 2; m1[0][1] = 3;
+	m1[1][0] = 4; m1[1][1] = 5;
+
+	TDynamicMatrix<int> m2(2);
+	m2[0][0] = 6; m2[0][1] = 7;
+	m2[1][0] = 8; m2[1][1] = 9;
+
+	TDynamicMatrix<int> m3 = m1 * m2;
+
+	EXPECT_EQ(36, m3[0][0]);
+	EXPECT_EQ(41, m3[0][1]);
+	EXPECT_EQ(64, m3[1][0]);
+	EXPECT_EQ(73, m3[1][1]);
+}
+
+TEST(TDynamicMatrix, can_multiply_matrix_by_scalar)
+{
+	TDynamicMatrix<int> m1(2);
+	m1[0][0] = 2; m1[0][1] = 3;
+	m1[1][0] = 4; m1[1][1] = 5;
+
+	TDynamicMatrix<int> m2 = m1 * 4;
+
+	EXPECT_EQ(8, m2[0][0]);
+	EXPECT_EQ(12, m2[0][1]);
+	EXPECT_EQ(16, m2[1][0]);
+	EXPECT_EQ(20, m2[1][1]);
+}
+
+TEST(TDynamicMatrix, can_multiply_matrix_by_vector)
+{
+	TDynamicMatrix<int> m(2);
+	m[0][0] = 2; m[0][1] = 3;
+	m[1][0] = 4; m[1][1] = 5;
+
+	TDynamicVector<int> v(2);
+	v[0] = 6; v[1] = 7;
+
+	TDynamicVector<int> result = m * v;
+
+	EXPECT_EQ(33, result[0]);
+	EXPECT_EQ(59, result[1]);
 }
 
diff --git a/test/test_tvector.cpp b/test/test_tvector.cpp
index 1f7737755..aede88c0a 100644
--- a/test/test_tvector.cpp
+++ b/test/test_tvector.cpp
@@ -4,138 +4,294 @@
 
 TEST(TDynamicVector, can_create_vector_with_positive_length)
 {
-  ASSERT_NO_THROW(TDynamicVector<int> v(5));
+	ASSERT_NO_THROW(TDynamicVector<int> v(7));
 }
 
 TEST(TDynamicVector, cant_create_too_large_vector)
 {
-  ASSERT_ANY_THROW(TDynamicVector<int> v(MAX_VECTOR_SIZE + 1));
+	ASSERT_ANY_THROW(TDynamicVector<int> v(MAX_VECTOR_SIZE + 5));
 }
 
 TEST(TDynamicVector, throws_when_create_vector_with_negative_length)
 {
-  ASSERT_ANY_THROW(TDynamicVector<int> v(-5));
+	ASSERT_ANY_THROW(TDynamicVector<int> v(-7));
 }
 
 TEST(TDynamicVector, can_create_copied_vector)
 {
-  TDynamicVector<int> v(10);
-
-  ASSERT_NO_THROW(TDynamicVector<int> v1(v));
+	TDynamicVector<int> v(8);
+	ASSERT_NO_THROW(TDynamicVector<int> v1(v));
 }
 
 TEST(TDynamicVector, copied_vector_is_equal_to_source_one)
 {
-  ADD_FAILURE();
+	TDynamicVector<int> v1(3);
+	v1[0] = 2; v1[1] = 3; v1[2] = 4;
+
+	TDynamicVector<int> v2(v1);
+
+	EXPECT_EQ(v1, v2);
 }
 
 TEST(TDynamicVector, copied_vector_has_its_own_memory)
 {
-  ADD_FAILURE();
+	TDynamicVector<int> v1(3);
+	v1[0] = 5; v1[1] = 6; v1[2] = 7;
+
+	TDynamicVector<int> v2(v1);
+	v2[0] = 15;
+
+	EXPECT_NE(v1[0], v2[0]);
+	EXPECT_EQ(5, v1[0]);
+	EXPECT_EQ(15, v2[0]);
 }
 
 TEST(TDynamicVector, can_get_size)
 {
-  TDynamicVector<int> v(4);
-
-  EXPECT_EQ(4, v.size());
+	TDynamicVector<int> v(5);
+	EXPECT_EQ(5, v.size());
 }
 
-//TEST(TDynamicVector, can_set_and_get_element)
-//{
-//  TDynamicVector<int> v(4);
-//  v[0] = 4;
-//
-//  EXPECT_EQ(4, v[0]);
-//}
+TEST(TDynamicVector, can_set_and_get_element)
+{
+	TDynamicVector<int> v(4);
+	v[0] = 7;
+
+	EXPECT_EQ(7, v[0]);
+}
 
 TEST(TDynamicVector, throws_when_set_element_with_negative_index)
 {
-  ADD_FAILURE();
+	TDynamicVector<int> v(3);
+	ASSERT_ANY_THROW(v.at(-1));
 }
 
 TEST(TDynamicVector, throws_when_set_element_with_too_large_index)
 {
-  ADD_FAILURE();
+	TDynamicVector<int> v(3);
+	ASSERT_ANY_THROW(v.at(5));
 }
 
 TEST(TDynamicVector, can_assign_vector_to_itself)
 {
-  ADD_FAILURE();
+	TDynamicVector<int> v(3);
+	v[0] = 2; v[1] = 3; v[2] = 4;
+
+	ASSERT_NO_THROW(v = v);
+	EXPECT_EQ(2, v[0]);
+	EXPECT_EQ(3, v[1]);
+	EXPECT_EQ(4, v[2]);
 }
 
 TEST(TDynamicVector, can_assign_vectors_of_equal_size)
 {
-  ADD_FAILURE();
+	TDynamicVector<int> v1(3);
+	v1[0] = 2; v1[1] = 3; v1[2] = 4;
+
+	TDynamicVector<int> v2(3);
+	v2 = v1;
+
+	EXPECT_EQ(v1, v2);
 }
 
 TEST(TDynamicVector, assign_operator_change_vector_size)
 {
-  ADD_FAILURE();
+	TDynamicVector<int> v1(3);
+	TDynamicVector<int> v2(6);
+
+	v2 = v1;
+
+	EXPECT_EQ(3, v2.size());
 }
 
 TEST(TDynamicVector, can_assign_vectors_of_different_size)
 {
-  ADD_FAILURE();
+	TDynamicVector<int> v1(3);
+	v1[0] = 2; v1[1] = 3; v1[2] = 4;
+
+	TDynamicVector<int> v2(5);
+	v2 = v1;
+
+	EXPECT_EQ(v1, v2);
+	EXPECT_EQ(3, v2.size());
 }
 
 TEST(TDynamicVector, compare_equal_vectors_return_true)
 {
-  ADD_FAILURE();
+	TDynamicVector<int> v1(3);
+	v1[0] = 2; v1[1] = 3; v1[2] = 4;
+
+	TDynamicVector<int> v2(3);
+	v2[0] = 2; v2[1] = 3; v2[2] = 4;
+
+	EXPECT_TRUE(v1 == v2);
 }
 
 TEST(TDynamicVector, compare_vector_with_itself_return_true)
 {
-  ADD_FAILURE();
+	TDynamicVector<int> v(3);
+	v[0] = 2; v[1] = 3; v[2] = 4;
+
+	EXPECT_TRUE(v == v);
 }
 
 TEST(TDynamicVector, vectors_with_different_size_are_not_equal)
 {
-  ADD_FAILURE();
+	TDynamicVector<int> v1(3);
+	TDynamicVector<int> v2(5);
+
+	EXPECT_TRUE(v1 != v2);
 }
 
 TEST(TDynamicVector, can_add_scalar_to_vector)
 {
-  ADD_FAILURE();
+	TDynamicVector<int> v1(3);
+	v1[0] = 2; v1[1] = 3; v1[2] = 4;
+
+	TDynamicVector<int> v2 = v1 + 6;
+
+	EXPECT_EQ(8, v2[0]);
+	EXPECT_EQ(9, v2[1]);
+	EXPECT_EQ(10, v2[2]);
 }
 
 TEST(TDynamicVector, can_subtract_scalar_from_vector)
 {
-  ADD_FAILURE();
+	TDynamicVector<int> v1(3);
+	v1[0] = 7; v1[1] = 8; v1[2] = 9;
+
+	TDynamicVector<int> v2 = v1 - 3;
+
+	EXPECT_EQ(4, v2[0]);
+	EXPECT_EQ(5, v2[1]);
+	EXPECT_EQ(6, v2[2]);
 }
 
 TEST(TDynamicVector, can_multiply_scalar_by_vector)
 {
-  ADD_FAILURE();
+	TDynamicVector<int> v1(3);
+	v1[0] = 2; v1[1] = 3; v1[2] = 4;
+
+	TDynamicVector<int> v2 = v1 * 4;
+
+	EXPECT_EQ(8, v2[0]);
+	EXPECT_EQ(12, v2[1]);
+	EXPECT_EQ(16, v2[2]);
 }
 
 TEST(TDynamicVector, can_add_vectors_with_equal_size)
 {
-  ADD_FAILURE();
+	TDynamicVector<int> v1(3);
+	v1[0] = 2; v1[1] = 3; v1[2] = 4;
+
+	TDynamicVector<int> v2(3);
+	v2[0] = 5; v2[1] = 6; v2[2] = 7;
+
+	TDynamicVector<int> v3 = v1 + v2;
+
+	EXPECT_EQ(7, v3[0]);
+	EXPECT_EQ(9, v3[1]);
+	EXPECT_EQ(11, v3[2]);
 }
 
 TEST(TDynamicVector, cant_add_vectors_with_not_equal_size)
 {
-  ADD_FAILURE();
+	TDynamicVector<int> v1(3);
+	TDynamicVector<int> v2(5);
+
+	ASSERT_ANY_THROW(v1 + v2);
 }
 
 TEST(TDynamicVector, can_subtract_vectors_with_equal_size)
 {
-  ADD_FAILURE();
+	TDynamicVector<int> v1(3);
+	v1[0] = 8; v1[1] = 9; v1[2] = 10;
+
+	TDynamicVector<int> v2(3);
+	v2[0] = 2; v2[1] = 3; v2[2] = 4;
+
+	TDynamicVector<int> v3 = v1 - v2;
+
+	EXPECT_EQ(6, v3[0]);
+	EXPECT_EQ(6, v3[1]);
+	EXPECT_EQ(6, v3[2]);
 }
 
 TEST(TDynamicVector, cant_subtract_vectors_with_not_equal_size)
 {
-  ADD_FAILURE();
+	TDynamicVector<int> v1(3);
+	TDynamicVector<int> v2(5);
+
+	ASSERT_ANY_THROW(v1 - v2);
 }
 
 TEST(TDynamicVector, can_multiply_vectors_with_equal_size)
 {
-  ADD_FAILURE();
+	TDynamicVector<int> v1(3);
+	v1[0] = 2; v1[1] = 3; v1[2] = 4;
+
+	TDynamicVector<int> v2(3);
+	v2[0] = 5; v2[1] = 6; v2[2] = 7;
+
+	int result = v1 * v2;
+
+	EXPECT_EQ(56, result);
 }
 
 TEST(TDynamicVector, cant_multiply_vectors_with_not_equal_size)
 {
-  ADD_FAILURE();
+	TDynamicVector<int> v1(3);
+	TDynamicVector<int> v2(5);
+
+	ASSERT_ANY_THROW(v1 * v2);
+}
+
+TEST(TDynamicVector, move_constructor_works_correctly)
+{
+	TDynamicVector<int> original(4);
+	original[0] = 10; original[1] = 20; original[2] = 30; original[3] = 40;
+
+	TDynamicVector<int> moved(std::move(original));
+
+	EXPECT_EQ(4, moved.size());
+	EXPECT_EQ(10, moved[0]);
+	EXPECT_EQ(20, moved[1]);
+	EXPECT_EQ(30, moved[2]);
+	EXPECT_EQ(40, moved[3]);
+	EXPECT_EQ(0, original.size());
 }
 
+TEST(TDynamicVector, move_assignment_works_correctly)
+{
+	TDynamicVector<int> source(3);
+	source[0] = 15; source[1] = 25; source[2] = 35;
+
+	TDynamicVector<int> destination(2);
+	destination = std::move(source);
+
+	EXPECT_EQ(3, destination.size());
+	EXPECT_EQ(15, destination[0]);
+	EXPECT_EQ(25, destination[1]);
+	EXPECT_EQ(35, destination[2]);
+	EXPECT_EQ(0, source.size());
+}
+
+TEST(TDynamicVector, swap_function_exchanges_contents)
+{
+	TDynamicVector<int> a(2);
+	a[0] = 5; a[1] = 10;
+
+	TDynamicVector<int> b(3);
+	b[0] = 15; b[1] = 20; b[2] = 25;
+
+	swap(a, b);
+
+	EXPECT_EQ(3, a.size());
+	EXPECT_EQ(15, a[0]);
+	EXPECT_EQ(20, a[1]);
+	EXPECT_EQ(25, a[2]);
+
+	EXPECT_EQ(2, b.size());
+	EXPECT_EQ(5, b[0]);
+	EXPECT_EQ(10, b[1]);
+}
\ No newline at end of file

From 5c8a4f4ff78c2aa3d4ab232cea72383396db80e8 Mon Sep 17 00:00:00 2001
From: VayDiSer <zoooblack7@gmail.com>
Date: Mon, 13 Oct 2025 00:45:20 +0300
Subject: [PATCH 2/4] versia

---
 include/tmatrix.h     | 7 ++++---
 test/test_tvector.cpp | 4 ++--
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/include/tmatrix.h b/include/tmatrix.h
index 6c1b3d0f9..d6ac04958 100644
--- a/include/tmatrix.h
+++ b/include/tmatrix.h
@@ -27,7 +27,9 @@ class TDynamicVector
 public:
     TDynamicVector(size_t size = 1) : sz(size)
     {
-        if (sz == 0 || sz > MAX_VECTOR_SIZE)
+        if (sz == 0)
+            throw invalid_argument("Error!");
+        if (sz > MAX_VECTOR_SIZE)
             throw out_of_range("Error!");
         pMem = new T[sz]();// {}; // У типа T д.б. констуктор по умолчанию
     }
@@ -49,8 +51,6 @@ class TDynamicVector
 
     TDynamicVector(TDynamicVector&& v) noexcept : sz(v.sz), pMem(v.pMem)
     {
-        sz = v.sz;
-        pMem = v.pMem;
         v.pMem = nullptr;
         v.sz = 0;
     }
@@ -343,6 +343,7 @@ class TDynamicMatrix : private TDynamicVector<TDynamicVector<T>>
         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;
     }
diff --git a/test/test_tvector.cpp b/test/test_tvector.cpp
index aede88c0a..c3fc56b33 100644
--- a/test/test_tvector.cpp
+++ b/test/test_tvector.cpp
@@ -14,7 +14,7 @@ TEST(TDynamicVector, cant_create_too_large_vector)
 
 TEST(TDynamicVector, throws_when_create_vector_with_negative_length)
 {
-	ASSERT_ANY_THROW(TDynamicVector<int> v(-7));
+	ASSERT_THROW(TDynamicVector<int> v(-7), out_of_range);
 }
 
 TEST(TDynamicVector, can_create_copied_vector)
@@ -63,7 +63,7 @@ TEST(TDynamicVector, can_set_and_get_element)
 TEST(TDynamicVector, throws_when_set_element_with_negative_index)
 {
 	TDynamicVector<int> v(3);
-	ASSERT_ANY_THROW(v.at(-1));
+	ASSERT_THROW(v.at(-1), out_of_range);
 }
 
 TEST(TDynamicVector, throws_when_set_element_with_too_large_index)

From ad5fc3aeb9e874c2940d1f7c6c35f4556cfb2a8e Mon Sep 17 00:00:00 2001
From: VayDiSer <zoooblack7@gmail.com>
Date: Mon, 13 Oct 2025 01:03:48 +0300
Subject: [PATCH 3/4] versia2

---
 include/tmatrix.h     | 5 +----
 test/test_tvector.cpp | 6 ++----
 2 files changed, 3 insertions(+), 8 deletions(-)

diff --git a/include/tmatrix.h b/include/tmatrix.h
index d6ac04958..408fb58f4 100644
--- a/include/tmatrix.h
+++ b/include/tmatrix.h
@@ -27,9 +27,7 @@ class TDynamicVector
 public:
     TDynamicVector(size_t size = 1) : sz(size)
     {
-        if (sz == 0)
-            throw invalid_argument("Error!");
-        if (sz > MAX_VECTOR_SIZE)
+        if (sz == 0 || sz > MAX_VECTOR_SIZE)
             throw out_of_range("Error!");
         pMem = new T[sz]();// {}; // У типа T д.б. констуктор по умолчанию
     }
@@ -343,7 +341,6 @@ class TDynamicMatrix : private TDynamicVector<TDynamicVector<T>>
         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;
     }
diff --git a/test/test_tvector.cpp b/test/test_tvector.cpp
index c3fc56b33..43102e529 100644
--- a/test/test_tvector.cpp
+++ b/test/test_tvector.cpp
@@ -240,10 +240,8 @@ TEST(TDynamicVector, can_multiply_vectors_with_equal_size)
 
 TEST(TDynamicVector, cant_multiply_vectors_with_not_equal_size)
 {
-	TDynamicVector<int> v1(3);
-	TDynamicVector<int> v2(5);
-
-	ASSERT_ANY_THROW(v1 * v2);
+	TDynamicVector<int> v1(3), v2(2);
+	EXPECT_ANY_THROW(v1 * v2);
 }
 
 TEST(TDynamicVector, move_constructor_works_correctly)

From dab4494bde8c15ece59ddb9250c1c6ab1ddb59ee Mon Sep 17 00:00:00 2001
From: VayDiSer <zoooblack7@gmail.com>
Date: Mon, 13 Oct 2025 01:12:47 +0300
Subject: [PATCH 4/4] versia3

---
 include/tmatrix.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/tmatrix.h b/include/tmatrix.h
index 408fb58f4..ddbeda647 100644
--- a/include/tmatrix.h
+++ b/include/tmatrix.h
@@ -177,7 +177,7 @@ class TDynamicVector
         return res;
     }
 
-    T operator*(const TDynamicVector& v) noexcept(noexcept(T()))
+    T operator*(const TDynamicVector& v) 
     {
         if (sz != v.sz)
             throw invalid_argument("Error!");