//============================//
//   (C)2004 Dieter Steiner   //
//     spoilerhead@dnet.it    //
//      Matr#: 0326004        //
//   All Rights reserverd     //
//============================//

//Package bruch

package bruch;

public class bruch{
	
	//Private Variablen_ Zähler oben, nenner oben, Zähler unten, nenner unten
	private int zo,no,zu,nu;
	//Ist der aktuzelel bruch ein Doppelbruch?
	private boolean is_db;
	
	//Erstellt einen "normalen" Bruch
	public bruch(int zaehler, int nenner)
	{
		super();
		zo = zaehler;
		no = 1;
		zu = nenner;
		nu = 1;
		
		is_db = false;
		return;
	}
	
	//ERstellt einen Doppelbruch
	
	public bruch(int zaehler_o, int nenner_o, int zaehler_u, int nenner_u)
	{
		super();
		zo = zaehler_o;
		no = nenner_o;
		zu = zaehler_u;
		nu = nenner_u;
		is_db = true;
		return;
	}
	
	//Prüft auf Division durch Null
	public boolean null_div()
	{
		if(is_db == false) return ( zu == 0);
		  else return ((no == 0) || (nu == 0) );
	}
	
	//Ist der Bruch ein Doppelbruch?
	public boolean ist_db()
	{
		return is_db;
	}
	
	//Wandelt einen Doppelbruch in einen Normalen Bruch um
	public void to_bruch()
	{
		zo = zo*nu;
		zu = no*zu;
		no = 1;
		nu = 1;
		is_db = false;	
		return;	
	}
	
	//Ändert das Vorzeichen des Bruches
	public void negiere_bruch()
	{
		zo *= -1;
		return;
	}
	
	//Verwandelt den Bruch in seinen Kehrwert
	public void kehrwert()
	{
		int hilf;
		
		hilf = zo;
		zo = zu;
		zu = hilf;
		if(is_db)
		{

			hilf = no;
			no = nu;
			nu = hilf;
		}
		return;
		
	}
	
	
	//Liefert Zähler
	public int get_z()
	{
		return zo;
	}
	
	//Liefert Nenner
	public int get_n()
	{
		return zu;
	}
	
	//Diese Methode berechnet den Größten Gemeinsamen Teiler nach Euklid
	//und dient zum Kürzen der Brüche
	private int ggt(int a, int b)
	{
		//ggt Nach dem #Algorithmus von Euklid berechnen
		int h,r;
		//a und b positiv machen
		if(a <0) a *= -1;
		if(b <0) b *= -1;
		if (a>b)
		  {
		  	h=a;
		  	a=b;
		  	b=h;} // sorge dafür, dass a<=b gilt
		  	
		while (a>0)
		{
			r = b%a; // r = Rest bei Division b durch a
			b=a; 
			a=r;
	    }
		return b;
	}
	
	//Addiert Bruch b zum aktuellen dazu	
	public void addiere(bruch b)
	{
	zo = zo*b.get_n() + b.get_z()*zu; //zaehler
	zu = zu*b.get_n(); //nenner	
	return;
	}
	
	//Subtrahiert b
	public void subtrahiere(bruch b)
	{
		b.negiere_bruch();
		addiere(b);
		return;
	}
	
	//multipliziert den aktuellen bruch mit b
	public void multipliziere(bruch b)
	{
		zo *= b.get_z();
		zu *= b.get_n();
		return;
	}
	
	//Dividiert den aktuellen bruch durch b
	public void dividiere(bruch b)
	{
		b.kehrwert();
		multipliziere(b);
		return;
	}
	
	//Kürzt den bruch
	public void kuerze()
	{
		int t;
		t = ggt(zo, zu);
		zo /= t;
		zu /= t;
		if(zu <0)
		  {
		  	zo *= -1;
		  	zu *= -1;
		  }
		
		return;
	}
	
	//Üerprüft ob der bruch inm gültigem bereich liegt
	public boolean valid()
	{
		if((zo >= 100) || (zo <= -100)) return false;
		if((zu >= 100) || (zu <= -100)) return false;
		if((no >= 100) || (no <= -100)) return false;
		if((nu >= 100) || (nu <= -100)) return false;
		
		return true;
		
	}
	
	//Wandelt den Bruch in einen String um, wird bei Ausgabe benötit
	public String toString()
	{
		if (zo == 0) return "0";
  	    if (is_db)  return String.valueOf(zo)+"/"+String.valueOf(no+"//"+zu)+"/"+String.valueOf(nu);
		return String.valueOf(zo)+"/"+String.valueOf(zu);
	}
}