Ошибка Debug assertion failed. Expression : vector subscript out of range С++. Приложения для счета матрицы 3-мя методами

Сначала выдало ошибку "inverseMatrix: идентификатор не найден" , переставил местами блоки кода: "// Функция для решения системы уравнений матричным методом" и "// 111" ,ошибка исчезла. Но появилась "Debug assertion failed. Expression : vector subscript out of range". Можно ли с этим что-либо сделать?

cpp.


#include <iostream>
#include <vector>
#include <iomanip>
#include <cmath>
#include "table.h" // Добавьте заголовок для библиотеки table

using namespace std;

// Функция для вычисления определителя матрицы
double determinant(const vector<vector<double>>& matrix) {
    int n = matrix.size();
    if (n == 1) {
        return matrix[0][0];
    }
    else if (n == 2) {
        return matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0];
    }
    else {
        double det = 0;
        for (int i = 0; i < n; i++) {
            vector<vector<double>> submatrix(n - 1, vector<double>(n - 1));
            for (int j = 1; j < n; j++) {
                for (int k = 0; k < n; k++) {
                    if (k != i) {
                        submatrix[j - 1][k < i ? k : k - 1] = matrix[j][k];
                    }
                }
            }
            det += pow(-1, i) * matrix[0][i] * determinant(submatrix);
        }
        return det;
    }
}

// Функция для решения системы уравнений методом Крамера
vector<double> solveByCramer(const vector<vector<double>>& A, const vector<double>& b) {
    int n = A.size();
    vector<double> x(n);
    double detA = determinant(A);
    if (abs(detA) < 1e-6) {
        throw runtime_error("Матрица вырождена. Решение не существует.");
    }
    for (int i = 0; i < n; i++) {
        vector<vector<double>> Ai(A);
        for (int j = 0; j < n; j++) {
            Ai[j][i] = b[j];
        }
        x[i] = determinant(Ai) / detA;
    }
    return x;
}

// Функция для решения системы уравнений методом Гаусса
vector<double> solveByGauss(vector<vector<double>> A, vector<double> b) {
    int n = A.size();
    vector<double> x(n);

    // Прямой ход метода Гаусса
    for (int i = 0; i < n; i++) {
        // Поиск ведущего элемента
        int pivotRow = i;
        for (int j = i + 1; j < n; j++) {
            if (abs(A[j][i]) > abs(A[pivotRow][i])) {
                pivotRow = j;
            }
        }
        // Перестановка строк, если необходимо
        if (pivotRow != i) {
            swap(A[i], A[pivotRow]);
            swap(b[i], b[pivotRow]);
        }

        // Нормализация строки
        double pivot = A[i][i];
        for (int j = i; j < n; j++) {
            A[i][j] /= pivot;
        }
        b[i] /= pivot;

        // Вычитание строки из остальных строк
        for (int j = i + 1; j < n; j++) {
            double factor = A[j][i];
            for (int k = i; k < n; k++) {
                A[j][k] -= factor * A[i][k];
            }
            b[j] -= factor * b[i];
        }
    }

    // Обратный ход метода Гаусса
    for (int i = n - 1; i >= 0; i--) {
        x[i] = b[i];
        for (int j = i + 1; j < n; j++) {
            x[i] -= A[i][j] * x[j];
        }
    }
    return x;
}

// 111
vector<vector<double>> inverseMatrix(const vector<vector<double>>& A) {
    int n = A.size();
    vector<vector<double>> invA(n, vector<double>(n));
    // Вычисление определителя матрицы
    double detA = determinant(A);
    if (abs(detA) < 1e-6) {
        return {}; // Возвращает пустую матрицу, если матрица вырождена
    }
    // Вычисление алгебраических дополнений
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            vector<vector<double>> submatrix(n - 1, vector<double>(n - 1));
            for (int k = 0; k < n; k++) {
                if (k != i) {
                    for (int l = 0; l < n; l++) {
                        if (l != j) {
                            submatrix[k < i ? k : k - 1][l < j ? l : l - 1] = A[k][l];
                        }
                    }
                }
            }
            invA[j][i] = pow(-1, i + j) * determinant(submatrix) / detA;
        }
    }
    return invA;
}


// Функция для решения системы уравнений матричным методом
vector<double> solveByMatrix(const vector<vector<double>>& A, const vector<double>& b) {
    int n = A.size();
    vector<double> x(n);
    // Вычисление обратной матрицы
    vector<vector<double>> invA = inverseMatrix(A);
    if (invA.empty()) {
        throw runtime_error("Матрица вырождена. Решение не существует.");
    }
    // Умножение обратной матрицы на вектор b
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            x[i] += invA[i][j] * b[j];
        }
    }
    return x;
}

// Функция для вывода матрицы
void printMatrix(const vector<vector<double>>& matrix) {
    int n = matrix.size();
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            cout << setw(8) << matrix[i][j] << " ";
        }
        cout << endl;
    }
}

