# Nullstelle berechnen



## xaja (20. Mai 2009)

Hallo ihrs, 
ich muss eine Nullstelle berechnen und hab folgenden Code. Meine Frage ist, ob ich die Funktion -x^3+1 überall dahin schreiben muss wo ich eben "Funktion" geschrieben habe. 

```
public class MyFunction {
	private Funktion funktion;
	
	private double genauigkeit=0.00001;
	
	public Nullstellensuche(Funktion funktion, double genauigkeit) {
	    this.funktion = funktion;
	    this.genauigkeit = genauigkeit;
	}
	/**
	 * Berechnet die Nullstelle der Funktion f(x) = -x^3+1 durch binaere Suche.
	 * 
	 * @param unten
	 *            untere Grenze.
	 * @param oben
	 *            obere Grenze.
	 * 
	 * @return Nullstelle der Funktion f(x) = -x^3+1.
	 */
	protected int berechneNullstelle(int unten, int oben) {
		// TODO
		int mitte=(unten+oben)/2;
		if ( Math.abs( funktion.f(mitte) ) < genauigkeit ) {
			return mitte;
		} else
			if ( funktion.f(mitte) * funktion.f(oben) < 0 ) {
				return berechneNullstelle(mitte, oben);
			} else{	
				// man überzeuge sich hier, dass f(mitte) * f(links) < 0 gelten muss!
			    return berechneNullstelle(unten, mitte);
			}
		return Integer.MIN_VALUE;
	}

	
	// Main-Methode zum Testen.
	public static void main(String[] args) {
		
		MyFunction analysis = new MyFunction();

		System.out.println("Nullstelle bei: x = "
				+ analysis.berechneNullstelle(-1000, 1000));
	}
}
```

würde mich über ne antwort freuen


----------



## SlaterB (20. Mai 2009)

der Klasse wird doch eine anscheinend beliebige Funktion übergeben, 
dann wäre es falsch, in der Doku eine bestimmte Funktion anzugeben, 
die am Ende gar nicht enthalten sein muss

Klassennamen Funktion + MyFunction deuten aber auf ein größeres Problem hin, wer soll da durchsehen?


deine main-Methode ruft übrigens Nullstellensuche() nicht auf, dann ist ja gar keine Funktion gesetzt?

Methoden klein schreiben!


----------



## Lexi (20. Mai 2009)

Nustellensuche() sieht mir eher wie ein Kontruktor aus. Der Konstruktor muss immer so heißen wie die Klasse ! 

Überall dort wo du funktion hingeschrieben hast, greifst du auf eine Objektvariable des Typ Funktion zu. Funktion müsstes du als Klasse definiert haben. Schau mal nach ob du die findest und poste sie dann hier .


----------



## xaja (21. Mai 2009)

also ich hab jetzt mal den konstruktor rausgenommen und ihr jetzt mal der geänderte code und mein frage ist nur, muss ich in meinen code nicht irgendwo meine funktion (-x^3+1) eingeben

```
public class MyFunction {
	
	private double genauigkeit=0.00001;
	/**
	 * Berechnet die Nullstelle der Funktion f(x) = -x^3+1 durch binaere Suche.
	 * 
	 * @param unten
	 *            untere Grenze.
	 * @param oben
	 *            obere Grenze.
	 * 
	 * @return Nullstelle der Funktion f(x) = -x^3+1.
	 */
	protected int berechneNullstelle(int unten, int oben) {
		// TODO 
		int mitte=(unten+oben)/2;
		if ( Math.abs( funktion.f(mitte) ) < genauigkeit ) {
			return mitte;
		} else
			if ( funktion.f(mitte) * funktion.f(oben) < 0 ) {
				return berechneNullstelle(mitte, oben);
			} else{	
				// man überzeuge sich hier, dass f(mitte) * f(links) < 0 gelten muss!
			    return berechneNullstelle(unten, mitte);
			}
		//return Integer.MIN_VALUE;
	}

	
	// Main-Methode zum Testen.
	public static void main(String[] args) {
		
		MyFunction analysis = new MyFunction();

		System.out.println("Nullstelle bei: x = "
				+ analysis.berechneNullstelle(-1000, 1000));
	}
}
```


----------



## SlaterB (22. Mai 2009)

ja, musst du, und zwar muss das funktion-Objekt definiert sein, auf welches in berechneNullstelle zugriffen wird,
da war die alte Version schon lauffähiger


----------



