# Pi auf 10000 Stellen berechnen



## dodel88250 (21. Aug 2012)

Hi Leute,

erstmal großes Lob an euer Forum, es hat mich schon oft weiter gebracht!

Leider habe ich zu diesem Thema noch nichts gefunden, ich hoffe aber ihr könnt mir weiterhelfen.

Meine Aufgabe ist es, ein JAVA-Programm zu entwickeln, welches Pi auf 10000 Stellen berechnet. Dabei darf die math-Klasse nicht verwendet werden.
Bislang hatte ich einige Ansatze hierfür, jedoch war keiner zielführend. Ich habe einige Ansätze und Formeln zur Berechnung von PI. Jedoch scheitere ich an dem Problem der Nachkommastellen. Nun wollte ich fragen, wie ich sowas am besten bewerkstellige, da so viele Nachkommastellen in keinen vorgegeben Datentyp passen. Von der Aufgabenstellung her wurde mir empfohlen ein Array zum Speichern der Stellen zu verwenden. Jedoch ist mir unklar, wie ich einzelne Stellen zur Laufzeit extrahieren kann.

Über eure Hilfe würde ich mich sehr freuen! 


Viele Grüße


----------



## Mujahiddin (21. Aug 2012)

[WR]Folgender Code ist eine Lösung des Problems. Falls du selbst draufkommen willst, nicht angucken![/WR]


```
public static double approximate(int precision) {
	return 4 / rApproximate( precision, 1 );
}

private static double rApproximate(int precision, int depth) {
	if( depth <= precision )
		return 2 * depth - 1 + depth * depth / rApproximate( precision, depth + 1 );
	return 1;
}

public static void main(String[] args) {
	int precision = 4; // auf 4 Nachkommastellen genau
	double pi = approximate( precision * 2 );
	double pow = Math.pow( 10, precision );
	double rounded = (long) ( pi * pow ) / pow;
	System.out.println(rounded);
}
```


----------



## nillehammer (21. Aug 2012)

Schließt das Verbot der "math-Klasse" auch die anderen Klassen dieses Packages mit ein? Spontan würde ich nämlich sagen, dass das Ergebnis der Berechnung ein BigDecimal sein könnte. Falls nicht, könnte ich mir ein bye-Array mit 1000 Stellen zur Speicherung der Nachkommastellen vorstellen. Ungefähr so:

```
final byte nachKommaStellen = new byte[1000];

for(int i=0; i< nachKommaStellen.length; i++ {
  nachKommastellen[i] = calcStelle(i);
}

private byte calcStelle(final int stelle) {

  // hier der Berechnungscode
}
```
Zur "Berechnung" von Pi kann ich leider nichts beitragen, weil ich da in Mathe nicht aufgepasst habe.


----------



## dodel88250 (21. Aug 2012)

Vielen Dank für deine schnelle Antwort!
Diese Möglichkeit kam mir auch in den Sinn. Problematisch ist aber, dass ich nicht weiß, wie ich Pi  stellenweise berechnen und in ein Array packen kann, sodass am Ende eine 10000stellige Zahl dabei herauskommt.


----------



## Templarthelast (21. Aug 2012)

Nimm einfach die Klase Bicdecimal und dann mit der Formel 
	
	
	
	





```
1/4pi = 1 - 1/3 - 1/5 - 1/7 - 1/9 - ...
```
 Pi auf die gewünschte Anzahl von Stellen berechnen.


----------



## dodel88250 (21. Aug 2012)

Mujahiddin hat gesagt.:


