Verdammt wo liegt der Fehler?

[alge]

Hallo zusammen.

Bin hier am Lernen und kam mit einer Übungsaufgabe auch gut zurecht, doch die Ausgabe des Programms macht nicht wirklich viel Sinn. Jetzt bin ich meinen Code schon xmal durchgegangen und finde einfach den Fehler nicht und das macht mich komplett irre. Kann mir jemand sagen, woran es liegt?

Also die Aufgabe war:

"Die Exponentialfunktion e^x mit der Eulerschen Zahl e als Basis, kann durch folgende
Reihe annäherungsweise berechnet werden:

e^x = (Summenzeichen von n=0 bis n=unendlich) (x^n)/(n!)

Schreiben Sie ein Java-Programm, das den Benutzer zur Eingabe einer Zahl x auffordert
und anschließend den Wert von e^x annäherunsweise ausgibt. Erweitern Sie anschließend
das Programm derart, dass auch die gewünschte Genauigkeit der Berechnung eingegeben
werden kann."

Sorry für die verwirrende Schreibweise der Reihe, aber kp wie ich solche Sonderzeichen hier einfügen kann.

Und hier mein Code:

import java.io.*;
import java.lang.*;

class euler {
	
	public static void main(String args[]) throws IOException {
		
		System.out.println("Berechnung der Exponentialfunktion e^x");
		System.out.println("");
		System.out.println("Bitte geben sie einen Wert x ein!");
		System.out.println("");
		System.out.flush();
			
		InputStreamReader isr = new InputStreamReader(System.in);
		BufferedReader br = new BufferedReader(isr);
		Double s = Double.valueOf(br.readLine());
		double x = s.doubleValue();
				
		System.out.println("");
		System.out.println("Die Berechnung kann nur näherungsweise erfolgen. Wie viele Durchläufe?");
		System.out.println("");
		System.out.flush();
		InputStreamReader isr2 = new InputStreamReader(System.in);
		BufferedReader br2 = new BufferedReader(isr2);
		String t = br2.readLine();
		int g = Integer.parseInt(t);
		
		int n = 0;
		int ngr;
		int nkl;
		int nz;
		int nf;
		double summe = 0;
		
		while (n < g) {
		ngr = n;
		nf = 1;
			while (ngr >= 2) {
				nkl = ngr - 1;
				nz = ngr*nkl;
				nf = nf*nz;
				ngr = ngr - 2;
			}
		int index = 0;
		double p = 1;
		while (index < n) {
			p = p*x;
			index++;
		}
		double bruch = p/nf;
		n++;
		summe = summe + bruch;
		}
		System.out.println("");
		System.out.print("e^" + x);
		System.out.print(" = " + summe);				
		
		}
	}

Das Programm lässt sich problemlos ausführen, aber die ausgegebenen Werte stimmen meist nicht.

Danke fürs Helfen!!

 

[Redfrettchen]

Hi,
hast du schon mal daran gedacht, das n! ziemlich schnell ziemlich groß wird und zu einem Überlauf führen könnte?

Gruß
Redfrettchen

 

[alge]

Hi,
hast du schon mal daran gedacht, das n! ziemlich schnell ziemlich groß wird und zu einem Überlauf führen könnte?

Gruß
Redfrettchen

Huch, das is wahr
Das heißt, wenn ich die Durchläufe auf z.B. 10 begrenze, müsste die Aufgabe erfüllt sein, oder nicht? Weil das ist dann wirklich nur noch sehr näherungsweise, aber die Werte bewegen sich im Rahmen.

Gruß zurück

 

[Marco13]

Abgesehen davon, dass ein Problem schon darin liegen könnte, dass du dort mit ints rechnest (besser wäre "eigentlich" double, aber für die Fakulatät (Ganzzahlen) wäre zumindest "long" wohl sinnvoller) solltest du überlegen, ob du das nicht etwas "schöner" schreiben könntest. Du könntest z.B. die Funktion Math.pow(x,n) verwenden, und eine (selbstgeschriebene) Methode
long factorial(int n) {...}

 

[Redfrettchen]

Hi,
hast du schon mal daran gedacht, das n! ziemlich schnell ziemlich groß wird und zu einem Überlauf führen könnte?

Gruß
Redfrettchen

Huch, das is wahr
Das heißt, wenn ich die Durchläufe auf z.B. 10 begrenze, müsste die Aufgabe erfüllt sein, oder nicht? Weil das ist dann wirklich nur noch sehr näherungsweise, aber die Werte bewegen sich im Rahmen.

Gruß zurück

Ähm, naja, ich denke nicht, dass die Aufgabe so gedacht war...
Dein Konzept ist zwar mathematisch in Ordnung, aber algorithmisch schmerzhaft, weil nicht effizient, implementiert nicht einmal effektiv. Versuch das Endergebnis aus Teilergebnissen zu gewinnen und verwende Teilergebnisse auch wieder.

Von einer factorial-Methode würde ich daher abraten, aber der Einwand mit dem Datentyp ist berechtigt.

 

[Marco13]

Die Möglichkeit, Teilerbnisse zu verwenden, ist bei einer "factorial"-Methode oder bei Math.pow natürlich nicht gegeben. Wenn es effizient sein soll, würde man das "eigentlich" machen (und in diesem Fall drängt es sich natürlich auf!), aber wenn es eine Übungsaufgabe sein soll, könnte man auch versuchen, es "schön" zu schreiben. Kommt halt immer drauf an, welche Priorität man setzt. Schneller als Math.pow(Math.E, x); krigt man es sowieso nicht :wink:

 

