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

using namespace std;

int main()
{
    cout<<"TESTY:"<<endl<<endl;
    cout<<"Konstruktory:"<<endl;
    cout<<"Bezargumentowy:"<<endl;
    wielomian w1;
    cout << w1 << "\nwielomian(int,double):"<<endl;
    wielomian w2(4, 2);
    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 << "Dodawanie: w1+w2: " << w5 + w6 << endl;
    cout << "Odejmowanie: w1-w2: " << w5 - w6 << endl;
    double pom2[] = { 4,2,4.8 };
    double pom3[] = { 3,3.1 };
    wielomian w7(2, pom2);
    wielomian w8(1, pom3);
    cout << "Mnozenie: w3*w4: " << w7*w8 << endl;
    cout << "Mnozenie przez skalar: w3*4.4: " << w7*4.4 << endl;
    w7 += w8;
    cout << "Suma rowan sie: w3+=w4: " << w7 << endl;
    w7 -= w8 += w7;
    cout << "Roznica rowna sie: w3-=w4+=w3: " << w7 << endl;
    w7 *= w8;
    cout << "Mnozenie rowna sie: w3*=w4: " << w7 << endl;
    w7 *= 2.5;
    cout << "Mnozenie skalar rowna sie: w3*=2.5: " << w7 << endl;
    cout << "wartosc w3 w punkcie 4.4: " << w7(4.4) << endl;
    cout << "wspolczynnik w3 przy x^4: " << w7[2] << endl;

    cout<<endl<<endl<<"Wprowadz stopien wielomianu a nastepnie wspoczynniki"<<endl;
    wielomian cos;
    try
    {
        cin>>cos;
        cout<<endl<<cos;
    }
    catch (string pom)
    {
        cout<<pom<<endl<<endl;
    }



}







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

using namespace std;

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];
    wspolczynniki[st] = wsp;
    for(int i=0; i<st; i++)
        wspolczynniki[i]=0;
}

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)
{
    we >> w.stopien;
    if(w.stopien<0)
        throw string("Bledny stopien pierwiastka - nie moze byc wiekszy od zera");
    w.~wielomian();
    w.wspolczynniki = new double[w.stopien + 1];
    for (int i=0; i<=w.stopien; i++)
    {
        we >> w.wspolczynniki[i];
    }
    if(w.wspolczynniki[w.stopien]==0)
        throw string("Bledny najwyzszy wspolczynnik - nie moze by zerem");
    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 = max(u.stopien, v.stopien);
    while (u.stopien == v.stopien && st > 0 && (u.wspolczynniki[st] + v.wspolczynniki[st] == 0))
        st--;
    double *wsp = policz_suma(u, v, st);
    wielomian w(st, wsp);
    delete[] wsp;
    return w;
}

wielomian operator-(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--;
    double *wsp = policz_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_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 = max(this->stopien, v.stopien);
    while (this->stopien == v.stopien && st > 0 && (this->wspolczynniki[st] + v.wspolczynniki[st] == 0))
        st--;
    double *wsp = policz_suma(*this, v, st);
    *this = wielomian(st, wsp); //tu korzystamy z przypisania kop
    delete[] wsp;
    return *this;
}

wielomian& wielomian::operator-=(const wielomian &v)
{
    int st = max(this->stopien, v.stopien);
    while (this->stopien == v.stopien && st > 0 && (this->wspolczynniki[st] - v.wspolczynniki[st] == 0))
        st--;
    double *wsp = policz_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_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];
}

double* policz_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_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_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;
}








#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 double* policz_suma(const wielomian &u, const wielomian &v, int st);
    friend double* policz_roznica(const wielomian &u, const wielomian &v, int st);
    friend double* policz_iloczyn(const wielomian &u, const wielomian &v, int st);
};