How do I seed this Mersenne Twister?

Quote: Ahigh

You need to fix when code converts subscripts to arrays with an index of i to an italic BBcode.

Quote:

init_genrand(seed) initializes the state vector by using
one unsigned 32-bit integer "seed", which may be zero.

init_by_array(init_key, key_length) initializes the state vector
by using an array init_key[] of unsigned 32-bit integers
of length key_kength. If key_length is smaller than 624,
then each array of 32-bit integers gives distinct initial
state vector. This is useful if you want a larger seed space
than 32-bit word.

Quote: Wizard

Thanks! I am not that picky. Would it suffice to seed to capture the time at the start of the program, and keep reseeding with that same time?

Quote: MathExtremist

System time in milliseconds is often used for a seed, but why reseed often? The period of the MT is 2^19937-1...

Quote: Wizard

Thanks! That occurred to me after I posted. That paper was a bit over my head.

Quote: Ahigh

I believe, though, if you have a good enough random number generator, the simplest shuffle is:

for( i=0; i<ncards; i++ )
{
random_card = unshuffled_deck( random_index( ncards - i ) );
shuffled_deck += random_card;
unshuffled_deck -= random_card;
}

Quote: AcesAndEights

The random bits come from atmospheric noise, which is better than any PRNG. Read more at the homepage of random.org.

Quote: wudged

Have you ever tried writing something to simulate an actual shuffle?

Quote: Wizard

I'm not saying this is optimal or unbiased, but I run through the deck hundreds of times swapping the cards in two random positions.

Quote: Ahigh

You need to shuffle each card at least once, IMO. How many swaps between two random cards are required to make sure each card gets shuffled?

Quote: Wizard

No number will guarantee every card gets touched. However, if you do 416 swaps, for example, every card should get swapped twice on average. About 13.5% of cards still won't get swapped. However, that doesn't contaminate the shoe. In baccarat, it is groups of cards that count. If I were programming this for real money wagers I would do a lot more swaps, to avoid player's detecting and exploiting anything. However, for my purposes, I think this technique is sufficient.

Quote: thecesspit

AHigh, see :

http://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle

