#include "wrapper.h"

extern "C" __declspec(dllexport) void __stdcall Calculate(const char* hands, const char* board, const char* dead, __int64* trialCount, double* results, double* player_results, double* opponent_results, double* Tie)
{
memset(results, 0, 23);
memset(player_results, 0, 9);
memset(opponent_results, 0, 9);
*Tie = 0;
HoldemCalculator calc;
calc.Calculate(hands, board, dead, trialCount, results, player_results, opponent_results, Tie);
calc.deletemdists();
}

///////////////////////////////////////////////////////////////////////////////
// Take a given agnostic hand, such as "AA" or "AJs+" or "77-TT", along with
// an optional collection of "dead" cards, and boil it down into its constituent
// specific Hold'em hands, storing these in the 'specificHands' vector passed
// in by the client.
// XxXx means a full range
// You can use the A9o - AQo notation => (A9o, ATo, AJo, AQo) or 77-TT => (77,88,99,TT)
// You can use the QQ+ notation => (QQ,KK,AA) or KTS+ => (KTs,KJs,KQs)
// You must always specify if you are considering suited and/or offsuited so don't forget the s or o suffix for each range except pockets
// There is no special rule regarding connectors, so QJs+ => (QJs) and 98o+ => (98o)
//
// Returns the number of specific hands the agnostic hand contains.
///////////////////////////////////////////////////////////////////////////////
int AgnosticHand::Instantiate(const char* handText, StdDeck_CardMask deadCards, vector<StdDeck_CardMask>& specificHands)
{
if (strcmp(handText, "XxXx") == 0)
{
return InstantiateRandom(deadCards, specificHands);
}

bool isPlus = (NULL != strchr(handText, '+'));
bool isSlice = (NULL != strchr(handText, '-'));
int handRanks[3] = { 0, 0, 0 };
if (isSlice) // TT - AA, ATo - AQo
{
const char* index = strchr(handText, '-');

char handCeil[4];
char handFloor[4];
strncpy(handFloor, handText, index - handText);
strcpy(handCeil, index + 1);

handRanks[0] = Card::CharToRank(handFloor[0]);
handRanks[1] = Card::CharToRank(handFloor[1]);
handRanks[2] = Card::CharToRank(handCeil[1]);
}
else // K2s+ or 32s
{
handRanks[0] = Card::CharToRank(handText[0]);
handRanks[1] = Card::CharToRank(handText[1]);
}

StdDeck_CardMask hand;

int combos = 0;

if (IsPair(handText))
{
StdDeck_CardMask card1, card2;

for (int rank = handRanks[0]; rank <= (isSlice ? handRanks[2] : (isPlus ? Card::Ace : handRanks[1])); rank++)
{
for(int suit1 = StdDeck_Suit_FIRST; suit1 <= StdDeck_Suit_LAST; suit1++)
{
for (int suit2 = suit1 + 1; suit2 <= StdDeck_Suit_LAST; suit2++)
{
card1 = StdDeck_MASK( StdDeck_MAKE_CARD(rank, suit1) );
card2 = StdDeck_MASK( StdDeck_MAKE_CARD(rank, suit2) );
StdDeck_CardMask_OR(hand, card1, card2);
if (!StdDeck_CardMask_ANY_SET(deadCards, hand))
{
specificHands.push_back(hand);
combos++;
}
}
}
}
}
else if (IsSuited(handText))
{
StdDeck_CardMask card1, card2, hand;

for (int rank1 = handRanks[1]; rank1 <= (isSlice ? handRanks[2] : (isPlus ? handRanks[0]-1 : handRanks[1])); rank1++)
{
for(int suit = StdDeck_Suit_FIRST; suit <= StdDeck_Suit_LAST; suit++) // 4 colors
{
card1 = StdDeck_MASK(StdDeck_MAKE_CARD(handRanks[0], suit));
card2 = StdDeck_MASK( StdDeck_MAKE_CARD(rank1, suit) );
StdDeck_CardMask_OR(hand, card1, card2);
if (!StdDeck_CardMask_ANY_SET(deadCards, hand))
{
specificHands.push_back(hand);
combos++;
}
}
}
}
else if (IsOffSuit(handText))
{
StdDeck_CardMask card1, card2, hand;

for (int rank1 = handRanks[1]; rank1 <= (isSlice ? handRanks[2] : (isPlus ? handRanks[0]-1 : handRanks[1])); rank1++)
{
for(int suit1 = StdDeck_Suit_FIRST; suit1 <= StdDeck_Suit_LAST; suit1++)
{
for (int suit2 = StdDeck_Suit_FIRST; suit2 <= StdDeck_Suit_LAST; suit2++)
{
if (suit1 == suit2)
continue;

card1 = StdDeck_MASK(StdDeck_MAKE_CARD(handRanks[0], suit1));
card2 = StdDeck_MASK( StdDeck_MAKE_CARD(rank1, suit2) );
StdDeck_CardMask_OR(hand, card1, card2);
if (!StdDeck_CardMask_ANY_SET(deadCards, hand))
{
specificHands.push_back(hand);
combos++;
}
}
}
}
}

return combos;
}

