public final class Bruch implements Comparable {

    private final long zaehler;
    private final long nenner;
/**
 * Ohne Eingabe des Nenners wird dieser automatisch auf 1 gesetzt
 * @param Zaehler muss eingegeben werden um einen Bruch zu erstellen.
 * 
 */
    public Bruch(long number) {
        zaehler = number;
        nenner = 1;
    }
/**
 * Wenn der Nenner gleich 0 dann Fehlermeldung ausgeben. Ansonsten stelle einen Bruch zusammen,
 * der die Vorzeichen beachtet.
 * @param zaehler
 * @param nenner
 */

    public Bruch(long zaehler, long nenner) {
        // TODO: Irgenwas stimmt nicht mit dem Vorzeichen und der Exception
        long ggt = groessterGemeinsamerTeiler(Math.abs(zaehler),Math.abs(nenner));
        if (nenner == 0) throw new ArithmeticException("Division durch Null!");
        if (zaehler < 0 & nenner < 0) {zaehler = zaehler * (-1); nenner = nenner * (-1);}
        if (zaehler > 0 & nenner < 0)  {zaehler = zaehler * (-1); nenner = nenner * (-1);}

            this.zaehler = zaehler / ggt;
            this.nenner = nenner / ggt;
  
    }
 
    
    
    /**
     * Berechnet den groessten gemeinsamen Teiler zweier positiver
     * Zahlen.
     * 
     * @param a 1. Zahl.
     * @param b 2. Zahl.
     * @return groesster gemeinsamer Teiler.
     */
    private static long groessterGemeinsamerTeiler(long a, long b) {
    
        while (b != 0) {

            long t = a % b;
            a = b;
            b = t;
        }
        return a;
    }
    /**
     * Auf Gleichen Nenner bringen und anschlie&Atilde;Ÿend die Brueche addieren
     * @param bruch2
     * @return Das Ergebnis der Addition
     */
    public Bruch addiere(Bruch bruch2) {

        return new Bruch(zaehler*bruch2.nenner + bruch2.zaehler*nenner, nenner*bruch2.nenner);
    }
/**
 * Auf Gleichen Nenner bringen und anschlie&Atilde;Ÿend die Brueche subtrahieren
 * @param bruch2
 * @return Das Ergebnis der Subtraktion.
 */
    public Bruch subtrahiere(Bruch bruch2) {
    	return new Bruch(zaehler*bruch2.nenner - bruch2.zaehler*nenner, nenner*bruch2.nenner);
    }
/**
 * 
 * @param bruch2
 * @return Das Ergebnis der Multiplikation.
 */
    public Bruch multipliziere(Bruch bruch2) {
        
        return new Bruch(zaehler * bruch2.zaehler, nenner * bruch2.nenner);
    }
/**
 * Kehrwert multiplizieren.
 * @param bruch2
 * @return Das Ergebnis der Division.
 * @
 */
    public Bruch dividiere(Bruch bruch2) {
    	if(nenner == 0){
        	throw new ArithmeticException();
    	}
        return new Bruch(zaehler * bruch2.nenner, nenner * bruch2.zaehler);
    }
/**
 * Zaehler und Nenner vertrauschen
 * @return vertauschte Werte Nenner <-> Zaehler
 */
    public Bruch invertiere() {
      
        return new Bruch(this.nenner,this.zaehler);
    }
/**
 * Rueckgabe des Zaehlers
 * @return Zaehler
 */
    public long zaehler() {
        return zaehler;
    }
/**
 * Rueckgabe des Nenners
 * @return Nenner
 */
    public long nenner() {
        return nenner;
    }
/**
 * Wenn der Nenner 1 ist, nur den Zaehler wiedergeben
 * @return Bruch als String wiedergeben
 */
    public String toString() {
        if (nenner == 1) return (String.valueOf(zaehler)); 
        else {
        return zaehler + "/" + nenner;
        }
        }
/**
 * 
 */
    public int compareTo(Object other) {
        // TODO korrigieren.
    	Bruch r = (Bruch) other;
    	
    	Bruch t = (Bruch) other;
        if( (zaehler*t.nenner) - (nenner*t.zaehler)<0)
            {return -5;}
        if( (zaehler*t.nenner) - (nenner*t.zaehler)>0)
            {return +5;}
        else
         {return 0;}
    
        
    }
/**
 * @return ob Gleichheit gegeben ist.
 */
    public boolean equals(Object other) {
        if (! (other instanceof Bruch)) return false;
        Bruch r = (Bruch) other;
        // TODO korrigieren. READY
        return zaehler == r.zaehler && nenner == r.nenner;
    }
/**
 * Gibt das Ergebnis mit doppelter Genauigkeit aus
 * @return double wert
 */
    public double doubleValue() {
        // TODO korrigieren.
        double z = zaehler;
        double n = nenner;
        double e = z/n;
           return e;

    }
}