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.


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.

Note that NaNs type may not be preserved on IEEE platforms (silent NaN
become quiet), for example on x86 systems in 32-bit mode.

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.
