Struct genetic_algorithm::strategy::permutate::Permutate

pub struct Permutate<G: PermutableGenotype, F: Fitness<Genotype = G>, SR: PermutateReporter<Genotype = G>> {
    pub genotype: G,
    pub fitness: F,
    pub config: PermutateConfig,
    pub state: PermutateState<G>,
    pub reporter: SR,
}

All possible combinations of genes are iterated over as chromosomes. The fitness is calculated for each chromosome and the best is taken. For efficiency reasons the full population is never instantiated as a whole.

The chromosome_permutations_size is subject to combinatorial explosion, so check the genotype for practical values before using the Permutate strategy. This will not pose any memory issues, as the permutations are not instantiated at the same time, just iterated over. But it will take forever…

There are reporting hooks in the loop receiving the PermutateState, which can by handled by an PermutateReporter (e.g. PermutateReporterNoop, PermutateReporterSimple). But you are encouraged to roll your own, see PermutateReporter.

See PermutateBuilder for initialization options.

All multithreading mechanisms are implemented using rayon::iter and std::sync::mpsc.

Example:

use genetic_algorithm::strategy::permutate::prelude::*;
use genetic_algorithm::fitness::placeholders::CountTrue;

// the search space
let genotype = BinaryGenotype::builder() // boolean alleles
    .with_genes_size(16)                 // 16 genes per chromosome
    .build()
    .unwrap();

// the search strategy
let permutate = Permutate::builder()
    .with_genotype(genotype)
    .with_fitness(CountTrue)                          // count the number of true values in the chromosomes
    .with_fitness_ordering(FitnessOrdering::Minimize) // aim for the least true values
    .with_par_fitness(true)                           // optional, defaults to false, use parallel fitness calculation
    .with_reporter(PermutateReporterSimple::new(100)) // optional builder step, report every 100 generations
    .call()
    .unwrap();

// it's all about the best chromosome after all
let best_chromosome = permutate.best_chromosome().unwrap();
assert_eq!(best_chromosome.genes, vec![false; 16])

Fields

genotype: G

fitness: F

config: PermutateConfig

state: PermutateState<G>

reporter: SR

Implementations

impl<G: PermutableGenotype, F: Fitness<Genotype = G>> Permutate<G, F, PermutateReporterNoop<G>>

pub fn builder() -> PermutateBuilder<G, F, PermutateReporterNoop<G>>

impl<G: PermutableGenotype, F: Fitness<Genotype = G>, SR: PermutateReporter<Genotype = G>> Permutate<G, F, SR>

pub fn init(&mut self)

Trait Implementations

impl<G: PermutableGenotype, F: Fitness<Genotype = G>, SR: PermutateReporter<Genotype = G>> Display for Permutate<G, F, SR>

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

Formats the value using the given formatter.

impl<G: PermutableGenotype, F: Fitness<Genotype = G>, SR: PermutateReporter<Genotype = G>> Strategy<G> for Permutate<G, F, SR>

fn call(&mut self)

fn best_chromosome(&self) -> Option<Chromosome<G>>

fn best_generation(&self) -> usize

fn best_fitness_score(&self) -> Option<FitnessValue>

impl<G: PermutableGenotype, F: Fitness<Genotype = G>, SR: PermutateReporter<Genotype = G>> TryFrom<Builder<G, F, SR>> for Permutate<G, F, SR>

type Error = TryFromBuilderError

The type returned in the event of a conversion error.

fn try_from(builder: PermutateBuilder<G, F, SR>) -> Result<Self, Self::Error>

Performs the conversion.