runden bis auf 2 stellen hinterm komma, 0 nicht wegschneiden

[marabu]

Hallo,

Zitat von 3_of_8:

... da musst du dich schon bei Intel beschweren, die ihren x86er so gebaut haben. ...

die FPU ist historisch gesehen ein x87, aber ich weiß was du meinst.

Zitat von Sidorion:

Dass die Borländer ein seltsames Verhältnis zur Mathematik haben, sieht man schon bei Mod.
Hier kommt bei negativen Dividend ein negativer Rest raus und der auch noch Betragsmäßig falsch.

Die MOD Operation bedarf stets der Definition - und es gibt mehr als eine Definition. Borland hat eine Definition gewählt und veröffentlicht: x mod y = x - (x div y) * y. Was ist daran seltsam?

Zitat von Sourcemaker:

... das behauptet die Delphi-Hilfe.

Die Behauptung habe ich gelesen. Abgeshen davon, dass deine Code-Zeile das Ergebnis 0.0000 liefert und somit nicht zur Erhellung der Problematik beiträgt, müsste nach deiner Argumentation 0.435 auf zwei Nachkommastellen gerundet 0.44 ergeben - das Eregbnis von RoundTo(0.435, -2) ist aber 0.43:

Delphi-Quellcode:

var
  d: Double;
begin
  d := 0.435; // 0,434999999999999998
  ShowMessage(Format('%.18f', [d]));
end;

Bei der Geschichte mit dem Banker's Rounding wird immer so getan, als ob das Verfahren auf Zahlen im Dezimalsystem ausgeführt würde, die FPU arbeitet aber mit dem dualen System. Und der IEEE Standard 754 spricht auch nicht vom Banker's Rounding:

Aus der HP 9000 Technical Documentation

The default rounding mode is round to nearest. The four rounding modes are:

Round To Nearest

Round to the representable value closest to the true value. If two representable values are equally close to the true value, choose the one whose least significant bit is 0. ...

Mir ist bewusst, dass es Zahlenbeispiele gibt, welche die Verwendung des Sinnbildes rechtfertigen, aber man sollte dabei aufpassen, dass man den Gültigkeitsbereich nicht verlässt. Für Round(10.5) und Round(11.5) wird tatsächlich zur nächsten geraden Zahl gerundet, aber wie man sieht gilt das nicht mehr, wenn RoundTo(value, digit) mit digit = -2 verwendet wird. Hier sei kurz angemerkt, dass RoundTo() sich auf Round() abstützt und die FPU das letzte Wort hat - da ist kein weiterer Pascal Code beteiligt, als der zur Skalierung innerhalb von RoundTo().

Ich erinnere mich an eine Fundstelle (Crawford & Gelsinger: Programming the 80386), wo der von Intel implementierte default rounding mode ohne weitere Erklärungen als "round towards nearest or even" bezeichnet wurde. Die Original Intel Referenz habe ich gerade nicht griffbereit, aber ich vermute, dass es interessant wäre darin zu lesen.

Freundliche Grüße

[3_of_8]

Mein Post war eine Antwort auf Sidorion mit seinem mod, da hat die FPU nichts damit zu tun.

[Progman]

Hinweis:

myStr := FloatToStrF(myFloat, ffFixed, 8, 2); //die 2 steht für die Nachkommastellen, gerundet wird automatisch

[alzaimar]

Hmmm. Interessante Diskussion. Ich verwende einfach:

Delphi-Quellcode:

Function Aufrunden (Const aValue : Extended; aDecimals : Byte) : Extended;
Var
  aDivider : Extended;

Begin
  aDivider := Power (10,aDecimals);
  If aValue>0 Then
    Result := Trunc (aValue*aDivider + 0.5) / aDivider
  else
    Result := Trunc (aValue*aDivider - 0.5) / aDivider;
End;

Das macht dann, unanhängig von Borland, Borländern, Wikis, Intels, FPU's und deren Befindlichkeiten, stehts das Gleiche.

@Progman: Komisch, FloatToStrF(0.435, ffFixed, 8, 2) liefert 0.44...

[Progman]

ist doch mathematisch korrekt, die 5 wird aufgerundet

[alzaimar]

Alter ist DAS früh!

[bit4bit]

@alzaimar

Deine Funktion führt reproduzierbar und portabel eine kaufmännische Rundung aus.

Der Name "Aufrunden" verwirrt da dann doch ein wenig, oder ?



bit4bit

[Thomas Feichtner]

Zitat von alzaimar:

Hmmm. Interessante Diskussion. Ich verwende einfach:

Delphi-Quellcode:

Function Aufrunden (Const aValue : Extended; aDecimals : Byte) : Extended;
Var
  aDivider : Extended;

Begin
  aDivider := Power (10,aDecimals);
  If aValue>0 Then
    Result := Trunc (aValue*aDivider + 0.5) / aDivider
  else
    Result := Trunc (aValue*aDivider - 0.5) / aDivider;
End;

Mit dieser Funktion habe ich auch nicht immer den richtigen Wert (xRound(2.51 * (100 - 74.5) / 100, 4)) bekommen

jetzt habe ich die Funktion ein wenig umgebaut. Bis jetzt funktionierts.

Delphi-Quellcode:

function  xRound(e: Extended; d: Integer ): Extended;
var
  nWert1: Extended;
  nTemp1: Currency;
begin
  nWert1 := e;
  { Zuerst Zahl multiplizieren, damit diese als Currency arbeiten kann
    damit bei xRound(2.51 * (100 - 74.5) / 100, 4) = 0.6401 auskommt und nicht
    0.64 }
  nTemp1 := e * IntPower(10, d - 1);
  if nTemp1 < 0.0 then
    nTemp1 := Trunc(nTemp1 * IntPower(10, 1) - 0.5 ) / IntPower(10, 1)
  else
    nTemp1 := Trunc(nTemp1 * IntPower(10, 1) + 0.5 ) / IntPower(10, 1);
  nWert1 := nTemp1 / IntPower(10, d - 1);
  { Jetzt normal runden -> sollte nicht mehr nötig sein }
  if nWert1 < 0.0 then
    Result := Trunc(nWert1 * IntPower(10, d) - 0.5 ) / IntPower(10, d)
  else
    Result := Trunc(nWert1 * IntPower(10, d) + 0.5 ) / IntPower(10, d);
end;