Thanks for the link Tom!

As it turns out (and unlike what I first asked), I don't actaully need for

every double floating-point number to be generated randomly that exists in

[0.0,1.0]. It turns out I'm able to determine the 'resolution' of the

generator that is good enough for my application for what it happens to be

doing at the moment. By 'resolution' I mean the number of possible

equally-spaced floating-point random values I need to generate in the

[0.0,1.0] range (e.g., resolution 3 would generate only these values: 0.0,

..5, 1.0).

So I created a class with a 'base' (= resolution-1) and let rand() generate

a random number from 0 to base, and then produce this number divided by

base to get it into the [0.0,1.0] range. This is sufficient for my

application.

I realized, based on the responses here, that any random number generator on

a digital computer will never return all possibly real numbers, so I had to

deal with a 'resolution' no matter what. The method I've created deals with

such any (not too big) resolution 'perfectly', and so it works!

Thanks!

[==Peteroid==]

"TOM" <no****@noprovider.nodomain> wrote in message

news:%2****************@TK2MSFTNGP09.phx.gbl...

You may want to read the section on random number generators in

"Numerical Recipes in C". The text is free and on-line in PDF format by

permission of the publisher, at:

http://www.nr.com/

It's very difficult to build a good random number generator. The text

illustrates the problems and some ways around it, but is focused

on float rather than double.

-- Tom

"Peteroid" <pe************@msn.com> wrote in message

news:u2**************@TK2MSFTNGP11.phx.gbl... Thanks, Carl!

You gave me a better way than I was going. I'll create a class that
allows me to generate a floating-point number in the range of [0.0.,1.0] (yes,

closed on both sides) of arbitray bit-count resolution up to a limit
(51, or

possibly even 63, sounds good, based on your response).

Say the bit-count is N. Generate an N-bit random number by generating
N/16 number of random 16-bit integers (using rand()), and possibly 1 more for

the

N%16 remaining bits (which is masked off the apprograte number of high

bits

to get correct number of bytes), and then append them into a double by

shifting and adding. Then divide by a double version of (2^N - 1) and
that should (for some values of N) produce the closed interval random

floating-point number expressed as a double!

The seed is nor just srand()...

Thanx again...! :)

[==Peteroid==]

"Carl Daniel [VC++ MVP]"
<cp*****************************@mvps.org.nospam > wrote in message news:uM**************@TK2MSFTNGP14.phx.gbl... Peteroid wrote:

> I know how to use rand() to generate random POSITIVE-INTEGER numbers.

>

> But, I'd like to generate a random DOUBLE number in the range of 0.0

> to 1.0 with resolution of a double (i.e., every possible double value

> in the range could come up with equal probability). I'd also like to

> be able to seed this generator (e.g., via the clock) so that the same

> sequence of random values don't come up every time.

A double in [0.0,1.0) has 2^52 distinct values. To generate such

doubles,

first generate a random integer in [0,2^52) and then divide it by 2^52.

Note that all such integers, including 2^52 can be represented exactly
as doubles.

You might want to look at boost::random (see

http://www.boost.org/libs/random/index.html for details) for

pseudo-random

generators that are good enough to generate 2^52 numbers without
cycles. You need to use a long period generator such as a Mersenne twister to

really get 2^52 values out of it. Your generator will have to generate 64 bit

values of course.

-cd