C - Gleitkomma Genauigkeit 2

JamesNguyen

Ich habe nun meine FUnktion angepasst und sie bricht jetzt auch immer ab denke ich

double quwl ( double rad )
{
	if ( rad < 0 ) return - 1 ;
	
	auto double xN = 1 ;
	
	if ( xN  < sqrt ( DBL_MIN )                 ||
		 xN  > sqrt ( DBL_MAX )                 ||
		 rad > DBL_MAX - xN * xN ) return - 1 ;
	
	auto double xNplus1 = 1 / ( 2 * xN ) * ( xN * xN + rad ) ;
	
	while ( fabs ( xNplus1 - xN ) > rad * 1e-14                       &&
						  xNplus1 > sqrt ( DBL_MIN ) - 1              &&
						  xNplus1 < sqrt ( DBL_MAX ) + 1              &&
			    			  rad < DBL_MAX - xNplus1 * xNplus1 + 1 )
	{
		xN = xNplus1 ;
		
		xNplus1 = 1 / ( 2 * xN ) * ( xN * xN + rad ) ;
	}
	
	return xNplus1 ;
}

aber kann mir jemand insbesondere in Verbindung mit der Genauigkeit von double erklären warum es funktioniert?

Auch habe ich gemerkt das ich die erste Bedingung in der while-Bedingung nicht unbedingt brauche

xNplus1 != xN && fabs ( xNplus1 - xN ) > rad * 1e-14 &&

also die Gleichheit. warum?

Danke,
James

DirkB

@JamesNguyen Du wurdest schon gebeten, deinen Code in Codetags zu packen.

Markiere deine Funktion mit der Maus und clicke au das </> neben dem C++ in der Editleiste.

Du hast Epsilon entdeckt.

JamesNguyen

Also so wie ich das sehe habe ich keine Ahnung wie ich Rundungsfehler in meinem Programm berücksichtige. einfach keine Ahnung

DirkB

@JamesNguyen Das fabs ( xNplus1 - xN ) > rad * 1e-14 ist die eigentliche Bedingung.

Mit dem 1E-14 legst du die Genauigkeit fest.

JamesNguyen

ok , ist das dann die richtige Bedingung für diese Problem ?

und sind die restlichen Bedingungen in meinem While ausdruck auch sinnvoll oder notwendig?

aber was ich eben noch nicht versteh ist ob ich Probleme

von der Natur

0.1 + 0.1 +0.1 + usw.

in meinem Programm berücksichtigt habe

da in meinem programm ja auch mit doubles gerechnet wird

bspw. xN * xN

DirkB

@JamesNguyen Je mehr Berechnungen du machst, umso größer kann sich der Fehler fortpflanzen, d.h. die Ungenauigkeit steigt.

JamesNguyen

ah meinst du also dass ich diese ungenauigkeiten gar nicht verhindern kann

sondern mein ergebnis nicht beliebig genau angeben kann?

wenn das so ist. wie weiß ich wie groß die ungenauigkeit ist

und wie kann ich mein ergebnis darauf anpassen?

DirkB

@JamesNguyen sagte in C - Gleitkomma Genauigkeit 2:

wie weiß ich wie groß die ungenauigkeit ist
und wie kann ich mein ergebnis darauf anpassen?

Abschätzen.
Das hängt von deinem speziellen Problem ab.

JamesNguyen

@DirkB sagte in C - Gleitkomma Genauigkeit 2:

Das fabs ( xNplus1 - xN ) > rad * 1e-14 ist die eigentliche Bedingung.
Mit dem 1E-14 legst du die Genauigkeit fest.

du hast ja geschrieben das legt die genauigkeit fest.

Ich würde eher sagen, dass legt fest ob er mehr oder weniger stellen des ergebnisses zurückgibt

Wie ungenau mein Ergebnis durch sich vergrößernde Fehler ist , ist damit nicht gesagt.

Th69

Überprüfe mal die Zeile 7 (if-Bedingung) - die kann so niemals zutreffen.

Und den !=-Vergleich in der while-Bedingung kannst du auch weglassen, da du doch sowieso die Differenz überprüfst.
Auch den Sinn des letzten Vergleichs in der Bedingung verstehe ich nicht.

PS: Für die Literale solltest du besser Konstanten (Makros) benutzen, damit der Code lesbarer wird.

JamesNguyen

ok update mit makros

double quwl ( double rad )
{
	if ( rad < 0 ) return - 1 ;
	
	auto double xN = 1 ;
	
	if ( xN  < sqrt ( DBL_MIN )                 ||
		 xN  > sqrt ( DBL_MAX )                 ||
		 rad > DBL_MAX - xN * xN ) return - 1 ;
	
	auto double xNplus1 = 1 / ( 2 * xN ) * ( xN * xN + rad ) ;
	
	while ( fabs ( xNplus1 - xN ) > rad * 1e-14                       &&
						  xNplus1 > sqrt ( DBL_MIN ) - 1              &&
						  xNplus1 < sqrt ( DBL_MAX ) + 1              &&
			    			  rad < DBL_MAX - xNplus1 * xNplus1 + 1 )
	{
		xN = xNplus1 ;
		
		xNplus1 = 1 / ( 2 * xN ) * ( xN * xN + rad ) ;
	}
	
	return xNplus1 ;
}

