Enum oxigen::survival_pressure::SurvivalPressureFunctions

pub enum SurvivalPressureFunctions {
    Worst,
    ChildrenReplaceMostSimilar,
    ChildrenReplaceParents,
    ChildrenReplaceParentsAndTheRestWorst,
    ChildrenReplaceParentsAndTheRestRandomly,
    ChildrenReplaceParentsAndTheRestRandomMostSimilar,
    ChildrenReplaceParentsAndTheRestMostSimilar,
    ChildrenReplaceParentsAndTheRestOldest,
    ChildrenFightMostSimilar,
    ChildrenFightParents,
    ChildrenFightParentsAndTheRestWorst,
    ChildrenFightParentsAndTheRestRandomly,
    ChildrenFightParentsAndTheRestRandomMostSimilar,
    ChildrenFightParentsAndTheRestMostSimilar,
    ChildrenFightParentsAndTheRestOldest,
    Overpopulation(M),
    CompetitiveOverpopulation(M),
    DeterministicOverpopulation,
}

Provided survival pressure functions.

Variants

Worst

Kill worst individuals until reach the population size.

ChildrenReplaceMostSimilar

Kill the most similar individual to each child.

ChildrenReplaceParents

Kill individuals that have been crossed. Note that since the same parents can produce many different children (they are selected to cross several times) the populationn size can be increased using this function.

ChildrenReplaceParentsAndTheRestWorst

Kill individuals that have been crossed and after that the worst individuals until reach the initial population size.

ChildrenReplaceParentsAndTheRestRandomly

Kill individuals that have been crossed and after that random individuals until reach the initial population size.

ChildrenReplaceParentsAndTheRestRandomMostSimilar

Kill individuals that have been crossed and after that randomly select an individual to fight to the the most similar to it until reach the initial population size. Note that this function is slow using the default Genotype similarity function because genes are compared one by one.

ChildrenReplaceParentsAndTheRestMostSimilar

Kill individuals that have been crossed and after that the most similar individuals until reach the initial population size. Note that this function is slow using the default Genotype similarity function because genes are compared one by one.

ChildrenReplaceParentsAndTheRestOldest

Kill individuals that have been crossed and after that the oldest individuals until reach the initial population size. /// Note that this function is slow because each individual similarity is computed across the rest of individuals of the population.

ChildrenFightMostSimilar

Each child fight with the most similar individual in the population.

ChildrenFightParents

Each child fight with a random parent in a parricide battle for survival. Note that because the same parents can produce many different children (they are selected to cross several times) the populationn size can be increased using this function.

ChildrenFightParentsAndTheRestWorst

Each child fight with a random parent in a parricide battle for survival and after that the worst individuals until reach the initial population size.

ChildrenFightParentsAndTheRestRandomly

Each child fight with a random parent in a parricide battle for survival and after that random individuals until reach the initial population size.

ChildrenFightParentsAndTheRestRandomMostSimilar

Each child fight with a random parent in a parricide battle for survival and after that randomly select an individual to fight to the the most similar to it until reach the initial population size. Note that this function is slow because each individual similarity is computed across the rest of individuals of the population.

ChildrenFightParentsAndTheRestMostSimilar

Each child fight with a random parent in a parricide battle for survival and after that the most similar individuals until reach the initial population size. Note that this function is slow because each individual similarity is computed across the rest of individuals of the population.

ChildrenFightParentsAndTheRestOldest

Each child fight with a random parent in a parricide battle for survival and after that the oldest individuals until reach the initial population size.

Overpopulation(M)

m individuals are randomly selected from the population (note that n < m < population_size where n is the number of generated individuals shall be true) and the most similars to the children are killed one by one.

CompetitiveOverpopulation(M)

Like OverPopulation but the existing individuals in the population that are most similar to each children fight with the corresponding children and the best survive.

DeterministicOverpopulation

Like ChildrenFightParents but instead of random fight between one child with one parent, the tuple of most similar parent-child is selected to fight.

Trait Implementations

impl<T: PartialEq + Send + Sync, G: Genotype<T>> SurvivalPressure<T, G> for SurvivalPressureFunctions

fn kill(
    &self,
    population_size: usize,
    population: &mut Vec<IndWithFitness<T, G>>,
    parents_children: &[Reproduction]
)

Removes individuals according to the population size; the population and the fitness of the population; and the parents and children relationships. Population is not sorted in any particular order, but children are after population_size. Note that in oxigen 1.x versions this function returned the indexes to be deleted without modifying the population, not it directly removes the individuals.