The 2+2 Forum Archives: 7 Card Hand Evaluators

Well, Results are in:

BAD!! = 0
High Card = 23294460
Pair = 58627800
Two Pair = 31433400
Three of a Kind = 6461620
Straight = 6180020
Flush = 4047644
Full House = 3473184
Four of a Kind = 224848
Straight Flush = 41584
Total Hands = 133784560

Validation seconds = 0.5620
Total HighPrecision Clocks = 1127079718
HighPrecision clocks per lookup = 8.424587

This uses Cactus Kev's Eval Routine ref http://www.suffecool.net/poker/evaluator.html
Which I moved Paul D. Senzee's Optimized Hand Evaluator
ref http://www.geocities.com/psenzee/code/fast_eval.c
eval_5hand_fast(int c1, int c2, int c3, int c4, int c5)
routine into Cactus Kevs eval_5hand routine.

You will need to add the routines in PokerLib.c to poker.h file.

Here is the main code which I called HandRankSetup.cpp:
Code:

  
// HandRankSetup.cpp : Sets up the HandRank File for VERY fast Lookups
// by Ray Wotton and the 2+2 list  My code is GPL, use it as you like

#include "stdafx.h"
#include "windows.h"
#include "poker.h"
#include <stdlib.h>
#include <string.h>
#include <time.h>

const char HandRanks[][16] = {"BAD!!","High Card","Pair","Two Pair","Three of a Kind","Straight","Flush","Full House","Four of a Kind","Straight Flush"};

__int64 IDs[612978];
int HR[32487834];   

int numIDs = 1;
int numcards = 0;
int maxHR = 0;
__int64 maxID = 0;

__int64 MakeID(__int64 IDin, int newcard)  // adding a new card to this ID
{
	__int64 ID = 0;
	int suitcount[4 + 1];
	int rankcount[13 + 1];
	int workcards[8];  // intentially keeping one as a 0 end
	int cardnum;
	int getout = 0;
	
	memset(workcards, 0, sizeof(workcards));
	memset(rankcount, 0, sizeof(rankcount));
	memset(suitcount, 0, sizeof(suitcount));
	
	for (cardnum = 0; cardnum < 6; cardnum++) {  // can't have more than 6 cards!
		workcards[cardnum + 1] =  (int) ((IDin >> (8 * cardnum)) & 0xff);  // leave the 0 hole for new card
	}

	// my cards are 2c = 1, 2d = 2  ... As = 52
	newcard--;  // make 0 based!

	workcards[0] = (((newcard >> 2) + 1) << 4) + (newcard & 3) + 1;  // add next card formats card to rrrr00ss

	for (numcards = 0; workcards[numcards]; numcards++) {
		suitcount[workcards[numcards] & 0xf]++;           // need to see if suit is significant
		rankcount[(workcards[numcards] >> 4) & 0xf]++;	  // and rank to be sure we don't have 4!
		if (numcards) {
			if (workcards[0] == workcards[numcards]) {	  // can't have the same card twice
				getout = 1;								  // if so need to get out after counting numcards
			}
		}
	}

	if (getout) {
		return 0;     // duplicated another card (ignore this one)    
	}

	
	int needsuited = numcards - 2;	   // for suit to be significant - need to have n-2 of same suit
	     
	if (numcards > 4) {  
		for (int rank = 1; rank < 14; rank++) {
			if (rankcount[rank] > 4) {  // if I have more than 4 of a rank then I shouldn't do this one!!
				return 0;   // can't have more than 4 of a rank so return an ID that can't be!
			}
		}
	}
	
	// However in the ID process I prefered that
	// 2s = 0x21, 3s = 0x31,.... Kc = 0xD4, Ac = 0xE4
	// This allows me to sort in Rank then Suit order
	
	// if we don't have at least 2 cards of the same suit for 4, we make this card suit 0.
	
	if (needsuited > 1) { 
		for (cardnum = 0; cardnum < numcards; cardnum++) {  // for each card
			if (suitcount[workcards[cardnum] & 0xf] < needsuited) {	// check suitcount to the number I need to have suits significant
				workcards[cardnum] &= 0xf0;   // if not enough - 0 out the suit - now this suit would be a 0 vs 1-4
			}
		}
	}

	// Sort Using XOR.  Network for N=7, using Bose-Nelson Algorithm: Thanks to the thread!
#define SWAP(I,J) {if (workcards[I] < workcards[J]) {workcards[I]^=workcards[J]; workcards[J]^=workcards[I]; workcards[I]^=workcards[J];}}		

	SWAP(0, 4);		
	SWAP(1, 5);		
	SWAP(2, 6);		
	SWAP(0, 2);		
	SWAP(1, 3);		
	SWAP(4, 6);		
	SWAP(2, 4);		
	SWAP(3, 5);		
	SWAP(0, 1);		
	SWAP(2, 3);		
	SWAP(4, 5);		
	SWAP(1, 4);		
	SWAP(3, 6);		
	SWAP(1, 2);		
	SWAP(3, 4);		
	SWAP(5, 6);	

	// long winded way to put the pieces into a __int64 
	// cards in bytes --66554433221100	 
	// the resulting ID is a 64 bit value with each card represented by 8 bits.
	ID =  (__int64) workcards[0] +
		 ((__int64) workcards[1] << 8) +
		 ((__int64) workcards[2] << 16) + 
		 ((__int64) workcards[3] << 24) +
		 ((__int64) workcards[4] << 32) +
		 ((__int64) workcards[5] << 40) +
		 ((__int64) workcards[6] << 48);    
	
	return ID;
}

