Struct GameAnalyzer 

pub struct GameAnalyzer<G = ()> {
    game: G,
}

Owns a fixed game definition and reusable analysis caches. Move generators may collect statistics, but must keep the rules unchanged. Closure-based games must be finite and acyclic; detected cycles panic. Outcome queries stop exploring a position once a winning move is found. Use impartial_graph for Win/Draw/Lose analysis of cyclic graphs.

use competitive::algorithm::{GameAnalyzer, GameOutcome};
let mut nim = GameAnalyzer::new().impartial(|&n: &usize| 0..n);
assert_eq!(nim.grundy().eval(&3), 3);
assert_eq!(nim.sum().grundy().eval(&[3, 3]), 0);
assert_eq!(nim.misere().outcome().eval(&1), GameOutcome::Lose);
assert_eq!(nim.outcome().eval(&1), GameOutcome::Win);
assert_eq!(nim.grundy().verify(0..10, |&n| n as u64), None);

Fields

game: G

Implementations

impl GameAnalyzer

pub fn impartial_graph<G>( self, graph: &G, ) -> GameAnalyzer<ImpartialGraph<'_, G>>

where G: Graph + VertexMap<Option<usize>>,

Uses the graph’s shared moves for both players. Query vertices must be valid inputs to the graph’s VertexMap operations.

impl<'g, G> GameAnalyzer<ImpartialGraph<'g, G>>

where G: Graph + VertexMap<Option<usize>>,

pub fn grundy( &mut self, ) -> GameAnalysis<'_, ImpartialGraph<'g, G>, G::Vertex, u64>

pub fn value( &mut self, ) -> GameAnalysis<'_, ImpartialGraph<'g, G>, G::Vertex, GameValue>

pub fn outcome( &mut self, ) -> GameAnalysis<'_, ImpartialGraph<'g, G>, G::Vertex, GameOutcome>

pub fn misere(&mut self) -> Misere<'_, ImpartialGraph<'g, G>>

pub fn sum(&mut self) -> GameSum<'_, ImpartialGraph<'g, G>>

pub fn clear_cache(&mut self)

impl GameAnalyzer

pub fn impartial<S, F, I>( self, moves: F, ) -> GameAnalyzer<Impartial<S, impl FnMut(&S) -> Map<I::IntoIter, fn(S) -> Neighbor<S, ()>>>>

where F: FnMut(&S) -> I, I: IntoIterator<Item = S>,

pub fn impartial_moves<S, L, F, I>( self, moves: F, ) -> GameAnalyzer<Impartial<S, F>>

where F: FnMut(&S) -> I, I: IntoIterator<Item = Neighbor<S, L>>,

Examples found in repository

crates/competitive/src/algorithm/game_analyzer/impartial.rs (line 27)

    pub fn impartial<S, F, I>(
        self,
        mut moves: F,
    ) -> GameAnalyzer<
        Impartial<S, impl FnMut(&S) -> std::iter::Map<I::IntoIter, fn(S) -> Neighbor<S, ()>>>,
    >
    where
        F: FnMut(&S) -> I,
        I: IntoIterator<Item = S>,
    {
        let label: fn(S) -> Neighbor<S, ()> = |to| Neighbor::new(to, ());
        self.impartial_moves(move |s: &S| moves(s).into_iter().map(label))
    }

impl<S, F> GameAnalyzer<Impartial<S, F>>

pub fn misere(&mut self) -> Misere<'_, Impartial<S, F>>

pub fn sum(&mut self) -> GameSum<'_, Impartial<S, F>>

pub fn clear_cache(&mut self)

impl<S, L, F, I> GameAnalyzer<Impartial<S, F>>

where S: Clone + Eq + Hash, F: FnMut(&S) -> I, I: IntoIterator<Item = Neighbor<S, L>>,

pub fn grundy(&mut self) -> GameAnalysis<'_, Impartial<S, F>, S, u64>

pub fn value(&mut self) -> GameAnalysis<'_, Impartial<S, F>, S, GameValue>

pub fn outcome(&mut self) -> GameAnalysis<'_, Impartial<S, F>, S, GameOutcome>

pub fn fold<V, C>( &mut self, combine: C, ) -> GameAnalysis<'_, Impartial<S, F>, S, V, false, impl FnMut(&mut Impartial<S, F>, &S) -> V>

where V: Clone, C: FnMut(&S, &[(L, V)]) -> V,

