kingmaker 0.1.0

A modular, performant, social choice framework for the simulation, computation, and analysis of strategic voting.
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

//! A collection of `methods` that can be used to tabulate the results of an election.
mod approval;
mod borda;
mod instant_runoff;
mod plurality;
mod random_dictator;
mod single_transferable_vote;
mod star;

pub use approval::Approval;
pub use borda::Borda;
pub use instant_runoff::IRV;
pub use plurality::Plurality;
pub use random_dictator::RandomDictator;
pub use single_transferable_vote::STV;
pub use star::Star;

#[cfg(test)]
mod tests {
    use crate::prelude::{methods::*, *};
    use std::collections::{BTreeMap, BTreeSet};

    fn candidates() -> Vec<Candidate> {
        vec![
            Candidate::new(0, "A", Some("DEM"), None),
            Candidate::new(1, "B", Some("REP"), None),
            Candidate::new(2, "C", None, None),
        ]
    }

    fn nominal_ballots() -> Profile<Nominal> {
        vec![
            Nominal(BTreeSet::from([])),
            Nominal(BTreeSet::from([])),
            Nominal(BTreeSet::from([0, 1])),
            Nominal(BTreeSet::from([1])),
            Nominal(BTreeSet::from([2])),
        ]
        .into()
    }

    fn ordinal_ballots() -> Profile<Ordinal> {
        vec![
            Ordinal(vec![0, 1, 2]),
            Ordinal(vec![1, 0, 2]),
            Ordinal(vec![2, 1, 0]),
            Ordinal(vec![2, 0, 1]),
            Ordinal(vec![0, 1, 2]),
            Ordinal(vec![2, 1, 0]),
        ]
        .into()
    }

    fn cardinal_ballots() -> Profile<Cardinal> {
        vec![
            Cardinal(BTreeMap::from([(0, 4), (1, 3), (2, 4)])),
            Cardinal(BTreeMap::from([(0, 4), (1, 1), (2, 2)])),
            Cardinal(BTreeMap::from([(0, 0), (1, 5), (2, 0)])),
            Cardinal(BTreeMap::from([(0, 0), (1, 2), (2, 1)])),
            Cardinal(BTreeMap::from([(0, 4), (1, 3), (2, 0)])),
        ]
        .into()
    }

    #[test]
    fn random_dictator_outcome() {
        let candidates = candidates();
        let ballots: Profile<Ordinal> = ordinal_ballots();
        let outcome = RandomDictator.outcome(&candidates, ballots);
        assert_eq!(outcome, SingleWinner::win(&candidates, 0));
    }

    #[test]
    fn plurality_outcome() {
        let candidates = candidates();
        let ballots = ordinal_ballots();
        let outcome = Plurality.outcome(&candidates, ballots);
        assert_eq!(outcome, SingleWinner::win(&candidates, 2));
    }

    #[test]
    fn approval_outcome() {
        let candidates = candidates();
        let ballots = nominal_ballots();
        let outcome = Approval.outcome(&candidates, ballots);
        assert_eq!(outcome, SingleWinner::win(&candidates, 1));
    }

    #[test]
    fn borda_outcome() {
        let candidates = candidates();
        let ballots = ordinal_ballots();
        let outcome = Borda.outcome(&candidates, ballots);
        assert_eq!(outcome, SingleWinner::tie(&candidates, &[0, 1, 2]));
    }

    #[test]
    fn star_outcome() {
        let candidates = candidates();
        let ballots = cardinal_ballots();
        let outcome = Star.outcome(&candidates, ballots);
        assert_eq!(outcome, SingleWinner::win(&candidates, 0));
    }

    #[test]
    fn instant_runoff_outcome() {
        let candidates = candidates();
        let ballots = ordinal_ballots();
        let outcome = IRV.outcome(&candidates, ballots);
        assert_eq!(outcome, SingleWinner::tie(&candidates, &[0, 2]));
    }

    #[test]
    fn single_transferable_vote_outcome() {
        let candidates = candidates();
        let ballots = ordinal_ballots();
        let outcome = STV::new(2).outcome(&candidates, ballots);
        assert_eq!(outcome, MultiWinner::seats(&candidates, &[1, 2]));
    }
}