Runden einer Dezimahlzahl

modooo

Wenn ich eine Dezimahlzahl eingebe wie kann ich die dann runden?
Ich hab irgendwas mit zb: intround(10.0+0.5 ) gelesen.
Aber es gibt ja auch negative Zahlen.
Jetzt weiß ich nicht genau wie ich das machen soll.
Den Speicherplatz für die Dezimahlzahl muß ich doch
als double deklarieren Oder?
Danke schon mal für die Hilfe.

linux

... <cmath> includieren und dann mit floor(deine_zahl) grundsätzlich ganzzahlig abrunden z.B. 1.2 auf 1.0 oder mit ceil(deine_zahl) grundsätzlich aufrunden.

Ansonsten kann mit dem Modulo-Operator % und mittels Divisionen durch 10 (ist ein bisschen Fummelei) wie üblich gerundet werden.

HumeSikkins

Hilft das?
Runden

Hallo,
hab da mal so ne alte Funktion ausgegraben...
ist nen bisschen Primitiv aber erfüllt eigentlich den Zweck.

int runden(float dez_zahl)
{
int z1, return_zahl;

z1 = (int)dez_zahl;
dez_zahl-=z1;
dez_zahl*= 10; //erste Nachkommastelle wird gerundet
if(dez_zahl < 5)
return_zahl = z1;
else
return_zahl = z1+1;

return return_zahl;
}

Funktion gibt gerundete Zahl als int zurück.
Gerundet wird hier die erste Nachkommastelle, sonst wie gewohnt ab 5 hoch kleiner als 5 abgerundet.

linux

... noch eine Alternative:

gerundetezahl = static_cast<int>(floatwert + 0.5) // für positive Zahlen

oder

gerundetezahl = static_cast<int>(floatwert - 0.5) // für negative Zahlen

Der static_cast-Operator bewirkt eine Umwandlung des Variablentyps.

HumeSikkins

@linux
Erklärst du mir mal, wo da was gerundet wird?
Nur mal so als Beispiel:
float floatwert = 1.2;
assert (static_cast<int>(floatwert + 0.5) == 1);

Würde ich nicht unbedingt als Runden bezeichnen.

Daniel E.

Sondern?

Hallo Chefe(Moderator), ich denke Du bist langjäriger Veteran !

Einfach mal ausprobieren. Gruss

(Irgendwas funktioniert mit der Anmeldung nicht, ich lande immer beim AnsiString-Beitrag)

int main()
{

float floatwert = 1.24;
float gerundetezahl;
gerundetezahl=static_cast<int>((floatwert*10) + 0.5);
cout<<(gerundetezahl/10)<<"\n"; // ergibt 1.2
// Die Rundungsgenauigkeit wird mit steigt mit der Zehnerpotenz

getchar();
return 0;
}

linux

... darüber hinaus hilft auch der das Includieren von <fenv.h>

Mit den bereitgestellten Funktionen kann man dann der Rundungsmodus des Fließkommasystems beinflusst werden.

... oder das Includieren von <math.h>

