Bash: Como gerar um número flutuante aleatório usando $ RANDOM

awk -v n=10 -v seed="$RANDOM" 'BEGIN { srand(seed); for (i=0; i<n; ++i) printf("%.4f\n", rand()) }'

Isso produzirá nnúmeros aleatórios (dez no exemplo) no intervalo [0,1) com quatro dígitos decimais. Ele usa a rand()função in awk(não no padrão, awkmas implementada pelas implementações mais comuns awk) que retorna um valor aleatório nesse intervalo. O gerador de números aleatórios é propagado pela $RANDOMvariável do shell.

Quando um awkprograma possui apenas BEGINblocos (e nenhum outro bloco de código), awknão tentará ler a entrada de seu fluxo de entrada padrão.

Em qualquer sistema OpenBSD (ou sistema que tenha o mesmo jotutilitário , originalmente no 4.2BSD), o seguinte irá gerar 10 números aleatórios conforme especificado:

jot -p 4 -r 10 0 1

Conforme apontado em outra resposta, existem outros utilitários que você pode usar para gerar números aleatórios. Nesta resposta, limito meus recursos a $RANDOM, e algumas funções aritméticas básicas.

Para números de ponto flutuante, tente algo como

printf '%s\n' $(echo "scale=8; $RANDOM/32768" | bc )

Isso lhe dará a melhor precisão porque $RANDOMgera apenas números entre 0 e 32767. (incluindo 32767!) Mas também quebrei minha regra sobre o uso de funções aritméticas básicas invocando bc.

Mas antes de prosseguir, gostaria de examinar dois problemas de precisão e intervalo para números de ponto flutuante. Depois disso, analisarei a geração de um intervalo de números inteiros (e se você puder gerar números inteiros, poderá dividi-los posteriormente para obter um decimal, se desejar, usando quaisquer utilitários de sua preferência para fazer isso).

Precisão

Tomando a abordagem de $RANDOM/32768, uma vez que $RANDOMgera valores de 0 a 32767, o resultado de $RANDOM/32768também será um número finito de valores. Em outras palavras, ainda é uma variável aleatória discreta (e com um computador você nunca conseguirá escapar desse fato). Com isso em mente, você pode obter algum grau de precisão usando printf.

Se você deseja uma cobertura mais fina do intervalo, pode começar a pensar na base 32768. Assim, em teoria, $RANDOM + $RANDOM*32768deve fornecer uma distribuição uniforme entre 0 e 1.073.741.823. Mas, duvido que a linha de comando lide com essa precisão muito bem. Alguns pontos relacionados a este caso específico:

• A soma de duas variáveis ​​aleatórias independentes e uniformemente distribuídas geralmente não é uniforme. Neste caso, pelo menos teoricamente falando (ver terceiro ponto), eles são.
• Não pense que você pode simplificar $RANDOM + $RANDOM*32768 = $RANDOM * ( 1 + 32768 ). As duas ocorrências de $RANDOMsão realmente dois eventos diferentes.
• Não sei o suficiente sobre como $RANDOMé gerado para saber se chamá-lo duas vezes assim realmente gerará dois eventos aleatórios independentes.

Variar

Vamos considerar apenas $RANDOM/32768. Se você quiser um número em um intervalo, digamos [a,b), então

$RANDOM/32768*(b-a) + a

vai pousar você no intervalo desejado.

Geração de valores inteiros

Primeiro, considere gerar números aleatórios entre [0,b)onde bé menor que 32768. Considere o produto q*b, onde qé a parte inteira de 32768/b. Então o que você pode fazer é gerar um número aleatório entre 0 e 32767, mas descartar aqueles que forem maiores ou iguais a q*b. Ligue para o número assim gerado G. Então Gcairá no intervalo de 0 a q*b, e sua distribuição será uniforme. Agora, aplique a aritmética modular para obter esse valor reduzido para o intervalo desejado:

G % b

Observe, gerando aleatoriamente um número da seguinte maneira

$RANDOM % b

não criará uma distribuição uniforme, a menos que seja bapenas um dos divisores de 32768.

Escrevendo um script bash para isso

Calcular q*bcomo descrito acima soa como uma dor. Mas realmente não é. Você pode obtê-lo da seguinte maneira:

q*b = 32768 - ( 32768 % b )

No Bash, você pode obter isso com

$((32768 - $((32768 % b)) ))

O código a seguir gerará um número aleatório no intervalo 0..b(não incluindo b). b=$1

m=$((32768 - $((32768 % $1)) ))
a=$RANDOM
while (( $a > $m )); 
do
    a=$RANDOM
done
a=$(($a % $1))
printf "$a\n"

Termo aditivo

Tecnicamente, há poucos motivos para trabalhar com

m=$((32768 - $((32768 % $1)) ))

O seguinte realizará a mesma coisa

a=$RANDOM
while (( $a > $1 )); 
do
    a=$RANDOM
