Ausgabe falsch!

[tanzverfuehrung]

HAllo Ihr lieben,
also ich habe ein Programm programmiert, der mit das Taylorpolynom ausgibt und zu bestimmten x, dass taylorpolynom ausrechnet.
Das habe ich auch hinbekommen...

package nachhilfe;
import static java.lang.Math.cos;
import static java.lang.Math.exp;
import static java.lang.Math.log;
import static java.lang.Math.pow;
import static java.lang.Math.sin;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Taylorpolynom {
	String polynom = "";
	static double entwicklugsPunkt, ordnung;
	private static int funktion;
	private static double[] funktionen;
	Fakultaet fak = new Fakultaet();
	double ergebnis;

	/**
	 * Funktionen und deren ersten 9 Ableitungen
	 */
	//@formatter:off
	//EXPONENTIAL
	public static double[] expAbleitungen(double entwicklugsPunkt) {
		double[] expFkt = new double[10];
		for (int i = 0; i < expFkt.length; i++) {
			expFkt[i] = exp(entwicklugsPunkt);
		}
		return expFkt;
	}
	//SINUS
	public static double[] sinAbleitungen(double entwicklugsPunkt) {
		double[] sinFkt = {sin(entwicklugsPunkt), 
			cos(entwicklugsPunkt), 
			-sin(entwicklugsPunkt), 
			-cos(entwicklugsPunkt), 
			sin(entwicklugsPunkt), 
			cos(entwicklugsPunkt), 
			-sin(entwicklugsPunkt), 
			-cos(entwicklugsPunkt), 
			sin(entwicklugsPunkt), 
			cos(entwicklugsPunkt)};
		return sinFkt;
	}

	//COSINUS
	public static double[] cosAbleitungen(double entwicklugsPunkt) {
		double[] cosFkt = {cos(entwicklugsPunkt), 
			-sin(entwicklugsPunkt), 
			-cos(entwicklugsPunkt), 
			sin(entwicklugsPunkt), 
			cos(entwicklugsPunkt), 
			-sin(entwicklugsPunkt), 
			-cos(entwicklugsPunkt), 
			sin(entwicklugsPunkt), 
			cos(entwicklugsPunkt),
			-sin(entwicklugsPunkt)};
		return cosFkt;
	}
	//LOGARITHMUS
	public static double[] lnAbleitungen(double entwicklugsPunkt) {
		double[] lnFkt = {log(entwicklugsPunkt),
			pow(entwicklugsPunkt, -1),
			-pow(entwicklugsPunkt, -2),
			2*pow(entwicklugsPunkt, -3),
			-6*pow(entwicklugsPunkt, -4),
			24*pow(entwicklugsPunkt, -5),
			-120*pow(entwicklugsPunkt, -6),
			720*pow(entwicklugsPunkt, -7),
			-5040*pow(entwicklugsPunkt, -8),
			40320*pow(entwicklugsPunkt, -9)};
		return lnFkt;
	}
	// @formatter:on


	/**
	 * Gibt mir den Taylapolynom wieder
	 * 
	 * @param entwicklungsPunkt
	 * @param ordnung
	 * @return taylorpolynom
	 */
	public String stringTaylorPolynom(double entwicklungsPunkt, double ordnung, double[] funktion) {

		for (int i = 0; i <= ordnung; i++) {
			int fakultaet = fak.fakultaet(i);
			if (!polynom.isEmpty())
				polynom = polynom + " + (" + funktion[i] + "/" + fakultaet + ")*(x-" + entwicklugsPunkt + ")^" + i;
			else
				polynom = "(" + funktion[i] + "/" + fakultaet + ")*(x-" + entwicklugsPunkt + ")^" + i;
		}
		return polynom;
	}

	/**
	 * Berechnet uns den Taylorpolynom, mit dem übergebenen x
	 * 
	 * @param entwicklungsPunkt
	 * @param ordnung
	 * @param x
	 * @return
	 */
	public double berechneTaylorPolynomForX(double entwicklungsPunkt, double ordnung, double x, double[] funktion) {
		double base = x - entwicklungsPunkt;
		for (int exponent = 0; exponent <= ordnung; exponent++) {
			double fakultaet = fak.fakultaet(exponent);
			ergebnis += (funktion[exponent] / fakultaet) * (Math.pow(base, exponent));
		}
		return ergebnis;
	}

	/**
	 * Fragt den Anwender in welchen Punkt er entwickeln will und bis zu welcher
	 * Ordnung.Und gibt dazu den passenen Taylorpolynom zurück und rechnet ihn
	 * für ein überggebenes x aus.
	 * 
	 * @param args
	 */
	public static void main(String args[]) {
		
		BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
		System.out.println("In welchem Punkt(ganzzahlige Zahl) soll der Taylorpolynom entwickelt werden??");
		try {
			entwicklugsPunkt = Integer.parseInt(reader.readLine());
		}
		catch (Exception e) {
			System.out.println("EXCEPTION! Der entwicklungsPunkt ist keine ganzzahlige Zahl!!Message: " + e.getMessage());
		}

		System.out.println("Und bitte geben Sie die Ordnung(ganzzahlige Zahl) an, nach der entwickelt werden soll??");
		try {
			ordnung = Integer.parseInt(reader.readLine());
		}
		catch (Exception e) {
			System.out.println("EXCEPTION! Die Ordnung ist keine ganzzahlige Zahl!!Message: " + e.getMessage());
		}
		System.out.println("Und geben Sie ein Wert für x ein [f(x)]:");
		try {
			x = Integer.parseInt(reader.readLine());
		}

		catch (Exception e) {
			System.out.println("EXCEPTION! Die Ordnung ist keine ganzzahlige Zahl!!Message: " + e.getMessage());
		}
		System.out.println("Von welcher Funktion wollen Sie das Taylorpolynom: ");
		System.out.println("1.Exponentialfunktion  exp(x)");
		System.out.println("2.Sinusfunktion  sin(x)");
		System.out.println("3.Cosinusfunktion  cos(x)");
		System.out.println("4.Logarithmusfunktion  ln(x)");
		try {
		funktion = Integer.parseInt(reader.readLine());
		switch (funktion) {
			case 1: funktionen =expAbleitungen(entwicklugsPunkt);
				break;
			case 2: funktionen = sinAbleitungen(entwicklugsPunkt);
				break;
			case 3: funktionen = cosAbleitungen(entwicklugsPunkt);
				break;
			case 4: funktionen = lnAbleitungen(entwicklugsPunkt);
				break;
		}
		}

		catch (Exception e) {
			System.out.println("EXCEPTION! Die Zahl liegt nicht zwischen 1 und 4 oder ist keien ganzzahlige Zahl" + e.getMessage());
		}
		Taylorpolynom taylor = new Taylorpolynom();
		System.out.println("Taylorpolynom: ");
			System.out.println(taylor.stringTaylorPolynom(entwicklugsPunkt, ordnung, funktionen));
			System.out.println("Und das Ergebnis dazu: ");
		
					System.out.println("taylor.berechneTaylorPolynomForX(entwicklugsPunkt, ordnung, x, funktionen));	
		
		
	}
}

Dann musste ich ein x eingeben und genau für das wurde es mir berechnet!!!
DAs funktionierte auch alles!
Jetzt wollte ich es noch einfacher schreiben..., das es gleich jedes mal, verschiedene Werte für verschiedene x ausgibt....doch leider kommt jetzt was ganz anderes raus und ich verstehe nicht wieso?!?!

package nachhilfe;

import static java.lang.Math.cos;
import static java.lang.Math.exp;
import static java.lang.Math.log;
import static java.lang.Math.pow;
import static java.lang.Math.sin;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Taylorpolynom {
	String polynom = "";
	static double entwicklugsPunkt, ordnung;
	private static int funktion;
	private static double[] funktionen;
	Fakultaet fak = new Fakultaet();
	double ergebnis;

	/**
	 * Funktionen und deren ersten 9 Ableitungen
	 */
	//@formatter:off
	//EXPONENTIAL
	public static double[] expAbleitungen(double entwicklugsPunkt) {
		double[] expFkt = new double[10];
		for (int i = 0; i < expFkt.length; i++) {
			expFkt[i] = exp(entwicklugsPunkt);
		}
		return expFkt;
	}
	//SINUS
	public static double[] sinAbleitungen(double entwicklugsPunkt) {
		double[] sinFkt = {sin(entwicklugsPunkt), 
			cos(entwicklugsPunkt), 
			-sin(entwicklugsPunkt), 
			-cos(entwicklugsPunkt), 
			sin(entwicklugsPunkt), 
			cos(entwicklugsPunkt), 
			-sin(entwicklugsPunkt), 
			-cos(entwicklugsPunkt), 
			sin(entwicklugsPunkt), 
			cos(entwicklugsPunkt)};
		return sinFkt;
	}

	//COSINUS
	public static double[] cosAbleitungen(double entwicklugsPunkt) {
		double[] cosFkt = {cos(entwicklugsPunkt), 
			-sin(entwicklugsPunkt), 
			-cos(entwicklugsPunkt), 
			sin(entwicklugsPunkt), 
			cos(entwicklugsPunkt), 
			-sin(entwicklugsPunkt), 
			-cos(entwicklugsPunkt), 
			sin(entwicklugsPunkt), 
			cos(entwicklugsPunkt),
			-sin(entwicklugsPunkt)};
		return cosFkt;
	}
	//LOGARITHMUS
	public static double[] lnAbleitungen(double entwicklugsPunkt) {
		double[] lnFkt = {log(entwicklugsPunkt),
			pow(entwicklugsPunkt, -1),
			-pow(entwicklugsPunkt, -2),
			2*pow(entwicklugsPunkt, -3),
			-6*pow(entwicklugsPunkt, -4),
			24*pow(entwicklugsPunkt, -5),
			-120*pow(entwicklugsPunkt, -6),
			720*pow(entwicklugsPunkt, -7),
			-5040*pow(entwicklugsPunkt, -8),
			40320*pow(entwicklugsPunkt, -9)};
		return lnFkt;
	}
	// @formatter:on


	/**
	 * Gibt mir den Taylapolynom wieder
	 * 
	 * @param entwicklungsPunkt
	 * @param ordnung
	 * @return taylorpolynom
	 */
	public String stringTaylorPolynom(double entwicklungsPunkt, double ordnung, double[] funktion) {

		for (int i = 0; i <= ordnung; i++) {
			int fakultaet = fak.fakultaet(i);
			if (!polynom.isEmpty())
				polynom = polynom + " + (" + funktion[i] + "/" + fakultaet + ")*(x-" + entwicklugsPunkt + ")^" + i;
			else
				polynom = "(" + funktion[i] + "/" + fakultaet + ")*(x-" + entwicklugsPunkt + ")^" + i;
		}
		return polynom;
	}

	/**
	 * Berechnet uns den Taylorpolynom, mit dem übergebenen x
	 * 
	 * @param entwicklungsPunkt
	 * @param ordnung
	 * @param x
	 * @return
	 */
	public double berechneTaylorPolynomForX(double entwicklungsPunkt, double ordnung, double x, double[] funktion) {
		double base = x - entwicklungsPunkt;
		for (int exponent = 0; exponent <= ordnung; exponent++) {
			double fakultaet = fak.fakultaet(exponent);
			ergebnis += (funktion[exponent] / fakultaet) * (Math.pow(base, exponent));
		}
		return ergebnis;
	}

	/**
	 * Fragt den Anwender in welchen Punkt er entwickeln will und bis zu welcher
	 * Ordnung.Und gibt dazu den passenen Taylorpolynom zurück und rechnet ihn
	 * für ein überggebenes x aus.
	 * 
	 * @param args
	 */
	public static void main(String args[]) {
		
		BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
		System.out.println("In welchem Punkt(ganzzahlige Zahl) soll der Taylorpolynom entwickelt werden??");
		try {
			entwicklugsPunkt = Integer.parseInt(reader.readLine());
		}
		catch (Exception e) {
			System.out.println("EXCEPTION! Der entwicklungsPunkt ist keine ganzzahlige Zahl!!Message: " + e.getMessage());
		}

		System.out.println("Und bitte geben Sie die Ordnung(ganzzahlige Zahl) an, nach der entwickelt werden soll??");
		try {
			ordnung = Integer.parseInt(reader.readLine());
		}
		catch (Exception e) {
			System.out.println("EXCEPTION! Die Ordnung ist keine ganzzahlige Zahl!!Message: " + e.getMessage());
		}
//		System.out.println("Und geben Sie ein Wert für x ein [f(x)]:");
//		try {
//			x = Integer.parseInt(reader.readLine());
//		}
//
//		catch (Exception e) {
//			System.out.println("EXCEPTION! Die Ordnung ist keine ganzzahlige Zahl!!Message: " + e.getMessage());
//		}
		System.out.println("Von welcher Funktion wollen Sie das Taylorpolynom: ");
		System.out.println("1.Exponentialfunktion  exp(x)");
		System.out.println("2.Sinusfunktion  sin(x)");
		System.out.println("3.Cosinusfunktion  cos(x)");
		System.out.println("4.Logarithmusfunktion  ln(x)");
		try {
		funktion = Integer.parseInt(reader.readLine());
		switch (funktion) {
			case 1: funktionen =expAbleitungen(entwicklugsPunkt);
				break;
			case 2: funktionen = sinAbleitungen(entwicklugsPunkt);
				break;
			case 3: funktionen = cosAbleitungen(entwicklugsPunkt);
				break;
			case 4: funktionen = lnAbleitungen(entwicklugsPunkt);
				break;
		}
		}

		catch (Exception e) {
			System.out.println("EXCEPTION! Die Zahl liegt nicht zwischen 1 und 4 oder ist keien ganzzahlige Zahl" + e.getMessage());
		}
		Taylorpolynom taylor = new Taylorpolynom();
		System.out.println("Taylorpolynom: ");
			System.out.println(taylor.stringTaylorPolynom(entwicklugsPunkt, ordnung, funktionen));
			System.out.println("Und das Ergebnis dazu: ");
			for (int i = -4; i < 5; i++) {
					System.out.println("x = "+i+" -->y = " +taylor.berechneTaylorPolynomForX(entwicklugsPunkt, ordnung, i, funktionen));	
			}
		
	}
}

CODE ÄNDERUNGEN!!!
Zeile 140-147 gelöscht!
und zeile 174 -- schleife eingefügt!

in der schleife, will ich alle x von -4 bis 4 ausgeben lassen :
for (int i = -4; i < 5; i++) {
System.out.println("x = "+i+" -->y = " +taylor.berechneTaylorPolynomForX(entwicklugsPunkt, ordnung, i, funktionen));
}



WO genau ist mein Fehler?Wieso kommen nicht die gleichen Werte raus??????;(;(;rtfm:

 

[HimBromBeere]

Also spontan fällit mir nichts auf, was da nicht funktionieren sollte. Nichtsdestotrotz ist den Code ziemlich verwirrend, weil z.B. die Ausgabe mit der Ordnung zweimal auftaucht (einmal im Zusammenhang mit der tatsächlichen Ordnung, und einmal in Verbindung mit x). Außerdem klingt "ganzzahlige Zahl" ziemlich bescheuert , wie wär´s mit "ganze Zahl"? Achja, und die Ausgabe in Zeile 174 (alte Datei) ist sowieso fehlerhaft, aber das ist wahrscheinlich nur ein Schreibfehler...

Um deinem Problem näher zu kommen, kannst du ja auch einfach innerhalb deiner neuen Schleife die Anweisung mit dem parseInt() unterbringen, also so etwas:

for (int i = -4; i < 5; i++) {
    int x = parseInt()...
    System.out.println(taylor.berechneTaylorPolynomForX(entwicklungspunkt, ordnung, x, funktionen);
    System.out.println("x = "+i+" -->y = " +taylor.berechneTaylorPolynomForX(entwicklugsPunkt, ordnung, i, funktionen));    
}

 

[tanzverfuehrung]

Also spontan fällit mir nichts auf, was da nicht funktionieren sollte. Nichtsdestotrotz ist den Code ziemlich verwirrend, weil z.B. die Ausgabe mit der Ordnung zweimal auftaucht (einmal im Zusammenhang mit der tatsächlichen Ordnung, und einmal in Verbindung mit x). Außerdem klingt "ganzzahlige Zahl" ziemlich bescheuert , wie wär´s mit "ganze Zahl"? Achja, und die Ausgabe in Zeile 174 (alte Datei) ist sowieso fehlerhaft, aber das ist wahrscheinlich nur ein Schreibfehler...

ja das stimmt schon alles...

Um deinem Problem näher zu kommen, kannst du ja auch einfach innerhalb deiner neuen Schleife die Anweisung mit dem parseInt() unterbringen, also so etwas:

for (int i = -4; i < 5; i++) {
    int x = parseInt()...
    System.out.println(taylor.berechneTaylorPolynomForX(entwicklungspunkt, ordnung, x, funktionen);
    System.out.println("x = "+i+" -->y = " +taylor.berechneTaylorPolynomForX(entwicklugsPunkt, ordnung, i, funktionen));    
}

und wieso komme ich dann meinem Problem näher???

dann sehe ich ja acuh nur das zwei verschiedene werte raus kommen odeR?

 

[tanzverfuehrung]

ich verstehe einfach nicht wieso da eine andere ausagbe kommt??????:L
es ist doch genau das gleiche, ;(bloß einmal reiche ich ein array rein, was alle werte enthält und durch gehen soll und bei dem andern mal, muss ich selber jedes x wert einzelnt eingeben!!!;(

 

[tanzverfuehrung]

so ein kleiner fehler und doch sitzt man so lange dran, bis man ihn findet!
also falls es jemanden interessiert:
in der MEthode

/**
	 * Berechnet uns den Taylorpolynom, mit dem übergebenen x
	 * 
	 * @param entwicklungsPunkt
	 * @param ordnung
	 * @param x
	 * @param funktion ausgewählte Fkt
	 * @return
	 */
	public double berechneTaylorPolynomForX(double entwicklungsPunkt, double ordnung, double x, double[] funktion) {
		double ergebnis = 0;
		double base = x - entwicklungsPunkt;
		for (int exponent = 0; exponent <= ordnung; exponent++) {
			double fakultaet = fak.fakultaet(exponent);
			ergebnis += (funktion[exponent] / fakultaet) * (Math.pow(base, exponent));
		}
		return ergebnis;
	}

nachdem ein x durch diese MEthode durch ist, muss das ergebnis wieder auf 0 gesetzt werden, sonst wird es immer wieder drauf summiert!!!:toll::applaus:

 

[jgh]

jo, mich interessiert das, danke

hatte auch kurz geschaut und (noch) nichts gefunden, aber so ist auch am besten, wenn man/du den Fehler selbst findest!