¿Cómo debo hacer una comparación de punto flotante?

TL;DR

• Utilice la siguiente función en lugar de la solución actualmente aceptada para evitar algunos resultados no deseados en ciertos casos límite, siendo potencialmente más eficiente.
• Conozca la imprecisión esperada que tiene en sus números e introdúzcalos en consecuencia en la función de comparación.

bool nearly_equal(
  float a, float b,
  float epsilon = 128 * FLT_EPSILON, float abs_th = FLT_MIN)
  // those defaults are arbitrary and could be removed
{
  assert(std::numeric_limits<float>::epsilon() <= epsilon);
  assert(epsilon < 1.f);

  if (a == b) return true;

  auto diff = std::abs(a-b);
  auto norm = std::min((std::abs(a) + std::abs(b)), std::numeric_limits<float>::max());
  // or even faster: std::min(std::abs(a + b), std::numeric_limits<float>::max());
  // keeping this commented out until I update figures below
  return diff < std::max(abs_th, epsilon * norm);
}

¿Gráficos, por favor?

Al comparar números de coma flotante, existen dos "modos".

El primero es el modo relativo , donde la diferencia entre xy yse considera relativa a su amplitud |x| + |y|. Cuando se traza en 2D, se obtiene el siguiente perfil, donde el verde significa igualdad de xy y. (Tomé un epsilonvalor de 0,5 con fines ilustrativos).

El modo relativo es el que se utiliza para valores de coma flotante "normales" o "suficientemente grandes". (Más sobre esto más adelante).

El segundo es un modo absoluto , cuando simplemente comparamos su diferencia con un número fijo. Da el siguiente perfil (nuevamente con un epsilonvalor de 0,5 y un abs_thvalor de 1 a modo ilustrativo).

Este modo absoluto de comparación es el que se utiliza para valores de punto flotante "pequeños".

Ahora la pregunta es, ¿cómo unimos esos dos patrones de respuesta?

En la respuesta de Michael Borgwardt, el cambio se basa en el valor de diff, que debería estar por debajo abs_th( Float.MIN_NORMALen su respuesta). Esta zona de cambio se muestra sombreada en el siguiente gráfico.

Como abs_th * epsilones más pequeño que abs_th, los parches verdes no se pegan, lo que a su vez le da a la solución una mala propiedad: podemos encontrar tripletas de números tales que x < y_1 < y_2y aún x == y2pero x != y1.

Tomemos este sorprendente ejemplo:

x  = 4.9303807e-32
y1 = 4.930381e-32
y2 = 4.9309825e-32

Tenemos x < y1 < y2, y de hecho y2 - xes más de 2000 veces más grande que y1 - x. Y, sin embargo, con la solución actual,

nearlyEqual(x, y1, 1e-4) == False
nearlyEqual(x, y2, 1e-4) == True

Por el contrario, en la solución propuesta anteriormente, la zona de cambio se basa en el valor de |x| + |y|, que está representado por el cuadrado sombreado a continuación. Garantiza que ambas zonas se conecten con gracia.

Además, el código anterior no tiene ramificaciones, lo que podría ser más eficiente. Tenga en cuenta que operaciones como maxy abs, que a priori necesitan ramificaciones, a menudo tienen instrucciones de ensamblaje dedicadas. Por esta razón, creo que este enfoque es superior a otra solución que sería arreglar el problema de Michael nearlyEqualcambiando el interruptor de diff < abs_tha diff < eps * abs_th, lo que produciría esencialmente el mismo patrón de respuesta.

¿Dónde cambiar entre comparación relativa y absoluta?

El cambio entre esos modos se realiza alrededor de abs_th, que se toma como FLT_MINen la respuesta aceptada. Esta elección significa que la representación de float32es lo que limita la precisión de nuestros números de coma flotante.

Esto no siempre tiene sentido. Por ejemplo, si los números que comparas son el resultado de una resta, quizás algo en el rango de FLT_EPSILONtenga más sentido. Si son raíces cuadradas de números restados, la imprecisión numérica podría ser aún mayor.

Es bastante obvio cuando se compara un punto flotante con 0. En este caso, cualquier comparación relativa fracasará, porque |x - 0| / (|x| + 0) = 1. Por lo tanto, la comparación debe cambiar al modo absoluto cuando xsea del orden de la imprecisión de su cálculo, y rara vez es tan baja como FLT_MIN.

Este es el motivo de la introducción del abs_thparámetro anterior.

Además, al no multiplicar abs_thpor epsilon, la interpretación de este parámetro es sencilla y corresponde al nivel de precisión numérica que esperamos de esos números.

Retumbar matemático

(mantenido aquí principalmente para mi propio placer)

De manera más general, supongo que un operador de comparación de punto flotante que se comporta bien =~debería tener algunas propiedades básicas.

Los siguientes son bastante obvios:

• autoigualdad:a =~ a
• simetría: a =~ bimplicab =~ a
• invariancia por oposición: a =~ bimplica-a =~ -b

(No tenemos a =~ be b =~ cimplica a =~ c, =~no es una relación de equivalencia).

Agregaría las siguientes propiedades que son más específicas para las comparaciones de punto flotante

• si a < b < c, entonces a =~ cimplica a =~ b(los valores más cercanos también deberían ser iguales)
• si a, b, m >= 0entonces a =~ bimplica a + m =~ b + m(los valores más grandes con la misma diferencia también deberían ser iguales)
• si 0 <= λ < 1entonces a =~ bimplica λa =~ λb(quizás menos obvio para argumentar a favor).

Esas propiedades ya imponen fuertes restricciones sobre posibles funciones cercanas a la igualdad. La función propuesta anteriormente los verifica. Quizás falten una o varias propiedades que de otro modo serían obvias.

Cuando se piensa en =~una relación de familia de igualdad =~[Ɛ,t]parametrizada por Ɛy abs_th, también se podría agregar

• si Ɛ1 < Ɛ2entonces a =~[Ɛ1,t] bimplica a =~[Ɛ2,t] b(la igualdad para una tolerancia dada implica igualdad en una tolerancia mayor)
• si t1 < t2entonces a =~[Ɛ,t1] bimplica a =~[Ɛ,t2] b(la igualdad para una imprecisión dada implica igualdad en una imprecisión mayor)

La solución propuesta también los verifica.

Sep 01 '2015 14:09 P-Gn