int SaveID(__int64 ID) 
{
	if (ID == 0) return 0;   // don't use up a record for a 0!

	if (ID >= maxID) {           // take care of the most likely first goes on the end...
		if (ID > maxID) {        // greater than create new else it was the last one!
			IDs[numIDs++] = ID;  // add the new ID
			maxID = ID;
		}
		return numIDs - 1;
	}

	// find the slot I will find it (by a pseudo bsearch algorithm)
	int low = 0;
	int high = numIDs - 1;
	__int64 testval;
	int holdtest;

	while (high - low > 1) {
		holdtest = (high + low + 1) / 2;
		testval = IDs[holdtest] - ID;
		if (testval > 0) high = holdtest;
		else if (testval < 0) low = holdtest;
		else return holdtest;   // got it!!
	}
	// I guess it couldn't be found so must be added to the current location (high)
	// make space...  // don't expect this much!
	memmove(&IDs[high + 1], &IDs[high], (numIDs - high) * sizeof(IDs[0]));  

	IDs[high] = ID;   // do the insert into the hole created
	numIDs++;        
	return high;
}

int DoEval(__int64 IDin)
{
	// I guess I have some explaining to do here...  I used the Cactus Kevs Eval ref http://www.suffecool.net/poker/evaluator.html
	// I Love the pokersource for speed, but I needed to do some tweaking to get it my way
	// and Cactus Kevs stuff was easy to tweak ;-)  
	int handrank = 0;
	int cardnum;
	int workcard;
	int rank;
	int suit;
	int mainsuit = 20;      // just something that will never hit...  need to eliminate the main suit from the iterator
	int suititerator = 0;
	int holdrank;
	int workcards[8];  // intentially keeping one as a 0 end
	int holdcards[8];
	int numevalcards = 0;

	// See Cactus Kevs page for explainations for this type of stuff...
	const int primes[] = { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41 };
	
	memset(workcards, 0, sizeof(workcards));
	memset(holdcards, 0, sizeof(holdcards));

	if (IDin) {	 // if I have a good ID then do it...
		for (cardnum = 0; cardnum < 7; cardnum++) {  // convert all 7 cards (0s are ok)
			holdcards[cardnum] =  (int) ((IDin >> (8 * cardnum)) & 0xff); 
			if (holdcards[cardnum] == 0) break;	// once I hit a 0 I know I am done
			numevalcards++;						// if not 0 then count the card
			if (suit = holdcards[cardnum] & 0xf) {	// find out what suit (if any) was significant
				mainsuit = suit;					// and remember it
			}
		}


		for (cardnum = 0; cardnum < numevalcards; cardnum++) {  // just have numcards...
			workcard = holdcards[cardnum];

			// convert to cactus kevs way!!  ref http://www.suffecool.net/poker/evaluator.html
			//   +--------+--------+--------+--------+
			//   |xxxbbbbb|bbbbbbbb|cdhsrrrr|xxpppppp|
			//   +--------+--------+--------+--------+
			//   p = prime number of rank (deuce=2,trey=3,four=5,five=7,...,ace=41)
			//   r = rank of card (deuce=0,trey=1,four=2,five=3,...,ace=12)
			//   cdhs = suit of card
			//   b = bit turned on depending on rank of card

			rank = (workcard >> 4) - 1;	 // my rank is top 4 bits 1-13 so convert
			suit = workcard & 0xf;  // my suit is bottom 4 bits 1-4, order is different, but who cares?  
			if (suit == 0) {		// if suit wasn't significant though...
				suit = suititerator++;   // Cactus Kev needs a suit!
				if (suititerator == 5)	 // loop through available suits
					suititerator = 1;
				if (suit == mainsuit) {   // if it was the sigificant suit...  Don't want extras!!
					suit = suititerator++;    // skip it
					if (suititerator == 5)	  // roll 1-4
						suititerator = 1;
				}
			}
			// now make Cactus Keys Card
			workcards[cardnum] = primes[rank] | (rank << 8) | (1 << (suit + 11)) | (1 << (16 + rank));
		}

		switch (numevalcards) {  // run Cactus Keys routines
			case 5 :  holdrank = eval_5cards(workcards[0],workcards[1],workcards[2],workcards[3],workcards[4]);
				      break;
					  // if 6 cards I would like to find HandRank for them 
					  // Cactus Key is 1 = highest - 7362 lowest I need to get the min for the permutations
			case 6 :  holdrank = eval_5cards(workcards[0],workcards[1],workcards[2],workcards[3],workcards[4]);
				      holdrank = __min(holdrank, eval_5cards(workcards[0],workcards[1],workcards[2],workcards[3],workcards[5]));
				      holdrank = __min(holdrank, eval_5cards(workcards[0],workcards[1],workcards[2],workcards[4],workcards[5]));
				      holdrank = __min(holdrank, eval_5cards(workcards[0],workcards[1],workcards[3],workcards[4],workcards[5]));
				      holdrank = __min(holdrank, eval_5cards(workcards[0],workcards[2],workcards[3],workcards[4],workcards[5]));
				      holdrank = __min(holdrank, eval_5cards(workcards[1],workcards[2],workcards[3],workcards[4],workcards[5]));
					  break;
			case 7 : holdrank = eval_7hand(workcards);  
				     break;
			default : // problem!!  shouldn't hit this... 
				      printf("    Problem with numcards = %d!!\n", numcards);
					  break;
		}

// I would like to change the format of Catus Kev's ret value to:
		// hhhhrrrrrrrrrrrr   hhhh = 1 high card -> 9 straight flush
		//                    r..r = rank within the above	1 to max of 2861
		handrank = 7463 - holdrank;  // now the worst hand = 1
		
		if      (handrank < 1278) handrank = handrank -    0 + 4096 * 1;  // 1277 high card
		else if (handrank < 4138) handrank = handrank - 1277 + 4096 * 2;  // 2860 one pair
		else if (handrank < 4996) handrank = handrank - 4137 + 4096 * 3;  //  858 two pair
		else if (handrank < 5854) handrank = handrank - 4995 + 4096 * 4;  //  858 three-kind
		else if (handrank < 5864) handrank = handrank - 5853 + 4096 * 5;  //   10 straights
		else if (handrank < 7141) handrank = handrank - 5863 + 4096 * 6;  // 1277 flushes
		else if (handrank < 7297) handrank = handrank - 7140 + 4096 * 7;  //  156 full house
		else if (handrank < 7453) handrank = handrank - 7296 + 4096 * 8;  //  156 four-kind
		else                      handrank = handrank - 7452 + 4096 * 9;  //   10 straight-flushes

	}
	return handrank;  // now a handrank that I like
}


