//main

#include <iostream>
#include <string>
#include "wielomian.h"

using namespace std;

void testy_konstruktorow();
void testy_sytuacji_wyjatkowych();
void testy_operacji_arytmetycznych();
void program();

int main()
{
    cout<<"TESTY:"<<endl<<endl;
    cout<<"Konstruktory:"<<endl;
    cout<<"Bezargumentowy:"<<endl;
    wielomian w1;
    cout << w1 << "\nwielomian(int,double):"<<endl;
    wielomian w2(6, 2.351);
    cout << w2 << "\nwielomian(int, const double[]):"<<endl;
    double tab[] = { 4.1,4.2,4.3,4.4,4.5,4.6,4.7,4.8 };
    wielomian w3(5, tab);
    cout << w3 << "\nwielomian(initializer_list<double>):"<<endl;
    initializer_list<double> pl{ 123, 323.5, 234.2, 444444.44, 3.1412 };
    wielomian w4(pl);
    cout << w4 <<endl<<endl;


    cout << "Operacje matematycznie"<<endl;
    double pom1[] = { 4.2,4,4.4,3,23 };
    wielomian w5(4, pom1);
    initializer_list<double> pl2{ 555.4,55.3,13.3,42.4,6.4,1.2 };
    wielomian w6(pl2);
    cout<<w5<<endl<<w6;
    cout << "w1+w2: " << w5 + w6 << endl;
    cout << "w1-w2: " << w5 - w6 << endl;
    double pom2[] = { 1,2,3.2 };
    double pom3[] = { 1,2.3 };
    wielomian w7(2, pom2);
    wielomian w8(1, pom3);
    cout << "w3*w4: " << w7*w8 << endl;
    cout << "w3*2.5: " << w7*2.5 << endl;
    w7 += w8;
    cout << "w3+=w4: " << w7 << endl;
    w7 -= w8 += w7;
    cout << "w3-=w4+=w3: " << w7 << endl;
    w7 *= w8;
    cout << "w3*=w4: " << w7 << endl;
    w7 *= 2.5;
    cout << "w3*=2.5: " << w7 << endl;
    cout << "wartosc w3 w punkcie 1.5: " << w7(1.5) << endl;
    cout << "wspolczynnik w3 przy x^2: " << w7[2] << endl;
}






//funkcje
#include <iostream>
#include <string>
#include "wielomian.h"

using namespace std;

//zamiast std::cerr wolalbym wyjatki, no ale specyfikacja

wielomian::wielomian(int st, double wsp) : stopien(st)// konstruktor tworzący jednomian
{
    if(wsp==0)
    {
        cerr<<"Wspolczynnik przy najwiekszej potedze jest rowny zero zatem stopien jest bledny!"<<endl;
        return;
    }
    wspolczynniki = new double[st+1];
    for(int i=0; i<=st; i++)
        wspolczynniki[i]=wsp;
}

wielomian::wielomian(int st, const double wsp[]) : stopien(st)// konstruktor tworzący wielomian
{

    if(wsp[st]==0)
    {
        cerr<<"Wspolczynnik przy najwiekszej potedze jest rowny zero zatem stopien jest bledny!"<<endl;
        return;
    }
    wspolczynniki = new double[st+1];
    for(int i=0; i<=st; i++)
        wspolczynniki[i]=wsp[i];
}

wielomian::wielomian (initializer_list<double> wsp) // lista współczynników
{
    if(*(wsp.end()-1) == 0)
    {
        cerr<<"Wspolczynnik przy najwiekszej potedze jest rowny zero zatem stopien jest bledny!"<<endl;
        return;
    }
    stopien = wsp.size() - 1;
    wspolczynniki = new double[stopien + 1];
    int i=0;
    for(auto iterator = wsp.begin(); iterator != wsp.end(); i++, iterator++)
        wspolczynniki[i] = *iterator;
}

wielomian::wielomian(const wielomian &pierwotny) // konstruktor kopijący
{
    stopien = pierwotny.stopien;
    wspolczynniki = new double[stopien + 1];
    for(int i=0 ; i<stopien; i++)
        wspolczynniki[i] = pierwotny.wspolczynniki[i];
}


