openpql-runner 0.1.3

A high-performance Rust implementation of Poker Query Language (PQL), enabling SQL-like queries for poker analysis and calculations. This project is a spiritual successor to the original Java implementation developed by Odds Oracle.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

use super::*;

#[pqlfn(alias = "equity")]
pub fn hvhequity(
    ctx: &PQLFnContext,
    hero: PQLPlayer,
    street: PQLStreet,
) -> PQLEquity {
    match street {
        PQLStreet::Preflop => unreachable!(),
        PQLStreet::Flop => flop_equity(ctx, hero),
        PQLStreet::Turn => turn_equity(ctx, hero),
        PQLStreet::River => river_equity(ctx, hero),
    }
}

// TODO: tmp; optimize
pub fn turn_equity(ctx: &PQLFnContext, hero: PQLPlayer) -> PQLEquity {
    let b64 = ctx.get_c64_board(PQLStreet::Turn);

    let all = if ctx.game.is_shortdeck() {
        PQLCard::all::<true>()
    } else {
        PQLCard::all::<false>()
    };

    let mut res: Vec<PQLFraction> = vec![];

    for river in all {
        if b64.contains_card(*river) {
            continue;
        }

        let mut board = b64;
        board.set(*river);

        let ratings: Vec<_> = PQLPlayer::iter(ctx.n_players)
            .map(|player| {
                ctx.game.eval_rating(ctx.get_c64_player(player), board)
            })
            .collect();

        let max = *ratings.iter().max().unwrap();

        if ratings[usize::from(hero)] == max {
            let n_winners = ratings.iter().filter(|&r| *r == max).count();

            res.push(PQLFraction::new(
                1,
                FractionInner::try_from(n_winners).unwrap(),
            ));
        } else {
            res.push(PQLFraction::zero());
        }
    }

    avg(&res)
}

// TODO: tmp; optimize
pub fn flop_equity(ctx: &PQLFnContext, hero: PQLPlayer) -> PQLEquity {
    fn inner<I: Iterator<Item = HandN<2>>>(
        ctx: &PQLFnContext,
        hero: PQLPlayer,
        iter: I,
    ) -> PQLEquity {
        let b64 = ctx.get_c64_board(PQLStreet::Flop);

        let mut res: Vec<PQLFraction> = vec![];

        for turn_river in iter {
            let turn = turn_river[0];
            let river = turn_river[1];

            if b64.contains_card(turn) || b64.contains_card(river) {
                continue;
            }

            let mut board = b64;
            board.set(turn);
            board.set(river);

            let ratings: Vec<_> = PQLPlayer::iter(ctx.n_players)
                .map(|player| {
                    ctx.game.eval_rating(ctx.get_c64_player(player), board)
                })
                .collect();

            let max = *ratings.iter().max().unwrap();

            if ratings[usize::from(hero)] == max {
                let n_winners = ratings.iter().filter(|&r| *r == max).count();

                res.push(PQLFraction::new(
                    1,
                    FractionInner::try_from(n_winners).unwrap(),
                ));
            } else {
                res.push(PQLFraction::zero());
            }
        }

        avg(&res)
    }

    if ctx.game.is_shortdeck() {
        inner(ctx, hero, HandN::<2>::iter_all::<true>())
    } else {
        inner(ctx, hero, HandN::<2>::iter_all::<false>())
    }
}

fn avg(vs: &[PQLFraction]) -> PQLEquity {
    let mut sum = 0.0;
    let mut count = 0.0;

    for v in vs {
        sum += v.to_double();
        count += 1.0;
    }

    sum / count
}