Struct genetic_algorithm::strategy::permutate::Permutate

pub struct Permutate<G: PermutableGenotype, F: Fitness<Allele = G::Allele>, SR: PermutateReporter<Allele = G::Allele>> {
    pub config: PermutateConfig,
    pub state: PermutateState<G::Allele>,
    /* private fields */
}

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.

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.

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 mut rng = rand::thread_rng(); // unused randomness provider implementing Trait rand::Rng
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_reporter(PermutateReporterSimple::new(100)) // optional builder step, report every 100 generations
    .with_multithreading(true)                        // optional, defaults to false, use all cores
    .call(&mut rng)
    .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

config: PermutateConfig

state: PermutateState<G::Allele>

Implementations

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

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

Trait Implementations

impl<G: PermutableGenotype, F: Fitness<Allele = G::Allele>, SR: PermutateReporter<Allele = G::Allele>> 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<Allele = G::Allele>, SR: PermutateReporter<Allele = G::Allele>> Strategy<G> for Permutate<G, F, SR>

fn call<R: Rng>(&mut self, rng: &mut R)

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

fn best_generation(&self) -> usize

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

impl<G: PermutableGenotype, F: Fitness<Allele = G::Allele>, SR: PermutateReporter<Allele = G::Allele>> 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.