Struct VoteCount 

pub struct VoteCount<I, R> {
    pub sum: Vec<R>,
    pub exhausted: R,
    _phantom: PhantomData<I>,
}

Result of a vote count.

Fields

sum: Vec<R>

Sum of votes for each candidate.

exhausted: R

Exhausted voting power.

_phantom: PhantomData<I>

Implementations

impl<I, R> VoteCount<I, R>

where I: Integer + Send + Sync, for<'a> &'a I: IntegerRef<I>, R: Rational<I> + Send + Sync, for<'a> &'a R: RationalRef<&'a I, R>,

pub fn count_votes( election: &Election, keep_factors: &[R], parallel: Parallel, thread_pool: Option<&VoteCountingThreadPool<'_, I, R>>, pascal: Option<&[Vec<I>]>, ) -> Self

Counts the votes, based on the given keep factors.

fn accumulate_votes_rayon( election: &Election, keep_factors: &[R], pascal: Option<&[Vec<I>]>, ) -> VoteAccumulator<I, R>

Parallel implementation of vote counting, leveraging all CPU cores to speed up the computation.

impl<I, R> VoteCount<I, R>

where I: Integer, for<'a> &'a I: IntegerRef<I>, R: Rational<I>, for<'a> &'a R: RationalRef<&'a I, R>,

pub fn write_stats( &self, out: &mut impl Write, threshold: &R, surplus: &R, ) -> Result<()>

Writes statistics about this vote count to the given output.

fn accumulate_votes_serial( election: &Election, keep_factors: &[R], pascal: Option<&[Vec<I>]>, ) -> VoteAccumulator<I, R>

Serial implementation of vote counting, using only one CPU core.

pub(crate) fn process_ballot( vote_accumulator: &mut VoteAccumulator<I, R>, keep_factors: &[R], pascal: Option<&[Vec<I>]>, i: usize, ballot: &Ballot, )

Processes a ballot and adds its votes to the accumulator.

pub fn threshold(&self, election: &Election) -> R

Computes the new threshold, based on the election parameters and the exhausted votes after this count.

pub fn surplus_droop(&self, threshold: &R, elected: &[usize]) -> R

Computes the current surplus, based on the votes, the threshold and the currently elected candidates, in a manner compatible with Droop.py. This is the sum of the differences between the received vote count and the required threshold, across all elected candidates.

Note: Normally we’d only add positive surpluses here, but sometimes an already elected candidate goes below the threshold. In this case, Droop.py just sums the difference for the elected candidates, which can lead to crashes. See the Self::surplus_positive() function which fixes this behavior.

pub fn surplus_positive(&self, threshold: &R, elected: &[usize]) -> R

Computes the current surplus, based on the votes, the threshold and the currently elected candidates. This is the sum of the differences between the received vote count and the required threshold, across all elected candidates.

Note: Normally we’d only add positive surpluses here, but sometimes an already elected candidate goes below the threshold. In this case, this function counts a positive surplus for this candidate. See the Self::surplus_droop() function for Droop.py’s behavior.

pub fn threshold_exhausted(election: &Election, exhausted: &R) -> R

Computes the new threshold, based on the given election parameters and exhausted votes.

This is the ratio between the effectively used voting power (i.e. subtracted from any exhausted voting power) and the number of elected seats plus one.