> [WR]Folgender Code ist eine Lösung des Problems. Falls du selbst draufkommen willst, nicht angucken![/WR]
> 
> 
> ```
> ...


Vielen Dank für die schnelle Antwort.

Funktioniert das auch auf 10000 Nachkommastellen? Ich bräuchte hier ja auch wieder eine Variable, welche 10000+1 Stelle speichern kann. Beziehungsweise wie könnte ich das Ergebnis stellenweise in ein Array abspeichern?


----------



## Deros (21. Aug 2012)

Templarthelast hat gesagt.:


> Nimm einfach die Klase Bicdecimal und dann mit der Formel
> 
> 
> 
> ...



falsche Formel die Leibnizreihe ist richtig


```
1/4pi = 1 - 1/3 + 1/5 - 1/7 + 1/9 +- ...
```


----------



## nillehammer (21. Aug 2012)

@Deros/Templarthelast: Könnt Ihr den Algorithmus hinter der von Euch skizzierten Formel noch kurz in Worte fassen? Damit müsste der TO dann in der Lage sein, das ganze in einer Schleife runterlaufen zu lassen.


----------



## tribalup (21. Aug 2012)

Leibniz-Reihe ? Wikipedia

Sry ich verlinke nicht gerne Wiki aber was sein muss. Da steht alles drin.


----------



## Deros (21. Aug 2012)

kurz der Algorithmus versucht in Worte zu fassen:
 eine Schleife mit 0.5*10^10000 Durchgängen (siehe Konvergenzgeschwindigkeit in schon genannten Artikel)
Vom Startpunkt x=0 wird abwechselnd 1/y addiert und subtrahiert wobei der divisor y (der bei 1 anfängt) immer um 2 steigt, sprich 1/1,1/3,1/5,...


----------



## Mujahiddin (21. Aug 2012)

Alles schön und gut aber nichts, was ich nicht schon gepostet hätte.
Das geht übrigens auch auf 10.000 Stellen, nur musst du da BigDecimal verwenden. Das folgende ist die Lösung... in etwa ( !! ). Ich weiß nicht, wie man den Zusammenhang zwischen Anzahl der Tiefe (des Rekursionsbaums) und Anzahl der Nachkommastellen kriegt. Aber das sei dem Geprüften überlassen. 

```
import java.math.BigDecimal;
import java.math.MathContext;


public class Test {
	
	private static final BigDecimal PI = new BigDecimal( "3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093844609550582231725359408128481117450284102701938521105559644622948954930381964428810975665933446128475648233786783165271201909145648566923460348610454326648213393607260249141273724587006606315588174881520920962829254091715364367892590360011330530548820466521384146951941511609433057270365759591953092186117381932611793105118548074462379962749567351885752724891227938183011949129833673362440656643086021394946395224737190702179860943702770539217176293176752384674818467669405132000568127145263560827785771342757789609173637178721468440901224953430146549585371050792279689258923542019956112129021960864034418159813629774771309960518707211349999998372978049951059731732816096318595024459455346908302642522308253344685035261931188171010003137838752886587533208381420617177669147303598253490428755468731159562863882353787593751957781857780532171226806613001927876611195909216420198938095257201065485863278865936153381827968230301952035301852968995773622599413891249721775283479131515574857242454150695950829533116861727855889075098381754637464939319255060400927701671139009848824012858361603563707660104710181942955596198946767837449448255379774726847104047534646208046684259069491293313677028989152104752162056966024058038150193511253382430035587640247496473263914199272604269922796782354781636009341721641219924586315030286182974555706749838505494588586926995690927210797509302955" );
	
	private static int precision;
	
	public static BigDecimal approximate(int precision) {
		return BigDecimal.valueOf( 4 ).divide( rApproximate( precision, 1 ), Test.precision, BigDecimal.ROUND_HALF_UP );
	}
	
	private static BigDecimal rApproximate(int precision, int depth) {
		if( depth <= precision ) {
			BigDecimal b1 = BigDecimal.valueOf( 2 );
			b1 = b1.multiply( BigDecimal.valueOf( depth ) );
			b1 = b1.subtract( BigDecimal.ONE );
			BigDecimal b2 = BigDecimal.valueOf( depth * depth );
			BigDecimal result = rApproximate( precision, depth + 1 );
			b2 = b2.divide( result, Test.precision, BigDecimal.ROUND_HALF_UP );
			b1 = b1.add( b2 );
			return b1;
		}
		return BigDecimal.ONE;
	}
	