wielomian::wielomian(wielomian &&pierwotny) // konstruktor przenoszący
{
    stopien = pierwotny.stopien;
    wspolczynniki = pierwotny.wspolczynniki;
    pierwotny.wspolczynniki = nullptr;
}

wielomian& wielomian::operator = (const wielomian &pierwotny) // przypisanie kopijące
{
    this->~wielomian();

    stopien = pierwotny.stopien;
    wspolczynniki = new double[stopien + 1];
    for(int i=0 ; i<stopien; i++)
        wspolczynniki[i] = pierwotny.wspolczynniki[i];
    return *this;
}

wielomian& wielomian::operator = (wielomian &&pierwotny)// przypisanie przenoszące
{
    this->~wielomian();

    stopien = pierwotny.stopien;
    wspolczynniki = pierwotny.wspolczynniki;
    pierwotny.wspolczynniki = nullptr;

    return *this;
}

wielomian::~wielomian() // destruktor
{
    delete[] wspolczynniki;
}


istream& operator >> (istream &we, wielomian &w)
{
    cout<<"Podaj stopien wielomianu (w postaci liczby naturnalnej)"<<endl;
    we >> w.stopien;
    w.~wielomian();
    w.wspolczynniki = new double[w.stopien + 1];
    cout<<"Podawaj kolejne wspolczynniki"<<endl;
    for (int i=0; i<w.stopien; i++)
    {
        we >> w.wspolczynniki[i];
    }
    cout<<"Podaj wspolczynnik przy x o najwiekszej potedze (musi byc rozny od 0)"<<endl;
    return we;
}

ostream& operator << (ostream &wy, const wielomian &wzor)
{
    for (int i=wzor.stopien; i>=1; i--)
    {
        wy << wzor.wspolczynniki[i] << "*x^" << i << " + ";
    }
    wy << wzor.wspolczynniki[0] << endl;
    return wy;
}


wielomian operator+(const wielomian &u, const wielomian &v)
{
    int st = stopien_plus(u, v);
    double *wsp = policz_wspolczynniki_suma(u, v, st);
    wielomian w(st, wsp);
    delete[] wsp;
    return w;
}

wielomian operator-(const wielomian &u, const wielomian &v)
{
    int st = stopien_minus(u, v);
    double *wsp = policz_wspolczynniki_roznica(u, v, st);
    wielomian w(st, wsp);
    delete[] wsp;
    return w;
}

wielomian operator*(const wielomian &u, const wielomian &v)
{
    int st = u.stopien + v.stopien;
    double *wsp = policz_wspolczynniki_iloczyn(u, v, st);
    wielomian w(st, wsp);
    delete[] wsp;
    return w;
}

wielomian operator*(const wielomian &u, double m)
{
    wielomian w = u;
    for (int i = 0; i <= w.stopien; i++)
        w.wspolczynniki[i] *= m;
    return w;
}

wielomian& wielomian::operator+=(const wielomian &v)
{
    int st = stopien_plus(*this, v);
    double *wsp = policz_wspolczynniki_suma(*this, v, st);
    wielomian *w = new wielomian(st, wsp);
    *this = *w; //tu korzystamy z przypisania kop
    delete[] wsp;
    delete w;
    return *this;
}

wielomian& wielomian::operator-=(const wielomian &v)
{
    int st = stopien_minus(*this, v);
    double *wsp = policz_wspolczynniki_roznica(*this, v, st);
    wielomian *w = new wielomian(st, wsp);
    *this = *w;
    delete[] wsp;
    delete w;
    return *this;
}

wielomian& wielomian::operator*=(const wielomian &v)
{
    int st = stopien + v.stopien;
    double *wsp = policz_wspolczynniki_iloczyn(*this, v, st);
    wielomian *w = new wielomian(st, wsp);
    *this = *w;
    delete[] wsp;
    delete w;
    return *this;
}

wielomian& wielomian::operator*=(double c)
{
    for (int i = 0; i <= stopien; i++)
        wspolczynniki[i] *= c;
    return *this;
}

double wielomian::operator()(double x) const
{
    if (stopien == 0)
        return wspolczynniki[0];
    double wynik = x*wspolczynniki[stopien] + wspolczynniki[stopien - 1];
    for (int i = stopien-2; i >= 0; i--)
        wynik = wynik*x + wspolczynniki[i];
    return wynik;
}

