Summenzeichen

[LuAn]

hi
gibt es einen befehl in java für das summenzeichen? oder wie kann ich einfach eine schöleife programmieren??
das ganze ist ein programm um pi zu berechnen und rechnet nach einer der Ramanujan-Formeln. Da wo summenzeichen als kommtentar steht fängt das summenzeichen an und bei ende soll es aufhören.

import java.math.*;
import java.math.BigDecimal;
class neupi
{
	public static void main(String[] args)
	{
		//Variablen Deklarieren
		double oben, mitte, unten, pi, untenmitte;
		int n;
		//Variablen initialisieren
		unten = 0;
		n = 0;
		mitte = 0;
		//Rechnung
		oben = 53360 * (Math.pow(640320, 0.5));
                                                //Summenzeichen
			mitte = facul(6*n) * (13591409+545140134 * n);
			untenmitte = facul(3*n) * Math.pow((8*100100025*327843840), n);
			unten = unten + Math.pow(-1, n) * (mitte / untenmitte);
                                                //ende
		pi = oben / mitte;
		System.out.println(pi);			
	}
	public static long facul (long n) 
		{
			if (n == 0)
				return 1;
			else		
				return n * facul(n-1);
		}
	}

 

[bygones]

Das geht nur über eine Schleife:

int summe = 0;
for(int i = 0; i < 100; i++) {
  sume += i;
}

 

[Beni]

Noch 1 oder 2 kleine Tipps:

Fakultät: speichere das Zwischenresultat, dann musst du nicht immer alles ausrechnen (dein Programm wird schneller).
Vorzeichen: ((n & 1 == 0) ? 1 : -1) dürfte ebenfalls schneller sein.
Alle Hochs: Basis speichern und parallel mitmultiplizieren.

Anzahl Durchläufe:
Wenn ich die Formel richtig verstanden habe geht es darum, dass sich ein Wert einer Grenze immer langsamer annähert. Jetzt kannst du messen, wann dieser Wert sich nicht mehr verändert (unter Ausnutzung der endlichen Rechengenauigkeit des Computers), und kommst so bis auf Maschinengenauigkeit an das Resultat heran (mehr geht nicht, ist aber auch noch unabhängig vom Datentyp und von der Hardware).

do{
     (...)
}
while( wert + veraenderung != wert )   // veraenderung wird immer kleiner

mfg Beni, der Student der von seinem Professor gequält wird. :###

 

[LuAn]

Danke für die Tips. werd ich bei zeiten mal ausproobieren. auch wenn ich das von beni nicht alles verstanden hab ;-)
(hab nicht sehr viel ahnung....)

 

[bygones]

Vorzeichen: ((n & 1 == 0) ? 1 : -1) dürfte ebenfalls schneller sein.

Habe ich richtig verstanden, dass soll angeben, ob n negativ oder positiv ist ??
Dann müsste es doch

((n & 256 == 0) ? 1 : -1)

heißen oder ?

 

[Beni]

Sorry, war ein bisschen unklar.

Wollte damit sagen: den Wert von Math.pow(-1, n) kann man schneller erhalten. (Das letzte Bit macht's aus, ob die n gerade oder ungerade ist, und (-1)^n gibt 1, wenn n gerade ist).

mfg Beni

 

[Nobody]

wenn ihr schneller rechnen wollt versucht mal das:

double pi = Math.ArcTan(1);
System.out.println(pi);

ist ne ganz gute näherung oder nach borland:

double pi=Math.PI;

den die schnellste variante um pi festzulegen, ist es auszulesen. schon schlau die jungs von borland

 

[Beni]

Ich hab die leise Vermutung das es hier darum geht PI auszurechnen, und nicht einfach den Wert zu erhalten.
Ansonsten hätte LuAn Pi einfach aus einem Formelbuch abgeschrieben...

P.S. bin mir nicht sicher, aber gehört Sun zu Borland?

 

[Nobody]

zum ausrechnen gabs auch ne variante:
4*arctan(1)

wenn sein muss, erklär ichs dir auch, wies funzt.
brauchst du noch mehr methoden?
hätte da das archimedes verfahren (er kannte noch keine sin, cos..... und arbeitete daher mit regelmässigen vielecken die sich durch 3*2^n beschreiben lassen)
überarbeites archimdes verfahren (mit sin...., mit regelmässigen vielecken)
dann wäre da noch das regentropfen oder montecarlo verfahren (für präsentationen wunderschön)
das wallis produkt

und vergesst nicht am 14.3 bzw 22.7 zu feiern