#include<iostream>
#include<string>

using namespace std;


class Cialo{
    protected:
        //Cialo element_neutralny;
        virtual Cialo operator+(const Cialo z){};   
        virtual Cialo operator*(const Cialo z){};
        virtual Cialo operator-(const Cialo z){};        
        virtual Cialo operator/(const Cialo z){};
        virtual Cialo operator=(const Cialo z){};
        virtual Cialo operator*(float alpha){};
        
        Cialo operator^(const int n){
            Cialo x=(*this);
            int p=n;
            while (p>0){
                x=x*(*this);
                p--;        
            };   
            return x; 
        };
        
        virtual void wypisz(){};
        virtual bool CzyZero(){};
        virtual void NowaWartosc(){};
};

class CialoC:protected Cialo{
    protected:
        float Rzeczyw;
        float Urojona;
    public:
        CialoC(float a, float b=0){
            Rzeczyw=a;
            Urojona=b;
        };
        
        CialoC():Rzeczyw(0),Urojona(0){};
        
        CialoC(const CialoC &Z){
            Rzeczyw=Z.Rzeczyw;
            Urojona=Z.Urojona;    
        };
        
        bool CzyZero(){
            if ((Rzeczyw==0) and (Urojona==0)) return true;
            else return false;    
        };
        
        void NowaWartosc(){
            cout<< "a+bi - podaj a i b: ";
            float re,im;
            cin>>re;
            cin>>im;
            CialoC *a;
            a=new CialoC(re,im);
            (*this)=(*a);
            delete a;  
        };
        
        void wypisz(){
            cout <<Rzeczyw << "+" <<Urojona<<"i";    
        };
        
        virtual float rzeczywista(){return Rzeczyw;};
        virtual float urojona() {return Urojona;};
        
        CialoC operator+(const CialoC W){
            CialoC a;
            a.Rzeczyw=Rzeczyw+W.Rzeczyw;
            a.Urojona=Urojona+W.Urojona;
            return a;    
        };
        
        Cialo operator*(float alpha){
            (*this).Rzeczyw=(*this).Rzeczyw*alpha; 
            (*this).Urojona=(*this).Urojona*alpha; 
            return (*this);  
        };
        
        CialoC operator*(const CialoC W){
            CialoC a;
            a.Rzeczyw=Rzeczyw*W.Rzeczyw-Urojona*W.Urojona;
            a.Urojona=Rzeczyw*W.Urojona+W.Rzeczyw*Urojona;
            return a;    
        };
        
        CialoC& operator=(const CialoC W){//tuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu
            //CialoC a;
            (*this).Rzeczyw=W.Rzeczyw;
            (*this).Urojona=W.Urojona;
            return *this;    
        };
        
        CialoC operator-(const CialoC W){
            CialoC a;
            a.Rzeczyw=Rzeczyw-W.Rzeczyw;
            a.Urojona=Urojona-W.Urojona;
            return a;
        };
        
        CialoC operator/(const CialoC W){ 
            CialoC z;
            float sp; //sprzezenie lb zesp;
            sp=(W.Rzeczyw*W.Rzeczyw)+(W.Urojona*W.Urojona);
            z.Rzeczyw=((Rzeczyw*W.Rzeczyw+Urojona*W.Urojona)/(sp));
            z.Urojona=((Urojona*W.Rzeczyw-Rzeczyw*W.Urojona)/(sp)); 
            return z;
        };
        
        /*CialoC operator^(const int n){
            CialoC a(1,1);
            for (int i=1; i<=n;i++){
                a=a*(*this);        
            };
            return a; 
        };
        
        /*void raport(){
            cout <<endl<<"a=";
            cout <<Rzeczyw << "+" <<Urojona<<"i" <<endl;    
        }*/
             
};

class CialoR:protected CialoC{
    //private:
        //float Urojona; 
    //public:
  /*  public:    CialoR():CialoC(){
          //  Urojona=0;
           // Rzeczyw=0;
        }; //konstrunktory
           
        CialoR(float a):CialoC(a){
           // Urojona=0;
           // Rzeczyw=a;
        };
        
        CialoR(const CialoR &Z){
            Rzeczyw=Z.Rzeczyw;    
        };
        
        CialoR& operator=(const CialoR W){//tuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu
            //CialoC a;
            (*this).Rzeczyw=W.Rzeczyw;
            return *this;    
        };
        
        void NowaWartosc(){
            cout<< "a: ";
            float re;
            cin>>re;
            (*this).Rzeczyw=re;
        };
        
        void wypisz(){
            cout <<"  "<<Rzeczyw<<"  ";    
        };
        
        bool CzyZero(){
            if (Rzeczyw==0) return true;
            else return false;    
        };
        
       
};

/******************************************************************************************************************/
/******************************************************************************************************************/
/******************************************************************************************************************/



template <class CialoX>
class Wielomian{
    private:
        friend class Cialo;
        int stopien;
        CialoX *wspolczynniki;
    public:
        ~Wielomian(){
            delete[] wspolczynniki;
            cout<< "DESTRUKTOR"<<endl;
        }; 
        