	public static void main(String[] args) {
		precision = 100; // auf 100 Nachkommastellen genau
		BigDecimal pi = approximate( precision * 2 );
		BigDecimal rounded = pi.round( new MathContext( precision ) );
		BigDecimal rounded2 = PI.round( new MathContext( precision ) );
		String s = rounded.toString();
		System.out.println( s );
		System.out.println( rounded2 );
		System.out.println( s.length() );
		System.out.println( rounded2.equals( rounded ) );
	}
}
```

Hinzu kommt noch, dass ab 1000 Stellen oder so irgendwas nicht stimmt.


----------



## Landei (21. Aug 2012)

Mit der Leibnitz-Reihe dürfte es schwierig werden, die gewünschte Genauigkeit zu erzielen, weil man sehr viele Glieder berechnen muss und sich deshalb die Rundungsfehler aufschaukeln. Am bequemsten ist die BBP-Reihe, die die isolierte Berechnung einer bestimmten Hexadezimalstelle erlaubt.


----------



## Deros (21. Aug 2012)

er darf die math-Klassen nicht verwenden von daher ist dein code eher unnütz.

wie komme ich also mit den primitven Datentypen aus? ich nehme meine zahl mit 10000 stellen und zerlege sie an der maximalen stelle die mein Datentyp noch fassen kann oder einer die mir sinnvoll erscheint und lege sie in das array. dann habe ich an der stelle array[0] die ersten 100 und im array[1] die nächsten 100.


----------



## pasvadin (26. Aug 2012)

Hallo liebe Community. 
Ich arbeite mit dodel88250 zusammen an dem oben beschriebenen Problem. 

Erstmal vielen Dank für die bisher vielen Beiträge. Jedoch liegt das Problem wie Deros hervorgehoben hat darin, dass die Aufgabenstellung deutlich die Verwendung der Klasse math verbietet. Somit gibt es für uns auch keinen Zugang zum Datentyp BigDecimal. 

@Deros: Dass wir das Ergebnis einfach aussplitten ist uns auch schon in den Sinn gekommen. Jedoch hängt es momentan noch etwas an der Umsetzung. Das Problem ist ja, dass bei vielen Folgen an irgendeinem Punkt Folgenglieder entstehen, welche an sich schon mehr als 10000 Stellen haben, was natürlich zwingend für ein Ergebnis mit 10000-stelliger Genauigkeit ist. Ebenso wüsste ich nicht, wie man ein Ergebnis über mehrere Variablen aufteilt. 

@Landei: Die Verwendung der BBP-Reihe ist mir bei der Recherche auch in den Sinn gekommen. Leider fand ich sämtliche Ausführungen hierzu doch recht komplex und schwer verständlich. Sämtliche Quellen erwähnen zwar, dass es möglich ist einzelne Stellen zu berechnen ohne die vorherigen zu kennen, jedoch habe ich keine Beispiele gefunden, wie dergleichen programmiert werden muss. Wenn Sie also wissen wie man diese Reihe anwendet, dann wäre ich über Ihre Hilfe sehr dankbar.

Im Moment versuchen wir die Berechnung mittels der Taylorreihe der arcsin-Funktion (Arkussinus und Arkuskosinus ? Wikipedia). Dabei ergibt die Belegung von x mit 0,5 Pi. Das Programmieren dieser Funktion ist an sich keine Schwierigkeit. Das Schwierige ist die Umsetzung mit Arrays. Da wir wie oben beschrieben irgendwann Folgenglieder mit mehr als 10000 Stellen haben. Müssen bereits die einzelnen Bestandteile der Folge als Array vorliegen. Nun müssen wir die Grundrechenarten (+,*,/) mit Arrays nachschreiben. 
Hat irgendjemand hier schon Erfahrung damit gemacht? Im Prinzip läuft es auf eine Implementierung der Rechenweise aus der Grundschule zurück, also schriftlich Addieren, Multiplizieren und Dividieren. 
Hierzu habe ich bereits viele Stunden Sucharbeit aufgewendet um wenigstens ein Struktogramm für diese doch recht aufwendige Implementierung zu finden. Leider wurde ich hierbei nicht fündig.
Über Hilfe würde ich mich sehr freuen.

Mit freundlichen Grüßen, 

pasvadin


----------



## Landei (26. Aug 2012)

Hier ist der Code in Python, ist nicht viel und sollte leicht zu übersetzen sein: http://en.literateprograms.org/Pi_with_the_BBP_formula_(Python)

Die Umwandlung von hexadezimal zu dezimal müsste man mit 
	
	
	
	





```
BigInteger
```
hinbekommen, die einen entsprechenden Konstruktor hat (diese muss man natürlich noch durch 16^Stellenzahl dividieren, um auf die richtige 
	
	
	
	





```
BigDecimal
```
zu kommen).


----------



## Mujahiddin (26. Aug 2012)

@Landei:
Sie dürfen keine math-Klassen verwenden.
Das muss anscheinend alles im Array geschehen...
Übrigens ist dein Link falsch, die letzte Klammer muss noch in den Link mit rein.

Das ist ziemlich schwer, was ihr machen müsst. Hat euer Dozent keine Anhaltspunkte geliefert?


----------



## pasvadin (27. Aug 2012)

Die Anhaltspunkte waren: 

die Funktion arcsin(x) mit der entsprechenden Formel, die bei Eingabe von 0,5 Pi ergibt,

die Verwendung von Arrays, bei denen jede Stelle im Array eine Stelle einer Zahl darstellt, also ein Array aus einstelligen Integers

und das Nachprogrammieren der Grundrechenarten (int[]+int[],int[]*int[],int[]/int[]).


----------



## pasvadin (27. Aug 2012)

Ich muss mich selbst verbessern. Der arcsin von 0,5 ergibt nicht Pi sonder Pi/6.


----------



## Mujahiddin (27. Aug 2012)

Habt ihr diese Rechenoperationen bereits geschrieben?
Wenn ja, kann man darauf einiges aufbauen.
Wenn nein, habt ihr es versucht? Ich kann euch eine Addition von zwei int-Arrays geben, aber ihr solltet in der Lage sein, das selbst zu schreiben.


----------



## pasvadin (28. Aug 2012)

Hallo,

wir haben bereits ein paar der Rechenarten (Addition und Multiplikation). Zum Speichern der Zahlen verwenden wir Arrays, die abhängig von der Größe der Zahl unterschiedliche Größen haben. Da Kommazahlen auch vorkommen können, haben wir die Stelle [0] des Arrays als Zehnerexponent definiert. Damit stellt das Array im Bereich [1] - [n] eine Ganze Zahl dar. Eine linksverschiebung der Kommastelle ist nicht vorgesehen, also wird [0] >= definiert, wobei der Exponent dann jeweils -[0] wäre. 
Ich hoffe das war soweit verständlich. Ansonsten hätte ich nachfolgend noch den Code für die Addition und Multiplikation.

Addition:

```
public static int[] add(int[] x, int[] y){ //funktion f01
		
		//konvertierung in gleich lange arrays mit gleicher nachkommazahl
		
		int[][] ab=makeComparable(x,y);
		int[] a = ab[1];
		int[] b = ab[2];
		int laenge = a.length;
		
		//berechnung
		int[] result = new int[laenge];
 		
		result[0] = a[0];
		
		for (int i=laenge-1; i>0; i--){
			result[i] = 0;
		}
		for (int i=laenge-1; i>=1; i--){
			result[i] = result[i]+a[i]+b[i];
			if (result[i]>=10){                      //Übertrag wird berechnet
				result[i] = result[i]-10;
				result[i-1] = 1;
			}
		}
		
		return result;
	}
