Struct Permutate

pub struct Permutate<G: PermutateGenotype, F: Fitness<Genotype = G>, SR: StrategyReporter<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 (unless the genotype seeds specific genes, in which case only those genes are iterated over). 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 StrategyReporter (e.g. PermutateReporterDuration, PermutateReporterSimple). But you are encouraged to roll your own, see StrategyReporter.

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(12)                 // 12 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 genes after all
let (best_genes, best_fitness_score) = permutate.best_genes_and_fitness_score().unwrap();
assert_eq!(best_genes, vec![false; 12]);
assert_eq!(best_fitness_score, 0);

Fields

genotype: G

fitness: F

config: PermutateConfig

state: PermutateState<G>

reporter: SR

Implementations

impl<G: PermutateGenotype, F: Fitness<Genotype = G>, SR: StrategyReporter<Genotype = G>> Permutate<G, F, SR>

where G::Chromosome: GenesOwner<Genes = G::Genes>,

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

impl<G: PermutateGenotype, F: Fitness<Genotype = G>> Permutate<G, F, StrategyReporterNoop<G>>

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

impl<G: PermutateGenotype, F: Fitness<Genotype = G>, SR: StrategyReporter<Genotype = G>> Permutate<G, F, SR>

pub fn setup(&mut self)

pub fn cleanup(&mut self)

Trait Implementations

impl<G: PermutateGenotype, F: Fitness<Genotype = G>, SR: StrategyReporter<Genotype = G>> Display for Permutate<G, F, SR>

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

Formats the value using the given formatter.

impl<G: PermutateGenotype, F: Fitness<Genotype = G>, SR: StrategyReporter<Genotype = G>> Strategy<G> for Permutate<G, F, SR>

fn call(&mut self)

fn best_generation(&self) -> usize

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

fn best_genes(&self) -> Option<G::Genes>

fn flush_reporter(&mut self, output: &mut Vec<u8>)

strategy can be boxed, need a way to get to the reporter

fn best_genes_and_fitness_score(&self) -> Option<(G::Genes, FitnessValue)>

impl<G: PermutateGenotype, F: Fitness<Genotype = G>, SR: StrategyReporter<Genotype = G>> TryFrom<Builder<G, F, SR>> for Permutate<G, F, SR>

type Error = TryFromStrategyBuilderError

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.