        Wielomian():stopien(0){
            wspolczynniki=new CialoX[1*sizeof(CialoX)];//[1*sizeof(CialoX)]; to bedzoe dobrze? nie bedze za mało miejsca w tablicy dynamicznej? wyciek pamieci?? :P                    
            wspolczynniki[0]=0;                   
            //cout<<"\nRUSZA KONSRTUKTOR 1\n";      
        };     
         
        Wielomian(int st):stopien(st){
            wspolczynniki=new CialoX[(st+1)*sizeof(CialoX)];       
            //cout<<"\nRUSZA KONSRTUKTOR 2\n";     
            CialoX a;
            for(int i=0;i<st+1;i++){
                int m=st-i;
                a.NowaWartosc();
                wspolczynniki[m]=a; 
            };
            system("cls");
        };
        Wielomian(const Wielomian<CialoX> &W) { //konstruktpr kopiujący
            stopien = W.stopien;
            wspolczynniki = new CialoX [(W.stopien+1)*sizeof(CialoX)];
            for(int j = 0; j <= stopien;  j++) {
                wspolczynniki[j] = W.wspolczynniki[j];
                //wspolczynniki[j].wypisz();
            };
            cout<<"\nRUSZA KONSRTUKTOR 4\n"; 
        };
        
        void raport(){
            cout<<"RAPORT! WIELOMIAN: \n";
            for(int i=0;i<((*this).stopien)+1;i++){
                wspolczynniki[(stopien)-i].wypisz();
                cout<<" * x^"<<(stopien)-i<<"+  ";
            };   
            cout<<endl;
        };
        
        inline void RedukcjaStopnia(){
            for(int i=stopien;i>0;i--){
                if (wspolczynniki[i].CzyZero()) {stopien=stopien-1;}
                else return;
            };
            return;
        };
        
        int Stopien() {
            return stopien;
        };
        
        bool Zerowy(){
            return (stopien==-1);    
        };
        
        inline Wielomian<CialoX>& operator+=(const Wielomian<CialoX>& W){
            if (stopien>=W.stopien){
                for(int i=0;i<stopien+1;i++){
                    wspolczynniki[i]=wspolczynniki[i]+(W.wspolczynniki[i]);    
                };        
            }else{
                stopien=W.stopien;
                int roznica=W.stopien-stopien;
                CialoX *nowe_wspolczynniki;
                nowe_wspolczynniki=new CialoX[W.stopien*sizeof(CialoX)];
                for(int i=0;i<stopien+1;i++){
                    nowe_wspolczynniki[i]=wspolczynniki[i]+(W.wspolczynniki[i]);    
                };
                for(int i=stopien+1;i<=W.stopien;i++){
                    nowe_wspolczynniki[i]=W.wspolczynniki[i];    
                };
                delete[] wspolczynniki;
                wspolczynniki=nowe_wspolczynniki;
            }; 
            RedukcjaStopnia();  
            return *this; 
        };
        
        
        
        inline Wielomian<CialoX>& operator*(const Wielomian<CialoX>& W){
            int degree=stopien+W.stopien;
            CialoX *nowe_wspolczynniki;
            nowe_wspolczynniki=new CialoX[(degree+1)*sizeof(CialoX)];
            for(int n=0;n<=stopien;n++){
                for(int k=0;k<=W.stopien;k++){
                    nowe_wspolczynniki[k+n]=nowe_wspolczynniki[k+n]+(wspolczynniki[n]*W.wspolczynniki[k]);    
                };    
            };
            delete[] wspolczynniki;
            wspolczynniki=nowe_wspolczynniki; 
            stopien=degree;
            RedukcjaStopnia();  
            this->raport();
            return *this; 
        };
        
        inline const Wielomian<CialoX> operator+(const Wielomian<CialoX>& W1) //const //- moze trzeb abdzoe iusunac const
	    {
		    Wielomian<CialoX> W2(*this);
            return W2+=W1;
	    }
        inline Wielomian<CialoX>& operator-=(const Wielomian<CialoX>& W){/// do zmiany... tzreba wykorzystać op += oraz *(int);
            Wielomian<CialoX> W2(*this);
            Wielomian<CialoX> W1(W);
            W1=W1*(-1);
            W1.raport();
            cout<<"tut";
            (*this)+=W1;
            RedukcjaStopnia();  
            return (*this);
        };
        
	    inline const Wielomian<CialoX> operator-(const Wielomian<CialoX>& W1) //const 
        {
            Wielomian<CialoX> W2(*this);
            return W2-=W1;      
        };
	    
        inline const Wielomian<CialoX>& operator*(float betha) //const
        {
             for(int i=0;i<stopien+1;i++){
                    wspolczynniki[i]=wspolczynniki[i]*betha;    
                };  
             return *this; 
        };
        