```

und Multiplikation:


```
public static int[] multiply(int[] a, int[] b){ //funktion f02

//Die Multiplikation ist implementiert wie das schriftliche Multiplizieren, es wird jede ziffer der 2. zahl(von vorne angefangen) mit jeder ziffer der 1. zahl (von hinten angefangen) durchmultipliziert. 
//Eine neue Ziffer der 2. Zahl bedeutet eine neue Zeile in der verwendeten Matrix. Diese wird um eins nach rechts versetzt begonnen.
//Erst am Ende werden die Zeilen zusammenaddiert
		
		int la = a.length;
		int ylength = b.length;
		
		int xlength = la+ylength;    // mit xlength und ylength sind die maße der berechnungsmatrix gemeint
		
		int[][] result = new int[ylength][xlength]; 
		
                // sämtliche Felder der Matrix auf 0 setzen
		
               for (int i = 0; i<result.length; i++){
			for (int k = 0; k<result[0].length; k++){
				result[i][k] = 0;
			}
		}
		
		for (int i = 1; i<ylength; i++){
			
			for (int k = la-1; k>=1; k--){
				
				result[i][xlength-ylength+i-((la-1)-k)] =result[i][xlength-ylength+i-((la-1)-k)]+ (b[i] * a[k]);   //versuch nr 3
				
				//>>>>>>>>>>>>>>>>>> ÜBERTRAG <<<<<<<<<<<<<<<<<<<<
				
				if (result[i][xlength-ylength+i-((la-1)-k)] >= 10){  //wenn ein übertrag verrechnet werden muss
				
					result[i][xlength-ylength+i-((la-1)-k)-1] = result[i][xlength-ylength+i-((la-1)-k)-1] + result[i][xlength-ylength+i-((la-1)-k)] / 10; //passt
					result[i][xlength-ylength+i-((la-1)-k)] = result[i][xlength-ylength+i-((la-1)-k)] % 10;
														
				}
			}
		}
		
		for (int k = xlength-1; k>=1; k--){
			for (int i = 1; i< ylength; i++){
				
				result[0][k] = result[0][k] + result[i][k];
				
				if (result[0][k] >= 10){
					
					result[0][k-1] = result[0][k-1] + (result[0][k]/10);
					result[0][k] = result[0][k] % 10;
					
				}
			}
		}
		
		result[0][0] = a[0]+b[0];
		
		return result[0];
	}
