Struct genevo::ga::GeneticAlgorithm

pub struct GeneticAlgorithm<G, F, E, S, C, M, R> where
    G: Genotype,
    F: Fitness,
    E: FitnessFunction<G, F>,
    S: SelectionOp<G, F>,
    C: CrossoverOp<G>,
    M: MutationOp<G>,
    R: ReinsertionOp<G, F>,  { /* fields omitted */ }

A GeneticAlgorithm declares the building blocks that make up the actual algorithm for a specific optimization problem.

Methods

impl<G, F, E, S, C, M, R> GeneticAlgorithm<G, F, E, S, C, M, R> where
    G: Genotype,
    F: Fitness,
    E: FitnessFunction<G, F>,
    S: SelectionOp<G, F>,
    C: CrossoverOp<G>,
    M: MutationOp<G>,
    R: ReinsertionOp<G, F>, 

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

pub fn evaluator(&self) -> &E

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

pub fn selector(&self) -> &S

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

pub fn breeder(&self) -> &C

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

pub fn mutator(&self) -> &M

Important traits for &'a mut W

impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

pub fn reinserter(&self) -> &R

pub fn min_population_size(&self) -> usize

Trait Implementations

impl<G: Clone, F: Clone, E: Clone, S: Clone, C: Clone, M: Clone, R: Clone> Clone for GeneticAlgorithm<G, F, E, S, C, M, R> where
    G: Genotype,
    F: Fitness,
    E: FitnessFunction<G, F>,
    S: SelectionOp<G, F>,
    C: CrossoverOp<G>,
    M: MutationOp<G>,
    R: ReinsertionOp<G, F>, 

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<G: Debug, F: Debug, E: Debug, S: Debug, C: Debug, M: Debug, R: Debug> Debug for GeneticAlgorithm<G, F, E, S, C, M, R> where
    G: Genotype,
    F: Fitness,
    E: FitnessFunction<G, F>,
    S: SelectionOp<G, F>,
    C: CrossoverOp<G>,
    M: MutationOp<G>,
    R: ReinsertionOp<G, F>, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<G: PartialEq, F: PartialEq, E: PartialEq, S: PartialEq, C: PartialEq, M: PartialEq, R: PartialEq> PartialEq for GeneticAlgorithm<G, F, E, S, C, M, R> where
    G: Genotype,
    F: Fitness,
    E: FitnessFunction<G, F>,
    S: SelectionOp<G, F>,
    C: CrossoverOp<G>,
    M: MutationOp<G>,
    R: ReinsertionOp<G, F>, 

fn eq(&self, __arg_0: &GeneticAlgorithm<G, F, E, S, C, M, R>) -> bool

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

fn ne(&self, __arg_0: &GeneticAlgorithm<G, F, E, S, C, M, R>) -> bool

This method tests for !=.

impl<G, F, E, S, C, M, R> TrackProcessingTime for GeneticAlgorithm<G, F, E, S, C, M, R> where
    G: Genotype,
    F: Fitness,
    E: FitnessFunction<G, F>,
    S: SelectionOp<G, F>,
    C: CrossoverOp<G>,
    M: MutationOp<G>,
    R: ReinsertionOp<G, F>, 

fn processing_time(&self) -> &ProcessingTime

impl<G, F, E, S, C, M, R> Algorithm for GeneticAlgorithm<G, F, E, S, C, M, R> where
    G: Genotype,
    F: Fitness + Send + Sync,
    E: FitnessFunction<G, F> + Sync,
    S: SelectionOp<G, F>,
    C: CrossoverOp<G> + Sync,
    M: MutationOp<G> + Sync,
    R: ReinsertionOp<G, F>, 

type Output = State<G, F>

type Error = GeneticAlgorithmError

fn reset(&mut self) -> Result<bool, Self::Error>

fn next(
    &mut self,
    iteration: u64,
    rng: &mut Prng
) -> Result<Self::Output, Self::Error>

impl<G, F, E, S, C, M, R> Termination<GeneticAlgorithm<G, F, E, S, C, M, R>> for FitnessLimit<G, F> where
    G: Genotype,
    F: Fitness + Send + Sync,
    E: FitnessFunction<G, F>,
    E: FitnessFunction<G, F> + Sync,
    S: SelectionOp<G, F>,
    C: CrossoverOp<G> + Sync,
    M: MutationOp<G> + Sync,
    R: ReinsertionOp<G, F>, 

fn evaluate(
    &mut self,
    state: &State<GeneticAlgorithm<G, F, E, S, C, M, R>>
) -> StopFlag

Evaluates the termination condition and returns a StopFlag depending on the result. The StopFlag indicates whether the simulation shall stop or continue.

fn reset(&mut self)

Resets the state of this Termination condition. This function is called on each Termination instance when the simulation is reset.