# Bruch rechnen



## Lisachen (16. Mai 2010)

Hey!

Ich soll in meine Klasse Bruch folgende Methode schreiben:

public Bruch mul(double scalar) - Multiplikation mit Skalar ( Approximiere die Fließkommazahl mit einem Bruch)

Wie kann ich denn bitte irgendein double mit einem Bruch approximieren??????

Folgende Teilaufgabe bereitet mir auch Kopfschmerzen:

Implementiere eine Methode void kuerzen(). (Soweit klar..)
Dann eine für alle Brüche global, einheitlich kofigurierbare, private boolesche und statische Variable private static boolean automatischKuerzen mit statischen "Settern" und "Gettern". Ist diese "Flag"-Variable True, so soll nach jeder Operation automatisch die Kürzen Routine auf das entsprechende Ergebnis angewendet werden.

????????Kann mir das bitte jemand auf meine Idiotensprache übersetzen, weil ich weiß leider nicht was man von mir will 

Vielen Dank!


----------



## Marco13 (16. Mai 2010)

Das approximieren kann ziemlich ... "tricky" sein, und funktioniert auch nur in gewissen grenzen. Wenn man also mal davon ausgeht, dass dort nicht 10^(-25) übergeben wird, sondern eine Zahle wie 123.456, dann kann man sagen, dass das ja 123456/1000 sind...

_Dann eine für alle Brüche global, einheitlich kofigurierbare, private boolesche und statische Variable private static boolean automatischKuerzen mit statischen "Settern" und "Gettern". Ist diese "Flag"-Variable True, so soll nach jeder Operation automatisch die Kürzen Routine auf das entsprechende Ergebnis angewendet werden._

Code sagt mehr als 1000 Worte

```
class Bruch
{
    private static boolean automatischKuerzen = false;

    // statische set/get-Methoden, um diese Variable abzufragen und zu ändern


....

    void rechneWas()
    {
        ... rechne, rechne, rechne...
        if (getAutomatischKuerzen())
        { 
            kuerze();
        }

    }
```


Eigentlich geht's nur um den ggt. Man sagt ja auch: In der [c]kuerze()[/c] liegt die [c]wuerze()[/c]


----------



## faetzminator (16. Mai 2010)

[Müll/]


----------



## Lisachen (17. Mai 2010)

Super, danke!

Das heißt also, ich muss bei meiner Zahl die Stellen vor dem Komma zählen + 1 rechnen und je nachdem einen 1 + dementsprechend viele Nullen.. 
Hm, doch wie tu ich das?? Wie sind Java Codes dafür?

Zu 2. ..
Also im Grunde schau ich, ob der ggT 1 ist und ob ich kuerzen muss??
Nur was bedeuten, denn all diese Wörter, "settern" "gettern" "Flag" - Variable für mein Beispiel?? =/


----------



## Lisachen (17. Mai 2010)

Also hier ist z.B. meine Additionsmethode:

```
public Bruch add(Bruch other){
		this.z = z * other.n + other.z * n;
		this.n = n * other.n;
		if (getAutomatischKuerzen()){
			kuerzen();
		}
}
```

War das so gemeint??


----------



## Marco13 (17. Mai 2010)

Ja, ich denke schon.


As Umwandeln von double in einen Bruch ist nicht ganz so einfach, wie du beschrieben hast. Beispiele:
1.2 = 12 /10
1.23 = 123/100
12.3 = 123/10
Das, was hinter dem "/" steht, hängt von der Anzahl der Nachkommastellen ab. Aber die Zahl mit
String s = String.valueOf(theDoubleValue);
in einen String umwandeln, und dann zu zählen ist nicht verkehrt. (Wie gesagt: Das funktioniert so einfach nur, wenn man nicht eine Zahl wie 1e-8 (=0.00000001) hat...)


----------



## Landei (17. Mai 2010)

Lisachen hat gesagt.:


> Wie kann ich denn bitte irgendein double mit einem Bruch approximieren??????



Natürlich kann man ein double immer mit Zehnteln, Hundertsteln u.s.w. approximieren, aber die beste Approximation bekommt man mit Kettenbrüchen: Vergleiche mal die Genauigkeit von pi appoximiert als 314/100 und 355/113 (was sich aus der Kettenbruchentwicklung ergibt).


----------



## Lisachen (18. Mai 2010)

Ich habe es jetzt mit der einfachen Art approximiert... Nur jetzt meckert Java, dass ich am Schluss etwas vom Typ Bruch zurückgeben muss.. Aber das tu ich doch ee??!! Ich versteh den Fehler leider nicht..