```

bei der Addtion verwende ich ein Modul, welches zwei Zahlen-Arrays auf dieselbe Größe und die entsprechende Potenz bringt. Dieses enthält aber noch irgendwo einen Fehler, den ich bisher nicht finden konnte. Dieser äußert sich insofern, dass die zweite Zahl nicht kürzer sein kann als die erste. Anders herum ist dies aber möglich. 


```
public static int[][] makeComparable(int[] x, int[] y){ //modul m03    

		//verändert zwei int-arrays so, dass sie die gleich länge und die gleiche anzahl an kommastellen besitzen
		//muss verwendet werden um mit arrays rechnen zu können
		
		int kommaDifferenz=0,     //Exponent wird verglichen
			laengeDifferenz=0,  //länge der Arrays werden verglichen
			startA = 0, 
			startB = 0, 
			endA = 0, 
			endB = 0, 
			laenge = 0,
			kommastellen = 0;
			
			int[] a,b;
				
			//nachkommastellen werden verglichen
				
			if (x.length>y.length){
				laengeDifferenz = x.length - y.length;
				startB = laengeDifferenz;
				laenge = y.length;
			}
			else{
				laengeDifferenz = y.length - x.length;
				startA = laengeDifferenz;
				laenge = x.length;
			}
			
			if (x[0]>y[0]){
				kommaDifferenz = x[0]-y[0];
				startA = kommaDifferenz;
				endB = kommaDifferenz;
				kommastellen = x[0];
			}
			else{
				kommaDifferenz = y[0]-x[0];
				startB = kommaDifferenz;
				endA = kommaDifferenz;
				kommastellen = y[0];
			}
			
			laenge = laenge + laengeDifferenz + kommaDifferenz + 1; //falls an der ersten stelle ein übertrag geschieht
			startA ++;
			startB ++;
			
			endA = laenge-endA;
			endB = laenge-endB;
					
			a = new int[laenge];
			b = new int[laenge];
			a[0] = kommastellen;
			b[0] = kommastellen;
			
			for (int i=1; i<laenge; i++){
				if (i>startA && i<endA) {
		 			a[i]=x[i-startA];
				}
				else{
					a[i]=0;
				}
				if (i>startB && i<endB) {
					b[i]=y[i-startB];
				}
				else{
					b[i]=0;
				}
			}
			
		int[][] ausgabe = new int[3][];	
		
		ausgabe[1] = a;
		ausgabe[2] = b;
		
		return ausgabe;
		
	}
