Bir ikiliyi 32 bit int'e yuvarlamanın hızlı bir yöntemi açıklandı

Lua'nın kaynak kodunu okurken, Lua'nın a'yı 32-bit'e macroyuvarlamak için kullandığını fark ettim . Çıkardım ve şöyle görünüyor:doubleintmacro

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];}

İşte ENDIANLOColarak tanımlanır endian , 0küçük endian için 1büyük endian için. Lua endiyansı dikkatle ele alır. veya tgibi bir tamsayı türü anlamına gelir .intunsigned int

Biraz araştırma yaptım macrove aynı düşünceyi kullanan daha basit bir format var :

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

Veya bir C ++ stilinde:

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

Bu hile IEEE 754 kullanan herhangi bir makinede çalışabilir (bu hemen hemen her makine anlamına gelir). Hem pozitif hem de negatif sayılar için çalışır ve yuvarlama Bankanın Kuralını takip eder . (Bu şaşırtıcı değildir, çünkü IEEE 754'ü takip eder.)

Test etmek için küçük bir program yazdım:

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

Beklendiği gibi -12345679 çıktı.

Bu zorluğun nasıl işlediğini ayrıntılı olarak anlatmak istiyorum macro. Sihirli sayı 6755399441055744.0aslında 2^51 + 2^52ya 1.5 * 2^52, ve 1.5ikili olarak temsil edilebilir 1.1. Bu sihirli sayıya herhangi bir 32-bit tam sayı eklendiğinde, buradan kayboldum. Bu hile nasıl çalışır?

Not: Bu Lua kaynak kodunda, Llimits.h .

GÜNCELLEME :

1. @Mysticial'ın işaret ettiği gibi, bu yöntem kendini 32 bit ile sınırlamaz , sayı 2 ^ 52 aralığında olduğu sürece int64 bit'e de genişletilebilir int. ( macroBazı değişikliklere ihtiyaç var.)
2. Bazı malzemeler bu yöntemin Direct3D'de kullanılamayacağını söylüyor .

3. X86 için Microsoft birleştirici ile çalışırken, daha da hızlı macroyazılmış assembly(bu da Lua kaynağından çıkarılır):

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

4. Tek bir hassas sayı için benzer bir sihirli sayı var: 1.5 * 2 ^23

A doubleşöyle temsil edilir:

ve iki adet 32-bit tamsayı olarak görülebilir; şimdi, intkodunuzun tüm sürümlerinde (32 bit olduğunu varsayarak int) alınan, şeklin sağındaki koddur , bu yüzden sonunda yaptığınız şey en düşük 32 bit mantis almaktır.

Şimdi, sihirli sayıya; doğru şekilde belirttiğiniz gibi, 6755399441055744 2 ^ 51 + 2 ^ 52; böyle bir sayı eklemek double, burada Wikipedia tarafından açıklandığı gibi ilginç bir özelliğe sahip olan 2 ^ 52 ve 2 ^ 53 arasındaki "tatlı aralığa" girmeye zorlar :

2 ⁵² = 4.503.599.627.370.496 ve 2 ⁵³ = 9.007.199.254.740.992 arasında temsili sayılar tamsayıdır

Bu, mantisin 52 bit genişliğinden kaynaklanmaktadır.

2 ⁵¹ +2 ⁵² eklemeyle ilgili diğer ilginç gerçek , sadece en düşük 32 biti aldığımız için mantissa'yı sadece en yüksek iki bitte etkilemesidir.

Son fakat en az değil: işaret.

IEEE 754 kayan nokta bir büyüklük ve işaret temsilini kullanırken, "normal" makinelerdeki tamsayılar 2'nin tamamlayıcı aritmetiğini kullanır; bu nasıl halledilir?

Sadece pozitif tamsayılardan bahsettik; şimdi 32-bit ile temsil edilebilen aralıkta negatif bir sayı ile uğraştığımızı varsayalım int(mutlak değerde) (-2 ^ 31 + 1); ara -a. Böyle bir sayı, sihirli sayı eklenerek açıkça pozitif hale getirilir ve elde edilen değer 2 ⁵² +2 ^51'dir. + (- a) olur.

Şimdi, mantis'i 2'nin tamamlayıcı temsilinde yorumlarsak ne elde ederiz? Bu, 2'nin (2 ⁵² +2 ⁵¹ ) ve (-a) tamamlayıcı sonucunun bir sonucu olmalıdır . Yine, ilk terim sadece üst iki biti etkiler, 0 ~ 50 bitlerinde kalan, 2'nin (-a) 'nın tamamlayıcı temsilidir (yine ek iki üst bit).

Bir 2'nin tamamlayıcı sayısının daha küçük bir genişliğe indirgenmesi sadece soldaki ekstra bitlerin kesilmesiyle yapıldığından, alt 32 bitin alınması 32 bit, 2'nin tamamlayıcı aritmetiğini doğru bir şekilde (-a) verir.