You only need to pass once through the deck, swapping two cards at a time to end up with a random shuffle. It also does it in place, which is memory efficient, if such a thing matters. The trick is to avoid the newbie mistake and end up with a cyclic shuffle (Sattolo's algorithm).

Quote: Ahigh

I think efficiency always matters. Both memory and CPU. You just want to get the job done as efficiently as possible providing that it is done properly.
Swapping two random indices just seems wrong to me intuitively.

Quote:

I only read briefly the wiki entry, but it appears that it also step incrementally through one index swapping with another random index.

Quote:

I am not an expert here, though, nor am I research on shuffle algorithms. I would trust Knuth on the subject, for sure.

Quote: Wizard

I it would take me ages to figure out how to grab the numbers from that web site into my program. My own Mersenne Twister has passed every test of randomness I've thrown at it.

Quote: Wizard

This is a little off topic, but speaks to the topic of finding the n-th element in an array with lots of gaps in it. For example, I have an array of 416 cards, but half the positions are blank, and I want to grab the 123rd non-blank position. It would be easy to code, but time consuming for the computer, to parse through the array, counting the cards.

My question is, does the computer do this anyway? For example, if you want the 123rd element in a full array, can the computer jump right to that position, or does it start at the beginning and take 122 more steps until it gets to the element requested?

To phrase it yet another way, when you declare an array, are the locations in the computer's memory sequential, or do they jump around? Dealing with pointers, I would tend to think they are sequential, but I don't trust myself to be right on that one.

Quote: Wizard

To phrase it yet another way, when you declare an array, are the locations in the computer's memory sequential, or do they jump around? Dealing with pointers, I would tend to think they are sequential, but I don't trust myself to be right on that one.

Quote: Ibeatyouraces

All this for the silly bac trenders?

Quote: Wizard

Do the advanced programmers on the forum approve of this Fisher-Yates shuffle I just wrote:

void fisher_yates(int deck[], int NumCards)
{
	int i,j,NewDeck[416];
	unsigned int rn;
	for (i=0; i<NumCards; i++)
	{
		rn=genrand_int32()%(NumCards-i);
		NewDeck[i]=deck[rn];
		for (j=rn; j<NumCards-1; j++)
			deck[j]=deck[j+1];
	}
	for (i=0; i<NumCards; i++)
		deck[i]=NewDeck[i];
}

Quote: Ibeatyouraces

All this for the silly bac trenders?

Quote: Wizard

Do the advanced programmers on the forum approve of this Fisher-Yates shuffle I just wrote. As you can see, after it pulls out the card in the rn-th place in the old deck it slides everything after it one position, to keep the old deck sequential and without gaps.

void fisher_yates(int deck[], int NumCards)
{
	int i,j,NewDeck[416];
	unsigned int rn;
	for (i=0; i<NumCards; i++)
	{
		rn=genrand_int32()%(NumCards-i);
		NewDeck[i]=deck[rn];
		for (j=rn; j<NumCards-1; j++)
			deck[j]=deck[j+1];
	}
	for (i=0; i<NumCards; i++)
		deck[i]=NewDeck[i];
}

Quote: Wizard

response to thecesspit

I disagree. If the first random number is 0, the first card in the shuffled deck will be the first card from the original deck.

Quote: wudged

It's been a while since I've used C++, but can't you initialize the NewDeck array using NumCards instead of 416?

void fisher_yates(int deck[], int NumCards)
{
	int i,j,random_card;
	unsigned int rn;
	for (i=NumCards-1; i>=0; i--)
	{
		rn=genrand_int32()%(i+1);
		random_card=deck[rn];
		for (j=rn; j<i-1; j++)
			deck[j]=deck[j+1];
		deck[i]=random_card;
	}
}

Quote: Wizard

Visual Studio doesn't let you. I tried. Seems that it should. I just know I'm going to get an array error when I use this code later for a bigger array.

Quote: Wizard

Thanks JB for your comments. The only thing I have a hard time with is waiting for the random number to be in the desired range. That could take a while, as they are drawn from 0 to 2^32-1. I know computer are fast these days, but I can remember the punch card days.

Quote: Wizard

Given this large cycle, I think taking the mod of a number as big as 4,294,967,295, would result in a very negligible bias. Perhaps that is the answer to ME's question.

Quote: Wizard

Here is my new and improved code, per your other suggestions.

Quote: wudged

		max = floor(4294967295 % (i + 1)) * (i + 1);
        	do
	        {
	            rn = genrand_int32();
	        }
	        while ((rn < 0) || (rn >= max));

This will strip off only the bias part and not spend "hours" trying to find a valid random number that avoids the bias

Quote: JB

In the for loop initializer, the middle condition should be i > 0 (not i >= 0). Also, moving cards about the array is unnecessary and slows down the function. Just swap the array values located in positions i and random_card.

void fisher_yates(int deck[], int NumCards)
{
	int i,hold;
	unsigned int rn;
	for (i=NumCards-1; i>0; i--)
	{
		rn=genrand_int32()%(i+1);
		hold=deck[rn];
		deck[rn]=deck[i];
		deck[i]=hold;
	}
}

Quote: Wizard

You're right, that does seem to work just as well, and I don't have to bother with the card slide. Thank you.

However, I think worrying about the bias over taking the mod of 2³² is rather ridiculous for practical purposes. I'm not saying discussion about it isn't worthy, but I don't want to slow down the program over it.

Quote: GLI Standard #11, 3.3.10 Scaling Algorithms

a) If a random number with a range shorter than that provided by the RNG is required for some purpose within the gaming device, the method of re-scaling, (i.e., converting the number to the lower range), is to be designed in such a way that all numbers within the lower range are equally probable.
b) If a particular random number selected is outside the range of equal distribution of re-scaling values, it is permissible to discard that random number and select the next in sequence for the purpose of re-scaling.

Quote: MathExtremist

The slowdown would be minimal since you'd only need to redraw once every 16.8M tries.

Quote:

subitem (b) is exactly what we're talking about.

Quote: Wizard

However, I'm not drawing a random number that is going to determine a real money outcome of a bet, but a simulation of something with billions of trials

Quote: DRich

BTW, why can't I see a way to delete a post?

Quote: DRich

nevermind, this was already said.

BTW, why can't I see a way to delete a post?

Quote: RaleighCraps

Just EDIT it, and remove all of your text.......