```

Ich weiß nicht genau ob der Code in dieser Art und Weise klar ist. Sollte er es nicht sein würde ich selbstverständlich entsprechende Stellen ausführlicher dokumentieren.

Viele Grüße, 

pasvadin


----------



## Mujahiddin (29. Aug 2012)

Wie sollen eigentlich Kommastellen in dem Array dargestellt werden?


----------



## 127.0.0.1 (29. Aug 2012)

dodel88250 hat gesagt.:


> Pi auf 10000 Stellen



Pi 3.14159, Pi-Nachkommastellen druckbereit, zahlen-erotisches Material


----------



## pasvadin (29. Aug 2012)

Mujahiddin hat gesagt.:


> Wie sollen eigentlich Kommastellen in dem Array dargestellt werden?



Wir übertragen momentan Kommazahlen in die wissenschaftliche Schreibweise mit ganzzahliger Mantisse. Die Stelle [0] jedes int-Arrays gibt den Exponenten an. Die Wert an der Stelle [0] werden nur im Betrag, also positiv verwendet, da wir eine links-Verschiebung des Kommas nicht vorgesehen haben.

Beispiel: 3.14159265358 wäre dann umgeschrieben: [11][3][1][4][1][5][9][2][6][5][3][5][8]. 

Somit sind von dieser Zahl die letzten 11 Ziffern hinter dem Komma.

Viele Grüße,

pasvadin


----------



## pasvadin (1. Sep 2012)

Ich hätte das Programm soweit fertig. Jetzt ist das größte Problem noch die Performanz. Die größten Geschwindigkeitseinbußen gibt es bei der Division. Anbei findet sich der Code dazu. 

```
public static int[] divide(int[] a, int[] b){
		
		int[][] ab = makeComparable(a,b);
		a = ab[1];
		b = ab[2];
		int foundResult = 0;
		int foundMaxDiv;
		int[] c = new int[a.length];
		int[] neun = new int[2];
		neun[1] = 9;
		int i=1;
		int temp;
		
		while (foundResult==0){   // 1 = gefunden
			foundMaxDiv=0;
			for (int n=9; ((n>=0)&&(foundMaxDiv==0)&&(foundResult==0)); n--){//&&(foundMaxDiv==0)
				c[i]=n;
				temp = compare(multiply(b,c),a);
				if (temp==3){
					foundResult = 1;						//foundResult = 1 bedeutet dass das ergebnis stimmt
				}
				else if (temp==2){
					foundMaxDiv=1;							//foundMaxDiv = 1 bedeutet, dass die momentane Stelle stimmt
				}
			} //schleife bis 0 wiederholen umd die richtige Stelle zu finden
			
			if (foundResult==0){                //wenn kein Ergebnis bisher gefunden wurde, ist bisher nur die Stelle richtig, das heißt es muss eine weitere Stelle angefügt werden

				i++;
				if (i>100){              //müsste etwa bei +10000 stellen liegen, damit unendliche zahlen keine endlosschleife erzeugen
					foundResult=1;
				}
				else if (i>=c.length){
					c = enlargeArray(c,1).clone();
				}
				else if (b.length>a.length){
					c[0]++;
				} 

			}
			
		}  //while
		c = compressArray(c,0,2).clone();
		
		return c;
	}
```
Wenn nun ein unendlich periodischer Bruch auftritt stecke ich prinzipiell in einer Endlosschleife. Um da wieder rauszukommen habe ich eine Abbruchbedingung einprogrammiert, dass wenn die n-te (im jetzigen Fall 100ste) Stelle erreicht ist, das Ergebnis als richtig angesehen wird. 

Das Problem ist nun, dass ich auf 10000 Stellen rechnen muss, d.h. bei periodischen Brüchen muss bei der Division die Schleife 10000 mal durchgegangen werden, um eine entsprechende Genauigkeit zu erreichen. Das dauert natürlich. Nun muss diese Prozedur entsprechend oft wiederholt werden. Ich habe aber schlecht Lust für dieses Programm meinen Rechner eine Woche durchlaufen zu lassen. 

Am geschicktesten wäre es natürlich, wenn das Programm von sich aus merken würde, wann ein periodischer Abschnitt erreicht ist und diesen dann einfach in die folgenden Felder einfügen würde. 

Wenn hier irgendjemand eine Idee hätte wäre das super.
Ansonsten wären Tipps zur Performanzsteigerung in meinem Code auch sehr willkommen.

Viele Grüße,

pasvadin


----------



## pasvadin (3. Sep 2012)

Hallo nochmal,

das Programm läuft soweit, es ist dabei zwar nicht sonderlich performant aber ich werde es jetzt dabei belassen. Es gibt nur noch ein paar Probleme bei denen ich nicht weiterkomme: 

1.) Java Speicherbereich. Da recht mehrdimensionale Arrays verwendet werden ist der Java zur Verfügung stehende Speicherplatz irgendwann zu Ende.

```
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
	at piberechnen.multiply(piberechnen.java:260)
	at piberechnen.piBerechnen(piberechnen.java:63)
	at piberechnen.main(piberechnen.java:13)