int _tmain(int argc, _TCHAR* argv[])
{
	int count = 0;
	int card;

	__int64 ID;
	int IDslot;

	clock_t timer = clock();   // remember when I started

	int handTypeSum[10];
	
	memset(handTypeSum, 0, sizeof(handTypeSum));  // init
	memset(IDs, 0, sizeof(IDs));
	memset(HR, 0, sizeof(HR));


  // step through the ID array - always shifting the current ID and adding 52 cards to the end of the array.
	// when I am at 7 cards put the Hand Rank in!!  
	// stepping through the ID array is perfect!!
	
    int IDnum;
	int holdid;

	printf("\nGetting Card IDs!\n");
	// as this loops through and find new combinations it adds them to the end
	// I need this list to be stable when I set the handranks (next set)  (I do the insertion sort on new IDs these)
	// so I had to get the IDs first and then set the handranks
	for (IDnum = 0; IDs[IDnum] || IDnum == 0; IDnum++) {  // start at 1 so I have a zero catching entry (just in case)
		for (card = 1; card < 53; card++) {	 // the ids above contain cards upto the current card.  Now add a new card 
			ID = MakeID(IDs[IDnum], card);   // get the new ID for it
			if (numcards < 7) holdid = SaveID(ID);   // and save it in the list if I am not on the 7th card
		}
		printf("\rID - %d", IDnum);	  // just to show the progress -- this will count up to  612976
	}
	
	printf("\nSetting HandRanks!\n");
	// this is as above, but will not be adding anything to the ID list, so it is stable
	for (IDnum = 0; IDs[IDnum] || IDnum == 0; IDnum++) {  // start at 1 so I have a zero catching entry (just in case)
		for (card = 1; card < 53; card++) {
			ID = MakeID(IDs[IDnum], card);
			if (numcards < 7)  IDslot = SaveID(ID) * 53 + 53;  // when in the index mode (< 7 cards) get the id to save
			else IDslot = DoEval(ID);   // if I am at the 7th card, get the HandRank to save
			maxHR = IDnum * 53 + card + 53;	// find where to put it 
			HR[maxHR] = IDslot;				// and save the pointer to the next card or the handrank
		}

		if (numcards == 6 || numcards == 7) {  
			// an extra, If you want to know what the handrank when there is 5 or 6 cards
			// you can just do HR[u3] or HR[u4] from below code for Handrank of the 5 or 6 card hand
			HR[IDnum * 53 + 53] = DoEval(IDs[IDnum]);  // this puts the above handrank into the array  
		}
		printf("\rID - %d", IDnum);	  // just to show the progress -- this will count up to  612976 same as above!
	}

	printf("\nNumber IDs = %d\nmaxHR = %d\n", numIDs, maxHR);  // for warm fuzzys

	timer = clock() - timer;  // end the timer
	
	printf("Training seconds = %.2f\n", (float)timer/CLOCKS_PER_SEC);  // display training time

	LARGE_INTEGER timings, endtimings;	// for high precision timing

	timer = clock();   // now get current time for Testing!  

	// another algorithm right off the thread

	int c0, c1, c2, c3, c4, c5, c6;
	int u0, u1, u2, u3, u4, u5;

	QueryPerformanceCounter(&timings);				    // start High Precision clock

	for (c0 = 1; c0 < 53; c0++) {
		u0 = HR[53+c0];
		for (c1 = c0+1; c1 < 53; c1++) {
			u1 = HR[u0+c1];
			for (c2 = c1+1; c2 < 53; c2++) {
				u2 = HR[u1+c2];
				for (c3 = c2+1; c3 < 53; c3++) {
					u3 = HR[u2+c3];
					for (c4 = c3+1; c4 < 53; c4++) {
						u4 = HR[u3+c4];
						for (c5 = c4+1; c5 < 53; c5++) {
							u5 = HR[u4+c5];
							for (c6 = c5+1; c6 < 53; c6++) {
								handTypeSum[HR[u5+c6] >> 12]++;
								count++;
							}
						}
					}
				}
			}
		}
	}
	
	QueryPerformanceCounter(&endtimings);	  // end the high precision clock

	timer = clock() - timer;  // get the time in this

	for (int i = 0; i <= 9; i++)  // display the results
		printf("\n%16s = %d", HandRanks[i], handTypeSum[i]);
	
	printf("\nTotal Hands = %d\n", count);
	
	__int64 clocksused = (__int64)endtimings.QuadPart - (__int64) timings.QuadPart;  // calc clocks used from the High Precision clock

	// and display the clock results
	printf("\nValidation seconds = %.4lf\nTotal HighPrecision Clocks = %I64d\nHighPrecision clocks per lookup = %lf\n", (double)timer/CLOCKS_PER_SEC, clocksused, (double) clocksused /  133784560.0) ;

	// output the array now that I have it!!
	FILE * fout = fopen("HandRanks.dat", "wb");
	if (!fout) {
		printf("Problem creating the Output File!\n");
		return 1;
	}
	fwrite(HR, sizeof(HR), 1, fout);  // big write, but quick
	
	fclose(fout);

	return 0;
}

