9.6. $RANDOM: generate random integer

   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

   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

   1 #!/bin/bash
   2 # brownian.sh
   3 # Author: Mendel Cooper
   4 # Reldate: 10/26/07
   5 # License: GPL3
   6 
   7 #  ----------------------------------------------------------------
   8 #  This script models Brownian motion:
   9 #+ the random wanderings of tiny particles in a fluid,
  10 #+ as they are buffeted by random currents and collisions.
  11 #+ This is colloquially known as the "Drunkard's Walk."
  12 
  13 #  It can also be considered as a stripped-down simulation of a
  14 #+ Galton Board, a slanted board with a pattern of pegs,
  15 #+ down which rolls a succession of marbles, one at a time.
  16 #+ At the bottom is a row of slots or catch basins in which
  17 #+ the marbles come to rest at the end of their journey.
  18 #  Think of it as a kind of bare-bones Pachinko game.
  19 #  As you see by running the script,
  20 #+ most of the marbles cluster around the center slot.
  21 #+ This is consistent with the expected binomial distribution.
  22 #  As a Galton Board simulation, the script
  23 #+ disregards such parameters as
  24 #+ board tilt-angle, rolling friction of the marbles,
  25 #+ angles of impact, and elasticity of the pegs.
  26 #  To what extent does this affect the accuracy of the simulation?
  27 #  ----------------------------------------------------------------
  28 
  29 PASSES=500            #  Number of particle interactions / marbles.
  30 ROWS=10               #  Number of "collisions" (or horiz. peg rows).
  31 RANGE=3               #  0 - 2 output range from $RANDOM.
  32 POS=0                 #  Left/right position.
  33 RANDOM=$$             #  Seeds the random number generator from PID
  34                       #+ of script.
  35 
  36 declare -a Slots      # Array holding cumulative results of passes.
  37 NUMSLOTS=21           # Number of slots at bottom of board.
  38 
  39 
  40 Initialize_Slots () { # Zero out all elements of the array.
  41 for i in $( seq $NUMSLOTS )
  42 do
  43   Slots[$i]=0
  44 done
  45 
  46 echo                  # Blank line at beginning of run.
  47   }
  48 
  49 
  50 Show_Slots () {
  51 echo -n " "
  52 for i in $( seq $NUMSLOTS )   # Pretty-print array elements.
  53 do
  54   printf "%3d" ${Slots[$i]}   # Allot three spaces per result.
  55 done
  56 
  57 echo # Row of slots:
  58 echo " |__|__|__|__|__|__|__|__|__|__|__|__|__|__|__|__|__|__|__|__|__|"
  59 echo "                                ^^"
  60 echo #  Note that if the count within any particular slot exceeds 99,
  61      #+ it messes up the display.
  62      #  Running only(!) 500 passes usually avoids this.
  63   }
  64 
  65 
  66 Move () {              # Move one unit right / left, or stay put.
  67   Move=$RANDOM         # How random is $RANDOM? Well, let's see ...
  68   let "Move %= RANGE"  # Normalize into range of 0 - 2.
  69   case "$Move" in
  70     0 ) ;;                   # Do nothing, i.e., stay in place.
  71     1 ) ((POS--));;          # Left.
  72     2 ) ((POS++));;          # Right.
  73     * ) echo -n "Error ";;   # Anomaly! (Should never occur.)
  74   esac
  75   }
  76 
  77 
  78 Play () {                    # Single pass (inner loop).
  79 i=0
  80 while [ "$i" -lt "$ROWS" ]   # One event per row.
  81 do
  82   Move
  83   ((i++));
  84 done
  85 
  86 SHIFT=11                     # Why 11, and not 10?
  87 let "POS += $SHIFT"          # Shift "zero position" to center.
  88 (( Slots[$POS]++ ))          # DEBUG: echo $POS
  89   }
  90 
  91 
  92 Run () {                     # Outer loop.
  93 p=0
  94 while [ "$p" -lt "$PASSES" ]
  95 do
  96   Play
  97   (( p++ ))
  98   POS=0                      # Reset to zero. Why?
  99 done
 100   }
 101 
 102 
 103 # --------------
 104 # main ()
 105 Initialize_Slots
 106 Run
 107 Show_Slots
 108 # --------------
 109 
 110 exit $?
 111 
 112 #  Exercises:
 113 #  ---------
 114 #  1) Show the results in a vertical bar graph, or as an alternative,
 115 #+    a scattergram.
 116 #  2) Alter the script to use /dev/urandom instead of $RANDOM.
 117 #     Will this make the results more random?

   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

   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".

   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