// Polynomi-luokan toteutus

#include <vector>
#include <iostream>
#include <algorithm>
#include <cmath>
#include "polynomi.hh"

const double EPSILON = 0.0001;

// Tyhjä oletusrakentaja
Polynomi::Polynomi() {
}

// Rakentaja polynomille, jossa on yksi termi
Polynomi::Polynomi(double kerroin, int eksponentti) {
    lisaaTermi(kerroin, eksponentti);
}

// Tulostaa polynomin
void Polynomi::tulosta(ostream &virta) const {
    if (termit_.size() == 0) {
        virta << "0";
        return;
    }
    
    unsigned int i;
    for (i = 0; i < termit_.size(); i++) {
        if (i != 0) {
            // Lisätään termien väliin plusmerkki
            virta << " + ";
        }
        virta << "(" << termit_.at(i).kerroin;
        virta << "x^" << termit_.at(i).eksponentti;
        virta << ")";
    }
}

bool vertaa_astetta(Termi a, Termi b) {
    // Lajittelussa tämä lajittelee isoimman eksponentin ensimmäiseksi
    return a.eksponentti > b.eksponentti;
}

// Sieventää polynomin seuraavasti:
// 1) Lajitellaan isointa astetta olevat termit vasemmalle
// 2) Jos peräkkäiset termit ovat samaa astetta, yhdistetään ne
// 3) Jos termit kerroin on 0, poistetaan se
void Polynomi::sievenna() {
    std::sort(termit_.begin(), termit_.end(), vertaa_astetta);
    
    unsigned int i;
    for (i = 0; i < termit_.size(); i++) {
        // Jos tämä ja edellinen ovat samaa astetta, vähennetään kertoimet
        if (i > 0) {
            if (termit_.at(i - 1).eksponentti == termit_.at(i).eksponentti) {
                termit_.at(i - 1).kerroin += termit_.at(i).kerroin;
                termit_.erase(termit_.begin() + i);
                // Vähennetään i:tä, jotta seuraavaksi tutkitaan käsitellyistä
                // kahdesta termistä ensimmäistä.
                i--;
            }
        }
        
        // Jos tulos tai muuten nykyinen termi on nollakertoiminen, poistetaan
        if (std::fabs(termit_.at(i).kerroin) < EPSILON) {
            termit_.erase(termit_.begin() + i);
            // Vähennetään i:tä, jotta jokainen termi käsitellään.
            // Seuraavalla kierroksella käytetään samaa i:n arvoa, mutta nyt
            // kyseisessä kohdassa on seuraava termi.
            i--;
        }
    }
}

// Lisää termin polynomin loppuun
void Polynomi::lisaaTermi(double kerroin, int eksponentti) {
    Termi termi = {kerroin, eksponentti};
    termit_.push_back(termi);
}

// Laskee polynomit yhteen, palauttaa tuloksen
Polynomi Polynomi::lisaa(const Polynomi &lisattava) const {
    Polynomi uusi;
    uusi.termit_ = termit_;
    unsigned int i;
    for (i = 0; i < lisattava.termit_.size(); i++) {
        uusi.termit_.push_back(lisattava.termit_.at(i));
    }
    return uusi;
}

// Vähentää toisen polynomin, palauttaa tuloksen
Polynomi Polynomi::vahenna(const Polynomi &vahennettava) const {
    Polynomi uusi;
    uusi.termit_ = termit_;
    unsigned int i;
    for (i = 0; i < vahennettava.termit_.size(); i++) {
        uusi.lisaaTermi(-vahennettava.termit_.at(i).kerroin,
                        vahennettava.termit_.at(i).eksponentti);
    }
    return uusi;
}