// Функция для вывода вектора
void printVector(const vector<double>& vector) {
    int n = vector.size();
    for (int i = 0; i < n; i++) {
        cout << "x" << i + 1 << " = " << setw(8) << vector[i] << endl;
    }
}

int main() {
    setlocale(LC_ALL, "rus");
    int n;
    cout << "Введите размерность системы уравнений: ";
    cin >> n;

    vector<vector<double>> A(n, vector<double>(n));
    vector<double> b(n);

    cout << "Введите элементы матрицы A:" << endl;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            cin >> A[i][j];
        }
    }

    cout << "Введите элементы вектора b:" << endl;
    for (int i = 0; i < n; i++) {
        cin >> b[i];
    }

    cout << "Выберите метод решения:" << endl;
    cout << "1 - Метод Крамера" << endl;
    cout << "2 - Метод Гаусса" << endl;
    cout << "3 - Матричный метод" << endl;

    int choice;
    cin >> choice;

    vector<double> x;
    try {
        switch (choice) {
        case 1:
            x = solveByCramer(A, b);
            break;
        case 2:
            x = solveByGauss(A, b);
            break;
        case 3:
            x = solveByMatrix(A, b);
            break;
        default:
            throw runtime_error("Некорректный выбор метода.");
        }

        // Вывод результата в таблицу с помощью библиотеки table
        table t;
        t.add_column("Переменная", "Значение");
        for (int i = 0; i < n; i++) {
            t.add_row({ "x" + to_string(i + 1), to_string(x[i]) });
        }
        cout << t << endl;
    }
    catch (const runtime_error& e) {
        cerr << "Ошибка: " << e.what() << endl;
    }

    return 0;
}

h.

#ifndef TABLE_H
#define TABLE_H

#include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <iomanip>

using namespace std;

class table {
public:
    // Конструктор
    table();

    // Добавление столбца
    void add_column(const string& name, const string& align = "center");

    // Добавление строки
    void add_row(const vector<string>& row);

    // Вывод таблицы на консоль
    friend ostream& operator<<(ostream& os, const table& t);

private:
    vector<string> column_names; // Имена столбцов
    vector<vector<string>> rows; // Данные таблицы
    vector<string> alignments; // Выравнивание столбцов
};

// Конструктор
table::table() {
}

// Добавление столбца
void table::add_column(const string& name, const string& align) {
    column_names.push_back(name);
    alignments.push_back(align);
}

// Добавление строки
void table::add_row(const vector<string>& row) {
    rows.push_back(row);
}

// Вывод таблицы на консоль
ostream& operator<<(ostream& os, const table& t) {
    // Вычисление максимальной ширины каждого столбца
    vector<int> column_widths(t.column_names.size(), 0);
    for (size_t i = 0; i < t.column_names.size(); i++) {
        column_widths[i] = t.column_names[i].size();
    }
    for (const auto& row : t.rows) {
        for (size_t i = 0; i < row.size(); i++) {
            column_widths[i] = max(column_widths[i], static_cast<int>(row[i].size()));
        }
    }

    // Вывод заголовка таблицы
    os << "+";
    for (size_t i = 0; i < t.column_names.size(); i++) {
        os << string(column_widths[i] + 2, '-') << "+";
    }
    os << endl;
    os << "|";
    for (size_t i = 0; i < t.column_names.size(); i++) {
        string name = t.column_names[i];
        if (t.alignments[i] == "left") {
            os << " " << name << string(column_widths[i] - name.size() + 1, ' ') << "|";
        }
        else if (t.alignments[i] == "right") {
            os << string(column_widths[i] - name.size() + 1, ' ') << name << " |";
        }
        else {
            os << string((column_widths[i] - name.size()) / 2, ' ') << name
                << string((column_widths[i] - name.size() + 1) / 2, ' ') << "|";
        }
    }
    os << endl;
    os << "+";
    for (size_t i = 0; i < t.column_names.size(); i++) {
        os << string(column_widths[i] + 2, '-') << "+";
    }
    os << endl;

    // Вывод строк таблицы
    for (const auto& row : t.rows) {
        os << "|";
        for (size_t i = 0; i < row.size(); i++) {
            string value = row[i];
            if (t.alignments[i] == "left") {
                os << " " << value << string(column_widths[i] - value.size() + 1, ' ') << "|";
            }
            else if (t.alignments[i] == "right") {
                os << string(column_widths[i] - value.size() + 1, ' ') << value << " |";
            }
            else {
                os << string((column_widths[i] - value.size()) / 2, ' ') << value
                    << string((column_widths[i] - value.size() + 1) / 2, ' ') << "|";
            }
        }
        os << endl;
    }

    // Вывод нижней границы таблицы
    os << "+";
    for (size_t i = 0; i < t.column_names.size(); i++) {
        os << string(column_widths[i] + 2, '-') << "+";
    }
    os << endl;

    return os;
}

#endif // TABLE_H