Nun frage ich mich, wann zwei Gleitkommazahlen "gleich genug" sind.

Hier eignet sich eigentlich kein Template. Da das Epsilon idealerweise abhängig vom Fall (Der benötigten Genauigkeit) zu wählen ist.

Wie asc sagte, kommt es drauf an, wie tolerant du sein kannst. Ich nehme an, du willst die Fliesskommazahlen zu einem bestimmten Zweck vergleichen - dann wirst du wahrscheinlich auch eine geeignete Genauigkeit finden.

Wie finde ich ein möglichst kleines Epsilon für einen bestimmten Zahlenbereich?
Kann man denn irgendwie feststellen, ob die Differenz zweier Gleitkommazahlen größer ist als die kleinstmögliche Differenz zwischen beiden?

Kann man denn irgendwie feststellen, ob die Differenz zweier Gleitkommazahlen größer ist als die kleinstmögliche Differenz zwischen beiden?

Das ergibt irgendwie keinen Sinn, da sollte ich nochmal drüber nachdenken.:)

std::numeric_limits<>::epsilon() hilft dir da eigentlich nicht viel, da es nur die kleinste mögliche Inkrementierung von 1. angibt.

Und gibt es eine Möglichkeit, die kleinste mögliche Inkrementierung einer beliebigen Gleitkommazahl zu bestimmen?

const float dein_toleranzwert_fuer_1x1 = 0.00001f;

bool IsSame (float a, float b, float coord_x, float coord_y)
{
 a -= b;
 b = dein_toleranzwert_fuer_1x1 * sqrt(coord_x * coord_y);
 if (a < 0)
     return a >= -b;
 return a <= b;
}

bb

nimm halt:

const float dein_toleranzwert_fuer_1x1 = 0.00001f;
[...]

Ich verstehe die Intention dahinter, aber wie kommst du auf die 0.00001?

template<T>
static T getTolerance( T dummy )
{
  return T(0);
}

und dann ein paar spezialisierungen anlegen:

template<>
static double getTolerance( double dummy )
{
  return .000001;
}

template<>
static float getTolerance( float dummy )
{
  return .0001f;
}

bin mir grad nicht sicher, ob die syntayx bei den spezialisierungen korrekt sind, aber ihr wisst was gemeint ist.

Eventuell kann man das epsilon auch abhängigmachen, von der größe von dummy, da ja die genauigkeit bei großen zahlen abnimmt

Gleitkommazahlen fragt man auf Gleichheit immer auf den Absultwert (fabs) der Differenz der beiden Werte auf kleiner eines Toleranzwertes (z.B. eps=0.1e-5) ab.

Na hoffentlich nicht.
http://c-faq.com/fp/fpequal.html

berniebutt schrieb:

Gleitkommazahlen fragt man auf Gleichheit immer auf den Absultwert (fabs) der Differenz der beiden Werte auf kleiner eines Toleranzwertes (z.B. eps=0.1e-5) ab.

Na hoffentlich nicht.
http://c-faq.com/fp/fpequal.html

double d1=7.500000002;
double d2=15.00000002;
double dx;
double eps=1.e-6;
int    gleich;

dx=fabsl(d1-d2/2.0);
if(dx < eps) gleich=TRUE;
  else       gleich=FALSE;

Was soll an dieser alt bewährten Vorgehensweise zum Prüfen zweier Gleitkommanzahlen auf Gleichheit etwas anders oder besser gemacht werden? So jedenfalls geht es klar und übersichtlich für alle Compiler und ist eine gängige Praxis, vor allem bei Iterationen. Der WEB-Hinweis sagt auch nichts anderes!

Was soll an dieser alt bewährten Vorgehensweise zum Prüfen zweier Gleitkommanzahlen auf Gleichheit etwas anders oder besser gemacht werden?

Das Problem kommt dann, wenn du mit sehr großen oder sehr kleinen Zahlen operierst. Wenn du auf Zahlen bei 1.e-7 opererierst, sind sie nach dem "Standard-Algorithmus" immer gleich - was ja wohl kaum gewollt sein kann. Und bei sehr großen Zahlen hast du praktisch nie "Gleichheit", auch wenn es eigentlich so sein sollte. Deshalb ist die Lösung aus dem cygnus-software-Link so interessant, weil es die Problematik eben löst.