#include <iostream>
#include <stdlib.h>
#include <fstream>

using namespace std;

class macierze {
private:
    unsigned int w, k;
    float** a;
    bool sztuczna;
public:
    macierze (unsigned int, unsigned int);
    ~macierze() {
        delete[] a[0];
        delete[] a;
    }

    macierze& operator+(macierze&);
    macierze& operator-(macierze&);
    macierze& operator*(macierze&);
    macierze& operator=(macierze&);

    macierze& operator*(float f); //mnozenie przez skalar z prawej strony

    friend ostream& operator<<(ostream&, macierze&);
    friend istream& operator>>(istream&, macierze&);

    macierze& odwracanie();
};

macierze::macierze(unsigned int wi, unsigned int k) {
    w=wi;
    this->k = k; // <=> (*this).k = k;
    a = new float* [w]; // 'a' to tablica wskaznikow do poczatkow kolejnych wierszy
    float* tab = new float[w*k]; // 'tab' to wlasciwa tablica elementow macierzy
    for (int i=0; i<w; ++i)
        a[i] = tab+i*k; // przypisanie elementom 'a' adresow poczatkow kolejnych wierszy;
                        // arytmetyka wskaznikowa
    sztuczna = false;
}

macierze& macierze::operator+(macierze& R) {
    if (k==R.k && w==R.w) {
        macierze *m = new macierze (w, k);
        m->sztuczna = true;
        for (int i=0; i<w*k; ++i)
            m->a[0][i] = a[0][i]+R.a[0][i];
        if (R.sztuczna)
            delete &R;
        if (sztuczna)
            delete this;
        return *m;
    }
}

macierze& macierze::operator*(macierze& R) {
    if (k==R.w) {
        macierze* XD = new macierze(w, R.k);
        XD->sztuczna = true; //o tym pan Mikolajczyk zapomnial albo kazal to dopisac i tak
        for (int i=0; i<XD->w*XD->k; ++i) { //krotsza wersja na 2 petle
            XD->a[0][i]=0;
            for (int j=0; j<k; ++j)
                XD->a[0][i] += a[i/XD->k][j]*R.a[j][i%XD->k];
        }
        if (R.sztuczna)
            delete &R;
        if (sztuczna)
            delete this;
        return *XD;
    }
}
macierze& macierze::operator=(macierze& wzor) {
    if (w==wzor.w && this->k==wzor.k) // w == this->w, this->k == k
        for (int i=0; i<w; ++i)
            for (int j=0; j<k; ++j)
                a[i][j]=wzor.a[i][j]; // a[i][j] == this->a[i][j]
    else
        cout << "Blad!\n";
    return *this; // automatycznie sciaga referencje ze zwracanej wartosci
}

macierze& macierze::operator*(float f) {
    macierze* m = new macierze (w, k);
    m->sztuczna = true;
    for (int i=0; i<w; ++i)
        for (int j=0; j<k; ++j)
            m->a[i][j] = a[i][j]*f;
    if (sztuczna)
        delete this;
    return *m;

}
macierze& operator*(float f, macierze& m) {
    return m*f; //mnozenie przez skalar jest przemienne, wiec f*m == m*f, natomiast drugi
                //przypadek mamy juz zalatwiony, wiec mozna AZ TAKIE NAIWNE kopiuj wklej zrobic
}

macierze& macierze::operator-(macierze& R) { //definicja ponizej mnozenia przez skalar
    return (*this)+((-1)*R);
}

ostream& operator<<(ostream& out, macierze& ktora) {
    for (int i=0; i<ktora.w; ++i) {
        for (int j=0; j<ktora.k; ++j)
            out << ktora.a[i][j] << '\t'; // tabulacja, ktora zrobi ladne, rowne wciecia
        out << endl;
    }
    if (ktora.sztuczna) //kasowanie sztucznych macierzy po wypisaniu
        delete &ktora;
    return out;
}
istream& operator>>(istream& in, macierze& ktora) {
    for (int i=0; i<ktora.w; ++i)
        for (int j=0; j<ktora.k; ++j) {
//            cout << "Element [" << i << "][" << j << "] == "; // prosta zacheta dla naszego przykladu,
                                                              // scisle i czysto teoretycznie niepotrzebna
            in >> ktora.a[i][j];
        }
    return in;
}

macierze& macierze::odwracanie() {
    if (w==k){
        macierze lol (w, 2*k);
        for (int i=0; i<w; ++i)
            for (int j=0; j<k; ++j) {
                lol.a[i][j] = a[i][j];
                lol.a[i][j+k] = (i==j) ? 1 : 0;
            }
        for (int i=0; i<w; ++i) {
            if (lol.a[i][i] == 0) {
                int j=i;
                while (++j<w && lol.a[j][i] == 0);
                if (j==w) {
                    cout << "Macierz nieodwracalna!";
                    return *this;
                }
                else
                    for (int m=i; m<lol.k; ++m)
                        swap(lol.a[i][m], lol.a[j][m]);
            }
            float wsp=lol.a[i][i];
            for (int m=i; m<lol.k; ++m)
                lol.a[i][m] /= wsp;
            for (int z=0; z<i; ++z)
                if (lol.a[z][i]) {
                    float wp = lol.a[z][i];
                    for (int g=i; g<lol.k; ++g)
                        lol.a[z][g] -= wp*lol.a[i][g];
                }
            for (int z=i+1; z<lol.w; ++z)
                if (lol.a[z][i])
                    for (int g=i; g<lol.k; ++g)
                        lol.a[z][g] -= lol[z][g]*lol.a[i][g];
        }
        macierze *Wynik = new macierze (w, k);
        for (int i=0; i<w; ++i)
            for (int j=0; j<k; ++j)
                Wyinik->a[i][j] = lol.a[i][k+j];
        Wynik->sztuczna = true;
        if (sztuczna)
            delete this;
        return *Wynik;
    }
    else {
        cout << "Macierz niekwadratowa!";
        return *this;
    }
}

int main() {
    ifstream is ("pliczek.txt");
    macierze n (3,4);
    macierze m (3,4);
    macierze p (4,3);
    float f;
    is >> n;
    is >> m;
    is >> p;
//    cout<<"Podaj skalar:";
    is >> f;
    cout << n << endl;
    cout << m << endl;
    cout << p << endl;
    cout << "Suma macierzy" << endl;;
    cout << n+m << endl;
    cout << "Roznica macierzy" << endl;;
    cout << n-m << endl;
    cout << "Mnozenie macierzy przez skalar f*macierz1*f" << endl;
    cout << f*n*f;
    cout << "Mnozenie macierzy1*macierz3" << endl;
    cout << n*p;
    return 0;
}