A new classification method for RNGs: Significance Level

[joe]

My experiments show that the random number generator
in Microsoft's VC++6 compiler is a statistical RNG with a
significance level 1.0%.
Statistical testing at SL >1.0% (for example 1.001%) passes the test,
but 1.0% does not pass...

Can anybody confirm this finding?

The RNG function of the various SW products can be
analyzed and classified better using its significance level
as shown above.
I think this IMO important finding deserves a deeper research... :-)

For the testing method see:
http://en.wikipedia.org/wiki/Binomial_test
http://en.wikipedia.org/wiki/Binomial_distribution

[David Kerber]

In article <g5**********@aioe.org>, jo*@iamnotathome.org.invalid says...

My experiments show that the random number generator
in Microsoft's VC++6 compiler is a statistical RNG with a
significance level 1.0%.
Statistical testing at SL >1.0% (for example 1.001%) passes the test,
but 1.0% does not pass...

Can anybody confirm this finding?

The RNG function of the various SW products can be
analyzed and classified better using its significance level
as shown above.
I think this IMO important finding deserves a deeper research... :-)

For the testing method see:
http://en.wikipedia.org/wiki/Binomial_test
http://en.wikipedia.org/wiki/Binomial_distribution

What are you using for your sample size and null hypothesis?

--
/~\ The ASCII
\ / Ribbon Campaign
X Against HTML
/ \ Email!

Remove the ns_ from if replying by e-mail (but keep posts in the
newsgroups if possible).

[joe]

"David Kerber" wrote:

jo*@iamnotathome.org.invalid says:

My experiments show that the random number generator
in Microsoft's VC++6 compiler is a statistical RNG with a
significance level 1.0%.
Statistical testing at SL >1.0% (for example 1.001%) passes the test,
but 1.0% does not pass...

Can anybody confirm this finding?

The RNG function of the various SW products can be
analyzed and classified better using its significance level
as shown above.
I think this IMO important finding deserves a deeper research... :-)

For the testing method see:
http://en.wikipedia.org/wiki/Binomial_test
http://en.wikipedia.org/wiki/Binomial_distribution

What are you using for your sample size and null hypothesis?

Here the details:
Sample size is 500 (ie. calling rand() 500 times),
rnd range is 37 (ie. 0 to 36; yes, a roulette simulation).
Doing the above mentioned StatTest after each rand() call.
The above said is called more than 30 times in a loop,
each time initializing the freq stats anew.
srand(time(0)) done only once at pgmstart.

[joe]

"joe" wrote:

"David Kerber" wrote:

jo*@iamnotathome.org.invalid says:

>
My experiments show that the random number generator
in Microsoft's VC++6 compiler is a statistical RNG with a
significance level 1.0%.
Statistical testing at SL >1.0% (for example 1.001%) passes the test,
but 1.0% does not pass...
>
Can anybody confirm this finding?
>
The RNG function of the various SW products can be
analyzed and classified better using its significance level
as shown above.
I think this IMO important finding deserves a deeper research... :-)
>
For the testing method see:
http://en.wikipedia.org/wiki/Binomial_test
http://en.wikipedia.org/wiki/Binomial_distribution

What are you using for your sample size and null hypothesis?

H0 = RNG passes the randomness test only at a significance level >1%
ie. try out 1% and 1.001% for example and you will
see it always fails at the <=1% level and always passes at >1% sig level.

Here the details:
Sample size is 500 (ie. calling rand() 500 times),
rnd range is 37 (ie. 0 to 36; yes, a roulette simulation).
Doing the above mentioned StatTest after each rand() call.
The above said is called more than 30 times in a loop,
each time initializing the freq stats anew.
srand(time(0)) done only once at pgmstart.

[David Kerber]

In article <g5**********@aioe.org>, jo*@iamnotathome.org.invalid says...

"joe" wrote:

"David Kerber" wrote:

jo*@iamnotathome.org.invalid says:

My experiments show that the random number generator
in Microsoft's VC++6 compiler is a statistical RNG with a
significance level 1.0%.
Statistical testing at SL >1.0% (for example 1.001%) passes the test,
but 1.0% does not pass...

Can anybody confirm this finding?

The RNG function of the various SW products can be
analyzed and classified better using its significance level
as shown above.
I think this IMO important finding deserves a deeper research... :-)

