Java Rechenfehler aufgrund zu geringer Zahlendichte.

[ice-breaker]

In der Aufgabe ist nichts vorhanden, was jemand mit Mittelstufen-Mathe nicht lösen könnte.

 

[Maggiefix]

ich würde es ungefähr so machen (ich schreibs nicht als code sonst hast du ja keine arbeit mehr und weil ich zu faul bin ^^):

neg=1
1.if (x<0) x = -x & neg=-1
2.while(x>2*pi) x = x-2*pi
3.if (pi < x < 2*pi) x = x-pi &neg=-1
4.if (pi/2<x<pi)x = x -pi/2

x = x*neg

und dann kannst du deine sinusfunktion laufen lassen
ich hoff mal ich hab keine fehler reingebaut aber ich hab grad wenig zeit
schaust halt mal

Vielen Dank ich werde es mir anschauen, aber ich glaube das hilft mir sehr

 

[Lunke]

4.if (pi/2<x<pi)x = x -pi/2

Falsch!
Mach mal ein Beispiel: sin(pi) = 0 aber sin(pi-pi/2) = sin(pi/2) = 1

Was ich eigentlich geschrieben habe, ist nämlich folgendes:
sin(pi/2 + y) = sin(pi/2 - y)

Das ist in der Tat etwas tricky:
Also, angenommen ich habe ein x, das zwischen pi/2 und pi liegt und möchte mein neues x' errechnen, das zwischen 0 und pi/2 liegen soll. Wie mache ich das nun?

1. Schritt:
Berechne den Abstand zu (pi/2) => y = x - pi/2

2. Schritt:
Ziehe den Abstand von pi/2 ab => x' = pi/2 - y = pi/2 - (x - pi/2) = pi - x

 

[Krik]

Mir ist schon klar das ich nehmen kann was ich will, ich würde nur gerne eine Empfehlung haben wie ich das möglichst schnell und einfach lösen kann.

Wenn man die Anzahl der Schleifendurchgänge vorher weiß oder ermitteln kann, dann nimmt man eine for-Schleife. Weiß man das nicht, nimmt man eine while-Schleife. Und dann muss man nur noch unterscheiden, ob eine Schleife mindestens einmal ausführen will (do-while) oder nicht (while).

 

[Hancock]

Also ne elegante Methode wäre Math.IEEEremainder, da nimmst du Math.PI als Divisor und dann bist du nah am Ziel dran (das Ergebnis ist in [-Pi,Pi]. Sonst würde ich

int n=(int)(x/(2*Math.PI));
x-=n*2*Math.PI;
//Jetzt ist x in [0,2*Pi)
bool negate;
if(x>Math.PI){
negate=true;
x-=Math.PI;
}
return (negate?-1:1)*mySin(x>Math.PI/2?Math.Pi-x:x);

Hab ich allerdings nicht getestet...

EDIT: ich bin grad am überlegen, was mit negativen x passiert...

 

[Maggiefix]

public static double transBesser(double x) {

		double multiplier = 1; 
		
		//1. Wenn x kleiner 0 
		if (x < 0) {
			x = -x;  
			multiplier = -1 ; 
		}
		
		//2. Solange x größer 2pi, ziehe 2pi ab  
		while ( x >= 2 * Math.PI) {
			x = x - 2 * Math.PI;
		}
		
		//3. Wenn x im Intervall [pi, 2pi]
		if (x > Math.PI && x < 2 * Math.PI) {
			x = x - Math.PI;
			multiplier = -1; 
		}
		
		//4. Wenn x im Intervall [pi/2, pi]
		if ( x > (Math.PI / 2) && x < Math.PI ) {
			x = Math.PI - x; 
		}
		
		x = x * multiplier;  		
		return x;
	}

Fall 1/3. machen mir jetzt noch sorgen da ja dort im Endeffekt wieder ein negativer X-Wert an mySin übergeben wird. Oder ist dies nicht zu vermeiden ?

 

[Hancock]

Wenn ich den Code richtig verstehe, dann funktioniert dein mySin auch für negative Werte (ist im Endeffekt die Reihendarstellung des Sinus, die abbricht, wenn das Glied kleiner als die Genauigkeit wird).
Aber du könntest es ja auch testen^^.

 

[simpsonsfan]

Implementieren Sie eine neue Klassenmethode mySinBesser, welche zunächst den Parameter auf das dichtere Intervall [0, (pi/2)] transformiert und anschließend die Methode mySin mit dem transformierten Wert aufruft.

Lies dir halt die Aufgabenstellung nochmal durch. Du sollst gerade keinen negativen Wert übergeben (wenngleich das auch funktionieren sollte). Und deinen multiplier solltest du auch tunlichst nicht einfach fest auf -1 setzen.
Davon ab kannst du dir natürlich nach dem jeweilig vorhergehenden Schritt die doppelten IF-Abfragen sparen.

 

[SaimenD]

jo LUNKE hat recht aber er hat ja schon erklärt wie man das richtig machen kann
und das mit dem multiplier = -1 war auch ne blöde idee von mir
besser wärs warscheinlich wenn man schreibt multiplier = multiplier*(-1) dann musst du aber int multiplier=1 deklarieren