        void Wyzeruj (CialoX *wspolczynniki, int ile){
            for (int i=0;i<=ile;i++){
                wspolczynniki[i]=0;    
            };   
             
            
        };
        
        
        
        
    
        
        inline Wielomian<CialoX> operator/(const Wielomian<CialoX>& W){
            Wielomian<CialoX> Iloraz, Reszta;
            Podziel(W, Iloraz, Reszta);
            return Iloraz;
        };
        
        inline Wielomian<CialoX> operator%(const Wielomian<CialoX>& W){
            Wielomian<CialoX> Iloraz, Reszta;
            Podziel(W, Iloraz, Reszta);
            return Reszta;
        };
        
        void Rozniczkuj(int m=1){  //dokonuje n-krotnego rożniczkowania na wileomainie;
            while (m>0) {
                for(int i=0;i<stopien;i++){
                    wspolczynniki[i]=wspolczynniki[i+1]*(i+1);       
                };  
                stopien--;
                RedukcjaStopnia();  
                m--;
            };
        };
        
        CialoX WartoscWielomianu(CialoX punkt){
            CialoX wart_w_pkt;
            for(int i=0; i<=stopien;i++){
                wart_w_pkt=wart_w_pkt+(wspolczynniki[i]*(punkt^i));    
            };
            return wart_w_pkt;    
        };
        
        CialoX Calkuj(CialoX a,CialoX b,int m=1){
            while(m>0){
                CialoX *nowe_wspolczynniki;
                int degree=stopien+1;
                nowe_wspolczynniki=new CialoX[(degree+1)*sizeof(CialoX)];
                for(int i=degree;i>0;i--){
                    nowe_wspolczynniki[i]=wspolczynniki[i-1]/i;    
                }
                nowe_wspolczynniki[0]=0;
                delete[] wspolczynniki;
                wspolczynniki=nowe_wspolczynniki;
                stopien++;    
                m--;
            };
            CialoX wartosc_calki;
            wartosc_calki=this.WartoscWielomianu(b)-this.WartoscWielomianu(a);
            return wartosc_calki;
        };

        void Podziel(const Wielomian<CialoX> &W, Wielomian<CialoX>& Iloraz, Wielomian<CialoX>& Reszta) const{ //R=reszta ???ZMien
            Wielomian R,I;
            I.stopien=stopien-W.stopien;
            CialoX *nowe_wspolczynniki_iloraz;
            nowe_wspolczynniki_iloraz=new CialoX[(I.stopien+1)*sizeof(CialoX)];
            delete [] I.wspolczynniki;
            I.wspolczynniki=nowe_wspolczynniki_iloraz;
            R=*this;
            for(int i=(I.stopien);i>-1;i--){
                I.wspolczynniki[i]=((R.wspolczynniki[R.stopien])/(W.wspolczynniki[W.stopien]));
                for(int n=W.stopien;n>-1;n--){
                    R.wspolczynniki[n+i]=R.wspolczynniki[n+i]-(I.wspolczynniki[i]*W.wspolczynniki[n]);        
                }
                R.RedukcjaStopnia();      
            };
            Reszta=R;
            Iloraz=I;        
        };  
        
        inline Wielomian<CialoX>& operator=(const Wielomian<CialoX>& W){
            delete[] wspolczynniki;
            wspolczynniki = new CialoX [(W.stopien+1)*sizeof(CialoX)];
            for(int j = 0; j <= stopien;  j++) {
                wspolczynniki[j] = W.wspolczynniki[j];
            };
            stopien=W.stopien;
            return *this;
        };       
};

template <class CialoX>
void Zamien(Wielomian<CialoX>& W1, Wielomian<CialoX>& W2)
{
    Wielomian<CialoX> Q(W1);
    (W1)=W2;
    W2=Q;
    W2.RedukcjaStopnia();
    W1.RedukcjaStopnia();      
};
        
template <class CialoX>
Wielomian<CialoX> NWD(Wielomian<CialoX> A, Wielomian<CialoX> B)
{
    Wielomian<CialoX> R;
    while(B.Stopien()>0)
    {
        R=A%B;
        //A=R;
        Zamien(A,B);
        B =R ;
        R.RedukcjaStopnia();
        A.RedukcjaStopnia();
        B.RedukcjaStopnia();
    };
    return A; 
};



  

/*********************************************************************/

int main(){

Wielomian<CialoC> a(3);   ///// gdy dam Wielomian<CialoR> a(3); nad ciałem liczb rzeczywisych to mam duuuużo błedów... :(
a.raport();
Wielomian<CialoC> b(1);
b.raport();
Wielomian<CialoC> m;

//CialoR f;
//f.NowaWartosc();
//f.wypisz();
//system("pause");
//b=(b/a);
//b.RedukcjaStopnia();
a.raport();
b.raport();
system("pause");
b=NWD(a,b);
system("pause");

//a.raport();

b.raport();

system("pause");
};