///////////////////////////////// end code!!

Wow!! I don't give any promises, but I verified it to the best of my ability over the last few days... As I said earlier, with the setups mentioned above, you will run the setup in about a minute, and poker hands (hand card order doesn't make any difference by the way!!) VERY quickly!!

Any questions let me know...
As I mentioned in the code, my stuff can all be GPL'd.
pygmyhipo, you guys with the pokersource are absolutely incredible what you can do!! Whenever I had a general purpose evaluator to do, that is what I used! I know I should have used the pokersource for the evaluator for this, but perhaps you could rewrite the DoEval section to stub out the pokersource lib... This was a thread project, and it works GREAT!!

Have a Profitable Day...
Ray...

I last visited these forums quite a few months ago. After reading a few of the ideas here I began coding my own evaluator in Java. It was based upon the tabled lookup ideas from the forum. After returning here a little while ago I was amazed at the amount of progress that had been made. Though my algorithm was quite similar to some of the ones presented here it was not nearly as fast by almost a factor of two. In any case, after looking at some of the code I have made some improvements. There was some some unnecessary code in various places. For instance, the "suit iterator" part of Ray's C code was not necessary. It is fine (and also semantically correct) to leave the undefined suit with a value of zero. The bitwise ANDs used in Cactus Kev's evaluator take care of that case. The other changes are apparent upon inspection. In any case, here is a trimmed and somewhat optimized Java version. I placed the Flushes, etc. lookup tables in static arrays in their own wrapper classes. Java's constructor size limitation forced this.
Code:


public class Evaluator {
	
	/* Card to integer conversions:
    
	2c =  1    2d = 14    2h = 27    2s = 40
	3c =  2    3d = 15    3h = 28    3s = 41
	4c =  3    4d = 16    4h = 29    4s = 42
	5c =  4    5d = 17    5h = 30    5s = 43
	6c =  5    6d = 18    6h = 31    6s = 44
	7c =  6    7d = 19    7h = 32    7s = 45
	8c =  7    8d = 20    8h = 33    8s = 46
	9c =  8    9d = 21    9h = 34    9s = 47
	Tc =  9    Td = 22    Th = 35    Ts = 48
	Jc = 10    Jd = 23    Jh = 36    Js = 49
	Qc = 11    Qd = 24    Qh = 37    Qs = 50
	Kc = 12    Kd = 25    Kh = 38    Ks = 51
	Ac = 13    Ad = 26    Ah = 39    As = 52

	*/

	public final static int NO_SUIT  = 0;
	public final static int CLUBS    = 1;
	public final static int DIAMONDS = 2;
	public final static int HEARTS   = 3;
	public final static int SPADES   = 4;

