En sevdiğiniz bit bilge tekniği nedir? [kapalı]

Birkaç gün önce StackExchange üyesi Anto bit bilge operatörler için geçerli kullanımları sordu . Kaymanın tamsayıları ikisinin gücü ile çarpmaktan ve bölmekten daha hızlı olduğunu söyledim. StackExchange üyesi Daemin, sağa kaymanın negatif sayılarla ilgili sorunlar sunduğunu belirterek karşılık verdi.

Bu noktada, vardiya operatörlerini işaretli tamsayılarla kullanmayı hiç düşünmemiştim. Öncelikle bu tekniği düşük seviye yazılım geliştirmede kullandım; bu nedenle her zaman işaretsiz tamsayılar kullandım. C, işaretsiz tamsayılarda mantıksal kaymalar gerçekleştirir. Doğru bir mantıksal kaydırma gerçekleştirirken işaret bitine dikkat edilmez. Boşaltılan bitler sıfırlarla doldurulur. Bununla birlikte, C, işaretli bir tamsayı sağını kaydırırken aritmetik bir kaydırma işlemi gerçekleştirir. Boş bitler işaret biti ile doldurulur. Bu fark, negatif bir değerin, sıfıra doğru kısaltılmak yerine sonsuza yuvarlanmasına neden olur; bu, işaretli tam sayı bölümünden farklı bir davranıştır.

Birkaç dakikalık düşünce birinci dereceden bir çözümle sonuçlandı. Çözelti, kaydırmadan önce koşullu olarak negatif değerleri pozitif değerlere dönüştürür. Bir değer, vardiya işlemi gerçekleştirildikten sonra koşullu olarak negatif biçimine dönüştürülür.

int a = -5;
int n = 1;

int negative = q < 0; 

a = negative ? -a : a; 
a >>= n; 
a = negative ? -a : a; 

Bu çözümün sorunu, koşullu atama ifadelerinin genellikle en az bir atlama komutuna çevrilmesidir ve atlama komutları, her iki komut yolunun kodunu çözmeyen işlemcilerde pahalı olabilir. Bir talimat boru hattını iki kez yeniden astarlamak zorunda kalmak, bölme üzerinde kayma ile elde edilen herhangi bir performans kazancında iyi bir çökme sağlar.

Yukarıdakilerle birlikte, Cumartesi günü şartlı görev sorununun cevabı ile uyandım. Bir aritmetik vardiya işlemi gerçekleştirirken yaşadığımız yuvarlama problemi, sadece ikisinin tamamlayıcı gösterimi ile çalışırken ortaya çıkar. Kişinin kompleman temsili ile gerçekleşmez. Sorunun çözümü, vardiya işlemini gerçekleştirmeden önce bir ikinin tamamlayıcı değerini bir kişinin tamamlayıcı değerine dönüştürmeyi içerir. Daha sonra kişinin tamamlayıcı değerini ikinin tamamlayıcı değerine dönüştürmeliyiz. Şaşırtıcı bir şekilde, bu operasyon setini, vardiya işlemini gerçekleştirmeden önce negatif değerleri şartlı olarak dönüştürmeden gerçekleştirebiliriz.

int a = -5;
int n = 1;

register int sign = (a >> INT_SIZE_MINUS_1) & 1

a = (a - sign) >> n + sign;   

İkinin tamamlayıcı negatif değeri, çıkartılarak kişinin tamamlayıcı negatif değerine dönüştürülür. Flip tarafında, bir kişinin kompleman negatif değeri bir ikisini tamamlayarak negatif değerine dönüştürülür. Yukarıda listelenen kod, işaret biti ikisinin tamamlayıcısından tamamlayıcısına dönüştürmek için kullanıldığından işe yarar . Yalnızca negatif değerler işaret bitlerini ayarlayacaktır; bu nedenle, a pozitif olduğunda değişken işareti sıfıra eşit olacaktır .

Yukarıdakilerle birlikte, yukarıdaki hileler gibi hileler çantanıza girmiş gibi düşünebilir misiniz? En sevdiğiniz bit bilge kesmek nedir? Her zaman yeni performans odaklı bit bilge kesmek için arıyorum.

Gosper'in hackini (HAKMEM # 175) seviyorum, bir sayı almanın ve aynı sayıda bitle bir sonraki sayıyı almanın çok kurnaz bir yolu. Örneğin, bu şekilde kürün kombinasyonları oluştururken faydalıdır n:

int set = (1 << k) - 1;
int limit = (1 << n);
while (set < limit) {
    doStuff(set);

    // Gosper's hack:
    int c = set & -set;
    int r = set + c;
    set = (((r^set) >>> 2) / c) | r;
}

Hızlı ters kare kök yöntemi şimdiye kadar gördüğüm bir kare kökü tersini hesaplamak için en tuhaf bit düzeyinde teknikleri kullanır:

float Q_rsqrt( float number )
{
    long i;
    float x2, y;
    const float threehalfs = 1.5F;

    x2 = number * 0.5F;
    y  = number;
    i  = * ( long * ) &y;                       // evil floating point bit level hacking [sic]
    i  = 0x5f3759df - ( i >> 1 );               // what the fuck? [sic]
    y  = * ( float * ) &i;
    y  = y * ( threehalfs - ( x2 * y * y ) );   // 1st iteration
    //    y  = y * ( threehalfs - ( x2 * y * y ) );   // 2nd iteration, this can be removed

    return y;
}

3'e bölün - çalışma zamanı kütüphane çağrısına başvurmadan.

3'e bölünmenin (Yığın Taşması ile ilgili bir ipucu sayesinde) şu şekilde tahmin edilebilir:

X / 3 = [(x / 4) + (x / 12)]

Ve X / 12 (x / 4) / 3'tür. Burada aniden ortaya çıkan bir tekrarlama unsuru vardır.

Ayrıca, oynadığınız sayıların aralığını sınırlarsanız, gerekli yineleme sayısını sınırlandırabileceğiniz de ortaya çıkar.

Ve böylece, 2000'den küçük işaretsiz tamsayılar için aşağıdakiler hızlı ve basit bir / 3 algoritmasıdır. (Daha büyük sayılar için daha fazla adım eklemeniz yeterlidir). Derleyiciler, halkı bundan optimize eder, böylece hızlı ve küçük olurlar:

statik imzasız kısa FastDivide3 (const imzasız kısa arg)
{
  imzasız kısa RunningSum;
  imzasız kısa Fraksiyonel Twelth;

  RunningSum = arg >> 2;

  FractionalTwelth = RunningSum >> 2;
  RunningSum + = FractionalTwelth;

  Kesirliİki >> >> 2;
  RunningSum + = FractionalTwelth;

  Kesirliİki >> >> 2;
  RunningSum + = FractionalTwelth;

  Kesirliİki >> >> 2;
  RunningSum + = FractionalTwelth;

  // Daha fazla hassasiyet için yukarıdaki 2 satırın daha fazla tekrarı

  RunningSum'a dönüş;
}

Erlang'a bakarsanız, bit işlemleri yapmak için tüm bir DSL var. Yani böyle bir şey söyleyerek bir veri yapısını bitlerle ayırabilirsiniz:

<> = << 1,17,42: 16 >>.

Tüm ayrıntılar burada: http://www.erlang.org/doc/reference_manual/expressions.html#id75782