```
Hier habe ich gegoogelt und ich habe herausgefunden, dass der Speicher vergrößert werden kann. Dies scheint einmal über die eclipse.ini Datei zu gehen, wobei 
	
	
	
	





```
-Xmx<n>m
```
, mit <n> als neuem Speicher verwendet werden muss. Diese Änderung in der .ini Datei hat keine Veränderung mit sich gebracht. Ebenso las ich, dass eine Ausführung über die Konsole möglich wäre, woraufhin der 2. Fehler aufgetreten ist(siehe 2.). Hierfür müsste der oben genannte Paramter an den ausführenden Befehl angehängt werden. Diese Option konnte ich bisher nicht austesten, da Fehler 2 aufgetreten ist.

2.) Kompilieren des Programms. Es ist mir zwar möglich über "File -> Export" eine .jar datei des Programms zu erstellen, jedoch lässt sich diese nicht ausführen. Bei der Eingabe in der Konsole "java -jar piberechnen.jar" tritt diese Ausnahme auf.

```
Exception in thread "main" java.lang.UnsupportedClassVersionError: piberechnen (
Unsupported major.minor version 50.0)
        at java.lang.ClassLoader.defineClass0(Native Method)
        at java.lang.ClassLoader.defineClass(Unknown Source)
        at java.security.SecureClassLoader.defineClass(Unknown Source)
        at java.net.URLClassLoader.defineClass(Unknown Source)
        at java.net.URLClassLoader.access$100(Unknown Source)
        at java.net.URLClassLoader$1.run(Unknown Source)
        at java.security.AccessController.doPrivileged(Native Method)
        at java.net.URLClassLoader.findClass(Unknown Source)
        at java.lang.ClassLoader.loadClass(Unknown Source)
        at java.lang.ClassLoader.loadClass(Unknown Source)
        at java.lang.ClassLoader.loadClassInternal(Unknown Source)
        at java.lang.Class.forName0(Native Method)
        at java.lang.Class.forName(Unknown Source)
        at org.eclipse.jdt.internal.jarinjarloader.JarRsrcLoader.main(JarRsrcLoa
der.java:56)
```
Ich habe zwar bereits nach dieser Exception gegoogelt, jedoch habe ich dabei keine Lösung zu dem Problem gefunden. 

Das Problem ist auch, dass wir zur Abgabe des Projekts zusätzlich zur .java Datei auch eine ausführbare Datei mitliefern müssen. Jedoch sollte diese auch funktionieren.

Über Hilfe würde ich mich sehr freuen.

Viele Grüße, 

pasvadin.


----------



## SlaterB (3. Sep 2012)

> Diese Änderung in der .ini Datei hat keine Veränderung mit sich gebracht.

Eclipse hat genug Speicher, du musst für die Ausführung eines Programm Runtime-Argumente übergeben, unter Run as ..,
oder in der Konsole bei einem java-Aufruf

---------


was liefert 
java -version 
in der Konsole?

und was liefert in Eclipse ein einfaches Programm

```
public class Test
{
    public static void main(String[] args)
    {
        System.out.println(System.getProperty("java.version"));
    }

}
```
?

manchmal gibts in Windows-Systemordnern auch irgendwo eine java.exe, die bevorzugt dran kommt,
dann kann helfen im Path das Java-Verzeichnis nach vorne zu stellen

bzw. testweise das jar in das bin-Verzeichnis der JRE verschieben und dort java aufrufen, geht es dort?


----------



## pasvadin (7. Sep 2012)

Tut mir Leid, dass ich mich eine Weile nicht gemeldet habe, aber ich komme jetzt in die Prüfungsphase und von der Zeit her wird da alles etwas eng.

In eclipse ist die Ausgabe: 

```
1.7.0_05
```

In der Konsole: 

```
java version "1.7.0_05"
Java(TM) SE Runtime Environment (build 1.7.0_05-b05)
Java HotSpot(TM) 64-Bit Server VM (build 23.1-b03, mixed mode)
```

Ich habe versucht via 
	
	
	
	





```
-Xms1024M
```
 in der Konsole den Speicher zu vergrößern, aber derselbe Fehler tritt auf:

```
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
```
.

Das Kompilieren der .jar Dateien funktioniert jetzt, wieso es vorher nicht ging kann ich nicht sagen. :/ 

Desweiteren sehe ich ein weiteres Problem darin, dass wir das Programm in dieser Form ausgeben müssen, dabei ist jedoch nicht klar ob es auf dem Rechner unseres Profs funktioniert.

Viele Grüße,

pasvadin


----------



## Mujahiddin (7. Sep 2012)

Das musst -Xmx sein


----------



## pasvadin (8. Sep 2012)

So ich habe dasselbe mal mit -Xmx ausprobiert. Im Endeffekt gewinne ich zwei Schleifendurchläufe dazu, bis derselbe Fehler wieder kommt.


----------