	public final static int BAD_CARD = -1;
	public final static int DEUCE    = 2;
	public final static int THREE    = 3;
	public final static int FOUR     = 4;
	public final static int FIVE     = 5;
	public final static int SIX      = 6;
	public final static int SEVEN    = 7;
	public final static int EIGHT    = 8;
	public final static int NINE     = 9;
	public final static int TEN      = 10;
	public final static int JACK     = 11;
	public final static int QUEEN    = 12;
	public final static int KING     = 13;
	public final static int ACE      = 14;

	public final static int NUM_SUITS = 4;
	public final static int NUM_RANKS = 13;
	public final static int NUM_CARDS = 52;
	
	public static int[]   handRanks = new int[32487834];        // array to hold hand rank lookup table
	public static boolean verbose   = true;						// toggles verbose mode
	
	private static int[]  hand; 								// re-usable array to hold cards in a hand
	private static long[] keys             = new long[612978];	// array to hold key lookup table
	private static int    numKeys          = 1;					// counter for number of defined keys in key array
	private static long   maxKey           = 0;					// holds current maximum key value
	private static int    numCards         = 0;					// re-usable counter for number of cards in a hand
	private static int    cardIndex        = 0;					// re-usable index for cards in a hands
	private static int    maxHandRankIndex = 0;
	
	private static long   startTimer;
	private static long   stopTimer;
	
	
	// Inserts a key into the key array and returns the insertion index. 
	public static int insertKey(long key) {
		
		// check to see if key is valid
		if (key == 0) {
			return 0;
		}
		
		// short circuit insertion for most common cases
		if (key >= maxKey) {
			if (key > maxKey) {
				keys[numKeys++] = key;	// appends the new key to the key array
				maxKey = key;
			}
			return numKeys - 1;
		}
		
		// use binary search to find insertion point for new key
		int low = -1;
		int high = numKeys;
		int pivot;
		long difference;
		
		while (high - low > 1) {
			pivot = (low + high) >>> 1;
			difference = keys[pivot] - key;
			if (difference > 0) {
				high = pivot;
			}
			else if (difference < 0) {
				low = pivot;
			}
			else {
				return pivot;	// key already exists
			}
		}
		
		// key does not exist so must be inserted
		System.arraycopy(keys, high, keys, high + 1, numKeys - high);
		keys[high] = key;
		
		numKeys++;
		return high;
		
	} // END insertKey method
	
	
	
	// Returns a key for the hand created by adding a new card to the hand 
	// represented by the given key.  Returns 0 if new card already appears in hand.
	private static long makeKey(long baseKey, int newCard) {
		
		int[] suitCount = new int[NUM_SUITS + 1]; 	// number of times a suit appears in a hand
		int[] rankCount = new int[NUM_RANKS + 1];	// number of times a rank appears in a hand
		hand = new int[8];										
		
		// extract the hand represented by the key value
		for (cardIndex = 0; cardIndex < 6; cardIndex++) {
			
			// hand[0] is used to hold the new card
			hand[cardIndex + 1] = (int)((baseKey >>> (8 * cardIndex)) & 0xFF);
		}
		
		hand[0] = formatCard8bit(newCard);
		
		// examine the hand to determine number of cards and rank/suit counts
		for (numCards = 0; hand[numCards] != 0; numCards++) {
			suitCount[hand[numCards] & 0xF]++;
			rankCount[(hand[numCards] >>> 4) & 0xF]++;
			
			// check to see if new card is already contained in hand (rank and suit considered)
			if (numCards != 0 && hand[0] == hand[numCards]) {
				return 0;
			}
		}
		
		// check to see if we already have four of a particular rank
		if (numCards > 4) {
			for (int rank = 1; rank < 14; rank++) {
				if (rankCount[rank] > 4) return 0;
			}
		}
		
		// determine the minimum number of suits required for a flush to be possible
		int minSuitCount = numCards - 2;
		
		// check to see if suit is significant
		if (minSuitCount > 1) {
			// examine each card in the hand
			for (cardIndex = 0; cardIndex < numCards; cardIndex++) {
				// if the suit is not significant then strip it from the card
				if (suitCount[hand[cardIndex] & 0xF] < minSuitCount) {
					hand[cardIndex] &= 0xF0;
				}
			}
		}
		
		sortHand();
		
		long key = 0;
		for (int i = 0; i < 7; i++) {
			key += (long)hand[i] << (i * 8);
		}
		
		return key;
		
	} // END makeKey method
	
	
	
	// Formats and returns a card in 8-bit packed representation.
	private static int formatCard8bit(int card) {
		
        // 8-Bit Packed Card Representation
        // +--------+
        // |rrrr--ss|
        // +--------+
        // r = rank of card		(deuce = 1, trey = 2, four = 3, five = 4,..., ace = 13)
		// s = suit of card		(suits are arbitrary, can take value from 0 to 3)	
		    
		card--;
		return (((card >>> 2) + 1) << 4) + (card & 3) + 1;
		
	} // END formatCard8bit method
	
	
	