done
printf "$a\n"

Dá muito mais trabalho, mas os computadores são rápidos.

Gerando um inteiro em um intervalo maior

Vou deixar você descobrir isso. É preciso ter cuidado e, em algum momento, você terá que levar em consideração as limitações de memória do computador ao lidar com operações aritméticas.

Nota final

A resposta aceita não criará um número aleatório uniformemente de 0 a 1.

Para ver isso, tente o seguinte

$ for i in {1..1000}; do echo .$RANDOM; done | awk '{ a += $1 } END { print a }'

Para uma distribuição verdadeiramente uniforme, [0,1)você deve ver uma média próxima a 0.500.

Mas, como você pode ver executando o snippet acima, você obterá algo como 314.432ou 322.619. Como são 1000 números, a média disso é .322. A verdadeira média para esta sequência de números gerados é.316362

Você pode obter essa média real usando o script perl

  perl -e '{ $i=0;  
             $s=0; 
             while ( $i<=32767 ) 
               { 
                 $j = sprintf "%.5f", ".$i"; 
                 $j =~ s/^0\.//; 
                 print "$j\n"; 
                 $s += $j; 
                 $i++ 
               }; 
             printf "%.5f\n", $s/32767; 
           }' 

Estou adicionando números inteiros aqui para ajudá-lo a ver como essa abordagem de uso .$RANDOMnão está fazendo o que você provavelmente deseja. Em outras palavras, pense em quais números inteiros estão sendo gerados e quais estão totalmente perdidos. Um grande número é ignorado; alguns são duplicados.

Em sistemas onde o printf do shell é capaz de entender o %aformato (bash ksh zsh , etc. [0,1))

printf '%.5f\n' "$(printf '0x0.%04xp1' $RANDOM)"

Você pode até usar mais dígitos combinando mais chamadas para $RANDOM(de 0,000000001 a 0,999999999)

printf '%.9f\n'  "$(printf '0x0.%08xp2' $(( ($RANDOM<<15) + $RANDOM )))"

O algoritmo "$RANDOM" interno (para o shell) é baseado em um registrador de deslocamento de realimentação linear (LFSR). Esses não são Geradores de Números Pseudo Aleatórios Criptograficamente Seguros (CSPRNGs). Uma opção melhor é usar bytes do /dev/urandomdispositivo. Isso exigirá a chamada para dump externo octal ou hexadecimal.

$ printf '%.19f\n' "0x0.$(od -N 8 -An -tx1 /dev/urandom | tr -d ' ')"
0.7532810412812978029

$ printf '%.19f\n' "0x0.$(hexdump -n 8 -v -e '"%02x"' /dev/urandom)"
0.9453460825607180595

Uma solução muito simples (mas não uniforme) para obter um float é:

printf '0.%04d\n' $RANDOM

Uma maneira de torná-lo uniforme no intervalo [0,1)(não incluindo 1):

while a=$RANDOM; ((a>29999)); do :; done; printf '0.%04d\n' "$((a%10000))"

Usar$(( ( RANDOM % N ) + MIN ))

Substitua Npelo número MAX e MIN pelo número mínimo que você deseja gerar. ( Ncomo MAX é exclusivo, coloque N+1MAX, MIN inclusive).

Ou você pode usar $(shuf -i MIN-MAX -n 1)em vez disso.

de man shuf:

-i, --input-range=LO-HI
    treat each number LO through HI as an input line
-n, --head-count=COUNT 
    output at most COUNT lines

O -n 1aqui shufsignifica gerar apenas um número aleatório.

Isso irá gerar números aleatórios entre 0~9999 com zeros à esquerda usando printf(no resultado, o número 1 é exclusivo).

printf "0.%04d\n" $(( RANDOM % 1000 ))
0.0215

Na festa

bc -l <<< "scale=4 ; $((RANDOM % 10000 ))/10000"

onde 1/10000está sua precisão aleatória e 4dígitos sua precisão de saída

zshpossui uma rand48()função aritmética (envoltório para a erand48()função padrão) em seu zsh/mathfuncmódulo:

zmodload zsh/mathfunc
printf '%.4f\n' $((rand48()))

Enquanto $RANDOMé de 15 bits, pseudo-aleatório e reproduzível, bash5.1+ tem um número inteiro de 32 bits mais seguro $SRANDOM, baseado em fontes verdadeiramente aleatórias quando disponíveis. Ele não suporta aritmética de ponto flutuante, mas pelo menos você pode usá-lo para semear awko gerador pseudo-aleatório (que, por padrão, usa o resultado muito previsível de time()):

echo "$SRANDOM" | awk '
  {
    srand($1)
    for (i = 0; i < 20; i++)
      printf "%.4f\n", rand()
  }'

(lembre-se de que ainda são apenas 32 bits de entropia e awkgera geração pseudo-aleatória determinística com base nessa semente)