Genauigkeit von Datentypen

[PaddyVII]

Guten Mittag, Delphianer,

ich denke ich hab hier etwas gefunden, über das nicht nur ich mir den Kopf zerbreche, aber ich möchte es verstehen, deshalb frag ich euch:

Vorarab: Ich wollte einen Münzgeldrechner schreiben (Quellcode ist unten), der einen Betrag, den man eingibt umwandelt in Münzgeld wechselt. Ziel dabei war es, so wenig wie möglich Münzen zu benutzen. Dies war die aufgabenstellung, nun kommt mein dazu passender code

Delphi-Quellcode:

procedure TForm1.edtEingabeChange(Sender: TObject);
var
  EingegebeneZahl: Currency;
  arGeld: array [0 .. 7] of Currency;
  i: Integer;
  zaehler: Integer;
begin
  // Array Füllen
  arGeld[0] := 2;
  arGeld[1] := 1;
  arGeld[2] := 0.50;
  arGeld[3] := 0.20;
  arGeld[4] := 0.10;
  arGeld[5] := 0.05;
  arGeld[6] := 0.02;
  arGeld[7] := 0.01;

  EingegebeneZahl := StrToFloat(edtEingabe.Text);
  mmoLog.Lines.Add(FloatToStr(EingegebeneZahl));

  for i := 0 to 7 do
  begin
    zaehler := 0;
    repeat
      if EingegebeneZahl < arGeld[i] then
      begin
        break;
      end;
      mmoLog.Lines.Add('Operation: '+FloatToStr(EingegebeneZahl)+' - '+FloatToStr(arGeld[i]));
      EingegebeneZahl := EingegebeneZahl - arGeld[i];
      mmoLog.Lines.Add(FloatToStr(EingegebeneZahl));

      Inc(zaehler);
    until arGeld[i] > EingegebeneZahl;
    if arGeld[i] = 2 then
      lbl2.Caption := IntToStr(zaehler);
    if arGeld[i] = 1 then
      lbl1.Caption := IntToStr(zaehler);
    if arGeld[i] = 0.50 then
      lbl050.Caption := IntToStr(zaehler);
    if arGeld[i] = 0.20 then
      lbl020.Caption := IntToStr(zaehler);
    if arGeld[i] = 0.10 then
      lbl010.Caption := IntToStr(zaehler);
    if arGeld[i] = 0.05 then
      lbl005.Caption := IntToStr(zaehler);
    if arGeld[i] = 0.02 then
      lbl002.Caption := IntToStr(zaehler);
    if arGeld[i] = 0.01 then
      lbl001.Caption := IntToStr(zaehler);
  end;
end;

Dieser Code funktioniert, soweit ohne fehler!!


Ändert man jedoch den Datentyp von currency in double, single o.ä...Funkitioniert das Programm nicht mehr richtig!! (Als kleine veranschaulichung habe ich ein memo eingebaut, welches die aktion mitschreibt, die gerade durchgeführt wird). Es wird nach der Dritten bzw. 4 Berechnung alles ungenau, und es wird nicht mehr weiter berechnet.




Ich will wissen warum?!! warum ändert sich der wert von alleine/ wird ungenau...


Ich hoffe ein paar von euch können sich einen Reim darauf machen



LG

Paddy_VII

p.s: es geht nicht darum, ob der Code nun effizient ist, oder nicht ?

[Union]

Das liegt an der internen Darstellung. Ein Wert 0.5 wird als Double evtl. als 0.5000000128973 gespeichert. Für diese Fälle arbeite mit CompareValue mit einem entsprechenden Delta.

[PaddyVII]

aber warum genau wird der wert ungenau?? wir haben ihn als double angegeben, klar aber dann müsste doch auch 0,5 0,5000000000000000000000000000 werden und nich irgendwelche wahllosen zahlen hintendranhackseln

[Daniel]

Das hängt damit zusammen, dass auch ein moderner Computer Fließkommazahlen nicht exakt darstellen kann.
Schau mal dort:
http://de.wikipedia.org/wiki/Gleitkommazahl

[PaddyVII]

aber dann bedeutet das doch, dass es mit Single double usw. völlig schwachsinnig wäre zu rechnen, weil sie ehh ungenau werden oder?

[Daniel]

Wie genau brauchst Du es denn?
Jeder Datentyp hat eine auf n Stellen garantierte Genauigkeit.
Dann muss man schauen, was man braucht und kann dann den entsprechenden Datentyp wählen.

"Single" ist für viele, viele Fälle absolut ausreichend.

[PaddyVII]

Zitat von Union:

Das liegt an der internen Darstellung. Ein Wert 0.5 wird als Double evtl. als 0.5000000128973 gespeichert. Für diese Fälle arbeite mit CompareValue mit einem entsprechenden Delta.

Wie würde denn das programm mit compareValue aussehen??

[DeddyH]

Zitat:

if arGeld[i] = 2 then

if SameValue(arGeld[i], 2, 0.005) then oder
if CompareValue(arGeld[i], 2, 0.005) = EqualsValue then

[himitsu]

Und wenn man die 0.005 weg lässt, dann wird automatisch ein typspezifischer Wert genommen.

Delphi-Quellcode:

const
  FuzzFactor = 1000;
  ExtendedResolution = 1E-19 * FuzzFactor;
  DoubleResolution   = 1E-15 * FuzzFactor;
  SingleResolution   = 1E-7 * FuzzFactor;

function SameValue(const A, B: Extended; Epsilon: Extended): Boolean;
begin
  if Epsilon = 0 then
    Epsilon := Max(Min(Abs(A), Abs(B)) * ExtendedResolution, ExtendedResolution);
  ...
end;

function IsZero(const A: Extended; Epsilon: Extended): Boolean;
begin
  if Epsilon = 0 then
    Epsilon := ExtendedResolution;
  ...
end;

[mm1256]

Ob es Sinn macht, statt Double Currency zu verwenden muss wohl jeder für sich selber entscheiden. Es kommt auf den Einzelfall an. Wenn z.B. ein Preis aus Menge mit bis zu 3 Nachkommastellen, Rabatt mit zwei Nachkommastellen, oder sogenannten Multi's wie sie bei Datanorm verwendet werden mit 3 Nachkommastellen....usw. berechnet werden muss, dann muss man Double und Currency mischen. Das ist auch nicht der Hit und darum kann es eleganter sein, die Doubles entsprechend zu behandeln.

Zitat von DeddyH:

if SameValue(arGeld[i], 2, 0.005) then

... in eine kleine Funktion packen, wenn man Double's für Beträge verwenden möchte

Delphi-Quellcode:

function GleicherBetrag(D1, D2: double): boolean;
begin
  Result := SameValue(D1, D2, 0.011);
end;