lab3.cpp

void complete_pivoting(vector<vector<double>> matrix) {
    cout << "Complete pivoting method" << endl << matrix << endl;

    const int matrix_size = matrix.size();
    const int matrix_size_minus_one = matrix_size - 1;

    int columns[matrix_size];
    vector<vector<double>> modified(matrix_size);

    for (int k = 0; k < matrix_size_minus_one; k++) {
        const int matrix_size_minus_k = matrix_size - k;
        const int matrix_size_minus_k_minus_one = matrix_size_minus_k - 1;
        const int matrix_size_minus_k_plus_one = matrix_size_minus_k + 1;
        const int current_matrix_size = matrix.size();

        int p = 0, q = 0;

        double a = matrix[0][0];
        for (int i = 0; i < current_matrix_size; i++) {
            for (int j = 0; j < current_matrix_size; j++) {
                if (fabs(matrix[i][j]) > fabs(a)) {
                    a = matrix[i][j];
                    p = i;
                    q = j;
                }
            }
        }
        double one_div_a = 1.0 / a;
        for (int i = 0; i < matrix_size_minus_k; i++) {
            if (i == p) continue;

            double matrix_size = -matrix[i][q] * one_div_a;
            for (int j = 0; j < matrix_size_minus_k_plus_one; j++) {
                matrix[i][j] += matrix[p][j] * matrix_size;
            }
        }

        columns[matrix_size_minus_k_minus_one] = q;
        modified[matrix_size_minus_k_minus_one] = matrix[p];

        matrix.erase(matrix.begin() + p);

        for (int i = 0; i < matrix.size(); i++) {
            matrix[i].erase(matrix[i].begin() + q);
        }
    }

    columns[0] = 0;
    modified[0] = matrix[0];

    int counter[4] {0}, cols[4];
    for (int i = modified.size() - 1; i >= 0; i--) {
        cols[i] = counter[columns[i]]++ + columns[i];
    }

    double x[matrix_size];
    for (int i = 0; i < matrix_size; i++) {
        double s = 0;
        for (int j = 0, index = 0; j < modified[i].size() - 1; j++, index++) {
            if (j == columns[i]) continue;
            s += x[cols[index]] * modified[i][j];
        }
        x[cols[i]] = (modified[i][modified[i].size() - 1] - s) / modified[i][columns[i]];
    }

    for (int i = 0; i < 4; i++) {
        cout << "x" << (i + 1) << " = " << x[i]<< endl;
    }
}