Comment générer de nombres aléatoires en Bash?

Veuillez voir $RANDOM:

$RANDOM interne de Bash fonction
(pas une constante) qui renvoie un
pseudo entier dans la gamme
0 - 32767. Il ne devrait pas être utilisé pour
générer une clé de chiffrement.

Vous pouvez également utiliser shuf (disponible en coreutils).

shuf -i 1-100000 -n 1

Il y a $ALÉATOIRE.
Je ne sais pas exactement comment il fonctionne. Mais il fonctionne.
Pour les tests, vous pouvez le faire :

echo $RANDOM

J'aime cette astuce:

echo ${RANDOM:0:1} # random number between 1 and 9
echo ${RANDOM:0:2} # random number between 1 and 99

...

J'ai pris un peu de ces idées et de fait une fonction qui doit effectuer rapidement si beaucoup de nombres aléatoires sont nécessaires.

appel od est cher si vous avez besoin de beaucoup de nombres aléatoires. Au lieu de cela j'appelle ça une fois et stocker 1024 nombres aléatoires à partir de /dev/urandom. Lorsque rand est appelé, le dernier nombre aléatoire est retourné et mis à l'échelle. Il est alors retiré de la mémoire cache. Lorsque le cache est vide, l'autre 1024 de nombres aléatoires est lu.

Exemple:

rand 10; echo $RET

Retourne un nombre aléatoire dans RET entre 0 et 9 inclus.

declare -ia RANDCACHE
declare -i RET RAWRAND=$(( (1<<32)-1 ))

function rand(){  # pick a random number from 0 to N-1. Max N is 2^32
  local -i N=$1
  [[ ${#RANDCACHE[*]} -eq 0 ]] && { RANDCACHE=( $(od -An -tu4 -N1024 /dev/urandom) ); }  # refill cache
  RET=$(( (RANDCACHE[-1]*N+1)/RAWRAND ))  # pull last random number and scale
  unset RANDCACHE[${#RANDCACHE[*]}-1]     # pop read random number
};

# test by generating a lot of random numbers, then effectively place them in bins and count how many are in each bin.

declare -i c; declare -ia BIN

for (( c=0; c<100000; c++ )); do
  rand 10
  BIN[RET]+=1  # add to bin to check distribution
done

for (( c=0; c<10; c++ )); do
  printf "%d %d\n" $c ${BIN[c]} 
done

Mise à JOUR: cela ne fonctionne pas si bien pour tout N. Il a également des déchets de bits aléatoires avec des petits N. en Notant que (dans ce cas) de 32 bits nombre aléatoire a assez d'entropie pour les 9 nombres aléatoires entre 0 et 9 (10*9=1 000 000 000 d' <= 2*32), nous pouvons extraire plusieurs nombres aléatoires à partir de chacune des 32 aléatoire de la source de la valeur.

#!/bin/bash

declare -ia RCACHE

declare -i RET             # return value
declare -i ENT=2           # keep track of unused entropy as 2^(entropy)
declare -i RND=RANDOM%ENT  # a store for unused entropy - start with 1 bit

declare -i BYTES=4         # size of unsigned random bytes returned by od
declare -i BITS=8*BYTES    # size of random data returned by od in bits
declare -i CACHE=16        # number of random numbers to cache
declare -i MAX=2**BITS     # quantum of entropy per cached random number
declare -i c

function rand(){  # pick a random number from 0 to 2^BITS-1
  [[ ${#RCACHE[*]} -eq 0 ]] && { RCACHE=( $(od -An -tu$BYTES -N$CACHE /dev/urandom) ); }  # refill cache - could use /dev/random if CACHE is small
  RET=${RCACHE[-1]}              # pull last random number and scale
  unset RCACHE[${#RCACHE[*]}-1]  # pop read random number
};

function randBetween(){
  local -i N=$1
  [[ ENT -lt N ]] && {  # not enough entropy to supply ln(N)/ln(2) bits
    rand; RND=RET       # get more random bits
    ENT=MAX             # reset entropy
  }
  RET=RND%N  # random number to return
  RND=RND/N  # remaining randomness
  ENT=ENT/N  # remaining entropy
};

declare -ia BIN

for (( c=0; c<100000; c++ )); do
  randBetween 10
  BIN[RET]+=1
done

for c in ${BIN[*]}; do
  echo $c
done

Ce sujet:

perl -e 'print int rand 10, "\n"; '

Générer des nombre aléatoire dans l'intervalle de 0 à n (entier signé de 16 bits). Résultat dans $RAND variable. Par exemple:

#!/bin/bash

random()
{
    local range=${1:-1}

    RAND=`od -t uI -N 4 /dev/urandom | awk '{print $2}'`
    let "RAND=$RAND%($range+1)"
}

n=10
while [ $(( n -=1 )) -ge "0" ]; do
    random 500
    echo "$RAND"
done