Poker for Programmers

using System;
using HoldemHand;

// A first try at calculating outs
namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {       
            string pocket = "As Ac";
            string board = "Kd 8h 9c";
            // Calcuate the outs
            ulong outsmask = Outs(Hand.ParseHand(pocket), Hand.ParseHand(board));

            Console.WriteLine("[{0}] {1} : Outs Count {2}",
                    pocket, board, Hand.BitCount(outsmask));

            // List the cards
            foreach (string card in Hand.Cards(outsmask))
            {
                Console.Write("{0} ", card);
            }
            Console.WriteLine();
        }

        // Return a hand mask of the cards that improve our hand
        static ulong Outs(ulong pocket, ulong board)
        {
            ulong retval = 0UL;
            ulong hand = pocket  board;

            // Get original hand value
            uint playerOrigHandVal = Hand.Evaluate(hand);

            // Look ahead one card
            foreach (ulong card in Hand.Hands(0UL, hand, 1))
            {
                // Get new hand value
                uint playerNewHandVal = Hand.Evaluate(hand  card);

                // If the hand improved then we have an out
                if (playerNewHandVal > playerOrigHandVal)
                {
                    // Add card to outs mask
                    retval = card;
                }
            }

            // return outs as a hand mask
            return retval;
        }
    }
}

using System;
using HoldemHand;

// A first try at calculating outs
namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {       
            string pocket = "As Ac";
            string board = "Kd 8h 9c";
            // Calcuate the outs
            ulong outsmask = Outs(Hand.ParseHand(pocket), Hand.ParseHand(board));

            Console.WriteLine("[{0}] {1} : Outs Count {2}",
                    pocket, board, Hand.BitCount(outsmask));

            // List the cards
            foreach (string card in Hand.Cards(outsmask))
            {
                Console.Write("{0} ", card);
            }
            Console.WriteLine();
        }

        // Return a hand mask of the cards that improve our hand
        static ulong Outs(ulong pocket, ulong board, params ulong [] opponents)
        {
            ulong retval = 0UL;

            // Get original hand value
            uint playerOrigHandVal = Hand.Evaluate(pocket  board);

            // Look ahead one card
            foreach (ulong card in Hand.Hands(0UL, board  pocket, 1))
            {
                // Get new hand value
                uint playerNewHandVal = Hand.Evaluate(pocket  board  card);
               
                // Get new board value
                uint boardHandVal = Hand.Evaluate(board  card);

                // Is the new hand better than the old one?
                bool handImproved = playerNewHandVal > playerOrigHandVal &&
                        Hand.HandType(playerNewHandVal) > Hand.HandType(playerOrigHandVal);

                // This compare ensures we move up in hand type.
                bool handStrongerThanBoard =
  Hand.HandType(playerNewHandVal) > Hand.HandType(boardHandVal);

                // Check against opponents cards
                bool handBeatAllOpponents = true;
                if (handImproved && handStrongerThanBoard &&
   opponents != null && opponents.Length > 0)
                {
                    foreach (ulong opponent in opponents)
                    {
                        uint opponentHandVal = Hand.Evaluate(opponent  board  card);
                        if (opponentHandVal > playerNewHandVal)
                        {
                            handBeatAllOpponents = false;
                            break;
                        }
                    }
                }

                // If the hand improved then we have an out
                if (handImproved && handStrongerThanBoard && handBeatAllOpponents)
                {
                    // Add card to outs mask
                    retval = card;
                }
            }

            // return outs as a hand mask
            return retval;
        }
    }
}

using System;
using HoldemHand;

