Struct genetic_algorithm::strategy::permutate::Permutate

pub struct Permutate<G: PermutableGenotype, F: Fitness<Genotype = G>> {
    pub population_size: BigUint,
    /* 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.

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_multithreading(true)                        // 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

population_size: BigUint

Implementations

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

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

Trait Implementations

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

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

Formats the value using the given formatter.

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

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

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>> TryFrom<Builder<G, F>> for Permutate<G, F>

type Error = TryFromBuilderError

The type returned in the event of a conversion error.

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

Performs the conversion.