Bu rasgele değerin neden 50/50 yerine 25/75 dağılımı var?

Düzenleme: Yani temelde ne yazmaya çalışıyorum için 1 bitlik bir karma olduğunu double.

Bir eşlemek istediğiniz doublekadar trueveya false50/50 şansı. Bunun için bazı rasgele sayılar alır kod yazdım (ben 50/50 sonuç almak yine normal tabloya veriler üzerinde kullanmak istediğiniz sadece bir örnek olarak) , çekler, son bit ve artışlarla yo 1, ya da eğer no takdirde 0.

Ancak, bu kod sürekli olarak% 25 yve% 75 ile sonuçlanır n. Neden 50/50 değil? Ve neden bu kadar garip ama düz (1/3) dağıtım?

public class DoubleToBoolean {
    @Test
    public void test() {

        int y = 0;
        int n = 0;
        Random r = new Random();
        for (int i = 0; i < 1000000; i++) {
            double randomValue = r.nextDouble();
            long lastBit = Double.doubleToLongBits(randomValue) & 1;
            if (lastBit == 1) {
                y++;
            } else {
                n++;
            }
        }
        System.out.println(y + " " + n);
    }
}

Örnek çıktı:

250167 749833

Çünkü nextDouble şu şekilde çalışır: ( kaynak )

public double nextDouble()
{
    return (((long) next(26) << 27) + next(27)) / (double) (1L << 53);
}

next(x)xrastgele bitler yapar .

Şimdi bu neden önemli? Çünkü birinci bölüm (bölümden önce) tarafından üretilen sayıların yaklaşık yarısı daha küçüktür 1L << 52ve bu nedenle bunların önemi, doldurabileceği 53 biti tamamen doldurmaz, yani anlamlılığın en az önemli biti her zaman sıfırdır.

Bu dikkatin yoğunluğu nedeniyle, doubleJava'daki a'nın (ve diğer birçok dilin) ​​gerçekten nasıl göründüğüne ve bu soruda neden önemli olduğuna dair bazı ekstra açıklamalar .

Temel olarak, doubleşuna benzer: ( kaynak )

Bu resimde görülmeyen çok önemli bir detay, sayıların "normalize edilmiş" ¹ olması, böylece 53 bit kesiti 1 ile başlayacaktır (üslüyü öyle olacak şekilde seçerek), o zaman 1 atlanır. Bu yüzden resim kesir için 52 bit gösteriyor (anlamlı), ancak etkili bir şekilde 53 bit var.

Normalleştirme nextDouble, 53'üncü bit kodunda ayarlanırsa, bu bitin üstü kapalı 1 olduğu ve kaybolduğu ve diğer 52 bitin kelimenin tam anlamıyla elde edilen sonucun önemine kopyalandığı anlamına gelir double. Ancak bu bit ayarlanmazsa, kalan bitler ayarlanana kadar sola kaydırılmalıdır.

Ortalama olarak, üretilen sayıların yarısı, anlamlılığın hiç sola kaymadığı (ve bunların en az anlamlı biti olarak 0'a sahip olanların yarısı) ve diğer yarısının en az 1 kaydırıldığı (veya sadece tamamen sıfır) böylece en küçük anlamlı bitleri her zaman 0 olur.

1: her zaman değil, açıkça Bu numaralar denormal veya normalin altında sayılar denir hiçbir yüksek 1. olan, sıfır için yapılamaz, bkz denormal numarasını: wikipedia .

Gönderen docs :

NextDouble yöntemi, Rastgele sınıfı tarafından şu şekilde uygulanır:

public double nextDouble() {
  return (((long)next(26) << 27) + next(27))
      / (double)(1L << 53);
}

Ama aynı zamanda aşağıdakileri de belirtir (benimkini vurgular):

[Java'nın ilk sürümlerinde sonuç yanlış olarak hesaplandı:

 return (((long)next(27) << 27) + next(27))
     / (double)(1L << 54);

Bu, daha iyi olmasa da eşdeğer görünebilir, ancak aslında kayan nokta sayılarının yuvarlanmasındaki önyargı nedeniyle büyük bir tekdüzelik getirdi: anlamlılığın düşük dereceli bitinin 0 olması üç kat daha muhtemeldi daha 1 olurdu ! Bu tekdüzelik muhtemelen pratikte çok önemli değil, ama mükemmellik için çalışıyoruz.]

Bu not en azından Java 5'ten beri var (Java için dokümanlar <= 1.4 bir giriş duvarının arkasında, kontrol etmek için çok tembel). Bu ilginç, çünkü problem hala Java 8'de bile var. Belki de "sabit" versiyon hiç test edilmedi?

Kayan nokta sayılarının nasıl temsil edildiği göz önüne alındığında bu sonuç beni şaşırtmıyor. Sadece 4 bit hassasiyetle çok kısa bir kayan nokta türümüz olduğunu varsayalım. Eğer eşit olarak dağıtılmış 0 ile 1 arasında rastgele bir sayı üretecek olsaydık, 16 olası değer olurdu:

0.0000
0.0001
0.0010
0.0011
0.0100
...
0.1110
0.1111

Makinede böyle görünüyorlarsa, 50/50 dağıtım elde etmek için düşük dereceli biti test edebilirsiniz. Bununla birlikte, IEEE şamandıraları bir mantisin 2 katı bir güç olarak temsil edilir; şamandıradaki bir alan 2'nin gücüdür (artı sabit bir ofset). 2'nin gücü, "mantis" kısmı daima> = 1.0 ve <2.0 olacak şekilde seçilir. Bu, aslında, sayı dışındaki rakamların 0.0000şu şekilde temsil edileceği anlamına gelir :

0.0001 = 2^(-4) x 1.000
0.0010 = 2^(-3) x 1.000
0.0011 = 2^(-3) x 1.100
0.0100 = 2^(-2) x 1.000
... 
0.0111 = 2^(-2) x 1.110
0.1000 = 2^(-1) x 1.000
0.1001 = 2^(-1) x 1.001
...
0.1110 = 2^(-1) x 1.110
0.1111 = 2^(-1) x 1.111

( 1İkili noktadan önce ima edilen bir değerdir; 32 ve 64 bitlik kayan noktalar için, aslında bunu tutmak için hiçbir bit ayrılmamıştır 1.)

Ancak yukarıdakilere bakmak, gösterimi bitlere dönüştürürseniz ve düşük bite bakarsanız, zamanın% 75'ini elde edeceğinizi neden göstermelidir. Bunun nedeni, 0 (düşük) değerden düşük 0.1000olan olası değerlerin yarısıdır ve mantislerinin kaydırılmasıyla 0'ın düşük bitte görünmesine neden olur. Durum, mantisin 52 bit (ima edilen 1 dahil değil) olduğu gibi aynıdır double.

@Sneftel yorumunda önerildiği gibi (Aslında, biz olabilir üretme vasıtasının dağıtımında 16'dan fazla olası değerler şunlardır:

0.0001000 with probability 1/128
0.0001001 with probability 1/128
...
0.0001111 with probability 1/128
0.001000  with probability 1/64
0.001001  with probability 1/64
...
0.01111   with probability 1/32 
0.1000    with probability 1/16
0.1001    with probability 1/16
...
0.1110    with probability 1/16
0.1111    with probability 1/16

Ama çoğu programcının bekleyeceği türden bir dağıtım olduğundan emin değilim, bu yüzden muhtemelen işe yaramaz. Ayrıca, rasgele kayan nokta değerleri genellikle olduğu gibi, değerler tamsayılar oluşturmak için kullanıldığında çok fazla kazanmaz.)