Un comentario en el código fuente de Python para objetos flotantes reconoce que:
La comparación es casi una pesadilla
Esto es especialmente cierto cuando se compara un flotante con un entero, porque, a diferencia de los flotantes, los enteros en Python pueden ser arbitrariamente grandes y siempre son exactos. Intentar convertir el entero en un flotador puede perder precisión y hacer que la comparación sea inexacta. Intentar lanzar el flotador a un número entero tampoco funcionará porque se perderá cualquier parte fraccional.
Para solucionar este problema, Python realiza una serie de comprobaciones, devolviendo el resultado si una de las comprobaciones tiene éxito. Compara los signos de los dos valores, luego si el número entero es "demasiado grande" para ser un flotante, luego compara el exponente del flotante con la longitud del entero. Si todas estas comprobaciones fallan, es necesario construir dos nuevos objetos de Python para comparar para obtener el resultado.
Al comparar un flotante vcon un entero / largo w, el peor de los casos es que:
vy wtienen el mismo signo (tanto positivo como negativo),- el entero
wtiene pocos bits suficientes para que pueda mantenerse en el size_ttipo (generalmente 32 o 64 bits),
- el entero
wtiene al menos 49 bits,
- el exponente del flotador
ves igual al número de bits en w.
Y esto es exactamente lo que tenemos para los valores en la pregunta:
>>> import math
>>> math.frexp(562949953420000.7) # gives the float's (significand, exponent) pair
(0.9999999999976706, 49)
>>> (562949953421000).bit_length()
49
Vemos que 49 es tanto el exponente del flotante como el número de bits en el entero. Ambos números son positivos, por lo que se cumplen los cuatro criterios anteriores.
Elegir uno de los valores para que sea más grande (o más pequeño) puede cambiar el número de bits del número entero o el valor del exponente, por lo que Python puede determinar el resultado de la comparación sin realizar la costosa verificación final.
Esto es específico para la implementación de CPython del lenguaje.
La comparación con más detalle.
La float_richcomparefunción maneja la comparación entre dos valores vy w.
A continuación se muestra una descripción paso a paso de las comprobaciones que realiza la función. Los comentarios en la fuente de Python son realmente muy útiles cuando se trata de entender lo que hace la función, por lo que los dejé en su lugar. También resumí estos controles en una lista al pie de la respuesta.
La idea principal es mapear los objetos de Python vy wdos dobles C apropiados, iy jque luego se pueden comparar fácilmente para obtener el resultado correcto. Tanto Python 2 como Python 3 usan las mismas ideas para hacer esto (el primero solo maneja inty longescribe por separado).
Lo primero que debe hacer es comprobar que ves sin duda un flotador Python y asignarla a una doble C i. A continuación, las miradas de función en si wes también un flotador y lo asigna a una doble C j. Este es el mejor de los casos para la función, ya que se pueden omitir todas las demás comprobaciones. La función también verifica si ves info nan:
static PyObject*
float_richcompare(PyObject *v, PyObject *w, int op)
{
double i, j;
int r = 0;
assert(PyFloat_Check(v));
i = PyFloat_AS_DOUBLE(v);
if (PyFloat_Check(w))
j = PyFloat_AS_DOUBLE(w);
else if (!Py_IS_FINITE(i)) {
if (PyLong_Check(w))
j = 0.0;
else
goto Unimplemented;
}
Ahora sabemos que si wfallaron estas comprobaciones, no es un flotador de Python. Ahora la función comprueba si es un entero de Python. Si este es el caso, la prueba más fácil es extraer el signo vy el signo de w(devolver 0si es cero, -1si es negativo, 1si es positivo). Si los signos son diferentes, esta es toda la información necesaria para devolver el resultado de la comparación:
else if (PyLong_Check(w)) {
int vsign = i == 0.0 ? 0 : i < 0.0 ? -1 : 1;
int wsign = _PyLong_Sign(w);
size_t nbits;
int exponent;
if (vsign != wsign) {
/* Magnitudes are irrelevant -- the signs alone
* determine the outcome.
*/
i = (double)vsign;
j = (double)wsign;
goto Compare;
}
}
Si esta verificación falló, entonces vy wtenga el mismo signo.
La siguiente verificación cuenta el número de bits en el entero w. Si tiene demasiados bits, no es posible mantenerlo como flotante y, por lo tanto, debe ser de mayor magnitud que el flotante v:
nbits = _PyLong_NumBits(w);
if (nbits == (size_t)-1 && PyErr_Occurred()) {
/* This long is so large that size_t isn't big enough
* to hold the # of bits. Replace with little doubles
* that give the same outcome -- w is so large that
* its magnitude must exceed the magnitude of any
* finite float.
*/
PyErr_Clear();
i = (double)vsign;
assert(wsign != 0);
j = wsign * 2.0;
goto Compare;
}
Por otro lado, si el entero wtiene 48 bits o menos, puede convertir C doble de forma segura jy comparar:
if (nbits <= 48) {
j = PyLong_AsDouble(w);
/* It's impossible that <= 48 bits overflowed. */
assert(j != -1.0 || ! PyErr_Occurred());
goto Compare;
}
A partir de este momento, sabemos que wtiene 49 o más bits. Será conveniente tratarlo wcomo un entero positivo, así que cambie el signo y el operador de comparación según sea necesario:
if (nbits <= 48) {
/* "Multiply both sides" by -1; this also swaps the
* comparator.
*/
i = -i;
op = _Py_SwappedOp[op];
}
Ahora la función mira el exponente del flotador. Recuerde que se puede escribir un flotador (ignorando el signo) como exponente significand * 2 y que el significand representa un número entre 0.5 y 1:
(void) frexp(i, &exponent);
if (exponent < 0 || (size_t)exponent < nbits) {
i = 1.0;
j = 2.0;
goto Compare;
}
Esto verifica dos cosas. Si el exponente es menor que 0, el flotador es menor que 1 (y por lo tanto, de menor magnitud que cualquier número entero). O, si el exponente es menor que el número de bits, wentonces tenemos eso, v < |w|ya que el exponente significativo * 2 es menor que 2 nbits .
Al fallar estas dos comprobaciones, la función busca ver si el exponente es mayor que el número de bits w. Esto muestra que significante * 2 exponente es mayor que 2 nbits y así v > |w|:
if ((size_t)exponent > nbits) {
i = 2.0;
j = 1.0;
goto Compare;
}
Si esta comprobación no tuvo éxito, sabemos que el exponente del flotante ves el mismo que el número de bits en el entero w.
La única forma de comparar los dos valores ahora es construir dos nuevos enteros de Python a partir de vy w. La idea es descartar la parte fraccional de v, duplicar la parte entera y luego agregar una. wtambién se duplica y estos dos nuevos objetos de Python se pueden comparar para obtener el valor de retorno correcto. El uso de un ejemplo con valores pequeños 4.65 < 4se determinaría mediante la comparación (2*4)+1 == 9 < 8 == (2*4)(que devuelve falso).
{
double fracpart;
double intpart;
PyObject *result = NULL;
PyObject *one = NULL;
PyObject *vv = NULL;
PyObject *ww = w;
// snip
fracpart = modf(i, &intpart); // split i (the double that v mapped to)
vv = PyLong_FromDouble(intpart);
// snip
if (fracpart != 0.0) {
/* Shift left, and or a 1 bit into vv
* to represent the lost fraction.
*/
PyObject *temp;
one = PyLong_FromLong(1);
temp = PyNumber_Lshift(ww, one); // left-shift doubles an integer
ww = temp;
temp = PyNumber_Lshift(vv, one);
vv = temp;
temp = PyNumber_Or(vv, one); // a doubled integer is even, so this adds 1
vv = temp;
}
// snip
}
}
Por brevedad, he omitido la comprobación adicional de errores y el seguimiento de basura que Python tiene que hacer cuando crea estos nuevos objetos. No es necesario decir que esto agrega una sobrecarga adicional y explica por qué los valores resaltados en la pregunta son significativamente más lentos para comparar que otros.
Aquí hay un resumen de las comprobaciones que realiza la función de comparación.
Deja que vsea un flotador y échalo como un doble C. Ahora, si wtambién es un flotador:
Comprueba si wes nano inf. Si es así, maneje este caso especial por separado dependiendo del tipo de w.
Si no es así, compare vy wdirectamente por sus representaciones como C dobles.
Si wes un entero:
Extraer los signos de vy w. Si son diferentes, entonces sabemos vy wson diferentes y cuál es el mayor valor.
( Los signos son los mismos ) . Verifique si wtiene demasiados bits para ser flotante (más de size_t). Si es así, wtiene mayor magnitud que v.
Compruebe si wtiene 48 o menos bits. Si es así, puede lanzarse con seguridad a un doble C sin perder su precisión y compararlo v.
( wtiene más de 48 bits. Ahora trataremos wcomo un entero positivo después de haber cambiado la operación de comparación según corresponda ) .
Considere el exponente de la carroza v. Si el exponente es negativo, entonces ves menor 1y, por lo tanto, menor que cualquier número entero positivo. De lo contrario, si el exponente es menor que el número de bits, wentonces debe ser menor que w.
Si el exponente de ves mayor que el número de bits, wentonces ves mayor que w.
( El exponente es el mismo que el número de bitsw ) .
El cheque final. Dividir ven sus partes enteras y fraccionarias. Duplique la parte entera y agregue 1 para compensar la parte fraccionaria. Ahora dobla el número entero w. Compare estos dos enteros nuevos para obtener el resultado.