// This example calculates the win odds for a player having "As Ks" against 
// five random players
namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // Calculate win odds using example code
            double w1 = WinOddsFivePlayerMonteCarlo(Hand.ParseHand("as ks"), 0UL, 5.0);
            Console.WriteLine("win: {0:0.00}%, time {1:0.0000}", w1 * 100.0, 5.0);

            // Calcluate win odds using Hand.WinOdds()
            w1 = Hand.WinOdds(Hand.ParseHand("as ks"), 0UL, 5, 5.0);
            Console.WriteLine("win: {0:0.00}%, time {1:0.0000}", w1 * 100.0, 5.0);
        }

        // An example of how to calculate win odds for five players
        static double WinOddsFivePlayerMonteCarlo(ulong pocket, ulong board, double duration)
        {
            // Keep track of stats
            long win = 0, lose = 0, tie = 0;

            // Loop through random boards
            foreach (ulong boardmask in Hand.RandomHands(board, pocket, 5, duration))
            {
                // Get random opponent hands
                ulong opp1mask = Hand.RandomHand(boardmask | pocket, 2);
                ulong opp2mask = Hand.RandomHand(boardmask | pocket | opp1mask, 2);
                ulong opp3mask = Hand.RandomHand(boardmask | pocket | opp1mask | 
                                        opp2mask, 2);
                ulong opp4mask = Hand.RandomHand(boardmask | pocket | opp1mask | 
                                        opp2mask | opp3mask, 2);
                ulong opp5mask = Hand.RandomHand(boardmask | pocket | opp1mask | 
                                    opp2mask | opp3mask | opp4mask, 2);
                // Get hand value for player and opponents
                uint playerHandVal = Hand.Evaluate(pocket | boardmask);
                uint opp1HandVal = Hand.Evaluate(opp1mask | boardmask);
                uint opp2HandVal = Hand.Evaluate(opp2mask | boardmask);
                uint opp3HandVal = Hand.Evaluate(opp3mask | boardmask);
                uint opp4HandVal = Hand.Evaluate(opp4mask | boardmask);
                uint opp5HandVal = Hand.Evaluate(opp5mask | boardmask);

                // Tally results
                if (playerHandVal > opp1HandVal && 
                    playerHandVal > opp2HandVal &&
                    playerHandVal > opp3HandVal && 
                    playerHandVal > opp4HandVal &&
                    playerHandVal > opp5HandVal)
                {
                    win++;
                }
                else if (playerHandVal >= opp1HandVal && 
                        playerHandVal >= opp2HandVal &&
                        playerHandVal >= opp3HandVal && 
                        playerHandVal >= opp4HandVal &&
                        playerHandVal >= opp5HandVal)
                {
                    tie++;
                }
                else
                {
                    lose++;
                }
            }

            // Return stats
            return ((double)(win + tie / 2.0)) / ((double)(win + tie + lose));
        }
    }
}

using System;
using System.Collections.Generic;
using HoldemHand;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // This code calculates the probablity of As Ks winning against
            // another random hand.
            ulong pocketmask = Hand.ParseHand("As Ks"); // Hole hand
            ulong board = Hand.ParseHand("");           // No board cards yet
            long wins = 0, ties = 0, loses = 0, count = 0;

            // Iterate through all possible opponent hole cards
            foreach (ulong oppmask in Hand.Hands(0UL, board  pocketmask, 2))
            {
                // Iterate through all board cards
                foreach (ulong boardmask in Hand.Hands(board, pocketmask  oppmask, 5))
                {
                    // Evaluate the player and opponent hands and tally the results
                    uint pocketHandVal = Hand.Evaluate(pocketmask   boardmask, 7);
                    uint oppHandVal = Hand.Evaluate(oppmask  boardmask, 7);
                    if (pocketHandVal > oppHandVal)
                    {
                        wins++;
                    }
                    else if (pocketHandVal == oppHandVal)
                    {
                        ties++;
                    }
                    else
                    {
                        loses++;
                    }
                    count++;
                }
            }

            // Prints: Win 67.0446323092352%
            Console.WriteLine("Win {0}%",
                (((double)wins) + ((double)ties) / 2.0) / ((double)count) * 100.0);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using HoldemHand;

namespace ConsoleApplication1
{
    class Program
    {
        [DllImport("Kernel32.dll")]
        private static extern bool QueryPerformanceCounter(out long lpPerformanceCount);
        [DllImport("Kernel32.dll")]
        private static extern bool QueryPerformanceFrequency(out long lpFrequency);

