Um método rápido para arredondar um duplo para um int de 32 bits explicado

Ao ler o código-fonte de Lua , notei que Lua usa a macropara arredondar de a doublepara 32 bits int. Eu extraí o macro, e fica assim:

union i_cast {double d; int i[2]};
#define double2int(i, d, t)  \
    {volatile union i_cast u; u.d = (d) + 6755399441055744.0; \
    (i) = (t)u.i[ENDIANLOC];}

Aqui ENDIANLOCé definido como endianness , 0para little endian, 1para big endian. Lua lida com cuidado com endianness. tsignifica o tipo inteiro, como intou unsigned int.

Eu fiz uma pequena pesquisa e há um formato mais simples macroque usa o mesmo pensamento:

#define double2int(i, d) \
    {double t = ((d) + 6755399441055744.0); i = *((int *)(&t));}

Ou no estilo C ++:

inline int double2int(double d)
{
    d += 6755399441055744.0;
    return reinterpret_cast<int&>(d);
}

Esse truque pode funcionar em qualquer máquina usando o IEEE 754 (o que significa praticamente todas as máquinas atualmente). Funciona para números positivos e negativos, e o arredondamento segue a regra do banqueiro . (Isso não é surpreendente, pois segue a IEEE 754.)

Eu escrevi um pequeno programa para testá-lo:

int main()
{
    double d = -12345678.9;
    int i;
    double2int(i, d)
    printf("%d\n", i);
    return 0;
}

E gera -12345679, conforme o esperado.

Gostaria de entrar em detalhes como isso macrofunciona. O número mágico 6755399441055744.0é realmente 2^51 + 2^52, ou 1.5 * 2^52, e 1.5em binário pode ser representado como 1.1. Quando qualquer número inteiro de 32 bits é adicionado a esse número mágico, perdi-me daqui. Como esse truque funciona?

PS: Isso está no código fonte de Lua, Llimits.h .

ATUALIZAÇÃO :

1. Como o @Mysticial aponta, esse método não se limita a 32 bits int, também pode ser expandido para 64 bits intdesde que o número esteja no intervalo de 2 ^ 52. (O macroprecisa de alguma modificação.)
2. Alguns materiais dizem que esse método não pode ser usado no Direct3D .

3. Ao trabalhar com o assembler da Microsoft para x86, há uma macroescrita ainda mais rápida assembly(isso também é extraído da fonte Lua):

   #define double2int(i,n)  __asm {__asm fld n   __asm fistp i}

4. Existe um número mágico semelhante para um número de precisão único: 1.5 * 2 ^23

A doubleé representado assim:

e pode ser visto como dois números inteiros de 32 bits; agora, a intversão tirada em todas as versões do seu código (supondo que seja um de 32 bits int) é a da direita na figura; portanto, o que você está fazendo no final é apenas pegar os 32 bits mais baixos de mantissa.

Agora, para o número mágico; como você afirmou corretamente, 6755399441055744 é 2 ^ 51 + 2 ^ 52; adicionar um número desse tipo obriga a doubleentrar no "intervalo ideal" entre 2 ^ 52 e 2 ^ 53, que, conforme explicado pela Wikipedia aqui , possui uma propriedade interessante:

Entre 2 ⁵² = 4.503.599.627.370.496 e 2 ⁵³ = 9.007.199.254.740.992, os números representáveis ​​são exatamente os números inteiros

Isto decorre do fato de a mantissa ter 52 bits de largura.

O outro fato interessante sobre a adição de 2 ⁵¹ +2 ⁵² é que ele afeta a mantissa somente nos dois bits mais altos - que são descartados de qualquer maneira, pois estamos usando apenas os 32 bits mais baixos.

Por último, mas não menos importante: o sinal.

O ponto flutuante IEEE 754 usa uma representação de magnitude e sinal, enquanto números inteiros em máquinas "normais" usam aritmética do complemento 2; como isso é tratado aqui?

Nós conversamos apenas sobre números inteiros positivos; Agora, suponha que estamos lidando com um número negativo no intervalo representável por 32 bits int; portanto, menor (em valor absoluto) que (-2 ^ 31 + 1); chame -a. Obviamente, esse número é tornado positivo adicionando o número mágico e o valor resultante é 2 ⁵² +2 ⁵¹ + (- a).

Agora, o que obtemos se interpretarmos a mantissa na representação do complemento de 2? Deve ser o resultado da soma do complemento de 2 de (2 ⁵² +2 ⁵¹ ) e (-a). Novamente, o primeiro termo afeta apenas os dois bits superiores, o que permanece nos bits 0 ~ 50 é a representação do complemento do 2 de (-a) (novamente, menos os dois bits superiores).

Como a redução do número do complemento de 2 para uma largura menor é feita apenas cortando os bits extras à esquerda, obter os 32 bits mais baixos nos fornece corretamente (-a) em 32 bits, a aritmética do complemento de 2.