Struct SelectTournament

pub struct SelectTournament {
    pub replacement_rate: f32,
    pub elitism_rate: f32,
    pub tournament_size: usize,
}

Run tournaments with randomly chosen chromosomes and pick a single winner. Do this untill the target_population_size (or full population when in shortage) of the population is reached and drop excess chromosomes. This approach kind of sorts the fitness first, but not very strictly. This preserves a level of diversity, which avoids local optimum lock-in.

Fields

replacement_rate: f32

elitism_rate: f32

tournament_size: usize

Implementations

impl Tournament

pub fn new( replacement_rate: f32, elitism_rate: f32, tournament_size: usize, ) -> Self

pub fn selection<G: EvolveGenotype, R: Rng>( &self, chromosomes: &mut Vec<G::Chromosome>, selection_size: usize, genotype: &mut G, config: &EvolveConfig, rng: &mut R, )

Trait Implementations

impl Clone for Tournament

fn clone(&self) -> Tournament

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Tournament

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

Formats the value using the given formatter.

impl From<Tournament> for Wrapper

fn from(select: SelectTournament) -> Self

Converts to this type from the input type.

impl Select for Tournament

fn call<G: EvolveGenotype, R: Rng, SR: StrategyReporter<Genotype = G>>( &mut self, genotype: &mut G, state: &mut EvolveState<G>, config: &EvolveConfig, _reporter: &mut SR, rng: &mut R, )

fn extract_elite_chromosomes<G: EvolveGenotype>( &self, state: &mut EvolveState<G>, config: &EvolveConfig, elitism_rate: f32, ) -> Vec<G::Chromosome>

fn parent_and_offspring_survival_sizes( &self, parents_size: usize, offspring_size: usize, target_size: usize, replacement_rate: f32, ) -> (usize, usize)