```
public Bruch mul(double scalar){ 
	//Brüche multiplizieren
		
		//scalar zu Bruch approximieren
		
		int c;
		int f = (int)(scalar);
		if(f == scalar){
			c = 0;
		int zähler = (int)scalar;
		int nenner = 1;
		System.out.println("n = " + nenner + ", z = " + zähler);
		}
		
		else{
		String s1 = String.valueOf(scalar);
		String s2 = String.valueOf(f);
		int a = s1.length() - 1;
		//-1 da Komma mit gezählt wird
		int b = s2.length();
		//c ist Anzahl der Nachkommastellen
		c = a - b;
		//System.out.println(c);
		//Nenner berechnen
		int d = 1;
		//der Nenner ist 10 hoch c
		for(int j = 0; j < c; j++){
		   d = d * 10;
		}
		
		int nenner = d;
		double h = scalar * d;
		int zähler = (int)h;
		//System.out.println(f);
		//System.out.println("n = " + nenner + ", z = " + zähler);
		
		this.z = z * zähler;
		this.n = n * nenner;
		
		return new Bruch((int)z, (int)n);
		
		}
	}
```

was stimmt denn nicht


----------



## Blakh (18. Mai 2010)

Du gibst momentan nur den Bruch im else - Zweig zurück.


```
if(f == scalar)
```

Wenn das true ist, dann machst du nur eine Ausgabe, aber gibst keinen Bruch zurück. Entweder hast du da eine Klammer vekehrt gesetzt, oder du musst hier 

```
return null;
```
einfügen.


----------



## Gast2 (18. Mai 2010)

Wenn der if-Zweig deiner Methode durchlaufen wird gibst du nichts zurück 

Edit: zu langsam ;(


----------



## Lisachen (18. Mai 2010)

danke =) =) =)


----------



## Lisachen (18. Mai 2010)

Zuerst implementiere eine entsprechende Methode void kuerzen:

```
public int ggt(int value1, int value2){
		int h;
		//ggt berechnen
		while (value2 != 0){
			h = value2;
			value2 = value1 % value2;
			value1 = h;
		}
		int ggt = value1;
		return ggt;
	}
	
	public void kuerzen(){
		int g = ggt(z,n);
		z = z/g;
		n = n/g;
	}
```

oke, so weit so gut..

Dann eine für alle Brüche global, einheitlich kofigurierbare, private boolesche und statische Variable private static boolean automatischKuerzen mit statischen "Settern" und "Gettern". Ist diese "Flag"-Variable True, so soll nach jeder Operation automatisch die Kürzen Routine auf das entsprechende Ergebnis angewendet werden.

Ich versteh das noch immer nicht, tut mir leid.
Was soll ich tun??
Soll ich jetzt meinen Zähler und Nenner immer mit Set/get Methoden ausgeben lassen?
Oder wie soll ich wo diese Variable reinschreiben =//

Kann mir bitte jemand z.B. anhand meiner Additionsmethode erklären was ich tun soll..??!!


```
public Bruch add(Bruch other){
		this.z = z * other.n + other.z * n;
		this.n = n * other.n;
		return new Bruch((int) z, (int) n);
	}
```


----------



## Blakh (18. Mai 2010)

```
private static boolean automatischKuerzen = false;
```

Ok erstmal worum es geht: Du hast eine Variable vom Typ boolean (true/false). Die soll statisch sein, d.h. es gibt davon immernur 1; global, d.h. in deiner Klasse und nicht Methode deklariert und private, d.h. von außen kommt man da nicht ran.



> ... dass statische Variablen immer zur Klassendefinition selbst gehören und nicht mit einer neuen Instanz erstellt werden. Statische Variablen gelten also für alle Instanzen einer Klassendefinition.



Wird diese "flag" true gesetzt ... d.h. soviel wie signal ... , dann sollst du nach jeder Rechnung kürzen.

Damit du setzen und lesen kannst in einer anderen Klasse brauchst du getter/setter-methoden:


```
public void setAutomatischKuerzen(boolean a) {
   this.automatischKuerzen = a;
}

public boolean getAutomatischKuerzen() {
   return automatischKuerzen;
}
```

Wieso man das jetzt statisch gemacht hat, k.a. . Meiner Meinung nach unnötig?


----------



## Lisachen (18. Mai 2010)

Oke, vielen dank, dass hab ich jetzt (hoffentlich) großteils verstanden.. aber irgendwie sitz ich vollkommen auf der Leitung, wie ich das ganze in meine Rechenmethoden einfügen kann .. ???!!!


