LES NOMBRES RATIONNELS

package rationnel;

/**
 *
 * @author yassine
 */

public class Rationnel extends Number implements Comparable<Rationnel>{

    private int numerateur;
    private int denominateur;
    static final int DIVISION_PAR_0=0;
    
    
    public void setNumerateur(int a){
        numerateur=a;
    }
    public int getNumerateur(){
        return numerateur;
    }
    
    public void setDenominateur(int a){
        if(a==0) erreur(DIVISION_PAR_0);
        else 
            denominateur=a;
        
    }
    public int getDenominateur(){
        return denominateur;
    }
    
    public Rationnel(int n,int d){
        this.setNumerateur(n);
        this.setDenominateur(d);
    }
    public Rationnel(int n){
        this(n,1);
    }
    public Rationnel(){
        this(0,1);
    }
    public Rationnel(Rationnel r){
        this(r.numerateur,r.denominateur);
    }
    /*
     * pour a>b>0 pgcd(a,b)=pgcd(a-b,b);
     */
    
    public static int pGCD(int a,int b){
        if(a<0) a=-a;
        else
            if(a==0) return b;
        if(b<0)  b=-b;
        else  
            if(b==0) return a;
        if(a==b)
            return a;
        if(a<b)
            return pGCD(a,b-a);
        return pGCD(a-b,b);
    }
    
    public static Rationnel toCanonique(Rationnel r){
        int pgcd=pGCD(r.getNumerateur(),r.getDenominateur());
        r.setNumerateur(r.getNumerateur()/pgcd);
        r.setDenominateur(r.getDenominateur()/pgcd);
        return r;
    }
    public Rationnel toCanonique(){
        return Rationnel.toCanonique(this);
    }
    static Rationnel moinsUnaire(Rationnel r){
        Rationnel tmp=new Rationnel(r);
        tmp.setNumerateur( tmp.getNumerateur()*-1);
        return tmp;
    }
    static Rationnel inverse(Rationnel r){
        Rationnel r2=new Rationnel(r); 
        int tmp=r2.getNumerateur();
        r2.setNumerateur(r2.getDenominateur());
        r2.setDenominateur(tmp);
        return r2;  
    }
    private static int numAPB(Rationnel a,Rationnel b){
        return a.getNumerateur()*b.getDenominateur()+a.getDenominateur()*b.getNumerateur();
    }
    private static int numAB(Rationnel a, Rationnel b){
        return a.getNumerateur()*b.getNumerateur();
    }
    private static int denAB(Rationnel a,Rationnel b){
        return a.getDenominateur()*b.getDenominateur();
    }
    public static Rationnel addition(Rationnel a,Rationnel b){
        Rationnel tmp=new Rationnel(numAPB(a,b),denAB(a,b));
        return toCanonique(tmp);
    }
    public static Rationnel soustraction(Rationnel a,Rationnel b){
        return Rationnel.addition(a,Rationnel.moinsUnaire(b));
    }
    public static Rationnel multiplication(Rationnel a,Rationnel b){
        return toCanonique(new Rationnel(numAB(a,b),denAB(a,b)));  
    }

    public static Rationnel division(Rationnel a,Rationnel b){
        return Rationnel.multiplication(a,inverse(b));
    }
    
    public static Rationnel puissance(Rationnel r,int n){
        return (new Rationnel((int)Math.pow(r.numerateur, n),
                (int)Math.pow(r.denominateur, n))).toCanonique();
        
    }   
    
    
    public Rationnel addition(Rationnel r){
        return Rationnel.addition(this, r);
    }

    public Rationnel soustraction(Rationnel r){
        return Rationnel.soustraction(this, r);
    }

    public Rationnel multiplication(Rationnel r){
        return Rationnel.multiplication(this, r);
    }

    public Rationnel division(Rationnel r){
        return Rationnel.division(this,r);
    }

    public Rationnel puissance(int n){
        return Rationnel.puissance(this,n);
    }
    
    public void affecter(Rationnel a,Rationnel b){
        a.setNumerateur(b.getNumerateur());
        a.setDenominateur(b.getDenominateur());
    }
    //les mêmes opération avec une affectation sur l'instance courante
    public void additionA(Rationnel r){
        Rationnel tmp=addition(this,r);
        affecter(this,tmp);
    }

    
    public void soustractionA(Rationnel r){
        Rationnel tmp=soustraction(this,r);
        affecter(this,tmp);
    }

    public void multiplicationA(Rationnel r){
        Rationnel tmp=multiplication(this,r);
        affecter(this,tmp);
    }

    public void divisionA(Rationnel r){
        Rationnel tmp=division(this,r);
        affecter(this,tmp);
    }

    public void puissanceA(int n){
        Rationnel tmp=puissance(this,n);
        affecter(this,tmp);
    }

    public int compareTo(Rationnel o) {        
        return this.soustraction(o).numerateur;
    }

    
    
    @Override
    public int hashCode() {
        int hash = 7;
        this.toCanonique();
        hash = 41 * hash + getNumerateur();
        hash = 41 * hash + getDenominateur();
        return hash;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        final Rationnel other = (Rationnel) obj;
        return compareTo(other)==0;
    }
    @Override
    public Rationnel clone(){
        return new Rationnel(this);
    }
    @Override
    public String toString(){
        return getNumerateur()+"/"+getDenominateur();
    }


    @Override
    public int intValue() {
        return (int) getNumerateur()/getDenominateur(); 
    }

    @Override
    public long longValue() {
        return (long) getNumerateur()/getDenominateur(); 
    }

    @Override
    public float floatValue() {
        return (float) getNumerateur()/getDenominateur(); 
    }

    @Override
    public double doubleValue() {
        return (double) getNumerateur()/getDenominateur(); 
    }
    
    static void erreur(int n){
        switch(n){
            case DIVISION_PAR_0:
                System.out.println("Erreur: Division par 0");
                System.exit(-1);
                break;
            default:
                System.exit(-1);
        }
    }

        

}