Objetos de ponto flutuante

type PyFloatObject

Este subtipo de PyObject representa um objeto de ponto flutuante do Python.

PyTypeObject PyFloat_Type

Parte da ABI Estável.

Esta instância do PyTypeObject representa o tipo de ponto flutuante do Python. Este é o mesmo objeto float na camada do Python.

int PyFloat_Check(PyObject *p)

Retorna true se seu argumento é um PyFloatObject ou um subtipo de PyFloatObject. Esta função sempre tem sucesso.

int PyFloat_CheckExact(PyObject *p)

Retorna true se seu argumento é um PyFloatObject, mas um subtipo de PyFloatObject. Esta função sempre tem sucesso.

PyObject *PyFloat_FromString(PyObject *str)

Retorna valor: Nova referência. Parte da ABI Estável.

Cria um objeto PyFloatObject baseado em uma string de valor “str” ou NULL em falha.

PyObject *PyFloat_FromDouble(double v)

Retorna valor: Nova referência. Parte da ABI Estável.

Cria um objeto PyFloatObject de v ou NULL em falha.

double PyFloat_AsDouble(PyObject *pyfloat)

Parte da ABI Estável.

Retorna uma representação C double do conteúdo de pyfloat. Se pyfloat não é um objeto de ponto flutuante do Python, mas possui o método __float__(), esse método será chamado primeiro para converter pyfloat em um ponto flutuante. Se __float__() não estiver definido, será usado __index__(). Este método retorna -1.0 em caso de falha, portanto, deve-se chamar PyErr_Occurred() para verificar se há erros.

Alterado na versão 3.8: Usa __index__(), se disponível.

double PyFloat_AS_DOUBLE(PyObject *pyfloat)

Retorna uma representação C double do conteúdo de pyfloat, mas sem verificação de erro.

PyObject *PyFloat_GetInfo(void)

Retorna valor: Nova referência. Parte da ABI Estável.

Retorna uma instância de structseq que contém informações sobre a precisão, os valores mínimo e máximo de um ponto flutuante. É um invólucro fino em torno do arquivo de cabeçalho float.h.

double PyFloat_GetMax()

Parte da ABI Estável.

Retorna o ponto flutuante finito máximo representável DBL_MAX como double do C.

double PyFloat_GetMin()

Parte da ABI Estável.

Retorna o ponto flutuante positivo mínimo normalizado DBL_MIN como double do C.

As funções Pack e Unpack

As funções de empacotamento e desempacotamento, pack e unpack respectivamente, fornecem uma maneira eficiente e independente de plataforma de armazenar valores de ponto flutuante como strings de bytes. As rotinas de Pack produzem uma string de bytes a partir de um C double, e as rotinas de Unpack produzem um C double a partir dessa string de bytes. O sufixo (2, 4 ou 8) especifica o número de bytes na string de bytes.

Em plataformas que parecem usar o formato IEEE 754, essas funções funcionam copiando bits. Em outras plataformas, o formato de 2 bytes é idêntico ao formato de meia precisão binário 16 do IEEE 754, o formato de 4 bytes (32 bits) é idêntico ao formato de precisão simples binário 32 do IEEE 754 e o formato de 8 bytes ao formato de precisão dupla binário 64 do IEEE 754, embora o empacotamento de INFs e NaNs (se tais recursos existirem na plataforma) não seja tratado corretamente, e tentar desempacotar uma string de bytes contendo um INF ou NaN do IEEE levantará uma exceção.

Observe que o tipo NaNs pode não ser preservado em plataformas IEEE (NaN silenciosos tornam-se silenciosos), por exemplo, em sistemas x86 no modo de 32 bits.

Em plataformas que não aderem IEEE com maior precisão ou maior alcance dinâmico do que o suportado pelo IEEE 754, nem todos os valores podem ser empacotados; em plataformas que não aderem IEEE com menor precisão ou menor alcance dinâmico, nem todos os valores podem ser desempacotados. O que acontece nesses casos é em parte acidental (infelizmente).

Adicionado na versão 3.11.

Funções Pack

As rotinas de empacotamento gravam 2, 4 ou 8 bytes, começando em p. le é um argumento int, diferente de zero se você quiser a sequência de bytes no formato little-endian (expoente por último, em p+1, p+3 ou p+6 p+7), zero se você quiser o formato big-endian (expoente primeiro, em p). A constante PY_BIG_ENDIAN pode ser usada para usar o endian nativo: é igual a 1 em processadores big-endian ou 0 em processadores little-endian.

Valor de retorno: 0 se tudo estiver OK, -1 se houver erro (e uma exceção for definida, provavelmente OverflowError).

Existem dois problemas em plataformas não IEEE:

• O que isso faz é indefinido se x é um NaN ou infinito.

• -0.0 e +0.0 produzem a mesma sequência de bytes.

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

Pack a C double as the IEEE 754 binary16 half-precision format.

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

Pack a C double as the IEEE 754 binary32 single precision format.

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

Pack a C double as the IEEE 754 binary64 double precision format.

Funções de Unpack

As rotinas de desempacotamento leem 2, 4 ou 8 bytes, começando em p. le é um argumento int, diferente de zero se a sequência de bytes estiver no formato little-endian (expoente por último, em p+1, p+3 ou p+6 e p+7), zero se big-endian (expoente primeiro, em p). A constante PY_BIG_ENDIAN pode ser usada para usar o endian nativo: é igual a 1 em processadores big-endian ou 0 em processadores little-endian.

Valor de retorno: O double descompactado. Em caso de erro, é -1.0 e PyErr_Occurred() é verdadeiro (e uma exceção é definida, provavelmente OverflowError).

Observe que em uma plataforma que não adere IEEE isso se recusará a descompactar uma sequência de bytes que representa um NaN ou infinito.

double PyFloat_Unpack2(const char *p, int le)

Unpack the IEEE 754 binary16 half-precision format as a C double.

double PyFloat_Unpack4(const char *p, int le)

Unpack the IEEE 754 binary32 single precision format as a C double.

double PyFloat_Unpack8(const char *p, int le)

Unpack the IEEE 754 binary64 double precision format as a C double.