double wielomian::operator[](int i) const
{
    if (i > stopien || i < 0)
    {
        std::cerr << "Zle podany indeks wspolczynnika!\n";
        return 0;
    }

    return wspolczynniki[i];
}

int stopien_plus(const wielomian &u, const wielomian &v)
{
    int st = max(u.stopien, v.stopien);
    while (u.stopien == v.stopien && st > 0 && (u.wspolczynniki[st] + v.wspolczynniki[st] == 0))
        st--;
    return st;
}

int stopien_minus(const wielomian &u, const wielomian &v)
{
    int st = max(u.stopien, v.stopien);
    while (u.stopien == v.stopien && st > 0 && (u.wspolczynniki[st] - v.wspolczynniki[st] == 0))
        st--;
    return st;
}

double* policz_wspolczynniki_suma(const wielomian &u, const wielomian &v, int st)
{
    double *wsp = new double[st + 1];
    int i;
    for (i = 0; i <= u.stopien && i <= v.stopien && i <= st; i++)
        wsp[i] = u.wspolczynniki[i] + v.wspolczynniki[i];
    if (u.stopien > v.stopien)
        for (;i <= u.stopien && i <= st;i++)
            wsp[i] = u.wspolczynniki[i];

    else if (v.stopien > u.stopien)
        for (;i <= v.stopien && i <= st;i++)
            wsp[i] = v.wspolczynniki[i];
    return wsp;
}

double* policz_wspolczynniki_roznica(const wielomian &u, const wielomian &v, int st)
{
    double *wsp = new double[st + 1];
    int i;
    for (i = 0; i <= u.stopien && i <= v.stopien && i <= st; i++)
        wsp[i] = u.wspolczynniki[i] - v.wspolczynniki[i];
    if (u.stopien > v.stopien)
        for (;i <= u.stopien && i <= st; i++)
            wsp[i] = u.wspolczynniki[i];

    else if (v.stopien > u.stopien)
        for (;i <= v.stopien && i <= st; i++)
            wsp[i] = v.wspolczynniki[i] * (-1);
    return wsp;
}

double* policz_wspolczynniki_iloczyn(const wielomian &u, const wielomian &v, int st)
{
    double *wsp = new double[st + 1];
    for (int i = 0; i <= st; i++)
        wsp[i] = 0;

    for (int i = 0; i <= u.stopien; i++)
        for (int j = 0; j <= v.stopien; j++)
            wsp[i + j] += u.wspolczynniki[i] * v.wspolczynniki[j];
    return wsp;
}







//deklaracje
#include <iostream>


class wielomian
{
private:
    int stopien;
    double *wspolczynniki;

public:
    wielomian(int st = 0, double wsp = 1.0);
    wielomian(int st, const double wsp[]);
    wielomian(std::initializer_list<double> wsp);
    wielomian(const wielomian &w);
    wielomian(wielomian &&w);
    wielomian& operator=(const wielomian &w);
    wielomian& operator=(wielomian &&w);
    ~wielomian();

    wielomian& operator+=(const wielomian &v);
    wielomian& operator-=(const wielomian &v);
    wielomian& operator*=(const wielomian &v);
    wielomian& operator*=(double c);
    double operator()(double x) const; // obliczenie wartości wielomianu w x-sie
    double operator[](int i) const; // odczytanie i-tego współczynnika

    int get_stopien();

    friend std::istream& operator>>(std::istream &we, wielomian &w);
    friend std::ostream& operator<<(std::ostream &wy, const wielomian &w);
    friend wielomian operator+(const wielomian &u, const wielomian &v);
    friend wielomian operator-(const wielomian &u, const wielomian &v);
    friend wielomian operator*(const wielomian &u, const wielomian &v);
    friend wielomian operator*(const wielomian &u, double c);
    friend int stopien_plus(const wielomian &u, const wielomian &v);
    friend int stopien_minus(const wielomian &u, const wielomian &v);
    friend double* policz_wspolczynniki_suma(const wielomian &u, const wielomian &v, int st);
    friend double* policz_wspolczynniki_roznica(const wielomian &u, const wielomian &v, int st);
    friend double* policz_wspolczynniki_iloczyn(const wielomian &u, const wielomian &v, int st);
};