I use this in my bot with a wrapper.

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 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!

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?

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)

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.

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

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#.

///////////////////////////////////////////////////////////////////////////////
// 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;
}