Gauss_Ty_kurwo

#include <iostream>
#include <iomanip>
#include <cmath>
#include <algorithm>
#define P 1E-12 //przyblizenie 0
using std::cout;
using std::cin;
using std::endl;

//tab[ilosc wierszy][ilosc kolumn]

class matrix{
    double **main_matrix;
    double *result;
    int size=0;

    static bool is_null(double input)
    {
        return fabs(input) < P;
    }
    bool calculate_simply();
    void show_result();
    void swapc(int k1,int k2);


public:
    matrix(){
        cout <<"Podaj rozmiar macierzy: \n";
        cin >>size;
        if (size<0) {
            cout<<"nieprawidlowa wartosc \n";
            return;
        }
        main_matrix=new double* [size];//kolumny
        result=new double [size];
        for (int i = 0; i <= size ; ++i) {
            main_matrix[i]=new double [size+1]; //wiersze
        }
    }
    void initialize();
    void display();
    void gauss_simply();
    void gauss_max_el();
    void full_gauss();
};


int main() {
    matrix m1;
    m1.initialize();
    m1.display();
    //m1.gauss_simply(); - dziala
    //m1.gauss_max_el(); //dziala
    m1.full_gauss();
    m1.display();
    //delete &m1;
    return 0;
}

void matrix::initialize() {
    for (int i=0; i<size; i++)
    {
        cout<<endl<<"Rownanie "<<i+1<<": "<<endl;
        for (int j=0; j<=size; j++)
        {
            if (j<size)
            {
                if (j == 0) cout<<"  ";
                cout<<"x"<<j;
                cout<<" * ";
                cin>>main_matrix[i][j];
                if (j < size-1) cout<<"+ ";
            }
            if (j == size)
            {
                cout<<"     = ";
                cin>>main_matrix[i][j];
            }
        }
    }
    for(int i=0; i<size; i++)
    {
        result[i]=i;
    }
}

bool matrix::calculate_simply() {
        double m=0;
        for (int i = 0; i < size ; ++i) {
            if(main_matrix[i][i]==0)
                return false;
            for (int j = i+1; j <=size ; ++j) {
                m=main_matrix[j][i]/main_matrix[i][i];
                main_matrix[j][i]=0;
                for (int k = i+1; k <=size+1 ; ++k) {
                    main_matrix[j][k]-=m*main_matrix[i][k];
                }
            }
        }
        return true;
}

void matrix::gauss_simply() {
    if (!calculate_simply())
    {
        cout << "0 na przekatnej macierzy, macierz osobliwa. koncze program... \n";
    }
    else
    {
        show_result();
    }
}

void matrix::show_result() {
    double *results;
    int n=size-1;
    results=new double [n];//liczba wierszy
    cout <<main_matrix[size-1][size]<<endl;
    cout <<main_matrix[size-1][size-1]<<endl;
    if(main_matrix[n][n]!=0)
        results[n]=main_matrix[n][size]/main_matrix[n][n];
    else
        cout<<"Problem jest !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n\n\n\n\n";
    cout <<"wynik 1: "<<results[n]<<endl;
    for (int i = size-1; i >=0 ; --i) {
        double sum=0.0;
        for (int j = i+1; j <= size ; ++j) {
            sum+=main_matrix[i][j]*results[j];
        }
        if(!is_null(main_matrix[i][i]))
            results[i]=(main_matrix[i][size]-sum)/main_matrix[i][i];
    }
    cout<<endl<<"Rozwiazania"<<endl;
    for (int i=0; i<size; i++)
    {
        cout<<std::setw(11)<<"x"<<result[i];
    }
    //cout<<std::setw(11)<<"b";
    cout <<endl;
    for (int i=0; i<size; i++)
    {
        cout<<std::setw(12)<<results[i];
    }
    delete [] results;
}
void matrix ::gauss_max_el() {
    double temp=0;
    int position=0;
    for (int i = 0; i < size ; ++i) {
        if(fabs(main_matrix[i][0])>=temp) {
            temp = main_matrix[i][0];
            position = i;
        }
    }
    if (position!=0)
        std::swap(main_matrix[position],main_matrix[0]);
    gauss_simply();
}

void matrix::display() {
    cout<<endl<<"MACIERZ"<<endl;
    for (int i=0; i<size; i++)
    {
        cout<<std::setw(11)<<"x"<<result[i];
    }
    cout<<std::setw(11)<<"b";
    for (int i=0; i<size; i++)
    {
        cout<<endl;
        for (int j=0; j<=size; j++)
        {
            cout<<std::setw(12)<<main_matrix[i][j];
        }
    }
    cout<<endl<<endl;
}

void matrix::swapc(int k1,int k2) {
    double temp;
    for (int i=0; i<size; i++)
    {
        temp = main_matrix[i][k1];
        main_matrix[i][k1] = main_matrix[i][k2];
        main_matrix[i][k2] = temp;
    }
    temp=result[k1];
    result[k1]=result[k2];
    result[k2]=temp;
}

void matrix::full_gauss() {
    double maks=0;
    int kolumna=0,wiersz=0;
    for (int k=0; k<size-1; k++)
    {
        kolumna=k;
        wiersz=k;
        maks=fabs(main_matrix[k][k]);
        for (int j=k; j<size; j++)
        {
            for (int i=k; i<size; i++)
            {
                if (fabs(main_matrix[j][i]) > maks)
                {
                    maks=fabs(main_matrix[j][i]);
                    kolumna=i;
                    wiersz=j;
                }
            }
        }

        if (kolumna != k) swapc(kolumna, k);
        if (wiersz != k) {
            std::swap(main_matrix[wiersz],main_matrix[k]);
        }
        calculate_simply();
        show_result();

}
}