For the testing method see:
http://en.wikipedia.org/wiki/Binomial_test
http://en.wikipedia.org/wiki/Binomial_distribution
>
What are you using for your sample size and null hypothesis?

H0 = RNG passes the randomness test only at a significance level >1%
ie. try out 1% and 1.001% for example and you will
see it always fails at the <=1% level and always passes at >1% sig level.

Here the details:
Sample size is 500 (ie. calling rand() 500 times),
rnd range is 37 (ie. 0 to 36; yes, a roulette simulation).
Doing the above mentioned StatTest after each rand() call.
The above said is called more than 30 times in a loop,
each time initializing the freq stats anew.
srand(time(0)) done only once at pgmstart.

I think your sample size is too small for such a conclusion to be
statistically valid.

--
/~\ The ASCII
\ / Ribbon Campaign
X Against HTML
/ \ Email!

Remove the ns_ from if replying by e-mail (but keep posts in the
newsgroups if possible).

[joe]

"David Kerber" wrote:

jo*@iamnotathome.org.invalid says:

"joe" wrote:

"David Kerber" wrote:
jo*@iamnotathome.org.invalid says:
>
My experiments show that the random number generator
in Microsoft's VC++6 compiler is a statistical RNG with a
significance level 1.0%.
Statistical testing at SL >1.0% (for example 1.001%) passes the test,
but 1.0% does not pass...
>
Can anybody confirm this finding?
>
The RNG function of the various SW products can be
analyzed and classified better using its significance level
as shown above.
I think this IMO important finding deserves a deeper research... :-)
>
For the testing method see:
http://en.wikipedia.org/wiki/Binomial_test
http://en.wikipedia.org/wiki/Binomial_distribution

What are you using for your sample size and null hypothesis?

H0 = RNG passes the randomness test only at a significance level >1%
ie. try out 1% and 1.001% for example and you will
see it always fails at the <=1% level and always passes at >1% sig level.

Here the details:
Sample size is 500 (ie. calling rand() 500 times),
rnd range is 37 (ie. 0 to 36; yes, a roulette simulation).
Doing the above mentioned StatTest after each rand() call.
The above said is called more than 30 times in a loop,
each time initializing the freq stats anew.
srand(time(0)) done only once at pgmstart.

I think your sample size is too small for such a conclusion to be
statistically valid.

The minimum neccessary is given in these relations
(cf. the above wiki pages and also stats books):

n*p >= 5 AND n*(1-p) >= 5

ie. for the above example:
n >= 5 / (1/37) >= 185
Above we have 500, ie. from 185 to 500 the test can be applied.

[David Kerber]

In article <g5**********@aioe.org>, jo*@iamnotathome.org.invalid says...

"David Kerber" wrote:

jo*@iamnotathome.org.invalid says:

"joe" wrote:
"David Kerber" wrote:
jo*@iamnotathome.org.invalid says:

My experiments show that the random number generator
in Microsoft's VC++6 compiler is a statistical RNG with a
significance level 1.0%.
Statistical testing at SL >1.0% (for example 1.001%) passes the test,
but 1.0% does not pass...

Can anybody confirm this finding?

The RNG function of the various SW products can be
analyzed and classified better using its significance level
as shown above.
I think this IMO important finding deserves a deeper research... :-)

For the testing method see:
http://en.wikipedia.org/wiki/Binomial_test
http://en.wikipedia.org/wiki/Binomial_distribution
>
What are you using for your sample size and null hypothesis?
>
H0 = RNG passes the randomness test only at a significance level >1%
ie. try out 1% and 1.001% for example and you will
see it always fails at the <=1% level and always passes at >1% sig level.
>
Here the details:
Sample size is 500 (ie. calling rand() 500 times),
rnd range is 37 (ie. 0 to 36; yes, a roulette simulation).
Doing the above mentioned StatTest after each rand() call.
The above said is called more than 30 times in a loop,
each time initializing the freq stats anew.
srand(time(0)) done only once at pgmstart.

I think your sample size is too small for such a conclusion to be
statistically valid.

The minimum neccessary is given in these relations
(cf. the above wiki pages and also stats books):

n*p >= 5 AND n*(1-p) >= 5

ie. for the above example:
n >= 5 / (1/37) >= 185
Above we have 500, ie. from 185 to 500 the test can be applied.

