Eulerschen Zahl

chefkoch87

Mitglied
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?

Java:
	    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());
 
     
            }}
 
P

pappawinni

Gast
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
Code:
test2
mit dem Namen
Code:
m2
erzeugt.
Es folgt die Ausgabe des Rückgabewerts der Methode
Code:
eulerreihe()
von
Code:
m2

Die Methode
Code:
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
Java:
        public double berechneFakultaet(int n)                      
        {
            if (n == 0)
                return 1;
            else
                return n * berechneFakultaet(n - 1);        
        }

du siehst das hier
Code:
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.
 
Zuletzt bearbeitet von einem Moderator:

Landei

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

Java:
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.
 

Neue Themen


Oben