#include <iostream>

using namespace std;


class wektor
{
    public:
        wektor(const int );
        virtual ~wektor();
        //void usun();
        void wpisz( );
        void wypisz();
        int wymiar();


    private:

        int k; // wymiar
        float *w;


};

#include "wektor.h"
#include <iostream>

 using namespace std;

wektor::wektor(const int n)
{
 int t=0;
k=n;
    new float [k];
    w= new float [k];

    for (int i=1; i<=k; i++)
    {
        w[i]=0;
    }
}

wektor::~wektor()
{

    delete w;
}

int wektor :: wymiar()
{
    return k;
}


void wektor :: wpisz()
{
    for(int i=1; i<=wymiar(); i++)
        cin>> w[i];

}

//a

#include "a.h"

#include <iostream>

using namespace std;

template <class T>

 A<T> :: A(const T& a, const T& b)
        {
            x=a;
            y=b;
        }


template <class T>
    A<T> :: A()
    {//konstruktor domyslny
       T x();
       T y();
    }

template <class T>
     A<T>:: ~A()
        {
            cout<<"Destruktor"<<endl;

        }


template <class T>

       A<T>:: A(const A& z)
        {
            x=z.x;
            y=z.y;
        }


template <class T>

ostream& operator << (ostream& wy,  A<T>& z)
{
    wy<<z.x<<","<<z.y<<endl;
    return wy;
}

//FUNKCJE ZESPOLONE

#include <iostream>
#include "zespolona.h"

using namespace std;

extern const Zespolona operator + ( Zespolona&, Zespolona&);
ostream& operator << (ostream& wy,Zespolona &z);
istream& operator>> (istream& we, Zespolona& z);
float max ( float A[3]);
extern void wpisywanie (Zespolona&, Zespolona &, Zespolona& );

//ZESPOLONE DEFINICJE

#include <iostream>
#include"funkcjezespolone.cpp"
#include"zespolona.h"
#include <stdarg.h>

using namespace std;



 const Zespolona operator + ( Zespolona&w, Zespolona& z)
 {
     return Zespolona(z.Re() + w.Re() ,z.Im() + w.Im());
 }


ostream& operator << (ostream& wy,Zespolona &z)
{
    wy<< z.Re()<<"+"<< z.Im()<<"i"<<endl;
    return wy;
}

istream& operator>> (istream& we, Zespolona& z)
{
   we>>z.a;
   we>>z.b;
   return we;
}





    float max ( float A[3])
{
    int b=0;
    float a=A[0];
    for(int i=1; i<3; i++)
    {
      if(A[i]>a) {a=A[i]; b=i;}
    }

    return b;
}

void wpisywanie (Zespolona& z1, Zespolona & z2, Zespolona& z3 )
{


float B[3];
B[0]=z1.Re();
B[1]=z2.Re();
B[2]=z3.Re();


float C[3];
C[0]=z1.Im();
C[1]=z2.Im();
C[2]=z3.Im();

int x= max(C);
if(max(C)== max(B))
    cout<<"Max =" <<B[x]<<"+"<<C[x]<<"i"<<endl;

else cout<<"Niestety, nie ma najwiekszego"<<endl;

}

#include <iostream>
#include"macierz.h"
using namespace std;


int main()
{cout<<"Podaj wymiary Twojej macierzy\n";
    int w,k;
 cin>>w>>k;
    Macierz A(w,k);
 cout<<"Wpisz liczby z Twej macierzy\n";
 cin>>A;
 cout<<"\nTwoja macierz to:\n\n";
 cout<<A;
 /*cout<<"Druga macierz ma wymiary\n";
    int W,K;
 cin>>W>>K;
    Macierz X(W,K);

 Macierz A(3,3), B(3,3);
 cin>>A;
 cout<<A<<"\n";
 B=A;
 cout<<"\n"<<B;
 A.zmiana(0,0,4.5);
 cout<<"\n"<<A;
 cout<<"\n"<<B;
 */
 int wyznacznik=0;
 wyznacznik=A.det();
 cout<<"\n det="<<wyznacznik;
     return 0;
}

#include<iostream>
#include<cstdlib>

using namespace std;

 class Macierz
       {
         
        private:
        int a,b;
        double **macierz;//zaczyn tablicy
        int sztuczna;//0-sztuczna,1-nie sztuczna
       
       
        public:
           
        Macierz(int w, int k);
        Macierz(Macierz&A);
        ~Macierz();
       
        friend istream& operator >> (istream&,Macierz&);
        friend ostream& operator << (ostream&,Macierz&);
        void zmiana (int, int, double);
        double det();
        Macierz& operator = (Macierz&);
        Macierz& operator+ (Macierz&);
        /*
        Macierz& operator- (Macierz&);
        Macierz& operator* (Macierz&);
        friend Macierz& operator* (double,Macierz&);
        Macierz& operator* (double);
        */
        };

