Struct TournamentSelection 

pub struct TournamentSelection {
    pub tournament_size: usize,
    pub with_replacement: bool,
}

Tournament selection operator

Selects the best individual from a randomly sampled subset (the “tournament”) of the population.

Sampling with vs. without replacement

By default competitors are sampled with replacement (each of the k competitors is drawn independently and uniformly from the whole population). This is the textbook model, for which the probability that the individual of rank i wins has the clean closed form and selection pressure grows smoothly with k; the same individual may appear more than once in a tournament. Crucially, tournament_size >= population size does not make selection deterministic under this model — a draw of k = n competitors with replacement includes the global best only with probability 1 - ((n-1)/n)^k (≈ 0.63 at k = n).

The without-replacement variant (constructed via without_replacement) instead draws k distinct individuals; there the tournament size is capped at the population size and k >= n degenerates to fully elitist selection (the global best is chosen every call).

Fields

tournament_size: usize

Tournament size (number of individuals competing)

with_replacement: bool

Whether competitors are sampled with replacement (canonical default) or as distinct individuals.

Implementations

impl TournamentSelection

pub fn new(tournament_size: usize) -> Self

Create a new tournament selection with the given size (sampling with replacement, the canonical model).

pub fn binary() -> Self

Create binary tournament selection (size = 2, with replacement)

pub fn without_replacement(tournament_size: usize) -> Self

Create a tournament selection that samples tournament_size distinct competitors (without replacement).

Note that with this variant tournament_size >= population size selects the global best deterministically every call.

Trait Implementations

impl Clone for TournamentSelection

fn clone(&self) -> TournamentSelection

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TournamentSelection

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<G: EvolutionaryGenome> SelectionOperator<G> for TournamentSelection

fn select<R: Rng>(&self, population: &[(G, f64)], rng: &mut R) -> usize

Select a single individual from the population

fn select_many<R: Rng>( &self, population: &[(G, f64)], count: usize, rng: &mut R, ) -> Vec<usize>

Select multiple individuals from the population