How can I generate random 64-bit signed integer with macOS?

Question

I need to generate some 64-bit signed integer for testing.

How can I do this?

#!/bin/sh
long=$(????)

Answer 1

Combine 2 32-bit integers captured from /dev/urandom. It should be possible to use od to capture a single 64-bit value per Stéphane's answer, but on at least some versions of OS X this fails without an appropriate error message.

#!/bin/sh
low32=$(od -An -td4 -N4 < /dev/urandom)
high32=$(od -An -td4 -N4 < /dev/urandom)
long=$(($low32 + ($high32 << 32) ))

Answer 2

macOS comes with Python. Use its random module.

python -c 'import random; rng = random.SystemRandom(); print rng.randint(-2**63, 2**63-1)'

If you don't need secure random numbers, this can be simplified to

python -c 'import random; print(random.randint(-2**63, 2**63-1))'

Answer 3

As macOS has /dev/urandom, you should be able to do:

od -An -vtd8 -N8 < /dev/urandom

However, according to those who've tried it on an actual macOS system (see comments), it doesn't work there. As macOS is meant to be a certified Unix system, that means it's a bug as POSIX clearly specifies the behaviour of that command. The only thing that POSIX leaves unspecified (implementation defined) is the byte order (which we don't care about here as that's all random bytes).

Alternatively, you could use ksh/bash/zsh's $RANDOM here. Even though macOS' sh is based on bash nowadays, it would be better to switch to bash/zsh (or ksh implementations other than mksh whose arithmetic use 32bits) as $RANDOM is not a sh feature so may not work in future version of macOS if they decide to switch to a different shell.

m=32768 # $RANDOM span
long=$((RANDOM+RANDOM*m+RANDOM*m*m+RANDOM*m*m*m+RANDOM*m*m*m*m))

or:

long=$((RANDOM|(RANDOM<<15)|(RANDOM<<30)|(RANDOM<<45)|(RANDOM<<60)))

That's 5*15 == 75 bits but that will be truncated to 64 bits by the shell.

In the POSIX tool chest, the way to generate random numbers is with awk's rand(), so you could do:

awk 'BEGIN{srand(); printf "%.20g\n", rand() * (2^64) - (2^63)}'

Beware though that with many awk implementations (those that base the srand() seed on the result of time(3)), you'll get the same output if you run it twice in the same second.

Also, because of the way floating point numbers are represented, I'd expect there would be some 64bit numbers (like 2⁶³-1) that it would never output.

Answer 4

You can append two 32-bit numbers together, e.g.,

#!/bin/bash
printf '0x%04x%04x\n' $RANDOM $RANDOM
j=$(printf '16#%04x%04x' $RANDOM $RANDOM)
echo $j
echo $(($j))

Sample output

0x5e34562d 
16#7cf567f9
2096457721

This is one of many features originating in the Korn shell (ksh), copied to bash and zsh a few years later.

Per comment - you can append additional bits:

#!/bin/bash    
printf '0x%04x%04x\n' $RANDOM $RANDOM
foo=32767
printf '%016x\n' $((foo << 49))
printf '%016x\n' $((foo << 34))
printf '%016x\n' $((foo << 19))
printf '%016x\n' $((foo << 4))
printf '%016x\n' $((foo % 16))

printf '%016x\n' $((foo << 49 |
                   (foo << 34) |
                   (foo << 19) |
                   (foo << 4) |
                   (foo % 16)))
printf '%d\n'    $((foo << 49 |
                   (foo << 34) |
                   (foo << 19) |
                   (foo << 4) |
                   (foo % 16)))

Sample output:

0x3a1e1184     
fffe000000000000
0001fffc00000000
00000003fff80000
000000000007fff0
000000000000000f
ffffffffffffffff
-1