mit ceil(deinezahl*100)/100; kann dann auf zwei Nachkommastellen gerundet werden (wg. 100'er)

Es gibt aber noch unendlich weitere Möglichkeiten zu Runden.

Winn

Mit:
double ceil(double x);
float ceilf(float);
long double ceill(long double);

#include <math.h>
#include <stdio.h>

int main(void)
{
   double x = 100.001, y = 9.99;

   printf("The ceiling of %f is %f.\n", x, ceil(x));
   printf("The ceiling of %f is %f.\n", y, ceil(y));

   return 0;
}
Output:
The ceiling of 100.001000 is 101.000000.
The ceiling of 9.990000 is 10.000000.

Und:
double floor(double x);
float floorf(float);
long double floorl(long double);

#include <math.h>
#include <stdio.h>

int main(void)
{
   double x = 12.03, y = 10.999;

   printf("Floor value of %f is %f.\n", x, floor(x));
   printf("Floor value of %f is %f.\n", y, floor(y));

   return 0;
}
Output:
Floor value of 12.030000 is 12.000000.
Floor value of 10.999000 is 10.000000.

Gruß Winn

HumeSikkins

Sondern?

Abschneiden?

@<linux> oder linux
Ich sehe in deinem ersten Beitrag (auf den ich geantwortet habe) kein * 10.

Naja, scheinbar bin ich einfach mal wieder zu blöd. Ich hatte immer gedacht, dass zwischen Runden und dem einfachen Abschneiden der Nachkommastellen ein Unterschied besteht.

Und was der Sinn von +0.5 im Zusammenhang mit dem Abschneiden sein soll ist mir auch nicht klar.

PS: Und ceil und floor liefern IMO die kleinste obere bzw. die größte untere Schranke. Auch das hatte ich bisher nicht als Runden betrachtet.

Aber wie immer gilt natürlich: Im Zweifelsfall liege ich falsch.

[ Dieser Beitrag wurde am 09.06.2003 um 01:24 Uhr von HumeSikkins editiert. ]

wenn du über x.5 liegst, und 0.5 dazurechnest, dann hast du (x+1).0
also von x.5 bis y.0 + 0.5 = (x+1).0 bis (x+1).5 - abgeschnitten ergibt das dann
wenn die nachkommastelle größer als 0.5 ist den aufgerundeten wert und wenn nicht, den kleineren.

0.1 -> 0.6 -> 0
0.2 -> 0.7 -> 0
0.3 -> 0.8 -> 0
0.4 -> 0.9 -> 0
0.5 -> 1.0 -> 1
0.6 -> 1.1 -> 1
0.7 -> 1.2 -> 1
0.8 -> 1.3 -> 1
0.9 -> 1.4 -> 1
1.0 -> 1.5 -> 1
...
1.5 -> 2.0 -> 2

etc. das entspricht doch einem ganz normalen runden?!

aber wahrscheinlich willst du mal wieder auf irgendein detail hinaus, was runden eigentlich bedeutet.

dann erklär mal, was du mit runden meinst, und warum du meinst, das das, was linux (ohne <> ) vorgeschlagen hat, nicht Runden ist

willst du vielleicht auf ungenauigkeiten beim dazuzählen von 0.5 hinaus? (nicht 0.5 selbst sollte ungenau sein, aber die andere zahl)

oder an die grenze von den numeric_limits?

HumeSikkins

aber wahrscheinlich willst du mal wieder auf irgendein detail hinaus, was runden eigentlich bedeutet.

Ich? Wo denkst du hin

willst du vielleicht auf ungenauigkeiten beim dazuzählen von 0.5 hinaus

Nein.

Naja, dann will ich doch mal lösen.

Ich habe schlicht und einfach einen brutalen Denkfehler gemacht, den aber erst gestern nacht beim Zähneputzen registriert.

Die Zeile:

static_cast<int>(floatwert + 0.5)

sah für mich eigenartig aus. Also habe ich mir schnell ein paar Beispiele überlegt um zu prüfen, ob sie auch das macht, was der Autor von ihr behauptet.

Eine Beispielrechnung sah dabei so aus:
1.2 + 0.5 = 1.7

1.7 ist näher an 2 als an 1, also muss da 2 rauskommen (der aufmerksame Leser wird hier den Denkfehler erkennen). Es kommt aber 1 raus. Schlussfolgerung (aus falscher Annahme): Es wird nicht gerundet, sondern einfach abgeschnitten.

Dann kommt Daniel E. und fragt "Sondern?"
Wenn Daniel E. eine Antwort von mir in Frage stellt, dann heißt das bekanntlich in 99% der Fälle, dass ich mal wieder schwachsinn rede. Also habe ich noch mal gaaaanz intensiv drüber nachgedacht und auch nochmal den FAQ-Beitrag gelesen.
Dort steht u.A.:

10.3 + 0.5 == 10.8
Nachkommastellen weg: 10
und das passt.

Und ich: Hä? Seit ihr alle bsoffen? 10.3 + 0.5 == 10.8 -> das ist doch näher an 11 (der aufmerksame Leser erkennt die Hartnäckigkeit des Denkfehlers) als an 10. Also müsste beim Runden doch 11 rauskommen nicht 10. Das ist doch eindeutig abschneiden und nicht runden.

Soweit so gut. Irgendwie nagte aber immer noch der Zweifel an mir. Also dachte ich mir, dass es vielleicht überhaupt gar kein Abschneiden gibt und das dies auch einfach nur eine Spezialform des Rundens ist. In meinem Hinterkopf regten sich Erinnerungen an drei (oder vier?) verschiedene Rundungstechniken die ich mal in technischer Informatik im Zusammenhang mit der FP-Darstellung gelernt hatte. Gab's da nicht auch ein simples abschneiden?

Naja, wie auch immer. Aus irgendeinem Grund entschied ich mich dazu Daniel E. nicht zu glauben und meine Ansicht zu posten.

Aber egal wieviel ich hier noch schreibe:

Alle meine Überlegungen sind und waren falsch.
Sie beruhten auf einem Denkfehler und auf der Fixierung auf die Begriffe Runden und Abschneiden.

Ich entschuldige mich also für die Verwirrung die ich gestiftet habe.

linux

... und so habe ich mich doch im richtigen Forum registriert

Allerdings frage ich mich, warum modooo nicht kein Interesse zeigt.

linux

... das gibt's doch gar nicht ! Jetzt schreibe ich schon wie ein Legasteniker.

davie

@Hume: Vergeben und Vergessen

edit: falscher Thread

[ Dieser Beitrag wurde am 10.06.2003 um 02:32 Uhr von davie editiert. ]