SameValue-Vergleiche in Settern

[karlkoch]

Hallo,

folgendes Codebeispiel:

Delphi-Quellcode:

type
  TMyClass = class
  private
    FPosition: Single;
    procedure SetPosition(Value: Single);
  public
    property Position read FPosition write SetPosition;
  end;

...

procedure TMyClass.SetPosition(Value: Single);
begin
  if not SameValue(Value, FPosition) then
  begin
    FPosition := Value;
    // Führe aufwendige Berechnungen durch
  end;
end;

Bisher habe ich für Gleitkommavergleiche SameValue verwendet. In diesem konkreten Fall kann es jedoch zu Problemen führen. Wird SameValue mit einem Epsilon von 0 aufgerufen, berechnet die Funktion ein eigenes Epsilon anhand der Eingabewerte. Dieses Epsilon kann dann so groß sein, das bereits 50000 und 50001 als gleich angesehen werden. Aber selbst bei einem kleinen Epsilon von z.B. 0.00001 gibt es das Problem, das fast gleiche Positionen bereits als gleich angesehen werden und die fast gleiche Position nicht übernommen wird. Wenn sich der Aufrufe von SetPosition jedoch darauf verlässt, dass die übergebene Position auch immer die neue Position ist, und mit dieser Position dann weiterrechnet, dann kann es bei sehr kleinen Positionsveränderungen passieren, dass überhaupt keine neue Position übernommen wird (wenn z.B. die Position in einem Timer inkrementiert wird (mit sehr kleinen Schritten)).

Nun meine Frage: Wie seht ihr das Problem bzw. wie ist hier die generelle Vorgehensweiße? Sollte man womöglich gar nicht mit SameValue in Settern arbeiten?

karlkoch

[Klaus01]

Bei sameValue kannst Du doch einen Epsilonwert
vorgeben.
Diesen Vorgabenwert kannst Du doch flexibel handhaben
je nachdem wie groß FPosition ist.

Delphi-Quellcode:

epsilon := FPosition * 0.0000001;

Grüße
Klaus

[Uwe Raabe]

Wenn du auf Nummer Sicher gehen willst, dann ersetze das "not SameValue" durch ein schlichtes "<>". Allerdings kann es dann zu einem erhöhten Rechenaufwand kommen.

Dein Problem mit den vielen kleinen Inkrementen kannst du damit in den Griff bekommen, in dem du den Aufrufer von SetPosition dazu veranlasst danach die Position noch einmal auszulesen. Er bekommt dann den echten Wert (nicht den er erwarten würde) und nach einer genügenden Zahl kleiner Inkremente wird die der Unterschied schon groß genug sein für SameValue.

[alzaimar]

Bei Floatingpoint-Werten kann man nicht immer erwarten, das scheinbar identische Werte auch wirklich 'gleich' sind. Warum das so ist, ist ein anderes Thema.

Wieso verwendest du also 'SameValue'?

Willst du nur eine gewisse 'Granularität' zulassen, um Berechnungen nicht zu oft durchzuführen? Dann definiere diese Granularität und lasse sie den Benutzer verändert (als public property). Alternativ kannst du die Granularität auch in Prozent/Promille angeben, à la "Erst wenn sich der Wert um x Prozent ändert, führe eine Neuberechnung durch".

Oder hast Du einfach nur gehört, das man FP-Werte nicht auf Gleichheit prüfen sollte? Dann nimm ein Epsilon, das um 2-3 Stellen über der Genauigkeit des von Dir verwendeten Datentypes liegt. Die Unterschiede scheinbar identischer Werte liegen i.A. in den letzten darstellbaren Stellen. Nur bei extrem perversen Iterationen schaukelt sich die Differenz hoch.