BorlandTalk.com

LarryJ · Guest

Below are two setups for creating a random number between 1 and 54. Are
these the two setups the same or does the, % 55; have an effect on how the
Rand() function select the number?

Randomize();
while(Num1==0){
Num1 = rand() % 55;
}

Randomize();
while(Num1<1 || Num1>54){
Num1 = rand();
}

Thanks
Larry Johnson

Bruce Salzman · Guest

"LarryJ" <LarryJ33 (AT) austin (DOT) rr.com> wrote in message
news:4576d447$1 (AT) newsgroups (DOT) borland.com...

Alan Bellingham · Guest

"LarryJ" <LarryJ33 (AT) austin (DOT) rr.com> wrote:

Alan Bellingham · Guest

" Bruce Salzman" <bruce (AT) nospam (DOT) org> wrote:

LarryJ · Guest

I am using BCB6.0 and I am looking for a way to generate a true random
number between 1 and 54. I have been disappointed with the results I am
getting from the built in random number generators such as using randomize()
with rand() or random(). When I analyze all the results after running these
functions 100,000 times I am seeing that the results tend to select some
numbers an overwhelming number of times and other numbers almost never.
Theoretically each number should selected a number of times that is close to
the mean. I have been looking for a true random number generation code but
have only found some old code in Basic. Is there any good random number
generation code available in C++?

Thanks
Larry Johnson

Bruce Larrabee · Guest

Hi Larry,

This from 'Numerical Recipes in C':

In C, if you multiply two unsigned long int integers on a machine with a 32-bit
long integer representation, the value returned is the low-order 32 bits of the
true 64-bit product. If we now choose m = 232, the mod in equation (7.1.1)
is free, and we have simply Ij+1 = aIj + c.
Knuth suggests a = 1664525 as a suitable multiplier for this value of m.
H.W. Lewis has conducted extensive tests of this value of a with c = 1013904223,
which is a prime close to (p5 - 2)m. The resulting in-line generator
(we will call it ranqd1) is simply:

unsigned long idum;

idum = 1664525L*idum + 1013904223L;

This is about as good as any 32-bit linear congruential generator,
entirely adequate for many uses. And, with only a single multiply and add,
it is very fast.

To check whether your machine has the desired integer properties, see if you can
generate the following sequence of 32-bit values (given here in hex): 00000000,
3C6EF35F, 47502932, D1CCF6E9, AAF95334, 6252E503, 9F2EC686, 57FE6C2D, A3D95FA8,
81FDBEE7, 94F0AF1A, CBF633B1.

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

I haven't tried this..

But I have used this:

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

#define IA 16807
#define IM 2147483647
#define AM (1.0/IM)
#define IQ 127773
#define IR 2836
#define NTAB 32
#define NDIV (1+(IM-1)/NTAB)
#define EPS 1.2e-7
#define RNMX (1.0-EPS)

Minimal random number generator of Park and Miller with Bays-Durham shuffle
and added safeguards. Returns a uniform random deviate between 0.0 and 1.0
(exclusive of the endpointvalues).
Call with idum a negative integer to initialize; thereafter, do not alter idum
between successive deviates in a sequence. RNMX should approximate the largest
floating value that is less than 1.

float ran1(long *idum)
{
int j;
long k;
static long iy=0;
static long iv[NTAB];
float temp;

if (*idum <= 0 || !iy)
{
// Initialize

if (-(*idum) < 1)
{
*idum=1; Be sure to prevent idum = 0.
}
else
{
*idum = -(*idum);
}

for (j=NTAB+7;j>=0;j--)
{
// Load the shuffle table (after 8 warm-ups).

k=(*idum)/IQ;

*idum=IA*(*idum-k*IQ)-IR*k;

if (*idum < 0)
{
*idum += IM;
}

if (j < NTAB)
{
iv[j] = *idum;
}
}

iy=iv[0];
}

k=(*idum)/IQ; // Start here when not initializing.

// Compute idum=(IA*idum) % IM without overflows
// by Schrage's method.

*idum=IA*(*idum-k*IQ)-IR*k;

if (*idum < 0)
{
*idum += IM;
}

j=iy/NDIV; // Will be in the range 0..NTAB-1.

// Output previously stored value and refill the
// suffle table.

iy=iv[j];

iv[j] = *idum;

if ((temp=AM*iy) > RNMX)
{
return RNMX;
}
else
{
return temp;
}
}

HTH,

Bruce

Richard Kavanagh · Guest

This is one of many.
Richard

long FSeed = 17; // pick a big number. prime might be good idea. run
tests.
long Rand()
{
// m = 2147483647 = 2^31 - 1; a = 16807;
// 127773 = m div a; 2836 = m mod a

long hi = FSeed / 127773L; // integer division
long lo = FSeed - hi * 127773L; // modulo
FSeed = 16807 * lo - 2836 * hi;
if (FSeed <= 0)
FSeed += 2147483647L;
return FSeed;
}

Thorsten Kettner · Guest

"LarryJ" <LarryJ33 (AT) austin (DOT) rr.com> wrote: