9.6. $RANDOM: generate random integer
$RANDOM is an internal Bash function (not a constant) that returns a pseudorandom integer in the range 0 - 32767. $RANDOM should not be used to generate an encryption key.
Example 9-23. 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 echo "Random number less than $RANGE --- $number" 30 31 echo 32 33 # If you need a random int greater than a lower bound, 34 # then set up a test to discard all numbers below that. 35 36 FLOOR=200 37 38 number=0 #initialize 39 while [ "$number" -le $FLOOR ] 40 do 41 number=$RANDOM 42 done 43 echo "Random number greater than $FLOOR --- $number" 44 echo 45 46 47 # May combine above two techniques to retrieve random number between two limits. 48 number=0 #initialize 49 while [ "$number" -le $FLOOR ] 50 do 51 number=$RANDOM 52 let "number %= $RANGE" # Scales $number down within $RANGE. 53 done 54 echo "Random number between $FLOOR and $RANGE --- $number" 55 echo 56 57 58 # Generate binary choice, that is, "true" or "false" value. 59 BINARY=2 60 number=$RANDOM 61 T=1 62 63 let "number %= $BINARY" 64 # let "number >>= 14" gives a better random distribution 65 # (right shifts out everything except last binary digit). 66 if [ "$number" -eq $T ] 67 then 68 echo "TRUE" 69 else 70 echo "FALSE" 71 fi 72 73 echo 74 75 76 # May generate toss of the dice. 77 SPOTS=7 # Modulo 7 gives range 0 - 6. 78 ZERO=0 79 die1=0 80 die2=0 81 82 # Tosses each die separately, and so gives correct odds. 83 84 while [ "$die1" -eq $ZERO ] # Can't have a zero come up. 85 do 86 let "die1 = $RANDOM % $SPOTS" # Roll first one. 87 done 88 89 while [ "$die2" -eq $ZERO ] 90 do 91 let "die2 = $RANDOM % $SPOTS" # Roll second one. 92 done 93 94 let "throw = $die1 + $die2" 95 echo "Throw of the dice = $throw" 96 echo 97 98 99 exit 0 |
Example 9-24. Picking a random card from a deck
1 #!/bin/bash
2 # pick-card.sh
3
4 # This is an example of choosing a random element 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 suite=($Suites) # Read into array variable.
29 denomination=($Denominations)
30
31 num_suites=${#suite[*]} # Count how many elements.
32 num_denominations=${#denomination[*]}
33
34 echo -n "${denomination[$((RANDOM%num_denominations))]} of "
35 echo ${suite[$((RANDOM%num_suites))]}
36
37
38 # $bozo sh pick-cards.sh
39 # Jack of Clubs
40
41
42 # Thank you, "jipe," for pointing out this use of $RANDOM.
43 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 returns 0. 10 11 # Exercise: Try to figure out the pattern here. |
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-25. 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 "Expects up to 3 passed parameters, but all are completely optional."
22 echo "min is the minimum value"
23 echo "max is the maximum value"
24 echo "multiple specifies that the answer must be a multiple of this value."
25 echo " i.e. answer must be evenly divisible by this number."
26 echo
27 echo "If any value is missing, defaults area supplied as: 0 32767 1"
28 echo "Successful completion returns 0, unsuccessful completion returns"
29 echo "function syntax and 1."
30 echo "The answer is returned in the global variable randomBetweenAnswer"
31 echo "Negative values for any passed parameter are handled correctly."
32 }
33
34 local min=${1:-0}
35 local max=${2:-32767}
36 local divisibleBy=${3:-1}
37 # Default values assigned, in case parameters not passed to function.
38
39 local x
40 local spread
41
42 # Let's make sure the divisibleBy value is positive.
43 [ ${divisibleBy} -lt 0 ] && divisibleBy=$((0-divisibleBy))
44
45 # Sanity check.
46 if [ $# -gt 3 -o ${divisibleBy} -eq 0 -o ${min} -eq ${max} ]; then
47 syntax
48 return 1
49 fi
50
51 # See if the min and max are reversed.
52 if [ ${min} -gt ${max} ]; then
53 # Swap them.
54 x=${min}
55 min=${max}
56 max=${x}
57 fi
58
59 # If min is itself not evenly divisible by $divisibleBy,
60 #+ then fix the min to be within range.
61 if [ $((min/divisibleBy*divisibleBy)) -ne ${min} ]; then
62 if [ ${min} -lt 0 ]; then
63 min=$((min/divisibleBy*divisibleBy))
64 else
65 min=$((((min/divisibleBy)+1)*divisibleBy))
66 fi
67 fi
68
69 # If max is itself not evenly divisible by $divisibleBy,
70 #+ then fix the max to be within range.
71 if [ $((max/divisibleBy*divisibleBy)) -ne ${max} ]; then
72 if [ ${max} -lt 0 ]; then
73 max=$((((max/divisibleBy)-1)*divisibleBy))
74 else
75 max=$((max/divisibleBy*divisibleBy))
76 fi
77 fi
78
79 # ---------------------------------------------------------------------
80 # Now do the real work.
81
82 # Note that to get a proper distribution for the end points, the
83 #+ range of random values has to be allowed to go between 0 and
84 #+ abs(max-min)+divisibleBy, not just abs(max-min)+1.
85
86 # The slight increase will produce the proper distribution for the
87 #+ end points.
88
89 # Changing the formula to use abs(max-min)+1 will still produce
90 #+ correct answers, but the randomness of those answers is faulty in
91 #+ that the number of times the end points ($min and $max) are returned
92 #+ is considerably lower than when the correct formula is used.
93 # ---------------------------------------------------------------------
94
95 spread=$((max-min))
96 [ ${spread} -lt 0 ] && spread=$((0-spread))
97 let spread+=divisibleBy
98 randomBetweenAnswer=$(((RANDOM%spread)/divisibleBy*divisibleBy+min))
99
100 return 0
101 }
102
103 # Let's test the function.
104 min=-14
105 max=20
106 divisibleBy=3
107
108
109 # Generate an array of expected answers and check to make sure we get
110 #+ at least one of each answer if we loop long enough.
111
112 declare -a answer
113 minimum=${min}
114 maximum=${max}
115 if [ $((minimum/divisibleBy*divisibleBy)) -ne ${minimum} ]; then
116 if [ ${minimum} -lt 0 ]; then
117 minimum=$((minimum/divisibleBy*divisibleBy))
118 else
119 minimum=$((((minimum/divisibleBy)+1)*divisibleBy))
120 fi
121 fi
122
123
124 # If max is itself not evenly divisible by $divisibleBy,
125 #+ then fix the max to be within range.
126
127 if [ $((maximum/divisibleBy*divisibleBy)) -ne ${maximum} ]; then
128 if [ ${maximum} -lt 0 ]; then
129 maximum=$((((maximum/divisibleBy)-1)*divisibleBy))
130 else
131 maximum=$((maximum/divisibleBy*divisibleBy))
132 fi
133 fi
134
135
136 # We need to generate only positive array subscripts,
137 #+ so we need a displacement that that will guarantee
138 #+ positive results.
139
140 displacement=$((0-minimum))
141 for ((i=${minimum}; i<=${maximum}; i+=divisibleBy)); do
142 answer[i+displacement]=0
143 done
144
145
146 # Now loop a large number of times to see what we get.
147 loopIt=1000 # The script author suggests 100000,
148 #+ but that takes a good long while.
149
150 for ((i=0; i<${loopIt}; ++i)); do
151
152 # Note that we are specifying min and max in reversed order here to
153 #+ make the function correct for this case.
154
155 randomBetween ${max} ${min} ${divisibleBy}
156
157 # Report an error if an answer is unexpected.
158 [ ${randomBetweenAnswer} -lt ${min} -o ${randomBetweenAnswer} -gt ${max} ] && echo MIN or MAX error - ${randomBetweenAnswer}!
159 [ $((randomBetweenAnswer%${divisibleBy})) -ne 0 ] && echo DIVISIBLE BY error - ${randomBetweenAnswer}!
160
161 # Store the answer away statistically.
162 answer[randomBetweenAnswer+displacement]=$((answer[randomBetweenAnswer+displacement]+1))
163 done
164
165
166
167 # Let's check the results
168
169 for ((i=${minimum}; i<=${maximum}; i+=divisibleBy)); do
170 [ ${answer[i+displacement]} -eq 0 ] && echo "We never got an answer of $i." || echo "${i} occurred ${answer[i+displacement]} times."
171 done
172
173
174 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-26. 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 zeroes=0 # Must initialize counts to zero.
11 ones=0 # since an uninitialized variable is null, not zero.
12 twos=0
13 threes=0
14 fours=0
15 fives=0
16 sixes=0
17
18 print_result ()
19 {
20 echo
21 echo "ones = $ones"
22 echo "twos = $twos"
23 echo "threes = $threes"
24 echo "fours = $fours"
25 echo "fives = $fives"
26 echo "sixes = $sixes"
27 echo
28 }
29
30 update_count()
31 {
32 case "$1" in
33 0) let "ones += 1";; # Since die has no "zero", this corresponds to 1.
34 1) let "twos += 1";; # And this to 2, etc.
35 2) let "threes += 1";;
36 3) let "fours += 1";;
37 4) let "fives += 1";;
38 5) let "sixes += 1";;
39 esac
40 }
41
42 echo
43
44
45 while [ "$throw" -lt "$MAXTHROWS" ]
46 do
47 let "die1 = RANDOM % $PIPS"
48 update_count $die1
49 let "throw += 1"
50 done
51
52 print_result
53
54 # The scores should distribute fairly evenly, assuming RANDOM is fairly random.
55 # With $MAXTHROWS at 600, all should cluster around 100, plus-or-minus 20 or so.
56 #
57 # Keep in mind that RANDOM is a pseudorandom generator,
58 # and not a spectacularly good one at that.
59
60 # Exercise (easy):
61 # ---------------
62 # Rewrite this script to flip a coin 1000 times.
63 # Choices are "HEADS" or "TAILS".
64
65 exit 0 |
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. (This mirrors the behavior of the random() function in C.)
Example 9-27. 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 device-file provides a means 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) or using dd (see Example 12-42). There are also other means of generating pseudorandom numbers in a script. Awk provides a convenient means of doing this. Example 9-28. Pseudorandom numbers, using awk
|