Float auf nächsten Zehner runden

maikmueller

Danke!

Komischerweise bin ich über den ersten Eintrag heute Morgen schon mal gestolpert...

maikmueller

Irgendwie komme ich hier nicht weiter. Die Funktion scheint wohl geeignet aber ich bekomme bei folgendem Code:

int zahl = 240; 
double temp = zahl/100; 
round(temp); 
zahl = temp*100;

Ich habe in meiner Form die math.h mit #include <math.h> auch eingebunden. Scheinbar interessiert das meinen C++ Builder 2010 mal garnicht.

Ich bin etwas ratlos.

LG Maik

akari

Hallo

Die round-Funktion ist in meinem BCB5 auch nicht integriert, deshalb habe ich im ersten Link ja auch andere vorgeschlagen.
Letzendlich ist das Stellenschieben bei Fließkommazahlen auch nicht das wahre. Denn Fließkommazahlen sind niemals exakt. Fließkommazahlen werden nur für die Ausgabe zurechtformatiert. Und das wird ja im zweiten Link erklärt. In deinem Fall :

double zahl = 1126.76;
  Edit1->Text=zahl;
  Edit2->Text=FloatToStrF(zahl, ffNumber, 8,1);

bis bald
akari

Wobei man mit dem round auch vorsichtig sein muss. Dass rundet nach dem amerikanischen Prinzip.

Wenn du exakt rechnen willst, musst du auf Integervariablen ausweichen. Fließkommavariablen nimmt man nur zum Schätzen.

maikmueller

Danke für deine Antwort, bei dieser Funktion schneidet er ja die letzte Zahl nur ab und rundet nicht. Ich muss mit dieser Zahl aber dann weiterrechnen und bin darauf angewiesen das keine "krummen" Zahlen nach dem Komma stehen. Weiß gerade auch nicht wie ich das jetzt lösen soll

Falls jemand noch eine Idee hat wäre ich dankbar.

LG Maik

akari

Hallo

bei dieser Funktion schneidet er ja die letzte Zahl nur ab und rundet nicht

Stimmt nicht. Die Ausgabe ist 1.126,8.

Ich muss mit dieser Zahl aber dann weiterrechnen und bin darauf angewiesen das keine "krummen" Zahlen nach dem Komma stehen. Weiß gerade auch nicht wie ich das jetzt lösen soll

Jedenfalls nicht mit den Fließkommatypen. Diese sind wie schon angemerkt immer potentiell ungenau.

bis bald
akari

Hallo,

rundet FormatFloat, oder schneidet das auch nur ab?

FormatFloat("#,##0.00",float);

VlG

Weder noch, nur die Ausgabe wird formatiert. Der Wert der Variablen bleibt unverändert.

_matze

maikmueller schrieb:

Irgendwie komme ich hier nicht weiter. Die Funktion scheint wohl geeignet aber ich bekomme bei folgendem Code:
int zahl = 240; 
double temp = zahl/100; 
round(temp); 
zahl = temp*100;

Was auch immer du bekommst (Satzende vergessen? ), hier machst du folgenden Fehler: du weist temp einen integer-Wert zu. Der hat natürlich keine Nachkommastellen. zahl ist ein int, 100 ist ein int(egrales Literal), also ist das Ergebnis des Ausdrucks auch ganzzahlig. Probier es mal so:

int zahl = 240; 
double temp = zahl/100.; //100. ist ein double-Literal, im Gegensatz zu 100 (int) oder 100.f (float)
round(temp); 
zahl = temp*100;

JBOpael

Mit RoundTo (math.hpp) kannst du auch noch festlegen auf welche kommastelle gerundet werden soll.

int zahl = 240; 
double temp = zahl/100.; //100. ist ein double-Literal, im Gegensatz zu 100 (int) oder 100.f (float)
RoundTo(temp,-2); 
zahl = temp*100;

Hallo,

_matze schrieb:

double zahl = 1126,76; // mal angepasst 
double temp = zahl/100; 
round(temp); 
zahl = temp*100;

was soll das bringen?
1126,76 / 100 = 11,2676
round(11,2676) = 11,3
11,3 * 100 = 1130

RoundTo find ich klingt verlockend.

VlG

double zahl= 10,1234;
zahl=(zahl*100)+0,5;
int zahl2=int(zahl);
double result=double(zahl2)/100.000;

RoundTo dürfte allerdings ebenfalls nach dem amerikanisches Prinzip runden...
Nimm den Code von nativ coder... Ist auch nur ein kleiner Fehler drin...

maikmueller schrieb:

Danke für deine Antwort, bei dieser Funktion schneidet er ja die letzte Zahl nur ab und rundet nicht. Ich muss mit dieser Zahl aber dann weiterrechnen und bin darauf angewiesen das keine "krummen" Zahlen nach dem Komma stehen. Weiß gerade auch nicht wie ich das jetzt lösen soll

Falls jemand noch eine Idee hat wäre ich dankbar.

LG Maik

/*
	rounds the double value to 1 decimal digits and returns
	the hundreds as int
*/
int roundKrfb( double *fltPtr )
{
	double	fltVal = *fltPtr;
	int		intVal;

	fltVal *= 10.0;
	if( fltVal < 0 )
		intVal = (int)(fltVal - 0.5);
	else
		intVal = (int)(fltVal + 0.5);
	*fltPtr = ((double)intVal) / 10.0;

	return intVal*10;
}

mfg Martin

berniebutt

Das ist rein ANSI-C!

Ich setze dafür eine eigene Funktion ein:

void Runden(DOUBLE von,DOUBLE *nach,int nk)
// ---------------------------------------------------------------------------
// Fliesskommazahl runden
// ---------------------------------------------------------------------------
// von     übergebene Fliesskommazahl
// *nach   Zeiger auf gerundete Fliesskommazahl
// nk      Anzahl der Nachkommastellen
// DOUBLE  Längster verfügbarer float-Typ
// ---------------------------------------------------------------------------
{
   long int   lvon;
   int        irest,i,faktor;
   DOUBLE     rest,ziel;

// test << "--> Runden" << endl;
// test << "... von-nk    " << von << "  " << endl;
   if(nk)
   {
      faktor = 1;
      for(i=0;i<nk;i++) faktor *=10;
      lvon  = (long int) von;
      rest  = von - (DOUBLE)lvon + 0.5/faktor;  // Rundung in nk+1
      irest = rest * faktor;
      ziel = (DOUBLE)lvon + (DOUBLE)(irest) / faktor;
//    test << "... faktor    " << faktor << endl;
//    test << "... lvon      " << lvon << endl;
//    test << "... rest      " << rest << endl;
//    test << "... irest     " << irest << endl;
   }
   else ziel = von;

   *nach = ziel;  // gerundetes Ergebnis

// test << "... ziel      " << ziel << endl;
// test << "--> Runden exit" << endl;
   return;
}

Diese Funktion tut das gewünschte. Wer will, mag eine Optimierung versuchen.