        static void Main(string[] args)
        {
            // This code calculates the probablity of As Ks winning against
            // another random hand.
            ulong pocketmask = Hand.ParseHand("As Ks"); // Hole hand
            ulong board = Hand.ParseHand("");           // No board cards yet

            // Trial numbers
            int[] trialsTable = {
                10, 50, 100, 500, 1000, 5000, 10000, 15000, 20000,
                25000, 30000, 40000, 50000, 100000, 150000, 200000,
                500000, 1000000, 2000000, 5000000, 10000000, 20000000
            };

            // timer values
            long start, freq, curtime;

            // Get time frequency
            QueryPerformanceFrequency(out freq);

            Console.WriteLine("Trials,Wins,Difference,Duration");

            foreach (int trials in trialsTable)
            {
                long wins = 0, ties = 0, loses = 0, count = 0;
                // Get start time
                QueryPerformanceCounter(out start);

                // Iterate through a series board cards
                foreach (ulong boardmask in
                    Hand.RandomHands(board, pocketmask, 5, trials))
                {
                    // Get a random opponent hand
                    ulong oppmask = Hand.RandomHand(boardmask | pocketmask, 2);

                    // Evaluate the player and opponent hands
                    uint pocketHandVal = Hand.Evaluate(pocketmask | boardmask, 7);
                    uint oppHandVal = Hand.Evaluate(oppmask | boardmask, 7);

                    // Calculate Statistics
                    if (pocketHandVal > oppHandVal)
                    {
                        wins++;
                    }
                    else if (pocketHandVal == oppHandVal)
                    {
                        ties++;
                    }
                    else
                    {
                        loses++;
                    }
                    count++;
                }

                // Get Current Time
                QueryPerformanceCounter(out curtime);
                double duration = ((curtime - start) / ((double)freq));

                // Correct answer is 67.0446323092352%
                Console.WriteLine("{0},{1},{2}%,{3}",
                    trials,
                    string.Format("{0:0.00}%", 
                        (((double)wins) + ((double)ties) / 2.0) / ((double)count) *100.0),
                    string.Format("{0:0.0000}", 
                        67.0446323092352 - ((((double)wins) + 
                        ((double)ties) / 2.0) / ((double)count) * 100.0)),
                    string.Format("{0:0.0000}", duration));
            }
        }
    }
}

public static IEnumerable<ulong> Hand.RandomHands(ulong shared, ulong dead, int ncards, int trials)

public static IEnumerable<ulong> Hand.RandomHands(ulong shared, ulong dead, int ncards, double duration) 

static public ulong Hand.RandomHand(ulong shared, ulong dead, int ncards) 

using System;
using System.Collections.Generic;
using System.Text;
using HoldemHand;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // Keep stats
            double win = 0.0, lose = 0.0, tie = 0.0;
            // Parse cards into hand masks
            ulong pocketcards = Hand.ParseHand("as ks");
            ulong opponentcards = Hand.ParseHand("5h tc");
            ulong boardcards = Hand.ParseHand("qs ts 5c");

            // Loop through all remaining 5 card boards.
            // All 5 card boardmask must contain the starting
            // board cards. That's why boardcards is passed in the first argument.
            // Neither player nor opponents cards should be allowed in the boardmask
            // which is why they are ORed together and passed to Hand.Hands()
            // second argument. 
            foreach (ulong boardmask in 
                Hand.Hands(boardcards, pocketcards | opponentcards, 5))
            {
                // Get Hand Values
                uint playerhandval = Hand.Evaluate(pocketcards | boardmask);
                uint opphandval = Hand.Evaluate(opponentcards | boardmask);

                // Compare and update the stats
                if (playerhandval > opphandval)
                {
                    win += 1.0;
                }
                else if (playerhandval == opphandval)
                {
                    tie += 1.0;
                }
                else
                {
                    lose += 1.0;
                }
            }
            // Print results which is 42.63%
            Console.WriteLine("Odds of beating opponent {0:0.00}%", 
                (win + tie / 2.0) / (win + tie + lose) * 100.0);
       }
    }
}