Struct Strategies 

pub struct Strategies<'a, Infoset, Action> { /* private fields */ }

A compact strategy for both players

Strategies are tied to a specific game and maintain a reference back to them. Create these from original data using Game::from_named.

Implementations

impl<'a, I, A> Strategies<'a, I, A>

pub fn as_named<'b: 'a>(&'b self) -> [NamedStrategyIter<'a, I, A>; 2]

Attach player, infoset, and action information to a strategy

Use this to convert a strategy profile into an exportable format.

Examples

let game = // ...
let (strats, _) = game.solve(
    // ...
).unwrap();
let [player_one_strat, player_two_strat] = strats.as_named();
for (infoset, actions) in player_one_strat {
    for (action, prob) in actions {
        // ...
    }
}

Examples found in repository

examples/kuhn_poker.rs (line 185)

fn main() {
    let args = Args::parse();
    let game = create_kuhn(args.num_cards);
    let (mut strats, _) = game
        .solve(
            SolveMethod::External,
            args.iterations,
            0.0,
            args.parallel,
            None,
        )
        .unwrap();
    strats.truncate(5e-3); // not visible
    let [player_one_strat, player_two_strat] = strats.as_named();
    println!("Player One");
    println!("==========");
    let mut init = Vec::with_capacity(3);
    let mut raised = Vec::with_capacity(3);
    for (&(card, raise), actions) in player_one_strat {
        if raise { &mut raised } else { &mut init }.push((card, actions));
    }
    println!("Initial Action");
    println!("--------------");
    print_card_strat(init, args.num_cards);
    println!("If Player Two Raised");
    println!("--------------------");
    print_card_strat(raised, args.num_cards);
    println!("Player Two");
    println!("==========");
    let mut called = Vec::with_capacity(3);
    let mut raised = Vec::with_capacity(3);
    for (&(card, raise), actions) in player_two_strat {
        if raise { &mut raised } else { &mut called }.push((card, actions));
    }
    println!("If Player One Called");
    println!("--------------------");
    print_card_strat(called, args.num_cards);
    println!("If Player One Raised");
    println!("--------------------");
    print_card_strat(raised, args.num_cards);
}

pub fn truncate(&mut self, thresh: f64)

Truncate actions with small probability

Since CFR produces approximate equilibria, often it will return a strategy with very low probability of playing an action that should never actually be played. Use this to truncate the probability of small actions when they’re played less than thresh of the time.

Examples found in repository

examples/kuhn_poker.rs (line 184)

fn main() {
    let args = Args::parse();
    let game = create_kuhn(args.num_cards);
    let (mut strats, _) = game
        .solve(
            SolveMethod::External,
            args.iterations,
            0.0,
            args.parallel,
            None,
        )
        .unwrap();
    strats.truncate(5e-3); // not visible
    let [player_one_strat, player_two_strat] = strats.as_named();
    println!("Player One");
    println!("==========");
    let mut init = Vec::with_capacity(3);
    let mut raised = Vec::with_capacity(3);
    for (&(card, raise), actions) in player_one_strat {
        if raise { &mut raised } else { &mut init }.push((card, actions));
    }
    println!("Initial Action");
    println!("--------------");
    print_card_strat(init, args.num_cards);
    println!("If Player Two Raised");
    println!("--------------------");
    print_card_strat(raised, args.num_cards);
    println!("Player Two");
    println!("==========");
    let mut called = Vec::with_capacity(3);
    let mut raised = Vec::with_capacity(3);
    for (&(card, raise), actions) in player_two_strat {
        if raise { &mut raised } else { &mut called }.push((card, actions));
    }
    println!("If Player One Called");
    println!("--------------------");
    print_card_strat(called, args.num_cards);
    println!("If Player One Raised");
    println!("--------------------");
    print_card_strat(raised, args.num_cards);
}

pub fn distance(&self, other: &Self, p: f64) -> [f64; 2]

Get the distance between this strategy and another strategy

This computes the avg of the l-p earth movers distance between the strategies for each player, thus the value is between 0 and 1 where 0 represents identical strategies, and 1 represents strategies that share no support.

This is only a valid distance if p is at least 1, which should also be the default setting.

Panics

Panics if other isn’t from the same game, or if p isn’t positive

pub fn get_info(&self) -> StrategiesInfo

Get regret and utility information for this strategy profile

Trait Implementations

impl<'a, Infoset: Clone, Action: Clone> Clone for Strategies<'a, Infoset, Action>

fn clone(&self) -> Strategies<'a, Infoset, Action>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a, Infoset: Debug, Action: Debug> Debug for Strategies<'a, Infoset, Action>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<I, A> PartialEq for Strategies<'_, I, A>

Strategies are equal if they contain identical values and are from the same game

Equality is strict since action probabilities can’t be nan.

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<I, A> Eq for Strategies<'_, I, A>