But you said you're initializing the frequency stats before each loop
iteration? To me, that would imply that your sample size is really only
36 for each of 30 or so runs. Or am I misunderstanding how you are
accumulating the results?
--
/~\ The ASCII
\ / Ribbon Campaign
X Against HTML
/ \ Email!

Remove the ns_ from if replying by e-mail (but keep posts in the
newsgroups if possible).

[user923005]

On Jul 11, 5:39*am, "joe" <[e-mail]:

My experiments show that the random number generator
in Microsoft's VC++6 compiler is a statistical RNG with a
significance level 1.0%.
Statistical testing at SL >1.0% (for example 1.001%) passes the test,
but 1.0% does not pass...

Can anybody confirm this finding?

The RNG function of the various SW products can be
analyzed and classified better using its significance level
as shown above.
I think this IMO important finding deserves a deeper research... :-)

For the testing method see:http://en.wikipedia.org/wiki/Binomia...l_distribution

I guess that what you really want is the statistics group.
news:sci.stat.math

Follow-up added.

[joe]

"David Kerber" wrote:

jo*@iamnotathome.org.invalid says:

"David Kerber" wrote:

jo*@iamnotathome.org.invalid says:
"joe" wrote:
"David Kerber" wrote:
jo*@iamnotathome.org.invalid says:
>
My experiments show that the random number generator
in Microsoft's VC++6 compiler is a statistical RNG with a
significance level 1.0%.
Statistical testing at SL >1.0% (for example 1.001%) passes the test,
but 1.0% does not pass...
>
Can anybody confirm this finding?
>
The RNG function of the various SW products can be
analyzed and classified better using its significance level
as shown above.
I think this IMO important finding deserves a deeper research... :-)
>
For the testing method see:
http://en.wikipedia.org/wiki/Binomial_test
http://en.wikipedia.org/wiki/Binomial_distribution

What are you using for your sample size and null hypothesis?

H0 = RNG passes the randomness test only at a significance level >1%
ie. try out 1% and 1.001% for example and you will
see it always fails at the <=1% level and always passes at >1% sig level.

Here the details:
Sample size is 500 (ie. calling rand() 500 times),
rnd range is 37 (ie. 0 to 36; yes, a roulette simulation).
Doing the above mentioned StatTest after each rand() call.
The above said is called more than 30 times in a loop,
each time initializing the freq stats anew.
srand(time(0)) done only once at pgmstart.
>
I think your sample size is too small for such a conclusion to be
statistically valid.

The minimum neccessary is given in these relations
(cf. the above wiki pages and also stats books):

n*p >= 5 AND n*(1-p) >= 5

ie. for the above example:
n >= 5 / (1/37) >= 185
Above we have 500, ie. from 185 to 500 the test can be applied.

But you said you're initializing the frequency stats before each loop
iteration? To me, that would imply that your sample size is really only
36 for each of 30 or so runs. Or am I misunderstanding how you are
accumulating the results?

The two loops I used are not that important.
I just simulate 30 days with each day 500 rand's (ie. spins, draws etc.).
At the beginning of each day the frequency stats are cleared.
Ie. the tests are done for intraday stats only.
I hope this makes it clear.

BTW, there is also a parallel discussion on this in sci.math
under the subject "Detecting biased random number generators".

[Jerry Coffin]

In article <g5**********@aioe.org>, jo*@iamnotathome.org.invalid says...

[ ... ]

The two loops I used are not that important.
I just simulate 30 days with each day 500 rand's (ie. spins, draws etc.).
At the beginning of each day the frequency stats are cleared.
Ie. the tests are done for intraday stats only.
I hope this makes it clear.

BTW, there is also a parallel discussion on this in sci.math
under the subject "Detecting biased random number generators".

Out of curiosity, what exact code are you using to get from the original
range of the generator to the 0-35 that you're using?

--
Later,
Jerry.

The universe is a figment of its own imagination.

[joe]

"Jerry Coffin" <jc*****@taeus.comwrote:

jo*@iamnotathome.org.invalid says...

[ ... ]

The two loops I used are not that important.
I just simulate 30 days with each day 500 rand's (ie. spins, draws etc.).
At the beginning of each day the frequency stats are cleared.
Ie. the tests are done for intraday stats only.
I hope this makes it clear.

