asked on

Help with random seed

I have a template class called RandomAtom which generates either a random lowercase letter or a random digit. In my main program I have defined a function called RandomItem. It is overloaded to produce either a random string of some parameterized length, or a random number of some paramaterized length. It uses my RandomAtom function. The problem is this: I don't know where to set the seed of the RandomAtom class so I can generate lets say 10 distinct strings or numbers. Someone told me to set the random seed in main, then make the RandomAtom object a parameter of my RandomItem function. I tried this and it generated the same string/number. Here is my code:

int randomItem(int len, RandomAtom<int> atom)
{
int thisDigit = 0;
int retVal = 0;
while (thisDigit == 0) thisDigit = atom.randomIntChar(); // first digit cannot be zero
while (len--)
{
retVal *= 10;
retVal += thisDigit;
thisDigit = atom.randomIntChar();
}
return retVal;
}

char* randomItem(int len, RandomAtom<char> atom)
{
char *retVal = new char[len + 1]; // new string
retVal[len] = '\0';
while (len--) {
retVal[len] = atom.randomIntChar(); // fill it backwards
}
return retVal;
}

int main()
{

RandomAtom<int> atom(GetTickCount());

for(int i = 0; i < 10; i++)
{
cout << randomItem(3, atom) << endl;
}
return 0;
}

This code generates the same 3 digit number 10 times.
Example usage of the class RandomAtom:
RandomAtom<int> atom(seed);
atom.randomIntChar(); // generate a random digit

Can someone help me find my error? Thanks.

imladris

I think it would help if you showed the implementation of the RandomAtom object.

nidan

ASKER

// File: RandomAtom.h

#ifndef _RandomAtom_H_
#define _RandomAtom_H_

#include "randInt.h" // defines M
#include <windows.h>

static const char* charAlphabet = "abcdefghijklmnopqrstuvwxyz";
static const int charModBase = 26;
static const int intModBase = 10;

template <class T>
class RandomAtom
{
public:
explicit RandomAtom(int seed = 1);
/* ...................................................
Purpose : Constructor. Sets the seed
Restrictions : Should only be used with char
and int
Input : An integer for the seed
Description : RandomAtom is the constructor for
a template class which is specialized
for int and char. It generates a
random digit or lowercase letter.
Example Usage: RandomAtom<int> atom();
RandomAtom<char> atom();
................................................... */

T randomIntChar();
/* ...................................................
Purpose : To generate a random digit or
lowercase letter
Restrictions : Should only be used
with the int and char data types
Output : A random digit or int
Description : A member function which generates
either a random digit or random
lowercase letter
Example Usage: int i = atom.randomIntChar();
char c = atom.randomIntChar();
................................................... */

private:
int state; // holds the seed
};

// Note: I had to place the implementation in this file
// because the compiler didn't allow a separate
// implementation file.

template <class T>
RandomAtom<T>::RandomAtom(int seed)
{
if(seed < 0)
seed += M;

state = seed;

if(state == 0)
state = 1;
}

template <class T>
T RandomAtom<T>::randomIntChar()
{
state = nextRand(state);
return (T)state;
}

// The specialized versions:
// char
template <>
class RandomAtom<char>
{
public:
explicit RandomAtom(int seed = 1);
T randomIntChar();
private:
int state;
};

template <>
RandomAtom<char>::RandomAtom(int seed)
{
if(seed < 0)
seed += M;

state = seed;

if(state == 0)
state = 1;
}

template <>
char RandomAtom<char>::randomIntChar()
{
state = nextRand(state);
return charAlphabet[state % charModBase]; // return a lowercase letter from charAlphabet
}

// int
template <>
class RandomAtom<int>
{
public:
explicit RandomAtom(int seed = 1);
T randomIntChar();
private:
int state;
};

template <>
RandomAtom<int>::RandomAtom(int seed)
{
if(seed < 0)
seed += M;

state = seed;

if(state == 0)
state = 1;
}

template <>
int RandomAtom<int>::randomIntChar()
{
state = nextRand(state);
return state % intModBase; // return a digit
}

#endif
----------------------------------------------------------
// File: randInt.h

#ifndef _randInt_H_
#define _randInt_H_

const int A = 48271;
const int M = 2147483647;
const int Q = M / A;
const int R = M % A;

int nextRand(int lastState);

#endif

------------------------------------------------------
// File: randInt.cpp

#include "randInt.h"

int nextRand(int lastState)
{
int tmpState = A * (lastState % Q) - R * (lastState / Q);

if(tmpState >= 0)
return tmpState;
else
return tmpState + M;
}

imladris

Ah, no. Perhaps it had nothing to do with RandomAtom after all (I couldn't see any problem with it anyway).

I think the problem is with GetTickCount. GetTickCount returns a DWORD. If that is larger than an int, in your environment, you will wind up getting the bottom bytes as the seed, and, on a little-endian PC, those are the most significant bytes, and so won't change much.

nidan

ASKER