## Lexi (22. Mai 2009)

Wie wäre es, wenn du uns einfach mal den Sourcecode der Klasse "Funktion" zeigst ? Die benutzt du doch die ganze Zeit.


----------



## xaja (24. Mai 2009)

hallo, mir is ein fehler unterlaufen und zwar ich soll das zeugs nicht rekursiv lösen sondern interativ und habs so gemacht

```
public class MyFunction {
	/**
	 * Berechnet die Nullstelle der Funktion f(x) = -x^3+1 durch binaere Suche.
	 * 
	 * @param unten
	 *            untere Grenze.
	 * @param oben
	 *            obere Grenze.
	 * 
	 * @return Nullstelle der Funktion f(x) = -x^3+1.
	 */
	protected int berechneNullstelle(int unten, int oben) {
		// TODO
		int wert; //der zusuchende Wert
		
		if(wert<unten && wert>oben){
			return 'F'; //Fehlerwert zurückgeben
		}
		while(unten<=oben){
			int mitte=(unten+oben)/2;//Mitte bestimmen
			if(wert<mitte){
				oben=mitte-1; //nach oben durchsuchen
			}else{
				if(wert>mitte){
					unten=mitte+1; //nach unten durchsuchen
				}else{
					return mitte; 
				}
			}
		}
		
		return Integer.MIN_VALUE;
	}
	// Main-Methode zum Testen.
	public static void main(String[] args) {
		
		MyFunction analysis = new MyFunction();

		System.out.println("Nullstelle bei: x = "
				+ analysis.berechneNullstelle(-1000, 1000));
	}
}
```

aber irgendwie weis ich nicht wo und wie ich meine funktion da rein zu schreiben hab:bahnhof:
für hilfe währe ich sehr dankbar


----------



## SlaterB (24. Mai 2009)

bevor du dich mit höheren Dingen wie Nullstellen beschäftigst, musst du doch erstmal eine Funktion haben?!

lange Zeit gab es bei dir eine Klasse Funktion, nun ist sie weg, da weiß niemand, was man davon halten soll,
im einfachsten Falle wäre die Funktion z.B.
public double f(double x) {
return -x*x*x+1;
}

nun schreibe doch erstmal ein funktionierendes Programm, welches den korrekten Funktionswert für ein paar x-Werte ausgibt,
dann hast du eine Grundlage..


----------



## Lexi (24. Mai 2009)

Lexi hat gesagt.:


> Wie wäre es, wenn du uns einfach mal den Sourcecode der Klasse "Funktion" zeigst ? Die benutzt du doch die ganze Zeit.


Ich kann mich hier nur selbst zitieren. Ist diese Klasse irgenwie verschwunden oder hast du sie aufgegessen ? Wenn das nicht zutreffen sollte, dann poste das Ding doch einfach mal hier.


----------



## xaja (25. Mai 2009)

So ich hab nur das vorgegeben und soll da irgendwie die nullstelle berechnen, wie ihr ja seht hab ich kein plan wie ich das machen soll und das ganz soll ich iterativ und mit einer binär suche lösen 


```
public class MyFunction {

	/**
	 * Berechnet die Nullstelle der Funktion f(x) = -x^3+1 durch binaere Suche.
	 * 
	 * @param unten
	 *            untere Grenze.
	 * @param oben
	 *            obere Grenze.
	 * 
	 * @return Nullstelle der Funktion f(x) = -x^3+1.
	 */
	protected int berechneNullstelle(int unten, int oben) {
		// TODO
		return Integer.MIN_VALUE;
	}

	
	// Main-Methode zum Testen.
	public static void main(String[] args) {
		
		MyFunction analysis = new MyFunction();

		System.out.println("Nullstelle bei: x = "
				+ analysis.berechneNullstelle(-1000, 1000));
	}
}
```


----------



## SlaterB (26. Mai 2009)

SlaterB hat gesagt.:


> bevor du dich mit höheren Dingen wie Nullstellen beschäftigst, musst du doch erstmal eine Funktion haben?!
> 
> lange Zeit gab es bei dir eine Klasse Funktion, nun ist sie weg, da weiß niemand, was man davon halten soll,
> im einfachsten Falle wäre die Funktion z.B.
> ...



----------

du könnest nun ja sagen, dass du gar zu gar keine Ahnung hast,
aber zumindest solltest du deine Aufgabe und das Wort 'Nullstelle' solange komplett vergessen


----------