	// Sorts the hand using Bose-Nelson Sorting Algorithm (N = 7).
	private static void sortHand() {
		swapCard(0, 4);
		swapCard(1, 5);
		swapCard(2, 6);
		swapCard(0, 2);
		swapCard(1, 3);
		swapCard(4, 6);
		swapCard(2, 4);
		swapCard(3, 5);
		swapCard(0, 1);
		swapCard(2, 3);
		swapCard(4, 5);
		swapCard(1, 4);
		swapCard(3, 6);
		swapCard(1, 2);
		swapCard(3, 4);
		swapCard(5, 6);	
	} // End sortHand method
	
	
	
	// Swaps card i with card j.
	private static void swapCard(int i, int j) {
		if (hand[i] < hand[j]) {
			hand[i] ^= hand[j];
			hand[j] ^= hand[i];
			hand[i] ^= hand[j];
		}	
	} // END swapCard method
	
	
	
	// Determines the relative strength of a hand (the hand is given by its unique key value).
	private static int getHandRank(long key) {
		
		// The following method implements a modified version of "Cactus Kev's Five-Card 
		// Poker Hand Evaluator" to determine the relative strength of two five-card hands.  
		// Reference: http://www.suffecool.net/poker/evaluator.html
		
		hand = new int[8];
		int currentCard;
		int rank;
		int handRank = 9999;
		int holdrank = 9999;
		int suit     = 0;
		int numCards = 0;

        final int[] primes = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41};
         
