Re: random real number between 0 (inclusive) and 1 (inclusive)
In comp.lang.java.programmer message <fgobj5$292n$1@ihnp4.ucsd.edu>,
Mon, 5 Nov 2007 16:13:23, Patricia Shanahan <pats@acm.org> posted:
Dr J R Stockton wrote:
In comp.lang.java.programmer message <jnasi31porsaqq0nb4u3r6mkdt3otanu9r
@4ax.com>, Sun, 4 Nov 2007 20:28:11, Roedy Green <see_website@mindprod.c
om.invalid> posted:
On Sun, 04 Nov 2007 19:35:39 -0000, "(-Peter-)"
<garfieldpbj@gmail.com> wrote, quoted or indirectly quoted someone who
said :
What I need is to generate a lot of random real numbers between 0 and
1, both inclusive (normally it's possible to generate the number
between 0(inclusive) and 1 (exclusive!!!) )
Multiply the number by 1+ulp where ulp in the smallest increment in a
double in the vicinity of 1.0
By stretching [0, 1) to cover [0, 1] there is necessarily a hole
created, perhaps at 0.5 .
By creating random R in [0, 1) and doing if (R==0.5) { R = 1 } ;
(apologies; I'm slowly learning to read Java;
writing it properly may follow)
one also gets a hole.
Now replace 0.5 by a random in [0, 1) independently generated and
renewed each time it is hit (so not correlated with the main Random),
and ISTM that all values in [0, 1] should be obtained with virtually
equal probability.
The Java code would be something like:
double nextInclusiveDouble(){
double r = nextDouble();
return r == nextDouble() ? 1 : r;
}
That's not the code for what I suggested. Whether it will do well
enough must depend on the details behind nextDouble. I suggested an
independent generator to maintain the Hole. Pseudo?-JavaSCRIPT :
var Hole = SomeOtherRandomFunction()
function nextInclusiveDouble() { var T
if ((T=Math.random())==Hole) {
T = 1 ; Hole = SomeOtherRandomFunction() }
return T }
Since SomeOtherRandomFunction is called only when Math.random() hits
Hole, it can be slow : something from Knuth implemented in Java[script].
If we were using a true random number generator, this would be close to
perfect. Let N be 2**53, the number of different nextDouble results, and
assume they are uniformly distributed and the results of consecutive
calls are independent.
If the works behind nextDouble were to have 53 bits (I suspect they have
more) consecutive calls would never give the same value.
The two nextDouble calls have N*N possible results.
They have whichever is the less of N**2 and 2**(GeneratorBits), ISTM.
Of those, N give
result 1. N-1 of the pairs result in e.g. 0. N numbers are each chosen
with probability (N-1)/(N*N), and 1.0 is chosen with probability
N/(N*N)=1/N.
This is indeed close enough that I don't think the difference would be
measurable over the probable lifetime of Java.
Does anyone know whether nextDouble produces pairs of consecutive equal
numbers with the correct probability, remembering that it is based on a
pseudo-random number generator?
Is nextDouble based on *A* specific PRNG, or is it based on whichever
PRNG the system author happened to like? In the latter case, your
question may have multiple answers.
--
(c) John Stockton, Surrey, UK. ?@merlyn.demon.co.uk Turnpike v6.05 MIME.
Web <URL:http://www.merlyn.demon.co.uk/> - FAQqish topics, acronyms & links;
Astro stuff via astron-1.htm, gravity0.htm ; quotings.htm, pascal.htm, etc.
No Encoding. Quotes before replies. Snip well. Write clearly. Don't Mail News.