# Eulerschen Zahl



## chefkoch87 (18. Nov 2012)

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 (18. Nov 2012)

Hoffe ihr könnt mir weiterhelfen


----------



## pappawinni (18. Nov 2012)

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.



chefkoch87 hat gesagt.:


> // rekursiver Ansatz
> 
> ```
> public double berechneFakultaet(int n)
> ...



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 (18. Nov 2012)

Super erklärt. Ich danke dir


----------



## Landei (18. Nov 2012)

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.


----------