        if (key != 0) {

            for (cardIndex = 0; cardIndex < 7; cardIndex++) {

            	currentCard = (int)((key >>> (8 * cardIndex)) & 0xFF);
                if (currentCard == 0) break;
                numCards++;
                
                // Cactus Kev Card Representation
                // +--------+--------+--------+--------+
                // |xxxbbbbb|bbbbbbbb|cdhsrrrr|xxpppppp|
                // +--------+--------+--------+--------+
                // p    = prime number of rank (deuce = 2, trey = 3, four = 5, five = 7,..., ace = 41)
                // r    = rank of card         (deuce = 0, trey = 1, four = 2, five = 3,..., ace = 12)
                // cdhs = suit of card
                // b    = bit turned on depending on rank of card
                
                // extract suit and rank from 8-bit packed representation
                rank = (currentCard >>> 4) - 1;	
                suit = currentCard & 0xF; 

                // change card representation to Cactus Kev Representation
                hand[cardIndex] = primes[rank] | (rank << 8) | (1 << (suit + 11)) | (1 << (16 + rank));
            }
            
            switch (numCards) { 
                case 5 :  
                	
                	holdrank = eval_5hand(hand[0],hand[1],hand[2],hand[3],hand[4]);
                	break;

                case 6 :
                    
                	// Cactus Kev's Evaluator ranks hands from 1 (Royal Flush) to 7462 (Seven High Card)
                    holdrank = eval_5hand(                   hand[0],hand[1],hand[2],hand[3],hand[4]);
                    holdrank = Math.min(holdrank, eval_5hand(hand[0],hand[1],hand[2],hand[3],hand[5]));
                    holdrank = Math.min(holdrank, eval_5hand(hand[0],hand[1],hand[2],hand[4],hand[5]));
                    holdrank = Math.min(holdrank, eval_5hand(hand[0],hand[1],hand[3],hand[4],hand[5]));
                    holdrank = Math.min(holdrank, eval_5hand(hand[0],hand[2],hand[3],hand[4],hand[5]));
                    holdrank = Math.min(holdrank, eval_5hand(hand[1],hand[2],hand[3],hand[4],hand[5]));
                    break;
                    
                case 7 :
                	
                    holdrank = eval_5hand(                   hand[0],hand[1],hand[2],hand[3],hand[4]);
                    holdrank = Math.min(holdrank, eval_5hand(hand[0],hand[1],hand[2],hand[3],hand[5]));
                    holdrank = Math.min(holdrank, eval_5hand(hand[0],hand[1],hand[2],hand[3],hand[6]));
                    holdrank = Math.min(holdrank, eval_5hand(hand[0],hand[1],hand[2],hand[4],hand[5]));
                    holdrank = Math.min(holdrank, eval_5hand(hand[0],hand[1],hand[2],hand[4],hand[6]));
                    holdrank = Math.min(holdrank, eval_5hand(hand[0],hand[1],hand[2],hand[5],hand[6]));
                    holdrank = Math.min(holdrank, eval_5hand(hand[0],hand[1],hand[3],hand[4],hand[5]));
                    holdrank = Math.min(holdrank, eval_5hand(hand[0],hand[1],hand[3],hand[4],hand[6]));
                    holdrank = Math.min(holdrank, eval_5hand(hand[0],hand[1],hand[3],hand[5],hand[6]));
                    holdrank = Math.min(holdrank, eval_5hand(hand[0],hand[1],hand[4],hand[5],hand[6]));
                    holdrank = Math.min(holdrank, eval_5hand(hand[0],hand[2],hand[3],hand[4],hand[5]));
                    holdrank = Math.min(holdrank, eval_5hand(hand[0],hand[2],hand[3],hand[4],hand[6]));
                    holdrank = Math.min(holdrank, eval_5hand(hand[0],hand[2],hand[3],hand[5],hand[6]));
                    holdrank = Math.min(holdrank, eval_5hand(hand[0],hand[2],hand[4],hand[5],hand[6]));
                    holdrank = Math.min(holdrank, eval_5hand(hand[0],hand[3],hand[4],hand[5],hand[6]));
                    holdrank = Math.min(holdrank, eval_5hand(hand[1],hand[2],hand[3],hand[4],hand[5]));
                    holdrank = Math.min(holdrank, eval_5hand(hand[1],hand[2],hand[3],hand[4],hand[6]));
                    holdrank = Math.min(holdrank, eval_5hand(hand[1],hand[2],hand[3],hand[5],hand[6]));
                    holdrank = Math.min(holdrank, eval_5hand(hand[1],hand[2],hand[4],hand[5],hand[6]));
                    holdrank = Math.min(holdrank, eval_5hand(hand[1],hand[3],hand[4],hand[5],hand[6]));
                    holdrank = Math.min(holdrank, eval_5hand(hand[2],hand[3],hand[4],hand[5],hand[6]));
                    break;
                    
                default :
                	
                    System.out.println("ERROR: Invalid hand in GetRank method.");
                    break;
                    
            }
            
            // Hand Rank Representation
            // +--------+--------+
            // |hhhheeee|eeeeeeee|
            // +--------+--------+
            // h    = poker hand	    (1 = High Card, 2 = One Pair, 3 = Two Pair,..., 9 = Straight Flush)				
            // e    = equivalency class (Rank of equivalency class relative to base hand)
            
            // +-----------------------------------+----------------------------------+-----------------+
            // 		5-Card Equivalency Classes			7-Card Equivalency Classes
            // +-----------------------------------+----------------------------------+-----------------+
            //  	        1277      							 407					High Card
            //				2860 								1470					One Pair
            //				 858 								 763					Two Pair
            //				 858 								 575					Three of a Kind
            //				  10 								  10					Straight
            //				1277 								1277					Flush
            //				 156 								 156					Full House
            //				 156 								 156					Four of a Kind
            //				  10								  10					Straight Flush
            // +----------+------------------------+----------------------------------+-----------------+
            //    Total:    7462								4824
            // +----------+------------------------+----------------------------------+-----------------+
            
            handRank = 7463 - holdrank;  // Invert ranking metric (1 is now worst hand)
                      														          
            if      (handRank < 1278) handRank = handRank -    0 + 4096 * 1; // High Card 
            else if (handRank < 4138) handRank = handRank - 1277 + 4096 * 2; // One Pair  
            else if (handRank < 4996) handRank = handRank - 4137 + 4096 * 3; // Two Pair   
            else if (handRank < 5854) handRank = handRank - 4995 + 4096 * 4; // Three of a Kind   
            else if (handRank < 5864) handRank = handRank - 5853 + 4096 * 5; // Straight     
            else if (handRank < 7141) handRank = handRank - 5863 + 4096 * 6; // Flush   
            else if (handRank < 7297) handRank = handRank - 7140 + 4096 * 7; // Full House    
            else if (handRank < 7453) handRank = handRank - 7296 + 4096 * 8; // Four of a Kind    
            else                      handRank = handRank - 7452 + 4096 * 9; // Straight Flush     
            
        }
        return handRank;
        
	} // END getHandRank method
	
	
	
	private static int getIndex(int key) {

		// use binary search to find key
		int low = -1;
		int high = 4888;
		int pivot;

		while (high - low > 1) {
			pivot = (low + high) >>> 1;
			if (Products.table[pivot] > key) {
				high = pivot;
			}
			else if (Products.table[pivot] < key) {
				low = pivot;
			}
			else {
				return pivot;	
			}
		}
		return -1;
		
	} // END getIndex method

	
	
	private static int eval_5hand(int c1, int c2, int c3, int c4, int c5) {
		int   q = (c1 | c2 | c3 | c4 | c5) >> 16;
		short s;
		
		// check for Flushes and Straight Flushes
		if ((c1 & c2 & c3 & c4 & c5 & 0xF000) != 0) return Flushes.table[q];
		
		// check for Straights and High Card hands
		if ((s = Unique.table[q]) != 0) return s;    
		
		q = (c1 & 0xFF) * (c2 & 0xFF) * (c3 & 0xFF) * (c4 & 0xFF) * (c5 & 0xFF);
		q = getIndex(q);
		 
		return Values.table[q];
		
	} // END eval_5hand method
	
	
	
	public static void generateTables() {

	        int  card;
	        int  handRank;
	        int  keyIndex;
	        long key;    
	        
	        if (verbose) {
	        	System.out.print("\nGenerating and sorting keys...");
	        	startTimer = System.currentTimeMillis();
	        }
	        
	        for (keyIndex = 0; keys[keyIndex] != 0 || keyIndex == 0; keyIndex++) {
	            
	            for (card = 1; card < 53; card++) {	      			// add a card to each previously calculated key
	            	key = makeKey(keys[keyIndex], card);  			// create the new key
	            	
	                if (numCards < 7) insertKey(key);				// insert the new key into the key lookup table			
	            }           
	        }
	        
	        if (verbose) {
	        	stopTimer = System.currentTimeMillis();
	        	System.out.printf("done.\n\n%35s %d\n", "Number of Keys Generated:", (keyIndex + 1));
	        	System.out.printf("%35s %f seconds\n\n", "Time Required:", ((stopTimer - startTimer) / 1000.0));
		        System.out.print("Generating hand ranks...");
		        startTimer = System.currentTimeMillis();
	        }
	        
	        for (keyIndex = 0; keys[keyIndex] != 0 || keyIndex == 0; keyIndex++) { 
	            
	            for (card = 1; card < 53; card++) {
	            	key = makeKey(keys[keyIndex], card);
	                
	                if (numCards < 7) {
	                	handRank = insertKey(key) * 53 + 53;  		// if number of cards is < 7 insert key
	                }
	                else {
	                	handRank = getHandRank(key);   				// if number of cards is 7 insert hand rank
	                }

	                maxHandRankIndex = keyIndex * 53 + card + 53;	// calculate hand rank insertion index
	                handRanks[maxHandRankIndex] = handRank;			// populate hand rank lookup table with appropriate value
	            }
	            
	            if (numCards == 6 || numCards == 7) {
	            	// insert the hand rank into the hand rank lookup table
	            	handRanks[keyIndex * 53 + 53] = getHandRank(keys[keyIndex]);
	            }
	        }
	        
	        if (verbose) {
	        	stopTimer = System.currentTimeMillis();
	        	System.out.printf("done.\n\n%35s %f seconds\n\n", "Time Required:", ((stopTimer - startTimer) / 1000.0));
	        }
	        
	} // END generateTables method
	
	
	
	public static void main (String [] args) {
		generateTables();

		int c0, c1, c2, c3, c4, c5, c6;
        int u0, u1, u2, u3, u4, u5;
		int numHands = 0;
		int handRank;
        int[]          handEnumerations = new int[10];
        int[][] equivalencyEnumerations = new int[10][3000];
        String[] handDescriptions = {"Invalid Hand", "High Card", "One Pair", "Two Pair", "Three of a Kind",
        		                     "Straight", "Flush", "Full House", "Four of a Kind", "Straight Flush"};

        if (verbose) {
        	System.out.print("Enumerating hand frequencies and equivalency classes...");
        	startTimer = System.currentTimeMillis();
        }

        for (c0 = 1; c0 < 53; c0++) {
            u0 = handRanks[53 + c0];
            for (c1 = c0 + 1; c1 < 53; c1++) {
                u1 = handRanks[u0 + c1];
                for (c2 = c1 + 1; c2 < 53; c2++) {
                    u2 = handRanks[u1 + c2];
                    for (c3 = c2 + 1; c3 < 53; c3++) {
                        u3 = handRanks[u2 + c3];
                        for (c4 = c3 + 1; c4 < 53; c4++) {
                            u4 = handRanks[u3 + c4];
                            for (c5 = c4 + 1; c5 < 53; c5++) {
                                u5 = handRanks[u4 + c5];
                                for (c6 = c5 + 1; c6 < 53; c6++) {
                                	handRank = handRanks[u5 + c6];
                                	handEnumerations[handRank >>> 12]++;
                                	equivalencyEnumerations[handRank >>> 12][handRank & 0xFFF]++;
                                	numHands++;
                                }
                            }
                        }
                    }
                }
            }
        }
        
        if (verbose) {
        	stopTimer = System.currentTimeMillis();
        	System.out.printf("done.\n\n%35s %f seconds\n\n", "Time Required:", ((stopTimer - startTimer) / 1000.0));
        }
    	
        System.out.println("SEVEN-CARD POKER HAND FREQUENCIES AND EQUIVALENCY CLASSES\n");
        System.out.printf("    %-17s %15s %15s\n", "HAND", "FREQUENCY", "CLASSES");
        System.out.println("    -------------------------------------------------");

        int sumEquivalency;
        int numClasses = 0;
        for (int i = handEnumerations.length - 1; i >= 0; i--) {
        	sumEquivalency = 0;
        	for (int j = 0; j < equivalencyEnumerations[i].length; j++) {
        		if (equivalencyEnumerations[i][j] != 0) sumEquivalency++;
        	}
        	numClasses += sumEquivalency;
        	System.out.printf("    %-17s %15d %15d\n", handDescriptions[i], handEnumerations[i], sumEquivalency);
        }
        System.out.println("    -------------------------------------------------");
        System.out.printf("    %-17s %15d %15d\n", "TOTAL", numHands, numClasses);	
	}

} // END class Evaluator

The 2+2 Forums