```
public Bruch add(Bruch other){
		this.z = z * other.n + other.z * n;
		this.n = n * other.n;
		if (getAutomatischKuerzen()!=a){
			kuerzen();
			}
		
		return new Bruch((int) z, (int) n);
		
	}
```

Diesen Ansatz hab ich, aber das stimmt ja so nicht..

Hilfe


----------



## Blakh (18. Mai 2010)

a ist nur eine Variable ... wusste nicht wie ich es nennen soll  . Sie steht für true oder false.


```
if (getAutomatischKuerzen()==true){
        kuerzen();
}
```

oder wie es besser ist :


```
if (getAutomatischKuerzen()){
        kuerzen();
}
```

getAutomatischKuerzen() lieftert true oder false, deshalb brauch man da nicht mehr vergleichen.

Zur Funktionsweise von getter/setter. Du setzt z.B. in deiner main: 



```
setAutomatischKuerzen(true);
```

Für die Methode lieferst du a = true und diese macht


```
this.atuomatischKuerzen = a;
```

du setzt die flag also auf true.


----------



## Lisachen (18. Mai 2010)

vielen dank, aber irgendwie blick ich noch immer nicht ganz durch...
ich hab jetzt alles so gemacht, wie du gemeint hast, nur weiß ich nicht wirklich in welche main Methode  ich 
"setAutomatischKuerzen(true);" hinschreiben soll 

also ich hab jetzt folgendes gemacht:


```
public class Bruch {
	int z, n;
	double e;
	private static boolean automatischKuerzen = false;
.
konstruktoren etc. ....
.
.
	public void setAutomatischKuerzen(boolean a){
		this.automatischKuerzen = a;
	}
	
	public boolean getAutmatischKuerzen(){
		return automatischKuerzen;
	}
	
	public Bruch add(Bruch other){
		this.z = z * other.n + other.z * n;
		this.n = n * other.n;
		if (getAutomatischKuerzen()){
			kuerzen();
			}
		
		return new Bruch((int) z, (int) n);
	}
```

was fehlt mir denn jetzt noch??

es tut mir wirklich leid, ich bin echt total schwer von begriff gerade.. =/


----------



## Blakh (18. Mai 2010)

Sieht schon ok aus .... vllt. der Schönheit wegen:


```
public void setAutomatischKuerzen(boolean automatischKuerzen){
        this.automatischKuerzen = automatischKuerzen;
    }
```

this.automatischKuerzen ist die globale Variable der Klasse und automatischKuerzen die lokale der Methode.

Und das 


```
private static boolean automatischKuerzen = false;
```

ohne = false ... mein Fehler. Die Initialisierung macht man bei Konstanten so. Die main - Methode hast du in der "Start"-Klasse deines Programmes und die sieht so aus:


```
public static void main(String[] args) {
// TODO Auto-generated method stub

}
```

In der Klasse Bruch wirst du die nicht haben. Was ist dir denn noch unklar?

Edit: Schreibfehler gefunden: public boolean getAut*o*matischKuerzen()

Wenn du weiterhin programmieren willst, dann nimm eine IDE (Entwicklertool) wie eclipse. Eclipse.org home

Das erschlägt dich vllt. am Anfang, weil du viel machen kannst, aber es hilft ungemein 

Edit 2: habe gelesen die "Getter" und "Setter" Methoden sollen statisch sein .. also noch ein static nach public einfügen.


----------



## Lisachen (18. Mai 2010)

Hmhm...
ich hab es jetzt in static umgewandelt.. also:

```
public static void setAutomatischKuerzen(boolean automatischKuerzen){
		this.automatischKuerzen = automatischKuerzen;
	}
	
	public static boolean getAutomatischKuerzen(){
		return automatischKuerzen;
	}
```

jetzt kommt allerdings eine Fehlermeldung, dass bei static Methoden kein this. existiert =/
Was schreib ich denn stattdessen??

Und dieses
"setAutomatischKuerzen(true);" hab ich in meine Main Methode eingefügt, aber es kann nicht gefunden werden.. aber ich hab das ganze doch in der Nebenklasse definiert =/ =/


----------



## Lisachen (18. Mai 2010)

Hab jetzt einfach "this" entfernt und die main Methode in die Bruch Klasse geschrieben.. Jetzt gibt mir Java zwar keine Fehlermeldung mehr aus, aber funktionieren tut es trotzdem nicht


----------



## Marco13 (18. Mai 2010)