#include "macierz.h"
#include <iostream>

using namespace std;


Macierz::~Macierz()
{
    for(int i=0;i<a;++i)//a bo destruktor jest polem w klasie
     delete [] macierz [i];
     delete [] macierz;
}



Macierz::Macierz(int w, int k)
{
    macierz=new double *[w];
    for(int i=0; i<w; ++i)
        macierz[i]=new double [k];

    /*for(int x=0;x<w;++x)
        {for(int y=0;y<k;++y)
          macierz[x][y]=0;
        }
    */

    a=w;
    b=k;

    sztuczna=1;
}


                Macierz::Macierz(Macierz&A)//tak jakby macierz D=A;
                {macierz=new double *[a];
                    for(int i=0; i<a; ++i)
                        macierz[i]=new double [b];
                    a=A.a;
                    b=A.b;//podajemy wymiary D
                    sztuczna=1;//bo my powolujemy macierz D do zycia

                    for(int i=0;i<a;++i)
                        for(int j=0;j<b;++j)
                            macierz[i][j]=A.macierz[i][j];
                }


istream& operator >>(istream &in,Macierz &A)
{for(int i=0;i<A.a;++i)
    {cout<<i+1<<":";
        for(int j=0;j<A.b;++j)
            {in>>A.macierz[i][j];
            }
    }
 return in;
 }

ostream& operator << (ostream &out,Macierz &A)
            {for(int i=0;i<A.a;++i)
                    {for(int j=0;j<=A.b-1;++j)
                        {out<<A.macierz[i][j]<<" ";
                            if(j==A.b-1) cout<<"\n";
                        }
                    }
             return out;
            }

void Macierz::zmiana(int w, int k, double n)
    {macierz[w][k]=n;
    }


                 double Macierz::det()
                 {if(a==b)
                  {if(a==1) return macierz[0][0];
                      double wynik=0;
                        for(int i=0;i<b;++i)
                            if(macierz[0][i]!=0)
                                {cout<<"\n"<<wynik<<"\n";
                                    Macierz M(a-1,a-1);
                                        for(int w=0;w<a-1;++w)
                                            for(int k=0;k<a-1;++k)
                                            {
                                             if(i>k)
                                             M.macierz[w][k]=macierz[w+1][k];

                                             if(i<=k)
                                             M.macierz[w][k]=macierz[w+1][k+1];
                                            }
                                                    cout<<"\n"<<M;
                                            wynik+=(((i%2)==0) ? 1 : (-1))*macierz[0][i]*M.det();
                                 }
                                                    return wynik;
                 }
                      else cout<<"B³¹d";
                      if(sztuczna==0) delete this;
                }




Macierz& Macierz::operator=(Macierz &M)
{if((a==M.a)&&(b==M.b))//rowne wymiary
 {for(int i=0;i<a;++i)
    for(int j=0;j<b;++j)
    macierz[i][j]=M.macierz[i][j];
 }
 else
    cout<<"Nie udalo sie przypisac";
 return *this;//bo obiekt niejawny
}

Macierz& Macierz::operator+ (Macierz&A)
{if((a==A.a)&&(b==A.b))
    {Macierz *S;
     S=new Macierz(a,b);
     for(int i=0;i<a;++i)
        for(int j=0;j<b;++j)
            (*S).macierz [i][j]=macierz[i][j]+A.macierz[i][j];
     }//czy sa sztuczne i jak tak to usunac
}

/*
Macierz& Macierz::operator- (Macierz&A)
{if((a==A.a)&&(b==A.b))//rowne wymiary
    {Macierz *S;
     S=new Macierz(a,b);
     for(int i=0;i<a;++i)
        for(int j=0;j<b;++j)
            S macierz [i][j]=macierz[i][j]-A.macierz[i][j];
    }
}

Macierz& Macierz::operator* (Macierz&A)
{if((a==A.a)&&(b==A.b)&&(a==b))//rowne wymiary
    {Macierz *S;
     S=new Macierz(a,b);
         for(int i=0;i<a;++i)
            for(int j=0;j<b;++j)
                for(int k=0;k<a;++k)
                    S macierz[i][j]=macierz[i][k]*A.macierz[k][j];

    }
}

Macierz& operator* (double a, Macierz&A)
{for(int i=0;i<a;++i)
        for(int j=0;j<b;++j)
            macierz[i][j]=macierz[a*i][a*j];

}
Macierz& Macierz::operator* (double a);
{for(int i=0;i<a;++i)
        for(int j=0;j<b;++j)
            macierz[i][j]=macierz[a*i][a*j];
}
*/