//
//  interval.cpp
//  interval
//
//  Created by vlaurain on 10/01/2018.
//  Copyright © 2018 vlaurain. All rights reserved.
//

#include "interval.hpp"
#include <iostream>



//=========Ici se trouvent tous les constructeurs==========
// constructeur sans argument
interval::interval(){
    borne_inf = 0.;
    borne_sup = 0.;
}
// constructeurs avec arguments
interval::interval(double a){
    borne_inf = a;
    borne_sup = a;
}

// public pour autoriser l’acce`s aux donne ́es par // les fonctions externes a` la classe
// donne ́es membres
// interval [0,0]
// interval [a,a]
interval::interval(double inf, double sup){
    if(inf<sup)
    {
    borne_inf = inf;
    borne_sup = sup;
    }
    else
    {
        borne_inf = sup;
        borne_sup = inf;
    }
    
}

// constructeur par recopie
interval::interval(const interval &a){
    borne_inf = a.borne_inf;
    borne_sup = a.borne_sup;
}



//======Fonctions à créer=====================
double interval::largeur() const{
    return(borne_sup-borne_inf);
}

void interval::Affiche() const{
    cout<<"Cet interval vaut: ["<<borne_inf<<","<<borne_sup<<"]"<<endl;
}

interval interval::Union(const interval &Autre)
{
    interval res;
    
    if (borne_inf<Autre.borne_inf)
    {res.borne_inf = borne_inf;}
    else{ res.borne_inf =Autre.borne_inf;}
    
    if (borne_sup>Autre.borne_sup)
    {res.borne_sup = borne_sup;}
    else{ res.borne_sup =Autre.borne_sup;}
    
    return(res);

    
}
//=========================== for private

double interval::get_inf() const{
    return(borne_inf);
}
double interval::get_sup() const{
    return(borne_sup);
}

void interval::set_sup(double newsup)
{
    if(newsup<borne_inf)
    {
        borne_sup=borne_inf;
        borne_inf=newsup;
    }
    else
    {borne_sup=newsup;}
    
    
}

void interval::set_inf(double newinf)
{
    if(newinf>borne_sup)
    {
        borne_inf=borne_sup;
        borne_sup=newinf;
        
    }
    else
    {borne_inf=newinf;}
}

//======================== Pour les avancés

interval interval::operator+(const interval &autre){
    interval res;
    res.borne_inf = borne_inf+autre.borne_inf;
    res.borne_sup = borne_sup+autre.borne_sup;
    return(res);
}



interval& interval::operator=(const interval &autre){
    // this est un pointeur sur l’objet auquel s’applique une fonction // membre
    if (this != &autre){ // test pour e ́viter l’auto-affectation
        borne_inf = autre.borne_inf;
        borne_sup = autre.borne_sup;
    }
    return(*this);
}