t4t 0.2.1

Tit-for-tat: a game theory toolbox.
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
124
125
126
127
128
129

use std::marker::PhantomData;

use crate::{
    Move, Outcome, Past, Payoff, PlayerIndex, Plies, Profile, Record, SequentialOutcome,
    SimultaneousOutcome, State, Summary, Transcript, Utility,
};

/// For repeated games, a history of previously played games.
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct History<M: Move, U: Utility, O: Outcome<M, U, P>, const P: usize> {
    outcomes: im::Vector<O>,
    score: Payoff<U, P>,
    summary: Summary<P>,
    move_type: PhantomData<M>,
}

impl<M: Move, U: Utility, O: Outcome<M, U, P>, const P: usize> History<M, U, O, P> {
    /// Construct a new, empty history.
    pub fn empty() -> Self {
        History::default()
    }

    /// Update the history by adding a new game outcome. Returns a reference to the newly added
    /// outcome.
    pub fn add(&mut self, outcome: O) -> &O {
        self.score = self.score + *outcome.payoff();
        self.summary = self.summary + outcome.record().summary();
        self.outcomes.push_back(outcome);
        self.outcomes.back().unwrap()
    }

    /// Get an iterator over the outcomes of previously played games.
    pub fn outcomes(&self) -> Past<&O> {
        Past::from_iter(self.outcomes.len(), self.outcomes.iter())
    }

    /// Get an iterator over the move records of previously played games.
    pub fn records(&self) -> Past<&<O as Outcome<M, U, P>>::Record> {
        Past::from_iter(
            self.outcomes.len(),
            self.outcomes().map(|outcome| outcome.record()),
        )
    }

    /// Get an iterator over the payoffs of previously played games.
    pub fn payoffs(&self) -> Past<&Payoff<U, P>> {
        Past::from_iter(
            self.outcomes.len(),
            self.outcomes().map(|outcome| outcome.payoff()),
        )
    }

    /// Get the cumulative score of all previously played games.
    pub fn score(&self) -> &Payoff<U, P> {
        &self.score
    }
}

impl<M: Move, U: Utility, const P: usize> History<M, U, SimultaneousOutcome<M, U, P>, P> {
    /// Get an iterator over the profiles of previously played games.
    pub fn profiles(&self) -> Past<&Profile<M, P>> {
        Past::from_iter(
            self.outcomes.len(),
            self.outcomes().map(|outcome| outcome.profile()),
        )
    }

    /// Get an iterator over all moves played by a given player.
    pub fn moves_for_player(&self, player: PlayerIndex<P>) -> Past<M> {
        Past::from_iter(
            self.outcomes.len(),
            self.profiles().map(move |profile| profile[player]),
        )
    }
}

impl<S: State, M: Move, U: Utility, const P: usize>
    History<M, U, SequentialOutcome<S, M, U, P>, P>
{
    /// Get an iterator over the transcripts of previously played games.
    pub fn transcripts(&self) -> Past<&Transcript<M, P>> {
        Past::from_iter(
            self.outcomes.len(),
            self.outcomes().map(|outcome| outcome.transcript()),
        )
    }
}

impl<M: Move, U: Utility, O: Outcome<M, U, P>, const P: usize> Default for History<M, U, O, P> {
    fn default() -> Self {
        History {
            outcomes: im::Vector::new(),
            score: Payoff::zeros(),
            summary: Summary::empty(),
            move_type: PhantomData,
        }
    }
}

impl<M: Move, U: Utility, O: Outcome<M, U, P>, const P: usize> Record<M, P>
    for History<M, U, O, P>
{
    fn plies(&self) -> Plies<M, P> {
        Past::from_iter(
            self.outcomes.len(),
            self.outcomes
                .iter()
                .flat_map(|outcome| outcome.record().plies()),
        )
    }

    fn summary(&self) -> Summary<P> {
        self.summary
    }
}

impl<M: Move, U: Utility, O: Outcome<M, U, P>, const P: usize> Outcome<M, U, P>
    for History<M, U, O, P>
{
    type Record = Self;

    fn record(&self) -> &Self {
        self
    }

    fn payoff(&self) -> &Payoff<U, P> {
        &self.score
    }
}