Advanced Bash-Scripting Guide: An in-depth exploration of the art of shell scripting | ||
---|---|---|
Prev | Chapter 9. Variables Revisited | Next |
$RANDOM is an internal Bash function (not a constant) that returns a pseudorandom [1] integer in the range 0 - 32767. It should not be used to generate an encryption key.
Example 9-25. Generating random numbers
1 #!/bin/bash 2 3 # $RANDOM returns a different random integer at each invocation. 4 # Nominal range: 0 - 32767 (signed 16-bit integer). 5 6 MAXCOUNT=10 7 count=1 8 9 echo 10 echo "$MAXCOUNT random numbers:" 11 echo "-----------------" 12 while [ "$count" -le $MAXCOUNT ] # Generate 10 ($MAXCOUNT) random integers. 13 do 14 number=$RANDOM 15 echo $number 16 let "count += 1" # Increment count. 17 done 18 echo "-----------------" 19 20 # If you need a random int within a certain range, use the 'modulo' operator. 21 # This returns the remainder of a division operation. 22 23 RANGE=500 24 25 echo 26 27 number=$RANDOM 28 let "number %= $RANGE" 29 # ^^ 30 echo "Random number less than $RANGE --- $number" 31 32 echo 33 34 35 36 # If you need a random integer greater than a lower bound, 37 #+ then set up a test to discard all numbers below that. 38 39 FLOOR=200 40 41 number=0 #initialize 42 while [ "$number" -le $FLOOR ] 43 do 44 number=$RANDOM 45 done 46 echo "Random number greater than $FLOOR --- $number" 47 echo 48 49 # Let's examine a simple alternative to the above loop, namely 50 # let "number = $RANDOM + $FLOOR" 51 # That would eliminate the while-loop and run faster. 52 # But, there might be a problem with that. What is it? 53 54 55 56 # Combine above two techniques to retrieve random number between two limits. 57 number=0 #initialize 58 while [ "$number" -le $FLOOR ] 59 do 60 number=$RANDOM 61 let "number %= $RANGE" # Scales $number down within $RANGE. 62 done 63 echo "Random number between $FLOOR and $RANGE --- $number" 64 echo 65 66 67 68 # Generate binary choice, that is, "true" or "false" value. 69 BINARY=2 70 T=1 71 number=$RANDOM 72 73 let "number %= $BINARY" 74 # Note that let "number >>= 14" gives a better random distribution 75 #+ (right shifts out everything except last binary digit). 76 if [ "$number" -eq $T ] 77 then 78 echo "TRUE" 79 else 80 echo "FALSE" 81 fi 82 83 echo 84 85 86 # Generate a toss of the dice. 87 SPOTS=6 # Modulo 6 gives range 0 - 5. 88 # Incrementing by 1 gives desired range of 1 - 6. 89 # Thanks, Paulo Marcel Coelho Aragao, for the simplification. 90 die1=0 91 die2=0 92 # Would it be better to just set SPOTS=7 and not add 1? Why or why not? 93 94 # Tosses each die separately, and so gives correct odds. 95 96 let "die1 = $RANDOM % $SPOTS +1" # Roll first one. 97 let "die2 = $RANDOM % $SPOTS +1" # Roll second one. 98 # Which arithmetic operation, above, has greater precedence -- 99 #+ modulo (%) or addition (+)? 100 101 102 let "throw = $die1 + $die2" 103 echo "Throw of the dice = $throw" 104 echo 105 106 107 exit 0 |
Example 9-26. Picking a random card from a deck
1 #!/bin/bash 2 # pick-card.sh 3 4 # This is an example of choosing random elements of an array. 5 6 7 # Pick a card, any card. 8 9 Suites="Clubs 10 Diamonds 11 Hearts 12 Spades" 13 14 Denominations="2 15 3 16 4 17 5 18 6 19 7 20 8 21 9 22 10 23 Jack 24 Queen 25 King 26 Ace" 27 28 # Note variables spread over multiple lines. 29 30 31 suite=($Suites) # Read into array variable. 32 denomination=($Denominations) 33 34 num_suites=${#suite[*]} # Count how many elements. 35 num_denominations=${#denomination[*]} 36 37 echo -n "${denomination[$((RANDOM%num_denominations))]} of " 38 echo ${suite[$((RANDOM%num_suites))]} 39 40 41 # $bozo sh pick-cards.sh 42 # Jack of Clubs 43 44 45 # Thank you, "jipe," for pointing out this use of $RANDOM. 46 exit 0 |
Jipe points out a set of techniques for generating random numbers within a range.
1 # Generate random number between 6 and 30. 2 rnumber=$((RANDOM%25+6)) 3 4 # Generate random number in the same 6 - 30 range, 5 #+ but the number must be evenly divisible by 3. 6 rnumber=$(((RANDOM%30/3+1)*3)) 7 8 # Note that this will not work all the time. 9 # It fails if $RANDOM%30 returns 0. 10 11 # Frank Wang suggests the following alternative: 12 rnumber=$(( RANDOM%27/3*3+6 )) |
Bill Gradwohl came up with an improved formula that works for positive numbers.
1 rnumber=$(((RANDOM%(max-min+divisibleBy))/divisibleBy*divisibleBy+min)) |
Here Bill presents a versatile function that returns a random number between two specified values.
Example 9-27. Random between values
1 #!/bin/bash 2 # random-between.sh 3 # Random number between two specified values. 4 # Script by Bill Gradwohl, with minor modifications by the document author. 5 # Used with permission. 6 7 8 randomBetween() { 9 # Generates a positive or negative random number 10 #+ between $min and $max 11 #+ and divisible by $divisibleBy. 12 # Gives a "reasonably random" distribution of return values. 13 # 14 # Bill Gradwohl - Oct 1, 2003 15 16 syntax() { 17 # Function embedded within function. 18 echo 19 echo "Syntax: randomBetween [min] [max] [multiple]" 20 echo 21 echo -n "Expects up to 3 passed parameters, " 22 echo "but all are completely optional." 23 echo "min is the minimum value" 24 echo "max is the maximum value" 25 echo -n "multiple specifies that the answer must be " 26 echo "a multiple of this value." 27 echo " i.e. answer must be evenly divisible by this number." 28 echo 29 echo "If any value is missing, defaults area supplied as: 0 32767 1" 30 echo -n "Successful completion returns 0, " 31 echo "unsuccessful completion returns" 32 echo "function syntax and 1." 33 echo -n "The answer is returned in the global variable " 34 echo "randomBetweenAnswer" 35 echo -n "Negative values for any passed parameter are " 36 echo "handled correctly." 37 } 38 39 local min=${1:-0} 40 local max=${2:-32767} 41 local divisibleBy=${3:-1} 42 # Default values assigned, in case parameters not passed to function. 43 44 local x 45 local spread 46 47 # Let's make sure the divisibleBy value is positive. 48 [ ${divisibleBy} -lt 0 ] && divisibleBy=$((0-divisibleBy)) 49 50 # Sanity check. 51 if [ $# -gt 3 -o ${divisibleBy} -eq 0 -o ${min} -eq ${max} ]; then 52 syntax 53 return 1 54 fi 55 56 # See if the min and max are reversed. 57 if [ ${min} -gt ${max} ]; then 58 # Swap them. 59 x=${min} 60 min=${max} 61 max=${x} 62 fi 63 64 # If min is itself not evenly divisible by $divisibleBy, 65 #+ then fix the min to be within range. 66 if [ $((min/divisibleBy*divisibleBy)) -ne ${min} ]; then 67 if [ ${min} -lt 0 ]; then 68 min=$((min/divisibleBy*divisibleBy)) 69 else 70 min=$((((min/divisibleBy)+1)*divisibleBy)) 71 fi 72 fi 73 74 # If max is itself not evenly divisible by $divisibleBy, 75 #+ then fix the max to be within range. 76 if [ $((max/divisibleBy*divisibleBy)) -ne ${max} ]; then 77 if [ ${max} -lt 0 ]; then 78 max=$((((max/divisibleBy)-1)*divisibleBy)) 79 else 80 max=$((max/divisibleBy*divisibleBy)) 81 fi 82 fi 83 84 # --------------------------------------------------------------------- 85 # Now, to do the real work. 86 87 # Note that to get a proper distribution for the end points, 88 #+ the range of random values has to be allowed to go between 89 #+ 0 and abs(max-min)+divisibleBy, not just abs(max-min)+1. 90 91 # The slight increase will produce the proper distribution for the 92 #+ end points. 93 94 # Changing the formula to use abs(max-min)+1 will still produce 95 #+ correct answers, but the randomness of those answers is faulty in 96 #+ that the number of times the end points ($min and $max) are returned 97 #+ is considerably lower than when the correct formula is used. 98 # --------------------------------------------------------------------- 99 100 spread=$((max-min)) 101 # Omair Eshkenazi points out that this test is unnecessary, 102 #+ since max and min have already been switched around. 103 [ ${spread} -lt 0 ] && spread=$((0-spread)) 104 let spread+=divisibleBy 105 randomBetweenAnswer=$(((RANDOM%spread)/divisibleBy*divisibleBy+min)) 106 107 return 0 108 109 # However, Paulo Marcel Coelho Aragao points out that 110 #+ when $max and $min are not divisible by $divisibleBy, 111 #+ the formula fails. 112 # 113 # He suggests instead the following formula: 114 # rnumber = $(((RANDOM%(max-min+1)+min)/divisibleBy*divisibleBy)) 115 116 } 117 118 # Let's test the function. 119 min=-14 120 max=20 121 divisibleBy=3 122 123 124 # Generate an array of expected answers and check to make sure we get 125 #+ at least one of each answer if we loop long enough. 126 127 declare -a answer 128 minimum=${min} 129 maximum=${max} 130 if [ $((minimum/divisibleBy*divisibleBy)) -ne ${minimum} ]; then 131 if [ ${minimum} -lt 0 ]; then 132 minimum=$((minimum/divisibleBy*divisibleBy)) 133 else 134 minimum=$((((minimum/divisibleBy)+1)*divisibleBy)) 135 fi 136 fi 137 138 139 # If max is itself not evenly divisible by $divisibleBy, 140 #+ then fix the max to be within range. 141 142 if [ $((maximum/divisibleBy*divisibleBy)) -ne ${maximum} ]; then 143 if [ ${maximum} -lt 0 ]; then 144 maximum=$((((maximum/divisibleBy)-1)*divisibleBy)) 145 else 146 maximum=$((maximum/divisibleBy*divisibleBy)) 147 fi 148 fi 149 150 151 # We need to generate only positive array subscripts, 152 #+ so we need a displacement that that will guarantee 153 #+ positive results. 154 155 disp=$((0-minimum)) 156 for ((i=${minimum}; i<=${maximum}; i+=divisibleBy)); do 157 answer[i+disp]=0 158 done 159 160 161 # Now loop a large number of times to see what we get. 162 loopIt=1000 # The script author suggests 100000, 163 #+ but that takes a good long while. 164 165 for ((i=0; i<${loopIt}; ++i)); do 166 167 # Note that we are specifying min and max in reversed order here to 168 #+ make the function correct for this case. 169 170 randomBetween ${max} ${min} ${divisibleBy} 171 172 # Report an error if an answer is unexpected. 173 [ ${randomBetweenAnswer} -lt ${min} -o ${randomBetweenAnswer} -gt ${max} ] \ 174 && echo MIN or MAX error - ${randomBetweenAnswer}! 175 [ $((randomBetweenAnswer%${divisibleBy})) -ne 0 ] \ 176 && echo DIVISIBLE BY error - ${randomBetweenAnswer}! 177 178 # Store the answer away statistically. 179 answer[randomBetweenAnswer+disp]=$((answer[randomBetweenAnswer+disp]+1)) 180 done 181 182 183 184 # Let's check the results 185 186 for ((i=${minimum}; i<=${maximum}; i+=divisibleBy)); do 187 [ ${answer[i+displacement]} -eq 0 ] \ 188 && echo "We never got an answer of $i." \ 189 || echo "${i} occurred ${answer[i+displacement]} times." 190 done 191 192 193 exit 0 |
Just how random is $RANDOM? The best way to test this is to write a script that tracks the distribution of "random" numbers generated by $RANDOM. Let's roll a $RANDOM die a few times . . .
Example 9-28. Rolling a single die with RANDOM
1 #!/bin/bash 2 # How random is RANDOM? 3 4 RANDOM=$$ # Reseed the random number generator using script process ID. 5 6 PIPS=6 # A die has 6 pips. 7 MAXTHROWS=600 # Increase this if you have nothing better to do with your time. 8 throw=0 # Throw count. 9 10 ones=0 # Must initialize counts to zero, 11 twos=0 #+ since an uninitialized variable is null, not zero. 12 threes=0 13 fours=0 14 fives=0 15 sixes=0 16 17 print_result () 18 { 19 echo 20 echo "ones = $ones" 21 echo "twos = $twos" 22 echo "threes = $threes" 23 echo "fours = $fours" 24 echo "fives = $fives" 25 echo "sixes = $sixes" 26 echo 27 } 28 29 update_count() 30 { 31 case "$1" in 32 0) let "ones += 1";; # Since die has no "zero", this corresponds to 1. 33 1) let "twos += 1";; # And this to 2, etc. 34 2) let "threes += 1";; 35 3) let "fours += 1";; 36 4) let "fives += 1";; 37 5) let "sixes += 1";; 38 esac 39 } 40 41 echo 42 43 44 while [ "$throw" -lt "$MAXTHROWS" ] 45 do 46 let "die1 = RANDOM % $PIPS" 47 update_count $die1 48 let "throw += 1" 49 done 50 51 print_result 52 53 exit 0 54 55 # The scores should distribute fairly evenly, assuming RANDOM is fairly random. 56 # With $MAXTHROWS at 600, all should cluster around 100, plus-or-minus 20 or so. 57 # 58 # Keep in mind that RANDOM is a pseudorandom generator, 59 #+ and not a spectacularly good one at that. 60 61 # Randomness is a deep and complex subject. 62 # Sufficiently long "random" sequences may exhibit 63 #+ chaotic and other "non-random" behavior. 64 65 # Exercise (easy): 66 # --------------- 67 # Rewrite this script to flip a coin 1000 times. 68 # Choices are "HEADS" and "TAILS". |
As we have seen in the last example, it is best to reseed the RANDOM generator each time it is invoked. Using the same seed for RANDOM repeats the same series of numbers. [2] (This mirrors the behavior of the random() function in C.)
Example 9-29. Reseeding RANDOM
1 #!/bin/bash 2 # seeding-random.sh: Seeding the RANDOM variable. 3 4 MAXCOUNT=25 # How many numbers to generate. 5 6 random_numbers () 7 { 8 count=0 9 while [ "$count" -lt "$MAXCOUNT" ] 10 do 11 number=$RANDOM 12 echo -n "$number " 13 let "count += 1" 14 done 15 } 16 17 echo; echo 18 19 RANDOM=1 # Setting RANDOM seeds the random number generator. 20 random_numbers 21 22 echo; echo 23 24 RANDOM=1 # Same seed for RANDOM... 25 random_numbers # ...reproduces the exact same number series. 26 # 27 # When is it useful to duplicate a "random" number series? 28 29 echo; echo 30 31 RANDOM=2 # Trying again, but with a different seed... 32 random_numbers # gives a different number series. 33 34 echo; echo 35 36 # RANDOM=$$ seeds RANDOM from process id of script. 37 # It is also possible to seed RANDOM from 'time' or 'date' commands. 38 39 # Getting fancy... 40 SEED=$(head -1 /dev/urandom | od -N 1 | awk '{ print $2 }') 41 # Pseudo-random output fetched 42 #+ from /dev/urandom (system pseudo-random device-file), 43 #+ then converted to line of printable (octal) numbers by "od", 44 #+ finally "awk" retrieves just one number for SEED. 45 RANDOM=$SEED 46 random_numbers 47 48 echo; echo 49 50 exit 0 |
The /dev/urandom pseudo-device file provides a method of generating much more "random" pseudorandom numbers than the $RANDOM variable. dd if=/dev/urandom of=targetfile bs=1 count=XX creates a file of well-scattered pseudorandom numbers. However, assigning these numbers to a variable in a script requires a workaround, such as filtering through od (as in above example and Example 15-13), or using dd (see Example 15-56), or even piping to md5sum (see Example 33-14). There are also other ways to generate pseudorandom numbers in a script. Awk provides a convenient means of doing this. Example 9-30. Pseudorandom numbers, using awk
The date command also lends itself to generating pseudorandom integer sequences. |
[1] | True "randomness," insofar as it exists at all, can only be found in certain incompletely understood natural phenomena such as radioactive decay. Computers can only simulate randomness, and computer-generated sequences of "random" numbers are therefore referred to as pseudorandom. |
[2] | The seed of a computer-generated pseudorandom number series can be considered an identification label. For example, think of the pseudorandom series with a seed of 23 as series #23. A property of a pseurandom number series is the length of the cycle before it starts repeating itself. A good pseurandom generator will produce series with very long cycles. |