Floating-Point Objects
**********************

type PyFloatObject

   This subtype of "PyObject" represents a Python floating-point
   object.

PyTypeObject PyFloat_Type
    * Part of the Stable ABI.*

   This instance of "PyTypeObject" represents the Python floating-
   point type.  This is the same object as "float" in the Python
   layer.

int PyFloat_Check(PyObject *p)

   Retorna verdadero si su argumento es un "PyFloatObject" o un
   subtipo de "PyFloatObject". Esta función siempre finaliza con
   éxito.

int PyFloat_CheckExact(PyObject *p)

   Retorna verdadero si su argumento es un "PyFloatObject", pero no un
   subtipo de "PyFloatObject". Esta función siempre finaliza con
   éxito.

PyObject *PyFloat_FromString(PyObject *str)
    *Return value: New reference.** Part of the Stable ABI.*

   Crea un objeto "PyFloatObject" basado en la cadena de caracteres en
   *str*, o "NULL" en caso de error.

PyObject *PyFloat_FromDouble(double v)
    *Return value: New reference.** Part of the Stable ABI.*

   Crea un objeto "PyFloatObject" a partir de *v*, o "NULL" en caso de
   error.

double PyFloat_AsDouble(PyObject *pyfloat)
    * Part of the Stable ABI.*

   Return a C double representation of the contents of *pyfloat*.  If
   *pyfloat* is not a Python floating-point object but has a
   "__float__()" method, this method will first be called to convert
   *pyfloat* into a float. If "__float__()" is not defined then it
   falls back to "__index__()". This method returns "-1.0" upon
   failure, so one should call "PyErr_Occurred()" to check for errors.

   Distinto en la versión 3.8: Utilice "__index__()" si está
   disponible.

double PyFloat_AS_DOUBLE(PyObject *pyfloat)

   Retorna una representación C double de los contenidos de *pyfloat*,
   pero sin verificación de errores.

PyObject *PyFloat_GetInfo(void)
    *Return value: New reference.** Part of the Stable ABI.*

   Retorna una instancia de *structseq* que contiene información sobre
   la precisión, los valores mínimos y máximos de un flotante. Es un
   contenedor reducido alrededor del archivo de encabezado "float.h".

double PyFloat_GetMax()
    * Part of the Stable ABI.*

   Retorna el máximo flotante finito representable *DBL_MAX* como C
   double.

double PyFloat_GetMin()
    * Part of the Stable ABI.*

   Retorna el flotante positivo normalizado mínimo *DBL_MIN* como C
   double.

Py_INFINITY

   This macro expands a to constant expression of type double, that
   represents the positive infinity.

   On most platforms, this is equivalent to the "INFINITY" macro from
   the C11 standard "<math.h>" header.

Py_NAN

   This macro expands a to constant expression of type double, that
   represents a quiet not-a-number (qNaN) value.

   On most platforms, this is equivalent to the "NAN" macro from the
   C11 standard "<math.h>" header.

Py_HUGE_VAL

   Equivalent to "INFINITY".

   Obsoleto desde la versión 3.14: The macro is *soft deprecated*.

Py_MATH_E

   The definition (accurate for a double type) of the "math.e"
   constant.

Py_MATH_El

   High precision (long double) definition of "e" constant.

Py_MATH_PI

   The definition (accurate for a double type) of the "math.pi"
   constant.

Py_MATH_PIl

   High precision (long double) definition of "pi" constant.

Py_MATH_TAU

   The definition (accurate for a double type) of the "math.tau"
   constant.

   Added in version 3.6.

Py_RETURN_NAN

   Return "math.nan" from a function.

   On most platforms, this is equivalent to "return
   PyFloat_FromDouble(NAN)".

Py_RETURN_INF(sign)

   Return "math.inf" or "-math.inf" from a function, depending on the
   sign of *sign*.

   On most platforms, this is equivalent to the following:

      return PyFloat_FromDouble(copysign(INFINITY, sign));

Py_IS_FINITE(X)

   Return "1" if the given floating-point number *X* is finite, that
   is, it is normal, subnormal or zero, but not infinite or NaN.
   Return "0" otherwise.

   Obsoleto desde la versión 3.14: The macro is *soft deprecated*.
   Use "isfinite" instead.

Py_IS_INFINITY(X)

   Return "1" if the given floating-point number *X* is positive or
   negative infinity.  Return "0" otherwise.

   Obsoleto desde la versión 3.14: The macro is *soft deprecated*.
   Use "isinf" instead.

