Zahlen runden

Hi!
Wie kann ich eine Float-Zahl auf zwei Nachkommastellen runden?
Ohne z.B. %7.2f zu benutzen. Ist das mit einfachsten Mitteln möglich?
Vielen Dank für eure Hilfe!

Walli

Ja, such mal im Forum. Wurde schon oft gefragt. Kurz: Du multiplizierst mit 1000 und weist das einem Integer zu. Dann holst du dir die letzte Ziffer mit dem %-Operator und merkst dir ob die >= 5 ist. Dann dividierst du durch 10 und addierst eine 1, falls die letzte Ziffer >= 5 war. Nun weist du das Ganze einem float zu und teilst durch 100, fertig! Ist nur auf die Schnelle, kann also Denkfehler enthalten. Einfach mal ausprobieren ;).

Hi!
Hab's so gemacht:
float j;
int h;
K=(K+0.005)*100;
h=K;
j=h/100;

Das funktioniert aber nicht. Es kommt nur so etwas wie 203.00000000 obwohl 203.28 erscheinen müsste. Seht ihr einen Fehler?

Walli

Ganzzahldivision im letzten Schritt...

??? Ganzzahldivision ????
Eine kleine Erläuterung bitte für mich

randa

Bei einer int-Division entstehen keine Kommas, das Ergebnis wird ganzzahlig. Teile durch 100.0f, in dem Fall castet der Compiler automatisch h nach float und berechnet wie gewünscht. Letztendlich müssen ja beide Zahlen float sein, damit korrekt gerechnet werden kann, und das wird erreicht, wenn einer der beiden (Dividend/Divisor) float ist.

Ahh, alles klar!
Jetzt hab ich aber so ein Ergebnis: 203.27999999
Woran könnte das liegen?

Hi!
Hab ne Lösung gefunden. Wenn man printf mit %g anstatt mit %f aufruft, wird die richtige Zahl dargestellt. Aber warum ist das so?

Walli

Golfi schrieb:

Ahh, alles klar!
Jetzt hab ich aber so ein Ergebnis: 203.27999999
Woran könnte das liegen?

Es liegt daran, dass die Builtin-Gleitkommatypen nicht beliebig genau sind. Wurde aber auch schon zigmal hier erklärt warum (-> Forensuche).

Sunday

zum Beispiel so:

//---------------------------------------------------------------------------
// LUT für 10^x (max. x = 9)
//---------------------------------------------------------------------------
static const double Power10_LUT[] = {      1.0,      10.0,      100.0,      1000.0,      10000.0,
                                      100000.0, 1000000.0, 10000000.0, 100000000.0, 1000000000.0 };
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
// Funktion rundet die angegebene Gleitkommazahl auf die gewünschte
// Anzahl an Nachkommastellen.
//
// Parameter:
// ==========
//   double Value     :  zu rundender Wert
//   int    Precision :  Anzahl der Nachkommastellen
//
// Rückgabe:
// =========
//   double           :  auf Precision gerundeter Wert
//---------------------------------------------------------------------------
double Round(const double Value, const int Precision)
{
  if (Precision < 0) return Value;

  double Power10;

  if (Precision > 9) Power10 = pow(10.0, (double) Precision);
  else               Power10 = Power10_LUT[Precision];

  double TmpValue   = Value * Power10;
  double FloorValue = floor(TmpValue);

  return (FloorValue + 0.5) >= TmpValue ? ( FloorValue        / Power10) : 
                                          ((FloorValue + 1.0) / Power10);
}