Eulerschen Zahl

[chefkoch87]

Hallo Zusammen,

ich möchte folgendes darstellen:

1+1/1 + 1/(1+2) + 1/ (1*2*3) + 1/ (1*2*3*4).........bis 1/(1*2*3*4*5*6*7*8*9)

Das ist mein Programmcode, welchen ich mit Hilfe des Buches Java mit BlueJ rauskopiert habe.
Nun meine Frage wie ist der Ablauf der Methode.

Zunächst erfolgt der Ablauf der Schleife, das Ergebnis aus berechneFakultaet geht in den rekursiven Ansatz und prüft ob n = 0 ist, und dann?

	    public double eulerreihe()
	    {
	        double ergebnis = 1;
	        for (int i = 9; i >= 1; i--) {
	            ergebnis +=1/ berechneFakultaet(i); }
	        return ergebnis;
	    }
	    
	    // rekursiver Ansatz
	    public double berechneFakultaet(int n)						
	    {
	        if (n == 0)
	            return 1;
	        else
	            return n * berechneFakultaet(n - 1);
	    }
	

     
            public static void main(String args[]) {
                    test2 m2 = new test2();
     

     
                    System.out.println("eulerreihe ergibt: " + m2.eulerreihe());
 
     
            }}

 

[chefkoch87]

Hoffe ihr könnt mir weiterhelfen

 

[pappawinni]

Es wäre gut gewesen, wenn du die Klasse test2 vollständig gepostet hättest.
Der Code ist also abgeschrieben aus einem Buch, wo das ohnehin schon erklärt wird.
Da fragt man sich schon, ob da noch zu helfen ist.

Also vielleicht in Kürze..
In der main-Methode..
wird eine Instanz der Klasse

test2

mit dem Namen

m2

erzeugt.
Es folgt die Ausgabe des Rückgabewerts der Methode

eulerreihe()

von

m2

Die Methode

eulerreihe()

..
summiert für i von 1 bis 9 die Quotienten 1/Fakultät(i) zu 1
die Faktultät wird von der Methode berechneFakultaet(int n) geliefert.

Die Methode berechneFakultaet(int n)
ist eine rekursive Methode. D.h. die Methode benutzt sich selbst.

// rekursiver Ansatz

        public double berechneFakultaet(int n)                      
        {
            if (n == 0)
                return 1;
            else
                return n * berechneFakultaet(n - 1);        
        }

du siehst das hier

return n * berechneFakultaet(n - 1);

.
Damit die Rekursion nicht bis in alle Ewigkeit läuft, bzw. bis zum Crash..
braucht es da eine Abbruchbedingung.
Nehmen wir an die Methode wird mit berechneFakultaet(3) aufgerufen,
dann ist n=3 wodurch also der else-Fall eintritt, wo dann n * berechneFakultaet(2) berechnet werden soll..
dann ist n=2 wodurch also der else-Fall eintritt, wo dann n * berechneFakultaet(1) berechnet werden soll..
dann ist n=1 wodurch also der else-Fall eintritt, wo dann n * berechneFakultaet(0) berechnet werden soll..
dann ist n=0 wofür 1 als Ergebnis geliefert wird...
wodurch jetzt endlich das Ergebnis des vorangegangen Aufrufs geliefert wird, was wiederum das Ergebnis des vorangegangenen Aufrufs liefert.. usw..
Es wird also jetzt rückwärts aufgelöst.

 

[chefkoch87]

Super erklärt. Ich danke dir

 

[Landei]

Und ein richtig schlechtes Buchbeispiel. Warum wird die Fakultät nicht "nebenher" berechnet, wenn ich sowieso schon eine Schleife habe?

public double eulerreihe()  {
  double ergebnis = 1;
  double fac = 1;
  for (int i = 1 ; i < 10; i++) {
       fac *= i;
       ergebnis += 1 / fac
  }
  return ergebnis;
}

Nur so nebenbei: Für eine ganz genaue Berechnung gibt es bessere Wege, etwa über die Kettenbruchentwicklung.