#define EPSILON 0.000001

#include <math.h>
#include <iostream>
#include <iomanip>
#include <stdio.h>
#include <fstream>

using namespace std;

class matrix {
private:
    int size;
    double **content;

public:
    //Конструкторы и деструктор
    matrix(int n = 1, double con = 0) {
        size = n;
        content = new double*[n];
        for (int i = 0; i < n; i++) content[i] = new double[n];
        if (!con) for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++)
                content[i][j] = 0;
        }
        else {
            for (int i = 0; i < n; i++) content[i][i] = con;
        }
    }

    matrix(const matrix& m) {
        size = m.size;
        content = new double*[size];
        for (int i = 0; i < size; i++) content[i] = new double[size];
        for (int i = 0; i < size; i++)
            for (int j = 0; j < size; j++) content[i][j] = m.content[i][j];
    }

    ~matrix() {
        for (int i = 0; i < size; i++)
            delete[] content[i];
        delete[] content;
    }

        //Общие методы
        void setCell(int i, int j, double num);
    void switchLines(int line1, int line2);
        double detUpperTriangular(int count);
        double norm();
        void print();

        //Методы для обычного метода Гаусса и нахождения обратной матрицы
        //Объединены для экономии времени работы программы
        int makeUpperTriangular(matrix& I, double *f); //Меняем также и единичную матрицу
        void finishInverseSolve(matrix &I, double *f); //из верхней треугольной
        void printGaussDetInverse(double *f);

        //Методы для метода Гаусса с выбором главного элемента
        int makeUpperTriangularChoose(double *f);
        void printGaussChoose(double *f);
        void solveChoose(double *f);
};

//Реализация методов
void matrix::setCell(int i, int j, double num) {
    content[i][j] = num;
}

void matrix::switchLines(int line1, int line2) {
    double *temp = new double[size];
    for (int i = 0; i < size; i++)  temp[i] = content[line1][i];
    for (int i = 0; i < size; i++)  content[line1][i] = content[line2][i];
    for (int i = 0; i < size; i++)  content[line2][i] = temp[i];
    delete[] temp;
}

double matrix::detUpperTriangular(int count) {
    double res = 1;
    for (int i = 0; i < size; i++) {
        res *= content[i][i];
    }
    if(res == 0.0 || res == -0.0) return 0.0;
    if(count % 2 == 0) return res;
    return -res;
}

int matrix::makeUpperTriangular(matrix& I, double *f) {
    int count = 0;
    double temp = 0;
    for(int k = 0; k < size - 1; k++) {
        if (content[k][k] == 0) {
            int l = k;
            while (content[l][k] == 0) {
                if (l == size - 1) break;
                l++;
            }
            if((content[l][k] == 0) && (l = size - 1)) continue;
            this->switchLines(k, l);
            I.switchLines(k, l);
            count++;
            temp = f[k];
            f[k] = f[l];
            f[l] = temp;
        }

        for(int i = k + 1; i < size; i++) {
            temp = content[i][k] / content[k][k];
            for(int j = k; j < size; j++) {
                content[i][j] -= temp * content[k][j];
                I.content[i][j] -= temp * I.content[k][j];
            }
            f[i] -= temp * f[k];
        }
    }
    return count;
}

double matrix::norm() {
    double res = 0;
    for(int i = 0; i < size; i++)
        for(int j = 0; j < size; j++) {
            res += content[i][j] * content[i][j];
        }
    return sqrt(res);
}

void matrix::finishInverseSolve(matrix& I, double *f) {
    for(int k = size - 1; k >= 0; k--) {
        f[k] /= content[k][k];
        I.content[k][k] /= content[k][k];
        /* Здесь должно быть
         * content[k][k] = 1.0;
         * но для экономии времени не будем этого делать
         */
        for(int i = k - 1; i >= 0; i--) {
            I.content[i][k] -= content[i][k] * I.content[k][k];
            f[i] -= f[k] * content[i][k];
            /* Здесь должно быть
             * content[i][k] = 0.0;
             * но для экономии времени не будем этого делать
             */
        }
    }
}