JamesNguyen

@DirkB

du hast vorher mal gesagt ich habe epsilon entdeckt

ich habe das mit probieren sehr weniger werte gefunden

werte die allein bei der != bedingung die iteration nicht abgebrochen haben

und so das programm ewig weiter lief

ist das eig das richtige epsilon?

wenn ja wieso?

lässt sich das mit der genauigkeit von double begründen?

JamesNguyen

Der Wert 0

liefert

-1.#IND00

?

DirkB

@JamesNguyen sagte in C - Gleitkomma Genauigkeit 2:

du hast vorher mal gesagt ich habe epsilon entdeckt

Epsilon ist die Bezeichnung für die Genauigkeit.
Es ist die Differenz, unterhalb der zwei Werte als gleich gelten.

Es ging auch nicht um einen speziellen Wert, sondern um die Tatsache dass man den braucht.

JamesNguyen

heißt das ich kann den selbst festlegen und es gibt keinen richtigen und falschen?

naja es könnte bspw. sein

das ich zu einem wert

ein epsilon finde

das genau dort die wurzeliteration beendet sodass die letzte stelle korrekt ist

aber gibt es ein bestimmtes epsilon das dies für alle werte richtig macht?

Oder soll ich dafür eine möglichst großes wählen?

DirkB

@JamesNguyen Epsilon ist ein Wert, kein Faktor.
Aber du kannst Epsilon aus den Vergleichswerten und der Genauigkeit berechnen.
Als Faktor hattest du ja 1e-14 genommen.

JamesNguyen

weil wenn ich das epsilon bei

radikant * 1e^-14

lasse

habe ich bspw. (bei vergleich mit wolfram alpha)

für bspw.

quwl ( 0.123456789012345 )

ist die letzte stelle von mir nicht richtig gerundet

JamesNguyen

Dieser Beitrag wurde gelöscht!

JamesNguyen

@DirkB sagte in C - Gleitkomma Genauigkeit 2:

@JamesNguyen Epsilon ist ein Wert, kein Faktor.
Aber du kannst Epsilon aus den Vergleichswerten und der Genauigkeit berechnen.
Als Faktor hattest du ja 1e-14 genommen.

wie kann ich das machen?

welche vergleichswerte meinst du?

weil diesen faktor habe ich glaube lediglich aus der wurzel (0.0025) glaube ich weil da die schleife endlos war

dann habe ich den solange größer gemacht bis die scfhleife abgebrochen hat

JamesNguyen

Ich habe jetzt mal weiter dran gearbeitet

double quwl ( double rad )
{
	if ( rad < 0 ) return - 1 ;
	
	auto double xN = 1 ;
	
	if ( xN  < sqrt ( DBL_MIN )                 ||
		 xN  > sqrt ( DBL_MAX )                 ||
		 rad > DBL_MAX - xN * xN ) return - 1 ;
	
	auto double xNplus1 = 1 / ( 2 * xN ) * ( xN * xN + rad ) ;
	
	while ( fabs ( xNplus1 - sqrt ( rad ) ) < fabs ( xN - sqrt ( rad ) )        &&
						    	    xNplus1 >= sqrt ( DBL_MIN )                 &&
						            xNplus1 <= sqrt ( DBL_MAX )                 &&
			    			            rad <= DBL_MAX - xNplus1 * xNplus1 )
	{
		xN = xNplus1 ;
		
		xNplus1 = 1 / ( 2 * xN ) * ( xN * xN + rad ) ;
	}
	
	return xN ;
}

gebe also xN und nicht xNplus1 zurück

zu Bedingung

angenommen

ich iteriere also

und

es kommt soll 5 am ende rauskommen

dann itereriert er

24 -> 15 -> 9 -> 6 -> 4

und dann bricht er ab (hier wird die annahme getroffen der wert kann auch 'auf die andere seite von 5 das wäre also nicht mehr streng monoton)

so

jetzt also betrag ( 6 - 5 ) = 1
betrag ( 4 -5 ) = 1

er bricht also ab

in meinem programm

würde er die 6 also xN

zurückgeben

und nicht 4 was xNplus1.

welche der beiden werte ist der richtige?

bzw. allgemeiner ist der wert richtiger dessen letzte nachkommastelle mit der richtigen zahl übereinstimmt oder
der wert dessen letzte nachkommastelle(n) vlt nicht übereinstimmen aber der wert liegt näher am richtigen wert?

wenn ich nun xNplus1 ausgebe

also

den letzten wert von

1.41421356237309510000
1.41421356237309490000

web2.0 rechnre liefert

1.414213562373095

hier wären beide werte gleich gut aber man würde sehen dass der die iteration von oben den richtigen wert unterschreitet hat

wolfram alpha liefert

1.41421356237309504....

hier wäre also der obere wert richtiger

könnte man das allgemein sagen und ich nehme lieber

xN also den oberen werte

und macht dann < statt <= in der bedingung?