combine receives each move’s label and the value of its destination.

impl GameAnalyzer

pub fn partisan<S, FL, FR, IL, IR>( self, left: FL, right: FR, ) -> GameAnalyzer<Partisan<S, impl FnMut(&S) -> Map<IL::IntoIter, fn(S) -> Neighbor<S, ()>>, impl FnMut(&S) -> Map<IR::IntoIter, fn(S) -> Neighbor<S, ()>>>>

where FL: FnMut(&S) -> IL, FR: FnMut(&S) -> IR, IL: IntoIterator<Item = S>, IR: IntoIterator<Item = S>,

pub fn partisan_moves<S, L, FL, FR, IL, IR>( self, left: FL, right: FR, ) -> GameAnalyzer<Partisan<S, FL, FR>>

where FL: FnMut(&S) -> IL, FR: FnMut(&S) -> IR, IL: IntoIterator<Item = Neighbor<S, L>>, IR: IntoIterator<Item = Neighbor<S, L>>,

Examples found in repository

crates/competitive/src/algorithm/game_analyzer/partisan.rs (lines 37-40)

    pub fn partisan<S, FL, FR, IL, IR>(
        self,
        mut left: FL,
        mut right: FR,
    ) -> GameAnalyzer<
        Partisan<
            S,
            impl FnMut(&S) -> std::iter::Map<IL::IntoIter, fn(S) -> Neighbor<S, ()>>,
            impl FnMut(&S) -> std::iter::Map<IR::IntoIter, fn(S) -> Neighbor<S, ()>>,
        >,
    >
    where
        FL: FnMut(&S) -> IL,
        FR: FnMut(&S) -> IR,
        IL: IntoIterator<Item = S>,
        IR: IntoIterator<Item = S>,
    {
        let label: fn(S) -> Neighbor<S, ()> = |to| Neighbor::new(to, ());
        self.partisan_moves(
            move |s: &S| left(s).into_iter().map(label),
            move |s: &S| right(s).into_iter().map(label),
        )
    }

impl<S, FL, FR> GameAnalyzer<Partisan<S, FL, FR>>

pub fn misere(&mut self) -> Misere<'_, Partisan<S, FL, FR>>

pub fn sum(&mut self) -> GameSum<'_, Partisan<S, FL, FR>>

pub fn clear_cache(&mut self)

impl<S, L, FL, FR, IL, IR> GameAnalyzer<Partisan<S, FL, FR>>

where S: Clone + Eq + Hash, FL: FnMut(&S) -> IL, FR: FnMut(&S) -> IR, IL: IntoIterator<Item = Neighbor<S, L>>, IR: IntoIterator<Item = Neighbor<S, L>>,

pub fn value(&mut self) -> GameAnalysis<'_, Partisan<S, FL, FR>, S, GameValue>

pub fn outcome( &mut self, ) -> GameAnalysis<'_, Partisan<S, FL, FR>, S, PartisanOutcome>

pub fn fold<V, C>( &mut self, combine: C, ) -> GameAnalysis<'_, Partisan<S, FL, FR>, S, V, false, impl FnMut(&mut Partisan<S, FL, FR>, &S) -> V>

where V: Clone, C: FnMut(&S, &[(Player, L, V)]) -> V,

combine receives all Left options followed by all Right options.

impl GameAnalyzer

pub fn scoring<S, L, F, T, I>( self, moves: F, terminal: T, ) -> GameAnalyzer<Scoring<S, F, T>>

where F: FnMut(&S) -> I, I: IntoIterator<Item = ScoreMove<S, L>>, T: FnMut(&S) -> Option<i64>,

Scores and rewards are measured for the player whose turn it is. terminal returns Some(score) at terminal states and None elsewhere.

impl<S, F, T> GameAnalyzer<Scoring<S, F, T>>

pub fn clear_cache(&mut self)

impl<S, L, F, T, I> GameAnalyzer<Scoring<S, F, T>>

where S: Clone + Eq + Hash, F: FnMut(&S) -> I, I: IntoIterator<Item = ScoreMove<S, L>>, T: FnMut(&S) -> Option<i64>,

pub fn score(&mut self) -> GameAnalysis<'_, Scoring<S, F, T>, S, i64>

impl GameAnalyzer

pub fn new() -> Self

Trait Implementations

impl<G: Default> Default for GameAnalyzer<G>

fn default() -> Self

Returns the “default value” for a type.