Ja, bei einer statischen Methode gibt's kein "this" (war wohl ein Versehen von Blakh).

Die Methode könnte wohl 

```
public static void setAutomatischKuerzen(boolean automatischKuerzen){
        Bruch.automatischKuerzen = automatischKuerzen;
}
```
sein.

In der main-Methode kann man dann (z.B. direkt in der ersten Zeile) sowas schreiben wie
Bruch.setAutomatischKuerzen(true);
um das automatische Kürzen einzuschalten.


----------



## Lisachen (18. Mai 2010)

danke, dass hab ich jetzt gemacht, aber es funktioniert einfach trotzdem nicht.. ich versteh das nicht..
vllt. liegts an meiner kuerz methode??
[/code]
	public int ggt(int value1, int value2){
		int h;
		//ggt berechnen
		while (value2 != 0){
			h = value2;
			value2 = value1 % value2;
			value1 = h;
		}
		int ggt = value1;
		return ggt;
	}
	//Kuerzmethode
	public void kuerzen(){

		int g = ggt(z,n);
		this.z = z/g;
		this.n = n/g;
	}

```
fehlt da ein return in meiner void methode?? wenn ja, was soll ich da hinschreiben??

meine Rechenoperation sieht so aus 

[code=Java]
	public Bruch add(Bruch other){
		this.z = z * other.n + other.z * n;
		this.n = n * other.n;
		if (getAutomatischKuerzen()){
			this.kuerzen();
			}
		
		return new Bruch((int) z, (int) n);
		
	}
```

wo sonst mein Fehler liegen könnte, weiß ich wirklich nicht ... =(


----------



## Lisachen (18. Mai 2010)

sry hab das java ding oben falsch..


```
public int ggt(int value1, int value2){
		int h;
		//ggt berechnen
		while (value2 != 0){
			h = value2;
			value2 = value1 % value2;
			value1 = h;
		}
		int ggt = value1;
		return ggt;
	}
	//Kuerzmethode
	public void kuerzen(){
		
		int g = ggt(z,n);
		this.z = z/g;
		this.n = n/g;
	}
```


----------



## Blakh (18. Mai 2010)

Was funktioniert denn nicht? Wo ist denn deine main - Klasse?


----------



## Lisachen (18. Mai 2010)

Weiß jetzt leider nicht welche Main Klasse du meinst..

Kopier mal beide 


```
public static void setAutomatischKuerzen(boolean automatischKuerzen){
		Bruch.automatischKuerzen = automatischKuerzen;
	}
	public static void main(String[] args) {
		
		Bruch.setAutomatischKuerzen(true);
	}
	
	public static boolean getAutomatischKuerzen(){
		return automatischKuerzen;
	}
```

und die Ausgabe..


```
public static void main(String[] args) {
				
		
		Bruch b = new Bruch (2, 5);

		Bruch other = new Bruch(6, 10);

		System.out.println (b.add(other));
```


----------



## Blakh (18. Mai 2010)

Pro Programm hast du nur eine main ...


```
Bruch.setAutomatischKuerzen(true);
```


Das kommt mit in die Ausgabe ... deine Klasse Bruch ist sozusagen dein Bauplan fuer Objekte vom Typ Bruch mit den entsprechenden Eigenschaften und Methoden. Da ist keine Main drin. Von der Klasse erstellst du dir Objekte mit new Bruch(). Und mit den Objekten kannst du dann etwas machen. Z.B:


```
Bruch a = new Bruch (2, 5);
 
        Bruch b = new Bruch(6, 10);
/* du Rufst die Methode add vom Objekt b auf und uebergibst a 
(dass  die uebergebene Variable in der Methode other benannt ist, ist nur in der 
entsprechenden Methode relevant. Es zaehlt nur der Typ, naemlich Bruch.)*/
Bruch ergebnis = b.add(a);
```

Und dann kannst du z.B. deine Flag aktivieren, damit gleich gekuerzt wird.


```
/*// in allen Objekten vom Typ Bruch (statisch) wird die Variable 
automatischKuerzen auf true gesetzt*/
Bruch.setAutomatischKuerzen(true); 

Bruch ergebnis = b.add(a); // liefert jetzt ein gekuerzten Bruch
```

Ob du das dann so einfach mit System.out.println(ergebnis) ausgeben kannst, weiss ich nicht. Wenn dann da etwas kryptisches steht, dann ist es wahrscheinlich die Speicheraddresse des Objekts. Dann musst du die toString() - methode ueberschreiben. (System.to.println) ruft diese standardmaessig auf.


----------



## Lisachen (18. Mai 2010)

Es funktioniert!!!!!!!!!!!!!!!!!   
Juhu, juhu, jetzt wird gefeiert XD


----------



## HelftMir (29. Nov 2010)

Helft mir Bitte  ich verstehe diese Aufgaben nicht kann jemand die Aufgaben beantworten?

Schreibe als Bruch

a) 8  5/6=      b) 11 7/9=    c) 4  2/15=    e) 9 7/8=    f) 15  3/7=

