Struct genevo::selection::tournament::TournamentSelector

pub struct TournamentSelector { /* private fields */ }

The TournamentSelector implements the tournament selection method. It runs tournaments with a small size of participants and pick the best performing individuals from each tournament.

The number of participants in each tournament is configurable by the tournament_size field. A tournament size of 1 is called 1-way tournament and is equivalent to random selection.

The final selection is picked from the best performing participants in each tournament but with a probability. The probability gives also chances to the second best, third best and so on. The probability is configurable by the probability field. A probability of 1.0 means the tournament is deterministic. The best and only the best individual of each tournament is selected.

To avoid that candidates chosen once are selected again they are removed from the list of candidates. Though this can be configured as well. The field remove_selected_individuals controls whether selected candidates are removed or not.

This TournamentSelector can be used for single-objective fitness values as well as multi-objective fitness values.

Implementations

impl TournamentSelector

pub fn new(
    selection_ratio: f64,
    num_individuals_per_parents: usize,
    tournament_size: usize,
    probability: f64,
    remove_selected_individuals: bool
) -> Self

Constructs a new instance of the TournamentSelector.

pub fn selection_ratio(&self) -> f64

Returns the selection ratio.

The selection ratio is the fraction of number of parents that are selected on every call of the select_from function and the number of individuals in the population.

pub fn set_selection_ratio(&mut self, value: f64)

Sets the selection ratio to a new value.

The selection ratio is the fraction of number of parents that are selected on every call of the select_from function and the number of individuals in the population.

pub fn num_individuals_per_parents(&self) -> usize

Returns the number of individuals per parents use by this selector.

pub fn set_num_individuals_per_parents(&mut self, value: usize)

Sets the number of individuals per parents to the given value.

pub fn tournament_size(&self) -> usize

Returns the size of one tournament.

pub fn set_tournament_size(&mut self, value: usize)

Sets the size of one tournament to a given value. The value must be a positive integer greater 0.

A tournament size of 1 is called 1-way tournament and is equivalent to random selection.

pub fn probability(&self) -> f64

Returns the probability to pick candidates from one tournament.

pub fn set_probability(&mut self, value: f64)

Set the probability to pick candidates from one tournament to the given value. The value must be between 0 and 1.0 (inclusive).

A probability of 1.0 means the tournament is deterministic. The best and only the best individual of each tournament is selected.

pub fn is_remove_selected_individuals(&self) -> bool

Returns whether individuals are removed from the list of candidates after they have been picked once.

pub fn set_remove_selected_individuals(&mut self, value: bool)

Sets whether individuals shall be removed from the list of candidates after they have been picked once.

Trait Implementations

impl Clone for TournamentSelector

fn clone(&self) -> TournamentSelector

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TournamentSelector

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

Formats the value using the given formatter.

impl GeneticOperator for TournamentSelector

fn name() -> String

The name of the operator used for display purposes. The name should make clear to the user of the simulation which implementation of which kind of operator is being performed.

impl PartialEq<TournamentSelector> for TournamentSelector

fn eq(&self, other: &TournamentSelector) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &TournamentSelector) -> bool

This method tests for !=.

impl<G, F> SelectionOp<G, F> for TournamentSelector where
    G: Genotype,
    F: Fitness, 

fn select_from<R>(
    &self,
    evaluated: &EvaluatedPopulation<G, F>,
    rng: &mut R
) -> Vec<Parents<G>> where
    R: Rng + Sized, 

Selects individuals from the given population according to the implemented selection strategy.

impl MultiObjective for TournamentSelector

Can be used for multi-objective optimization

impl SingleObjective for TournamentSelector

Can be used for single-objective optimization

impl StructuralPartialEq for TournamentSelector