[alge]

So, ich hab jetzt mal versucht es "schöner" zu schreiben.

Allerdings will er trotzdem nicht, lässt sich zwar kompilieren, wenn ich es aber ausführen will, kommt eine lange Kette von Meldungen. Woran könnte das jetzt wieder liegen??

Danke nochmal.



Hier der Code:

import java.io.*;
import java.lang.*;

class eulersch {

public eulersch(){
} 
public static long faculty(int x) {
	int k = x-1;
	long f = 1;
	while (k > 0) {
		f = f*x*k;
		x = x-2;
		k = k-2;
	}
	long z = f;
	System.out.println(z);
	return z;
}

public static double potence(double x, int y) {
	int d;
	double r = 1;
	for (d = 0; d < y; d++) 
		r = r*x;
		return r;
}

public int intread() throws IOException {
	InputStreamReader isr = new InputStreamReader(System.in);
	BufferedReader br = new BufferedReader(isr);
	int d = Integer.parseInt(br.readLine());
	return d;
}

public double doubleread() throws IOException {
	InputStreamReader isr = new InputStreamReader(System.in);
	BufferedReader br = new BufferedReader(isr);
	Double d = Double.valueOf(br.readLine());
	double x = d.doubleValue();
	return x;
}

}

class reihe {
	public static double main(String args[]) throws IOException {
		
		System.out.println("Programm zur näherungsweisen Berechnung von e^x");
		System.out.println("");
		System.out.println("Bitte geben sie ein x ein!");
		System.out.println("");
		System.out.flush();
		eulersch a = new eulersch();
		double x = a.doubleread();
		
		System.out.println("");
		System.out.println("Bitte geben sie die Anzahl der Durchläufe an.");
		System.out.println("");
		System.out.flush();
		int d = a.intread();
		
		int nlauf;
		long f = a.faculty(0);
		double p = a.potence(x, 0);
		double ex = p/f;	
		
		for (nlauf = 0; nlauf < d && f < 1000000; nlauf++)
			f = a.faculty(nlauf);
			p = a.potence(x, nlauf);
			ex = ex+ (f/p);
		
			
		System.out.println("");
		System.out.print("e^" + x);
		System.out.println(" = " + ex);
		return ex;
			}
}

 

[Marco13]

main kann kein double zurückgeben, sondern muss void sein.

Ansonsten fehlten bei der Schleife noch geschweifte Klammern

      for (nlauf = 0; nlauf < d && f < 1000000; nlauf++)
      {
         f = a.faculty(nlauf);
         p = a.potence(x, nlauf);
         ex = ex+ (p/f);
     }

Und es müßte p/f heißen, statt f/p

Und ex sollte am Anfang 0 sein. (oder die Schleife muß bei 1 loslaufen :roll: )

---> ACHTUNG: :meld: Hier fängt der Klugscheiß-Teil an :meld:

java.lang muss man nicht importen.

Klassennamen schreibt man groß.

Dass die "main" eine Exception wirft ... ist höchstens für so ein kleines Übungsprogramm OK.

Die Methoden, die statisch sein können, sollten statisch sein.

Mach mal eine Websuche nach "fast OR schnelle exponentiation"

Variablen sollte man nur dann deklarieren, wenn man sie braucht

Variablen sollte man nur dort deklarieren, wo man sie braucht.

Die Dinger heißten auf englisch übrigens "factorial" und "power".
Aber das nur nebenbei.

Hm. Mal ein zusammengefasster Vorschlag.

import java.io.*;

class Eulersch
{
    private static long factorial(int x)
    {
        return (x<2?1:x*factorial(x-1));
    }

    private static double power(double x, int y)
    {
        double result = 1;
        while (y!=0)
        {
            if (y%2==1) result*=x;
            x*=x;
            y>>=1;
        }
        return result;
    }

    private static int readInt(String message)
    {
        while (true)
        {
            try
            {
                System.out.print(message);
                BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
                return Integer.parseInt(br.readLine());
            }
            catch (NumberFormatException e) 
            {
                System.out.println("Ungueltige Eingabe!");
            }
            catch (IOException e)
            {
                System.err.println("Fehler: "+e.getMessage());
            }
        }
    }

    private static double readDouble(String message)
    {
        while (true)
        {
            try
            {
                System.out.print(message);
                BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
                return Double.parseDouble(br.readLine());
            }
            catch (NumberFormatException e) 
            {
                System.out.println("Ungueltige Eingabe!");
            }
            catch (IOException e)
            {
                System.err.println("Fehler: "+e.getMessage());
            }
        }

    }

    public static void main(String args[])
    {
        System.out.println("Programm zur naeherungsweisen Berechnung von e^x");
        double x = readDouble("Bitte geben sie ein x ein: ");
        int d = readInt("Bitte geben sie die Anzahl der Durchlaeufe an: ");

        double ex = 0;
        for (int n = 0; n < d; n++) ex+=power(x,n)/factorial(n);

        System.out.print("e^" + x);
        System.out.println(" = " + ex);
        System.out.println("Probe: "+Math.pow(Math.E, x));
    }
}