Thanks shadehs!
I have tried it out and it works great. I can also extend your wrapper to call other functions in XPokerEquity from C#.

This is an example of how to use XPokerEquity with C#;

Post flop should be instantaneous given the iterations are so small. The of where you do the equity should be no different to doing it preflop.

does anybody know or share a postflop lookuptable?
I' using the xpoker equity calculator for doing the ev calculations during runtime -> is very often too slow (especially every hand vs every hand in an range for 2 players)

The lookup tables are the fastest but you can still get terrific speeds without.

OK guys, I hear what you are saying! Pre-calculation is obviously the best way to speed up hand evaluation.

Could you please tell me how to actually do it with 1 to 9 opponents (all with different hand ranges) and for all betting rounds?

I need a reliable, easy to use and fast (in that priority order) hand evaluator for my Holdem C# Bot. Preferably with documentation and usage examples.

So for this bot

It should handle preflop, flop, turn and river (2, 5, 6 and 7 cards). It should handle 1 - 9 opponents. I also need functions to calculate win probability, EV and other things my bot might need.

The alternatives I have found are all several years old, which makes me unsure which is the best choice today.

I therefore turn to you guys for some advice, it will be greatly appreciated!

calculating equity against a probability distribution of 1326 hands becomes trivial with a pre-calculated matrix

The only place I do live evaluation is showdown... perfectly possible to pre-calculate everything for the river too

I use this in my bot with a wrapper.

Anyone know the status of the XpokerEquity functions? See here: http://www.codingthewheel.com/archives/ ... n-poker-1/

I have found the source, but what is the status? Are there bugs in it (someone said it doesn't return the same Equity as pokerstove)?

Anyone have a C# wrapper for it?

Any alternative that does the same, but in C# ?

Did you try http://www.codeproject.com/Articles/190 ... n-C-Part-2
Keith adds MonteCarlo analysis and multicore support.

Are you not getting a little hung up on the speed of the evaluator?

When you run your tests, are you pre-populating a list of random hands and running though that? If not, you should be.

Managed to run last test on view menu (Thread Pool Evaluate/Iterate) in Debug mode and are getting 80-100M hands/sec. This is slooooow compared to some other evaluators.

I use this:
http://www.codeproject.com/Articles/122 ... d-Analysis

Lots of features - there are a few speed improvements that can be made too.

I use this:
http://www.codeproject.com/Articles/122 ... d-Analysis

Lots of features - there are a few speed improvements that can be made too.

there are a few speed improvements that can be made too

http://www.codeproject.com/Articles/19091/More-Texas-Holdem-Analysis-in-C-Part-1

I don't know the best answer.
I've ported the poker-eval 7 card evaluation function to c# (exactly the same with all the table lookups) and it's 10x slower
I wonder why ?