void matrix::printGaussDetInverse(double *f) {
    matrix I(size, 1);
    double det;

    if((det = this->detUpperTriangular(this->makeUpperTriangular(I, f))) < EPSILON) {
        cout << "Матрица не является обратимой" << endl;
        cout << "Бесконечное множество решений" << endl;
        return;
    }
    else {
        cout << "Определитель матрицы: " << det << endl << endl;
    }

    this->finishInverseSolve(I, f);
    I.print();
    cout << endl;

    for(int i = 0; i < size; i++) {
        cout << 'X' << i + 1 << "= " << f[i] << endl;
    }
    cout << endl;
}

int matrix::makeUpperTriangularChoose(double *f) {
    int count = 0;
    double temp = 0;
    for(int k = 0; k < size - 1; k++) {
        double max = content[k][k];
        int l = k;

        for(int i = k + 1; i < size; i++) {
            if(content[i][k] > max) {
                max = content[i][k];
                l = i;
            }
        }

        if(max == 0) continue;
        if(l != k) {
            this->switchLines(k, l);
            count++;
            temp = f[k];
            f[k] = f[l];
            f[l] = temp;
        }

        for(int i = k + 1; i < size; i++) {
            temp = content[i][k] / content[k][k];
            for(int j = k; j < size; j++) {
                content[i][j] -= temp * content[k][j];
            }
            f[i] -= temp * f[k];
        }
    }
    return count;
}

void matrix::solveChoose(double *f) {
    for(int k = size - 1; k >= 0; k--) {
        f[k] /= content[k][k];
        /* Здесь должно быть
         * content[k][k] = 1.0;
         * но для экономии времени не будем этого делать
         */
        for(int i = k - 1; i >= 0; i--) {
            f[i] -= f[k] * content[i][k];
            /* Здесь должно быть
             * content[i][k] = 0.0;
             * но для экономии времени не будем этого делать
             */
        }
    }
}

void matrix::printGaussChoose(double *f) {
    if((this->detUpperTriangular(this->makeUpperTriangularChoose(f))) < EPSILON) {
        cout << "Бесконечное множество решений" << endl;
        return;
    }

    this->solveChoose(f);

    for(int i = 0; i < size; i++) {
        cout << 'X' << i + 1 << "= " << f[i] << endl;
    }
}

void matrix::print() {
    for(int i = 0; i < size; i++) {
        for(int j = 0; j < size - 1; j++) {
            cout << content[i][j] << ' ';
        }
        cout << content[i][size - 1] << endl;
    }
}

int main(int argc, char **argv) {
    int n;
    int m = 8;
    sscanf(argv[1], "%d", &n);

    matrix A(n, n);
    double *f = new double[n];
    double *f1 = new double[n];

    cout << setprecision(2) << fixed;

    if(argc < 3) { //Ввод формул
        for(int i = 0; i < n; i++) {
            for(int j = 0; j < n; j++) {
                if(i != j) {
                    A.setCell(i, j, ((double)(i + j + 2)/(m + n)));
                }
                else {
                    A.setCell(i, j, (double)(n + (double)m * m + (double)(j + 1) / m + (double)(i + 1) / n));
                }
            }
            f[i] = 200 + 50 * (i + 1);
            f1[i] = f[i];
        }
    }
    else { //Ввод из файла
        ifstream input;
        input.open(argv[2]);
        double temp;
        for(int i = 0; i < n; i++) {
            for(int j = 0; j < n; j++) {
                input >> temp;
                A.setCell(i, j, temp);
            }
            input >> temp;
            f[i] = temp;
            f1[i] = f[i];
        }
        input.close();
    }

    matrix B(A);

    A.printGaussDetInverse(f);
    B.printGaussChoose(f1);

    delete[] f1;
    delete[] f;

    return 0;
}