electosim 0.3.0

Library to compute electoral methods (as D'Hondt) and simulate elections
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
130
131
132
133
134
135

//! # Divisor methods
//! Each seat is assigned to the candidate with the highest result of the division of the number of votes by a divisor.
//! The divisor is a function that takes the number of seats won by the candidate and returns a float number.
//!
//! All divisor methods are implemented based on the [compute_divisor_method] function.

use crate::{
    interface::{WithSeats, WithVotes},
    utils::clear_results,
};

/// A factory for divisor methods.
///
///
/// # Arguments
///
/// * `results` - A mutable reference to a vector of candidates.
/// * `seats` - The number of seats available in the election.
/// * `divisor` - A function that takes the number of seats won by the candidate and returns a float number.
///
/// # Example (D'Hondt method)
///
/// ```rust
/// use electosim::methods::divisor::compute_divisor_method;
/// use electosim::models::Candidacy;
///
/// let mut candidacies = vec![
///    Candidacy::new(2010, 0),
///    Candidacy::new(1018, 0),
///    Candidacy::new(86, 0),
///    Candidacy::new(77, 0),
/// ];
///
/// compute_divisor_method(&mut candidacies, 13, |s| (s + 1) as f32).unwrap();
/// ```
pub fn compute_divisor_method<'a, T>(
    results: &'a mut Vec<T>,
    seats: u16,
    divisor: impl Fn(u16) -> f32,
) -> Result<(), &'a str>
where
    T: WithSeats + WithVotes,
{
    clear_results(results);

    for _ in 0..seats {
        let better_idx = results
            .iter()
            .map(|c| {
                let votes = c.get_votes() as f32;
                let seats = c.get_seats();
                let div = divisor(seats);

                votes / div
            })
            .enumerate()
            .max_by(|(_, a), (_, b)| a.total_cmp(b));

        match better_idx {
            Some((idx, _)) => results[idx].increase_seats(1),
            None => return Err("EMPTY_RESULTS"),
        }
    }

    Ok(())
}

#[allow(dead_code)]
pub fn compute_dhondt<T>(results: &mut Vec<T>, seats: u16) -> Result<(), &str>
where
    T: WithSeats + WithVotes,
{
    compute_divisor_method(results, seats, |s| (s + 1) as f32)
}

#[allow(dead_code)]
pub fn compute_sainte_lague<T>(results: &mut Vec<T>, seats: u16) -> Result<(), &str>
where
    T: WithSeats + WithVotes,
{
    compute_divisor_method(results, seats, |s| (2 * s + 1) as f32)
}

#[allow(dead_code)]
pub fn compute_adams<T>(results: &mut Vec<T>, seats: u16) -> Result<(), &str>
where
    T: WithSeats + WithVotes,
{
    compute_divisor_method(results, seats, |s| s as f32)
}

#[allow(dead_code)]
pub fn compute_imperiali<T>(results: &mut Vec<T>, seats: u16) -> Result<(), &str>
where
    T: WithSeats + WithVotes,
{
    compute_divisor_method(results, seats, |s| (s + 2) as f32)
}

#[allow(dead_code)]
pub fn compute_huntington_hill<T>(results: &mut Vec<T>, seats: u16) -> Result<(), &str>
where
    T: WithSeats + WithVotes,
{
    compute_divisor_method(results, seats, |s| ((s * (s + 1)) as f32).sqrt())
}

#[allow(dead_code)]
pub fn compute_danish<T>(results: &mut Vec<T>, seats: u16) -> Result<(), &str>
where
    T: WithSeats + WithVotes,
{
    compute_divisor_method(results, seats, |s| (3 * s + 1) as f32)
}

#[allow(dead_code)]
pub fn compute_wta<T>(results: &mut Vec<T>, seats: u16) -> Result<(), &str>
where
    T: WithSeats + WithVotes,
{
    clear_results(results);

    let better_idx = results
        .iter()
        .map(|c| c.get_votes())
        .enumerate()
        .max_by(|(_, a), (_, b)| a.cmp(b));

    match better_idx {
        Some((idx, _)) => results[idx].set_seats(seats),
        None => return Err("EMPTY_RESULTS"),
    }

    Ok(())
}