Struct genetic_algorithm::strategy::evolve::EvolveBuilder

pub struct EvolveBuilder<G: Genotype, M: Mutate, F: Fitness<Allele = G::Allele>, S: Crossover, C: Compete, E: Extension, SR: EvolveReporter<Allele = G::Allele>> {

    pub genotype: Option<G>,
    pub target_population_size: usize,
    pub max_stale_generations: Option<usize>,
    pub max_chromosome_age: Option<usize>,
    pub target_fitness_score: Option<FitnessValue>,
    pub valid_fitness_score: Option<FitnessValue>,
    pub fitness_ordering: FitnessOrdering,
    pub par_fitness: bool,
    pub replace_on_equal_fitness: bool,
    pub mutate: Option<M>,
    pub fitness: Option<F>,
    pub crossover: Option<S>,
    pub compete: Option<C>,
    pub extension: E,
    pub reporter: SR,
    pub rng_seed: Option<u64>,
}

The builder for an Evolve struct.

Fields

genotype: Option<G>

target_population_size: usize

max_stale_generations: Option<usize>

max_chromosome_age: Option<usize>

target_fitness_score: Option<FitnessValue>

valid_fitness_score: Option<FitnessValue>

fitness_ordering: FitnessOrdering

par_fitness: bool

replace_on_equal_fitness: bool

mutate: Option<M>

fitness: Option<F>

crossover: Option<S>

compete: Option<C>

extension: E

reporter: SR

rng_seed: Option<u64>

Implementations

impl<G: Genotype, M: Mutate, F: Fitness<Allele = G::Allele>, S: Crossover, C: Compete> Builder<G, M, F, S, C, ExtensionNoop, EvolveReporterNoop<G::Allele>>

pub fn new() -> Self

impl<G: Genotype, M: Mutate, F: Fitness<Allele = G::Allele>, S: Crossover, C: Compete, E: Extension, SR: EvolveReporter<Allele = G::Allele>> Builder<G, M, F, S, C, E, SR>

pub fn build(self) -> Result<Evolve<G, M, F, S, C, E, SR>, TryFromBuilderError>

pub fn with_genotype(self, genotype: G) -> Self

pub fn with_target_population_size(self, target_population_size: usize) -> Self

pub fn with_max_stale_generations(self, max_stale_generations: usize) -> Self

pub fn with_max_stale_generations_option( self, max_stale_generations_option: Option<usize>, ) -> Self

pub fn with_max_chromosome_age(self, max_chromosome_age: usize) -> Self

pub fn with_max_chromosome_age_option( self, max_chromosome_age_option: Option<usize>, ) -> Self

pub fn with_target_fitness_score( self, target_fitness_score: FitnessValue, ) -> Self

pub fn with_target_fitness_score_option( self, target_fitness_score_option: Option<FitnessValue>, ) -> Self

pub fn with_valid_fitness_score(self, valid_fitness_score: FitnessValue) -> Self

pub fn with_valid_fitness_score_option( self, valid_fitness_score_option: Option<FitnessValue>, ) -> Self

pub fn with_fitness_ordering(self, fitness_ordering: FitnessOrdering) -> Self

pub fn with_par_fitness(self, par_fitness: bool) -> Self

pub fn with_replace_on_equal_fitness( self, replace_on_equal_fitness: bool, ) -> Self

pub fn with_mutate(self, mutate: M) -> Self

pub fn with_fitness(self, fitness: F) -> Self

pub fn with_crossover(self, crossover: S) -> Self

pub fn with_compete(self, compete: C) -> Self

pub fn with_extension<E2: Extension>( self, extension: E2, ) -> Builder<G, M, F, S, C, E2, SR>

pub fn with_reporter<SR2: EvolveReporter<Allele = G::Allele>>( self, reporter: SR2, ) -> Builder<G, M, F, S, C, E, SR2>

pub fn with_rng_seed_from_u64(self, rng_seed: u64) -> Self

impl<G: Genotype, M: Mutate, F: Fitness<Allele = G::Allele>, S: Crossover, C: Compete, E: Extension, SR: EvolveReporter<Allele = G::Allele>> Builder<G, M, F, S, C, E, SR>

pub fn rng(&self) -> SmallRng

pub fn call(self) -> Result<Evolve<G, M, F, S, C, E, SR>, TryFromBuilderError>

pub fn call_repeatedly( self, max_repeats: usize, ) -> Result<Evolve<G, M, F, S, C, E, SR>, TryFromBuilderError>

pub fn call_par_repeatedly( self, max_repeats: usize, ) -> Result<Evolve<G, M, F, S, C, E, SR>, TryFromBuilderError>

pub fn call_speciated( self, number_of_species: usize, ) -> Result<Evolve<G, M, F, S, C, E, SR>, TryFromBuilderError>

pub fn call_par_speciated( self, number_of_species: usize, ) -> Result<Evolve<G, M, F, S, C, E, SR>, TryFromBuilderError>

Trait Implementations

impl<G: Clone + Genotype, M: Clone + Mutate, F: Clone + Fitness<Allele = G::Allele>, S: Clone + Crossover, C: Clone + Compete, E: Clone + Extension, SR: Clone + EvolveReporter<Allele = G::Allele>> Clone for Builder<G, M, F, S, C, E, SR>

fn clone(&self) -> Builder<G, M, F, S, C, E, SR>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<G: Debug + Genotype, M: Debug + Mutate, F: Debug + Fitness<Allele = G::Allele>, S: Debug + Crossover, C: Debug + Compete, E: Debug + Extension, SR: Debug + EvolveReporter<Allele = G::Allele>> Debug for Builder<G, M, F, S, C, E, SR>

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

Formats the value using the given formatter.

impl<G: Genotype, M: Mutate, F: Fitness<Allele = G::Allele>, S: Crossover, C: Compete> Default for Builder<G, M, F, S, C, ExtensionNoop, EvolveReporterNoop<G::Allele>>

fn default() -> Self

Returns the “default value” for a type.

impl<G: Genotype, M: Mutate, F: Fitness<Allele = G::Allele>, S: Crossover, C: Compete, E: Extension, SR: EvolveReporter<Allele = G::Allele>> TryFrom<Builder<G, M, F, S, C, E, SR>> for Evolve<G, M, F, S, C, E, SR>

type Error = TryFromBuilderError

The type returned in the event of a conversion error.

fn try_from( builder: EvolveBuilder<G, M, F, S, C, E, SR>, ) -> Result<Self, Self::Error>

Performs the conversion.