Texas Holdem Hand Equity Calculation in IronPython

This year I have been working in my free time to create easy to use Texas Holdem poker spreadsheets based on IronPython using Resolver One. These spreadsheets can be used to calculate Win/Tie/Loss odds, but some people like to use hand equity instead since it represents a player’s overall stake in the pot. Equity of 1.0 or 100% means that they will win the entire pot, where as equity of 0.5 (50%) or 0.25 (25%) means that they will split the pot with other players. You can again use Monte Carlo analysis to run a number of trials before all of the board cards are dealt to estimate a player’s current equity in the hand. This means that if during 4 trials I would win 2 of them and split the pot with one other player on the other 2, then my equity would be (1.0+1.0+0.5+0.5)/4 =  3/4 or 75%.

Calculating Win/Tie/Loss statistics on an independent player vs player basis is very simple, as the player’s pocket cards are evaluated against each opponent one at a time to show which opponent hands are stronger or weaker than your own. This does not take into account how the pocket cards of other opponents might change the odds, since in reality you usually play verse a table of opponents not just one opponent at a time. Changing the spreadsheet to work against the whole table would require changing the Monte Carlo simulation from a “row by row” analysis to a “table by table” analysis, where by you setup a table of opponents using a random hand for each player given the information that you have about their hand (AK, KK or QQ, Group1, etc..) and then generate a random 5 card hand based on the currently dealt cards.

There are a lot of issues that you have to watch out for in this type of Multiway Isometric Ranged Equity Calculation, but the basics are simple so long as you have a method of comparing multiple player’s hands for a given board. The C# poker library that I use is mainly focused on heads-up hands, but it only took me about an hour to whip up a method that would take a board setup and a list of player pocket hands and return the scored value and equity for each hand as well as the highest ranked hand and a list of the winners. Here’s the code:

#This function can be used to calculate equity for multiple hands and a given board def HandEquity(ulBoard, lstulHands, bPrintResults=False): """Used to calculate hand equity for a given 5 card poker hand and a list of players hands. If a hand wins then it's equity is 1, a loss is 0, and a tie is 1/n where n is the number of hands that tie. ulBoard: A 5 card hand for the board represented as a 52 bit mask in an unsigned long. Use HoldemHand.Hand.ParseHand method to parse "Ac Kd Th 3c 2d" type strings into bitmasks. lstulHands: a list of 2 card pocket hand masks as unsigned longs. Invalid hands that duplicate board cards are accepted but will get None for their score and equity. Use Use HoldemHand.Hand.ParseHand("Ac Kc") or HoldemHand.PocketHands.Query("AK").ToArray() to get hand masks. bPrintResults: True will print the results to the console. Use False for fastest results. NOTE: change 'pass #print' or '#print' lines to 'print' to enable more detailed debug messages Returns a tuple of (lstintScores, lstfEquity, intHighScore, lstHighScorers): lstintScores = integer representing the scored value for each hand. If hand is invalid given the board cards, value will be None. lstfEquity = float representing the hand's equity. If hand is invalid given the board cards, value will be None. Sum of all valid hands will equal 1. intHighScore = integer representing the highest scored value (ie what the winner(s) had). Use HoldemHand.Hand.DescriptionFromHandValueInternal(intHighScore) to get a string description lstHighScorers = list of the index to each of the winners. use len(lstHighScorers) to find out how many winners there were. Example: testBoard = ((288<< (13 * 3)) + (7<< (13 * 2))) #0b100100000000000000011100000000000000000000000000 is Ts 7s 4h 3h 2h testHands = [3, 3 << 13, 3 << (13*2), int('1100',2)] #3 is 0b11 for 3c 2c, "3 << 13" is 3d 2d, "3 << (13*2)" is 3h 2h, and int('1100',2) is 4c 5c (lstintScores, lstfEquity, intHighScore, lstHighScorers) = HandEquity(testBoard, testHands)""" intTotalHands = len(lstulHands) if intTotalHands < 1: raise Exception("Error: lstulHands must have at least one hand.") if HoldemHand.Hand.BitCount(ulBoard) != 5: raise Exception("Error: ulBoard must be a 5 card hand.") if(bPrintResults): print "Start HandEquity with %d hands and board cards: %s" % (intTotalHands, HoldemHand.Hand.MaskToString(ulBoard)) lstintScores = [None]*intTotalHands #List that holds scores for all the handss lstfEquity = [None]*intTotalHands #List that holds equity values for all the hands intHighScore = -1 #The highest score currently found lstHighScorers = [] #list of the index for hands that currently have the highscore intScore = None #temp variable to hold the current score #NOTE: Hand equity will not be available until after this loop finishes! for intIndex,aHand in enumerate(lstulHands): if HoldemHand.Hand.BitCount(aHand) != 2: raise Exception("Error: Pocket hands must contain 2 cards. lstulHands index %03d HandMask=0x%0.13X contains %d cards." % (intIndex, aHand, HoldemHand.Hand.BitCount(aHand))) if(aHand & ulBoard == 0): #Make sure there are no duplicate cards on the board and hand first lstintScores[intIndex] = intScore = HoldemHand.Hand.Evaluate(aHand | ulBoard) #evaluate the hand and board cards to get the score if intScore > intHighScore: intHighScore = intScore #Set new high score lstfEquity[intIndex] = float(1) for aScoreIndex in lstHighScorers: #Reset old high scores equity to zero lstfEquity[aScoreIndex] = 0 lstHighScorers = [intIndex] #Reset high score list elif intScore == intHighScore: #There is a tied pot, so calculate partial equity lstHighScorers.append(intIndex) #Add this index to the current high score for aScoreIndex in lstHighScorers: #Reset old high scores equity to partial equity lstfEquity[aScoreIndex] = 1 / float(len(lstHighScorers)) else: lstfEquity[intIndex] = 0 #losing hand gets no equity #print "%03d: Hand %s score is %s (%d)" % (intIndex, HoldemHand.Hand.MaskToString(aHand), HoldemHand.Hand.DescriptionFromHandValueInternal(intScore),intScore) else: pass #print "%03d: Hand %s has duplicate cards. Score and Equity are None." % (intIndex, HoldemHand.Hand.MaskToString(aHand)) #Hand equity is now finished. if(bPrintResults): #Print results for each hand print "Best hand is '%s' with %d winner(s) getting %0.2f equity in the hand." % (HoldemHand.Hand.DescriptionFromHandValueInternal(intHighScore), len(lstHighScorers), 1 / float(len(lstHighScorers))) for intIndex,aHand in enumerate(lstulHands): if(lstintScores[intIndex] == None): print "%03d: Hand %s HandScore=None Equity=None." % (intIndex, HoldemHand.Hand.MaskToString(aHand)) else: print "%03d: Hand %s HandScore=%09d Equity=%0.2f." % (intIndex, HoldemHand.Hand.MaskToString(aHand), lstintScores[intIndex], lstfEquity[intIndex]) return (lstintScores, lstfEquity, intHighScore, lstHighScorers) #Return Results

Here is a sample print-out when bPrintResults is True:

testBoard = ((288<< (13 * 3)) + (7<< (13 * 2))) #0b100100000000000000011100000000000000000000000000 is Ts 7s 4h 3h 2h
testHands = [3, 3 << 13, 3 << (13*2), int('1100',2)] #Hands: 3c 2c, 3d 2d, 3h 2h, and 4c 5c
(lstintScores, lstfEquity, intHighScore, lstHighScorers) = HandEquity(testBoard, testHands, True)

Start HandEquity with 4 hands and board cards: Ts 7s 4h 3h 2h
Best hand is 'Two pair, Three's and Two's with a Ten for a kicker' with 2 winner(s) getting 0.50 equity in the hand.
000: Hand 3c 2c HandScore=033622016 Equity=0.50
001: Hand 3d 2d HandScore=033622016 Equity=0.50
002: Hand 3h 2h HandScore=None        Equity=None
003: Hand 5c 4c HandScore=016942384 Equity=0.00

This is just a first step towards a full table Monte Carlo Simulator, but it gives you all of the details that are needed to find the winner(s) for a hand and calculate hand equity. The code used to generate a random board would be the same as in the other poker spreadsheets, but the player hand selection logic would need to use some sort of Round Robin algorithm to make sure that each player gets equal access to all of their possible pocket cards. Then you would use the HandEquity method to calculate the player’s equity for each hand and aggregate the results. My next goal is to change the spreadsheet code to use multiple threads, so I probably won’t tackle multi-way analysis anytime soon.