Integer class>>randomBits: Q

I realize this is deprecated by virtue of method being in that category, but there’s no further comment as to why, hence the below inquiry.

Parcel loadParcelByName: 'CiphersBase'.

int := Integer randomBits: 4096.

(int printStringRadix: 2) inject: Dictionary new

                into:

                                [:dict :char |

                                dict

                                                at: char put: (dict at: char ifAbsent: [0]) + 1;

                                                yourself].

$0 "16r0030":  84

$1 "16r0031":  4012

Naively, I would have expected close to 50/50 split, not 98/2?

Running the above to get back just 8 bytes, the bits appear to be much closer split, often times exact down the middle.

$0 "16r0030":  31

$1 "16r0031":  32

-Boris

Sr. Software Engineer

DeepCove Labs

4th floor, 595 Howe Street

Vancouver, BC V6C 2T5

Canada

Henrik,

This all makes more sense to me now. I realized quickly that this wasn’t quite what I needed anyhow since I was looking to generate numbers whose base32 encoded value would be exactly 9 (for example) characters long, so what I was really looking for is a random number in the range 16r10000000000 (100000000) - 16r1FFFFFFFFFFF (ZZZZZZZZZ); too bad one can’t just pass a DSSRandom instance to #atRandom:,

(16r10000000000 to: 16r1FFFFFFFFFFF) atRandom: DSSRandom default

A correct implementation (albeit slower, and still depending on DSSRandom to return a high-quality random) would be something like:
randomBits2: size
| random bits |
    random := Security.DSSRandom default.
    bits := random next.
    [    bits highBit < size
    ] whileTrue: [|nextInput|
        nextInput := random next.
        bits := (bits bitShift: nextInput highBit -1) bitOr: (nextInput bitXor: 1 << nextInput highBit)  ].
    ^(bits bitShift: (size - bits highBit -1)) bitXor: 1 << bits highBit

Speaking of bugs:
randomBits2: size

    | random bits |
    random := Security.DSSRandom default.
    bits := random next.
    [bits highBit < size] whileTrue:
            [| nextInput |
            nextInput := random next.
            bits := (bits bitShift: nextInput highBit - 1)
                        bitOr: (nextInput bitXor: 1 << (nextInput highBit - 1))].
    bits := bits bitShift: size - bits highBit +1.
    ^bits bitXor: 1 << (bits highBit - 1)

is closer to what I meant, after actually running the code. :)

A way to see the thingy in the Note:, is inspecting
|b|
b := Bag new.
10000 timesRepeat: [b add: (Integer randomBits: 3)].
b

and notice how delightfully rare 0-3 are compared to 4-7.

So there's good reason why this is deprecated :)

Cheers,
Henry