Struct Game 

pub struct Game<Infoset, Action> { /* private fields */ }

A compact game representation

This structure allows computing approximate equilibria, and evaluating the regret and utility of strategy profiles.

Implementations

impl<I: Hash + Eq, A: Hash + Eq> Game<I, A>

pub fn from_root<T>(root: T) -> Result<Self, GameError>

where T: IntoGameNode<PlayerInfo = I, Action = A>, T::ChanceInfo: Hash + Eq,

Create a game from the root node of an arbitrary game tree

For more information on how to create a game, see the necessary trait IntoGameNode for details on how to structure the input data.

Examples found in repository

examples/kuhn_poker.rs (line 120)

fn create_kuhn(num_cards: usize) -> Game<(usize, bool), Action> {
    Game::from_root(create_kuhn_one(num_cards)).unwrap()
}

impl<I, A> Game<I, A>

pub fn solve( &self, method: SolveMethod, max_iter: u64, max_reg: f64, num_threads: usize, params: Option<RegretParams>, ) -> Result<(Strategies<'_, I, A>, RegretBound), SolveError>

Find an approximate Nash equilibrium of the current game

Often you’ll either want to run with max_iter as usize::MAX and max_reg as a meaningful regret, or max_iter as a number set based off of the time you have and max_reg set to 0.0, although setting both as a tradeoff also reasonable.

Arguments

• method - The method of solving to use. When in doubt prefer External. See SolveMethod for details on the distinctions.
• max_iter - The maximum number of iterations to run. The maximum regret of the found strategy is bounded by the square-root of the number of iterations.
• max_reg - Terminate early if the regret of the returned strategy is going to be less than this value. With this current implementation this is only valid when the method is Full and the params are vanilla. If using other parameters, this should be set lower than the desired regret.
• num_threads - The number of threads to use for solving. Zero selects based off of thread::available_parallelism. One uses a single threaded variant that’s more efficient when not in a threaded environment.
• param - Advanced parameters that govern the behavior of the regret and strategy updates. See RegretParams for more details, or set to None to use the default.

Errors

If num_threads is too large, and this tries to spawn too many threads, or if there are problems spawning threads. This will not error when num_threads is 1.

Examples found in repository

examples/kuhn_poker.rs (lines 176-182)

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 num_infosets(&self) -> usize

The total number of information sets for each player

impl<I: Hash + Eq + Clone, A: Hash + Eq + Clone> Game<I, A>

pub fn from_named( &self, strats: [impl IntoIterator<Item = (impl Borrow<I>, impl IntoIterator<Item = (impl Borrow<A>, impl Borrow<f64>)>)>; 2], ) -> Result<Strategies<'_, I, A>, StratError>

Convert a named strategy into Strategies

The input can be any set of types that vaguelly iterates over pairs of information sets and then actions paired to weights. Weights can be any non-negative f64, which will be normalized in the final strategy. There are no restrictions on iteration order.

Example

use std::collections::HashMap;

let game = // ...
let one: HashMap<&'static str, HashMap<&'static str, f64>> = [
    ("info", [("A", 0.2), ("B", 0.8)].into())
].into();
let two: HashMap<&'static str, HashMap<&'static str, f64>> = [
    ("info", [("1", 0.5), ("2", 0.5)].into())
].into();
let strat = game.from_named([one, two]).unwrap();
let info = strat.get_info();
info.regret();

Errors

This will error if a valid strategy wasn’t specified for every infoset, or it received invalid infosets or actions for the current Game.

impl<I: Eq, A: Eq> Game<I, A>

pub fn from_named_eq( &self, strats: [impl IntoIterator<Item = (impl Borrow<I>, impl IntoIterator<Item = (impl Borrow<A>, impl Borrow<f64>)>)>; 2], ) -> Result<Strategies<'_, I, A>, StratError>

Convert a named strategy into Strategies

In case cloning is very expensive, this version doesn’t require cloning or hashing, but otherwise runs in time quadratic in the number of infosets and actions, which is almost certaintly going to be worse than the cost of cloning.

Also note that currently constructing the Game requires hashing so that relaxation is meaningless.

This is otherwise the same as Game::from_named, so see that method for examples.

Trait Implementations

impl<Infoset: Debug, Action: Debug> Debug for Game<Infoset, Action>

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

Formats the value using the given formatter.

impl<I, A> PartialEq for Game<I, A>

Two games are equal if and only if they are the same game

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 Game<I, A>