Poker hand evaluator

This crate contains fast Texas hold'em poker hand equity evaluator.

Each of the 52 deck cards is attributed an integer key.
The 9 least significant bits encode the card suit, the others 23 the card face.

This encoding, based on keys precalculated by crate poker_keygen, in is such that it enables to uniquely identify a hand rank by a few simple operations (sums, bit mask, bit shift, and table lookups).

To use this crate as a server see poker_server.

Eval

Building the lookup is performed in sequence:

5-card hands

Build 5-card lookup tables: five::build_tables.
Which enables function get_rank_five.

use poker_eval::eval::five::{build_tables, get_rank_five};

// precalculate lookup tables
let t5 = build_tables(false);

// run the evaluation multiple times
let rank = get_rank_five(&t5, [31, 26, 50, 16, 49]);
assert_eq!(rank, 3971)

7-card hands

Build 7-card lookup tables: seven::build_tables using function [eval::seven::get_rank_seven] built on [eval::five::get_rank_five].
Which enables function get_rank.
This function is the entry point to evaluate a player hand.

use poker_eval::eval::seven::{build_tables, get_rank};

// precalculate lookup tables
let arc_t7 = build_tables(false);

// run the evaluation multiple times
let rank = get_rank(&arc_t7, [5, 4, 18, 31, 34, 48, 22]);
assert_eq!(rank, 1689)

Calc

From function get_rank, 2 calculation functions are implemented:

• deterministic, ie. exhaustive
• monte carlo

Deterministic

Function calc_equity_det:

• Calculate the equity of all players hands through exhaustive simulation.
• This requires all players cards to be known.
• This is feasible because in all cases, the number of simulations is small - and the evaluator fast.

use poker_eval::eval::seven::build_tables;
use poker_eval::calc::equity_det::calc_equity_det;

// precalculate lookup tables
let arc_t7 = build_tables(true);

// then you can call calc_equity_det multiple times
let equity = calc_equity_det(
    // clone of Arc<TableSeven>
    arc_t7.clone(),  
    // players cards  
    vec![[7, 8], [22, 27]],  
    // table cards  
    vec![51, 30, 41],  
    // verbose  
    true
);
println!("equity = {:?}", equity);
//Ok([[0.23131312, 0.10707071], [0.55454546, 0.10707071]])

Monte carlo

Function calc_equity_mc:

• Calculate the equity of the first player though monte carlo simulation.
• This does not require all players to be known.
• Because the number of cases is potentially massive, a number of simlations must be specified.

use poker_eval::eval::seven::build_tables;
use poker_eval::calc::equity_mc::calc_equity_monte_carlo;

// precalculate lookup tables
let arc_t7 = build_tables(true);

// then you can call calc_equity_monte_carlo multiple times
let equity = calc_equity_monte_carlo(
    // clone of Arc<TableSeven>
    arc_t7.clone(),
    // player cards
    vec![vec![8, 9], vec![11, 28], vec![]],
    // table cards
    vec![15, 47, 23, 33],
    // number of game
    100_000_000,
);
println!("equity = {:?}", equity);
// Ok(HandEquity { win: 0.3167, tie: 0.0 })