From ef0f4155cf3a10748d42b17d9961c52d1b03c8de Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Tue, 16 Sep 2025 21:18:29 +0300
Subject: [PATCH 001/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=20Tvector?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_vector/vector.h | 694 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 694 insertions(+)
 create mode 100644 lib_vector/vector.h

diff --git a/lib_vector/vector.h b/lib_vector/vector.h
new file mode 100644
index 00000000..ea1c7777
--- /dev/null
+++ b/lib_vector/vector.h
@@ -0,0 +1,694 @@
+// Copyright 2025 Zabytina Julia. All rights reserved.
+#pragma once
+#include <cstddef> 
+#include <stdexcept>
+#include <vector>
+#include <exception>
+#include <random>
+#include <iostream>
+#include <utility>
+#include <memory>
+#include <algorithm>
+template <class T>
+class Tvector {
+public:
+    enum State {
+        empty, busy, deleted
+    };
+private:
+    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();
+    inline bool is_full() const noexcept {
+        return _size == _capacity;
+    }
+public:
+    Tvector() noexcept;
+    Tvector(size_t size);
+    Tvector(T* data, size_t size);
+    Tvector(const Tvector<T>& other_vector);
+    ~Tvector() noexcept;
+
+    inline bool is_empty() const noexcept {
+        return _size == 0;
+    }
+    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<T>& vector) const;
+    bool operator!=(const Tvector<T>& vector) const;
+    Tvector<T>& operator=(const Tvector<T>& 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<T>& 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<typename U>
+    friend std::ostream& operator<<(std::ostream&, const Tvector<U>& vector);
+    template <class U> friend void shell_sort(Tvector<U>& object) noexcept;
+    template <class U> friend void shuffle(Tvector<U>& object) noexcept;
+    template <class U> friend size_t find_first_element(const Tvector<U>& object, const U& value);
+    template <class U> friend size_t find_last_element(const Tvector<U>& object, const U& value);
+    template <class U> friend size_t find_count_of_all_suitable_elements(const Tvector<U>& object, const U& value);
+};
+template <class T>
+size_t Tvector<T>::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 <class T>
+void Tvector<T>::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<T*>(::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 <class T>
+void Tvector<T>::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<T*>(::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 <class T>
+void Tvector<T>::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 <class T>
+void Tvector<T>::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 <class T>
+void Tvector<T>::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 <class T>
+Tvector<T>::Tvector() noexcept {
+    _size = 0;
+    _capacity = 0;
+    _data = nullptr;
+    _states = nullptr;
+    _deleted = 0;
+}
+template <class T>
+Tvector<T>::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 <class T>
+Tvector<T>::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 <class T>
+Tvector<T>::Tvector(const Tvector<T>& 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 <class T>
+Tvector<T>::~Tvector() noexcept {
+    delete[] _data;
+    delete[] _states;
+}
+template <class T>
+inline T& Tvector<T>::front() {
+    if (_size == 0) {
+        throw std::out_of_range("Vector is empty");
+    }
+    return _data[0];
+}
+template <class T>
+inline T& Tvector<T>::back() {
+    if (_size == 0) {
+        throw std::out_of_range("Vector is empty");
+    }
+    return _data[_size - 1];
+}
+template <class T>
+inline const T& Tvector<T>::front() const {
+    if (_size == 0) {
+        throw std::out_of_range("Vector is empty");
+    }
+    return _data[0];
+}
+template <class T>
+inline const T& Tvector<T>::back() const {
+    if (_size == 0) {
+        throw std::out_of_range("Vector is empty");
+    }
+    return _data[_size - 1];
+}
+template <class T>
+bool Tvector<T>::operator==(const Tvector<T>& 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 <class T>
+bool Tvector<T>::operator!=(const Tvector<T>& vector) const {
+    return !(*this == vector);
+}
+template <class T>
+Tvector<T>& Tvector<T>::operator=(const Tvector<T>& 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 <class T>
+inline const T& Tvector<T>::operator[](size_t index) const {
+    size_t real_index = get_real_position(index);
+    return _data[real_index];
+}
+template <class T>
+inline T& Tvector<T>::operator[](size_t index) {
+    size_t real_index = get_real_position(index);
+    return _data[real_index];
+}
+template <class T>
+T& Tvector<T>::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 <class T>
+const T& Tvector<T>::at(size_t index) const {
+    size_t real_index = get_real_position(index);
+    return const_cast<Tvector*>(this)->at(real_index);
+}
+template <class T>
+void Tvector<T>::assign(const Tvector<T>& 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 <class T>
+void Tvector<T>::clear() {
+    for (size_t i = 0; i < _size; ++i) {
+        if (_states[i] == State::busy) {
+            _states[i] = State::empty;
+        }
+    }
+    _size = 0;
+    _deleted = 0;
+}
+template <class T>
+void Tvector<T>::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 <class T>
+void Tvector<T>::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 <class T>
+void Tvector<T>::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 <class T>
+void Tvector<T>::push_back(const T& value) {
+    if (_size >= _capacity) {
+        reserve(_capacity + RESERVE_MEMORY);
+    }
+    _data[_size] = value;
+    _states[_size] = State::busy;
+    _size++;
+}
+template <class T>
+void Tvector<T>::pop_back() {
+    if (_size == 0) {
+        throw std::out_of_range("Vector has size = 0");
+    }
+    _states[_size - 1] = State::empty;
+    _size--;
+}
+template <class T>
+void Tvector<T>::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 <class T>
+void Tvector<T>::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<typename U>
+std::ostream& operator<<(std::ostream& out, const Tvector<U>& vector) {
+    out << "[";
+    bool first = true;
+    for (size_t i = 0; i < vector._size; ++i) {
+        if (vector._states[i] == Tvector<U>::State::busy) {
+            if (!first) out << ", ";
+            out << vector._data[i];
+            first = false;
+        }
+    }
+    out << "]";
+    return out;
+}
+template <class U>
+void shell_sort(Tvector<U>& 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 <class U>
+void shuffle(Tvector<U>& 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<size_t> 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 <class U>
+size_t find_first_element(const Tvector<U>& 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 <class U>
+size_t find_last_element(const Tvector<U>& 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 <class U>
+size_t find_count_of_all_suitable_elements(const Tvector<U>& 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;
+}

From 93de87bad2fcb0382ea63eff5f5cacd8d526651d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Tue, 16 Sep 2025 21:19:29 +0300
Subject: [PATCH 002/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=20vector.cpp?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_vector/vector.cpp | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 lib_vector/vector.cpp

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

From 123493f83c903707bb1ba71f641d340456ac454d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Tue, 16 Sep 2025 21:26:17 +0300
Subject: [PATCH 003/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=D1=8B=20=D1=82=D0=B5=D1=81=D1=82=D1=8B=20=D0=BD?=
 =?UTF-8?q?=D0=B0=20Tvector?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 tests/test_vector.cpp | 544 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 544 insertions(+)
 create mode 100644 tests/test_vector.cpp

diff --git a/tests/test_vector.cpp b/tests/test_vector.cpp
new file mode 100644
index 00000000..a2efd98d
--- /dev/null
+++ b/tests/test_vector.cpp
@@ -0,0 +1,544 @@
+// Copyright 2025 Julia Zabytina
+#include <gtest/gtest.h>
+#include "../lib_easy_example/easy_example.h"
+#include "../lib_vector/vector.h"
+TEST(TestVectorLib, default_constructor) {
+    // Arrange
+    Tvector<int> vector;
+    // Act
+    bool actual_result = vector.get_size() == 0
+        && vector.get_deleted() == 0
+        && vector.get_capacity() == 0
+        && vector.get_data() == nullptr
+        && vector.get_states() == nullptr;
+
+    // Assert
+    bool expected_result = true;
+    EXPECT_EQ(expected_result, actual_result);
+}
+TEST(TestVectorLib, constructor_with_size) {
+    // Arrange
+    size_t size = 10;
+    Tvector<int> vector(size);
+    // Act
+    bool actual_result = vector.get_size() == size
+        && vector.get_capacity() == 25
+        && vector.get_data() != nullptr
+        && vector.get_states() != nullptr
+        && vector.get_deleted() == 0;;
+
+    // Assert
+    bool expected_result = true;
+    EXPECT_EQ(expected_result, actual_result);
+}
+TEST(TestVectorLib, constructor_with_array_and_size) {
+    // Arrange
+    int data[3] = { 1,2,3 };
+    size_t size = 3;
+    Tvector<int> vector(data, size);
+    // Act
+    bool actual_result = vector.get_size() == size
+        && vector.get_capacity() == 18
+        && vector.get_data() != nullptr
+        && vector.get_states() != nullptr
+        && vector.get_data()[0] == data[0]
+        && vector.get_data()[1] == data[1]
+        && vector.get_data()[2] == data[2]
+        && vector.get_deleted() == 0;
+    // Assert
+    bool expected_result = true;
+    EXPECT_EQ(expected_result, actual_result);
+}
+TEST(TestVectorLib, copy_constructor) {
+    // Arrange
+    int data[3] = { 1,2,3 };
+    size_t size = 3;
+    Tvector<int> old_vector(data, size);
+    Tvector<int> new_vector(old_vector);
+    // Act
+    bool actual_result = old_vector == new_vector;
+    // Assert
+    bool expected_result = true;
+    EXPECT_EQ(expected_result, actual_result);
+}
+TEST(TestVectorLib, is_empty) {
+    // Arrange
+    Tvector<int> 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<int> 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<int> 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<int> 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<int> 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<int> 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<int> 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<int> 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<int> 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, сomparison_operator_true) {
+    // Arrange
+    int data[3] = { 1,2,3 };
+    size_t size = 3;
+    Tvector<int> vector1(data, size);
+    Tvector<int> vector2(data, size);
+    // Act
+    bool actual_result = vector1 == vector2;
+    // Assert
+    bool expected_result = true;
+    EXPECT_EQ(expected_result, actual_result);
+}
+TEST(TestVectorLib, сomparison_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<int> vector1(data1, size1);
+    Tvector<int> vector2(data2, size2);
+    // Act
+    bool actual_result = vector1 == vector2;
+    // Assert
+    bool expected_result = false;
+    EXPECT_EQ(expected_result, actual_result);
+}
+TEST(TestVectorLib, not_сomparison_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<int> vector1(data1, size1);
+    Tvector<int> vector2(data2, size2);
+    // Act
+    bool actual_result = vector1 != vector2;
+    // Assert
+    bool expected_result = true;
+    EXPECT_EQ(expected_result, actual_result);
+}
+TEST(TestVectorLib, not_сomparison_operator_false) {
+    // Arrange
+    int data[3] = { 1,2,3 };
+    size_t size = 3;
+    Tvector<int> vector1(data, size);
+    Tvector<int> 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<int> vector1(data1, size1);
+    Tvector<int> 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<int> 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<int> 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<int> vector1;
+    Tvector<int> vector2(data, size);
+    vector1.assign(vector2);
+    // Act
+    Tvector<int> actual_result = vector1;
+    // Assert
+    Tvector<int> expected_result = vector2;
+    EXPECT_EQ(expected_result, actual_result);
+}
+TEST(TestVectorLib, clear) {
+    // Arrange
+    int data[3] = { 1, 2, 3 };
+    Tvector<int> 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<int> 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<int> 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<int> 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<int> 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<int> 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<int> 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<int> 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<int> 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<int> 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<int> 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<int> 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<int> 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<int> 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<int> 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<int> 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<int> 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<int> vector(data, size);
+    int sorted_data[10] = { 2, 3, 7, 9, 99, 888, 1000, 1546, 8777, 1223343 };
+    Tvector<int> sorted_vector(sorted_data, size);
+    shell_sort(vector);
+    // Act
+    Tvector<int> actual_result = vector;
+    // Assert
+    Tvector<int> 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<int> 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<int> 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[7] = { 1 ,3, 3, 4, 5, 3, 3 };
+    size_t size = 7;
+    Tvector<int> 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);
+}

From 6154b19e3f69dadcbbdcf6f7e6ad9ee052c0ab5b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Thu, 18 Sep 2025 21:33:43 +0300
Subject: [PATCH 004/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=D0=BE=20=D0=BE=D0=B1=D1=8A=D1=8F=D0=B2=D0=BB=D0=B5?=
 =?UTF-8?q?=D0=BD=D0=B8=D0=B5=20=D0=BA=D0=BB=D0=B0=D1=81=D1=81=D0=B0=20Mat?=
 =?UTF-8?q?hVector?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_math_vector/math_vector.h | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 lib_math_vector/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..06fade6a
--- /dev/null
+++ b/lib_math_vector/math_vector.h
@@ -0,0 +1,21 @@
+#pragma once
+#include "../lib_vector/vector.h"
+template <class T>
+class MathVector : public Tvector<T> {
+public:
+    MathVector();
+    MathVector(size_t size);
+    MathVector(T* data, size_t size);
+    MathVector(const MathVector<T>& other);
+    virtual ~MathVector();
+};
+template<class T>
+MathVector<T>::MathVector() : Tvector<T>() {}
+template <class T>
+MathVector<T>::MathVector(size_t size) : Tvector<T>(size) {}
+template <class T>
+MathVector<T>::MathVector(T* data, size_t size) : Tvector<T>(data, size) {} 
+template <class T>
+MathVector<T>::MathVector(const MathVector<T>& other) : Tvector<T>(other) {}
+template <class T>
+MathVector<T>::~MathVector() = default;

From 651f9e2ba5d6367a364910ad332e9dd6e49a85ec Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Thu, 18 Sep 2025 21:38:06 +0300
Subject: [PATCH 005/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=20=D0=BA=D0=BB=D0=B0=D1=81=D1=81=20MathVector=20?=
 =?UTF-8?q?=D1=81=20=D0=B7=D0=B0=D0=B3=D0=BE=D0=BB=D0=BE=D0=B2=D0=BE=D1=87?=
 =?UTF-8?q?=D0=BD=D1=8B=D0=BC=20=D1=84=D0=B0=D0=B9=D0=BB=D0=BE=D0=BC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_math_vector/math_vector.cpp | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 lib_math_vector/math_vector.cpp

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"

From cf7252ef0cc3850f6d3cfc475dec244c4d008472 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Thu, 18 Sep 2025 21:50:37 +0300
Subject: [PATCH 006/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=D0=BE=20=D0=BE=D0=B1=D1=8A=D1=8F=D0=B2=D0=BB=D0=B5?=
 =?UTF-8?q?=D0=BD=D0=B8=D0=B5=20=D0=BA=D0=BB=D0=B0=D1=81=D1=81=D0=B0=20Mat?=
 =?UTF-8?q?rix?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_matrix/matrix.h | 185 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 185 insertions(+)
 create mode 100644 lib_matrix/matrix.h

diff --git a/lib_matrix/matrix.h b/lib_matrix/matrix.h
new file mode 100644
index 00000000..ac69b563
--- /dev/null
+++ b/lib_matrix/matrix.h
@@ -0,0 +1,185 @@
+#pragma once
+#include "../lib_math_vector/math_vector.h"
+template <class T>
+class Matrix : public MathVector<MathVector<T>> {
+protected:
+    size_t _M;
+    size_t _N;
+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 {
+        return _M;
+    }
+    size_t getN() const {
+        return _N;
+    }
+    Matrix<T> operator + (T value) const;
+    Matrix<T> operator - (T value) const;
+    Matrix<T> operator * (T value) const;
+    Matrix<T> operator / (T value) const;
+
+    Matrix<T>& operator += (T value);
+    Matrix<T>& operator -= (T value);
+    Matrix<T>& operator *= (T value);
+    Matrix<T>& operator /= (T value);
+
+    Matrix<T> operator + (const MathVector<T>& vector) const;
+    Matrix<T> operator - (const MathVector<T>& vector) const;
+    MathVector<T> operator * (const MathVector<T>& vector) const;
+
+    Matrix<T>& operator += (const MathVector<T>& vector);
+    Matrix<T>& operator -= (const MathVector<T>& vector);
+
+    Matrix<T> operator + (const Matrix<T>& other_matrix) const;
+    Matrix<T> operator - (const Matrix<T>& other_matrix) const;
+    Matrix<T> operator * (const Matrix<T>& other_matrix) const;
+
+    Matrix<T>& operator += (const Matrix<T>& other_matrix);
+    Matrix<T>& operator -= (const Matrix<T>& other_matrix);
+    Matrix<T>& operator *= (const Matrix<T>& other_matrix);
+
+    friend std::ostream& operator<< (std::ostream& out, const Matrix<T>& matrix);
+    MathVector<T>& operator[](size_t index);
+    const MathVector<T>& operator[](size_t index) const;
+
+
+};
+template <class T>
+Matrix<T>::Matrix() : MathVector<MathVector<T>>(), _M(0), _N(0) {}
+template <class T>
+Matrix<T>::Matrix(size_t M, size_t N) : MathVector<MathVector<T>>(M) {
+    _M = M;
+    _N = N;
+    for (size_t i = 0; i < M; ++i) {
+        (*this)[i] = MathVector<T>(N);
+    }
+}
+template <class T>
+Matrix<T>::Matrix(T* data, size_t M, size_t N) : MathVector<MathVector<T>>(M) {
+    _M = M;
+    _N = N;
+    for (size_t i = 0; i < M; ++i) {
+        (*this)[i] = MathVector<T>(data + i * N, N);
+    }
+}
+template <class T>
+Matrix<T>::Matrix(const Matrix& other) :
+    MathVector<MathVector<T>>(other), _M(other._M), _N(other._N) {}
+template <class T>
+Matrix<T>::~Matrix() = default;
+
+template <class T>
+std::ostream& operator<<(std::ostream& out, const Matrix<T>& 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;
+}
+
+template <class T>
+Matrix<T> Matrix<T>::operator + (T value) const {
+    Matrix<T> matrix;
+    return matrix;
+}
+template <class T>
+Matrix<T> Matrix<T>::operator - (T value) const {
+    Matrix<T> matrix;
+    return matrix;
+}
+template <class T>
+Matrix<T> Matrix<T>::operator * (T value) const {
+    Matrix<T> matrix;
+    return matrix;
+}
+template <class T>
+Matrix<T> Matrix<T>::operator / (T value) const {
+    Matrix<T> matrix;
+    return matrix;
+}
+
+template <class T>
+Matrix<T>& Matrix<T>::operator += (T value) {
+    return *this;
+}
+template <class T>
+Matrix<T>& Matrix<T>::operator -= (T value) {
+    return *this;
+
+}
+template <class T>
+Matrix<T>& Matrix<T>::operator *= (T value) {
+    return *this;
+}
+template <class T>
+Matrix<T>& Matrix<T>::operator /= (T value) {
+    return *this;
+}
+
+template <class T>
+Matrix<T> Matrix<T>::operator + (const MathVector<T>& vector) const {
+    Matrix<T> matrix;
+    return matrix;
+}
+template <class T>
+Matrix<T> Matrix<T>::operator - (const MathVector<T>& vector) const {
+    Matrix<T> matrix;
+    return matrix;
+}
+template <class T>
+MathVector<T> Matrix<T>::operator * (const MathVector<T>& vector) const {
+    Matrix<T> matrix;
+    return matrix;
+}
+
+template <class T>
+Matrix<T>& Matrix<T>::operator += (const MathVector<T>& vector) {
+    return *this;
+}
+template <class T>
+Matrix<T>& Matrix<T>::operator -= (const MathVector<T>& vector) {
+    return *this;
+}
+
+template <class T>
+Matrix<T> Matrix<T>::operator + (const Matrix<T>& other_matrix) const {
+    Matrix<T> matrix;
+    return matrix;
+}
+template <class T>
+Matrix<T> Matrix<T>::operator - (const Matrix<T>& other_matrix) const {
+    Matrix<T> matrix;
+    return matrix;
+}
+template <class T>
+Matrix<T> Matrix<T>::operator * (const Matrix<T>& other_matrix) const {
+    Matrix<T> matrix;
+    return matrix;
+}
+
+template <class T>
+Matrix<T>& Matrix<T>::operator += (const Matrix<T>& other_matrix) {
+    return *this;
+}
+template <class T>
+Matrix<T>& Matrix<T>::operator -= (const Matrix<T>& other_matrix) {
+    return *this;
+}
+template <class T>
+Matrix<T>& Matrix<T>::operator *= (const Matrix<T>& other_matrix) {
+    return *this;
+}
+template <class T>
+MathVector<T>& Matrix<T>::operator[](size_t index) {
+    return MathVector<MathVector<T>>::operator[](index);
+}
+template <class T>
+const MathVector<T>& Matrix<T>::operator[](size_t index) const {
+    return MathVector<MathVector<T>>::operator[](index);
+}

From 2eb45df9db623d6c2f54e140d2008f1fb7917f34 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Thu, 18 Sep 2025 21:56:47 +0300
Subject: [PATCH 007/109] =?UTF-8?q?=D0=9D=D0=B5=D0=B1=D0=BE=D0=BB=D1=8C?=
 =?UTF-8?q?=D1=88=D0=B8=D0=B5=20=D0=B8=D0=B7=D0=BC=D0=B5=D0=BD=D0=B5=D0=BD?=
 =?UTF-8?q?=D0=B8=D1=8F=20(=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE?=
 =?UTF-8?q?=D1=80=20=D0=B2=D1=8B=D0=B2=D0=BE=D0=B4=D0=B0=20=D1=82=D0=B5?=
 =?UTF-8?q?=D0=BF=D0=B5=D1=80=D1=8C=20=D0=B2=D0=BD=D1=83=D1=82=D1=80=D0=B8?=
 =?UTF-8?q?=20=D0=BA=D0=BB=D0=B0=D1=81=D1=81=D0=B0)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_matrix/matrix.h | 21 +++++++++------------
 1 file changed, 9 insertions(+), 12 deletions(-)

diff --git a/lib_matrix/matrix.h b/lib_matrix/matrix.h
index ac69b563..4ff9c5c9 100644
--- a/lib_matrix/matrix.h
+++ b/lib_matrix/matrix.h
@@ -42,7 +42,15 @@ class Matrix : public MathVector<MathVector<T>> {
     Matrix<T>& operator -= (const Matrix<T>& other_matrix);
     Matrix<T>& operator *= (const Matrix<T>& other_matrix);
 
-    friend std::ostream& operator<< (std::ostream& out, const Matrix<T>& matrix);
+    friend std::ostream& operator<< (std::ostream& out, const Matrix<T>& 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;
+    }
     MathVector<T>& operator[](size_t index);
     const MathVector<T>& operator[](size_t index) const;
 
@@ -72,17 +80,6 @@ Matrix<T>::Matrix(const Matrix& other) :
 template <class T>
 Matrix<T>::~Matrix() = default;
 
-template <class T>
-std::ostream& operator<<(std::ostream& out, const Matrix<T>& 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;
-}
-
 template <class T>
 Matrix<T> Matrix<T>::operator + (T value) const {
     Matrix<T> matrix;

From ce081481f7c12cb8b2b124f94e8c16a6e0b38df5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Thu, 18 Sep 2025 21:57:42 +0300
Subject: [PATCH 008/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=D0=BE=20=D0=BE=D0=B1=D1=8A=D1=8F=D0=B2=D0=BB=D0=B5?=
 =?UTF-8?q?=D0=BD=D0=B8=D0=B5=20=D0=BA=D0=BB=D0=B0=D1=81=D1=81=D0=B0=20Tri?=
 =?UTF-8?q?angle=20Matrix?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_triangle_matrix/triangle_matrix.h | 145 ++++++++++++++++++++++++++
 1 file changed, 145 insertions(+)
 create mode 100644 lib_triangle_matrix/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..452dd223
--- /dev/null
+++ b/lib_triangle_matrix/triangle_matrix.h
@@ -0,0 +1,145 @@
+#pragma once 
+#include "../lib_matrix/matrix.h"
+template <class T>
+class TriangleMatrix : public Matrix<T> {
+public: 
+    TriangleMatrix();
+    TriangleMatrix(size_t M, size_t N);
+    TriangleMatrix(T* data, size_t M, size_t N);
+    TriangleMatrix(const TriangleMatrix& other);
+    ~TriangleMatrix();
+
+    TriangleMatrix<T> operator + (T value) const;
+    TriangleMatrix<T> operator - (T value) const;
+    TriangleMatrix<T> operator * (T value) const;
+    TriangleMatrix<T> operator / (T value) const;
+
+    TriangleMatrix<T>& operator += (T value);
+    TriangleMatrix<T>& operator -= (T value);
+    TriangleMatrix<T>& operator *= (T value);
+    TriangleMatrix<T>& operator /= (T value);
+
+    TriangleMatrix<T> operator + (const MathVector<T>& vector) const;
+    TriangleMatrix<T> operator - (const MathVector<T>& vector) const;
+    MathVector<T> operator * (const MathVector<T>& vector) const;
+
+    TriangleMatrix<T>& operator += (const MathVector<T>& vector);
+    TriangleMatrix<T>& operator -= (const MathVector<T>& vector);
+
+    TriangleMatrix<T> operator + (const TriangleMatrix<T>& other_matrix) const;
+    TriangleMatrix<T> operator - (const TriangleMatrix<T>& other_matrix) const;
+    TriangleMatrix<T> operator * (const TriangleMatrix<T>& other_matrix) const;
+
+    TriangleMatrix<T>& operator += (const TriangleMatrix<T>& other_matrix);
+    TriangleMatrix<T>& operator -= (const TriangleMatrix<T>& other_matrix);
+    TriangleMatrix<T>& operator *= (const TriangleMatrix<T>& other_matrix);
+
+    friend std::ostream& operator<<(std::ostream& out, const TriangleMatrix<T>& 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;
+    }
+};
+template <class T>
+TriangleMatrix<T>::TriangleMatrix() : Matrix<T>() {}
+template <class T>
+TriangleMatrix<T>::TriangleMatrix(const TriangleMatrix& other) : Matrix<T>(other) {}
+template <class T>
+TriangleMatrix<T>::~TriangleMatrix() = default;
+
+template <class T>
+TriangleMatrix<T> TriangleMatrix<T>::operator + (T value) const {
+    TriangleMatrix<T> matrix;
+    return matrix;
+}
+template <class T>
+TriangleMatrix<T> TriangleMatrix<T>::operator - (T value) const {
+    TriangleMatrix<T> matrix;
+    return matrix;
+}
+template <class T>
+TriangleMatrix<T> TriangleMatrix<T>::operator * (T value) const {
+    TriangleMatrix<T> matrix;
+    return matrix;
+}
+template <class T>
+TriangleMatrix<T> TriangleMatrix<T>::operator / (T value) const {
+    TriangleMatrix<T> matrix;
+    return matrix;
+}
+
+template <class T>
+TriangleMatrix<T>& TriangleMatrix<T>::operator += (T value) {
+    return *this;
+}
+template <class T>
+TriangleMatrix<T>& TriangleMatrix<T>::operator -= (T value) {
+    return *this;
+
+}
+template <class T>
+TriangleMatrix<T>& TriangleMatrix<T>::operator *= (T value) {
+    return *this;
+}
+template <class T>
+TriangleMatrix<T>& TriangleMatrix<T>::operator /= (T value) {
+    return *this;
+}
+
+template <class T>
+TriangleMatrix<T> TriangleMatrix<T>::operator + (const MathVector<T>& vector) const {
+    TriangleMatrix<T> matrix;
+    return matrix;
+}
+template <class T>
+TriangleMatrix<T> TriangleMatrix<T>::operator - (const MathVector<T>& vector) const {
+    TriangleMatrix<T> matrix;
+    return matrix;
+}
+template <class T>
+MathVector<T> TriangleMatrix<T>::operator * (const MathVector<T>& vector) const {
+    TriangleMatrix<T> matrix;
+    return matrix;
+}
+
+template <class T>
+TriangleMatrix<T>& TriangleMatrix<T>::operator += (const MathVector<T>& vector) {
+    return *this;
+}
+template <class T>
+TriangleMatrix<T>& TriangleMatrix<T>::operator -= (const MathVector<T>& vector) {
+    return *this;
+}
+
+template <class T>
+TriangleMatrix<T> TriangleMatrix<T>::operator + (const TriangleMatrix<T>& other_matrix) const {
+    TriangleMatrix<T> matrix;
+    return matrix;
+}
+template <class T>
+TriangleMatrix<T> TriangleMatrix<T>::operator - (const TriangleMatrix<T>& other_matrix) const {
+    TriangleMatrix<T> matrix;
+    return matrix;
+}
+template <class T>
+TriangleMatrix<T> TriangleMatrix<T>::operator * (const TriangleMatrix<T>& other_matrix) const {
+    TriangleMatrix<T> matrix;
+    return matrix;
+}
+
+template <class T>
+TriangleMatrix<T>& TriangleMatrix<T>::operator += (const TriangleMatrix<T>& other_matrix) {
+    return *this;
+}
+template <class T>
+TriangleMatrix<T>& TriangleMatrix<T>::operator -= (const TriangleMatrix<T>& other_matrix) {
+    return *this;
+}
+template <class T>
+TriangleMatrix<T>& TriangleMatrix<T>::operator *= (const TriangleMatrix<T>& other_matrix) {
+    return *this;
+}

From bf8c4e62e1cfc6ba93d6acd3422610ca987044d5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Thu, 18 Sep 2025 22:40:35 +0300
Subject: [PATCH 009/109] =?UTF-8?q?=D0=98=D1=81=D0=BF=D1=80=D0=B0=D0=B2?=
 =?UTF-8?q?=D0=BB=D0=B5=D0=BD=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE?=
 =?UTF-8?q?=D1=80=20=D1=83=D0=BC=D0=BD=D0=BE=D0=B6=D0=B5=D0=BD=D0=B8=D1=8F?=
 =?UTF-8?q?=20=D0=BC=D0=B0=D1=82=D1=80=D0=B8=D1=86=D1=8B=20=D0=BD=D0=B0=20?=
 =?UTF-8?q?=D0=B2=D0=B5=D0=BA=D1=82=D0=BE=D1=80=20(=D0=B1=D1=8B=D0=BB?=
 =?UTF-8?q?=D0=B0=20=D0=BE=D1=88=D0=B8=D0=B1=D0=BA=D0=B0=20=D1=81=20=D1=82?=
 =?UTF-8?q?=D0=B8=D0=BF=D0=BE=D0=BC=20=D0=B2=D0=BE=D0=B7=D0=B2=D1=80=D0=B0?=
 =?UTF-8?q?=D1=89=D0=B0=D0=B5=D0=BC=D0=BE=D0=B3=D0=BE=20=D0=B7=D0=BD=D0=B0?=
 =?UTF-8?q?=D1=87=D0=B5=D0=BD=D0=B8=D1=8F)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_matrix/matrix.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib_matrix/matrix.h b/lib_matrix/matrix.h
index 4ff9c5c9..501d93f5 100644
--- a/lib_matrix/matrix.h
+++ b/lib_matrix/matrix.h
@@ -131,8 +131,8 @@ Matrix<T> Matrix<T>::operator - (const MathVector<T>& vector) const {
 }
 template <class T>
 MathVector<T> Matrix<T>::operator * (const MathVector<T>& vector) const {
-    Matrix<T> matrix;
-    return matrix;
+    MathVector<T> math_vector;
+    return math_vector;
 }
 
 template <class T>

From 7117587eb8c6fb503c75ae167f1cea3ec601d7c9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Thu, 18 Sep 2025 22:51:02 +0300
Subject: [PATCH 010/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=D0=B0=20=D1=80=D0=B5=D0=B0=D0=BB=D0=B8=D0=B7=D0=B0?=
 =?UTF-8?q?=D1=86=D0=B8=D1=8F=20=D0=B8=D0=BD=D1=82=D0=B5=D1=80=D1=84=D0=B5?=
 =?UTF-8?q?=D0=B9=D1=81=D0=B0=20=D0=BA=D0=B0=D0=BB=D1=8C=D0=BA=D1=83=D0=BB?=
 =?UTF-8?q?=D1=8F=D1=82=D0=BE=D1=80=D0=B0=20=D0=BC=D0=B0=D1=82=D1=80=D0=B8?=
 =?UTF-8?q?=D1=86?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 main/main.cpp | 282 +++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 278 insertions(+), 4 deletions(-)

diff --git a/main/main.cpp b/main/main.cpp
index 217f8971..0bc47c59 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 <iostream>
 #include <iomanip>
 #include "../lib_easy_example/easy_example.h"
@@ -34,4 +35,277 @@ int main() {
   return 0;
 }
 
-#endif  // EASY_EXAMPLE
+#endif
+#ifdef CIRCLES_AND_SPHERES
+#include <iostream>
+#include <cmath>
+#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 <iostream>
+#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 << "|     КАЛЬКУЛЯТОР ДЛЯ РАЗЛИЧНЫХ МАТРИЦ   |\n";
+    std::cout << "|          (обычные и треугольные)       |\n";
+    std::cout << "==========================================\n";
+    std::cout << "\n";
+    std::cout << "ГЛАВНОЕ МЕНЮ =====\n";
+    std::cout << " 1.Сложение матриц\n";
+    std::cout << " 2.Вычитание матриц\n";
+    std::cout << " 3.Умножение матриц\n";
+    std::cout << " 4.Прибавить скаляр к матрице\n";
+    std::cout << " 5.Вычесть скаляр из матрицы\n";
+    std::cout << " 6.Умножить матрицу на скаляр\n";
+    std::cout << " 7.Деление на скаляр\n";
+    std::cout << " 8.Прибавить к матрице вектор\n";
+    std::cout << " 9.Вычесть вектор из матрицы\n";
+    std::cout << " 10.Умножить матрицу на вектор\n";
+    std::cout << " 11.Выйти\n";
+}
+int main() {
+    setlocale(LC_ALL, "Russian");
+    int user_choice;
+    do {
+        printMainMenu();
+        std::cout << "Ваш выбор: ";
+        std::cin >> user_choice;
+
+        if (user_choice == 11) {
+            break;
+        }
+        int matrix_type;
+        std::cout << "Выберите тип матрицы:\n";
+        std::cout << "1. Обычная матрица\n";
+        std::cout << "2. Треугольная матрица\n";
+        std::cin >> matrix_type;
+
+        size_t M, N;
+        std::cout << "Введите размеры матрицы 1 (M - кол-во строк, N - кол-во столбцов)\n";
+        std::cout << "M = ";
+        std::cin >> M;
+        std::cout << "N = ";
+        std::cin >> N;
+
+        Matrix<int> matrix1(M, N);
+
+        std::cout << "Введите элементы матрицы 1:\n";
+        system("pause");
+
+        switch (user_choice) {
+        case 1: {
+            size_t K, L;
+            std::cout << "Введите размеры матрицы 2 (K - кол-во строк, L - кол-во столбцов)\n";
+            std::cout << "K = ";
+            std::cin >> K;
+            std::cout << "L = ";
+            std::cin >> L;
+            Matrix<int> matrix2(K, L);
+
+            std::cout << "Введите элементы матрицы 2:\n";
+            system("pause");
+            Matrix<int> result = matrix1 + matrix2;
+            std::cout << "Результат:\n" << result;
+            break;
+        }
+        case 2: {
+            size_t K, L;
+            std::cout << "Введите размеры матрицы 2 (K - кол-во строк, L - кол-во столбцов)\n";
+            std::cout << "K = ";
+            std::cin >> K;
+            std::cout << "L = ";
+            std::cin >> L;
+            Matrix<int> matrix2(K, L);
+
+            std::cout << "Введите элементы матрицы 2:\n";
+            system("pause");
+            Matrix<int> result = matrix1 - matrix2;
+            std::cout << "Результат:\n" << result;
+            break;
+        }
+        case 3: {
+            size_t K, L;
+            std::cout << "Введите размеры матрицы 2 (K - кол-во строк, L - кол-во столбцов)\n";
+            std::cout << "K = ";
+            std::cin >> K;
+            std::cout << "L = ";
+            std::cin >> L;
+            Matrix<int> matrix2(K, L);
+
+            std::cout << "Введите элементы матрицы 2:\n";
+            system("pause");
+            Matrix<int> result = matrix1 * matrix2;
+            std::cout << "Результат:\n" << result;
+            break;
+        }
+        case 4: {
+            int scalar;
+            std::cout << "Введите скаляр:\n";
+            std::cin >> scalar;
+            system("pause");
+            Matrix<int> result = matrix1 + scalar;
+            std::cout << "Результат:\n" << result;
+            break;
+        }
+        case 5: {
+            int scalar;
+            std::cout << "Введите скаляр:\n";
+            std::cin >> scalar;
+            system("pause");
+            Matrix<int> result = matrix1 - scalar;
+            std::cout << "Результат:\n" << result;
+            break;
+        }
+        case 6: {
+            int scalar;
+            std::cout << "Введите скаляр:\n";
+            std::cin >> scalar;
+            system("pause");
+            Matrix<int> result = matrix1 * scalar;
+            std::cout << "Результат:\n" << result;
+            break;
+        }
+        case 7: {
+            int scalar;
+            std::cout << "Введите скаляр:\n";
+            std::cin >> scalar;
+            system("pause");
+            Matrix<int> result = matrix1 / scalar;
+            std::cout << "Результат:\n" << result;
+            break;
+        }
+        case 8: {
+            size_t size;
+            std::cout << "Введите размер вектора:\n";
+            std::cin >> size;
+            MathVector<int> mathvector(size);
+
+            std::cout << "Введите элементы вектора:\n";
+            system("pause");
+            Matrix<int> result = matrix1 + mathvector;
+            std::cout << "Результат:\n" << result;
+            break;
+        }
+        case 9: {
+            size_t size;
+            std::cout << "Введите размер вектора:\n";
+            std::cin >> size;
+            MathVector<int> mathvector(size);
+
+            std::cout << "Введите элементы вектора:\n";
+            system("pause");
+            Matrix<int> result = matrix1 - mathvector;
+            std::cout << "Результат:\n" << result;
+            break;
+        }
+        case 10: {
+            size_t size;
+            std::cout << "Введите размер вектора:\n";
+            std::cin >> size;
+            MathVector<int> mathvector(size);
+
+            std::cout << "Введите элементы вектора:\n";
+            system("pause");
+            MathVector<int> result = matrix1 * mathvector;
+            std::cout << "Результат:\n" << result;
+            break;
+        }  
+        default: {
+            std::cout << "Неверный ввод! Попробуйте снова\n";
+            break;
+        }
+                }
+        std::cout << "\n Нажмите Enter для продолжения...";
+        std::cin.ignore();
+        std::cin.get();
+    } while (true);
+
+    return 0;
+}
+#endif
+

From 3a852a2672981a621ac31d6dde231cda0497b22e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Thu, 18 Sep 2025 22:58:10 +0300
Subject: [PATCH 011/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=D0=B0=20=D1=80=D0=B5=D0=B0=D0=BB=D0=B8=D0=B7=D0=B0?=
 =?UTF-8?q?=D1=86=D0=B8=D1=8F=20=D0=B8=D0=BD=D1=82=D0=B5=D1=80=D1=84=D0=B5?=
 =?UTF-8?q?=D0=B9=D1=81=D0=B0=20=D0=BA=D0=B0=D0=BB=D1=8C=D0=BA=D1=83=D0=BB?=
 =?UTF-8?q?=D1=8F=D1=82=D0=BE=D1=80=D0=B0=20=D0=BC=D0=B0=D1=82=D1=80=D0=B8?=
 =?UTF-8?q?=D1=86=20=D1=81=20=D0=BD=D0=B0=D0=B4=D0=BF=D0=B8=D1=81=D1=8F?=
 =?UTF-8?q?=D0=BC=D0=B8=20=D0=BD=D0=B0=20=D0=B0=D0=BD=D0=B3=D0=BB=D0=B8?=
 =?UTF-8?q?=D0=B9=D1=81=D0=BA=D0=BE=D0=BC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 main/main.cpp | 101 +++++++++++++++++++++++++-------------------------
 1 file changed, 51 insertions(+), 50 deletions(-)

diff --git a/main/main.cpp b/main/main.cpp
index 0bc47c59..e65391ee 100644
--- a/main/main.cpp
+++ b/main/main.cpp
@@ -131,42 +131,43 @@ int main() {
 
 void printMainMenu() {
     std::cout << "==========================================\n";
-    std::cout << "|     КАЛЬКУЛЯТОР ДЛЯ РАЗЛИЧНЫХ МАТРИЦ   |\n";
-    std::cout << "|          (обычные и треугольные)       |\n";
+    std::cout << "|     CALCULATOR FOR VARIOUS MATRICES     |\n";
+    std::cout << "|       (REGULAR AND TRIANGULAR)          |\n";
     std::cout << "==========================================\n";
     std::cout << "\n";
-    std::cout << "ГЛАВНОЕ МЕНЮ =====\n";
-    std::cout << " 1.Сложение матриц\n";
-    std::cout << " 2.Вычитание матриц\n";
-    std::cout << " 3.Умножение матриц\n";
-    std::cout << " 4.Прибавить скаляр к матрице\n";
-    std::cout << " 5.Вычесть скаляр из матрицы\n";
-    std::cout << " 6.Умножить матрицу на скаляр\n";
-    std::cout << " 7.Деление на скаляр\n";
-    std::cout << " 8.Прибавить к матрице вектор\n";
-    std::cout << " 9.Вычесть вектор из матрицы\n";
-    std::cout << " 10.Умножить матрицу на вектор\n";
-    std::cout << " 11.Выйти\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. Add scalar to matrix\n";
+    std::cout << " 5. Subtract scalar from matrix\n";
+    std::cout << " 6. Multiply matrix by scalar\n";
+    std::cout << " 7. Division by scalar\n";
+    std::cout << " 8. Add vector to matrix\n";
+    std::cout << " 9. Subtract vector from matrix\n";
+    std::cout << " 10. Multiply matrix by vector\n";
+    std::cout << " 11. Exit\n";
 }
+
 int main() {
     setlocale(LC_ALL, "Russian");
     int user_choice;
     do {
         printMainMenu();
-        std::cout << "Ваш выбор: ";
+        std::cout << "Your choice: ";
         std::cin >> user_choice;
 
         if (user_choice == 11) {
             break;
         }
         int matrix_type;
-        std::cout << "Выберите тип матрицы:\n";
-        std::cout << "1. Обычная матрица\n";
-        std::cout << "2. Треугольная матрица\n";
+        std::cout << "Choose matrix type:\n";
+        std::cout << "1. Regular matrix\n";
+        std::cout << "2. Triangular matrix\n";
         std::cin >> matrix_type;
 
         size_t M, N;
-        std::cout << "Введите размеры матрицы 1 (M - кол-во строк, N - кол-во столбцов)\n";
+        std::cout << "Enter dimensions of matrix 1 (M - rows, N - columns)\n";
         std::cout << "M = ";
         std::cin >> M;
         std::cout << "N = ";
@@ -174,133 +175,133 @@ int main() {
 
         Matrix<int> matrix1(M, N);
 
-        std::cout << "Введите элементы матрицы 1:\n";
+        std::cout << "Enter elements of matrix 1:\n";
         system("pause");
 
         switch (user_choice) {
         case 1: {
             size_t K, L;
-            std::cout << "Введите размеры матрицы 2 (K - кол-во строк, L - кол-во столбцов)\n";
+            std::cout << "Enter dimensions of matrix 2 (K - rows, L - columns)\n";
             std::cout << "K = ";
             std::cin >> K;
             std::cout << "L = ";
             std::cin >> L;
             Matrix<int> matrix2(K, L);
 
-            std::cout << "Введите элементы матрицы 2:\n";
+            std::cout << "Enter elements of matrix 2:\n";
             system("pause");
             Matrix<int> result = matrix1 + matrix2;
-            std::cout << "Результат:\n" << result;
+            std::cout << "Result:\n" << result;
             break;
         }
         case 2: {
             size_t K, L;
-            std::cout << "Введите размеры матрицы 2 (K - кол-во строк, L - кол-во столбцов)\n";
+            std::cout << "Enter dimensions of matrix 2 (K - rows, L - columns)\n";
             std::cout << "K = ";
             std::cin >> K;
             std::cout << "L = ";
             std::cin >> L;
             Matrix<int> matrix2(K, L);
 
-            std::cout << "Введите элементы матрицы 2:\n";
+            std::cout << "Enter elements of matrix 2:\n";
             system("pause");
             Matrix<int> result = matrix1 - matrix2;
-            std::cout << "Результат:\n" << result;
+            std::cout << "Result:\n" << result;
             break;
         }
         case 3: {
             size_t K, L;
-            std::cout << "Введите размеры матрицы 2 (K - кол-во строк, L - кол-во столбцов)\n";
+            std::cout << "Enter dimensions of matrix 2 (K - rows, L - columns)\n";
             std::cout << "K = ";
             std::cin >> K;
             std::cout << "L = ";
             std::cin >> L;
             Matrix<int> matrix2(K, L);
 
-            std::cout << "Введите элементы матрицы 2:\n";
+            std::cout << "Enter elements of matrix 2:\n";
             system("pause");
             Matrix<int> result = matrix1 * matrix2;
-            std::cout << "Результат:\n" << result;
+            std::cout << "Result:\n" << result;
             break;
         }
         case 4: {
             int scalar;
-            std::cout << "Введите скаляр:\n";
+            std::cout << "Enter scalar:\n";
             std::cin >> scalar;
             system("pause");
             Matrix<int> result = matrix1 + scalar;
-            std::cout << "Результат:\n" << result;
+            std::cout << "Result:\n" << result;
             break;
         }
         case 5: {
             int scalar;
-            std::cout << "Введите скаляр:\n";
+            std::cout << "Enter scalar:\n";
             std::cin >> scalar;
             system("pause");
             Matrix<int> result = matrix1 - scalar;
-            std::cout << "Результат:\n" << result;
+            std::cout << "Result:\n" << result;
             break;
         }
         case 6: {
             int scalar;
-            std::cout << "Введите скаляр:\n";
+            std::cout << "Enter scalar:\n";
             std::cin >> scalar;
             system("pause");
             Matrix<int> result = matrix1 * scalar;
-            std::cout << "Результат:\n" << result;
+            std::cout << "Result:\n" << result;
             break;
         }
         case 7: {
             int scalar;
-            std::cout << "Введите скаляр:\n";
+            std::cout << "Enter scalar:\n";
             std::cin >> scalar;
             system("pause");
             Matrix<int> result = matrix1 / scalar;
-            std::cout << "Результат:\n" << result;
+            std::cout << "Result:\n" << result;
             break;
         }
         case 8: {
             size_t size;
-            std::cout << "Введите размер вектора:\n";
+            std::cout << "Enter vector size:\n";
             std::cin >> size;
             MathVector<int> mathvector(size);
 
-            std::cout << "Введите элементы вектора:\n";
+            std::cout << "Enter vector elements:\n";
             system("pause");
             Matrix<int> result = matrix1 + mathvector;
-            std::cout << "Результат:\n" << result;
+            std::cout << "Result:\n" << result;
             break;
         }
         case 9: {
             size_t size;
-            std::cout << "Введите размер вектора:\n";
+            std::cout << "Enter vector size:\n";
             std::cin >> size;
             MathVector<int> mathvector(size);
 
-            std::cout << "Введите элементы вектора:\n";
+            std::cout << "Enter vector elements:\n";
             system("pause");
             Matrix<int> result = matrix1 - mathvector;
-            std::cout << "Результат:\n" << result;
+            std::cout << "Result:\n" << result;
             break;
         }
         case 10: {
             size_t size;
-            std::cout << "Введите размер вектора:\n";
+            std::cout << "Enter vector size:\n";
             std::cin >> size;
             MathVector<int> mathvector(size);
 
-            std::cout << "Введите элементы вектора:\n";
+            std::cout << "Enter vector elements:\n";
             system("pause");
             MathVector<int> result = matrix1 * mathvector;
-            std::cout << "Результат:\n" << result;
+            std::cout << "Result:\n" << result;
             break;
-        }  
+        }
         default: {
-            std::cout << "Неверный ввод! Попробуйте снова\n";
+            std::cout << "Invalid input! Please try again\n";
             break;
         }
-                }
-        std::cout << "\n Нажмите Enter для продолжения...";
+        }
+        std::cout << "\n Press Enter to continue...";
         std::cin.ignore();
         std::cin.get();
     } while (true);

From 60a7ff1afb3da1365ad4236196d6f70ccfe64ccc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Fri, 26 Sep 2025 18:27:29 +0300
Subject: [PATCH 012/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=D0=B0=20=D1=80=D0=B5=D0=B0=D0=BB=D0=B8=D0=B7=D0=B0?=
 =?UTF-8?q?=D1=86=D0=B8=D1=8F=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE?=
 =?UTF-8?q?=D1=80=D0=BE=D0=B2=20*,=20/,=20*=3D,=20/=3D=20(=D0=B2=D0=B5?=
 =?UTF-8?q?=D0=BA=D1=82=D0=BE=D1=80=20=D0=B8=20=D1=87=D0=B8=D1=81=D0=BB?=
 =?UTF-8?q?=D0=BE)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_math_vector/math_vector.h | 48 +++++++++++++++++++++++++++++++++++
 1 file changed, 48 insertions(+)

diff --git a/lib_math_vector/math_vector.h b/lib_math_vector/math_vector.h
index 06fade6a..ab55d7cc 100644
--- a/lib_math_vector/math_vector.h
+++ b/lib_math_vector/math_vector.h
@@ -1,4 +1,5 @@
 #pragma once
+#include <stdexcept> 
 #include "../lib_vector/vector.h"
 template <class T>
 class MathVector : public Tvector<T> {
@@ -8,6 +9,14 @@ class MathVector : public Tvector<T> {
     MathVector(T* data, size_t size);
     MathVector(const MathVector<T>& other);
     virtual ~MathVector();
+
+    MathVector<T> operator * (T value) const;
+    MathVector<T> operator / (T value) const;
+
+    MathVector<T>& operator *= (T value);
+    MathVector<T>& operator /= (T value);
+
+
 };
 template<class T>
 MathVector<T>::MathVector() : Tvector<T>() {}
@@ -19,3 +28,42 @@ template <class T>
 MathVector<T>::MathVector(const MathVector<T>& other) : Tvector<T>(other) {}
 template <class T>
 MathVector<T>::~MathVector() = default;
+
+template <class T>
+MathVector<T> MathVector<T>::operator * (T value) const {
+    MathVector<T> result(this->get_size());
+    for (size_t i = 0; i < this->get_size(); ++i) {
+        result[i] = this->get_data()[i] * value;
+    }
+    return result;
+}
+template <class T>
+MathVector<T> MathVector<T>::operator / (T value) const {
+    if (value == 0) {
+        throw std::logic_error("Can't divide by zero!");
+    }
+    MathVector<T> result(this->get_size());
+    for (size_t i = 0; i < this->get_size(); ++i) {
+        result[i] = this->get_data()[i] / value;
+    }
+    return result;
+}
+template <class T>
+MathVector<T>& MathVector<T>::operator *= (T value) {
+    for (size_t i = 0; i < this->get_size(); ++i) {
+        this->get_data()[i] *= value;
+   }
+    return *this;
+}
+template <class T>
+MathVector<T>& MathVector<T>::operator /= (T value) {
+    if (value == 0) {
+        throw std::logic_error("Can't divide by zero!");
+    }
+    for (size_t i = 0; i < this->get_size(); ++i) {
+        this->get_data()[i] /= value;
+    }
+    return *this;
+}
+
+

From 545ef539f73c18e8895d0fe500ec7b4ec6c147c2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Fri, 26 Sep 2025 18:56:17 +0300
Subject: [PATCH 013/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=D1=8B=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE?=
 =?UTF-8?q?=D1=80=D1=8B=20+,=20-,=20*,=20+=3D,=20-=3D=20(=D0=B2=D0=B5?=
 =?UTF-8?q?=D0=BA=D1=82=D0=BE=D1=80=20=D0=B8=20=D0=B2=D0=B5=D0=BA=D1=82?=
 =?UTF-8?q?=D0=BE=D1=80)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_math_vector/math_vector.h | 67 +++++++++++++++++++++++++++++++++++
 1 file changed, 67 insertions(+)

diff --git a/lib_math_vector/math_vector.h b/lib_math_vector/math_vector.h
index ab55d7cc..42ea2dda 100644
--- a/lib_math_vector/math_vector.h
+++ b/lib_math_vector/math_vector.h
@@ -16,6 +16,12 @@ class MathVector : public Tvector<T> {
     MathVector<T>& operator *= (T value);
     MathVector<T>& operator /= (T value);
 
+    MathVector<T> operator + (const MathVector<T>& vector) const;
+    MathVector<T> operator - (const MathVector<T>& vector) const;
+    T operator * (const MathVector<T>& vector) const;
+
+    MathVector<T>& operator += (const MathVector<T>& vector);
+    MathVector<T>& operator -= (const MathVector<T>& vector);
 
 };
 template<class T>
@@ -65,5 +71,66 @@ MathVector<T>& MathVector<T>::operator /= (T value) {
     }
     return *this;
 }
+template<class T>
+MathVector<T> MathVector<T>::operator + (const MathVector<T>& vector) const {
+    if (this->get_size() != vector.get_size()) {
+        throw std::logic_error("Vectors must have the same dimension");
+    }
+    MathVector<T> result(this->get_size());
+    for (size_t i = 0; i < this->get_size(); ++i) {
+        result[i] = this->get_data()[i] + vector.get_data()[i];
+    }
+    return result;
+}
+template<class T>
+MathVector<T> MathVector<T>::operator - (const MathVector<T>& vector) const {
+    if (this->get_size() != vector.get_size()) {
+        throw std::logic_error("Vectors must have the same dimension");
+    }
+    MathVector<T> result(this->get_size());
+    for (size_t i = 0; i < this->get_size(); ++i) {
+        result[i] = this->get_data()[i] - vector.get_data()[i];
+    }
+    return result;
+}
+template<class T>
+T MathVector<T>::operator * (const MathVector<T>& vector) const {
+    if (this->get_size() != vector.get_size()) {
+        throw std::logic_error("Vectors must have the same dimension");
+    }
+    T result{};
+    for (size_t i = 0; i < this->get_size(); ++i) {
+        result += this->get_data()[i] * vector.get_data()[i];
+    }
+    return result;
+}
+template<class T>
+MathVector<T>& MathVector<T>::operator += (const MathVector<T>& vector)  {
+    if (this->get_size() != vector.get_size()) {
+        throw std::logic_error("Vectors must have the same dimension");
+    }
+    for (size_t i = 0; i < this->get_size(); ++i) {
+        this->get_data()[i] += vector.get_data()[i];
+    }
+    return *this;
+}
+template<class T>
+MathVector<T>& MathVector<T>::operator -= (const MathVector<T>& vector) {
+    if (this->get_size() != vector.get_size()) {
+        throw std::logic_error("Vectors must have the same dimension");
+    }
+    for (size_t i = 0; i < this->get_size(); ++i) {
+        this->get_data()[i] -= vector.get_data()[i];
+    }
+    return *this;
+}
+
+
+
+
+
+
+
+
 
 

From 40f0e251d50deb311bfa7c102d2a19984817068b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Fri, 26 Sep 2025 19:18:41 +0300
Subject: [PATCH 014/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE=D1=80?=
 =?UTF-8?q?=20=D0=B2=D1=8B=D0=B2=D0=BE=D0=B4=D0=B0,=20=D0=B8=D0=B7=D0=BC?=
 =?UTF-8?q?=D0=B5=D0=BD=D0=B5=D0=BD=D0=BE=20this->get=5Fdata()[i]=20=D0=BD?=
 =?UTF-8?q?=D0=B0=20(*this)[i]=20=D0=B4=D0=BB=D1=8F=20=D0=BA=D0=BE=D0=BD?=
 =?UTF-8?q?=D1=81=D0=B8=D1=81=D1=82=D0=B5=D0=BD=D1=82=D0=BD=D0=BE=D1=81?=
 =?UTF-8?q?=D1=82=D0=B8=20=D0=B2=20=D1=80=D0=B5=D0=B0=D0=BB=D0=B8=D0=B7?=
 =?UTF-8?q?=D0=B0=D1=86=D0=B8=D0=B8=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82?=
 =?UTF-8?q?=D0=BE=D1=80=D0=BE=D0=B2?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_math_vector/math_vector.h | 44 +++++++++++++++++------------------
 1 file changed, 22 insertions(+), 22 deletions(-)

diff --git a/lib_math_vector/math_vector.h b/lib_math_vector/math_vector.h
index 42ea2dda..5811dee7 100644
--- a/lib_math_vector/math_vector.h
+++ b/lib_math_vector/math_vector.h
@@ -9,7 +9,6 @@ class MathVector : public Tvector<T> {
     MathVector(T* data, size_t size);
     MathVector(const MathVector<T>& other);
     virtual ~MathVector();
-
     MathVector<T> operator * (T value) const;
     MathVector<T> operator / (T value) const;
 
@@ -22,7 +21,7 @@ class MathVector : public Tvector<T> {
 
     MathVector<T>& operator += (const MathVector<T>& vector);
     MathVector<T>& operator -= (const MathVector<T>& vector);
-
+    friend std::ostream& operator<<(std::ostream& out, const MathVector<T>& vector);
 };
 template<class T>
 MathVector<T>::MathVector() : Tvector<T>() {}
@@ -34,12 +33,11 @@ template <class T>
 MathVector<T>::MathVector(const MathVector<T>& other) : Tvector<T>(other) {}
 template <class T>
 MathVector<T>::~MathVector() = default;
-
 template <class T>
 MathVector<T> MathVector<T>::operator * (T value) const {
     MathVector<T> result(this->get_size());
     for (size_t i = 0; i < this->get_size(); ++i) {
-        result[i] = this->get_data()[i] * value;
+        result[i] = (*this)[i] * value;
     }
     return result;
 }
@@ -50,14 +48,14 @@ MathVector<T> MathVector<T>::operator / (T value) const {
     }
     MathVector<T> result(this->get_size());
     for (size_t i = 0; i < this->get_size(); ++i) {
-        result[i] = this->get_data()[i] / value;
+        result[i] = (*this)[i] / value;
     }
     return result;
 }
 template <class T>
 MathVector<T>& MathVector<T>::operator *= (T value) {
     for (size_t i = 0; i < this->get_size(); ++i) {
-        this->get_data()[i] *= value;
+        (*this)[i] *= value;
    }
     return *this;
 }
@@ -67,7 +65,7 @@ MathVector<T>& MathVector<T>::operator /= (T value) {
         throw std::logic_error("Can't divide by zero!");
     }
     for (size_t i = 0; i < this->get_size(); ++i) {
-        this->get_data()[i] /= value;
+        (*this)[i] /= value;
     }
     return *this;
 }
@@ -78,7 +76,7 @@ MathVector<T> MathVector<T>::operator + (const MathVector<T>& vector) const {
     }
     MathVector<T> result(this->get_size());
     for (size_t i = 0; i < this->get_size(); ++i) {
-        result[i] = this->get_data()[i] + vector.get_data()[i];
+        result[i] = (*this)[i] + vector[i];
     }
     return result;
 }
@@ -89,7 +87,7 @@ MathVector<T> MathVector<T>::operator - (const MathVector<T>& vector) const {
     }
     MathVector<T> result(this->get_size());
     for (size_t i = 0; i < this->get_size(); ++i) {
-        result[i] = this->get_data()[i] - vector.get_data()[i];
+        result[i] = (*this)[i] - vector[i];
     }
     return result;
 }
@@ -100,7 +98,7 @@ T MathVector<T>::operator * (const MathVector<T>& vector) const {
     }
     T result{};
     for (size_t i = 0; i < this->get_size(); ++i) {
-        result += this->get_data()[i] * vector.get_data()[i];
+        result += (*this)[i] * vector[i];
     }
     return result;
 }
@@ -110,7 +108,7 @@ MathVector<T>& MathVector<T>::operator += (const MathVector<T>& vector)  {
         throw std::logic_error("Vectors must have the same dimension");
     }
     for (size_t i = 0; i < this->get_size(); ++i) {
-        this->get_data()[i] += vector.get_data()[i];
+        (*this)[i] += vector[i];
     }
     return *this;
 }
@@ -120,17 +118,19 @@ MathVector<T>& MathVector<T>::operator -= (const MathVector<T>& vector) {
         throw std::logic_error("Vectors must have the same dimension");
     }
     for (size_t i = 0; i < this->get_size(); ++i) {
-        this->get_data()[i] -= vector.get_data()[i];
+        (*this)[i] -= vector[i];
     }
     return *this;
 }
-
-
-
-
-
-
-
-
-
-
+template<class T>
+std::ostream& operator<<(std::ostream& out, const MathVector<T>& 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;
+}

From 4853d6f5d2832120ddfbdbd8099055a5809bf48e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Sat, 27 Sep 2025 14:20:27 +0300
Subject: [PATCH 015/109] =?UTF-8?q?=D0=98=D0=B7=D0=BC=D0=B5=D0=BD=D0=B5?=
 =?UTF-8?q?=D0=BD=D1=8B=20=D0=BD=D0=B0=D0=B7=D0=B2=D0=B0=D0=BD=D0=B8=D1=8F?=
 =?UTF-8?q?=20=D0=B2=20=D1=82=D0=B5=D1=81=D1=82=D0=B0=D1=85=20=D0=B4=D0=BB?=
 =?UTF-8?q?=D1=8F=20=D0=BF=D1=80=D0=BE=D0=B2=D0=B5=D1=80=D0=BA=D0=B8=20?=
 =?UTF-8?q?=D0=BA=D0=BE=D0=BD=D1=81=D1=82=D1=80=D1=83=D0=BA=D1=82=D0=BE?=
 =?UTF-8?q?=D1=80=D0=BE=D0=B2?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 tests/test_vector.cpp | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/tests/test_vector.cpp b/tests/test_vector.cpp
index a2efd98d..b1a6e933 100644
--- a/tests/test_vector.cpp
+++ b/tests/test_vector.cpp
@@ -1,8 +1,7 @@
 // Copyright 2025 Julia Zabytina
 #include <gtest/gtest.h>
-#include "../lib_easy_example/easy_example.h"
 #include "../lib_vector/vector.h"
-TEST(TestVectorLib, default_constructor) {
+TEST(TestVectorLib, vector_default_constructor) {
     // Arrange
     Tvector<int> vector;
     // Act
@@ -16,7 +15,7 @@ TEST(TestVectorLib, default_constructor) {
     bool expected_result = true;
     EXPECT_EQ(expected_result, actual_result);
 }
-TEST(TestVectorLib, constructor_with_size) {
+TEST(TestVectorLib, vector_constructor_with_size) {
     // Arrange
     size_t size = 10;
     Tvector<int> vector(size);
@@ -31,7 +30,7 @@ TEST(TestVectorLib, constructor_with_size) {
     bool expected_result = true;
     EXPECT_EQ(expected_result, actual_result);
 }
-TEST(TestVectorLib, constructor_with_array_and_size) {
+TEST(TestVectorLib, vector_constructor_with_array_and_size) {
     // Arrange
     int data[3] = { 1,2,3 };
     size_t size = 3;
@@ -49,7 +48,7 @@ TEST(TestVectorLib, constructor_with_array_and_size) {
     bool expected_result = true;
     EXPECT_EQ(expected_result, actual_result);
 }
-TEST(TestVectorLib, copy_constructor) {
+TEST(TestVectorLib, vector_copy_constructor) {
     // Arrange
     int data[3] = { 1,2,3 };
     size_t size = 3;

From 7bb41956f5be8e0059bc8af233283ae1c45f1294 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Sat, 27 Sep 2025 14:44:28 +0300
Subject: [PATCH 016/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=D1=8B=20=D1=82=D0=B5=D1=81=D1=82=D1=8B=20=D0=BD?=
 =?UTF-8?q?=D0=B0=20=D0=BA=D0=BE=D0=BD=D1=81=D1=82=D1=80=D1=83=D0=BA=D1=82?=
 =?UTF-8?q?=D0=BE=D1=80=D1=8B?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 tests/test_math_vector.cpp | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 tests/test_math_vector.cpp

diff --git a/tests/test_math_vector.cpp b/tests/test_math_vector.cpp
new file mode 100644
index 00000000..e69de29b

From 46eacd1072b400b485630bac61db902287fe7fef Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Sat, 27 Sep 2025 14:48:44 +0300
Subject: [PATCH 017/109] =?UTF-8?q?=D0=A0=D0=B5=D0=B0=D0=BB=D0=B8=D0=B7?=
 =?UTF-8?q?=D0=B0=D1=86=D0=B8=D1=8F=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82?=
 =?UTF-8?q?=D0=BE=D1=80=D0=B0=20=D0=B2=D1=8B=D0=B2=D0=BE=D0=B4=D0=B0=20?=
 =?UTF-8?q?=D1=82=D0=B5=D0=BF=D0=B5=D1=80=D1=8C=20=D0=B2=D0=BD=D1=83=D1=82?=
 =?UTF-8?q?=D1=80=D0=B8=20=D0=BA=D0=BB=D0=B0=D1=81=D1=81=D0=B0=20MathVecto?=
 =?UTF-8?q?r,=20=D0=B2=D0=BE=20=D0=B8=D0=B7=D0=B1=D0=B5=D0=B6=D0=B0=D0=BD?=
 =?UTF-8?q?=D0=B8=D0=B5=20=D0=BE=D1=88=D0=B8=D0=B1=D0=BE=D0=BA=20=D0=BB?=
 =?UTF-8?q?=D0=B8=D0=BD=D0=BA=D0=BE=D0=B2=D0=BA=D0=B8=20=D0=BF=D1=80=D0=B8?=
 =?UTF-8?q?=20=D0=B7=D0=B0=D0=BF=D1=83=D1=81=D0=BA=D0=B5=20=D1=82=D0=B5?=
 =?UTF-8?q?=D1=81=D1=82=D0=BE?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_math_vector/math_vector.h | 24 +++++++++++-------------
 1 file changed, 11 insertions(+), 13 deletions(-)

diff --git a/lib_math_vector/math_vector.h b/lib_math_vector/math_vector.h
index 5811dee7..927b79e5 100644
--- a/lib_math_vector/math_vector.h
+++ b/lib_math_vector/math_vector.h
@@ -21,7 +21,17 @@ class MathVector : public Tvector<T> {
 
     MathVector<T>& operator += (const MathVector<T>& vector);
     MathVector<T>& operator -= (const MathVector<T>& vector);
-    friend std::ostream& operator<<(std::ostream& out, const MathVector<T>& vector);
+    friend std::ostream& operator<<(std::ostream& out, const MathVector<T>& 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;
+    }
 };
 template<class T>
 MathVector<T>::MathVector() : Tvector<T>() {}
@@ -122,15 +132,3 @@ MathVector<T>& MathVector<T>::operator -= (const MathVector<T>& vector) {
     }
     return *this;
 }
-template<class T>
-std::ostream& operator<<(std::ostream& out, const MathVector<T>& 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;
-}

From 44c007187f8bc5f73baf7f89004e2acb70abae2e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Sat, 27 Sep 2025 14:54:06 +0300
Subject: [PATCH 018/109] =?UTF-8?q?=D0=98=D1=81=D0=BF=D1=80=D0=B0=D0=B2?=
 =?UTF-8?q?=D0=BB=D0=B5=D0=BD=D1=8B=20=D1=82=D0=B5=D1=81=D1=82=D1=8B=20?=
 =?UTF-8?q?=D0=BD=D0=B0=20=D0=BA=D0=BE=D0=BD=D1=81=D1=82=D1=80=D1=83=D0=BA?=
 =?UTF-8?q?=D1=82=D0=BE=D1=80=D1=8B?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 tests/test_vector.cpp | 50 +++++++++++--------------------------------
 1 file changed, 13 insertions(+), 37 deletions(-)

diff --git a/tests/test_vector.cpp b/tests/test_vector.cpp
index b1a6e933..dd758365 100644
--- a/tests/test_vector.cpp
+++ b/tests/test_vector.cpp
@@ -2,63 +2,39 @@
 #include <gtest/gtest.h>
 #include "../lib_vector/vector.h"
 TEST(TestVectorLib, vector_default_constructor) {
-    // Arrange
+    // Arrange & Act
     Tvector<int> vector;
-    // Act
-    bool actual_result = vector.get_size() == 0
-        && vector.get_deleted() == 0
-        && vector.get_capacity() == 0
-        && vector.get_data() == nullptr
-        && vector.get_states() == nullptr;
-
     // Assert
-    bool expected_result = true;
-    EXPECT_EQ(expected_result, actual_result);
+    EXPECT_TRUE(vector.is_empty());
 }
 TEST(TestVectorLib, vector_constructor_with_size) {
-    // Arrange
+    // Arrange & Act
     size_t size = 10;
     Tvector<int> vector(size);
-    // Act
-    bool actual_result = vector.get_size() == size
-        && vector.get_capacity() == 25
-        && vector.get_data() != nullptr
-        && vector.get_states() != nullptr
-        && vector.get_deleted() == 0;;
-
     // Assert
-    bool expected_result = true;
-    EXPECT_EQ(expected_result, actual_result);
+    EXPECT_LE(vector.get_size(), vector.get_capacity());
+    EXPECT_EQ(vector.get_size(), size);
 }
 TEST(TestVectorLib, vector_constructor_with_array_and_size) {
-    // Arrange
+    // Arrange & Act
     int data[3] = { 1,2,3 };
     size_t size = 3;
     Tvector<int> vector(data, size);
-    // Act
-    bool actual_result = vector.get_size() == size
-        && vector.get_capacity() == 18
-        && vector.get_data() != nullptr
-        && vector.get_states() != nullptr
-        && vector.get_data()[0] == data[0]
-        && vector.get_data()[1] == data[1]
-        && vector.get_data()[2] == data[2]
-        && vector.get_deleted() == 0;
     // Assert
-    bool expected_result = true;
-    EXPECT_EQ(expected_result, actual_result);
+    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
+    // Arrange & Act
     int data[3] = { 1,2,3 };
     size_t size = 3;
     Tvector<int> old_vector(data, size);
     Tvector<int> new_vector(old_vector);
-    // Act
-    bool actual_result = old_vector == new_vector;
     // Assert
-    bool expected_result = true;
-    EXPECT_EQ(expected_result, actual_result);
+    EXPECT_EQ(old_vector, new_vector);
 }
 TEST(TestVectorLib, is_empty) {
     // Arrange

From 192eeac504eb943c9287431e3b36ad548faa00c7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Sat, 27 Sep 2025 15:21:34 +0300
Subject: [PATCH 019/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=D1=8B=20=D1=82=D0=B5=D1=81=D1=82=D1=8B=20=D0=BD?=
 =?UTF-8?q?=D0=B0=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE=D1=80=D1=8B?=
 =?UTF-8?q?=20*,=20/=20(=D0=B2=20=D1=82=D0=BE=D0=BC=20=D1=87=D0=B8=D1=81?=
 =?UTF-8?q?=D0=BB=D0=B5,=20=D0=BD=D0=B0=20=D0=B8=D1=81=D0=BA=D0=BB=D1=8E?=
 =?UTF-8?q?=D1=87=D0=B5=D0=BD=D0=B8=D0=B5=20=D0=BF=D1=80=D0=B8=20=D0=B4?=
 =?UTF-8?q?=D0=B5=D0=BB=D0=B5=D0=BD=D0=B8=D0=B8=20=D0=BD=D0=B0=200)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 tests/test_math_vector.cpp | 75 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 75 insertions(+)

diff --git a/tests/test_math_vector.cpp b/tests/test_math_vector.cpp
index e69de29b..b74974e4 100644
--- a/tests/test_math_vector.cpp
+++ b/tests/test_math_vector.cpp
@@ -0,0 +1,75 @@
+// Copyright 2025 Julia Zabytina
+#include <stdexcept>
+#include <gtest/gtest.h>
+#include "../lib_math_vector/math_vector.h"
+TEST(TestMathVectorLib, mathvector_default_constructor) {
+    // Arrange & Act
+    MathVector<int> vector;
+    // Assert
+    EXPECT_TRUE(vector.is_empty());
+}
+TEST(TestMathVectorLib, mathvector_constructor_with_size) {
+    // Arrange & Act
+    size_t size = 10;
+    MathVector<int> vector(size);
+    // Assert
+    EXPECT_LE(vector.get_size(), vector.get_capacity());
+    EXPECT_EQ(vector.get_size(), size);
+}
+TEST(TestMathVectorLib, mathvector_constructor_with_array_and_size) {
+    // Arrange & Act
+    int data[3] = { 1,2,3 };
+    size_t size = 3;
+    MathVector<int> 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_copy_constructor) {
+    // Arrange & Act
+    int data[3] = { 1,2,3 };
+    size_t size = 3;
+    MathVector<int> old_vector(data, size);
+    MathVector<int> new_vector(old_vector);
+    // Assert
+    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<int> vector(data, size);
+    MathVector<int> 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<int> vector(data, size);
+    MathVector<int> 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<int> vector(data, size);
+    int value = 0;
+    // Assert
+    EXPECT_THROW(vector / value, std::logic_error);
+}
+

From 28827801bb5b45d1328e965a0cc435bb52d833c0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Sat, 27 Sep 2025 15:31:16 +0300
Subject: [PATCH 020/109] =?UTF-8?q?=D0=98=D1=81=D0=BF=D1=80=D0=B0=D0=B2?=
 =?UTF-8?q?=D0=BB=D0=B5=D0=BD=D1=8B=20=D1=81=D0=B8=D0=BD=D1=82=D0=B0=D0=BA?=
 =?UTF-8?q?=D1=81=D0=B8=D1=87=D0=B5=D1=81=D0=BA=D0=B8=D0=B5=20=D0=BE=D1=88?=
 =?UTF-8?q?=D0=B8=D0=B1=D0=BA=D0=B8=20=D0=B2=20=D0=BD=D0=B0=D0=B7=D0=B2?=
 =?UTF-8?q?=D0=B0=D0=BD=D0=B8=D1=8F=D1=85=20=D1=82=D0=B5=D1=81=D1=82=D0=BE?=
 =?UTF-8?q?=D0=B2?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 tests/test_vector.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/tests/test_vector.cpp b/tests/test_vector.cpp
index dd758365..ad786875 100644
--- a/tests/test_vector.cpp
+++ b/tests/test_vector.cpp
@@ -141,7 +141,7 @@ TEST(TestVectorLib, get_end) {
     int* expected_result = &(vector.get_data()[0]) + size;
     EXPECT_EQ(expected_result, actual_result);
 }
-TEST(TestVectorLib, сomparison_operator_true) {
+TEST(TestVectorLib, comparison_operator_true) {
     // Arrange
     int data[3] = { 1,2,3 };
     size_t size = 3;
@@ -153,7 +153,7 @@ TEST(TestVectorLib, get_end) {
     bool expected_result = true;
     EXPECT_EQ(expected_result, actual_result);
 }
-TEST(TestVectorLib, сomparison_operator_false) {
+TEST(TestVectorLib, comparison_operator_false) {
     // Arrange
     int data1[3] = { 1,2,3 };
     size_t size1 = 3;
@@ -167,7 +167,7 @@ TEST(TestVectorLib, get_end) {
     bool expected_result = false;
     EXPECT_EQ(expected_result, actual_result);
 }
-TEST(TestVectorLib, not_сomparison_operator_true) {
+TEST(TestVectorLib, not_comparison_operator_true) {
     // Arrange
     int data1[3] = { 1,2,3 };
     size_t size1 = 3;
@@ -181,7 +181,7 @@ TEST(TestVectorLib, get_end) {
     bool expected_result = true;
     EXPECT_EQ(expected_result, actual_result);
 }
-TEST(TestVectorLib, not_сomparison_operator_false) {
+TEST(TestVectorLib, not_comparison_operator_false) {
     // Arrange
     int data[3] = { 1,2,3 };
     size_t size = 3;

From cfd7002e3d94b5b90000f223d86aa54e2fb9cdde Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Sat, 27 Sep 2025 15:48:14 +0300
Subject: [PATCH 021/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=D1=8B=20=D1=82=D0=B5=D1=81=D1=82=D1=8B=20=D0=BD?=
 =?UTF-8?q?=D0=B0=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE=D1=80=D1=8B?=
 =?UTF-8?q?=20*=3D,=20/=3D=20(=D0=B2=D0=B5=D0=BA=D1=82=D0=BE=D1=80=D0=B0?=
 =?UTF-8?q?=20=D0=BD=D0=B0=20=D1=81=D0=BA=D0=B0=D0=BB=D1=8F=D1=80,=20?=
 =?UTF-8?q?=D0=B2=20=D1=82=D0=BE=D0=BC=20=D1=87=D0=B8=D1=81=D0=BB=D0=B5,?=
 =?UTF-8?q?=20=D1=82=D0=B5=D1=81=D1=82=20=D0=BD=D0=B0=20=D0=B8=D1=81=D0=BA?=
 =?UTF-8?q?=D0=BB=D1=8E=D1=87=D0=B5=D0=BD=D0=B8=D0=B5=20=D0=B2=20=D1=81?=
 =?UTF-8?q?=D0=BB=D1=83=D1=87=D0=B0=D0=B5=20=D0=B4=D0=B5=D0=BB=D0=B5=D0=BD?=
 =?UTF-8?q?=D0=B8=D1=8F=20=D0=BD=D0=B0=200);=20+,=20-=20=D0=B4=D0=BB=D1=8F?=
 =?UTF-8?q?=20=D0=B4=D0=B2=D1=83=D1=85=20=D0=B2=D0=B5=D0=BA=D1=82=D0=BE?=
 =?UTF-8?q?=D1=80=D0=BE=D0=B2,=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82?=
 =?UTF-8?q?=D0=BE=D1=80=D0=B0=20*=20=D0=B4=D0=BB=D1=8F=20=D0=B4=D0=B2?=
 =?UTF-8?q?=D1=83=D1=85=20=D0=B2=D0=B5=D0=BA=D1=82=D0=BE=D1=80=D0=BE=D0=B2?=
 =?UTF-8?q?=20(=D1=81=D0=BA=D0=B0=D0=BB=D1=8F=D1=80=D0=BD=D0=BE=D0=B5=20?=
 =?UTF-8?q?=D0=BF=D1=80=D0=BE=D0=B8=D0=B7=D0=B2=D0=B5=D0=B4=D0=B5=D0=BD?=
 =?UTF-8?q?=D0=B8=D0=B5)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 tests/test_math_vector.cpp | 85 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 85 insertions(+)

diff --git a/tests/test_math_vector.cpp b/tests/test_math_vector.cpp
index b74974e4..1c11fca7 100644
--- a/tests/test_math_vector.cpp
+++ b/tests/test_math_vector.cpp
@@ -72,4 +72,89 @@ TEST(TestMathVectorLib, mathvector_div_on_null_exception) {
     // 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<int> 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<int> 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<int> 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<int> vector1(data1, size1);
+    MathVector<int> vector2(data2, size2);
+    MathVector<int> 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<int> vector1(data1, size1);
+    MathVector<int> vector2(data2, size2);
+    MathVector<int> 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<int> vector1(data1, size1);
+    MathVector<int> 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);  
+}

From d66794621dcb5870124b3ad850f7e1dfc48b93fa Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Sat, 27 Sep 2025 15:56:24 +0300
Subject: [PATCH 022/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=D1=8B=20=D1=82=D0=B5=D1=81=D1=82=D1=8B=20=D0=BD?=
 =?UTF-8?q?=D0=B0=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE=D1=80=D1=8B?=
 =?UTF-8?q?=20+,=20-=20=D0=B8=20*=20=D0=B2=20=D1=81=D0=BB=D1=83=D1=87?=
 =?UTF-8?q?=D0=B0=D0=B5=20=D1=81=20=D0=B4=D0=B2=D1=83=D0=BC=D1=8F=20=D0=B2?=
 =?UTF-8?q?=D0=B5=D0=BA=D1=82=D0=BE=D1=80=D0=B0=D0=BC=D0=B8=20=D1=80=D0=B0?=
 =?UTF-8?q?=D0=B7=D0=BD=D0=BE=D0=B9=20=D1=80=D0=B0=D1=81=D0=B7=D0=BC=D0=B5?=
 =?UTF-8?q?=D1=80=D0=BD=D0=BE=D1=81=D1=82=D0=B8=20(=D1=81=D0=BB=D1=83?=
 =?UTF-8?q?=D1=87=D0=B0=D0=B9=20=D1=81=20=D0=B8=D1=81=D0=BA=D0=BB=D1=8E?=
 =?UTF-8?q?=D1=87=D0=B5=D0=BD=D0=B8=D0=B5=D0=BC)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 tests/test_math_vector.cpp | 42 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)

diff --git a/tests/test_math_vector.cpp b/tests/test_math_vector.cpp
index 1c11fca7..61c67f0a 100644
--- a/tests/test_math_vector.cpp
+++ b/tests/test_math_vector.cpp
@@ -158,3 +158,45 @@ TEST(TestMathVectorLib, mathvector_scalar_product) {
     // 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<int> vector1(data1, size1);
+    MathVector<int> 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<int> vector1(data1, size1);
+    MathVector<int> 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<int> vector1(data1, size1);
+    MathVector<int> vector2(data2, size2);
+
+    // Assert
+    EXPECT_THROW(vector1 * vector2, std::logic_error);
+}

From 47e33b9aaf8f3d96368d110f09fc60054037a3be Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Sat, 27 Sep 2025 16:02:30 +0300
Subject: [PATCH 023/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=D1=8B=20=D1=82=D0=B5=D1=81=D1=82=D1=8B=20=D0=BD?=
 =?UTF-8?q?=D0=B0=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE=D1=80=D1=8B?=
 =?UTF-8?q?=20+=3D,=20-=3D=20=D0=B2=20=D1=81=D0=BB=D1=83=D1=87=D0=B0=D0=B5?=
 =?UTF-8?q?=20=D1=81=20=D0=B4=D0=B2=D1=83=D0=BC=D1=8F=20=D0=B2=D0=B5=D0=BA?=
 =?UTF-8?q?=D1=82=D0=BE=D1=80=D0=B0=D0=BC=D0=B8=20(=D0=B2=20=D1=82=D0=BE?=
 =?UTF-8?q?=D0=BC=20=D1=87=D0=B8=D1=81=D0=BB=D0=B5,=20=D0=BD=D0=B0=20?=
 =?UTF-8?q?=D1=81=D0=BB=D1=83=D1=87=D0=B0=D0=B8=20=D1=81=20=D0=B8=D1=81?=
 =?UTF-8?q?=D0=BA=D0=BB=D1=8E=D1=87=D0=B5=D0=BD=D0=B8=D1=8F=D0=BC=D0=B8,?=
 =?UTF-8?q?=20=D0=BA=D0=BE=D0=B3=D0=B4=D0=B0=20=D1=83=20=D0=B2=D0=B5=D0=BA?=
 =?UTF-8?q?=D1=82=D0=BE=D1=80=D0=BE=D0=B2=20=D1=80=D0=B0=D0=B7=D0=BD=D0=B0?=
 =?UTF-8?q?=D1=8F=20=D1=80=D0=B0=D0=B7=D0=BC=D0=B5=D1=80=D0=BD=D0=BE=D1=81?=
 =?UTF-8?q?=D1=82=D1=8C)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 tests/test_math_vector.cpp | 60 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 60 insertions(+)

diff --git a/tests/test_math_vector.cpp b/tests/test_math_vector.cpp
index 61c67f0a..9a234df9 100644
--- a/tests/test_math_vector.cpp
+++ b/tests/test_math_vector.cpp
@@ -200,3 +200,63 @@ TEST(TestMathVectorLib, mathvector_scalar_product_for_vectors_with_different_dim
     // 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<int> vector1(data1, size1);
+    MathVector<int> 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<int> vector1(data1, size1);
+    MathVector<int> 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<int> vector1(data1, size1);
+    MathVector<int> 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<int> vector1(data1, size1);
+    MathVector<int> vector2(data2, size2);
+
+    // Assert
+    EXPECT_THROW(vector1 -= vector2, std::logic_error);
+}

From 095a0a9f66a663b3d068f1df2e4a60ba691d7677 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Mon, 29 Sep 2025 09:33:30 +0300
Subject: [PATCH 024/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=D1=8B=20=D0=B3=D0=B5=D1=82=D1=82=D0=B5=D1=80=D1=8B?=
 =?UTF-8?q?=20=D0=B4=D0=BB=D1=8F=20=D0=BD=D0=B0=D0=BF=D0=B8=D1=81=D0=B0?=
 =?UTF-8?q?=D0=BD=D0=B8=D1=8F=20=D1=82=D0=B5=D1=81=D1=82=D0=BE=D0=B2?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_matrix/matrix.h | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/lib_matrix/matrix.h b/lib_matrix/matrix.h
index 501d93f5..b3fe84f8 100644
--- a/lib_matrix/matrix.h
+++ b/lib_matrix/matrix.h
@@ -53,7 +53,12 @@ class Matrix : public MathVector<MathVector<T>> {
     }
     MathVector<T>& operator[](size_t index);
     const MathVector<T>& operator[](size_t index) const;
-
+    size_t getM() const {
+        return M;
+    }
+    size_t getN() const {
+        return N;
+    }
 
 };
 template <class T>

From 8e18a1be72a4fc9e68852cdc38b9fe6d728b4984 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Mon, 29 Sep 2025 09:41:30 +0300
Subject: [PATCH 025/109] =?UTF-8?q?=D0=A3=D0=B1=D1=80=D0=B0=D0=BD=D0=BE=20?=
 =?UTF-8?q?=D0=B4=D1=83=D0=B1=D0=BB=D0=B8=D1=80=D0=BE=D0=B2=D0=B0=D0=BD?=
 =?UTF-8?q?=D0=B8=D0=B5=20=D0=BA=D0=BE=D0=B4=D0=B0,=20=D1=81=D0=B2=D1=8F?=
 =?UTF-8?q?=D0=B0=D0=B7=D0=BD=D0=BD=D0=BE=D0=B5=20=D1=81=20=D0=B3=D0=B5?=
 =?UTF-8?q?=D1=82=D1=82=D0=B5=D1=80=D0=B0=D0=BC=D0=B8...?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_matrix/matrix.h | 24 ++++++++++--------------
 1 file changed, 10 insertions(+), 14 deletions(-)

diff --git a/lib_matrix/matrix.h b/lib_matrix/matrix.h
index b3fe84f8..d1e4bbaf 100644
--- a/lib_matrix/matrix.h
+++ b/lib_matrix/matrix.h
@@ -11,12 +11,8 @@ class Matrix : public MathVector<MathVector<T>> {
     Matrix(T* data, size_t M, size_t N);
     Matrix(const Matrix& other);
     virtual ~Matrix();
-    size_t getM() const {
-        return _M;
-    }
-    size_t getN() const {
-        return _N;
-    }
+    size_t getM() const;
+    size_t getN() const;
     Matrix<T> operator + (T value) const;
     Matrix<T> operator - (T value) const;
     Matrix<T> operator * (T value) const;
@@ -41,7 +37,6 @@ class Matrix : public MathVector<MathVector<T>> {
     Matrix<T>& operator += (const Matrix<T>& other_matrix);
     Matrix<T>& operator -= (const Matrix<T>& other_matrix);
     Matrix<T>& operator *= (const Matrix<T>& other_matrix);
-
     friend std::ostream& operator<< (std::ostream& out, const Matrix<T>& matrix) {
         for (size_t i = 0; i < matrix.getM(); ++i) {
             for (size_t j = 0; j < matrix.getN(); ++j) {
@@ -53,15 +48,16 @@ class Matrix : public MathVector<MathVector<T>> {
     }
     MathVector<T>& operator[](size_t index);
     const MathVector<T>& operator[](size_t index) const;
-    size_t getM() const {
-        return M;
-    }
-    size_t getN() const {
-        return N;
-    }
-
 };
 template <class T>
+size_t Matrix<T>::getM() const {
+    return _M;
+}
+template <class T>
+size_t Matrix<T>::getN() const {
+    return _N;
+}
+template <class T>
 Matrix<T>::Matrix() : MathVector<MathVector<T>>(), _M(0), _N(0) {}
 template <class T>
 Matrix<T>::Matrix(size_t M, size_t N) : MathVector<MathVector<T>>(M) {

From 89df2fbd179d1094689935f611d560ba8aa7897b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Mon, 29 Sep 2025 09:47:16 +0300
Subject: [PATCH 026/109] =?UTF-8?q?=D0=98=D1=81=D0=BF=D1=80=D0=B0=D0=B2?=
 =?UTF-8?q?=D0=BB=D0=B5=D0=BD=D1=8B=20=D1=81=D0=B8=D0=BD=D1=82=D0=B0=D0=BA?=
 =?UTF-8?q?=D1=81=D0=B8=D1=87=D0=B5=D1=81=D0=BA=D0=B8=D0=B5=20=D0=BE=D1=88?=
 =?UTF-8?q?=D0=B8=D0=B1=D0=BA=D0=B8=20=D0=B2=20=D0=BA=D0=BE=D0=BD=D1=81?=
 =?UTF-8?q?=D1=82=D1=80=D1=83=D0=BA=D1=82=D0=BE=D1=80=D0=B0=D1=85?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_matrix/matrix.h | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/lib_matrix/matrix.h b/lib_matrix/matrix.h
index d1e4bbaf..d0bfc723 100644
--- a/lib_matrix/matrix.h
+++ b/lib_matrix/matrix.h
@@ -63,16 +63,16 @@ template <class T>
 Matrix<T>::Matrix(size_t M, size_t N) : MathVector<MathVector<T>>(M) {
     _M = M;
     _N = N;
-    for (size_t i = 0; i < M; ++i) {
-        (*this)[i] = MathVector<T>(N);
+    for (size_t i = 0; i < _M; ++i) {
+        (*this)[i] = MathVector<T>(_N);
     }
 }
 template <class T>
 Matrix<T>::Matrix(T* data, size_t M, size_t N) : MathVector<MathVector<T>>(M) {
     _M = M;
     _N = N;
-    for (size_t i = 0; i < M; ++i) {
-        (*this)[i] = MathVector<T>(data + i * N, N);
+    for (size_t i = 0; i < _M; ++i) {
+        (*this)[i] = MathVector<T>(data + i * _N, _N);
     }
 }
 template <class T>

From eb1a89e5d6fff20c995ef201dd56a735c8ec01ff Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Mon, 29 Sep 2025 10:20:27 +0300
Subject: [PATCH 027/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=D1=8B=20=D1=82=D0=B5=D1=81=D1=82=D1=8B=20=D0=BD?=
 =?UTF-8?q?=D0=B0=20=D0=BA=D0=BE=D0=BD=D1=81=D1=82=D1=80=D1=83=D0=BA=D1=82?=
 =?UTF-8?q?=D0=BE=D1=80=D1=8B=20=D0=B8=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0?=
 =?UTF-8?q?=D1=82=D0=BE=D1=80=20=D0=BF=D1=80=D0=B8=D1=81=D0=B2=D0=B0=D0=B8?=
 =?UTF-8?q?=D0=B2=D0=B0=D0=BD=D0=B8=D1=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 tests/test_matrix.cpp | 57 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 57 insertions(+)
 create mode 100644 tests/test_matrix.cpp

diff --git a/tests/test_matrix.cpp b/tests/test_matrix.cpp
new file mode 100644
index 00000000..761be5c1
--- /dev/null
+++ b/tests/test_matrix.cpp
@@ -0,0 +1,57 @@
+// Copyright 2025 Julia Zabytina
+#include <stdexcept>
+#include <gtest/gtest.h>
+#include "../lib_matrix/matrix.h"
+TEST(TestMatrixLib, matrix_default_constructor) {
+    // Arrange & Act
+    Matrix<int> 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<int> 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<int> 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<int> old_matrix(data, M, N);
+    Matrix<int> 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<int> matrix1(data1, M, N);
+    Matrix<int> matrix2(data2, M, N);
+    // Act
+    matrix1 = matrix2;
+    // Assert
+    EXPECT_EQ(matrix1, matrix2);
+}

From 598097c3435fe00479f2431a5fec3ceb039fca1e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Mon, 29 Sep 2025 11:04:22 +0300
Subject: [PATCH 028/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=D1=8B=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE?=
 =?UTF-8?q?=D1=80=D1=8B=20+,=20-,=20*=20=D0=B8=20/=20=D0=B4=D0=BB=D1=8F=20?=
 =?UTF-8?q?=D0=BC=D0=B0=D1=82=D1=80=D0=B8=D1=86=D1=8B=20=D0=B8=20=D1=81?=
 =?UTF-8?q?=D0=BA=D0=B0=D0=BB=D1=8F=D1=80=D0=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_matrix/matrix.h | 31 +++++++++++++++++++++++++++----
 1 file changed, 27 insertions(+), 4 deletions(-)

diff --git a/lib_matrix/matrix.h b/lib_matrix/matrix.h
index d0bfc723..6b58647a 100644
--- a/lib_matrix/matrix.h
+++ b/lib_matrix/matrix.h
@@ -1,4 +1,5 @@
 #pragma once
+#include <stdexcept>
 #include "../lib_math_vector/math_vector.h"
 template <class T>
 class Matrix : public MathVector<MathVector<T>> {
@@ -13,6 +14,7 @@ class Matrix : public MathVector<MathVector<T>> {
     virtual ~Matrix();
     size_t getM() const;
     size_t getN() const;
+
     Matrix<T> operator + (T value) const;
     Matrix<T> operator - (T value) const;
     Matrix<T> operator * (T value) const;
@@ -57,6 +59,7 @@ template <class T>
 size_t Matrix<T>::getN() const {
     return _N;
 }
+
 template <class T>
 Matrix<T>::Matrix() : MathVector<MathVector<T>>(), _M(0), _N(0) {}
 template <class T>
@@ -83,22 +86,42 @@ Matrix<T>::~Matrix() = default;
 
 template <class T>
 Matrix<T> Matrix<T>::operator + (T value) const {
-    Matrix<T> matrix;
+    Matrix<T> matrix(_M, _N);
+    for (size_t i = 0; i < _M; ++i) {
+        for (size_t j = 0; j < _N; ++j) {
+            matrix[i][j] = (*this)[i][j] + value
+        }
+    }
     return matrix;
 }
 template <class T>
 Matrix<T> Matrix<T>::operator - (T value) const {
-    Matrix<T> matrix;
+    Matrix<T> matrix(_M, _N);
+    for (size_t i = 0; i < _M; ++i) {
+        for (size_t j = 0; j < _N; ++j) {
+            matrix[i][j] = (*this)[i][j] - value
+        }
+    }
     return matrix;
 }
 template <class T>
 Matrix<T> Matrix<T>::operator * (T value) const {
-    Matrix<T> matrix;
+    Matrix<T> matrix(_M, _N);
+    for (size_t i = 0; i < _M; ++i) {
+        for (size_t j = 0; j < _N; ++j) {
+            matrix[i][j] = (*this)[i][j] * value
+        }
+    }
     return matrix;
 }
 template <class T>
 Matrix<T> Matrix<T>::operator / (T value) const {
-    Matrix<T> matrix;
+    Matrix<T> matrix(_M, _N);
+    for (size_t i = 0; i < _M; ++i) {
+        for (size_t j = 0; j < _N; ++j) {
+            matrix[i][j] = (*this)[i][j] / value
+        }
+    }
     return matrix;
 }
 

From a7c4ebdd10776101368ee2b9050e65d70515d1d9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Mon, 29 Sep 2025 11:11:49 +0300
Subject: [PATCH 029/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=D1=8B=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE?=
 =?UTF-8?q?=D1=80=D1=8B=20+=3D,=20-=3D,=20*=3D,=20/=3D=20=D0=B4=D0=BB?=
 =?UTF-8?q?=D1=8F=20=D0=BC=D0=B0=D1=82=D1=80=D0=B8=D1=86=D1=8B=20=D0=B8=20?=
 =?UTF-8?q?=D1=81=D0=BA=D0=B0=D0=BB=D1=8F=D1=80=D0=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_matrix/matrix.h | 37 ++++++++++++++++++++++++++++++-------
 1 file changed, 30 insertions(+), 7 deletions(-)

diff --git a/lib_matrix/matrix.h b/lib_matrix/matrix.h
index 6b58647a..37814eb1 100644
--- a/lib_matrix/matrix.h
+++ b/lib_matrix/matrix.h
@@ -89,7 +89,7 @@ Matrix<T> Matrix<T>::operator + (T value) const {
     Matrix<T> matrix(_M, _N);
     for (size_t i = 0; i < _M; ++i) {
         for (size_t j = 0; j < _N; ++j) {
-            matrix[i][j] = (*this)[i][j] + value
+            matrix[i][j] = (*this)[i][j] + value;
         }
     }
     return matrix;
@@ -99,7 +99,7 @@ Matrix<T> Matrix<T>::operator - (T value) const {
     Matrix<T> matrix(_M, _N);
     for (size_t i = 0; i < _M; ++i) {
         for (size_t j = 0; j < _N; ++j) {
-            matrix[i][j] = (*this)[i][j] - value
+            matrix[i][j] = (*this)[i][j] - value;
         }
     }
     return matrix;
@@ -109,40 +109,63 @@ Matrix<T> Matrix<T>::operator * (T value) const {
     Matrix<T> matrix(_M, _N);
     for (size_t i = 0; i < _M; ++i) {
         for (size_t j = 0; j < _N; ++j) {
-            matrix[i][j] = (*this)[i][j] * value
+            matrix[i][j] = (*this)[i][j] * value;
         }
     }
     return matrix;
 }
 template <class T>
 Matrix<T> Matrix<T>::operator / (T value) const {
+    if (value == 0) {
+        throw std::logic_error("Division by zero!");
+    }
     Matrix<T> matrix(_M, _N);
     for (size_t i = 0; i < _M; ++i) {
         for (size_t j = 0; j < _N; ++j) {
-            matrix[i][j] = (*this)[i][j] / value
+            matrix[i][j] = (*this)[i][j] / value;
         }
     }
     return matrix;
 }
-
 template <class T>
 Matrix<T>& Matrix<T>::operator += (T value) {
+    for (size_t i = 0; i < _M; ++i) {
+        for (size_t j = 0; j < _N; ++j) {
+            (*this)[i][j] = (*this)[i][j] + value;
+        }
+    }
     return *this;
 }
 template <class T>
 Matrix<T>& Matrix<T>::operator -= (T value) {
+    for (size_t i = 0; i < _M; ++i) {
+        for (size_t j = 0; j < _N; ++j) {
+            (*this)[i][j] = (*this)[i][j] - value;
+        }
+    }
     return *this;
-
 }
 template <class T>
 Matrix<T>& Matrix<T>::operator *= (T value) {
+    for (size_t i = 0; i < _M; ++i) {
+        for (size_t j = 0; j < _N; ++j) {
+            (*this)[i][j] = (*this)[i][j] * value;
+        }
+    }
     return *this;
 }
 template <class T>
 Matrix<T>& Matrix<T>::operator /= (T value) {
+    if (value == 0) {
+        throw std::logic_error("Division by zero!");
+    }
+    for (size_t i = 0; i < _M; ++i) {
+        for (size_t j = 0; j < _N; ++j) {
+            (*this)[i][j] = (*this)[i][j] / value;
+        }
+    }
     return *this;
 }
-
 template <class T>
 Matrix<T> Matrix<T>::operator + (const MathVector<T>& vector) const {
     Matrix<T> matrix;

From ef9a7540ace4dd7305715936815e98ebd81b0777 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Mon, 29 Sep 2025 12:06:27 +0300
Subject: [PATCH 030/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=D1=8B=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE?=
 =?UTF-8?q?=D1=80=D1=8B=20+=20=D0=B8=20-=20=D0=B4=D0=BB=D1=8F=20=D0=B4?=
 =?UTF-8?q?=D0=B2=D1=83=D1=85=20=D0=BC=D0=B0=D1=82=D1=80=D0=B8=D1=86?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_matrix/matrix.h | 56 ++++++++++++++++-----------------------------
 1 file changed, 20 insertions(+), 36 deletions(-)

diff --git a/lib_matrix/matrix.h b/lib_matrix/matrix.h
index 37814eb1..73330af3 100644
--- a/lib_matrix/matrix.h
+++ b/lib_matrix/matrix.h
@@ -25,13 +25,6 @@ class Matrix : public MathVector<MathVector<T>> {
     Matrix<T>& operator *= (T value);
     Matrix<T>& operator /= (T value);
 
-    Matrix<T> operator + (const MathVector<T>& vector) const;
-    Matrix<T> operator - (const MathVector<T>& vector) const;
-    MathVector<T> operator * (const MathVector<T>& vector) const;
-
-    Matrix<T>& operator += (const MathVector<T>& vector);
-    Matrix<T>& operator -= (const MathVector<T>& vector);
-
     Matrix<T> operator + (const Matrix<T>& other_matrix) const;
     Matrix<T> operator - (const Matrix<T>& other_matrix) const;
     Matrix<T> operator * (const Matrix<T>& other_matrix) const;
@@ -166,40 +159,31 @@ Matrix<T>& Matrix<T>::operator /= (T value) {
     }
     return *this;
 }
-template <class T>
-Matrix<T> Matrix<T>::operator + (const MathVector<T>& vector) const {
-    Matrix<T> matrix;
-    return matrix;
-}
-template <class T>
-Matrix<T> Matrix<T>::operator - (const MathVector<T>& vector) const {
-    Matrix<T> matrix;
-    return matrix;
-}
-template <class T>
-MathVector<T> Matrix<T>::operator * (const MathVector<T>& vector) const {
-    MathVector<T> math_vector;
-    return math_vector;
-}
-
-template <class T>
-Matrix<T>& Matrix<T>::operator += (const MathVector<T>& vector) {
-    return *this;
-}
-template <class T>
-Matrix<T>& Matrix<T>::operator -= (const MathVector<T>& vector) {
-    return *this;
-}
-
 template <class T>
 Matrix<T> Matrix<T>::operator + (const Matrix<T>& other_matrix) const {
-    Matrix<T> matrix;
-    return matrix;
+    if (_M != other_matrix.getM() || _N != other_matrix.getN()) {
+        throw std::logic_error("The matrices have different sizes!");
+    }
+    Matrix<T> result(_M, _N);
+    for (size_t i = 0; i < _M; ++i) {
+        for (size_t j = 0; j < _N; ++j) {
+            result[i][j] = (*this)[i][j] + other_matrix[i][j];
+        }
+    }
+    return result;
 }
 template <class T>
 Matrix<T> Matrix<T>::operator - (const Matrix<T>& other_matrix) const {
-    Matrix<T> matrix;
-    return matrix;
+    if (_M != other_matrix.getM() || _N != other_matrix.getN()) {
+        throw std::logic_error("The matrices have different sizes!");
+    }
+    Matrix<T> result(_M, _N);
+    for (size_t i = 0; i < _M; ++i) {
+        for (size_t j = 0; j < _N; ++j) {
+            result[i][j] = (*this)[i][j] - other_matrix[i][j];
+        }
+    }
+    return result;
 }
 template <class T>
 Matrix<T> Matrix<T>::operator * (const Matrix<T>& other_matrix) const {

From f4af57c5946045f8635636c88e38019371380186 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Mon, 29 Sep 2025 12:08:41 +0300
Subject: [PATCH 031/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=D1=8B=20=D1=82=D0=B5=D1=81=D1=82=D1=8B=20=D0=BD?=
 =?UTF-8?q?=D0=B0=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE=D1=80=D1=8B?=
 =?UTF-8?q?=20+=20=D0=B8=20-=20=D0=B4=D0=BB=D1=8F=20=D0=BC=D0=B0=D1=82?=
 =?UTF-8?q?=D1=80=D0=B8=D1=86=20(=D0=B2=20=D1=82=D0=BE=D0=BC=20=D1=87?=
 =?UTF-8?q?=D0=B8=D1=81=D0=BB=D0=B5,=20=D1=82=D0=B5=D1=81=D1=82=D1=8B=20?=
 =?UTF-8?q?=D0=BD=D0=B0=20=D0=B8=D1=81=D0=BA=D0=BB=D1=8E=D1=87=D0=B5=D0=BD?=
 =?UTF-8?q?=D0=B8=D1=8F,=20=D0=BA=D0=BE=D0=B3=D0=B4=D0=B0=20=D1=80=D0=B0?=
 =?UTF-8?q?=D0=B7=D0=BC=D0=B5=D1=80=D1=8B=20=D0=BC=D0=B0=D1=82=D1=80=D0=B8?=
 =?UTF-8?q?=D1=86=20=D1=80=D0=B0=D0=B7=D0=BB=D0=B8=D1=87=D0=BD=D1=8B=20?=
 =?UTF-8?q?=D0=B8=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=86=D0=B8=D1=8F=20?=
 =?UTF-8?q?=D0=BD=D0=B5=D0=B2=D0=BE=D0=B7=D0=BC=D0=BE=D0=B6=D0=BD=D0=B0)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 tests/test_matrix.cpp | 200 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 200 insertions(+)

diff --git a/tests/test_matrix.cpp b/tests/test_matrix.cpp
index 761be5c1..1f4640b4 100644
--- a/tests/test_matrix.cpp
+++ b/tests/test_matrix.cpp
@@ -55,3 +55,203 @@ TEST(TestMatrixLib, matrix_assignment_operator) {
     // Assert
     EXPECT_EQ(matrix1, matrix2);
 }
+TEST(TestMatrixLib, matrix_add_value) {
+    // Arrange
+    size_t M = 2, N = 2;
+    int data[4] = { 1, 2, 3, 4 };
+    int value = 10;
+    Matrix<int> matrix(data, M, N);
+    Matrix<int> 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_sub_value) {
+    // Arrange
+    size_t M = 2, N = 2;
+    int data[4] = { 1, 2, 3, 4 };
+    int value = 10;
+    Matrix<int> matrix(data, M, N);
+    Matrix<int> 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_mult_value) {
+    // Arrange
+    size_t M = 2, N = 2;
+    int data[4] = { 1, 2, 3, 4 };
+    int value = 10;
+    Matrix<int> matrix(data, M, N);
+    Matrix<int> 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<int> matrix(data, M, N);
+    Matrix<int> 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<int> matrix(data, M, N);
+    // Assert
+    EXPECT_THROW(matrix / value;, std::logic_error);
+}
+TEST(TestMatrixLib, matrix_add_assign_value) {
+    // Arrange
+    size_t M = 2, N = 2;
+    int data[4] = { 2, 2, 10, 4 };
+    int value = 2;
+    Matrix<int> 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_sub_assign_value) {
+    // Arrange
+    size_t M = 2, N = 2;
+    int data[4] = { 2, 2, 10, 4 };
+    int value = 2;
+    Matrix<int> 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_mult_assign_value) {
+    // Arrange
+    size_t M = 2, N = 2;
+    int data[4] = { 2, 2, 10, 4 };
+    int value = 2;
+    Matrix<int> 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<int> 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<int> 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<int> matrix1(data1, M, N);
+    Matrix<int> matrix2(data2, M, N);
+    Matrix<int> 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<int> matrix1(data1, M, N);
+    Matrix<int> matrix2(data2, M, N);
+    Matrix<int> 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<int> matrix1(data1, M1, N1);
+    Matrix<int> 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<int> matrix1(data1, M1, N1);
+    Matrix<int> matrix2(data2, M2, N2);
+
+    // Assert
+    EXPECT_THROW(matrix1 - matrix2, std::logic_error);
+}

From 373d57f20ee1038aa39359a0ece78d793125d7ed Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Mon, 29 Sep 2025 12:44:31 +0300
Subject: [PATCH 032/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=D1=8B=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE?=
 =?UTF-8?q?=D1=80=D1=8B=20+=3D=20=D0=B8=20-=3D=20=D0=B4=D0=BB=D1=8F=20?=
 =?UTF-8?q?=D0=B4=D0=B2=D1=83=D1=85=20=D0=BC=D0=B0=D1=82=D1=80=D0=B8=D1=86?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_matrix/matrix.h | 17 ++++++++++++++++-
 1 file changed, 16 insertions(+), 1 deletion(-)

diff --git a/lib_matrix/matrix.h b/lib_matrix/matrix.h
index 73330af3..a8eb107e 100644
--- a/lib_matrix/matrix.h
+++ b/lib_matrix/matrix.h
@@ -190,13 +190,28 @@ Matrix<T> Matrix<T>::operator * (const Matrix<T>& other_matrix) const {
     Matrix<T> matrix;
     return matrix;
 }
-
 template <class T>
 Matrix<T>& Matrix<T>::operator += (const Matrix<T>& 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) {
+        for (size_t j = 0; j < _N; ++j) {
+            (*this)[i][j] += other_matrix[i][j];
+        }
+    }
     return *this;
 }
 template <class T>
 Matrix<T>& Matrix<T>::operator -= (const Matrix<T>& 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) {
+        for (size_t j = 0; j < _N; ++j) {
+            (*this)[i][j] -= other_matrix[i][j];
+        }
+    }
     return *this;
 }
 template <class T>

From 1b3ded63e37e7ad2c3ee98c678c897a775ecfcf9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Mon, 29 Sep 2025 12:46:02 +0300
Subject: [PATCH 033/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=D1=8B=20=D1=82=D0=B5=D1=81=D1=82=D1=8B=20=D0=BD?=
 =?UTF-8?q?=D0=B0=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE=D1=80=D1=8B?=
 =?UTF-8?q?=20+=3D,=20-=3D=20(=D0=B2=20=D1=82=D0=BE=D0=BC=20=D1=87=D0=B8?=
 =?UTF-8?q?=D1=81=D0=BB=D0=B5=20=D1=82=D0=B5=D1=81=D1=82=D1=8B=20=D0=BD?=
 =?UTF-8?q?=D0=B0=20=D1=81=D0=BB=D1=83=D1=87=D0=B0=D0=B8,=20=D0=BA=D0=BE?=
 =?UTF-8?q?=D0=B3=D0=B4=D0=B0=20=D1=80=D0=B0=D0=B7=D0=BC=D0=B5=D1=80=D1=8B?=
 =?UTF-8?q?=20=D0=BC=D0=B0=D1=82=D1=80=D0=B8=D1=86=20=D0=BD=D0=B5=D1=81?=
 =?UTF-8?q?=D0=BE=D0=B2=D0=BC=D0=B5=D1=81=D1=82=D0=B8=D0=BC=D1=8B=20=D0=B8?=
 =?UTF-8?q?=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=86=D0=B8=D1=8F=20=D0=BD?=
 =?UTF-8?q?=D0=B5=D0=B2=D0=BE=D0=B7=D0=BC=D0=BE=D0=B6=D0=BD=D0=B0=20(?=
 =?UTF-8?q?=D0=BE=D0=B6=D0=B8=D0=B4=D0=B4=D0=B0=D0=B5=D1=82=D1=81=D1=8F=20?=
 =?UTF-8?q?=D0=B8=D1=81=D0=BA=D0=BB=D1=8E=D1=87=D0=B5=D0=BD=D0=B8=D0=B5)?=
 =?UTF-8?q?=20)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 tests/test_matrix.cpp | 58 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 58 insertions(+)

diff --git a/tests/test_matrix.cpp b/tests/test_matrix.cpp
index 1f4640b4..0d7ae7f3 100644
--- a/tests/test_matrix.cpp
+++ b/tests/test_matrix.cpp
@@ -255,3 +255,61 @@ TEST(TestMatrixLib, matrix_sub_matrix_with_exception) {
     // 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<int> matrix1(data1, M, N);
+    Matrix<int> 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<int> matrix1(data1, M1, N1);
+    Matrix<int> 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<int> matrix1(data1, M, N);
+    Matrix<int> 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<int> matrix1(data1, M1, N1);
+    Matrix<int> matrix2(data2, M2, N2);
+    // Assert
+    EXPECT_THROW(matrix1 -= matrix2, std::logic_error);
+}

From 950db46804c7c2e08364b6d982fb06906e045734 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Tue, 30 Sep 2025 18:55:37 +0300
Subject: [PATCH 034/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE=D1=80?=
 =?UTF-8?q?=20*=20=D0=B4=D0=BB=D1=8F=20=D0=BC=D0=B0=D1=82=D1=80=D0=B8?=
 =?UTF-8?q?=D1=86=20=D0=98=20=D0=BC=D0=B5=D1=82=D0=BE=D0=B4=20=D0=B4=D0=BB?=
 =?UTF-8?q?=D1=8F=20=D1=82=D1=80=D0=B0=D0=BD=D1=81=D0=BF=D0=BE=D0=BD=D0=B8?=
 =?UTF-8?q?=D1=80=D0=BE=D0=B2=D0=B0=D0=BD=D0=B8=D1=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_matrix/matrix.h | 43 ++++++++++++++++++++++++++++++++++++-------
 1 file changed, 36 insertions(+), 7 deletions(-)

diff --git a/lib_matrix/matrix.h b/lib_matrix/matrix.h
index a8eb107e..7eed3722 100644
--- a/lib_matrix/matrix.h
+++ b/lib_matrix/matrix.h
@@ -6,6 +6,15 @@ class Matrix : public MathVector<MathVector<T>> {
 protected:
     size_t _M;
     size_t _N;
+    Matrix<T> transpose() const {
+        Matrix<T> 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);
@@ -29,9 +38,10 @@ class Matrix : public MathVector<MathVector<T>> {
     Matrix<T> operator - (const Matrix<T>& other_matrix) const;
     Matrix<T> operator * (const Matrix<T>& other_matrix) const;
 
+    Matrix<T> operator * (const MathVector<T>& vector) const;
+
     Matrix<T>& operator += (const Matrix<T>& other_matrix);
     Matrix<T>& operator -= (const Matrix<T>& other_matrix);
-    Matrix<T>& operator *= (const Matrix<T>& other_matrix);
     friend std::ostream& operator<< (std::ostream& out, const Matrix<T>& matrix) {
         for (size_t i = 0; i < matrix.getM(); ++i) {
             for (size_t j = 0; j < matrix.getN(); ++j) {
@@ -187,9 +197,32 @@ Matrix<T> Matrix<T>::operator - (const Matrix<T>& other_matrix) const {
 }
 template <class T>
 Matrix<T> Matrix<T>::operator * (const Matrix<T>& other_matrix) const {
-    Matrix<T> matrix;
-    return matrix;
+    if (_N != other_matrix.getM()) {
+        throw std::logic_error("The sizes of the matrices are not compatible for this operation!");
+    }
+    Matrix<T> result (_M, other_matrix.getN());
+    Matrix<T> 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 <class T>
+Matrix<T> Matrix<T>::operator * (const MathVector<T>& vector) const {
+    if (_N != vector.get_size()) {
+
+    }
+}
+
+
+
+
+
+
+
+
 template <class T>
 Matrix<T>& Matrix<T>::operator += (const Matrix<T>& other_matrix) {
     if (_M != other_matrix.getM() || _N != other_matrix.getN()) {
@@ -215,10 +248,6 @@ Matrix<T>& Matrix<T>::operator -= (const Matrix<T>& other_matrix) {
     return *this;
 }
 template <class T>
-Matrix<T>& Matrix<T>::operator *= (const Matrix<T>& other_matrix) {
-    return *this;
-}
-template <class T>
 MathVector<T>& Matrix<T>::operator[](size_t index) {
     return MathVector<MathVector<T>>::operator[](index);
 }

From 078ecc41fc0dc4a62bd36a6fa249c8c132985391 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Tue, 30 Sep 2025 18:56:42 +0300
Subject: [PATCH 035/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=D1=8B=20=D1=82=D0=B5=D1=81=D1=82=D1=8B=20=D0=BD?=
 =?UTF-8?q?=D0=B0=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE=D1=80=20*?=
 =?UTF-8?q?=20(=D0=B2=20=D1=82=D0=BE=D0=BC=20=D1=87=D0=B8=D1=81=D0=BB?=
 =?UTF-8?q?=D0=B5=20=D0=BD=D0=B0=20=D1=81=D0=BB=D1=83=D1=87=D0=B0=D0=B9=20?=
 =?UTF-8?q?=D1=81=20=D0=B8=D1=81=D0=BA=D0=BB=D1=8E=D1=87=D0=B5=D0=BD=D0=B8?=
 =?UTF-8?q?=D0=B5=D0=BC=20-=20=D1=80=D0=B0=D0=B7=D0=BC=D0=B5=D1=80=D1=8B?=
 =?UTF-8?q?=20=D0=BC=D0=B0=D1=82=D1=80=D0=B8=D1=86=20=D0=BD=D0=B5=D1=81?=
 =?UTF-8?q?=D0=BE=D0=B2=D0=BC=D0=B5=D1=81=D1=82=D0=B8=D0=BC=D1=8B=20=D0=B4?=
 =?UTF-8?q?=D0=BB=D1=8F=20=D1=83=D0=BC=D0=BD=D0=BE=D0=B6=D0=B5=D0=BD=D0=B8?=
 =?UTF-8?q?=D1=8F)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 tests/test_matrix.cpp | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/tests/test_matrix.cpp b/tests/test_matrix.cpp
index 0d7ae7f3..bf188359 100644
--- a/tests/test_matrix.cpp
+++ b/tests/test_matrix.cpp
@@ -313,3 +313,33 @@ TEST(TestMatrixLib, matrix_sub_assign_matrix_with_exception) {
     // 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<int> matrix1(data1, M1, N1);
+    Matrix<int> matrix2(data2, M2, N2);
+    Matrix<int> 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<int> matrix1(data1, M1, N1);
+    Matrix<int> matrix2(data2, M2, N2);
+    //Assert
+    EXPECT_THROW(matrix1 * matrix2, std::logic_error);
+}

From 36ee6e5f7fb3886c3d4ff79c825fd41f66d3370f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Tue, 30 Sep 2025 19:51:50 +0300
Subject: [PATCH 036/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE=D1=80?=
 =?UTF-8?q?=20=D0=BF=D1=80=D0=B8=D1=81=D0=B2=D0=B0=D0=B8=D0=B2=D0=B0=D0=BD?=
 =?UTF-8?q?=D0=B8=D1=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_matrix/matrix.h | 26 +++++++++++++++++---------
 1 file changed, 17 insertions(+), 9 deletions(-)

diff --git a/lib_matrix/matrix.h b/lib_matrix/matrix.h
index 7eed3722..78f155c3 100644
--- a/lib_matrix/matrix.h
+++ b/lib_matrix/matrix.h
@@ -53,6 +53,7 @@ class Matrix : public MathVector<MathVector<T>> {
     }
     MathVector<T>& operator[](size_t index);
     const MathVector<T>& operator[](size_t index) const;
+    Matrix<T>& operator=(const Matrix<T>& other);
 };
 template <class T>
 size_t Matrix<T>::getM() const {
@@ -198,7 +199,8 @@ Matrix<T> Matrix<T>::operator - (const Matrix<T>& other_matrix) const {
 template <class T>
 Matrix<T> Matrix<T>::operator * (const Matrix<T>& other_matrix) const {
     if (_N != other_matrix.getM()) {
-        throw std::logic_error("The sizes of the matrices are not compatible for this operation!");
+        throw std::logic_error
+        ("The sizes of the matrices are not compatible for this operation!");
     }
     Matrix<T> result (_M, other_matrix.getN());
     Matrix<T> matrix_t = other_matrix.transpose();
@@ -212,17 +214,16 @@ Matrix<T> Matrix<T>::operator * (const Matrix<T>& other_matrix) const {
 template <class T>
 Matrix<T> Matrix<T>::operator * (const MathVector<T>& 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<T> result(_M);
+    for (size_t i = 0; i < _M; ++i) {
+        result[i] = (*this)[i] * vector;
 
     }
+    return result;
 }
-
-
-
-
-
-
-
-
 template <class T>
 Matrix<T>& Matrix<T>::operator += (const Matrix<T>& other_matrix) {
     if (_M != other_matrix.getM() || _N != other_matrix.getN()) {
@@ -255,3 +256,10 @@ template <class T>
 const MathVector<T>& Matrix<T>::operator[](size_t index) const {
     return MathVector<MathVector<T>>::operator[](index);
 }
+template <class T>
+Matrix<T>& Matrix<T>::operator=(const Matrix<T>& other) {
+    MathVector<MathVector<T>>::operator=(other);
+    _M = other._M;
+    _N = other._N;
+    return *this;
+}

From 1f8c6914ae0007f40d57e314c5f149ce1307b0d7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Tue, 30 Sep 2025 19:53:02 +0300
Subject: [PATCH 037/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE=D1=80?=
 =?UTF-8?q?=20=D0=BF=D1=80=D0=B8=D1=81=D0=B2=D0=B0=D0=B8=D0=B2=D0=B0=D0=BD?=
 =?UTF-8?q?=D0=B8=D1=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_math_vector/math_vector.h | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/lib_math_vector/math_vector.h b/lib_math_vector/math_vector.h
index 927b79e5..0fc35d21 100644
--- a/lib_math_vector/math_vector.h
+++ b/lib_math_vector/math_vector.h
@@ -21,6 +21,7 @@ class MathVector : public Tvector<T> {
 
     MathVector<T>& operator += (const MathVector<T>& vector);
     MathVector<T>& operator -= (const MathVector<T>& vector);
+    MathVector<T>& operator=(const MathVector<T>& other);
     friend std::ostream& operator<<(std::ostream& out, const MathVector<T>& vector) {
         out << "[";
         for (size_t i = 0; i < vector.get_size(); ++i) {
@@ -132,3 +133,10 @@ MathVector<T>& MathVector<T>::operator -= (const MathVector<T>& vector) {
     }
     return *this;
 }
+template <class T>
+MathVector<T>& MathVector<T>::operator=(const MathVector<T>& other) {
+    if (this != &other) {
+        Tvector<T>::operator=(other);
+    }
+    return *this;
+}

From e02c7d2235623f1ee2a15b743d36590829a1c51f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Tue, 30 Sep 2025 20:16:06 +0300
Subject: [PATCH 038/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=20=D1=82=D0=B5=D1=81=D1=82=20=D0=BD=D0=B0=20=D0=BE?=
 =?UTF-8?q?=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE=D1=80=20=D0=BF=D1=80=D0=B8?=
 =?UTF-8?q?=D1=81=D0=B2=D0=B0=D0=B8=D0=B2=D0=B0=D0=BD=D0=B8=D1=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 tests/test_math_vector.cpp | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/tests/test_math_vector.cpp b/tests/test_math_vector.cpp
index 9a234df9..920f2a7c 100644
--- a/tests/test_math_vector.cpp
+++ b/tests/test_math_vector.cpp
@@ -260,3 +260,17 @@ TEST(TestMathVectorLib, mathvector_sub_assign_for_vectors_with_different_dimensi
     // Assert
     EXPECT_THROW(vector1 -= vector2, std::logic_error);
 }
+TEST(TestMathVectorLib, mathvector_simple_assignment) {
+    // Arrange
+    MathVector<int> vector1(2);
+    MathVector<int> 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);  
+}

From 187a5e83c4300c829520870eee39d67dc9604481 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Tue, 30 Sep 2025 20:17:54 +0300
Subject: [PATCH 039/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE=D1=80?=
 =?UTF-8?q?=20*=20=D0=B4=D0=BB=D1=8F=20=D0=BC=D0=B0=D1=82=D1=80=D0=B8?=
 =?UTF-8?q?=D1=86=D1=8B=20=D0=B8=20=D0=B2=D0=B5=D0=BA=D1=82=D0=BE=D1=80?=
 =?UTF-8?q?=D0=B0,=20=D0=B0=20=D1=82=D0=B0=D0=BA=D0=B6=D0=B5=20=D0=BE?=
 =?UTF-8?q?=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE=D1=80=20=D0=BF=D1=80=D0=B8?=
 =?UTF-8?q?=D1=81=D0=B2=D0=B0=D0=B8=D0=B2=D0=B0=D0=BD=D0=B8=D1=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_matrix/matrix.h | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/lib_matrix/matrix.h b/lib_matrix/matrix.h
index 78f155c3..2d009273 100644
--- a/lib_matrix/matrix.h
+++ b/lib_matrix/matrix.h
@@ -16,6 +16,8 @@ class Matrix : public MathVector<MathVector<T>> {
         return result;
     }
 public:
+    using MathVector<MathVector<T>>::operator=;
+
     Matrix();
     Matrix(size_t M, size_t N);
     Matrix(T* data, size_t M, size_t N);
@@ -38,7 +40,7 @@ class Matrix : public MathVector<MathVector<T>> {
     Matrix<T> operator - (const Matrix<T>& other_matrix) const;
     Matrix<T> operator * (const Matrix<T>& other_matrix) const;
 
-    Matrix<T> operator * (const MathVector<T>& vector) const;
+    MathVector<T> operator * (const MathVector<T>& vector) const;
 
     Matrix<T>& operator += (const Matrix<T>& other_matrix);
     Matrix<T>& operator -= (const Matrix<T>& other_matrix);
@@ -212,7 +214,7 @@ Matrix<T> Matrix<T>::operator * (const Matrix<T>& other_matrix) const {
     return result;
 }
 template <class T>
-Matrix<T> Matrix<T>::operator * (const MathVector<T>& vector) const {
+MathVector<T> Matrix<T>::operator * (const MathVector<T>& vector) const {
     if (_N != vector.get_size()) {
         throw std::logic_error
         ("Size of matrix aren't compatible with vector's size for this operation!");

From 7d5d91b2def609a7335d18cef66805ee898ffb32 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Tue, 30 Sep 2025 20:19:43 +0300
Subject: [PATCH 040/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=D1=8B=20=D1=82=D0=B5=D1=81=D1=82=D1=8B=20=D0=BD?=
 =?UTF-8?q?=D0=B0=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE=D1=80=20*?=
 =?UTF-8?q?=20=D0=B4=D0=BB=D1=8F=20=D0=BC=D0=B0=D1=82=D1=80=D0=B8=D1=86?=
 =?UTF-8?q?=D1=8B=20=D0=B8=20=D0=B2=D0=B5=D0=BA=D1=82=D0=BE=D1=80=D0=B0=20?=
 =?UTF-8?q?(+=20=D1=81=D0=BB=D1=83=D1=87=D0=B0=D0=B9=20=D1=81=20=D0=B8?=
 =?UTF-8?q?=D1=81=D0=BA=D0=BB=D1=8E=D1=87=D0=B5=D0=BD=D0=B8=D0=B5=D0=BC),?=
 =?UTF-8?q?=20=D1=82=D0=B5=D1=81=D1=82=20=D0=BD=D0=B0=20=D0=BE=D0=BF=D0=B5?=
 =?UTF-8?q?=D1=80=D0=B0=D1=82=D0=BE=D1=80=20=D0=BF=D1=80=D0=B8=D1=81=D0=B2?=
 =?UTF-8?q?=D0=B0=D0=B8=D0=B2=D0=B0=D0=BD=D0=B8=D1=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 tests/test_matrix.cpp | 44 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/tests/test_matrix.cpp b/tests/test_matrix.cpp
index bf188359..a0482516 100644
--- a/tests/test_matrix.cpp
+++ b/tests/test_matrix.cpp
@@ -343,3 +343,47 @@ TEST(TestMatrixLib, matrix_mult_matrix_with_throw) {
     //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<int> matrix(data1, M, N);
+    MathVector<int> vector(data2, size);
+    MathVector<int> 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<int> matrix(data1, M, N);
+    MathVector<int> vector(data2, size);
+    // Assert
+    EXPECT_THROW(matrix * vector, std::logic_error);
+}
+TEST(TestMatrixLib, matrix_simple_assignment) {
+    // Arrange
+    Matrix<int> matrix1(2, 2);
+    Matrix<int> 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);
+}

From a5333b3880c86f2e8e8c21ff6d9fa2ebb1407894 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Tue, 30 Sep 2025 20:38:11 +0300
Subject: [PATCH 041/109] =?UTF-8?q?=D0=A3=D0=B1=D1=80=D0=B0=D0=BD=D1=8B=20?=
 =?UTF-8?q?=D0=BD=D0=B5=D0=B2=D0=BE=D0=B7=D0=BC=D0=BE=D0=B6=D0=BD=D1=8B?=
 =?UTF-8?q?=D0=B5=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D0=B8=D0=B8:=20=D1=81?=
 =?UTF-8?q?=D0=BB=D0=BE=D0=B6=D0=B5=D0=BD=D0=B8=D0=B5=20=D0=B8=20=D0=B2?=
 =?UTF-8?q?=D1=8B=D1=87=D0=B8=D1=82=D0=B0=D0=BD=D0=B8=D0=B5=20=D0=B2=D0=B5?=
 =?UTF-8?q?=D0=BA=D1=82=D0=BE=D1=80=D0=B0=20=D0=B8=20=D0=BC=D0=B0=D1=82?=
 =?UTF-8?q?=D1=80=D0=B8=D1=86=D1=8B=20(=D0=BE=D1=88=D0=B8=D0=B1=D0=BE?=
 =?UTF-8?q?=D1=87=D0=BD=D1=8B=D0=B5)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 main/main.cpp | 28 +++-------------------------
 1 file changed, 3 insertions(+), 25 deletions(-)

diff --git a/main/main.cpp b/main/main.cpp
index e65391ee..bc6d33d8 100644
--- a/main/main.cpp
+++ b/main/main.cpp
@@ -143,10 +143,8 @@ void printMainMenu() {
     std::cout << " 5. Subtract scalar from matrix\n";
     std::cout << " 6. Multiply matrix by scalar\n";
     std::cout << " 7. Division by scalar\n";
-    std::cout << " 8. Add vector to matrix\n";
-    std::cout << " 9. Subtract vector from matrix\n";
-    std::cout << " 10. Multiply matrix by vector\n";
-    std::cout << " 11. Exit\n";
+    std::cout << " 8. Multiply matrix by vector\n";
+    std::cout << " 9. Exit\n";
 }
 
 int main() {
@@ -268,32 +266,12 @@ int main() {
 
             std::cout << "Enter vector elements:\n";
             system("pause");
-            Matrix<int> result = matrix1 + mathvector;
+            MathVector<int> result = matrix1 * mathvector;
             std::cout << "Result:\n" << result;
             break;
         }
         case 9: {
-            size_t size;
-            std::cout << "Enter vector size:\n";
-            std::cin >> size;
-            MathVector<int> mathvector(size);
 
-            std::cout << "Enter vector elements:\n";
-            system("pause");
-            Matrix<int> result = matrix1 - mathvector;
-            std::cout << "Result:\n" << result;
-            break;
-        }
-        case 10: {
-            size_t size;
-            std::cout << "Enter vector size:\n";
-            std::cin >> size;
-            MathVector<int> mathvector(size);
-
-            std::cout << "Enter vector elements:\n";
-            system("pause");
-            MathVector<int> result = matrix1 * mathvector;
-            std::cout << "Result:\n" << result;
             break;
         }
         default: {

From db6f76f4392f7a83e52ed3f5dd38857259f07c88 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Wed, 1 Oct 2025 10:00:53 +0300
Subject: [PATCH 042/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE=D1=80?=
 =?UTF-8?q?=20=D0=BF=D1=80=D0=B8=D1=81=D0=B2=D0=B0=D0=B8=D0=B2=D0=B0=D0=BD?=
 =?UTF-8?q?=D0=B8=D1=8F,=20=D0=B0=20=D1=82=D0=B0=D0=BA=D0=B6=D0=B5=20?=
 =?UTF-8?q?=D1=83=D0=B1=D1=80=D0=B0=D0=BD=D1=8B=20=D0=BE=D0=B1=D1=8A=D1=8F?=
 =?UTF-8?q?=D0=B2=D0=BB=D0=B5=D0=BD=D0=B8=D1=8F=20=D0=BE=D0=BF=D0=B5=D1=80?=
 =?UTF-8?q?=D0=B0=D1=82=D0=BE=D1=80=D0=BE=D0=B2,=20=D0=BA=D0=BE=D1=82?=
 =?UTF-8?q?=D0=BE=D1=80=D1=8B=D0=B5=20=D0=BD=D0=B5=20=D1=80=D0=B5=D0=B0?=
 =?UTF-8?q?=D0=BB=D0=B8=D0=B7=D1=83=D0=B5=D0=BC=D1=8B=20=D0=B2=20=D0=BA?=
 =?UTF-8?q?=D0=BE=D0=BD=D1=82=D0=B5=D0=BA=D1=81=D1=82=D0=B5=20=D0=BC=D0=B0?=
 =?UTF-8?q?=D1=82=D1=80=D0=B8=D1=86,=20=D0=B2=20=D1=82=D0=BE=D0=BC=20?=
 =?UTF-8?q?=D1=87=D0=B8=D1=81=D0=BB=D0=B5=20=D0=B8=20=D1=82=D1=80=D0=B5?=
 =?UTF-8?q?=D1=83=D0=B3=D0=BE=D0=BB=D1=8C=D0=BD=D1=8B=D1=85=20(=D0=B1?=
 =?UTF-8?q?=D1=8B=D0=BB=D0=B8=20=D0=B4=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB=D0=B5?=
 =?UTF-8?q?=D0=BD=D1=8B=20=D0=BF=D0=BE=20=D0=BE=D1=88=D0=B8=D0=B1=D0=BA?=
 =?UTF-8?q?=D0=B5)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_triangle_matrix/triangle_matrix.h | 33 +++++----------------------
 1 file changed, 6 insertions(+), 27 deletions(-)

diff --git a/lib_triangle_matrix/triangle_matrix.h b/lib_triangle_matrix/triangle_matrix.h
index 452dd223..f7bb6fbe 100644
--- a/lib_triangle_matrix/triangle_matrix.h
+++ b/lib_triangle_matrix/triangle_matrix.h
@@ -19,20 +19,14 @@ class TriangleMatrix : public Matrix<T> {
     TriangleMatrix<T>& operator *= (T value);
     TriangleMatrix<T>& operator /= (T value);
 
-    TriangleMatrix<T> operator + (const MathVector<T>& vector) const;
-    TriangleMatrix<T> operator - (const MathVector<T>& vector) const;
     MathVector<T> operator * (const MathVector<T>& vector) const;
 
-    TriangleMatrix<T>& operator += (const MathVector<T>& vector);
-    TriangleMatrix<T>& operator -= (const MathVector<T>& vector);
-
     TriangleMatrix<T> operator + (const TriangleMatrix<T>& other_matrix) const;
     TriangleMatrix<T> operator - (const TriangleMatrix<T>& other_matrix) const;
     TriangleMatrix<T> operator * (const TriangleMatrix<T>& other_matrix) const;
 
     TriangleMatrix<T>& operator += (const TriangleMatrix<T>& other_matrix);
     TriangleMatrix<T>& operator -= (const TriangleMatrix<T>& other_matrix);
-    TriangleMatrix<T>& operator *= (const TriangleMatrix<T>& other_matrix);
 
     friend std::ostream& operator<<(std::ostream& out, const TriangleMatrix<T>& matrix) {
         for (size_t i = 0; i < matrix.getM(); ++i) {
@@ -43,6 +37,7 @@ class TriangleMatrix : public Matrix<T> {
         }
         return out;
     }
+    TriangleMatrix<T>& operator= (const TriangleMatrix<T>& other);
 };
 template <class T>
 TriangleMatrix<T>::TriangleMatrix() : Matrix<T>() {}
@@ -50,7 +45,6 @@ template <class T>
 TriangleMatrix<T>::TriangleMatrix(const TriangleMatrix& other) : Matrix<T>(other) {}
 template <class T>
 TriangleMatrix<T>::~TriangleMatrix() = default;
-
 template <class T>
 TriangleMatrix<T> TriangleMatrix<T>::operator + (T value) const {
     TriangleMatrix<T> matrix;
@@ -90,31 +84,12 @@ TriangleMatrix<T>& TriangleMatrix<T>::operator /= (T value) {
     return *this;
 }
 
-template <class T>
-TriangleMatrix<T> TriangleMatrix<T>::operator + (const MathVector<T>& vector) const {
-    TriangleMatrix<T> matrix;
-    return matrix;
-}
-template <class T>
-TriangleMatrix<T> TriangleMatrix<T>::operator - (const MathVector<T>& vector) const {
-    TriangleMatrix<T> matrix;
-    return matrix;
-}
 template <class T>
 MathVector<T> TriangleMatrix<T>::operator * (const MathVector<T>& vector) const {
     TriangleMatrix<T> matrix;
     return matrix;
 }
 
-template <class T>
-TriangleMatrix<T>& TriangleMatrix<T>::operator += (const MathVector<T>& vector) {
-    return *this;
-}
-template <class T>
-TriangleMatrix<T>& TriangleMatrix<T>::operator -= (const MathVector<T>& vector) {
-    return *this;
-}
-
 template <class T>
 TriangleMatrix<T> TriangleMatrix<T>::operator + (const TriangleMatrix<T>& other_matrix) const {
     TriangleMatrix<T> matrix;
@@ -139,7 +114,11 @@ template <class T>
 TriangleMatrix<T>& TriangleMatrix<T>::operator -= (const TriangleMatrix<T>& other_matrix) {
     return *this;
 }
+
 template <class T>
-TriangleMatrix<T>& TriangleMatrix<T>::operator *= (const TriangleMatrix<T>& other_matrix) {
+TriangleMatrix<T>& TriangleMatrix<T>::operator= (const TriangleMatrix<T>& other) {
+    Matrix<T>::operator=(other);
+    _M = other._M;
+    _N = other._N;
     return *this;
 }

From b800f7d23429d54aca9b8960c60a6498e6a36d5d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Sat, 4 Oct 2025 11:10:18 +0300
Subject: [PATCH 043/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=D0=BE=20=D0=BE=D0=B1=D1=8A=D1=8F=D0=B2=D0=BB=D0=B5?=
 =?UTF-8?q?=D0=BD=D0=B8=D0=B5=20=D0=BA=D0=BB=D0=B0=D1=81=D1=81=D0=B0=20Tri?=
 =?UTF-8?q?angle=20Matrix?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_triangle_matrix/triangle_matrix.h | 124 ++++++++------------------
 1 file changed, 35 insertions(+), 89 deletions(-)

diff --git a/lib_triangle_matrix/triangle_matrix.h b/lib_triangle_matrix/triangle_matrix.h
index f7bb6fbe..daf425c7 100644
--- a/lib_triangle_matrix/triangle_matrix.h
+++ b/lib_triangle_matrix/triangle_matrix.h
@@ -1,14 +1,18 @@
 #pragma once 
 #include "../lib_matrix/matrix.h"
 template <class T>
-class TriangleMatrix : public Matrix<T> {
-public: 
+class TriangleMatrix: public Matrix<T> {
+public:
     TriangleMatrix();
-    TriangleMatrix(size_t M, size_t N);
-    TriangleMatrix(T* data, size_t M, size_t N);
+    TriangleMatrix(size_t size);
+    TriangleMatrix(T* data, size_t size);
     TriangleMatrix(const TriangleMatrix& other);
     ~TriangleMatrix();
 
+    size_t getSize() const { 
+        return this->_M; 
+    }
+
     TriangleMatrix<T> operator + (T value) const;
     TriangleMatrix<T> operator - (T value) const;
     TriangleMatrix<T> operator * (T value) const;
@@ -21,104 +25,46 @@ class TriangleMatrix : public Matrix<T> {
 
     MathVector<T> operator * (const MathVector<T>& vector) const;
 
-    TriangleMatrix<T> operator + (const TriangleMatrix<T>& other_matrix) const;
-    TriangleMatrix<T> operator - (const TriangleMatrix<T>& other_matrix) const;
-    TriangleMatrix<T> operator * (const TriangleMatrix<T>& other_matrix) const;
+    TriangleMatrix<T> operator + (const TriangleMatrix<T>& other) const;
+    TriangleMatrix<T> operator - (const TriangleMatrix<T>& other) const;
+    TriangleMatrix<T> operator * (const TriangleMatrix<T>& other) const;
 
-    TriangleMatrix<T>& operator += (const TriangleMatrix<T>& other_matrix);
-    TriangleMatrix<T>& operator -= (const TriangleMatrix<T>& other_matrix);
+    TriangleMatrix<T>& operator += (const TriangleMatrix<T>& other);
+    TriangleMatrix<T>& operator -= (const TriangleMatrix<T>& other);
+    TriangleMatrix<T>& operator= (const TriangleMatrix<T>& other);
 
     friend std::ostream& operator<<(std::ostream& out, const TriangleMatrix<T>& matrix) {
-        for (size_t i = 0; i < matrix.getM(); ++i) {
-            for (size_t j = 0; j < matrix.getN(); ++j) {
-                out << matrix[i][j] << "\t";
+        for (size_t i = 0; i < matrix._M; ++i) {
+            for (size_t j = 0; j < matrix._N; ++j) {
+                if (i <= j) {
+                    out << matrix[i][j] << "\t";
+                }
+                else {
+                    out << "0\t";
+                }
             }
             out << std::endl;
         }
         return out;
     }
-    TriangleMatrix<T>& operator= (const TriangleMatrix<T>& other);
 };
-template <class T>
-TriangleMatrix<T>::TriangleMatrix() : Matrix<T>() {}
-template <class T>
-TriangleMatrix<T>::TriangleMatrix(const TriangleMatrix& other) : Matrix<T>(other) {}
-template <class T>
-TriangleMatrix<T>::~TriangleMatrix() = default;
-template <class T>
-TriangleMatrix<T> TriangleMatrix<T>::operator + (T value) const {
-    TriangleMatrix<T> matrix;
-    return matrix;
-}
-template <class T>
-TriangleMatrix<T> TriangleMatrix<T>::operator - (T value) const {
-    TriangleMatrix<T> matrix;
-    return matrix;
-}
-template <class T>
-TriangleMatrix<T> TriangleMatrix<T>::operator * (T value) const {
-    TriangleMatrix<T> matrix;
-    return matrix;
-}
-template <class T>
-TriangleMatrix<T> TriangleMatrix<T>::operator / (T value) const {
-    TriangleMatrix<T> matrix;
-    return matrix;
-}
-
-template <class T>
-TriangleMatrix<T>& TriangleMatrix<T>::operator += (T value) {
-    return *this;
-}
-template <class T>
-TriangleMatrix<T>& TriangleMatrix<T>::operator -= (T value) {
-    return *this;
-
-}
-template <class T>
-TriangleMatrix<T>& TriangleMatrix<T>::operator *= (T value) {
-    return *this;
-}
-template <class T>
-TriangleMatrix<T>& TriangleMatrix<T>::operator /= (T value) {
-    return *this;
+template<class T>
+TriangleMatrix<T>::TriangleMatrix(): Matrix<T>() {}
+template<class T>
+TriangleMatrix<T>::TriangleMatrix(size_t N): MathVector<MathVector<T>>(N) {
+    for (size_t i = 0; i < N; ++i) {
+       
+    }
 }
+template<class T>
+TriangleMatrix<T>::TriangleMatrix(T* data, size_t size) {
 
-template <class T>
-MathVector<T> TriangleMatrix<T>::operator * (const MathVector<T>& vector) const {
-    TriangleMatrix<T> matrix;
-    return matrix;
 }
 
-template <class T>
-TriangleMatrix<T> TriangleMatrix<T>::operator + (const TriangleMatrix<T>& other_matrix) const {
-    TriangleMatrix<T> matrix;
-    return matrix;
-}
-template <class T>
-TriangleMatrix<T> TriangleMatrix<T>::operator - (const TriangleMatrix<T>& other_matrix) const {
-    TriangleMatrix<T> matrix;
-    return matrix;
-}
-template <class T>
-TriangleMatrix<T> TriangleMatrix<T>::operator * (const TriangleMatrix<T>& other_matrix) const {
-    TriangleMatrix<T> matrix;
-    return matrix;
-}
+template<class T>
+TriangleMatrix<T>::TriangleMatrix(const TriangleMatrix& other) {
 
-template <class T>
-TriangleMatrix<T>& TriangleMatrix<T>::operator += (const TriangleMatrix<T>& other_matrix) {
-    return *this;
-}
-template <class T>
-TriangleMatrix<T>& TriangleMatrix<T>::operator -= (const TriangleMatrix<T>& other_matrix) {
-    return *this;
 }
 
-template <class T>
-TriangleMatrix<T>& TriangleMatrix<T>::operator= (const TriangleMatrix<T>& other) {
-    Matrix<T>::operator=(other);
-    _M = other._M;
-    _N = other._N;
-    return *this;
-}
+template<class T>
+TriangleMatrix<T>::~TriangleMatrix() = default;

From 6892ddbd6ed2943bae218622fa5372755a1349cc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Sat, 4 Oct 2025 11:36:04 +0300
Subject: [PATCH 044/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=20=5Fstart=5Findex=20=D0=B4=D0=BB=D1=8F=20=D1=80?=
 =?UTF-8?q?=D0=B0=D0=B1=D0=BE=D1=82=D1=8B=20=D1=81=20=D1=82=D1=80=D0=B5?=
 =?UTF-8?q?=D1=83=D0=B3=D0=BE=D0=BB=D1=8C=D0=BD=D0=BE=D0=B9=20=D0=BC=D0=B0?=
 =?UTF-8?q?=D1=82=D1=80=D0=B8=D1=86=D0=B5=D0=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_math_vector/math_vector.h | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/lib_math_vector/math_vector.h b/lib_math_vector/math_vector.h
index 0fc35d21..2c14afe1 100644
--- a/lib_math_vector/math_vector.h
+++ b/lib_math_vector/math_vector.h
@@ -2,7 +2,9 @@
 #include <stdexcept> 
 #include "../lib_vector/vector.h"
 template <class T>
-class MathVector : public Tvector<T> {
+class MathVector:public Tvector<T> {
+protected:
+    size_t _start_index = 0;
 public:
     MathVector();
     MathVector(size_t size);
@@ -118,7 +120,7 @@ MathVector<T>& MathVector<T>::operator += (const MathVector<T>& vector)  {
     if (this->get_size() != vector.get_size()) {
         throw std::logic_error("Vectors must have the same dimension");
     }
-    for (size_t i = 0; i < this->get_size(); ++i) {
+    for (size_t i = 0; i < this->get_size(); ++i) { 
         (*this)[i] += vector[i];
     }
     return *this;

From be6bdd48676af9b2ba5bc37f6207a20138e0ab50 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Sat, 4 Oct 2025 11:42:14 +0300
Subject: [PATCH 045/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=20=D0=B3=D0=B5=D1=82=D1=82=D0=B5=D1=80=20=D0=B4?=
 =?UTF-8?q?=D0=BB=D1=8F=20=5Fstart=5Findex=20=D0=B8=20=D0=BD=D0=B5=D1=81?=
 =?UTF-8?q?=D0=BA=D0=BE=D0=BB=D1=8C=D0=BA=D0=BE=20=D0=BD=D0=BE=D0=B2=D1=8B?=
 =?UTF-8?q?=D1=85=20=D0=BA=D0=BE=D0=BD=D1=81=D1=82=D1=80=D1=83=D0=BA=D1=82?=
 =?UTF-8?q?=D0=BE=D1=80=D0=BE=D0=B2,=20=D1=83=D1=87=D0=B8=D1=82=D1=8B?=
 =?UTF-8?q?=D0=B2=D0=B0=D1=8E=D1=89=D0=B8=D0=B5=20=D0=BD=D0=B0=D0=BB=D0=B8?=
 =?UTF-8?q?=D1=87=D0=B8=D0=B5=20=D1=8D=D1=82=D0=BE=D0=B3=D0=BE=20=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B4=D0=B5=D0=BA=D1=81=D0=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_math_vector/math_vector.h | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/lib_math_vector/math_vector.h b/lib_math_vector/math_vector.h
index 2c14afe1..f78449d0 100644
--- a/lib_math_vector/math_vector.h
+++ b/lib_math_vector/math_vector.h
@@ -8,9 +8,16 @@ class MathVector:public Tvector<T> {
 public:
     MathVector();
     MathVector(size_t size);
+    MathVector(size_t size, size_t start_index);
     MathVector(T* data, size_t size);
+    MathVector(T* data, size_t size, size_t start_index);
     MathVector(const MathVector<T>& other);
     virtual ~MathVector();
+
+    size_t get_start_index() const { 
+        return _start_index; 
+    }
+
     MathVector<T> operator * (T value) const;
     MathVector<T> operator / (T value) const;
 
@@ -41,8 +48,13 @@ MathVector<T>::MathVector() : Tvector<T>() {}
 template <class T>
 MathVector<T>::MathVector(size_t size) : Tvector<T>(size) {}
 template <class T>
+MathVector<T>::MathVector(size_t size, size_t start_index) : Tvector<T>(size), _start_index(start_index) {}
+template <class T>
 MathVector<T>::MathVector(T* data, size_t size) : Tvector<T>(data, size) {} 
 template <class T>
+MathVector<T>::MathVector(T* data, size_t size, size_t start_index) : 
+    Tvector<T>(data, size), _start_index(start_index) {}
+template <class T>
 MathVector<T>::MathVector(const MathVector<T>& other) : Tvector<T>(other) {}
 template <class T>
 MathVector<T>::~MathVector() = default;

From 893fc1e82628c015eb657fb83068bba437935334 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Sat, 4 Oct 2025 11:49:38 +0300
Subject: [PATCH 046/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=20=D1=81=D0=B5=D1=82=D1=82=D0=B5=D1=80=20=D0=B4?=
 =?UTF-8?q?=D0=BB=D1=8F=20=D1=81=D1=82=D0=B0=D1=80=D1=82=D0=BE=D0=B2=D0=BE?=
 =?UTF-8?q?=D0=B3=D0=BE=20=D0=B8=D0=BD=D0=B4=D0=B5=D0=BA=D1=81=D0=B0=20?=
 =?UTF-8?q?=D0=B8=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE=D1=80=D1=8B?=
 =?UTF-8?q?=20[]?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_math_vector/math_vector.h | 22 +++++++++++++++++++++-
 1 file changed, 21 insertions(+), 1 deletion(-)

diff --git a/lib_math_vector/math_vector.h b/lib_math_vector/math_vector.h
index f78449d0..0cf042d6 100644
--- a/lib_math_vector/math_vector.h
+++ b/lib_math_vector/math_vector.h
@@ -17,6 +17,9 @@ class MathVector:public Tvector<T> {
     size_t get_start_index() const { 
         return _start_index; 
     }
+    void set_start_index(size_t index) { 
+        _start_index = index; 
+    }
 
     MathVector<T> operator * (T value) const;
     MathVector<T> operator / (T value) const;
@@ -42,6 +45,8 @@ class MathVector:public Tvector<T> {
         out << "]";
         return out;
     }
+    T& operator[](size_t index);
+    const T& operator[](size_t index) const;
 };
 template<class T>
 MathVector<T>::MathVector() : Tvector<T>() {}
@@ -55,7 +60,8 @@ template <class T>
 MathVector<T>::MathVector(T* data, size_t size, size_t start_index) : 
     Tvector<T>(data, size), _start_index(start_index) {}
 template <class T>
-MathVector<T>::MathVector(const MathVector<T>& other) : Tvector<T>(other) {}
+MathVector<T>::MathVector(const MathVector<T>& other) : 
+    Tvector<T>(other), _start_index(other._start_index) {}
 template <class T>
 MathVector<T>::~MathVector() = default;
 template <class T>
@@ -154,3 +160,17 @@ MathVector<T>& MathVector<T>::operator=(const MathVector<T>& other) {
     }
     return *this;
 }
+template <class T>
+T& MathVector<T>::operator[](size_t index) {
+    if (index < _start_index || index >= _start_index + this->get_size()) {
+        throw std::out_of_range("Index out of range");
+    }
+    return Tvector<T>::operator[](index - _start_index);
+}
+template <class T>
+const T& MathVector<T>::operator[](size_t index) const {
+    if (index < _start_index || index >= _start_index + this->get_size()) {
+        throw std::out_of_range("Index out of range");
+    }
+    return Tvector<T>::operator[](index - _start_index);
+}

From ef5d9179bb55a006946078b4727661187a2e4161 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Sat, 4 Oct 2025 12:09:33 +0300
Subject: [PATCH 047/109] =?UTF-8?q?=D0=9D=D0=B5=D0=B1=D0=BE=D0=BB=D1=8C?=
 =?UTF-8?q?=D1=88=D0=B8=D0=B5=20=D0=BF=D1=80=D0=B0=D0=B2=D0=BA=D0=B8?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_math_vector/math_vector.h | 10 +---------
 1 file changed, 1 insertion(+), 9 deletions(-)

diff --git a/lib_math_vector/math_vector.h b/lib_math_vector/math_vector.h
index 0cf042d6..d36d94aa 100644
--- a/lib_math_vector/math_vector.h
+++ b/lib_math_vector/math_vector.h
@@ -46,7 +46,6 @@ class MathVector:public Tvector<T> {
         return out;
     }
     T& operator[](size_t index);
-    const T& operator[](size_t index) const;
 };
 template<class T>
 MathVector<T>::MathVector() : Tvector<T>() {}
@@ -163,14 +162,7 @@ MathVector<T>& MathVector<T>::operator=(const MathVector<T>& other) {
 template <class T>
 T& MathVector<T>::operator[](size_t index) {
     if (index < _start_index || index >= _start_index + this->get_size()) {
-        throw std::out_of_range("Index out of range");
-    }
-    return Tvector<T>::operator[](index - _start_index);
-}
-template <class T>
-const T& MathVector<T>::operator[](size_t index) const {
-    if (index < _start_index || index >= _start_index + this->get_size()) {
-        throw std::out_of_range("Index out of range");
+        throw std::logic_error("Index out of range");
     }
     return Tvector<T>::operator[](index - _start_index);
 }

From 8f85ca52acfb3f0756d6e9982bdb02f7563f171a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Sat, 4 Oct 2025 12:49:39 +0300
Subject: [PATCH 048/109] =?UTF-8?q?=D0=A3=D0=B1=D1=80=D0=B0=D0=BD=20=D0=BE?=
 =?UTF-8?q?=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE=D1=80=20[]?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_matrix/matrix.h | 13 +------------
 1 file changed, 1 insertion(+), 12 deletions(-)

diff --git a/lib_matrix/matrix.h b/lib_matrix/matrix.h
index 2d009273..6fbeaaf6 100644
--- a/lib_matrix/matrix.h
+++ b/lib_matrix/matrix.h
@@ -16,8 +16,6 @@ class Matrix : public MathVector<MathVector<T>> {
         return result;
     }
 public:
-    using MathVector<MathVector<T>>::operator=;
-
     Matrix();
     Matrix(size_t M, size_t N);
     Matrix(T* data, size_t M, size_t N);
@@ -53,8 +51,7 @@ class Matrix : public MathVector<MathVector<T>> {
         }
         return out;
     }
-    MathVector<T>& operator[](size_t index);
-    const MathVector<T>& operator[](size_t index) const;
+    
     Matrix<T>& operator=(const Matrix<T>& other);
 };
 template <class T>
@@ -251,14 +248,6 @@ Matrix<T>& Matrix<T>::operator -= (const Matrix<T>& other_matrix) {
     return *this;
 }
 template <class T>
-MathVector<T>& Matrix<T>::operator[](size_t index) {
-    return MathVector<MathVector<T>>::operator[](index);
-}
-template <class T>
-const MathVector<T>& Matrix<T>::operator[](size_t index) const {
-    return MathVector<MathVector<T>>::operator[](index);
-}
-template <class T>
 Matrix<T>& Matrix<T>::operator=(const Matrix<T>& other) {
     MathVector<MathVector<T>>::operator=(other);
     _M = other._M;

From afae7512c777b055090050403ea14d155945acfc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Sat, 4 Oct 2025 12:58:30 +0300
Subject: [PATCH 049/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=D1=8B=20=D1=82=D0=B5=D1=81=D1=82=D1=8B=20=D0=BD?=
 =?UTF-8?q?=D0=B0=20=D0=BD=D0=BE=D0=B2=D1=8B=D0=B5=20=D0=BA=D0=BE=D0=BD?=
 =?UTF-8?q?=D1=81=D1=82=D1=80=D1=83=D0=BA=D1=82=D0=BE=D1=80=D1=8B=20=D0=B8?=
 =?UTF-8?q?=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE=D1=80=20[],=20?=
 =?UTF-8?q?=D1=81=20=D1=83=D1=87=D1=91=D1=82=D0=BE=D0=BC=20=D1=81=D1=82?=
 =?UTF-8?q?=D0=B0=D1=80=D1=82=D0=BE=D0=B2=D0=BE=D0=B3=D0=BE=20=D0=B8=D0=BD?=
 =?UTF-8?q?=D0=B4=D0=B5=D0=BA=D1=81=D0=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 tests/test_math_vector.cpp | 55 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 55 insertions(+)

diff --git a/tests/test_math_vector.cpp b/tests/test_math_vector.cpp
index 920f2a7c..c6580006 100644
--- a/tests/test_math_vector.cpp
+++ b/tests/test_math_vector.cpp
@@ -16,6 +16,16 @@ TEST(TestMathVectorLib, mathvector_constructor_with_size) {
     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<int> 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 };
@@ -28,6 +38,20 @@ TEST(TestMathVectorLib, mathvector_constructor_with_array_and_size) {
     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<int> 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 };
@@ -35,6 +59,7 @@ TEST(TestMathVectorLib, mathvector_copy_constructor) {
     MathVector<int> old_vector(data, size);
     MathVector<int> 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) {
@@ -274,3 +299,33 @@ TEST(TestMathVectorLib, mathvector_simple_assignment) {
     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<int> 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[5], 6);
+}
+TEST(TestMathVectorLib, mathvector_operator_square_brackets_with_exception) {
+    // Arrange
+    size_t size = 5;
+    size_t start_index = 2;
+    MathVector<int> vector1(size, start_index);
+    vector1[2] = 3;
+    vector1[3] = 4;
+    vector1[4] = 5;
+    vector1[5] = 6;
+    vector1[6] = 7;
+    //Act & Assert
+    EXPECT_THROW(vector1[0], std::logic_error);
+    EXPECT_THROW(vector1[1], std::logic_error);
+    EXPECT_THROW(vector1[7], std::logic_error);
+}

From 8ff2e54b666273a17016bf372b1b20737580c595 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Sat, 4 Oct 2025 13:09:31 +0300
Subject: [PATCH 050/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=D1=8B=20=D0=BA=D0=BE=D0=BD=D1=81=D1=82=D1=80=D1=83?=
 =?UTF-8?q?=D0=BA=D1=82=D0=BE=D1=80=D1=8B?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_triangle_matrix/triangle_matrix.h | 35 +++++++++++++++------------
 1 file changed, 19 insertions(+), 16 deletions(-)

diff --git a/lib_triangle_matrix/triangle_matrix.h b/lib_triangle_matrix/triangle_matrix.h
index daf425c7..180166fe 100644
--- a/lib_triangle_matrix/triangle_matrix.h
+++ b/lib_triangle_matrix/triangle_matrix.h
@@ -1,7 +1,8 @@
 #pragma once 
 #include "../lib_matrix/matrix.h"
+
 template <class T>
-class TriangleMatrix: public Matrix<T> {
+class TriangleMatrix : public Matrix<T> {
 public:
     TriangleMatrix();
     TriangleMatrix(size_t size);
@@ -9,8 +10,8 @@ class TriangleMatrix: public Matrix<T> {
     TriangleMatrix(const TriangleMatrix& other);
     ~TriangleMatrix();
 
-    size_t getSize() const { 
-        return this->_M; 
+    size_t getSize() const {
+        return this->_M;
     }
 
     TriangleMatrix<T> operator + (T value) const;
@@ -34,8 +35,8 @@ class TriangleMatrix: public Matrix<T> {
     TriangleMatrix<T>& operator= (const TriangleMatrix<T>& other);
 
     friend std::ostream& operator<<(std::ostream& out, const TriangleMatrix<T>& matrix) {
-        for (size_t i = 0; i < matrix._M; ++i) {
-            for (size_t j = 0; j < matrix._N; ++j) {
+        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";
                 }
@@ -49,22 +50,24 @@ class TriangleMatrix: public Matrix<T> {
     }
 };
 template<class T>
-TriangleMatrix<T>::TriangleMatrix(): Matrix<T>() {}
+TriangleMatrix<T>::TriangleMatrix() : Matrix<T>() {}
 template<class T>
-TriangleMatrix<T>::TriangleMatrix(size_t N): MathVector<MathVector<T>>(N) {
-    for (size_t i = 0; i < N; ++i) {
-       
+TriangleMatrix<T>::TriangleMatrix(size_t size) : Matrix<T>(size, size) {
+    for (size_t i = 0; i < size; ++i) {
+        (*this)[i] = MathVector<T>(size - i, i);
     }
 }
 template<class T>
-TriangleMatrix<T>::TriangleMatrix(T* data, size_t size) {
-
+TriangleMatrix<T>::TriangleMatrix(T* data, size_t size) : Matrix<T>(size, size) {
+    size_t data_index = 0;
+    for (size_t i = 0; i < size; ++i) {
+        (*this)[i] = MathVector<T>(size - i, i);
+        for (size_t j = i; j < size; ++j) {
+            (*this)[i][j] = data[data_index++];
+        }
+    }
 }
-
 template<class T>
-TriangleMatrix<T>::TriangleMatrix(const TriangleMatrix& other) {
-
-}
-
+TriangleMatrix<T>::TriangleMatrix(const TriangleMatrix& other) : Matrix<T>(other) {}
 template<class T>
 TriangleMatrix<T>::~TriangleMatrix() = default;

From 0a176c5f34f517b51790ad260e13443ce6fb3a1f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Sun, 5 Oct 2025 18:00:02 +0300
Subject: [PATCH 051/109] =?UTF-8?q?=D0=9F=D0=BE=D0=BB=D0=BD=D0=BE=D1=81?=
 =?UTF-8?q?=D1=82=D1=8C=D1=8E=20=D0=B3=D0=BE=D1=82=D0=BE=D0=B2=D1=8B=20?=
 =?UTF-8?q?=D0=BA=D0=BE=D0=BD=D1=81=D1=82=D1=80=D1=83=D0=BA=D1=82=D0=BE?=
 =?UTF-8?q?=D1=80=D1=8B,=20=D0=B4=D0=B5=D1=81=D1=82=D1=80=D1=83=D0=BA?=
 =?UTF-8?q?=D1=82=D0=BE=D1=80=20=D0=B8=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0?=
 =?UTF-8?q?=D1=82=D0=BE=D1=80=20=D0=BF=D1=80=D0=B8=D1=81=D0=B2=D0=B0=D0=B8?=
 =?UTF-8?q?=D0=B2=D0=B0=D0=BD=D0=B8=D1=8F=20(=D1=80=D0=B5=D0=B0=D0=BB?=
 =?UTF-8?q?=D0=B8=D0=B7=D0=B0=D1=86=D0=B8=D0=B8)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_triangle_matrix/triangle_matrix.h | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/lib_triangle_matrix/triangle_matrix.h b/lib_triangle_matrix/triangle_matrix.h
index 180166fe..53d8b2bd 100644
--- a/lib_triangle_matrix/triangle_matrix.h
+++ b/lib_triangle_matrix/triangle_matrix.h
@@ -59,15 +59,19 @@ TriangleMatrix<T>::TriangleMatrix(size_t size) : Matrix<T>(size, size) {
 }
 template<class T>
 TriangleMatrix<T>::TriangleMatrix(T* data, size_t size) : Matrix<T>(size, size) {
-    size_t data_index = 0;
     for (size_t i = 0; i < size; ++i) {
-        (*this)[i] = MathVector<T>(size - i, i);
-        for (size_t j = i; j < size; ++j) {
-            (*this)[i][j] = data[data_index++];
-        }
+        (*this)[i] = MathVector<T>(data + i * size + i, size - i, i);
+       
     }
 }
 template<class T>
 TriangleMatrix<T>::TriangleMatrix(const TriangleMatrix& other) : Matrix<T>(other) {}
 template<class T>
 TriangleMatrix<T>::~TriangleMatrix() = default;
+template<class T>
+TriangleMatrix<T>& TriangleMatrix<T>::operator= (const TriangleMatrix<T>& other) {
+    if (this != &other) {
+        Matrix<T>::operator=(other);
+    }
+    return *this;
+}

From 3822b6e0f2048485cd351672461d9e835e99bd58 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Sun, 5 Oct 2025 20:18:35 +0300
Subject: [PATCH 052/109] =?UTF-8?q?=D0=9A=D0=BE=D0=BD=D1=81=D1=82=D1=80?=
 =?UTF-8?q?=D1=83=D0=BA=D1=82=D0=BE=D1=80=20=D1=81=20=D0=BC=D0=B0=D1=81?=
 =?UTF-8?q?=D1=81=D0=B8=D0=B2=D0=BE=D0=BC=20=D0=B8=20=D1=80=D0=B0=D0=B7?=
 =?UTF-8?q?=D0=BC=D0=B5=D1=80=D0=BE=D0=BC=20=D0=BF=D0=BE=D0=BA=D0=B0=20?=
 =?UTF-8?q?=D0=BD=D0=B5=20=D1=80=D0=B5=D0=B0=D0=BB=D0=B8=D0=B7=D0=BE=D0=B2?=
 =?UTF-8?q?=D0=B0=D0=BD=20(=D0=BF=D1=80=D0=B5=D0=B4=D1=8B=D0=B4=D1=83?=
 =?UTF-8?q?=D1=89=D0=B8=D0=B9=20=D0=BA=D0=BE=D0=BD=D1=81=D1=82=D1=80=D1=83?=
 =?UTF-8?q?=D0=BA=D1=82=D0=BE=D1=80=20=D0=B1=D1=8B=D0=BB=20=D0=BD=D0=B5?=
 =?UTF-8?q?=D0=B2=D0=B5=D1=80=D0=B5=D0=BD=20-=20=D0=BE=D0=BD=20=D0=BD?=
 =?UTF-8?q?=D0=B5=20=D0=BF=D1=80=D0=BE=D1=88=D1=91=D0=BB=20=D1=82=D0=B5?=
 =?UTF-8?q?=D1=81=D1=82),=20=D0=B4=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB=D0=B5?=
 =?UTF-8?q?=D0=BD=D1=8B=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE=D1=80?=
 =?UTF-8?q?=D1=8B=20+,=20-,=20*,=20/=20=D0=B4=D0=BB=D1=8F=20=D1=82=D1=80?=
 =?UTF-8?q?=D0=B5=D1=83=D0=B3=D0=BE=D0=BB=D1=8C=D0=BD=D0=BE=D0=B9=20=D0=BC?=
 =?UTF-8?q?=D0=B0=D1=82=D1=80=D0=B8=D1=86=D1=8B=20=D0=B8=20=D0=B7=D0=BD?=
 =?UTF-8?q?=D0=B0=D1=87=D0=B5=D0=BD=D0=B8=D1=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_triangle_matrix/triangle_matrix.h | 53 +++++++++++++++++++++++----
 1 file changed, 46 insertions(+), 7 deletions(-)

diff --git a/lib_triangle_matrix/triangle_matrix.h b/lib_triangle_matrix/triangle_matrix.h
index 53d8b2bd..34b70596 100644
--- a/lib_triangle_matrix/triangle_matrix.h
+++ b/lib_triangle_matrix/triangle_matrix.h
@@ -57,13 +57,9 @@ TriangleMatrix<T>::TriangleMatrix(size_t size) : Matrix<T>(size, size) {
         (*this)[i] = MathVector<T>(size - i, i);
     }
 }
-template<class T>
-TriangleMatrix<T>::TriangleMatrix(T* data, size_t size) : Matrix<T>(size, size) {
-    for (size_t i = 0; i < size; ++i) {
-        (*this)[i] = MathVector<T>(data + i * size + i, size - i, i);
-       
-    }
-}
+//template<class T>
+//TriangleMatrix<T>::TriangleMatrix(T* data, size_t size) : Matrix<T>(size, size) { 
+//}
 template<class T>
 TriangleMatrix<T>::TriangleMatrix(const TriangleMatrix& other) : Matrix<T>(other) {}
 template<class T>
@@ -75,3 +71,46 @@ TriangleMatrix<T>& TriangleMatrix<T>::operator= (const TriangleMatrix<T>& other)
     }
     return *this;
 }
+template<class T>
+TriangleMatrix<T> TriangleMatrix<T>::operator + (T value) const {
+    TriangleMatrix<T> 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<class T>
+TriangleMatrix<T> TriangleMatrix<T>::operator - (T value) const {
+    TriangleMatrix<T> 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<class T>
+TriangleMatrix<T> TriangleMatrix<T>::operator * (T value) const {
+    TriangleMatrix<T> 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<class T>
+TriangleMatrix<T> TriangleMatrix<T>::operator / (T value) const {
+    if (value == 0) {
+        throw std::logic_error("Division by zero!");
+    }
+    TriangleMatrix<T> 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;
+}

From 3b942ac08ae56b879cba59528eb2b1fba207abf1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Sun, 5 Oct 2025 20:19:42 +0300
Subject: [PATCH 053/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=D1=8B=20=D1=82=D0=B5=D1=81=D1=82=D1=8B=20=D0=BD?=
 =?UTF-8?q?=D0=B0=20=D0=BA=D0=BE=D0=BD=D1=81=D1=82=D1=80=D1=83=D0=BA=D1=82?=
 =?UTF-8?q?=D0=BE=D1=80=D1=8B=20(=D1=82=D0=B5=D1=81=D1=82=20=D0=BD=D0=B0?=
 =?UTF-8?q?=20=D0=BA=D0=BE=D0=BD=D1=81=D1=82=D1=80=D1=83=D0=BA=D1=82=D0=BE?=
 =?UTF-8?q?=D1=80=20=D1=81=20=D0=BC=D0=B0=D1=81=D1=81=D0=B8=D0=B2=D0=BE?=
 =?UTF-8?q?=D0=BC=20=D0=B8=20=D1=80=D0=B0=D0=B7=D0=BC=D0=B5=D1=80=D0=BE?=
 =?UTF-8?q?=D0=BC=20=D0=BF=D0=BE=D0=BA=D0=B0=20=D0=BD=D0=B5=20=D0=BF=D1=80?=
 =?UTF-8?q?=D0=BE=D1=85=D0=BE=D0=B4=D0=B8=D1=82)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 tests/test_triangle_matrix.cpp | 41 ++++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 tests/test_triangle_matrix.cpp

diff --git a/tests/test_triangle_matrix.cpp b/tests/test_triangle_matrix.cpp
new file mode 100644
index 00000000..3999ba4a
--- /dev/null
+++ b/tests/test_triangle_matrix.cpp
@@ -0,0 +1,41 @@
+//Copyright 2025 Julia Zabytina
+#include <stdexcept>
+#include <gtest/gtest.h>
+#include "../lib_triangle_matrix/triangle_matrix.h"
+TEST(TestTriangleMatrixLib, tr_matrix_default_constructor) {
+    // Arrange & Act
+    TriangleMatrix<int> 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<int> 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<int> matrix(data, size);
+
+    // Assert
+    EXPECT_EQ(size, matrix.getSize());
+
+    EXPECT_EQ(matrix[0][0], 1);
+    EXPECT_EQ(matrix[0][1], 2);
+    EXPECT_EQ(matrix[0][2], 3);
+    EXPECT_EQ(matrix[1][1], 4);
+    EXPECT_EQ(matrix[1][2], 5);
+    EXPECT_EQ(matrix[2][2], 6);
+
+    EXPECT_THROW(matrix[1][0], std::logic_error);
+    EXPECT_THROW(matrix[2][0], std::logic_error);
+    EXPECT_THROW(matrix[2][1], std::logic_error);
+}
+
+

From da15c1d03a3d530bee670fe7f18f23016403d79f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Sun, 5 Oct 2025 20:24:15 +0300
Subject: [PATCH 054/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=D1=8B=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE?=
 =?UTF-8?q?=D1=80=D1=8B=20+=3D,=20-=3D,=20*=3D,=20/=3D=20=D0=B4=D0=BB?=
 =?UTF-8?q?=D1=8F=20=D0=BC=D0=B0=D1=82=D1=80=D0=B8=D1=86=D1=8B=20=D0=B8=20?=
 =?UTF-8?q?=D0=B7=D0=BD=D0=B0=D1=87=D0=B5=D0=BD=D0=B8=D1=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_triangle_matrix/triangle_matrix.h | 39 +++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)

diff --git a/lib_triangle_matrix/triangle_matrix.h b/lib_triangle_matrix/triangle_matrix.h
index 34b70596..99228672 100644
--- a/lib_triangle_matrix/triangle_matrix.h
+++ b/lib_triangle_matrix/triangle_matrix.h
@@ -114,3 +114,42 @@ TriangleMatrix<T> TriangleMatrix<T>::operator / (T value) const {
     }
     return result;
 }
+template<class T>
+TriangleMatrix<T>& TriangleMatrix<T>::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<class T>
+TriangleMatrix<T>& TriangleMatrix<T>::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<class T>
+TriangleMatrix<T>& TriangleMatrix<T>::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<class T>
+TriangleMatrix<T>& TriangleMatrix<T>::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;
+}

From 2042a5c90cb80f597d52b6d71610bec0c997a362 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Mon, 6 Oct 2025 22:38:18 +0300
Subject: [PATCH 055/109] =?UTF-8?q?=D0=9D=D0=B5=D0=B1=D0=BE=D0=BB=D1=8C?=
 =?UTF-8?q?=D1=88=D0=B8=D0=B5=20=D0=BF=D1=80=D0=B0=D0=B2=D0=BA=D0=B8?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_vector/vector.h | 1256 +++++++++++++++++++++----------------------
 1 file changed, 628 insertions(+), 628 deletions(-)

diff --git a/lib_vector/vector.h b/lib_vector/vector.h
index ea1c7777..0dcdbfae 100644
--- a/lib_vector/vector.h
+++ b/lib_vector/vector.h
@@ -1,694 +1,694 @@
-// Copyright 2025 Zabytina Julia. All rights reserved.
-#pragma once
-#include <cstddef> 
-#include <stdexcept>
-#include <vector>
-#include <exception>
-#include <random>
-#include <iostream>
-#include <utility>
-#include <memory>
-#include <algorithm>
-template <class T>
-class Tvector {
-public:
-    enum State {
-        empty, busy, deleted
-    };
-private:
-    static constexpr size_t RESERVE_MEMORY = 15;
-    static constexpr size_t MAX_PERCENT_DELETED = 15;
+    // Copyright 2025 Zabytina Julia. All rights reserved.
+    #pragma once
+    #include <cstddef> 
+    #include <stdexcept>
+    #include <vector>
+    #include <exception>
+    #include <random>
+    #include <iostream>
+    #include <utility>
+    #include <memory>
+    #include <algorithm>
+    template <class T>
+    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 _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();
-    inline bool is_full() const noexcept {
-        return _size == _capacity;
-    }
-public:
-    Tvector() noexcept;
-    Tvector(size_t size);
-    Tvector(T* data, size_t size);
-    Tvector(const Tvector<T>& other_vector);
-    ~Tvector() noexcept;
+        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();
+        inline bool is_full() const noexcept {
+            return _size == _capacity;
+        }
+    public:
+        Tvector() noexcept;
+        Tvector(size_t size);
+        Tvector(T* data, size_t size);
+        Tvector(const Tvector<T>& other_vector);
+        virtual ~Tvector() noexcept;
 
-    inline bool is_empty() const noexcept {
-        return _size == 0;
-    }
-    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 {
+        inline bool is_empty() const noexcept {
+            return _size == 0;
+        }
+        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<T>& vector) const;
+        bool operator!=(const Tvector<T>& vector) const;
+        Tvector<T>& operator=(const Tvector<T>& 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<T>& 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<typename U>
+        friend std::ostream& operator<<(std::ostream&, const Tvector<U>& vector);
+        template <class U> friend void shell_sort(Tvector<U>& object) noexcept;
+        template <class U> friend void shuffle(Tvector<U>& object) noexcept;
+        template <class U> friend size_t find_first_element(const Tvector<U>& object, const U& value);
+        template <class U> friend size_t find_last_element(const Tvector<U>& object, const U& value);
+        template <class U> friend size_t find_count_of_all_suitable_elements(const Tvector<U>& object, const U& value);
+    };
+    template <class T>
+    size_t Tvector<T>::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;
     }
-    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<T>& vector) const;
-    bool operator!=(const Tvector<T>& vector) const;
-    Tvector<T>& operator=(const Tvector<T>& 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<T>& 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 <class T>
+    void Tvector<T>::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<T*>(::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;
 
-    template<typename U>
-    friend std::ostream& operator<<(std::ostream&, const Tvector<U>& vector);
-    template <class U> friend void shell_sort(Tvector<U>& object) noexcept;
-    template <class U> friend void shuffle(Tvector<U>& object) noexcept;
-    template <class U> friend size_t find_first_element(const Tvector<U>& object, const U& value);
-    template <class U> friend size_t find_last_element(const Tvector<U>& object, const U& value);
-    template <class U> friend size_t find_count_of_all_suitable_elements(const Tvector<U>& object, const U& value);
-};
-template <class T>
-size_t Tvector<T>::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;
+                _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;
             }
-            ++busy_count;
         }
     }
-    return _size;
-}
-template <class T>
-void Tvector<T>::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--;
+    template <class T>
+    void Tvector<T>::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<T*>(::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;
             }
-            _data[i].~T();
-            _states[i] = State::empty;
         }
-        _size = new_size;
     }
-    else {
-        size_t new_capacity = new_size + RESERVE_MEMORY;
-        T* new_data = static_cast<T*>(::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;
+    template <class T>
+    void Tvector<T>::shrink_to_fit() {
+        if (_size >= _capacity) {
+            return;
         }
-        try {
+        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 (new_data + i) T(std::move(_data[i]));
+                new_data[i] = 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[] _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;
+            _capacity = _size;
         }
     }
-}
-template <class T>
-void Tvector<T>::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;
+    template <class T>
+    void Tvector<T>::reserve(size_t new_capacity) {
+        if (new_capacity <= _capacity) {
+            return;
         }
-        _size = new_size;
-    }
-    else {
-        size_t new_capacity = new_size + RESERVE_MEMORY;
-        T* new_data = static_cast<T*>(::operator new(new_capacity * sizeof(T)));
+        T* new_data = new T[new_capacity];
         State* new_states = new State[new_capacity];
-        for (size_t i = new_size; i < new_capacity; ++i) {
-            new_states[i] = State::empty;
+        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];
         }
-        try {
-            for (size_t i = 0; i < _size; ++i) {
-                new (new_data + i) T(std::move(_data[i]));
-                new_states[i] = _states[i];
+        delete[] _data;
+        delete[] _states;
+        _data = new_data;
+        _states = new_states;
+        _capacity = new_capacity;
+    }
+    template <class T>
+    void Tvector<T>::compact_storage() {
+        size_t busy_count = 0;
+        for (size_t i = 0; i < _size; ++i) {
+            if (_states[i] == State::busy) {
+                busy_count++;
             }
-            for (size_t i = _size; i < new_size; ++i) {
-                new (new_data + i) T(value);
-                new_states[i] = State::busy;
+        }
+        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) {
+        }
+        for (size_t i = 0; i < _size; ++i) {
+            if (_states[i] != State::empty) {
                 _data[i].~T();
             }
-            ::operator delete(_data);
-            delete[] _states;
+        }
+        delete[] _data;
+        delete[] _states;
+        _data = new_data;
+        _states = new_states;
+        _capacity = new_capacity;
+        _size = busy_count;
+        _deleted = 0;
+    }
+    template <class T>
+    Tvector<T>::Tvector() noexcept {
+        _size = 0;
+        _capacity = 0;
+        _data = nullptr;
+        _states = nullptr;
+        _deleted = 0;
+    }
+    template <class T>
+    Tvector<T>::Tvector(size_t size) {
+        _size = size;
+        _capacity = size + RESERVE_MEMORY;
+        _data = new T[_capacity];
 
-            _data = new_data;
-            _states = new_states;
-            _capacity = new_capacity;
-            _size = new_size;
+        try {
+            _states = new State[_capacity];
         }
-        catch (...) {
-            for (size_t i = 0; i < new_size; ++i) {
-                new_data[i].~T();
-            }
-            ::operator delete(new_data);
-            delete[] new_states;
+        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 <class T>
-void Tvector<T>::shrink_to_fit() {
-    if (_size >= _capacity) {
-        return;
+    template <class T>
+    Tvector<T>::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;
     }
-    else if (_size == 0) {
-        delete[] _data;
-        delete[] _states;
+    template <class T>
+    Tvector<T>::Tvector(const Tvector<T>& other_vector) {
+        _size = other_vector._size;
+        _capacity = other_vector._capacity;
         _data = nullptr;
         _states = nullptr;
-        _capacity = 0;
-        _deleted = 0;
+        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 <class T>
+    Tvector<T>::~Tvector() noexcept {
+        delete[] _data;
+        delete[] _states;
+    }
+    template <class T>
+    inline T& Tvector<T>::front() {
+        if (_size == 0) {
+            throw std::out_of_range("Vector is empty");
+        }
+        return _data[0];
+    }
+    template <class T>
+    inline T& Tvector<T>::back() {
+        if (_size == 0) {
+            throw std::out_of_range("Vector is empty");
+        }
+        return _data[_size - 1];
+    }
+    template <class T>
+    inline const T& Tvector<T>::front() const {
+        if (_size == 0) {
+            throw std::out_of_range("Vector is empty");
+        }
+        return _data[0];
+    }
+    template <class T>
+    inline const T& Tvector<T>::back() const {
+        if (_size == 0) {
+            throw std::out_of_range("Vector is empty");
+        }
+        return _data[_size - 1];
     }
-    else {
-        T* new_data = new T[_size];
-        State* new_states = new State[_size];
+    template <class T>
+    bool Tvector<T>::operator==(const Tvector<T>& vector) const {
+        if (this->_size != vector._size)
+            return false;
+
         for (size_t i = 0; i < _size; ++i) {
-            new_data[i] = std::move(_data[i]);
-            new_states[i] = _states[i];
+            if ((*this)[i] != vector[i])
+                return false;
+        }
+        return true;
+    }
+    template <class T>
+    bool Tvector<T>::operator!=(const Tvector<T>& vector) const {
+        return !(*this == vector);
+    }
+    template <class T>
+    Tvector<T>& Tvector<T>::operator=(const Tvector<T>& 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 = _size;
-    }
-}
-template <class T>
-void Tvector<T>::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 <class T>
-void Tvector<T>::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 <class T>
-Tvector<T>::Tvector() noexcept {
-    _size = 0;
-    _capacity = 0;
-    _data = nullptr;
-    _states = nullptr;
-    _deleted = 0;
-}
-template <class T>
-Tvector<T>::Tvector(size_t size) {
-    _size = size;
-    _capacity = size + RESERVE_MEMORY;
-    _data = new T[_capacity];
+        _capacity = vector._capacity;
+        _size = vector._size;
+        _deleted = vector._deleted;
 
-    try {
-        _states = new State[_capacity];
-    }
-    catch (const std::bad_alloc&) {
-        delete[] _data;
-        throw;
+        return *this;
     }
-    _deleted = 0;
-
-    for (size_t i = 0; i < _capacity; ++i) {
-        _states[i] = i < _size ? State::busy : State::empty;
-    }
-}
-template <class T>
-Tvector<T>::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];
+    template <class T>
+    inline const T& Tvector<T>::operator[](size_t index) const {
+        size_t real_index = get_real_position(index);
+        return _data[real_index];
     }
-    catch (const std::bad_alloc&) {
-        delete[] _data;
-        throw;
+    template <class T>
+    inline T& Tvector<T>::operator[](size_t index) {
+        size_t real_index = get_real_position(index);
+        return _data[real_index];
     }
-    for (size_t i = 0; i < _capacity; ++i) {
-        if (i < _size) {
-            _data[i] = data[i];
-            _states[i] = State::busy;
+    template <class T>
+    T& Tvector<T>::at(size_t index) {
+        if (index >= _size) {
+            throw std::out_of_range("Index out of range");
         }
-        else {
-            _states[i] = State::empty;
+        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 <class T>
+    const T& Tvector<T>::at(size_t index) const {
+        size_t real_index = get_real_position(index);
+        return const_cast<Tvector*>(this)->at(real_index);
     }
-    _deleted = 0;
-}
-template <class T>
-Tvector<T>::Tvector(const Tvector<T>& other_vector) {
-    _size = other_vector._size;
-    _capacity = other_vector._capacity;
-    _data = nullptr;
-    _states = nullptr;
-    try {
+    template <class T>
+    void Tvector<T>::assign(const Tvector<T>& 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);
     }
-    catch (const std::bad_alloc&) {
-        throw;
+    template <class T>
+    void Tvector<T>::clear() {
+        for (size_t i = 0; i < _size; ++i) {
+            if (_states[i] == State::busy) {
+                _states[i] = State::empty;
+            }
+        }
+        _size = 0;
+        _deleted = 0;
     }
-    try {
-        _states = new State[_capacity];
+    template <class T>
+    void Tvector<T>::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;
     }
-    catch (const std::bad_alloc&) {
-        delete[] _data;
-        throw;
+    template <class T>
+    void Tvector<T>::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 <class T>
+    void Tvector<T>::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 <class T>
+    void Tvector<T>::push_back(const T& value) {
+        if (_size >= _capacity) {
+            reserve(_capacity + RESERVE_MEMORY);
+        }
+        _data[_size] = value;
+        _states[_size] = State::busy;
+        _size++;
+    }
+    template <class T>
+    void Tvector<T>::pop_back() {
+        if (_size == 0) {
+            throw std::out_of_range("Vector has size = 0");
+        }
+        _states[_size - 1] = State::empty;
+        _size--;
     }
-    _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 <class T>
-Tvector<T>::~Tvector() noexcept {
-    delete[] _data;
-    delete[] _states;
-}
-template <class T>
-inline T& Tvector<T>::front() {
-    if (_size == 0) {
-        throw std::out_of_range("Vector is empty");
-    }
-    return _data[0];
-}
-template <class T>
-inline T& Tvector<T>::back() {
-    if (_size == 0) {
-        throw std::out_of_range("Vector is empty");
-    }
-    return _data[_size - 1];
-}
-template <class T>
-inline const T& Tvector<T>::front() const {
-    if (_size == 0) {
-        throw std::out_of_range("Vector is empty");
-    }
-    return _data[0];
-}
-template <class T>
-inline const T& Tvector<T>::back() const {
-    if (_size == 0) {
-        throw std::out_of_range("Vector is empty");
-    }
-    return _data[_size - 1];
-}
-template <class T>
-bool Tvector<T>::operator==(const Tvector<T>& vector) const {
-    if (this->_size != vector._size)
-        return false;
-
-    for (size_t i = 0; i < _size; ++i) {
-        if ((*this)[i] != vector[i])
-            return false;
+    template <class T>
+    void Tvector<T>::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();
+        }
     }
-    return true;
-}
-template <class T>
-bool Tvector<T>::operator!=(const Tvector<T>& vector) const {
-    return !(*this == vector);
-}
-template <class T>
-Tvector<T>& Tvector<T>::operator=(const Tvector<T>& vector) {
-    if (this == &vector) {
-        return *this;
+    template <class T>
+    void Tvector<T>::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;
+            }
+        }
     }
-    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 <class T>
-inline const T& Tvector<T>::operator[](size_t index) const {
-    size_t real_index = get_real_position(index);
-    return _data[real_index];
-}
-template <class T>
-inline T& Tvector<T>::operator[](size_t index) {
-    size_t real_index = get_real_position(index);
-    return _data[real_index];
-}
-template <class T>
-T& Tvector<T>::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 <class T>
-const T& Tvector<T>::at(size_t index) const {
-    size_t real_index = get_real_position(index);
-    return const_cast<Tvector*>(this)->at(real_index);
-}
-template <class T>
-void Tvector<T>::assign(const Tvector<T>& 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 <class T>
-void Tvector<T>::clear() {
-    for (size_t i = 0; i < _size; ++i) {
-        if (_states[i] == State::busy) {
-            _states[i] = State::empty;
+    template<typename U>
+    std::ostream& operator<<(std::ostream& out, const Tvector<U>& vector) {
+        out << "[";
+        bool first = true;
+        for (size_t i = 0; i < vector._size; ++i) {
+            if (vector._states[i] == Tvector<U>::State::busy) {
+                if (!first) out << ", ";
+                out << vector._data[i];
+                first = false;
+            }
         }
+        out << "]";
+        return out;
     }
-    _size = 0;
-    _deleted = 0;
-}
-template <class T>
-void Tvector<T>::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 <class T>
-void Tvector<T>::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 <class T>
-void Tvector<T>::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 <class T>
-void Tvector<T>::push_back(const T& value) {
-    if (_size >= _capacity) {
-        reserve(_capacity + RESERVE_MEMORY);
-    }
-    _data[_size] = value;
-    _states[_size] = State::busy;
-    _size++;
-}
-template <class T>
-void Tvector<T>::pop_back() {
-    if (_size == 0) {
-        throw std::out_of_range("Vector has size = 0");
-    }
-    _states[_size - 1] = State::empty;
-    _size--;
-}
-template <class T>
-void Tvector<T>::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 <class T>
-void Tvector<T>::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();
+    template <class U>
+    void shell_sort(Tvector<U>& 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 <class U>
+    void shuffle(Tvector<U>& 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<size_t> 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<typename U>
-std::ostream& operator<<(std::ostream& out, const Tvector<U>& vector) {
-    out << "[";
-    bool first = true;
-    for (size_t i = 0; i < vector._size; ++i) {
-        if (vector._states[i] == Tvector<U>::State::busy) {
-            if (!first) out << ", ";
-            out << vector._data[i];
-            first = false;
-        }
-    }
-    out << "]";
-    return out;
-}
-template <class U>
-void shell_sort(Tvector<U>& 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;
-                }
+    template <class U>
+    size_t find_first_element(const Tvector<U>& 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 <class U>
+    size_t find_last_element(const Tvector<U>& 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;
             }
         }
-        h /= 3;
-    }
-}
-template <class U>
-void shuffle(Tvector<U>& 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<size_t> 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 <class U>
-size_t find_first_element(const Tvector<U>& 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 <class U>
-size_t find_last_element(const Tvector<U>& 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 <class U>
-size_t find_count_of_all_suitable_elements(const Tvector<U>& 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;
-}
+        return last_pos;
+    }
+    template <class U>
+    size_t find_count_of_all_suitable_elements(const Tvector<U>& 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;
+    }

From 0d800ec19dc1706d6b8428652491cdaaebae33e1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Mon, 6 Oct 2025 22:41:22 +0300
Subject: [PATCH 056/109] =?UTF-8?q?=D0=98=D0=B7=D0=BC=D0=B5=D0=BD=D0=B5?=
 =?UTF-8?q?=D0=BD=D0=B8=D1=8F=20=D0=BA=D0=BB=D0=B0=D1=81=D1=81=D0=B0=20Mat?=
 =?UTF-8?q?hVector=20=D0=B4=D0=BB=D1=8F=20=D1=80=D0=B5=D0=B0=D0=BB=D0=B8?=
 =?UTF-8?q?=D0=B7=D0=B0=D1=86=D0=B8=D0=B8=20=D1=82=D1=80=D0=B5=D1=83=D0=B3?=
 =?UTF-8?q?=D0=BE=D0=BB=D1=8C=D0=BD=D0=BE=D0=B9=20=D0=BC=D0=B0=D1=82=D1=80?=
 =?UTF-8?q?=D0=B8=D1=86=D1=8B:=20=D0=B2=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0?=
 =?UTF-8?q?=D1=82=D0=BE=D1=80=20=3D=20=D0=B4=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=D0=BE=20=D0=BF=D1=80=D0=B8=D1=81=D0=B2=D0=B0=D0=B8?=
 =?UTF-8?q?=D0=B2=D0=B0=D0=BD=D0=B8=D0=B5=20=5Fstart=5Findex,=20=D1=80?=
 =?UTF-8?q?=D0=B5=D0=B0=D0=BB=D0=B8=D0=B7=D0=BE=D0=B2=D0=B0=D0=BD=D1=8B=20?=
 =?UTF-8?q?=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE=D1=80=20[]=20-=20?=
 =?UTF-8?q?=D0=BD=D0=B5=20=D0=B1=D1=80=D0=BE=D1=81=D0=B0=D0=B5=D1=82=20?=
 =?UTF-8?q?=D0=B8=D1=81=D0=BA=D0=BB=D1=8E=D1=87=D0=B5=D0=BD=D0=B8=D0=B9,?=
 =?UTF-8?q?=20=D1=84=D1=83=D0=BD=D0=BA=D1=86=D0=B8=D1=8F=20at()=20-=20?=
 =?UTF-8?q?=D0=B1=D1=80=D0=BE=D1=81=D0=B0=D0=B5=D1=82=20=D0=B8=D1=81=D0=BA?=
 =?UTF-8?q?=D0=BB=D1=8E=D1=87=D0=B5=D0=BD=D0=B8=D1=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_math_vector/math_vector.h | 24 ++++++++++++++++++++++--
 1 file changed, 22 insertions(+), 2 deletions(-)

diff --git a/lib_math_vector/math_vector.h b/lib_math_vector/math_vector.h
index d36d94aa..103425da 100644
--- a/lib_math_vector/math_vector.h
+++ b/lib_math_vector/math_vector.h
@@ -21,6 +21,9 @@ class MathVector:public Tvector<T> {
         _start_index = index; 
     }
 
+    T& at(size_t index);
+    const T& at(size_t index) const;
+
     MathVector<T> operator * (T value) const;
     MathVector<T> operator / (T value) const;
 
@@ -37,7 +40,7 @@ class MathVector:public Tvector<T> {
     friend std::ostream& operator<<(std::ostream& out, const MathVector<T>& vector) {
         out << "[";
         for (size_t i = 0; i < vector.get_size(); ++i) {
-            out << vector[i];
+            out << vector.Tvector<T>::operator[](i); 
             if (i < vector.get_size() - 1) {
                 out << ", ";
             }
@@ -46,6 +49,7 @@ class MathVector:public Tvector<T> {
         return out;
     }
     T& operator[](size_t index);
+    const T& operator[](size_t index) const;
 };
 template<class T>
 MathVector<T>::MathVector() : Tvector<T>() {}
@@ -156,13 +160,29 @@ template <class T>
 MathVector<T>& MathVector<T>::operator=(const MathVector<T>& other) {
     if (this != &other) {
         Tvector<T>::operator=(other);
+        _start_index = other._start_index;
     }
     return *this;
 }
 template <class T>
 T& MathVector<T>::operator[](size_t index) {
+    return Tvector<T>::operator[](index - _start_index);
+}
+template <class T>
+const T& MathVector<T>::operator[](size_t index) const {
+    return Tvector<T>::operator[](index - _start_index);
+}
+template <class T>
+T& MathVector<T>::at(size_t index) {
+    if (index < _start_index || index >= _start_index + this->get_size()) {
+        throw std::logic_error("MathVector index out of range");
+    }
+    return Tvector<T>::operator[](index - _start_index);
+}
+template <class T>
+const T& MathVector<T>::at(size_t index) const {
     if (index < _start_index || index >= _start_index + this->get_size()) {
-        throw std::logic_error("Index out of range");
+        throw std::std::logic_error("MathVector index out of range");
     }
     return Tvector<T>::operator[](index - _start_index);
 }

From 02f0378c3572222f78a06258544dacb3eee24643 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Mon, 6 Oct 2025 22:43:33 +0300
Subject: [PATCH 057/109] =?UTF-8?q?=D0=98=D0=B7=D0=BC=D0=B5=D0=BD=D1=91?=
 =?UTF-8?q?=D0=BD=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE=D1=80=20<<?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_math_vector/math_vector.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib_math_vector/math_vector.h b/lib_math_vector/math_vector.h
index 103425da..c5a3630a 100644
--- a/lib_math_vector/math_vector.h
+++ b/lib_math_vector/math_vector.h
@@ -40,7 +40,7 @@ class MathVector:public Tvector<T> {
     friend std::ostream& operator<<(std::ostream& out, const MathVector<T>& vector) {
         out << "[";
         for (size_t i = 0; i < vector.get_size(); ++i) {
-            out << vector.Tvector<T>::operator[](i); 
+            out << vector[i];
             if (i < vector.get_size() - 1) {
                 out << ", ";
             }

From 5f678fbc057eede8be713683b896ada8d20bbc21 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Mon, 6 Oct 2025 23:07:28 +0300
Subject: [PATCH 058/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=D1=8B=20=D1=82=D0=B5=D1=81=D1=82=D1=8B=20=D0=BD?=
 =?UTF-8?q?=D0=B0=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE=D1=80=20[]?=
 =?UTF-8?q?=20=D0=B8=20at()=20(=D0=B2=20=D1=82=D0=BE=D0=BC=20=D1=87=D0=B8?=
 =?UTF-8?q?=D1=81=D0=BB=D0=B5,=20=D0=BD=D0=B0=20=D1=81=D0=BB=D1=83=D1=87?=
 =?UTF-8?q?=D0=B0=D0=B9=20=D1=81=20=D0=B8=D1=81=D0=BA=D0=BB=D1=8E=D1=87?=
 =?UTF-8?q?=D0=B5=D0=BD=D0=B8=D0=B5=D0=BC)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 tests/test_math_vector.cpp | 27 +++++++++++++++++++++++----
 1 file changed, 23 insertions(+), 4 deletions(-)

diff --git a/tests/test_math_vector.cpp b/tests/test_math_vector.cpp
index c6580006..bff4c8e9 100644
--- a/tests/test_math_vector.cpp
+++ b/tests/test_math_vector.cpp
@@ -312,9 +312,11 @@ TEST(TestMathVectorLib, mathvector_operator_square_brackets) {
     //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_operator_square_brackets_with_exception) {
+TEST(TestMathVectorLib, mathvector_at) {
     // Arrange
     size_t size = 5;
     size_t start_index = 2;
@@ -325,7 +327,24 @@ TEST(TestMathVectorLib, mathvector_operator_square_brackets_with_exception) {
     vector1[5] = 6;
     vector1[6] = 7;
     //Act & Assert
-    EXPECT_THROW(vector1[0], std::logic_error);
-    EXPECT_THROW(vector1[1], std::logic_error);
-    EXPECT_THROW(vector1[7], std::logic_error);
+    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<int> 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);
 }

From eb7bca6b1980ddcf0f8668e689649b3a0fce5162 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Mon, 6 Oct 2025 23:10:13 +0300
Subject: [PATCH 059/109] =?UTF-8?q?=D0=9D=D0=B5=D0=B1=D0=BE=D0=BB=D1=8C?=
 =?UTF-8?q?=D1=88=D0=B8=D0=B5=20=D0=BF=D1=80=D0=B0=D0=B2=D0=BA=D0=B8?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 tests/test_vector.cpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/tests/test_vector.cpp b/tests/test_vector.cpp
index ad786875..a2c39fb7 100644
--- a/tests/test_vector.cpp
+++ b/tests/test_vector.cpp
@@ -1,6 +1,7 @@
 // Copyright 2025 Julia Zabytina
 #include <gtest/gtest.h>
 #include "../lib_vector/vector.h"
+/*
 TEST(TestVectorLib, vector_default_constructor) {
     // Arrange & Act
     Tvector<int> vector;
@@ -517,3 +518,5 @@ TEST(TestVectorLib, find_count_of_suitable_elements) {
     size_t expected_result = 4;
     EXPECT_EQ(expected_result, actual_result);
 }
+
+*/

From 21c4b06c48efff4efe28605835495930a4fa948c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Mon, 6 Oct 2025 23:13:05 +0300
Subject: [PATCH 060/109] =?UTF-8?q?=D0=98=D0=B7=D0=BC=D0=B5=D0=BD=D1=91?=
 =?UTF-8?q?=D0=BD=20=D1=82=D0=B5=D1=81=D1=82=20find=5Fcount=5Fof=5Fsuitabl?=
 =?UTF-8?q?e=5Felements?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 tests/test_vector.cpp | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/tests/test_vector.cpp b/tests/test_vector.cpp
index a2c39fb7..e003e79e 100644
--- a/tests/test_vector.cpp
+++ b/tests/test_vector.cpp
@@ -1,7 +1,6 @@
 // Copyright 2025 Julia Zabytina
 #include <gtest/gtest.h>
 #include "../lib_vector/vector.h"
-/*
 TEST(TestVectorLib, vector_default_constructor) {
     // Arrange & Act
     Tvector<int> vector;
@@ -509,8 +508,8 @@ TEST(TestVectorLib, find_last) {
 }
 TEST(TestVectorLib, find_count_of_suitable_elements) {
     // Arrange
-    int data[7] = { 1 ,3, 3, 4, 5, 3, 3 };
-    size_t size = 7;
+    int data[8] = { 1 ,3, 3, 4, 5, 3, 3, 7 };
+    size_t size = 8;
     Tvector<int> vector(data, size);
     // Act
     size_t actual_result = find_count_of_all_suitable_elements(vector, 3);
@@ -518,5 +517,3 @@ TEST(TestVectorLib, find_count_of_suitable_elements) {
     size_t expected_result = 4;
     EXPECT_EQ(expected_result, actual_result);
 }
-
-*/

From 15e7707d8a7953ba6565452356dc262b9fb50250 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Mon, 6 Oct 2025 23:31:31 +0300
Subject: [PATCH 061/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=D1=8B=20=D1=82=D0=B5=D1=81=D1=82=D1=8B=20=D0=BD?=
 =?UTF-8?q?=D0=B0=20=D0=BA=D0=BE=D0=BD=D1=81=D1=82=D1=80=D1=83=D0=BA=D1=82?=
 =?UTF-8?q?=D0=BE=D1=80=20=D0=BA=D0=BE=D0=BF=D0=B8=D1=80=D0=BE=D0=B2=D0=B0?=
 =?UTF-8?q?=D0=BD=D0=B8=D1=8F=20=D0=B8=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0?=
 =?UTF-8?q?=D1=82=D0=BE=D1=80=20=D0=BF=D1=80=D0=B8=D1=81=D0=B2=D0=B0=D0=B8?=
 =?UTF-8?q?=D0=B2=D0=B0=D0=BD=D0=B8=D1=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 tests/test_triangle_matrix.cpp | 43 ++++++++++++++++++++++------------
 1 file changed, 28 insertions(+), 15 deletions(-)

diff --git a/tests/test_triangle_matrix.cpp b/tests/test_triangle_matrix.cpp
index 3999ba4a..7eff65c7 100644
--- a/tests/test_triangle_matrix.cpp
+++ b/tests/test_triangle_matrix.cpp
@@ -16,26 +16,39 @@ TEST(TestTriangleMatrixLib, tr_matrix_constructor_with_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<int> matrix(data, size);
-
     // Assert
     EXPECT_EQ(size, matrix.getSize());
-
-    EXPECT_EQ(matrix[0][0], 1);
-    EXPECT_EQ(matrix[0][1], 2);
-    EXPECT_EQ(matrix[0][2], 3);
-    EXPECT_EQ(matrix[1][1], 4);
-    EXPECT_EQ(matrix[1][2], 5);
-    EXPECT_EQ(matrix[2][2], 6);
-
-    EXPECT_THROW(matrix[1][0], std::logic_error);
-    EXPECT_THROW(matrix[2][0], std::logic_error);
-    EXPECT_THROW(matrix[2][1], std::logic_error);
+    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<int> matrix1(data, size);
+    TriangleMatrix<int> 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<int> matrix1(data, size);
+    TriangleMatrix<int> matrix2;
+    matrix2 = matrix1;
+    // Assert
+    EXPECT_EQ(matrix1, matrix2);
 }
-
-

From 8d943a0b17f10386173ba728ff88fb4ecd79ca5b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Mon, 6 Oct 2025 23:48:20 +0300
Subject: [PATCH 062/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=D1=8B=20=D1=82=D0=B5=D1=81=D1=82=D1=8B=20=D0=BD?=
 =?UTF-8?q?=D0=B0=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE=D1=80=D1=8B?=
 =?UTF-8?q?=20+,-,*,/,=20+=3D,=20-=3D,=20*=3D,=20/=3D=20=D1=81=20=D1=82?=
 =?UTF-8?q?=D1=80=D0=B5=D1=83=D0=B3=D0=BE=D0=BB=D1=8C=D0=BD=D0=BE=D0=B9=20?=
 =?UTF-8?q?=D0=BC=D0=B0=D1=82=D1=80=D0=B8=D1=86=D0=B5=D0=B9=20=D0=B8=20?=
 =?UTF-8?q?=D1=81=D0=BA=D0=B0=D0=BB=D1=8F=D1=80=D0=BE=D0=BC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 tests/test_triangle_matrix.cpp | 137 +++++++++++++++++++++++++++++++++
 1 file changed, 137 insertions(+)

diff --git a/tests/test_triangle_matrix.cpp b/tests/test_triangle_matrix.cpp
index 7eff65c7..0845af87 100644
--- a/tests/test_triangle_matrix.cpp
+++ b/tests/test_triangle_matrix.cpp
@@ -52,3 +52,140 @@ TEST(TestTriangleMatrixLib, tr_matrix_operator_assignment) {
     // Assert
     EXPECT_EQ(matrix1, matrix2);
 }
+TEST(TestTriangleMatrixLib, tr_matrix_add_value) {
+    // Arrange
+    size_t size = 3;
+    int data[6] = { 1, 2, 3, 4, 5, 6 };
+    size_t value = 10;
+    TriangleMatrix<int> matrix(data, size);
+    TriangleMatrix<int> result(size);
+    //Act
+    result = matrix + value;
+    // Assert
+    EXPECT_EQ(result.at(0).at(0), 11);
+    EXPECT_EQ(result.at(0).at(1), 12);
+    EXPECT_EQ(result.at(0).at(2), 13);
+    EXPECT_EQ(result.at(1).at(1), 14);
+    EXPECT_EQ(result.at(1).at(2), 15);
+    EXPECT_EQ(result.at(2).at(2), 16);
+}
+TEST(TestTriangleMatrixLib, tr_matrix_sub_value) {
+    // Arrange
+    size_t size = 3;
+    int data[6] = { 1, 2, 3, 4, 5, 6 };
+    size_t value = 1;
+    TriangleMatrix<int> matrix(data, size);
+    TriangleMatrix<int> result(size);
+    //Act
+    result = matrix - value;
+    // Assert
+    EXPECT_EQ(result.at(0).at(0), 0);
+    EXPECT_EQ(result.at(0).at(1), 1);
+    EXPECT_EQ(result.at(0).at(2), 2);
+    EXPECT_EQ(result.at(1).at(1), 3);
+    EXPECT_EQ(result.at(1).at(2), 4);
+    EXPECT_EQ(result.at(2).at(2), 5);
+}
+TEST(TestTriangleMatrixLib, tr_matrix_mult_value) {
+    // Arrange
+    size_t size = 3;
+    int data[6] = { 1, 2, 3, 4, 5, 6 };
+    size_t value = 10;
+    TriangleMatrix<int> matrix(data, size);
+    TriangleMatrix<int> 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 };
+    size_t value = 2;
+    TriangleMatrix<int> matrix(data, size);
+    TriangleMatrix<int> 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<int> matrix(data, size);
+    // Assert
+    EXPECT_THROW(matrix / value, std::logic_error);
+}
+TEST(TestTriangleMatrixLib, tr_matrix_add_assign_value) {
+    // Arrange & Act
+    size_t size = 3;
+    int data[6] = { 2, 2, 4, 4, 8, 6 };
+    size_t value = 2;
+    TriangleMatrix<int> matrix(data, size);
+    matrix += value;
+    // Assert
+    EXPECT_EQ(matrix.at(0).at(0), 4);
+    EXPECT_EQ(matrix.at(0).at(1), 4);
+    EXPECT_EQ(matrix.at(0).at(2), 6);
+    EXPECT_EQ(matrix.at(1).at(1), 6);
+    EXPECT_EQ(matrix.at(1).at(2), 10);
+    EXPECT_EQ(matrix.at(2).at(2), 8);
+}
+TEST(TestTriangleMatrixLib, tr_matrix_sub_assign_value) {
+    // Arrange & Act
+    size_t size = 3;
+    int data[6] = { 2, 2, 4, 4, 8, 6 };
+    size_t value = 2;
+    TriangleMatrix<int> matrix(data, size);
+    matrix -= value;
+    // Assert
+    EXPECT_EQ(matrix.at(0).at(0), 0);
+    EXPECT_EQ(matrix.at(0).at(1), 0);
+    EXPECT_EQ(matrix.at(0).at(2), 2);
+    EXPECT_EQ(matrix.at(1).at(1), 2);
+    EXPECT_EQ(matrix.at(1).at(2), 6);
+    EXPECT_EQ(matrix.at(2).at(2), 4);
+}
+TEST(TestTriangleMatrixLib, tr_matrix_mult_assign_value) {
+    // Arrange & Act
+    size_t size = 3;
+    int data[6] = { 1, 2, 3, 4, 5, 6 };
+    size_t value = 10;
+    TriangleMatrix<int> 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 };
+    size_t value = 2;
+    TriangleMatrix<int> 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);
+}

From f6170cc8c06dc78a1ab3b3a21c95d610ce1433b5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Mon, 6 Oct 2025 23:52:20 +0300
Subject: [PATCH 063/109] =?UTF-8?q?=D0=94=D0=BE=D1=80=D0=B0=D0=B1=D0=BE?=
 =?UTF-8?q?=D1=82=D0=B0=D0=BD=D1=8B=20=D0=BA=D0=BE=D0=BD=D1=81=D1=82=D1=80?=
 =?UTF-8?q?=D1=83=D0=BA=D1=82=D0=BE=D1=80=D1=8B?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_triangle_matrix/triangle_matrix.h | 19 ++++++++++++++++---
 1 file changed, 16 insertions(+), 3 deletions(-)

diff --git a/lib_triangle_matrix/triangle_matrix.h b/lib_triangle_matrix/triangle_matrix.h
index 99228672..304a2067 100644
--- a/lib_triangle_matrix/triangle_matrix.h
+++ b/lib_triangle_matrix/triangle_matrix.h
@@ -10,6 +10,7 @@ class TriangleMatrix : public Matrix<T> {
     TriangleMatrix(const TriangleMatrix& other);
     ~TriangleMatrix();
 
+
     size_t getSize() const {
         return this->_M;
     }
@@ -57,9 +58,21 @@ TriangleMatrix<T>::TriangleMatrix(size_t size) : Matrix<T>(size, size) {
         (*this)[i] = MathVector<T>(size - i, i);
     }
 }
-//template<class T>
-//TriangleMatrix<T>::TriangleMatrix(T* data, size_t size) : Matrix<T>(size, size) { 
-//}
+template<class T>
+TriangleMatrix<T>::TriangleMatrix(T* data, size_t size) : Matrix<T>(size, size) {
+    if (size > 0 && data == nullptr) {
+        throw std::invalid_argument("Null data pointer with non-zero size");
+    }
+    size_t data_index = 0;
+    for (size_t i = 0; i < size; ++i) {
+        // Создаем MathVector для строки i
+        (*this)[i] = MathVector<T>(size - i, i);
+        // Заполняем элементы от i до size-1
+        for (size_t j = i; j < size; ++j) {
+            (*this)[i][j] = data[data_index++];
+        }
+    }
+}
 template<class T>
 TriangleMatrix<T>::TriangleMatrix(const TriangleMatrix& other) : Matrix<T>(other) {}
 template<class T>

From 6fa8ee3581edbada3428aad22c363f00aeffd510 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Tue, 7 Oct 2025 00:11:40 +0300
Subject: [PATCH 064/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=D1=8B=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE?=
 =?UTF-8?q?=D1=80=D1=8B=20*=20=D0=B4=D0=BB=D1=8F=20=D0=BC=D0=B0=D1=82?=
 =?UTF-8?q?=D1=80=D0=B8=D1=86=D1=8B=20=D0=B8=20=D0=B2=D0=B5=D0=BA=D1=82?=
 =?UTF-8?q?=D0=BE=D1=80=D0=B0,=20+,=20-,=20+=3D,=20-=3D=20=D0=B4=D0=BB?=
 =?UTF-8?q?=D1=8F=20=D0=B4=D0=B2=D1=83=D1=85=20=D0=BC=D0=B0=D1=82=D1=80?=
 =?UTF-8?q?=D0=B8=D1=86?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_triangle_matrix/triangle_matrix.h | 66 +++++++++++++++++++++++++--
 1 file changed, 61 insertions(+), 5 deletions(-)

diff --git a/lib_triangle_matrix/triangle_matrix.h b/lib_triangle_matrix/triangle_matrix.h
index 304a2067..c4f1caa7 100644
--- a/lib_triangle_matrix/triangle_matrix.h
+++ b/lib_triangle_matrix/triangle_matrix.h
@@ -60,14 +60,9 @@ TriangleMatrix<T>::TriangleMatrix(size_t size) : Matrix<T>(size, size) {
 }
 template<class T>
 TriangleMatrix<T>::TriangleMatrix(T* data, size_t size) : Matrix<T>(size, size) {
-    if (size > 0 && data == nullptr) {
-        throw std::invalid_argument("Null data pointer with non-zero size");
-    }
     size_t data_index = 0;
     for (size_t i = 0; i < size; ++i) {
-        // Создаем MathVector для строки i
         (*this)[i] = MathVector<T>(size - i, i);
-        // Заполняем элементы от i до size-1
         for (size_t j = i; j < size; ++j) {
             (*this)[i][j] = data[data_index++];
         }
@@ -166,3 +161,64 @@ TriangleMatrix<T>& TriangleMatrix<T>::operator /= (T value) {
     }
     return *this;
 }
+template<class T>
+MathVector<T> TriangleMatrix<T>::operator * (const MathVector<T>& vector) const {
+    if (this->getSize() != vector.getSize()()) {
+        throw std::logic_error("Matrix columns must equal vector size");
+    }
+    MathVector<T> result(this->getSize());
+    for (size_t i = 0; i < this->getSize(); ++i) {
+        result[i] = (*this)[i] * vector;
+    }
+    return result;
+}
+template<class T>
+TriangleMatrix<T> TriangleMatrix<T>::operator + (const TriangleMatrix<T>& other) const {
+    if (this->getSize() != other.getSize()()) {
+        throw std::logic_error("Matrices must have the same size");
+    }
+    TriangleMatrix<T> 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<class T>
+TriangleMatrix<T> TriangleMatrix<T>::operator - (const TriangleMatrix<T>& other) const {
+    if (this->getSize() != other.getSize()()) {
+        throw std::logic_error("Matrices must have the same size");
+    }
+    TriangleMatrix<T> 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<class T>
+TriangleMatrix<T>& TriangleMatrix<T>::operator += (const TriangleMatrix<T>& 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<class T>
+TriangleMatrix<T>& TriangleMatrix<T>::operator -= (const TriangleMatrix<T>& 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;
+}

From fd581a3432d5a511e704b48c57f4e37f3460e2e0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Tue, 7 Oct 2025 00:15:46 +0300
Subject: [PATCH 065/109] =?UTF-8?q?=D0=98=D1=81=D0=BF=D1=80=D0=B0=D0=B2?=
 =?UTF-8?q?=D0=BB=D0=B5=D0=BD=D1=8B=20=D0=BE=D1=88=D0=B8=D0=B1=D0=BA=D0=B8?=
 =?UTF-8?q?=20=D1=81=D0=B8=D0=BD=D1=82=D0=B0=D0=BA=D1=81=D0=B8=D1=81=D0=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_triangle_matrix/triangle_matrix.h | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/lib_triangle_matrix/triangle_matrix.h b/lib_triangle_matrix/triangle_matrix.h
index c4f1caa7..db72ee1a 100644
--- a/lib_triangle_matrix/triangle_matrix.h
+++ b/lib_triangle_matrix/triangle_matrix.h
@@ -161,9 +161,10 @@ TriangleMatrix<T>& TriangleMatrix<T>::operator /= (T value) {
     }
     return *this;
 }
+
 template<class T>
 MathVector<T> TriangleMatrix<T>::operator * (const MathVector<T>& vector) const {
-    if (this->getSize() != vector.getSize()()) {
+    if (this->getSize() != vector.get_size() ) {
         throw std::logic_error("Matrix columns must equal vector size");
     }
     MathVector<T> result(this->getSize());
@@ -174,7 +175,7 @@ MathVector<T> TriangleMatrix<T>::operator * (const MathVector<T>& vector) const
 }
 template<class T>
 TriangleMatrix<T> TriangleMatrix<T>::operator + (const TriangleMatrix<T>& other) const {
-    if (this->getSize() != other.getSize()()) {
+    if (this->getSize() != other.getSize()) {
         throw std::logic_error("Matrices must have the same size");
     }
     TriangleMatrix<T> result(this->getSize());
@@ -187,7 +188,7 @@ TriangleMatrix<T> TriangleMatrix<T>::operator + (const TriangleMatrix<T>& other)
 }
 template<class T>
 TriangleMatrix<T> TriangleMatrix<T>::operator - (const TriangleMatrix<T>& other) const {
-    if (this->getSize() != other.getSize()()) {
+    if (this->getSize() != other.getSize()) {
         throw std::logic_error("Matrices must have the same size");
     }
     TriangleMatrix<T> result(this->getSize());
@@ -200,7 +201,7 @@ TriangleMatrix<T> TriangleMatrix<T>::operator - (const TriangleMatrix<T>& other)
 }
 template<class T>
 TriangleMatrix<T>& TriangleMatrix<T>::operator += (const TriangleMatrix<T>& other) {
-    if (this->getSize() != other.getSize()()) {
+    if (this->getSize() != other.getSize()) {
         throw std::logic_error("Matrices must have the same size");
     }
     for (size_t i = 0; i < this->getSize(); ++i) {
@@ -212,7 +213,7 @@ TriangleMatrix<T>& TriangleMatrix<T>::operator += (const TriangleMatrix<T>& othe
 }
 template<class T>
 TriangleMatrix<T>& TriangleMatrix<T>::operator -= (const TriangleMatrix<T>& other) {
-    if (this->getSize() != other.getSize()()) {
+    if (this->getSize() != other.getSize()) {
         throw std::logic_error("Matrices must have the same size");
     }
     for (size_t i = 0; i < this->getSize(); ++i) {

From 23ff54a82dae65b077493d3d2027001ddcf6d00e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Tue, 7 Oct 2025 00:25:15 +0300
Subject: [PATCH 066/109] =?UTF-8?q?=D0=94=D0=BE=D1=80=D0=B0=D0=B1=D0=BE?=
 =?UTF-8?q?=D1=82=D0=B0=D0=BD=20main=20=D1=81=20=D0=BA=D0=B0=D0=BB=D1=8C?=
 =?UTF-8?q?=D0=BA=D1=83=D0=BB=D1=8F=D1=82=D0=BE=D1=80=D0=BE=D0=BC=20-=20?=
 =?UTF-8?q?=D1=84=D1=83=D0=BD=D0=BA=D1=86=D0=B8=D0=B8=20=D0=B7=D0=B0=D0=BF?=
 =?UTF-8?q?=D0=BE=D0=BB=D0=BD=D0=B5=D0=BD=D0=B8=D1=8F=20=D0=BC=D0=B0=D1=82?=
 =?UTF-8?q?=D1=80=D0=B8=D1=86=20=D0=B8=20=D0=B2=D0=B5=D0=BA=D1=82=D0=BE?=
 =?UTF-8?q?=D1=80=D0=B0,=20=D0=B4=D0=BE=D1=80=D0=B0=D0=B1=D0=BE=D1=82?=
 =?UTF-8?q?=D0=B0=D0=BD=20switch,=20=D1=83=D0=B1=D1=80=D0=B0=D0=BD=D1=8B?=
 =?UTF-8?q?=20=D0=B7=D0=B0=D0=B3=D0=BB=D1=83=D1=88=D0=BA=D0=B8=20=D0=BD?=
 =?UTF-8?q?=D0=B0=20=D0=B2=D0=B2=D0=BE=D0=B4=D0=B5=20=D0=BC=D0=B0=D1=82?=
 =?UTF-8?q?=D1=80=D0=B8=D1=86?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 main/main.cpp | 347 ++++++++++++++++++++++++++++++++++----------------
 1 file changed, 236 insertions(+), 111 deletions(-)

diff --git a/main/main.cpp b/main/main.cpp
index bc6d33d8..3e651e30 100644
--- a/main/main.cpp
+++ b/main/main.cpp
@@ -147,144 +147,269 @@ void printMainMenu() {
     std::cout << " 9. Exit\n";
 }
 
+template<typename T>
+void fillMatrix(Matrix<T>& 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<typename T>
+void fillTriangleMatrix(TriangleMatrix<T>& 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<typename T>
+void fillVector(MathVector<T>& 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 == 11) {
+        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;
 
-        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<int> matrix1(M, N);
-
-        std::cout << "Enter elements of matrix 1:\n";
-        system("pause");
+        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;
 
-        switch (user_choice) {
-        case 1: {
-            size_t K, L;
-            std::cout << "Enter dimensions of matrix 2 (K - rows, L - columns)\n";
-            std::cout << "K = ";
-            std::cin >> K;
-            std::cout << "L = ";
-            std::cin >> L;
-            Matrix<int> matrix2(K, L);
+            Matrix<int> matrix1(M, N);
+            std::cout << "Enter elements of matrix 1:\n";
+            fillMatrix(matrix1);
 
-            std::cout << "Enter elements of matrix 2:\n";
-            system("pause");
-            Matrix<int> result = matrix1 + matrix2;
-            std::cout << "Result:\n" << result;
-            break;
+            switch (user_choice) {
+            case 1: {
+                std::cout << "Enter dimensions of matrix 2 (must be " << M << " x " << N << ")\n";
+                Matrix<int> matrix2(M, N);
+                std::cout << "Enter elements of matrix 2:\n";
+                fillMatrix(matrix2);
+                Matrix<int> 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<int> matrix2(M, N);
+                std::cout << "Enter elements of matrix 2:\n";
+                fillMatrix(matrix2);
+                Matrix<int> 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<int> matrix2(N, K);
+                std::cout << "Enter elements of matrix 2:\n";
+                fillMatrix(matrix2);
+                Matrix<int> result = matrix1 * matrix2;
+                std::cout << "Result:\n" << result;
+                break;
+            }
+            case 4: {
+                int scalar;
+                std::cout << "Enter scalar: ";
+                std::cin >> scalar;
+                Matrix<int> result = matrix1 + scalar;
+                std::cout << "Result:\n" << result;
+                break;
+            }
+            case 5: {
+                int scalar;
+                std::cout << "Enter scalar: ";
+                std::cin >> scalar;
+                Matrix<int> result = matrix1 - scalar;
+                std::cout << "Result:\n" << result;
+                break;
+            }
+            case 6: {
+                int scalar;
+                std::cout << "Enter scalar: ";
+                std::cin >> scalar;
+                Matrix<int> result = matrix1 * scalar;
+                std::cout << "Result:\n" << result;
+                break;
+            }
+            case 7: {
+                int scalar;
+                std::cout << "Enter scalar: ";
+                std::cin >> scalar;
+                try {
+                    Matrix<int> result = matrix1 / scalar;
+                    std::cout << "Result:\n" << result;
+                }
+                catch (const std::exception& e) {
+                    std::cout << "Error: " << e.what() << std::endl;
+                }
+                break;
+            }
+            case 8: {
+                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<int> mathvector(size);
+                std::cout << "Enter vector elements:\n";
+                fillVector(mathvector);
+                try {
+                    MathVector<int> 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;
+            }
+            }
         }
-        case 2: {
-            size_t K, L;
-            std::cout << "Enter dimensions of matrix 2 (K - rows, L - columns)\n";
-            std::cout << "K = ";
-            std::cin >> K;
-            std::cout << "L = ";
-            std::cin >> L;
-            Matrix<int> matrix2(K, L);
-
-            std::cout << "Enter elements of matrix 2:\n";
-            system("pause");
-            Matrix<int> result = matrix1 - matrix2;
-            std::cout << "Result:\n" << result;
-            break;
-        }
-        case 3: {
-            size_t K, L;
-            std::cout << "Enter dimensions of matrix 2 (K - rows, L - columns)\n";
-            std::cout << "K = ";
-            std::cin >> K;
-            std::cout << "L = ";
-            std::cin >> L;
-            Matrix<int> matrix2(K, L);
-
-            std::cout << "Enter elements of matrix 2:\n";
-            system("pause");
-            Matrix<int> result = matrix1 * matrix2;
-            std::cout << "Result:\n" << result;
-            break;
-        }
-        case 4: {
-            int scalar;
-            std::cout << "Enter scalar:\n";
-            std::cin >> scalar;
-            system("pause");
-            Matrix<int> result = matrix1 + scalar;
-            std::cout << "Result:\n" << result;
-            break;
-        }
-        case 5: {
-            int scalar;
-            std::cout << "Enter scalar:\n";
-            std::cin >> scalar;
-            system("pause");
-            Matrix<int> result = matrix1 - scalar;
-            std::cout << "Result:\n" << result;
-            break;
-        }
-        case 6: {
-            int scalar;
-            std::cout << "Enter scalar:\n";
-            std::cin >> scalar;
-            system("pause");
-            Matrix<int> result = matrix1 * scalar;
-            std::cout << "Result:\n" << result;
-            break;
-        }
-        case 7: {
-            int scalar;
-            std::cout << "Enter scalar:\n";
-            std::cin >> scalar;
-            system("pause");
-            Matrix<int> result = matrix1 / scalar;
-            std::cout << "Result:\n" << result;
-            break;
-        }
-        case 8: {
+        else if (matrix_type == 2) {
+            // Triangular Matrix operations
             size_t size;
-            std::cout << "Enter vector size:\n";
+            std::cout << "Enter size of triangular matrix: ";
             std::cin >> size;
-            MathVector<int> mathvector(size);
 
-            std::cout << "Enter vector elements:\n";
-            system("pause");
-            MathVector<int> result = matrix1 * mathvector;
-            std::cout << "Result:\n" << result;
-            break;
-        }
-        case 9: {
+            TriangleMatrix<int> matrix1(size);
+            std::cout << "Enter elements of triangular matrix (only upper triangle):\n";
+            fillTriangleMatrix(matrix1);
 
-            break;
-        }
-        default: {
-            std::cout << "Invalid input! Please try again\n";
-            break;
+            switch (user_choice) {
+            case 1: {
+                TriangleMatrix<int> matrix2(size);
+                std::cout << "Enter elements of second triangular matrix:\n";
+                fillTriangleMatrix(matrix2);
+                try {
+                    TriangleMatrix<int> result = matrix1 + matrix2;
+                    std::cout << "Result:\n" << result;
+                }
+                catch (const std::exception& e) {
+                    std::cout << "Error: " << e.what() << std::endl;
+                }
+                break;
+            }
+            case 2: {
+                TriangleMatrix<int> matrix2(size);
+                std::cout << "Enter elements of second triangular matrix:\n";
+                fillTriangleMatrix(matrix2);
+                try {
+                    TriangleMatrix<int> 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<int> result = matrix1 + scalar;
+                std::cout << "Result:\n" << result;
+                break;
+            }
+            case 5: {
+                int scalar;
+                std::cout << "Enter scalar: ";
+                std::cin >> scalar;
+                TriangleMatrix<int> result = matrix1 - scalar;
+                std::cout << "Result:\n" << result;
+                break;
+            }
+            case 6: {
+                int scalar;
+                std::cout << "Enter scalar: ";
+                std::cin >> scalar;
+                TriangleMatrix<int> result = matrix1 * scalar;
+                std::cout << "Result:\n" << result;
+                break;
+            }
+            case 7: {
+                int scalar;
+                std::cout << "Enter scalar: ";
+                std::cin >> scalar;
+                try {
+                    TriangleMatrix<int> result = matrix1 / scalar;
+                    std::cout << "Result:\n" << result;
+                }
+                catch (const std::exception& e) {
+                    std::cout << "Error: " << e.what() << std::endl;
+                }
+                break;
+            }
+            case 8: {
+                MathVector<int> mathvector(size);
+                std::cout << "Enter vector elements:\n";
+                fillVector(mathvector);
+                try {
+                    MathVector<int> 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 << "\n Press Enter to continue...";
+        std::cout << "\nPress Enter to continue...";
         std::cin.ignore();
         std::cin.get();
-    } while (true);
+        system("cls");
 
+    } while (true);
     return 0;
 }
 #endif
-

From f16c315e954f6fdb4c97dcb8583b839b99d61bb8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Tue, 7 Oct 2025 00:50:58 +0300
Subject: [PATCH 067/109] =?UTF-8?q?=D0=9F=D0=B5=D1=80=D0=B5=D0=BF=D0=B8?=
 =?UTF-8?q?=D1=81=D0=B0=D0=BD=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE?=
 =?UTF-8?q?=D1=80=20=D0=B4=D0=BB=D1=8F=20=D0=BC=D0=B0=D1=82=D1=80=D0=B8?=
 =?UTF-8?q?=D1=86=D1=8B=20=D0=B8=20=D0=B2=D0=B5=D0=BA=D1=82=D0=BE=D1=80?=
 =?UTF-8?q?=D0=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_triangle_matrix/triangle_matrix.h | 23 +++++++++++++++++++++--
 1 file changed, 21 insertions(+), 2 deletions(-)

diff --git a/lib_triangle_matrix/triangle_matrix.h b/lib_triangle_matrix/triangle_matrix.h
index db72ee1a..c0568ec0 100644
--- a/lib_triangle_matrix/triangle_matrix.h
+++ b/lib_triangle_matrix/triangle_matrix.h
@@ -164,13 +164,24 @@ TriangleMatrix<T>& TriangleMatrix<T>::operator /= (T value) {
 
 template<class T>
 MathVector<T> TriangleMatrix<T>::operator * (const MathVector<T>& vector) const {
-    if (this->getSize() != vector.get_size() ) {
+    if (this->getSize() != vector.get_size()) {
         throw std::logic_error("Matrix columns must equal vector size");
     }
+
     MathVector<T> result(this->getSize());
+
     for (size_t i = 0; i < this->getSize(); ++i) {
-        result[i] = (*this)[i] * vector;
+        T sum = T(); // Инициализируем нулем типа T
+
+        // Ручное вычисление скалярного произведения
+        // Для треугольной матрицы: элементы ниже диагонали = 0
+        for (size_t j = i; j < this->getSize(); ++j) {
+            sum += (*this)[i][j] * vector[j];
+        }
+
+        result[i] = sum;
     }
+
     return result;
 }
 template<class T>
@@ -223,3 +234,11 @@ TriangleMatrix<T>& TriangleMatrix<T>::operator -= (const TriangleMatrix<T>& othe
     }
     return *this;
 }
+template<class T>
+TriangleMatrix<T> TriangleMatrix<T>::operator * (const TriangleMatrix<T>& other) const {
+    if (this->getSize() != other.getSize()) {
+        throw std::logic_error("Matrices must have the same size");
+    }
+    TriangleMatrix<T> result(this->getSize());
+
+}

From ac1d6ecd7d53cf03b5a674668183e1eb32884c83 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Tue, 7 Oct 2025 00:52:18 +0300
Subject: [PATCH 068/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=D1=8B=20=D1=82=D0=B5=D1=81=D1=82=D1=8B=20=D0=BD?=
 =?UTF-8?q?=D0=B0=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE=D1=80=D1=8B?=
 =?UTF-8?q?=20+,=20-,=20+=3D,=20-=3D,=20*=20=D0=B2=D0=BA=D0=BB=D1=8E=D1=87?=
 =?UTF-8?q?=D0=B0=D1=8F=20=D1=81=D0=BB=D1=83=D1=87=D0=B0=D0=B8=20=D1=81=20?=
 =?UTF-8?q?=D0=B8=D1=81=D0=BA=D0=BB=D1=8E=D1=87=D0=B5=D0=BD=D0=B8=D1=8F?=
 =?UTF-8?q?=D0=BC=D0=B8?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 tests/test_triangle_matrix.cpp | 163 +++++++++++++++++++++++++++++++--
 1 file changed, 154 insertions(+), 9 deletions(-)

diff --git a/tests/test_triangle_matrix.cpp b/tests/test_triangle_matrix.cpp
index 0845af87..f650a943 100644
--- a/tests/test_triangle_matrix.cpp
+++ b/tests/test_triangle_matrix.cpp
@@ -56,7 +56,7 @@ TEST(TestTriangleMatrixLib, tr_matrix_add_value) {
     // Arrange
     size_t size = 3;
     int data[6] = { 1, 2, 3, 4, 5, 6 };
-    size_t value = 10;
+    int value = 10;
     TriangleMatrix<int> matrix(data, size);
     TriangleMatrix<int> result(size);
     //Act
@@ -73,7 +73,7 @@ TEST(TestTriangleMatrixLib, tr_matrix_sub_value) {
     // Arrange
     size_t size = 3;
     int data[6] = { 1, 2, 3, 4, 5, 6 };
-    size_t value = 1;
+    int value = 1;
     TriangleMatrix<int> matrix(data, size);
     TriangleMatrix<int> result(size);
     //Act
@@ -90,7 +90,7 @@ TEST(TestTriangleMatrixLib, tr_matrix_mult_value) {
     // Arrange
     size_t size = 3;
     int data[6] = { 1, 2, 3, 4, 5, 6 };
-    size_t value = 10;
+    int value = 10;
     TriangleMatrix<int> matrix(data, size);
     TriangleMatrix<int> result(size);
     //Act
@@ -107,7 +107,7 @@ TEST(TestTriangleMatrixLib, tr_matrix_div_value) {
     // Arrange
     size_t size = 3;
     int data[6] = { 2, 2, 4, 4, 8, 6 };
-    size_t value = 2;
+    int value = 2;
     TriangleMatrix<int> matrix(data, size);
     TriangleMatrix<int> result(size);
     //Act
@@ -131,9 +131,9 @@ TEST(TestTriangleMatrixLib, tr_matrix_div_value_with_exception) {
 }
 TEST(TestTriangleMatrixLib, tr_matrix_add_assign_value) {
     // Arrange & Act
-    size_t size = 3;
+    int size = 3;
     int data[6] = { 2, 2, 4, 4, 8, 6 };
-    size_t value = 2;
+    int value = 2;
     TriangleMatrix<int> matrix(data, size);
     matrix += value;
     // Assert
@@ -148,7 +148,7 @@ TEST(TestTriangleMatrixLib, tr_matrix_sub_assign_value) {
     // Arrange & Act
     size_t size = 3;
     int data[6] = { 2, 2, 4, 4, 8, 6 };
-    size_t value = 2;
+    int value = 2;
     TriangleMatrix<int> matrix(data, size);
     matrix -= value;
     // Assert
@@ -163,7 +163,7 @@ TEST(TestTriangleMatrixLib, tr_matrix_mult_assign_value) {
     // Arrange & Act
     size_t size = 3;
     int data[6] = { 1, 2, 3, 4, 5, 6 };
-    size_t value = 10;
+    int value = 10;
     TriangleMatrix<int> matrix(data, size);
     matrix *= value;
     // Assert
@@ -178,7 +178,7 @@ TEST(TestTriangleMatrixLib, tr_matrix_div_assign_value) {
     // Arrange & Act
     size_t size = 3;
     int data[6] = { 2, 2, 4, 4, 8, 6 };
-    size_t value = 2;
+    int value = 2;
     TriangleMatrix<int> matrix(data, size);
     matrix /= value;
     // Assert
@@ -189,3 +189,148 @@ TEST(TestTriangleMatrixLib, tr_matrix_div_assign_value) {
     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<int> matrix1(data1, size);
+    TriangleMatrix<int> matrix2(data2, size);
+    TriangleMatrix<int> 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<int> matrix1(data1, size);
+    TriangleMatrix<int> matrix2(data2, size);
+    TriangleMatrix<int> 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<int> matrix1(data1, size);
+    TriangleMatrix<int> 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<int> matrix1(data1, size);
+    TriangleMatrix<int> 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<int> matrix1(data1, 3);
+    TriangleMatrix<int> 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<int> matrix1(data1, 3);
+    TriangleMatrix<int> 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<int> matrix1(data1, 3);
+    TriangleMatrix<int> 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<int> matrix1(data1, 3);
+    TriangleMatrix<int> 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<int> matrix(data1, 3);
+    MathVector<int> vector(data2, 3);
+    MathVector<int> 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<int> matrix(data1, 3);
+    MathVector<int> vector(data2, 10);
+    MathVector<int> result(3);
+    // Assert
+    EXPECT_THROW(matrix * vector, std::logic_error);
+}

From 224cdde464d5cd2f26f7b9a98e60d37fc8a109ef Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Tue, 7 Oct 2025 01:08:57 +0300
Subject: [PATCH 069/109] =?UTF-8?q?=D0=A2=D0=B5=D1=81=D1=82=D1=8B=20=D0=BD?=
 =?UTF-8?q?=D0=B0=20*=20=D0=B4=D0=B2=D1=83=D1=85=20=D1=82=D1=80=D0=B5?=
 =?UTF-8?q?=D1=83=D0=B3=D0=BE=D0=BB=D1=8C=D0=BD=D1=8B=D1=85=20=D0=BC=D0=B0?=
 =?UTF-8?q?=D1=82=D1=80=D0=B8=D1=86=20(+=20=D1=81=D0=BB=D1=83=D1=87=D0=B0?=
 =?UTF-8?q?=D0=B9=20=D1=81=20=D0=B8=D1=81=D0=BA=D0=BB=D1=8E=D1=87=D0=B5?=
 =?UTF-8?q?=D0=BD=D0=B8=D0=B5=D0=BC)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 tests/test_triangle_matrix.cpp | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/tests/test_triangle_matrix.cpp b/tests/test_triangle_matrix.cpp
index f650a943..560a8c4b 100644
--- a/tests/test_triangle_matrix.cpp
+++ b/tests/test_triangle_matrix.cpp
@@ -334,3 +334,31 @@ TEST(TestTriangleMatrixLib, tr_matrix_mult_vector_with_exception) {
     // 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<int> matrix1(data1, size);
+    TriangleMatrix<int> matrix2(data2, size);
+    TriangleMatrix<int> 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<int> matrix1(data1, 3);
+    TriangleMatrix<int> matrix2(data2, 4);
+    TriangleMatrix<int> result(3);
+    // Assert
+    EXPECT_THROW(matrix1 * matrix2, std::logic_error);
+}

From 032e29715a2cd0ddc8a6bbb16ccc7cbd3b39a83b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Tue, 7 Oct 2025 01:15:15 +0300
Subject: [PATCH 070/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE=D1=80?=
 =?UTF-8?q?=20*?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_triangle_matrix/triangle_matrix.h | 21 +++++++++++----------
 1 file changed, 11 insertions(+), 10 deletions(-)

diff --git a/lib_triangle_matrix/triangle_matrix.h b/lib_triangle_matrix/triangle_matrix.h
index c0568ec0..d4a05bb3 100644
--- a/lib_triangle_matrix/triangle_matrix.h
+++ b/lib_triangle_matrix/triangle_matrix.h
@@ -161,27 +161,19 @@ TriangleMatrix<T>& TriangleMatrix<T>::operator /= (T value) {
     }
     return *this;
 }
-
 template<class T>
 MathVector<T> TriangleMatrix<T>::operator * (const MathVector<T>& vector) const {
     if (this->getSize() != vector.get_size()) {
         throw std::logic_error("Matrix columns must equal vector size");
     }
-
     MathVector<T> result(this->getSize());
-
     for (size_t i = 0; i < this->getSize(); ++i) {
-        T sum = T(); // Инициализируем нулем типа T
-
-        // Ручное вычисление скалярного произведения
-        // Для треугольной матрицы: элементы ниже диагонали = 0
+        T sum = T(); 
         for (size_t j = i; j < this->getSize(); ++j) {
             sum += (*this)[i][j] * vector[j];
         }
-
         result[i] = sum;
     }
-
     return result;
 }
 template<class T>
@@ -240,5 +232,14 @@ TriangleMatrix<T> TriangleMatrix<T>::operator * (const TriangleMatrix<T>& other)
         throw std::logic_error("Matrices must have the same size");
     }
     TriangleMatrix<T> 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;
 }

From 12a4eae71ec7b966a4a3a0e0ab447273f1112dd5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Tue, 7 Oct 2025 18:15:03 +0300
Subject: [PATCH 071/109] =?UTF-8?q?=D0=97=D0=B0=D0=B4=D0=B0=D0=BD=D0=B8?=
 =?UTF-8?q?=D0=B5=20=D0=B8=D0=B7=20=D0=A2=D0=9A:=20=D0=BF=D0=BE=D0=B8?=
 =?UTF-8?q?=D1=81=D0=BA=20=D0=BB=D0=BE=D0=BA=D0=B0=D0=BB=D1=8C=D0=BD=D0=BE?=
 =?UTF-8?q?=D0=B3=D0=BE=20=D0=BC=D0=B8=D0=BD=D0=B8=D0=BC=D1=83=D0=BC=D0=B0?=
 =?UTF-8?q?=20=D0=B2=20=D0=BC=D0=B0=D1=82=D1=80=D0=B8=D1=86=D0=B5?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_algoritm/algoritm.h | 55 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 55 insertions(+)
 create mode 100644 lib_algoritm/algoritm.h

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

From dfeff048ace158e9fef4fb2a7232623f5e248585 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Tue, 7 Oct 2025 18:53:05 +0300
Subject: [PATCH 072/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=D1=8B=20=D1=82=D0=B5=D1=81=D1=82=D1=8B?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 tests/test_algoritm.cpp | 68 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 68 insertions(+)
 create mode 100644 tests/test_algoritm.cpp

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 <stdexcept>
+#include <gtest/gtest.h>
+TEST(TestAlgoritmLib, test_for_one_local_min) {
+    int data[9] = { 1, 20, 30,
+                    40, 50, 60 ,
+                    70, 80, 90 };
+    Matrix<int> 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<int> 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<int> 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<int> 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<int> matrix(data, 3, 3);
+    int result = find_local_minimum(matrix);
+    EXPECT_EQ(result, 1);
+}
+TEST(TestAlgoritmLib, test_single_element) {
+    int data[1] = { 5 };
+    Matrix<int> 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<int> 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<int> 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);
+}

From 0c04291fa2724ee8c13484d427fda7c7a3e5ac64 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Fri, 10 Oct 2025 16:31:45 +0300
Subject: [PATCH 073/109] =?UTF-8?q?=D0=A0=D0=B5=D0=BD=D0=B0=D0=BB=D0=B8?=
 =?UTF-8?q?=D0=B7=D0=B0=D1=86=D0=B8=D1=8F=20=D0=BA=D0=BB=D0=B0=D1=81=D1=81?=
 =?UTF-8?q?=D0=B0=20=D0=A1=D1=84=D0=B5=D1=80=D0=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_sphere/sphere.h | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 lib_sphere/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);
+    }
+};

From 7eeecc153cfcab26e98915dd7a0ee95ee91dd3ba Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Fri, 10 Oct 2025 16:32:52 +0300
Subject: [PATCH 074/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=20=D0=BA=D0=BB=D0=B0=D1=81=D1=81=20=D0=9E=D0=BA?=
 =?UTF-8?q?=D1=80=D1=83=D0=B6=D0=BD=D0=BE=D1=81=D1=82=D1=8C?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_circle/circle.h | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 lib_circle/circle.h

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 <cmath>
+class Circle : public Point {
+private:
+    int _radius;
+public:
+    Circle(int x, int y, int radius) : Point(x,y), _radius(radius) {}
+    Circle(Point coord_center, int radius)
+        : Point(coord_center.getX(), coord_center.getY()), _radius(radius) {}
+    Circle(const Circle& other) = default;
+    int getR() const {
+        return _radius;
+    }
+    void setR(int r) {
+        _radius = r;
+    }
+    bool operator == (const Circle& other) const {
+        return _x == other._x && _y == other._y && _radius == other._radius;
+    }
+    bool operator != (const Circle& other) const{
+        return !(*this == other);
+    }
+};

From 1494246ad588b0fb1a2ecbbdb552c41e7993d227 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Fri, 10 Oct 2025 16:33:33 +0300
Subject: [PATCH 075/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=20=D0=BA=D0=BB=D0=B0=D1=81=D1=81=20=D0=A2=D0=BE?=
 =?UTF-8?q?=D1=87=D0=BA=D0=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_point/point.h | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 lib_point/point.h

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;
+};

From 0e600e72f0cf2aa49b30cdda7ee12d42ca5ad81c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Fri, 10 Oct 2025 16:34:19 +0300
Subject: [PATCH 076/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=20=D0=BA=D0=BB=D0=B0=D1=81=D1=81=203D-=D0=A2=D0=BE?=
 =?UTF-8?q?=D1=87=D0=BA=D0=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_point3d/point3d.h | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 lib_point3d/point3d.h

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;
+};

From d431304edc9947de0f7d713ee20e7542b2fd8c43 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Fri, 10 Oct 2025 16:39:14 +0300
Subject: [PATCH 077/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=D1=8B=20=D1=82=D0=B5=D1=81=D1=82=D1=8B?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 tests/test_circles_and_spheres.cpp | 242 +++++++++++++++++++++++++++++
 1 file changed, 242 insertions(+)
 create mode 100644 tests/test_circles_and_spheres.cpp

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 <gtest/gtest.h>
+#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

From fb90c58ecaf10b9e8829c208134a0decb0b72a77 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Sun, 12 Oct 2025 12:34:05 +0300
Subject: [PATCH 078/109] =?UTF-8?q?=D0=92=D1=8B=D0=BD=D0=B5=D1=81=D0=BB?=
 =?UTF-8?q?=D0=B0=20=D0=BC=D0=B5=D1=82=D0=BE=D0=B4=20is=5Fempty()=20=D0=B2?=
 =?UTF-8?q?=20Public=20=D0=B2=D0=BE=20=D0=B8=D0=B7=D0=B1=D0=B5=D0=B6=D0=B0?=
 =?UTF-8?q?=D0=BD=D0=B8=D0=B5=20=D0=BE=D1=88=D0=B8=D0=B1=D0=BE=D0=BA=20?=
 =?UTF-8?q?=D0=B2=20=D1=81=D1=82=D0=B5=D0=BA=D0=B5?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_vector/vector.h | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/lib_vector/vector.h b/lib_vector/vector.h
index 0dcdbfae..5cada0e8 100644
--- a/lib_vector/vector.h
+++ b/lib_vector/vector.h
@@ -14,7 +14,7 @@
     public:
         enum State {
             empty, busy, deleted
-        };
+        };   //ВЫНЕСЛА ис эмпти 
     protected:
         static constexpr size_t RESERVE_MEMORY = 15;
         static constexpr size_t MAX_PERCENT_DELETED = 15;
@@ -31,9 +31,6 @@
         void shrink_to_fit();
         void reserve(size_t new_capacity);
         void compact_storage();
-        inline bool is_full() const noexcept {
-            return _size == _capacity;
-        }
     public:
         Tvector() noexcept;
         Tvector(size_t size);
@@ -44,6 +41,9 @@
         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;
         }
@@ -100,6 +100,7 @@
         template <class U> friend size_t find_last_element(const Tvector<U>& object, const U& value);
         template <class U> friend size_t find_count_of_all_suitable_elements(const Tvector<U>& object, const U& value);
     };
+
     template <class T>
     size_t Tvector<T>::get_real_position(size_t busy_index) const noexcept {
         size_t busy_count = 0;

From e054c78269cfff1a6977f7a26f0e9f67c7749238 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Sun, 12 Oct 2025 12:36:48 +0300
Subject: [PATCH 079/109] =?UTF-8?q?=D0=9D=D0=B5=D0=B1=D0=BE=D0=BB=D1=88?=
 =?UTF-8?q?=D0=B8=D0=B5=20=D0=BF=D1=80=D0=B0=D0=B2=D0=BA=D0=B8?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_vector/vector.h | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/lib_vector/vector.h b/lib_vector/vector.h
index 5cada0e8..64038b5b 100644
--- a/lib_vector/vector.h
+++ b/lib_vector/vector.h
@@ -14,7 +14,7 @@
     public:
         enum State {
             empty, busy, deleted
-        };   //ВЫНЕСЛА ис эмпти 
+        };
     protected:
         static constexpr size_t RESERVE_MEMORY = 15;
         static constexpr size_t MAX_PERCENT_DELETED = 15;
@@ -24,7 +24,6 @@
         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);

From a2963e3a7280b00176ff8561fc20dead87e197a8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Mon, 13 Oct 2025 08:55:53 +0300
Subject: [PATCH 080/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=D0=BE=20this->=20=D0=BF=D0=B5=D1=80=D0=B5=D0=B4=20?=
 =?UTF-8?q?=D0=B2=D1=8B=D0=B7=D0=BE=D0=B2=D0=BE=D0=BC=20=D0=BE=D0=BF=D0=B5?=
 =?UTF-8?q?=D1=80=D0=B0=D1=82=D0=BE=D1=80=D0=BE=D0=B2=20=D0=B8=D0=B7=20Tve?=
 =?UTF-8?q?ctor=20=D0=B4=D0=BB=D1=8F=20=D1=8F=D1=81=D0=BD=D0=BE=D1=81?=
 =?UTF-8?q?=D1=82=D0=B8?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_math_vector/math_vector.h | 34 +++++++++++++++++++---------------
 1 file changed, 19 insertions(+), 15 deletions(-)

diff --git a/lib_math_vector/math_vector.h b/lib_math_vector/math_vector.h
index c5a3630a..510d810e 100644
--- a/lib_math_vector/math_vector.h
+++ b/lib_math_vector/math_vector.h
@@ -37,17 +37,9 @@ class MathVector:public Tvector<T> {
     MathVector<T>& operator += (const MathVector<T>& vector);
     MathVector<T>& operator -= (const MathVector<T>& vector);
     MathVector<T>& operator=(const MathVector<T>& other);
-    friend std::ostream& operator<<(std::ostream& out, const MathVector<T>& 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;
-    }
+    template<typename U>
+    friend std::ostream& operator<<(std::ostream&, const MathVector<U>& vector);
+   
     T& operator[](size_t index);
     const T& operator[](size_t index) const;
 };
@@ -166,23 +158,35 @@ MathVector<T>& MathVector<T>::operator=(const MathVector<T>& other) {
 }
 template <class T>
 T& MathVector<T>::operator[](size_t index) {
-    return Tvector<T>::operator[](index - _start_index);
+    return this->Tvector<T>::operator[](index - _start_index);
 }
 template <class T>
 const T& MathVector<T>::operator[](size_t index) const {
-    return Tvector<T>::operator[](index - _start_index);
+    return this->Tvector<T>::operator[](index - _start_index);
 }
 template <class T>
 T& MathVector<T>::at(size_t index) {
     if (index < _start_index || index >= _start_index + this->get_size()) {
         throw std::logic_error("MathVector index out of range");
     }
-    return Tvector<T>::operator[](index - _start_index);
+    return this->Tvector<T>::operator[](index - _start_index);
 }
 template <class T>
 const T& MathVector<T>::at(size_t index) const {
     if (index < _start_index || index >= _start_index + this->get_size()) {
         throw std::std::logic_error("MathVector index out of range");
     }
-    return Tvector<T>::operator[](index - _start_index);
+    return this->Tvector<T>::operator[](index - _start_index);
+}
+template <class U>
+std::ostream& operator<<(std::ostream&, const MathVector<U>& vector) {
+    out << "[";
+    for (size_t i = 0; i < vector.get_size(); ++i) {
+        out << vector[i];
+        if (i < vector.get_size() - 1) {
+            out << ", ";
+        }
+    }
+    out << "]";
+    return out;
 }

From 54eb1d5d097e6708704570c38cf3ef0388faee0f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Mon, 13 Oct 2025 08:57:24 +0300
Subject: [PATCH 081/109] =?UTF-8?q?=D0=92=D1=8B=D0=BD=D0=B5=D1=81=D0=B5?=
 =?UTF-8?q?=D0=BD=D0=B0=20=D0=B8=D0=B7=20=D0=BA=D0=BB=D0=B0=D1=81=D1=81?=
 =?UTF-8?q?=D0=B0=20=D1=80=D0=B5=D0=B0=D0=BB=D0=B8=D0=B7=D0=B0=D1=86=D0=B8?=
 =?UTF-8?q?=D1=8F=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE=D1=80=D0=B0?=
 =?UTF-8?q?=20<<?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_math_vector/math_vector.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/lib_math_vector/math_vector.h b/lib_math_vector/math_vector.h
index 510d810e..68120a76 100644
--- a/lib_math_vector/math_vector.h
+++ b/lib_math_vector/math_vector.h
@@ -178,6 +178,7 @@ const T& MathVector<T>::at(size_t index) const {
     }
     return this->Tvector<T>::operator[](index - _start_index);
 }
+
 template <class U>
 std::ostream& operator<<(std::ostream&, const MathVector<U>& vector) {
     out << "[";

From f084077ef1faf7deafbd8349dcfbe57924ea12d9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Mon, 13 Oct 2025 09:00:24 +0300
Subject: [PATCH 082/109] =?UTF-8?q?=D0=92=D1=8B=D0=BD=D0=B5=D1=81=D0=B5?=
 =?UTF-8?q?=D0=BD=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE=D1=80=20<<?=
 =?UTF-8?q?=20=D0=B8=D0=B7=20=D0=BA=D0=BB=D0=B0=D1=81=D1=81=D0=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_matrix/matrix.h | 22 ++++++++++++----------
 1 file changed, 12 insertions(+), 10 deletions(-)

diff --git a/lib_matrix/matrix.h b/lib_matrix/matrix.h
index 6fbeaaf6..7136fac4 100644
--- a/lib_matrix/matrix.h
+++ b/lib_matrix/matrix.h
@@ -42,15 +42,8 @@ class Matrix : public MathVector<MathVector<T>> {
 
     Matrix<T>& operator += (const Matrix<T>& other_matrix);
     Matrix<T>& operator -= (const Matrix<T>& other_matrix);
-    friend std::ostream& operator<< (std::ostream& out, const Matrix<T>& 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;
-    }
+    template<typename U>
+    friend std::ostream& operator<<(std::ostream&, const Matrix<U>& matrix);
     
     Matrix<T>& operator=(const Matrix<T>& other);
 };
@@ -62,7 +55,6 @@ template <class T>
 size_t Matrix<T>::getN() const {
     return _N;
 }
-
 template <class T>
 Matrix<T>::Matrix() : MathVector<MathVector<T>>(), _M(0), _N(0) {}
 template <class T>
@@ -254,3 +246,13 @@ Matrix<T>& Matrix<T>::operator=(const Matrix<T>& other) {
     _N = other._N;
     return *this;
 }
+template <class U>
+std::ostream& operator<<(std::ostream&, const Matrix<U>& 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;
+}

From f321f87e746d340dc531d546717522a115801aa6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Mon, 13 Oct 2025 09:05:30 +0300
Subject: [PATCH 083/109] =?UTF-8?q?=D0=98=D1=81=D0=BF=D1=80=D0=B0=D0=B2?=
 =?UTF-8?q?=D0=BB=D0=B5=D0=BD=D0=B0=20=D0=BE=D1=88=D0=B8=D0=B1=D0=BA=D0=B0?=
 =?UTF-8?q?=20=D0=B2=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE=D1=80?=
 =?UTF-8?q?=D0=B5=20<<?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_math_vector/math_vector.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib_math_vector/math_vector.h b/lib_math_vector/math_vector.h
index 68120a76..34843ac5 100644
--- a/lib_math_vector/math_vector.h
+++ b/lib_math_vector/math_vector.h
@@ -180,7 +180,7 @@ const T& MathVector<T>::at(size_t index) const {
 }
 
 template <class U>
-std::ostream& operator<<(std::ostream&, const MathVector<U>& vector) {
+std::ostream& operator<<(std::ostream& out, const MathVector<U>& vector) {
     out << "[";
     for (size_t i = 0; i < vector.get_size(); ++i) {
         out << vector[i];

From f021e1e44d5700e065dec0d0d7480b5fa53fe644 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Mon, 13 Oct 2025 20:31:37 +0300
Subject: [PATCH 084/109] =?UTF-8?q?=D0=98=D1=81=D0=BF=D1=80=D0=B0=D0=B2?=
 =?UTF-8?q?=D0=BB=D0=B5=D0=BD=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE?=
 =?UTF-8?q?=D1=80=20=D0=B2=D1=8B=D0=B2=D0=BE=D0=B4=D0=B0=20=D0=B8=20=D1=83?=
 =?UTF-8?q?=D0=BF=D1=80=D0=BE=D1=89=D0=B5=D0=BD=D1=8B=20=D1=80=D0=B5=D0=B0?=
 =?UTF-8?q?=D0=BB=D0=B8=D0=B7=D0=B0=D1=86=D0=B8=D0=B8=20=D0=BD=D0=B5=D0=BA?=
 =?UTF-8?q?=D0=BE=D1=82=D0=BE=D1=80=D1=8B=D1=85=20=D0=B0=D1=80=D0=B8=D1=84?=
 =?UTF-8?q?=D0=BC=D0=B5=D1=82=D0=B8=D1=87=D0=B5=D1=81=D0=BA=D0=B8=D1=85=20?=
 =?UTF-8?q?=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE=D1=80=D0=BE=D0=B2?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_matrix/matrix.h | 38 +++++++++++---------------------------
 1 file changed, 11 insertions(+), 27 deletions(-)

diff --git a/lib_matrix/matrix.h b/lib_matrix/matrix.h
index 7136fac4..0b8828bd 100644
--- a/lib_matrix/matrix.h
+++ b/lib_matrix/matrix.h
@@ -103,9 +103,7 @@ template <class T>
 Matrix<T> Matrix<T>::operator * (T value) const {
     Matrix<T> matrix(_M, _N);
     for (size_t i = 0; i < _M; ++i) {
-        for (size_t j = 0; j < _N; ++j) {
-            matrix[i][j] = (*this)[i][j] * value;
-        }
+        matrix[i] = (*this)[i] * value;
     }
     return matrix;
 }
@@ -116,9 +114,7 @@ Matrix<T> Matrix<T>::operator / (T value) const {
     }
     Matrix<T> matrix(_M, _N);
     for (size_t i = 0; i < _M; ++i) {
-        for (size_t j = 0; j < _N; ++j) {
-            matrix[i][j] = (*this)[i][j] / value;
-        }
+        matrix[i] = (*this)[i] / value;
     }
     return matrix;
 }
@@ -126,7 +122,7 @@ template <class T>
 Matrix<T>& Matrix<T>::operator += (T value) {
     for (size_t i = 0; i < _M; ++i) {
         for (size_t j = 0; j < _N; ++j) {
-            (*this)[i][j] = (*this)[i][j] + value;
+            (*this)[i][j] += value;
         }
     }
     return *this;
@@ -135,7 +131,7 @@ template <class T>
 Matrix<T>& Matrix<T>::operator -= (T value) {
     for (size_t i = 0; i < _M; ++i) {
         for (size_t j = 0; j < _N; ++j) {
-            (*this)[i][j] = (*this)[i][j] - value;
+            (*this)[i][j] -=  value;
         }
     }
     return *this;
@@ -143,9 +139,7 @@ Matrix<T>& Matrix<T>::operator -= (T value) {
 template <class T>
 Matrix<T>& Matrix<T>::operator *= (T value) {
     for (size_t i = 0; i < _M; ++i) {
-        for (size_t j = 0; j < _N; ++j) {
-            (*this)[i][j] = (*this)[i][j] * value;
-        }
+        (*this)[i] *= value;
     }
     return *this;
 }
@@ -155,10 +149,8 @@ Matrix<T>& Matrix<T>::operator /= (T value) {
         throw std::logic_error("Division by zero!");
     }
     for (size_t i = 0; i < _M; ++i) {
-        for (size_t j = 0; j < _N; ++j) {
-            (*this)[i][j] = (*this)[i][j] / value;
+            (*this)[i] /= value;
         }
-    }
     return *this;
 }
 template <class T>
@@ -168,9 +160,7 @@ Matrix<T> Matrix<T>::operator + (const Matrix<T>& other_matrix) const {
     }
     Matrix<T> result(_M, _N);
     for (size_t i = 0; i < _M; ++i) {
-        for (size_t j = 0; j < _N; ++j) {
-            result[i][j] = (*this)[i][j] + other_matrix[i][j];
-        }
+        result[i] = (*this)[i] + other_matrix[i];
     }
     return result;
 }
@@ -181,9 +171,7 @@ Matrix<T> Matrix<T>::operator - (const Matrix<T>& other_matrix) const {
     }
     Matrix<T> result(_M, _N);
     for (size_t i = 0; i < _M; ++i) {
-        for (size_t j = 0; j < _N; ++j) {
-            result[i][j] = (*this)[i][j] - other_matrix[i][j];
-        }
+        result[i] = (*this)[i] - other_matrix[i];
     }
     return result;
 }
@@ -221,9 +209,7 @@ Matrix<T>& Matrix<T>::operator += (const Matrix<T>& other_matrix) {
         throw std::logic_error("The matrices have different sizes!");
     }
     for (size_t i = 0; i < _M; ++i) {
-        for (size_t j = 0; j < _N; ++j) {
-            (*this)[i][j] += other_matrix[i][j];
-        }
+        (*this)[i] += other_matrix[i];
     }
     return *this;
 }
@@ -233,9 +219,7 @@ Matrix<T>& Matrix<T>::operator -= (const Matrix<T>& other_matrix) {
         throw std::logic_error("The matrices have different sizes!");
     }
     for (size_t i = 0; i < _M; ++i) {
-        for (size_t j = 0; j < _N; ++j) {
-            (*this)[i][j] -= other_matrix[i][j];
-        }
+        (*this)[i] -= other_matrix[i];
     }
     return *this;
 }
@@ -247,7 +231,7 @@ Matrix<T>& Matrix<T>::operator=(const Matrix<T>& other) {
     return *this;
 }
 template <class U>
-std::ostream& operator<<(std::ostream&, const Matrix<U>& matrix) {
+std::ostream& operator<<(std::ostream& out, const Matrix<U>& matrix) {
     for (size_t i = 0; i < matrix.getM(); ++i) {
         for (size_t j = 0; j < matrix.getN(); ++j) {
             out << matrix[i][j] << "\t";

From a99cee7b1f90a59b5af8c9320ede893020a974a9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Mon, 13 Oct 2025 20:36:36 +0300
Subject: [PATCH 085/109] =?UTF-8?q?=D0=92=D1=8B=D0=BD=D0=B5=D1=81=D0=B5?=
 =?UTF-8?q?=D0=BD=D0=B0=20=D0=B8=D0=B7=20=D0=BA=D0=BB=D0=B0=D1=81=D1=81?=
 =?UTF-8?q?=D0=B0=20=D1=80=D0=B5=D0=B0=D0=BB=D0=B8=D0=B7=D0=B0=D1=86=D0=B8?=
 =?UTF-8?q?=D1=8F=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE=D1=80=D0=B0?=
 =?UTF-8?q?=20<<?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_triangle_matrix/triangle_matrix.h | 31 +++++++++++++++------------
 1 file changed, 17 insertions(+), 14 deletions(-)

diff --git a/lib_triangle_matrix/triangle_matrix.h b/lib_triangle_matrix/triangle_matrix.h
index d4a05bb3..b24a2a09 100644
--- a/lib_triangle_matrix/triangle_matrix.h
+++ b/lib_triangle_matrix/triangle_matrix.h
@@ -35,20 +35,8 @@ class TriangleMatrix : public Matrix<T> {
     TriangleMatrix<T>& operator -= (const TriangleMatrix<T>& other);
     TriangleMatrix<T>& operator= (const TriangleMatrix<T>& other);
 
-    friend std::ostream& operator<<(std::ostream& out, const TriangleMatrix<T>& 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;
-    }
+    template <typename U>
+    friend std::ostream& operator<<(std::ostream& out, const TriangleMatrix<T>& matrix);
 };
 template<class T>
 TriangleMatrix<T>::TriangleMatrix() : Matrix<T>() {}
@@ -243,3 +231,18 @@ TriangleMatrix<T> TriangleMatrix<T>::operator * (const TriangleMatrix<T>& other)
     }
     return result;
 }
+template <typename U>
+std::ostream& operator<<(std::ostream& out, const TriangleMatrix<U>& 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;
+}

From 05f3d0669a1f5bb67b17d920fe52146a2b9f9354 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Tue, 14 Oct 2025 09:25:16 +0300
Subject: [PATCH 086/109] =?UTF-8?q?=D0=9D=D0=B5=D0=B1=D0=BE=D0=BB=D1=8C?=
 =?UTF-8?q?=D1=88=D0=B8=D0=B5=20=D0=B8=D0=B7=D0=BC=D0=B5=D0=BD=D0=B5=D0=BD?=
 =?UTF-8?q?=D0=B8=D1=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 tests/test_stack.cpp | 167 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 167 insertions(+)
 create mode 100644 tests/test_stack.cpp

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 <stdexcept>
+//#include <gtest/gtest.h>
+//#include "../lib_stack/stack.h"
+//
+//TEST(TestStackLib, stack_constructor_with_size) {
+//    // Arrange & Act
+//    size_t size = 10;
+//    Stack<int> 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<int> stack1(size);
+//    Stack<int> stack2(stack1);
+//    // Assert
+//    EXPECT_TRUE(stack1 == stack2);
+//}
+//TEST(TestStackLib, stack_push_element) {
+//    // Arrange 
+//    size_t size = 10;
+//    int element = 100;
+//    Stack<int> 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<int> 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<int> 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<int> 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<int> 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<int> stack(size);
+//    // Assert & Act
+//    EXPECT_TRUE(stack.is_empty());
+//}
+//TEST(TestStackLib, stack_clear) {
+//    // Arrange 
+//    size_t size = 0;
+//    int element = 300;
+//
+//    Stack<int> 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<int> 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<int> stack(size);
+//    // Assert
+//    EXPECT_THROW(stack.top(), std::logic_error);
+//}
+//TEST(TestStackLib, stack_operator_compare_expect_true) {
+//    // Arrange & Act
+//    size_t size = 10;
+//    Stack<int> stack(size);
+//    Stack<int> 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<int> stack(size1);
+//    Stack<int> stack_other(size2);
+//    // Assert
+//    EXPECT_FALSE(stack == stack_other);
+//}
+//TEST(TestStackLib, stack_operator_assign) {
+//    //Arrange
+//    size_t size1 = 10;
+//    size_t size2 = 20;
+//    Stack<int> stack(size1);
+//    Stack<int> 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<int> stack(size);
+//    Stack<int> 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<int> stack(size1);
+//    Stack<int> stack_other(size2);
+//    // Assert
+//    EXPECT_TRUE(stack != stack_other);
+//}

From 0f5dcca96eb2cd7e3bf9c5248f87efd6479d4887 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Mon, 20 Oct 2025 10:29:02 +0300
Subject: [PATCH 087/109] =?UTF-8?q?=D0=A3=D0=B1=D1=80=D0=B0=D0=BD=D1=8B=20?=
 =?UTF-8?q?=D0=BD=D0=B5=20=D0=BD=D1=83=D0=B6=D0=BD=D1=8B=D0=B5=20=D1=82?=
 =?UTF-8?q?=D0=B5=D1=81=D1=82=D1=8B?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 tests/test_matrix.cpp | 30 ------------------------------
 1 file changed, 30 deletions(-)

diff --git a/tests/test_matrix.cpp b/tests/test_matrix.cpp
index a0482516..ffa52d76 100644
--- a/tests/test_matrix.cpp
+++ b/tests/test_matrix.cpp
@@ -55,36 +55,6 @@ TEST(TestMatrixLib, matrix_assignment_operator) {
     // Assert
     EXPECT_EQ(matrix1, matrix2);
 }
-TEST(TestMatrixLib, matrix_add_value) {
-    // Arrange
-    size_t M = 2, N = 2;
-    int data[4] = { 1, 2, 3, 4 };
-    int value = 10;
-    Matrix<int> matrix(data, M, N);
-    Matrix<int> 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_sub_value) {
-    // Arrange
-    size_t M = 2, N = 2;
-    int data[4] = { 1, 2, 3, 4 };
-    int value = 10;
-    Matrix<int> matrix(data, M, N);
-    Matrix<int> 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_mult_value) {
     // Arrange
     size_t M = 2, N = 2;

From 5c9c836f8187e350f78db56495c4cb966821fe85 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Mon, 20 Oct 2025 10:42:18 +0300
Subject: [PATCH 088/109] =?UTF-8?q?=D0=A3=D0=B1=D1=80=D0=B0=D0=BD=D0=BE=20?=
 =?UTF-8?q?=D0=BB=D0=B8=D1=88=D0=BD=D0=B5=D0=B5=20std::?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_math_vector/math_vector.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib_math_vector/math_vector.h b/lib_math_vector/math_vector.h
index 34843ac5..c7e80dea 100644
--- a/lib_math_vector/math_vector.h
+++ b/lib_math_vector/math_vector.h
@@ -174,7 +174,7 @@ T& MathVector<T>::at(size_t index) {
 template <class T>
 const T& MathVector<T>::at(size_t index) const {
     if (index < _start_index || index >= _start_index + this->get_size()) {
-        throw std::std::logic_error("MathVector index out of range");
+        throw std::logic_error("MathVector index out of range");
     }
     return this->Tvector<T>::operator[](index - _start_index);
 }

From 21912c245ab53c1aa341362dc51ad14fff01a546 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Mon, 20 Oct 2025 10:53:28 +0300
Subject: [PATCH 089/109] =?UTF-8?q?=D0=A3=D0=B1=D1=80=D0=B0=D0=BD=D1=8B=20?=
 =?UTF-8?q?=D0=BD=D0=B5=D0=BB=D0=BE=D0=B3=D0=B8=D1=87=D0=BD=D1=8B=D0=B5=20?=
 =?UTF-8?q?=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=86=D0=B8=D0=B8=20=D0=B8=D0=B7?=
 =?UTF-8?q?=20=D0=BA=D0=B0=D0=BB=D1=8C=D0=BA=D1=83=D0=BB=D1=8F=D1=82=D0=BE?=
 =?UTF-8?q?=D1=80=D0=B0=20=D0=BC=D0=B0=D1=82=D1=80=D0=B8=D1=86?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 main/main.cpp | 30 ++++++------------------------
 1 file changed, 6 insertions(+), 24 deletions(-)

diff --git a/main/main.cpp b/main/main.cpp
index 3e651e30..a5a282bd 100644
--- a/main/main.cpp
+++ b/main/main.cpp
@@ -139,12 +139,10 @@ void printMainMenu() {
     std::cout << " 1. Matrix addition\n";
     std::cout << " 2. Matrix subtraction\n";
     std::cout << " 3. Matrix multiplication\n";
-    std::cout << " 4. Add scalar to matrix\n";
-    std::cout << " 5. Subtract scalar from matrix\n";
-    std::cout << " 6. Multiply matrix by scalar\n";
-    std::cout << " 7. Division by scalar\n";
-    std::cout << " 8. Multiply matrix by vector\n";
-    std::cout << " 9. Exit\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<typename T>
@@ -245,22 +243,6 @@ int main() {
                 break;
             }
             case 4: {
-                int scalar;
-                std::cout << "Enter scalar: ";
-                std::cin >> scalar;
-                Matrix<int> result = matrix1 + scalar;
-                std::cout << "Result:\n" << result;
-                break;
-            }
-            case 5: {
-                int scalar;
-                std::cout << "Enter scalar: ";
-                std::cin >> scalar;
-                Matrix<int> result = matrix1 - scalar;
-                std::cout << "Result:\n" << result;
-                break;
-            }
-            case 6: {
                 int scalar;
                 std::cout << "Enter scalar: ";
                 std::cin >> scalar;
@@ -268,7 +250,7 @@ int main() {
                 std::cout << "Result:\n" << result;
                 break;
             }
-            case 7: {
+            case 5: {
                 int scalar;
                 std::cout << "Enter scalar: ";
                 std::cin >> scalar;
@@ -281,7 +263,7 @@ int main() {
                 }
                 break;
             }
-            case 8: {
+            case 6: {
                 size_t size;
                 std::cout << "Enter vector size (must be " << N << "): ";
                 std::cin >> size;

From 5f71806e7d3ec62fd49dbdc2b72ec0bf8532f91a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Mon, 20 Oct 2025 11:01:27 +0300
Subject: [PATCH 090/109] =?UTF-8?q?=D0=A2=D0=B5=D0=BF=D0=B5=D1=80=D1=8C=20?=
 =?UTF-8?q?=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE=D1=80=20*=20=D0=B8?=
 =?UTF-8?q?=20/=20=D0=BD=D0=B0=20=D1=81=D0=BA=D0=B0=D0=BB=D1=8F=D1=80=20?=
 =?UTF-8?q?=D0=B8=D1=81=D0=BF=D0=BE=D0=BB=D1=8C=D0=B7=D1=83=D0=B5=D1=82=20?=
 =?UTF-8?q?=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE=D1=80=D1=8B=20=D0=B8?=
 =?UTF-8?q?=D0=B7=20MathVector?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_matrix/matrix.h | 35 ++++++-----------------------------
 1 file changed, 6 insertions(+), 29 deletions(-)

diff --git a/lib_matrix/matrix.h b/lib_matrix/matrix.h
index 0b8828bd..49cb1520 100644
--- a/lib_matrix/matrix.h
+++ b/lib_matrix/matrix.h
@@ -24,8 +24,6 @@ class Matrix : public MathVector<MathVector<T>> {
     size_t getM() const;
     size_t getN() const;
 
-    Matrix<T> operator + (T value) const;
-    Matrix<T> operator - (T value) const;
     Matrix<T> operator * (T value) const;
     Matrix<T> operator / (T value) const;
 
@@ -78,45 +76,24 @@ Matrix<T>::Matrix(const Matrix& other) :
     MathVector<MathVector<T>>(other), _M(other._M), _N(other._N) {}
 template <class T>
 Matrix<T>::~Matrix() = default;
-
-template <class T>
-Matrix<T> Matrix<T>::operator + (T value) const {
-    Matrix<T> matrix(_M, _N);
-    for (size_t i = 0; i < _M; ++i) {
-        for (size_t j = 0; j < _N; ++j) {
-            matrix[i][j] = (*this)[i][j] + value;
-        }
-    }
-    return matrix;
-}
-template <class T>
-Matrix<T> Matrix<T>::operator - (T value) const {
-    Matrix<T> matrix(_M, _N);
-    for (size_t i = 0; i < _M; ++i) {
-        for (size_t j = 0; j < _N; ++j) {
-            matrix[i][j] = (*this)[i][j] - value;
-        }
-    }
-    return matrix;
-}
 template <class T>
 Matrix<T> Matrix<T>::operator * (T value) const {
-    Matrix<T> matrix(_M, _N);
+    Matrix result(_M, _N);
     for (size_t i = 0; i < _M; ++i) {
-        matrix[i] = (*this)[i] * value;
+        result[i] = (*this)[i] * value;
     }
-    return matrix;
+    return result;
 }
 template <class T>
 Matrix<T> Matrix<T>::operator / (T value) const {
     if (value == 0) {
         throw std::logic_error("Division by zero!");
     }
-    Matrix<T> matrix(_M, _N);
+    Matrix result(_M, _N);
     for (size_t i = 0; i < _M; ++i) {
-        matrix[i] = (*this)[i] / value;
+        result[i] = (*this)[i] / value;
     }
-    return matrix;
+    return result;
 }
 template <class T>
 Matrix<T>& Matrix<T>::operator += (T value) {

From 9e9f820d3a55f8cd1821d847097b32994ebc5244 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Mon, 20 Oct 2025 11:06:38 +0300
Subject: [PATCH 091/109] =?UTF-8?q?=D0=A3=D0=B1=D1=80=D0=B0=D0=BD=D1=8B=20?=
 =?UTF-8?q?=D1=82=D0=B5=D1=81=D1=82=D1=8B=20=D0=BD=D0=B0=20=D0=BD=D0=B5?=
 =?UTF-8?q?=D0=BB=D0=BE=D0=B3=D0=B8=D1=87=D0=BD=D1=8B=D0=B5=20=D0=BE=D0=BF?=
 =?UTF-8?q?=D0=B5=D1=80=D0=B0=D1=82=D0=BE=D1=80=D1=8B?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 tests/test_matrix.cpp | 30 ++----------------------------
 1 file changed, 2 insertions(+), 28 deletions(-)

diff --git a/tests/test_matrix.cpp b/tests/test_matrix.cpp
index ffa52d76..90aae44e 100644
--- a/tests/test_matrix.cpp
+++ b/tests/test_matrix.cpp
@@ -2,6 +2,8 @@
 #include <stdexcept>
 #include <gtest/gtest.h>
 #include "../lib_matrix/matrix.h"
+
+
 TEST(TestMatrixLib, matrix_default_constructor) {
     // Arrange & Act
     Matrix<int> matrix;
@@ -94,34 +96,6 @@ TEST(TestMatrixLib, matrix_div_value_with_exception) {
     // Assert
     EXPECT_THROW(matrix / value;, std::logic_error);
 }
-TEST(TestMatrixLib, matrix_add_assign_value) {
-    // Arrange
-    size_t M = 2, N = 2;
-    int data[4] = { 2, 2, 10, 4 };
-    int value = 2;
-    Matrix<int> 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_sub_assign_value) {
-    // Arrange
-    size_t M = 2, N = 2;
-    int data[4] = { 2, 2, 10, 4 };
-    int value = 2;
-    Matrix<int> 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_mult_assign_value) {
     // Arrange
     size_t M = 2, N = 2;

From 055355c133e1fab9e8481c0ba0495d76bc792de5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Mon, 20 Oct 2025 11:07:33 +0300
Subject: [PATCH 092/109] =?UTF-8?q?=D0=A3=D0=B1=D1=80=D0=B0=D0=BD=D1=8B=20?=
 =?UTF-8?q?+=3D=20=D0=B8=20-=3D=20(=D0=B8=D1=85=20=D0=BD=D0=B5=D1=82=20?=
 =?UTF-8?q?=D0=B2=20=D0=B2=D0=B5=D0=BA=D1=82=D0=BE=D1=80=D0=B5,=20=D0=B4?=
 =?UTF-8?q?=D0=B5=D0=BB=D0=B0=D1=82=D1=8C=20=D0=BF=D0=BE=D0=B4=D0=BE=D0=B1?=
 =?UTF-8?q?=D0=BD=D0=BE=D0=B5=20=D0=B2=20=D0=BC=D0=B0=D1=82=D1=80=D1=86?=
 =?UTF-8?q?=D0=B5=20=D1=81=D1=82=D1=80=D0=B0=D0=BD=D0=BD=D0=BE)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_matrix/matrix.h | 20 --------------------
 1 file changed, 20 deletions(-)

diff --git a/lib_matrix/matrix.h b/lib_matrix/matrix.h
index 49cb1520..09c30f4f 100644
--- a/lib_matrix/matrix.h
+++ b/lib_matrix/matrix.h
@@ -27,8 +27,6 @@ class Matrix : public MathVector<MathVector<T>> {
     Matrix<T> operator * (T value) const;
     Matrix<T> operator / (T value) const;
 
-    Matrix<T>& operator += (T value);
-    Matrix<T>& operator -= (T value);
     Matrix<T>& operator *= (T value);
     Matrix<T>& operator /= (T value);
 
@@ -96,24 +94,6 @@ Matrix<T> Matrix<T>::operator / (T value) const {
     return result;
 }
 template <class T>
-Matrix<T>& Matrix<T>::operator += (T value) {
-    for (size_t i = 0; i < _M; ++i) {
-        for (size_t j = 0; j < _N; ++j) {
-            (*this)[i][j] += value;
-        }
-    }
-    return *this;
-}
-template <class T>
-Matrix<T>& Matrix<T>::operator -= (T value) {
-    for (size_t i = 0; i < _M; ++i) {
-        for (size_t j = 0; j < _N; ++j) {
-            (*this)[i][j] -=  value;
-        }
-    }
-    return *this;
-}
-template <class T>
 Matrix<T>& Matrix<T>::operator *= (T value) {
     for (size_t i = 0; i < _M; ++i) {
         (*this)[i] *= value;

From b6a226315309b418ffe6a04be20bc5f47090d986 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Mon, 20 Oct 2025 11:32:36 +0300
Subject: [PATCH 093/109] =?UTF-8?q?=D0=A3=D0=BF=D1=80=D0=BE=D1=89=D0=B5?=
 =?UTF-8?q?=D0=BD=D0=B0=20=D1=80=D0=B5=D0=B0=D0=BB=D0=B8=D0=B7=D0=B0=D1=86?=
 =?UTF-8?q?=D0=B8=D1=8F=20=D0=BD=D0=B5=D0=BA=D0=BE=D1=82=D0=BE=D1=80=D1=8B?=
 =?UTF-8?q?=D1=85=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE=D1=80=D0=BE?=
 =?UTF-8?q?=D0=B2=20=D1=81=20=D1=83=D1=87=D0=B5=D1=82=D0=BE=D0=BC=20=D0=BE?=
 =?UTF-8?q?=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE=D1=80=D0=BE=D0=B2=20=D0=B8?=
 =?UTF-8?q?=D0=B7=20MathVector=20=D0=B8=20=D0=B4=D1=80=D1=83=D0=B3=D0=B8?=
 =?UTF-8?q?=D1=85=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE=D1=80=D0=BE?=
 =?UTF-8?q?=D0=B2=20Matrix?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_matrix/matrix.h | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/lib_matrix/matrix.h b/lib_matrix/matrix.h
index 09c30f4f..61e8c0a5 100644
--- a/lib_matrix/matrix.h
+++ b/lib_matrix/matrix.h
@@ -156,7 +156,6 @@ MathVector<T> Matrix<T>::operator * (const MathVector<T>& vector) const {
     MathVector<T> result(_M);
     for (size_t i = 0; i < _M; ++i) {
         result[i] = (*this)[i] * vector;
-
     }
     return result;
 }
@@ -165,9 +164,7 @@ Matrix<T>& Matrix<T>::operator += (const Matrix<T>& 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];
-    }
+    (*this) = (*this) + other_matrix;
     return *this;
 }
 template <class T>
@@ -175,16 +172,16 @@ Matrix<T>& Matrix<T>::operator -= (const Matrix<T>& 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];
-    }
+    (*this) = (*this) - other_matrix;
     return *this;
 }
 template <class T>
 Matrix<T>& Matrix<T>::operator=(const Matrix<T>& other) {
+    (if this != &other) {
     MathVector<MathVector<T>>::operator=(other);
     _M = other._M;
     _N = other._N;
+}
     return *this;
 }
 template <class U>

From e4a79f6d3062bd21a687b05dbe8e4872e751a6bf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Mon, 20 Oct 2025 11:40:14 +0300
Subject: [PATCH 094/109] =?UTF-8?q?=D0=A3=D0=B1=D1=80=D0=B0=D0=BD=D0=B0=20?=
 =?UTF-8?q?=D1=81=D0=B8=D0=BD=D1=82=D0=B0=D0=BA=D1=81=D0=B8=D1=87=D0=B5?=
 =?UTF-8?q?=D1=81=D0=BA=D0=B0=D1=8F=20=D0=BE=D1=88=D0=B8=D0=B1=D0=BA=D0=B0?=
 =?UTF-8?q?=20=D0=B2=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE=D1=80?=
 =?UTF-8?q?=D0=B5=20=3D,=20=D0=B4=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB=D0=B5?=
 =?UTF-8?q?=D0=BD=D0=BE=20noexcept=20=D0=BA=20=D0=B3=D0=B5=D1=82=D1=82?=
 =?UTF-8?q?=D0=B5=D1=80=D0=B0=D0=BC,=20=D0=BD=D0=B5=D0=B1=D0=BE=D0=BB?=
 =?UTF-8?q?=D1=88=D0=B0=D1=8F=20=D0=BE=D0=BF=D1=82=D0=B8=D0=BC=D0=B8=D0=B7?=
 =?UTF-8?q?=D0=B0=D1=86=D0=B8=D1=8F=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82?=
 =?UTF-8?q?=D0=BE=D1=80=D0=BE=D0=B2?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_matrix/matrix.h | 28 ++++++++++++----------------
 1 file changed, 12 insertions(+), 16 deletions(-)

diff --git a/lib_matrix/matrix.h b/lib_matrix/matrix.h
index 61e8c0a5..a6b94ac5 100644
--- a/lib_matrix/matrix.h
+++ b/lib_matrix/matrix.h
@@ -21,9 +21,9 @@ class Matrix : public MathVector<MathVector<T>> {
     Matrix(T* data, size_t M, size_t N);
     Matrix(const Matrix& other);
     virtual ~Matrix();
-    size_t getM() const;
-    size_t getN() const;
-
+    size_t getM() const noexcept;
+    size_t getN() const noexcept;
+   
     Matrix<T> operator * (T value) const;
     Matrix<T> operator / (T value) const;
 
@@ -44,11 +44,11 @@ class Matrix : public MathVector<MathVector<T>> {
     Matrix<T>& operator=(const Matrix<T>& other);
 };
 template <class T>
-size_t Matrix<T>::getM() const {
+size_t Matrix<T>::getM() const noexcept {
     return _M;
 }
 template <class T>
-size_t Matrix<T>::getN() const {
+size_t Matrix<T>::getN() const noexcept {
     return _N;
 }
 template <class T>
@@ -95,9 +95,7 @@ Matrix<T> Matrix<T>::operator / (T value) const {
 }
 template <class T>
 Matrix<T>& Matrix<T>::operator *= (T value) {
-    for (size_t i = 0; i < _M; ++i) {
-        (*this)[i] *= value;
-    }
+    (*this) = (*this) * value;
     return *this;
 }
 template <class T>
@@ -105,9 +103,7 @@ Matrix<T>& Matrix<T>::operator /= (T value) {
     if (value == 0) {
         throw std::logic_error("Division by zero!");
     }
-    for (size_t i = 0; i < _M; ++i) {
-            (*this)[i] /= value;
-        }
+    (*this) = (*this) / value;
     return *this;
 }
 template <class T>
@@ -177,11 +173,11 @@ Matrix<T>& Matrix<T>::operator -= (const Matrix<T>& other_matrix) {
 }
 template <class T>
 Matrix<T>& Matrix<T>::operator=(const Matrix<T>& other) {
-    (if this != &other) {
-    MathVector<MathVector<T>>::operator=(other);
-    _M = other._M;
-    _N = other._N;
-}
+    if (this != &other) {
+        MathVector<MathVector<T>>::operator=(other);
+        _M = other._M;
+        _N = other._N;
+    }
     return *this;
 }
 template <class U>

From 63027f715b6d5b1ca6326feb65fe4241b7865ce9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Mon, 20 Oct 2025 11:47:32 +0300
Subject: [PATCH 095/109] =?UTF-8?q?=D0=A3=D0=B1=D1=80=D0=B0=D0=BD=D1=8B=20?=
 =?UTF-8?q?=D0=BD=D0=B5=D0=BB=D0=BE=D0=B3=D0=B8=D1=87=D0=BD=D1=8B=D0=B5=20?=
 =?UTF-8?q?=D1=82=D0=B5=D1=81=D1=82=D1=8B?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 tests/test_triangle_matrix.cpp | 66 ++--------------------------------
 1 file changed, 2 insertions(+), 64 deletions(-)

diff --git a/tests/test_triangle_matrix.cpp b/tests/test_triangle_matrix.cpp
index 560a8c4b..1ac9f828 100644
--- a/tests/test_triangle_matrix.cpp
+++ b/tests/test_triangle_matrix.cpp
@@ -52,40 +52,7 @@ TEST(TestTriangleMatrixLib, tr_matrix_operator_assignment) {
     // Assert
     EXPECT_EQ(matrix1, matrix2);
 }
-TEST(TestTriangleMatrixLib, tr_matrix_add_value) {
-    // Arrange
-    size_t size = 3;
-    int data[6] = { 1, 2, 3, 4, 5, 6 };
-    int value = 10;
-    TriangleMatrix<int> matrix(data, size);
-    TriangleMatrix<int> result(size);
-    //Act
-    result = matrix + value;
-    // Assert
-    EXPECT_EQ(result.at(0).at(0), 11);
-    EXPECT_EQ(result.at(0).at(1), 12);
-    EXPECT_EQ(result.at(0).at(2), 13);
-    EXPECT_EQ(result.at(1).at(1), 14);
-    EXPECT_EQ(result.at(1).at(2), 15);
-    EXPECT_EQ(result.at(2).at(2), 16);
-}
-TEST(TestTriangleMatrixLib, tr_matrix_sub_value) {
-    // Arrange
-    size_t size = 3;
-    int data[6] = { 1, 2, 3, 4, 5, 6 };
-    int value = 1;
-    TriangleMatrix<int> matrix(data, size);
-    TriangleMatrix<int> result(size);
-    //Act
-    result = matrix - value;
-    // Assert
-    EXPECT_EQ(result.at(0).at(0), 0);
-    EXPECT_EQ(result.at(0).at(1), 1);
-    EXPECT_EQ(result.at(0).at(2), 2);
-    EXPECT_EQ(result.at(1).at(1), 3);
-    EXPECT_EQ(result.at(1).at(2), 4);
-    EXPECT_EQ(result.at(2).at(2), 5);
-}
+
 TEST(TestTriangleMatrixLib, tr_matrix_mult_value) {
     // Arrange
     size_t size = 3;
@@ -129,36 +96,7 @@ TEST(TestTriangleMatrixLib, tr_matrix_div_value_with_exception) {
     // Assert
     EXPECT_THROW(matrix / value, std::logic_error);
 }
-TEST(TestTriangleMatrixLib, tr_matrix_add_assign_value) {
-    // Arrange & Act
-    int size = 3;
-    int data[6] = { 2, 2, 4, 4, 8, 6 };
-    int value = 2;
-    TriangleMatrix<int> matrix(data, size);
-    matrix += value;
-    // Assert
-    EXPECT_EQ(matrix.at(0).at(0), 4);
-    EXPECT_EQ(matrix.at(0).at(1), 4);
-    EXPECT_EQ(matrix.at(0).at(2), 6);
-    EXPECT_EQ(matrix.at(1).at(1), 6);
-    EXPECT_EQ(matrix.at(1).at(2), 10);
-    EXPECT_EQ(matrix.at(2).at(2), 8);
-}
-TEST(TestTriangleMatrixLib, tr_matrix_sub_assign_value) {
-    // Arrange & Act
-    size_t size = 3;
-    int data[6] = { 2, 2, 4, 4, 8, 6 };
-    int value = 2;
-    TriangleMatrix<int> matrix(data, size);
-    matrix -= value;
-    // Assert
-    EXPECT_EQ(matrix.at(0).at(0), 0);
-    EXPECT_EQ(matrix.at(0).at(1), 0);
-    EXPECT_EQ(matrix.at(0).at(2), 2);
-    EXPECT_EQ(matrix.at(1).at(1), 2);
-    EXPECT_EQ(matrix.at(1).at(2), 6);
-    EXPECT_EQ(matrix.at(2).at(2), 4);
-}
+
 TEST(TestTriangleMatrixLib, tr_matrix_mult_assign_value) {
     // Arrange & Act
     size_t size = 3;

From 4a82f5be7c0a25bd872f2dafb096c147da757676 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Mon, 20 Oct 2025 11:48:15 +0300
Subject: [PATCH 096/109] =?UTF-8?q?=D0=A3=D0=B1=D1=80=D0=B0=D0=BD=D1=8B=20?=
 =?UTF-8?q?=D0=BD=D0=B5=D0=BB=D0=BE=D0=B3=D0=B8=D1=87=D0=BD=D1=8B=D0=B5=20?=
 =?UTF-8?q?=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE=D1=80=D1=8B=20+=20?=
 =?UTF-8?q?=D0=B8=20-=20=D1=81=D0=BE=20=D1=81=D0=BA=D0=B0=D0=BB=D1=8F?=
 =?UTF-8?q?=D1=80=D0=BE=D0=BC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_triangle_matrix/triangle_matrix.h | 49 ++-------------------------
 1 file changed, 2 insertions(+), 47 deletions(-)

diff --git a/lib_triangle_matrix/triangle_matrix.h b/lib_triangle_matrix/triangle_matrix.h
index b24a2a09..c5cc277b 100644
--- a/lib_triangle_matrix/triangle_matrix.h
+++ b/lib_triangle_matrix/triangle_matrix.h
@@ -1,6 +1,5 @@
 #pragma once 
 #include "../lib_matrix/matrix.h"
-
 template <class T>
 class TriangleMatrix : public Matrix<T> {
 public:
@@ -9,19 +8,12 @@ class TriangleMatrix : public Matrix<T> {
     TriangleMatrix(T* data, size_t size);
     TriangleMatrix(const TriangleMatrix& other);
     ~TriangleMatrix();
-
-
-    size_t getSize() const {
+    size_t getSize() const noexcept {
         return this->_M;
     }
-
-    TriangleMatrix<T> operator + (T value) const;
-    TriangleMatrix<T> operator - (T value) const;
     TriangleMatrix<T> operator * (T value) const;
     TriangleMatrix<T> operator / (T value) const;
 
-    TriangleMatrix<T>& operator += (T value);
-    TriangleMatrix<T>& operator -= (T value);
     TriangleMatrix<T>& operator *= (T value);
     TriangleMatrix<T>& operator /= (T value);
 
@@ -68,26 +60,6 @@ TriangleMatrix<T>& TriangleMatrix<T>::operator= (const TriangleMatrix<T>& other)
     return *this;
 }
 template<class T>
-TriangleMatrix<T> TriangleMatrix<T>::operator + (T value) const {
-    TriangleMatrix<T> 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<class T>
-TriangleMatrix<T> TriangleMatrix<T>::operator - (T value) const {
-    TriangleMatrix<T> 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<class T>
 TriangleMatrix<T> TriangleMatrix<T>::operator * (T value) const {
     TriangleMatrix<T> result(this->getSize());
     for (size_t i = 0; i < result.getSize(); ++i) {
@@ -110,24 +82,7 @@ TriangleMatrix<T> TriangleMatrix<T>::operator / (T value) const {
     }
     return result;
 }
-template<class T>
-TriangleMatrix<T>& TriangleMatrix<T>::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<class T>
-TriangleMatrix<T>& TriangleMatrix<T>::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<class T>
 TriangleMatrix<T>& TriangleMatrix<T>::operator *= (T value) {
     for (size_t i = 0; i < this->getSize(); ++i) {

From 0d60e2edbb8d45a3f0c0017dc21088da6135f8c8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Mon, 20 Oct 2025 22:01:05 +0300
Subject: [PATCH 097/109] =?UTF-8?q?=D0=98=D1=81=D0=BF=D1=80=D0=B0=D0=B2?=
 =?UTF-8?q?=D0=BB=D0=B5=D0=BD=D1=8B=20=D1=82=D0=B5=D1=81=D1=82=D1=8B=20?=
 =?UTF-8?q?=D0=BD=D0=B0=20=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE=D1=80?=
 =?UTF-8?q?=D1=8B=20=D0=B2=20=D1=81=D0=B2=D1=8F=D0=B7=D0=B8=20=D1=81=20?=
 =?UTF-8?q?=D0=BE=D0=BF=D1=82=D0=B8=D0=BC=D0=B8=D0=B7=D0=B0=D1=86=D0=B8?=
 =?UTF-8?q?=D0=B5=D0=B9=20=D0=B8=D1=85=20=D1=80=D0=B5=D0=B0=D0=BB=D0=B8?=
 =?UTF-8?q?=D0=B7=D0=B0=D1=86=D0=B8=D0=B8?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 tests/test_triangle_matrix.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/test_triangle_matrix.cpp b/tests/test_triangle_matrix.cpp
index 1ac9f828..8c6bd8ea 100644
--- a/tests/test_triangle_matrix.cpp
+++ b/tests/test_triangle_matrix.cpp
@@ -59,7 +59,7 @@ TEST(TestTriangleMatrixLib, tr_matrix_mult_value) {
     int data[6] = { 1, 2, 3, 4, 5, 6 };
     int value = 10;
     TriangleMatrix<int> matrix(data, size);
-    TriangleMatrix<int> result(size);
+    Matrix<int> result(size);
     //Act
     result = matrix * value;
     // Assert
@@ -76,7 +76,7 @@ TEST(TestTriangleMatrixLib, tr_matrix_div_value) {
     int data[6] = { 2, 2, 4, 4, 8, 6 };
     int value = 2;
     TriangleMatrix<int> matrix(data, size);
-    TriangleMatrix<int> result(size);
+    Matrix<int> result(size);
     //Act
     result = matrix / value;
     // Assert

From 47fa082fe37fba181cf3ac3938300e2485f4669a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Mon, 20 Oct 2025 22:02:52 +0300
Subject: [PATCH 098/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=20=D0=BA=D0=BE=D0=BD=D1=81=D1=82=D1=80=D1=83=D0=BA?=
 =?UTF-8?q?=D1=82=D0=BE=D1=80,=20=D0=BF=D1=80=D0=B8=D0=BD=D0=B8=D0=BC?=
 =?UTF-8?q?=D0=B0=D1=8E=D1=89=D0=B8=D0=B9=20=D1=82=D1=80=D0=B5=D1=83=D0=B3?=
 =?UTF-8?q?=D0=BE=D0=BB=D1=8C=D0=BD=D1=83=D1=8E=20=D0=BC=D0=B0=D1=82=D1=80?=
 =?UTF-8?q?=D0=B8=D1=86=D1=83=20=D0=B4=D0=BB=D1=8F=20=D0=BE=D0=BF=D1=82?=
 =?UTF-8?q?=D0=B8=D0=BC=D0=B8=D0=B7=D0=B0=D1=86=D0=B8=D0=B8=20=D0=BE=D0=BF?=
 =?UTF-8?q?=D0=B5=D1=80=D0=B0=D1=82=D0=BE=D1=80=D0=BE=D0=B2=20=D0=B2=20?=
 =?UTF-8?q?=D0=BA=D0=BB=D0=B0=D1=81=D1=81=D0=B5=20TriangleMatrix?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_matrix/matrix.h | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/lib_matrix/matrix.h b/lib_matrix/matrix.h
index a6b94ac5..5d64f9f9 100644
--- a/lib_matrix/matrix.h
+++ b/lib_matrix/matrix.h
@@ -1,6 +1,8 @@
 #pragma once
 #include <stdexcept>
 #include "../lib_math_vector/math_vector.h"
+template <class T> class TriangleMatrix;
+
 template <class T>
 class Matrix : public MathVector<MathVector<T>> {
 protected:
@@ -19,6 +21,7 @@ class Matrix : public MathVector<MathVector<T>> {
     Matrix();
     Matrix(size_t M, size_t N);
     Matrix(T* data, size_t M, size_t N);
+    Matrix(const TriangleMatrix<T>& triangle);
     Matrix(const Matrix& other);
     virtual ~Matrix();
     size_t getM() const noexcept;
@@ -70,6 +73,19 @@ Matrix<T>::Matrix(T* data, size_t M, size_t N) : MathVector<MathVector<T>>(M) {
     }
 }
 template <class T>
+Matrix<T>::Matrix(const TriangleMatrix<T>& triangle): Matrix<T>(triangle.getM(), triangle.getN()) {
+    for (size_t i = 0; i < triangle.getM(); ++i) {
+        for (size_t j = 0; j < triangle.getN(); ++j) {
+            if (i <= j) {
+                (*this)[i][j] = triangle[i][j];
+            }
+            else {
+                (*this)[i][j] = T();
+            }
+        }
+    }
+}
+template <class T>
 Matrix<T>::Matrix(const Matrix& other) :
     MathVector<MathVector<T>>(other), _M(other._M), _N(other._N) {}
 template <class T>

From e4ba0cdb4159ed95ab3a48d404607436a2937e8a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Mon, 20 Oct 2025 22:04:38 +0300
Subject: [PATCH 099/109] =?UTF-8?q?=D0=9F=D1=80=D0=B0=D0=B2=D0=BA=D0=B8=20?=
 =?UTF-8?q?=D0=BA=D0=BE=D0=BD=D1=81=D1=82=D1=80=D1=83=D0=BA=D1=82=D0=BE?=
 =?UTF-8?q?=D1=80=D0=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_matrix/matrix.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/lib_matrix/matrix.h b/lib_matrix/matrix.h
index 5d64f9f9..24d7294e 100644
--- a/lib_matrix/matrix.h
+++ b/lib_matrix/matrix.h
@@ -73,9 +73,9 @@ Matrix<T>::Matrix(T* data, size_t M, size_t N) : MathVector<MathVector<T>>(M) {
     }
 }
 template <class T>
-Matrix<T>::Matrix(const TriangleMatrix<T>& triangle): Matrix<T>(triangle.getM(), triangle.getN()) {
-    for (size_t i = 0; i < triangle.getM(); ++i) {
-        for (size_t j = 0; j < triangle.getN(); ++j) {
+Matrix<T>::Matrix(const TriangleMatrix<T>& triangle): Matrix<T>(triangle.getSize(), triangle.getSize()) {
+    for (size_t i = 0; i < triangle.getSize(); ++i) {
+        for (size_t j = 0; j < triangle.getSize(); ++j) {
             if (i <= j) {
                 (*this)[i][j] = triangle[i][j];
             }

From c6d6076db3b948df87dd60f9c651b10e26aedbaf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Tue, 25 Nov 2025 14:03:10 +0300
Subject: [PATCH 100/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=20cmake=20=D0=BB=D0=B8=D1=81=D1=82?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 CMakeLists.txt | 33 +++++++++++++++++++++++++++++----
 1 file changed, 29 insertions(+), 4 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 2ed05fc1..b6d905d4 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,33 @@ 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_list)
+add_subdirectory(lib_stack)
+add_subdirectory(lib_queue)
+add_subdirectory(lib_queue_on_list)
+add_subdirectory(lib_stack_on_list)
+
+add_subdirectory(lib_point)
+add_subdirectory(lib_point3d)
+add_subdirectory(lib_circle)
+add_subdirectory(lib_sphere)
+
+
+add_subdirectory(lib_dsu)
+
+add_subdirectory(lib_doubly_linked_list)
+
+add_subdirectory(lib_algoritm)
+
+
+
+
 add_subdirectory(main)                # подключаем дополнительный CMakeLists.txt из подкаталога с именем main
 
 option(BTEST "build test?" ON)        # указываем подключаем ли google-тесты (ON или YES) или нет (OFF или NO)
@@ -23,6 +50,4 @@ if(BTEST)                             # если тесты подключены
     add_subdirectory("third_party/gtest" EXCLUDE_FROM_ALL)
     enable_testing()
     add_subdirectory(tests)
-endif()
-
-
+endif()
\ No newline at end of file

From a3f87de48d344cb9d4b5d49af6fd99d69a1a2276 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Tue, 25 Nov 2025 14:06:30 +0300
Subject: [PATCH 101/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=20cmake=20=D0=BB=D0=B8=D1=81=D1=82?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_vector/CMakeLists.txt | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 lib_vector/CMakeLists.txt

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

From 7f77b5f4c2be161df75491a06c50cdeed5303e3d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Tue, 25 Nov 2025 14:08:11 +0300
Subject: [PATCH 102/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=20cmake=20=D0=BB=D0=B8=D1=81=D1=82?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_triangle_matrix/CMakeLists.txt | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 lib_triangle_matrix/CMakeLists.txt

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

From 50d854455effc981e4fed57143ca0e7a5600b8c9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Tue, 25 Nov 2025 14:14:06 +0300
Subject: [PATCH 103/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=20.cpp=20=D1=84=D0=B0=D0=B9=D0=BB=20=D0=B8=20cmake?=
 =?UTF-8?q?=20=D0=BB=D0=B8=D1=81=D1=82?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_sphere/CMakeLists.txt | 2 ++
 lib_sphere/sphere.cpp     | 1 +
 2 files changed, 3 insertions(+)
 create mode 100644 lib_sphere/CMakeLists.txt
 create mode 100644 lib_sphere/sphere.cpp

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"

From bf0ae47d41bf674af31408e4bccaddfd5ce33ef1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Tue, 25 Nov 2025 14:17:23 +0300
Subject: [PATCH 104/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=20.cpp=20=D1=84=D0=B0=D0=B9=D0=BB?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_triangle_matrix/triangle_matrix.cpp | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 lib_triangle_matrix/triangle_matrix.cpp

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"

From 39d2d318ac8cd2382898e74b79118ab99a8e8b13 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Tue, 25 Nov 2025 14:22:21 +0300
Subject: [PATCH 105/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=20.cpp=20=D1=84=D0=B0=D0=B9=D0=BB=20=D0=B8=20cmake?=
 =?UTF-8?q?=20=D0=BB=D0=B8=D1=81=D1=82?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_point3d/CMakeLists.txt |  2 ++
 lib_point3d/point3d.cpp    | 10 ++++++++++
 2 files changed, 12 insertions(+)
 create mode 100644 lib_point3d/CMakeLists.txt
 create mode 100644 lib_point3d/point3d.cpp

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 <cmath>
+//
+//int Point3D::getDistanceTo(const Point3D& other) const {
+//    return static_cast<int>(std::round(std::sqrt(
+//        std::pow(other.getX() - _x, 2) +
+//        std::pow(other.getY() - _y, 2) +
+//        std::pow(other.getZ() - _z, 2)
+//    ))); 
+//}

From 0821e1ddb6fd9621dd3ac08c30107bf98b1f8eb1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Tue, 25 Nov 2025 14:23:15 +0300
Subject: [PATCH 106/109] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB?=
 =?UTF-8?q?=D0=B5=D0=BD=20.cpp=20=D1=84=D0=B0=D0=B9=D0=BB=20=D0=B8=20cmake?=
 =?UTF-8?q?=20=D0=BB=D0=B8=D1=81=D1=82?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_point/CMakeLists.txt | 1 +
 lib_point/point.cpp      | 8 ++++++++
 2 files changed, 9 insertions(+)
 create mode 100644 lib_point/CMakeLists.txt
 create mode 100644 lib_point/point.cpp

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 <cmath>
+//int Point::getDistanceTo(const Point& other) const {
+//    return static_cast<int>(std::round(std::sqrt(
+//        std::pow(other.getX() - _x, 2) 
+//        + std::pow(other.getY() - _y, 2
+//        ))));
+//}

From 72987874fd0e1ba04be76ede2deb697919a847cf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Sun, 30 Nov 2025 08:59:12 +0300
Subject: [PATCH 107/109] CMakeLists.txt

---
 CMakeLists.txt | 9 ---------
 1 file changed, 9 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index b6d905d4..4c972104 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -20,22 +20,13 @@ add_subdirectory(lib_math_vector)
 add_subdirectory(lib_matrix)
 add_subdirectory(lib_triangle_matrix)
 
-add_subdirectory(lib_list)
-add_subdirectory(lib_stack)
-add_subdirectory(lib_queue)
-add_subdirectory(lib_queue_on_list)
-add_subdirectory(lib_stack_on_list)
-
 add_subdirectory(lib_point)
 add_subdirectory(lib_point3d)
 add_subdirectory(lib_circle)
 add_subdirectory(lib_sphere)
 
-
 add_subdirectory(lib_dsu)
 
-add_subdirectory(lib_doubly_linked_list)
-
 add_subdirectory(lib_algoritm)
 
 

From 84f37dc0cc478fe40a1b9872a8f5a90970245ae6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Sun, 30 Nov 2025 09:01:09 +0300
Subject: [PATCH 108/109] lib_algoritm/CMakeLists.txt

---
 lib_algoritm/CMakeLists.txt | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 lib_algoritm/CMakeLists.txt

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

From 1482f61b07a0797e9ae8b8c84fe2cdef3d0e2a34 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=AE=D0=BB=D1=8F=20=D0=97=D0=B0=D0=B1=D1=8B=D1=82=D0=B8?=
 =?UTF-8?q?=D0=BD=D0=B0?= <user@mail.ru>
Date: Mon, 1 Dec 2025 16:34:05 +0300
Subject: [PATCH 109/109] =?UTF-8?q?Cmake=20=D0=BB=D0=B8=D1=81=D1=82=20?=
 =?UTF-8?q?=D0=B8=20=D1=83=D0=BF=D1=80=D0=BE=D1=89=D0=B5=D0=BD=D0=B0=20?=
 =?UTF-8?q?=D1=80=D0=B5=D0=B0=D0=BB=D0=B8=D0=B7=D0=B0=D1=86=D0=B8=D1=8F=20?=
 =?UTF-8?q?=D0=BE=D0=BF=D0=B5=D1=80=D0=B0=D1=82=D0=BE=D1=80=D0=BE=D0=B2=20?=
 =?UTF-8?q?=D0=BC=D0=B0=D1=82=D1=80=D0=B8=D1=86=D1=8B?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 lib_matrix/CMakeLists.txt |  1 +
 lib_matrix/matrix.h       | 59 +++++++++++++--------------------------
 2 files changed, 21 insertions(+), 39 deletions(-)
 create mode 100644 lib_matrix/CMakeLists.txt

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
index 24d7294e..60f865ff 100644
--- a/lib_matrix/matrix.h
+++ b/lib_matrix/matrix.h
@@ -21,7 +21,6 @@ class Matrix : public MathVector<MathVector<T>> {
     Matrix();
     Matrix(size_t M, size_t N);
     Matrix(T* data, size_t M, size_t N);
-    Matrix(const TriangleMatrix<T>& triangle);
     Matrix(const Matrix& other);
     virtual ~Matrix();
     size_t getM() const noexcept;
@@ -73,53 +72,39 @@ Matrix<T>::Matrix(T* data, size_t M, size_t N) : MathVector<MathVector<T>>(M) {
     }
 }
 template <class T>
-Matrix<T>::Matrix(const TriangleMatrix<T>& triangle): Matrix<T>(triangle.getSize(), triangle.getSize()) {
-    for (size_t i = 0; i < triangle.getSize(); ++i) {
-        for (size_t j = 0; j < triangle.getSize(); ++j) {
-            if (i <= j) {
-                (*this)[i][j] = triangle[i][j];
-            }
-            else {
-                (*this)[i][j] = T();
-            }
-        }
-    }
-}
-template <class T>
 Matrix<T>::Matrix(const Matrix& other) :
     MathVector<MathVector<T>>(other), _M(other._M), _N(other._N) {}
 template <class T>
 Matrix<T>::~Matrix() = default;
 template <class T>
 Matrix<T> Matrix<T>::operator * (T value) const {
-    Matrix result(_M, _N);
-    for (size_t i = 0; i < _M; ++i) {
-        result[i] = (*this)[i] * value;
-    }
-    return result;
+    return Matrix<T>(*this) *= value;
 }
 template <class T>
 Matrix<T> Matrix<T>::operator / (T value) const {
     if (value == 0) {
         throw std::logic_error("Division by zero!");
     }
-    Matrix result(_M, _N);
-    for (size_t i = 0; i < _M; ++i) {
-        result[i] = (*this)[i] / value;
-    }
-    return result;
+    return Matrix<T>(*this) /= value;
 }
 template <class T>
 Matrix<T>& Matrix<T>::operator *= (T value) {
-    (*this) = (*this) * value;
-    return *this;
+    template <class T>
+    Matrix<T>& Matrix<T>::operator *= (T value) {
+        for (size_t i = 0; i < _M; ++i) {
+            (*this)[i] *= value;
+        }
+        return *this;
+    }
 }
 template <class T>
 Matrix<T>& Matrix<T>::operator /= (T value) {
     if (value == 0) {
         throw std::logic_error("Division by zero!");
     }
-    (*this) = (*this) / value;
+    for (size_t i = 0; i < _M; ++i) {
+        (*this)[i] /= value;
+    }
     return *this;
 }
 template <class T>
@@ -127,22 +112,14 @@ Matrix<T> Matrix<T>::operator + (const Matrix<T>& other_matrix) const {
     if (_M != other_matrix.getM() || _N != other_matrix.getN()) {
         throw std::logic_error("The matrices have different sizes!");
     }
-    Matrix<T> result(_M, _N);
-    for (size_t i = 0; i < _M; ++i) {
-        result[i] = (*this)[i] + other_matrix[i];
-    }
-    return result;
+    return Matrix<T>(*this) += other_matrix;
 }
 template <class T>
 Matrix<T> Matrix<T>::operator - (const Matrix<T>& other_matrix) const {
     if (_M != other_matrix.getM() || _N != other_matrix.getN()) {
         throw std::logic_error("The matrices have different sizes!");
     }
-    Matrix<T> result(_M, _N);
-    for (size_t i = 0; i < _M; ++i) {
-        result[i] = (*this)[i] - other_matrix[i];
-    }
-    return result;
+    return Matrix<T>(*this) -= other_matrix;
 }
 template <class T>
 Matrix<T> Matrix<T>::operator * (const Matrix<T>& other_matrix) const {
@@ -176,7 +153,9 @@ Matrix<T>& Matrix<T>::operator += (const Matrix<T>& other_matrix) {
     if (_M != other_matrix.getM() || _N != other_matrix.getN()) {
         throw std::logic_error("The matrices have different sizes!");
     }
-    (*this) = (*this) + other_matrix;
+    for (size_t i = 0; i < _M; ++i) {
+        (*this)[i] += other_matrix[i];
+    }
     return *this;
 }
 template <class T>
@@ -184,7 +163,9 @@ Matrix<T>& Matrix<T>::operator -= (const Matrix<T>& other_matrix) {
     if (_M != other_matrix.getM() || _N != other_matrix.getN()) {
         throw std::logic_error("The matrices have different sizes!");
     }
-    (*this) = (*this) - other_matrix;
+    for (size_t i = 0; i < _M; ++i) {
+        (*this)[i] -= other_matrix[i];
+    }
     return *this;
 }
 template <class T>