BTW, there is also a parallel discussion on this in sci.math
under the subject "Detecting biased random number generators".

Out of curiosity, what exact code are you using to get from the original
range of the generator to the 0-35 that you're using?

Jerry, it is 0 to 36.
As recommended in many books (for example Phillip Good
"Permutation, Parametric and Bootstrap Tests of Hypotheses")
I use the following:

int genrand(int lo, int hi)
{
int z = rand() % (hi - lo + 1) + lo;
return z;
}
....
int r = genrand(0, 36);

[Richard Heathfield]

joe said:

<snip>

Pete, can you confirm that then the max possible value
one can get is RAND_MAX - 1, and not RAND_MAX ?

He can't, because it isn't so.

The Standard says that "RAND_MAX [...] expands to an integral constant
expression, the value of which is the maximum value returned by the rand
function".

<snip>

--
Richard Heathfield <http://www.cpax.org.uk>
Email: -http://www. +rjh@
Google users: <http://www.cpax.org.uk/prg/writings/googly.php>
"Usenet is a strange place" - dmr 29 July 1999

[joe]

"Richard Heathfield" <rj*@see.sig.invalidwrote:

>
The Standard says that "RAND_MAX [...] expands to an integral constant
expression, the value of which is the maximum value returned by the rand
function".

My final version:

int genrand(unsigned range)
{ // generates random number between 0 and range-1
// range can be maximally RAND_MAX + 1
// THIS IS THE RECOMMENDED CORRECT METHOD
// (recommended by me and others :-)

if (range < 2)
return 0;
if (range (RAND_MAX + 1))
range = RAND_MAX + 1;
const unsigned maxr = RAND_MAX + 1 - ((RAND_MAX + 1) % range);
unsigned value = maxr;
while (value >= maxr)
value = rand();
return value % range;
}

[Jerry Coffin]

In article <g5**********@aioe.org>, jo*@iamnotathome.org.invalid says...

[ ... ]

Jerry, it is 0 to 36.

Okay -- not that it makes any real difference in terms of the algorithm.

As recommended in many books (for example Phillip Good
"Permutation, Parametric and Bootstrap Tests of Hypotheses")
I use the following:

int genrand(int lo, int hi)
{
int z = rand() % (hi - lo + 1) + lo;
return z;
}
...
int r = genrand(0, 36);

I had a hunch you might be doing it in a manner that was biased, and I
was right. Here's how I do it:

#include <stdlib.h>

int rand_lim(int limit) {
/* return a random number between 0 and limit inclusive.
*/

int divisor = RAND_MAX/(limit+1);
int retval;

do {
retval = rand() / divisor;
} while (retval limit);

return retval;
}

--
Later,
Jerry.

The universe is a figment of its own imagination.

[Pete Becker]

On 2008-07-12 22:59:09 -0400, "joe" <jo*@iamnotathome.org.invalidsaid:

"Richard Heathfield" <rj*@see.sig.invalidwrote:

>>
The Standard says that "RAND_MAX [...] expands to an integral constant
expression, the value of which is the maximum value returned by the rand
function".

My final version:

