Matrix.cpp

#include "Matrix.hpp"
#include <stdexcept>
#include <iomanip>
#include <iostream>
#include <sstream>
// Конструктор
Matrix::Matrix(int size) : N(size) {
    allocateMemory();
}

// Конструктор копирования
Matrix::Matrix(const Matrix& other) : N(other.N) {
    allocateMemory();
    copyDataFrom(other);
}

// Деструктор
Matrix::~Matrix() {
    deallocateMemory();
}

// Выделение памяти
void Matrix::allocateMemory() {
    data = new double*[N];
    for (int i = 0; i < N; ++i) {
        data[i] = new double[N];
        for (int j = 0; j < N; ++j) {
            data[i][j] = 0;
        }
    }
}

// Освобождение памяти
void Matrix::deallocateMemory() {
    for (int i = 0; i < N; ++i) {
        delete[] data[i];
    }
    delete[] data;
}

// Копирование данных
void Matrix::copyDataFrom(const Matrix& other) {
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            data[i][j] = other.data[i][j];
        }
    }
}

// Оператор присваивания
Matrix& Matrix::operator=(const Matrix& other) {
    if (this != &other) {
        deallocateMemory();
        N = other.N;
        allocateMemory();
        copyDataFrom(other);
    }
    return *this;
}

// Доступ к элементам
double& Matrix::operator()(int i, int j) {
    if (i >= N || j >= N || i < 0 || j < 0)
        throw std::out_of_range("Index out of bounds");
    return data[i][j];
}

const double& Matrix::operator()(int i, int j) const {
    if (i >= N || j >= N || i < 0 || j < 0)
        throw std::out_of_range("Index out of bounds");
    return data[i][j];
}

// Арифметические операции
Matrix Matrix::operator+(const Matrix& other) const {
    if (N != other.N)
        throw std::invalid_argument("Matrix sizes do not match");

    Matrix result(N);
    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < N; ++j) {
            result(i, j) = (*this)(i, j) + other(i, j);
        }
    }
    return result;
}

Matrix& Matrix::operator+=(const Matrix& other) {
    *this = *this + other;
    return *this;
}

Matrix Matrix::operator*(const Matrix& other) const {
    if (N != other.N)
        throw std::invalid_argument("Matrix sizes do not match");

    Matrix result(N);
    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < N; ++j) {
            result(i, j) = 0;
            for (int k = 0; k < N; ++k) {
                result(i, j) += (*this)(i, k) * other(k, j);
            }
        }
    }
    return result;
}

// Операции сравнения
bool Matrix::operator==(const Matrix& other) const {
    if (N != other.N)
        return false;
    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < N; ++j) {
            if (data[i][j] != other.data[i][j])
                return false;
        }
    }
    return true;
}

bool Matrix::operator!=(const Matrix& other) const {
    return !(*this == other);
}

// Транспонирование
Matrix Matrix::transpose() const {
    Matrix result(N);
    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < N; ++j) {
            result(i, j) = (*this)(j, i);
        }
    }
    return result;
}

// Ввод и вывод

std::istream& operator>>(std::istream& is, Matrix& matrix) {
    int totalElements = matrix.N * matrix.N; // Общее количество элементов
    int elementCount = 0; // Счетчик введенных элементов

    // Создадим временный буфер для хранения всех введенных данных
    std::string inputLine;
    std::getline(is >> std::ws, inputLine); // Считываем всю строку с элементами, игнорируя начальные пробелы
    std::stringstream ss(inputLine); // Используем stringstream для обработки чисел

    for (int i = 0; i < matrix.N; ++i) {
        for (int j = 0; j < matrix.N; ++j) {
            if (!(ss >> matrix(i, j))) { // Попытка ввести элемент
                throw std::runtime_error("Error: Invalid input. Please enter numeric values.");
            }
            elementCount++; // Увеличиваем счетчик при успешном вводе
        }
    }

    // Проверяем, что после ввода всех нужных элементов не осталось лишних
    double extra;
    if (ss >> extra) { // Если после чтения всех элементов есть еще данные, это ошибка
        throw std::runtime_error("Error: Too many elements entered.");
    }

    if (elementCount != totalElements) {
        throw std::runtime_error("Error: Incorrect number of elements entered.");
    }

    return is;
}



std::ostream& operator<<(std::ostream& out, const Matrix& matrix) {
    for (int i = 0; i < matrix.N; ++i) {
        for (int j = 0; j < matrix.N; ++j) {
            out << std::setw(10) << matrix(i, j) << " ";
        }
        out << std::endl;
    }
    return out;
}

// Вычисление определителя (рекурсивно)
double Matrix::determinant() const {
    if (N == 1) return data[0][0];
    if (N == 2) return data[0][0] * data[1][1] - data[0][1] * data[1][0];

    double det = 0;
    for (int p = 0; p < N; ++p) {
        Matrix subMatrix(N - 1);
        for (int i = 1; i < N; i++) {
            int sub_j = 0;
            for (int j = 0; j < N; j++) {
                if (j == p) continue;
                subMatrix(i - 1, sub_j) = data[i][j];
                sub_j++;
            }
        }
        det += data[0][p] * (p % 2 == 0 ? 1 : -1) * subMatrix.determinant();
    }
    return det;
}