Schreibe als gemischte Zahl

a)  18/7=    b)  40/3= c)  25/8=   d)  100/12=   e)  75/13=  f)  120/11=  g) 36/7=  h) 88/10=

Mache gleichnamig

a)  7/12 und 5/8  b) 5/14 und 9/7  c) 3/5 und 1/18  d) 5/9 und 1/12  e) 7/20 und 11/50  f 5/4 und 4/15


----------



## bone2 (29. Nov 2010)

das ist ein java und kein mathe forum?! wo ist das java problem?

die aufgaben sind so 5./6. klasse, schau mal in dein mathebuch, da wird bruchrechnung sicher erklärt


----------



## Andi_CH (29. Nov 2010)

DANKE, sonst bin ich immer der Böse :-(


----------



## Landei (29. Nov 2010)

Au Mann, was hat der Matheleerkörper da versagt! Aber da ich grade gute Laune habe...



HelftMir hat gesagt.:


> Helft mir Bitte  ich verstehe diese Aufgaben nicht kann jemand die Aufgaben beantworten?
> 
> Schreibe als Bruch
> 
> a) 8  5/6



8  5/6 ist eigentlich eine bequeme Schrweibweise für 8 + 5/6. Nun ist die 8 ein "ganzer Kuchen", denn man nicht ohne weiteres zu den Sechstel-Stücken dazuaddieren kann. Wenn man acht Kuchen hat, wieviel Kuchen-Sechstel bekommt man daraus geschnitten? Ich tippe mal auf ungefähr 48 (wenn ich den Kuchen schneiden darf, tendenziell weniger). Wir haben also 48 Sechstel-Stücken, dazu die 5 Sechstel-Stücken von ganz vom Anfang, das sind... Trommelwirbel... 53/6.



> Schreibe als gemischte Zahl
> 
> a)  18/7=



Das ist genau die umgekehrte Fragestellung. Wir haben 18 Siebtel-Stücken. Wieviele ganze Kuchen kann man damit "zusammensetzen" und was bleibt übrig? Mit 7 Stücken haben wir einen Kuchen, bleiben 11 Stücken. Davon nochmal 7 Stücken gibt einen weiteren Kuchen, wobei 4 Stücken übrigbleiben. Also insgesamt 2 Kuchen und 4 Stücken, also 2 4/7. Das Ganze Verfahren heißt "Division mit Rest", wofür es natürlich "ordentliche" Lösungswege mit Bleistift und Papier gibt, sonst wird man bei größeren Zahlen vom ganzen Kuchen-Subtrahieren noch hungrig.



> Mache gleichnamig
> 
> a)  7/12 und 5/8



Die 7 und die 5 spielen erst einmal keine Rolle, es geht darum, den Hauptnenner (oder kleinstes gemeinsames Vielfaches) von 12 und 8 zu finden. Dafür gibt es verschiedene Methoden, und ich weiß nicht, welche der Lehrer hier sehen will. Für kleine Zahlen kann man sich die eine nehmen und immer wieder addieren, bis sie durch die zweite teilbar ist.

12+12 = 24, und hurra, 8 teilt 24, damit ist 24 unser Hauptnenner (bei anderen Kombinationen muss man länger rechnen, etwa bei 5 und 7 kommt man zu 5,10,15,20,25,30,35, bis die 7 endlich die Zahl teilt). Wie gesagt, es gibt verschiedene Verfahren.

In Ordnung, so weit so gut. Wie mache ich jetzt aus 7/12 irgendwelche Vierundzwanzigstel? 12 = 2*24, also ist ein 1/12 auch gleich *zwei *mal 1/24. Dementsprechend sind 7/12 wegen 2*7=14 gleich 14/24. Das Gleiche für 8: 8 = 3*24, deshalb ist 1/8 auch gleich *drei* mal 1/24, und 5/8 wegen 5*3=15 auch 15/24. Unsere Brüche sind jetzt "gleichnamig": 14/24 und 15/24, jetzt kann man sie problemlos addieren oder subtrahieren.


----------