int genrand(unsigned range)
{ // generates random number between 0 and range-1
// range can be maximally RAND_MAX + 1
// THIS IS THE RECOMMENDED CORRECT METHOD
// (recommended by me and others :-)

if (range < 2)
return 0;
if (range (RAND_MAX + 1))
range = RAND_MAX + 1;

This last step isn't right. If the caller asks for random numbers in a
particular range, either return random numbers in that range or report
an error.

--
Pete
Roundhouse Consulting, Ltd. (www.versatilecoding.com) Author of "The
Standard C++ Library Extensions: a Tutorial and Reference
(www.petebecker.com/tr1book)

[vippstar]

On Jul 13, 2:35 pm, Pete Becker <[e-mail]:

On 2008-07-12 22:59:09 -0400, "joe" <[e-mail]:

"Richard Heathfield" <[e-mail]:

The Standard says that "RAND_MAX [...] expands to an integral constant
expression, the value of which is the maximum value returned by the rand
function".

My final version:

int genrand(unsigned range)
{ // generates random number between 0 and range-1
// range can be maximally RAND_MAX + 1
// THIS IS THE RECOMMENDED CORRECT METHOD
// (recommended by me and others :-)

if (range < 2)
return 0;
if (range (RAND_MAX + 1))
range = RAND_MAX + 1;

This last step isn't right.

<snip>
It's redundant, but not wrong.

[Pete Becker]

On 2008-07-13 09:17:51 -0400, vi******@gmail.com said:

On Jul 13, 2:35 pm, Pete Becker <[e-mail]:

>On 2008-07-12 22:59:09 -0400, "joe" <[e-mail]:

>>"Richard Heathfield" <[e-mail]:

>>>The Standard says that "RAND_MAX [...] expands to an integral constant
expression, the value of which is the maximum value returned by the rand
function".

>>My final version:

>>int genrand(unsigned range)
{ // generates random number between 0 and range-1
// range can be maximally RAND_MAX + 1
// THIS IS THE RECOMMENDED CORRECT METHOD
// (recommended by me and others :-)

>>if (range < 2)
return 0;
if (range (RAND_MAX + 1))
range = RAND_MAX + 1;

This last step isn't right.

<snip>
It's redundant, but not wrong.

How is it redundant? If the caller asks for a range that's larger than
this distribution can handle and this check isn't present, the
algorithm will not return values that cover the requested range.

--
Pete
Roundhouse Consulting, Ltd. (www.versatilecoding.com) Author of "The
Standard C++ Library Extensions: a Tutorial and Reference
(www.petebecker.com/tr1book)

[vippstar]

On Jul 13, 5:04 pm, Pete Becker <[e-mail]:

On 2008-07-13 09:17:51 -0400, [e-mail] said:

On Jul 13, 2:35 pm, Pete Becker <[e-mail]:

On 2008-07-12 22:59:09 -0400, "joe" <[e-mail]:

>"Richard Heathfield" <[e-mail]:

>>The Standard says that "RAND_MAX [...] expands to an integral constant
expression, the value of which is the maximum value returned by the rand
function".

>My final version:

>int genrand(unsigned range)
{ // generates random number between 0 and range-1
// range can be maximally RAND_MAX + 1
// THIS IS THE RECOMMENDED CORRECT METHOD
// (recommended by me and others :-)

>if (range < 2)
return 0;
if (range (RAND_MAX + 1))
range = RAND_MAX + 1;

This last step isn't right.

<snip>
It's redundant, but not wrong.

How is it redundant? If the caller asks for a range that's larger than
this distribution can handle and this check isn't present, the
algorithm will not return values that cover the requested range.

Whether that second if is present or not, the behavior of the
algorithm is the same.

[Pete Becker]

On 2008-07-13 10:11:09 -0400, vi******@gmail.com said:

On Jul 13, 5:04 pm, Pete Becker <[e-mail]:

>On 2008-07-13 09:17:51 -0400, [e-mail] said:

>>On Jul 13, 2:35 pm, Pete Becker <[e-mail]:
On 2008-07-12 22:59:09 -0400, "joe" <[e-mail]:

>>>>"Richard Heathfield" <[e-mail]:

>>>>>The Standard says that "RAND_MAX [...] expands to an integral constant
>expression, the value of which is the maximum value returned by the rand
>function".

>>>>My final version:

>>>>int genrand(unsigned range)
{ // generates random number between 0 and range-1
// range can be maximally RAND_MAX + 1
// THIS IS THE RECOMMENDED CORRECT METHOD
// (recommended by me and others :-)

>>>>if (range < 2)
return 0;
if (range (RAND_MAX + 1))
range = RAND_MAX + 1;

>>>This last step isn't right.
<snip>
It's redundant, but not wrong.

How is it redundant? If the caller asks for a range that's larger than
this distribution can handle and this check isn't present, the
algorithm will not return values that cover the requested range.

Whether that second if is present or not, the behavior of the
algorithm is the same.

It should produce an error. The fact that it doesn't means it's wrong,
not that it's redundant.

--
Pete
Roundhouse Consulting, Ltd. (www.versatilecoding.com) Author of "The
Standard C++ Library Extensions: a Tutorial and Reference
(www.petebecker.com/tr1book)

[vippstar]

On Jul 13, 6:48 pm, Pete Becker <[e-mail]:

On 2008-07-13 10:11:09 -0400, [e-mail] said:

On Jul 13, 5:04 pm, Pete Becker <[e-mail]:

On 2008-07-13 09:17:51 -0400, [e-mail] said:

>On Jul 13, 2:35 pm, Pete Becker <[e-mail]:
On 2008-07-12 22:59:09 -0400, "joe" <[e-mail]:

>>>"Richard Heathfield" <[e-mail]:

>>>>The Standard says that "RAND_MAX [...] expands to an integral constant
expression, the value of which is the maximum value returned by the rand
function".

>>>My final version:

>>>int genrand(unsigned range)
{ // generates random number between 0 and range-1
// range can be maximally RAND_MAX + 1
// THIS IS THE RECOMMENDED CORRECT METHOD
// (recommended by me and others :-)

>>>if (range < 2)
return 0;
if (range (RAND_MAX + 1))
range = RAND_MAX + 1;

>>This last step isn't right.
<snip>
It's redundant, but not wrong.

How is it redundant? If the caller asks for a range that's larger than
this distribution can handle and this check isn't present, the
algorithm will not return values that cover the requested range.

Whether that second if is present or not, the behavior of the
algorithm is the same.

It should produce an error. The fact that it doesn't means it's wrong,
not that it's redundant.

You're wrong.

[Richard Heathfield]

[attribs tidied up a bit, distracting dates/times removed, email addresses
restored - your newsreader (and Pete's) should not have removed them]

vi******@gmail.com said:

Pete Becker wrote:

>vi******@gmail.com said:

Pete Becker wrote:
vi******@gmail.com said:
Pete Becker wrote:
On 2008-07-12 22:59:09 -0400, "joe" <jo*@iamnotathome.org.invalid>
said:

<snip>

>>

>>>>int genrand(unsigned range)
{ // generates random number between 0 and range-1
// range can be maximally RAND_MAX + 1
// THIS IS THE RECOMMENDED CORRECT METHOD
// (recommended by me and others :-)

>>>>if (range < 2)
return 0;
if (range (RAND_MAX + 1))
range = RAND_MAX + 1;

>>>This last step isn't right.
<snip>
It's redundant, but not wrong.

>How is it redundant? If the caller asks for a range that's larger
than this distribution can handle and this check isn't present, the
algorithm will not return values that cover the requested range.
Whether that second if is present or not, the behavior of the
algorithm is the same.

It should produce an error. The fact that it doesn't means it's wrong,
not that it's redundant.

You're wrong.

Pete Becker is an experienced programmer with an excellent track record.
That doesn't automatically make him right, but it does mean that in a
tis-tisnt between him and anonymous-you, the wise reader will give more
weight to him than to you. You may be correct to claim that he is wrong,
but to make the claim without explaining *why* he's wrong is not going to
win the argument for you.

I suggest that you explain exactly what you think Pete Becker is claiming,
and exactly why you think he's wrong, with reference to the Standard. If
you have a point, I'm sure that Pete will be the first to concede it - but
as things stand at present, the ball is in your court, not his.

--
Richard Heathfield <http://www.cpax.org.uk>
Email: -http://www. +rjh@
Google users: <http://www.cpax.org.uk/prg/writings/googly.php>
"Usenet is a strange place" - dmr 29 July 1999

[Walter Roberson]

In article <48**********************************@k13g2000hse. googlegroups.com>,
<vi******@gmail.comwrote:

>On Jul 13, 6:48 pm, Pete Becker <[e-mail]:

>It should produce an error. The fact that it doesn't means it's wrong,
not that it's redundant.

>You're wrong.

"right" or "wrong" in situations like this depend upon the
documented requirements upon the function. I've looked back through the
thread, but I can't seem to find any statement of what *exactly* the
function is supposed to do under which circumstances, so we cannot
say for sure what is "right" or "wrong" code to implement the function.
*Any* code that was standard conforming could be given as an
implementation of the function, and we have no firm grounds upon which to
say that the code is "wrong".

When there are no documented requirements for a function,
perceptions of "right" or "wrong" depend strongly upon
"reasonable expectations" of what the function would do. And it
seems to me that for -most- people, the "reasonable expectation"
of behaviour if the function cannot deliver the request range of
values is some kind of indication that there was a parameter problem.
It is my belief that relatively few people would have the
"reasonable expectation" that the function would instead quietly
deliver only a subset of the requested values. Yes, it is true that
*by chance* a random number generator run for several runs might not
-happen- to generate values greater than a certain value, but as
the number of runs increases, the probability of that happening
becomes statistically small enough that we can reasonably make
judgements about whether the function really is producing a
uniform random distribution.
--
"The beauties of conception are always superior to those of
expression." -- Walter J. Phillips

[James Kanze]

On Jul 13, 5:48 pm, Pete Becker <[e-mail]:

On 2008-07-13 10:11:09 -0400, [e-mail] said:

[...]

How is it redundant? If the caller asks for a range that's
larger than this distribution can handle and this check
isn't present, the algorithm will not return values that
cover the requested range.

Whether that second if is present or not, the behavior of
the algorithm is the same.

It should produce an error. The fact that it doesn't means
it's wrong, not that it's redundant.

From a quality of implementation point of view. Formally, the
contract is to return a number in the given range. The single
statement "return 0;" meets that requirement, and you don't need
all of this extra testing:-).

Of course, the specification did state that the "range can be
maximally RAND_MAX + 1", so normally, I would expect an
assertion failure if my argument wasn't in this range. Or
totally undefined behavior, but not the function arbitrarily
changing my argument.

--
James Kanze (GABI Software) email:ja*********@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[Keith Thompson]

James Kanze <ja*********@gmail.comwrites:
[...]

Of course, the specification did state that the "range can be
maximally RAND_MAX + 1", so normally, I would expect an
assertion failure if my argument wasn't in this range. Or
totally undefined behavior, but not the function arbitrarily
changing my argument.

Surely arbitrarily changing the argument *is* an example of "totally
undefined behavior".

semi-8-)}

--
Keith Thompson (The_Other_Keith) ks***@mib.org <http://www.ghoti.net/~kst>
Nokia
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"

[James Kanze]

On Jul 14, 6:26 pm, Keith Thompson <[e-mail]:

James Kanze <[e-mail]:

[...]

Of course, the specification did state that the "range can be
maximally RAND_MAX + 1", so normally, I would expect an
assertion failure if my argument wasn't in this range. Or
totally undefined behavior, but not the function arbitrarily
changing my argument.

Surely arbitrarily changing the argument *is* an example of "totally
undefined behavior".

When undefined behavior occurs, anything the program does is
correct. But from a quality of implementation point of view, we
don't normally expect it to go out of the way to make things
worse; *IF* the code detects the error, it should treat it as an
error.

--
James Kanze (GABI Software) email:ja*********@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[Keith Thompson]

James Kanze <ja*********@gmail.comwrites:

On Jul 14, 6:26 pm, Keith Thompson <[e-mail]:

>James Kanze <[e-mail]:

>[...]

Of course, the specification did state that the "range can be
maximally RAND_MAX + 1", so normally, I would expect an
assertion failure if my argument wasn't in this range. Or
totally undefined behavior, but not the function arbitrarily
changing my argument.

>Surely arbitrarily changing the argument *is* an example of "totally
undefined behavior".

When undefined behavior occurs, anything the program does is
correct. But from a quality of implementation point of view, we
don't normally expect it to go out of the way to make things
worse; *IF* the code detects the error, it should treat it as an
error.

Certainly.

By snipping the smiley, you've made it appear that I was making a
serious point. I wasn't.

--
Keith Thompson (The_Other_Keith) ks***@mib.org <http://www.ghoti.net/~kst>
Nokia
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"

[James Kanze]

On Jul 15, 5:21 pm, Keith Thompson <[e-mail]:

James Kanze <[e-mail]:

On Jul 14, 6:26 pm, Keith Thompson <[e-mail]:

James Kanze <[e-mail]:

[...]
Of course, the specification did state that the "range can be
maximally RAND_MAX + 1", so normally, I would expect an
assertion failure if my argument wasn't in this range. Or
totally undefined behavior, but not the function arbitrarily
changing my argument.

Surely arbitrarily changing the argument *is* an example of "totally
undefined behavior".

When undefined behavior occurs, anything the program does is
correct. But from a quality of implementation point of view, we
don't normally expect it to go out of the way to make things
worse; *IF* the code detects the error, it should treat it as an
error.

Certainly.

By snipping the smiley, you've made it appear that I was making a
serious point. I wasn't.

Sorry. I missed the smiley. So it looks like we're in violent
agreement.

--
James Kanze (GABI Software) email:ja*********@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]