What's wrong with using $RANDOM + $FLOOR in bash? - bash

Question

Reading this: http://www.tldp.org/LDP/abs/html/randomvar.html
# If you need a random integer greater than a lower bound,
#+ then set up a test to discard all numbers below that.
FLOOR=200
number=0 #initialize
while [ "$number" -le $FLOOR ]
do
number=$RANDOM
done
echo "Random number greater than $FLOOR --- $number"
echo
# Let's examine a simple alternative to the above loop, namely
# let "number = $RANDOM + $FLOOR"
# That would eliminate the while-loop and run faster.
# But, there might be a problem with that. What is it?
I have been not able to come up with a decent answer to the question in the last comment. That's the way I always generated my pseudorandom numbers in other languages (C/C++, Pascal), and had no problems -- is this something relevant only to Bash?

Answer 1

In programming languages where your random-number generator could give you values up to just below the overflow point, the latter code would have a bug wherein items within the range between MAXINT - FLOOR and MAXINT would overflow.
Bash does not have this bug, but the reference you are reading is evidently written without that awareness.

Answer 2

$RANDOM returns a random 16-bit integer, i.e. the range is 0 to 32767. I think the question in the comment presumes that you only want to change the lower bound to $FLOOR, but still expect the upper bound to be 32767. If you use $RANDOM + $FLOOR, you're also increasing the upper bound to 32967, which is not expected.
You can do it without a loop, though:
number=$(($FLOOR + (($RANDOM*32567)/32767)))

Answer 3

I am not sure what the issue ABS sees. Here's a sample test program where I pick numbers between 10 to 19. I track the chosen numbers with the arrays right_way (the way ABS says to do it) and wrong_way (The way they said is incorrect, but don't explain why).:
#! /bin/bash
declare -a right_way
declare -a wrong_way
for count in {1..10000}
do
#
# Generating Random Number between 10 and 20
#
number=0
while (( $number < 10 ))
do
(( number = $RANDOM % 20 ))
done
right_way[$number]=$(( ${right_way[$number]} + 1 ))
number=$(($RANDOM % 10 + 10 ))
wrong_way[$number]=$((${wrong_way[$number]} + 1 ))
done
printf "%10s %10s %10s\n" "Number" "Right Way" "Wrong Way"
for index in {10..19}
do
printf "%10d %10d %10d\n" $index ${right_way[$index]} ${wrong_way[$index]}
done
And here's the results:
Number Right Way Wrong Way
10 1027 1006
11 1001 998
12 996 974
13 985 1003
14 1065 991
15 990 990
16 959 1063
17 1023 989
18 967 988
19 987 998
I would expect each number to be chosen around 1000 times on the average, and it's pretty close with both methods.