Py_IS_NAN(X)

   Return "1" if the given floating-point number *X* is a not-a-number
   (NaN) value.  Return "0" otherwise.

   Obsoleto desde la versión 3.14: The macro is *soft deprecated*.
   Use "isnan" instead.


Funciones de empaquetado y desempaquetado
=========================================

Las funciones de empaquetar y desempaquetar proporcionan una manera
eficiente e independiente de la plataforma para almacenar valores de
coma flotante como cadenas de bytes. Las rutinas Pack producen una
cadena de bytes a partir de un C double, y las rutinas Desempaquetar
producen un C double a partir de dicha cadena de bytes. El sufijo (2,
4 u 8) especifica el número de bytes en la cadena de bytes.

En plataformas que parecen usar formatos IEEE 754, estas funciones
actúan copiando los bits. En otras plataformas, el formato 2-byte es
idéntico al formato de media precision IEEE 754 binary16, el formato
de 4-byte (32 bits) es idéntico al formato de precisión simple binario
IEEE 754 binary32, y el formato de 8-byte al formato de doble
precisión binario IEEE 754 binary64, aunque el empaquetado de INFs y
NaNs (si existen en la plataforma) no se maneja correctamente,
mientras que intentar desempaquetar una cadena de bytes que contenga
un IEEE INF o NaN generará una excepción.

En plataformas que no son IEEE con más precisión, o mayor rango
dinámico, que el IEEE 754 admite, no se pueden empaquetar todos los
valores; en plataformas que no son IEEE con menos precisión o con un
rango dinámico más pequeño, no se pueden desempaquetar todos los
valores. Lo que sucede en tales casos es en parte accidental
(desafortunadamente).

Added in version 3.11.


Funciones de Empaquetado
------------------------

Las rutinas de empaquetado escriben 2, 4 o 8 bytes, comenzando en *p*.
*le* es un argumento int, distinto de cero si desea que la cadena de
bytes esté en formato little-endian (exponente al final, en "p+1",
"p+3", o "p+6" "p+7"), y cero si desea el formato big-endian
(exponente primero, en *p*). La constante "PY_BIG_ENDIAN" se puede
usar para emplear el endian nativo: es igual a "1" en el procesador
big-endian, o "0" en el procesador little-endian.

Valor retornado: "0" si todo está bien, "-1" si hay error (y se
establece una excepción, probablemente "OverflowError").

Hay dos problemas en plataformas que no son IEEE:

* Lo que esto hace es indefinido si *x* es un NaN o infinito.

* "-0.0" and "+0.0" produce la misma cadena de bytes.

int PyFloat_Pack2(double x, char *p, int le)

   Empaquete un C doble como el formato de media precisión IEEE 754
   binary16.

int PyFloat_Pack4(double x, char *p, int le)

   Empaque un C doble como el formato de precisión simple IEEE 754
   binary32.

int PyFloat_Pack8(double x, char *p, int le)

   Empaque un C doble como el formato de doble precisión IEEE 754
   binary64.


Funciones de Desempaquetado
---------------------------

Las rutinas de desempaquetado leen 2, 4 u 8 bytes, comenzando en *p*.
*le* es un argumento int , distinto de cero si la cadena bytes está en
formato little-endian (exponente al final, en "p+1", "p+3" o "p+6" y
"p+7"), cero si está en formato big-endian (exponente primero, en
*p*). La constante "PY_BIG_ENDIAN" se puede usar para utilizar el
endian nativo: es igual a "1" en un procesador big endian, o "0" en un
procesador little-endian.

Valor retornado: Doble desempaquetado. Si hay error, "-1.0" y
"PyErr_Occurred()" es verdadero (y se establece una excepción,
probablemente "OverflowError").

Hay que tener en cuenta que en una plataforma que no sea IEEE, esto se
negará a desempaquetar una cadena de bytes que representa un NaN o
infinito.

double PyFloat_Unpack2(const char *p, int le)

   Descomprima el formato de media precisión IEEE 754 binary16 como un
   doble C.

double PyFloat_Unpack4(const char *p, int le)

   Descomprima el formato de precisión simple IEEE 754 binary32 como
   un doble C.

double PyFloat_Unpack8(const char *p, int le)

   Descomprima el formato de doble precisión IEEE 754 binary64 como un
   doble C.
