Struct BinaryGeneticAlgorithm 

pub struct BinaryGeneticAlgorithm<B: Backend> { /* private fields */ }

Binary-coded canonical Genetic Algorithm.

Example

use burn::backend::Flex;
use rlevo_evolution::algorithms::ga_binary::{BinaryGaConfig, BinaryGeneticAlgorithm};

let strategy = BinaryGeneticAlgorithm::<Flex>::new();
let params = BinaryGaConfig::default_for(32, 16);
let _ = (strategy, params);

Implementations

impl<B: Backend> BinaryGeneticAlgorithm<B>

pub fn new() -> Self

Builds a new (stateless) strategy object.

Trait Implementations

impl<B: Clone + Backend> Clone for BinaryGeneticAlgorithm<B>

fn clone(&self) -> BinaryGeneticAlgorithm<B>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<B: Copy + Backend> Copy for BinaryGeneticAlgorithm<B>

impl<B: Debug + Backend> Debug for BinaryGeneticAlgorithm<B>

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

Formats the value using the given formatter.

impl<B: Default + Backend> Default for BinaryGeneticAlgorithm<B>

fn default() -> BinaryGeneticAlgorithm<B>

Returns the “default value” for a type.

impl<B: Backend> Strategy<B> for BinaryGeneticAlgorithm<B>

where B::Device: Clone,

fn init( &self, params: &BinaryGaConfig, rng: &mut dyn Rng, device: &<B as BackendTypes>::Device, ) -> BinaryGaState<B>

Build the initial state.

Samples an (pop_size, D) binary population uniformly at random (each gene independently Bernoulli(0.5)) using a host RNG derived from rng. Sets fitness to empty and best_fitness to f32::NEG_INFINITY (the worst value under the maximise convention); the first tell call populates both.

fn ask( &self, params: &BinaryGaConfig, state: &BinaryGaState<B>, rng: &mut dyn Rng, device: &<B as BackendTypes>::Device, ) -> (Tensor<B, 2, Int>, BinaryGaState<B>)

Propose the next offspring population.

On the very first call (before any tell), state.fitness is empty — the harness has not evaluated the seed population yet. In that case the unchanged seed population is returned so the harness can evaluate and pass it back to tell.

On subsequent calls the method runs one full selection → crossover → mutation pipeline, deriving three independent host sub-streams from rng via crate::rng::seed_stream:

• SeedPurpose::Selection — two independent tournament draws (parents A and parents B);
• SeedPurpose::Crossover — per-gene coin flip (probability crossover_p);
• SeedPurpose::Mutation — per-gene bit-flip (probability mutation_rate).

Panics

Propagates the programming-error panics of the delegated host operators once state.fitness is non-empty: tournament_indices_host panics if the fitness slice is empty or tournament_size == 0, and the crossover / mutation operators assume shape-consistent inputs. validate() rules these out for a well-formed config, but BinaryGaState / BinaryGaConfig fields are public and can be mutated into an invalid state after validation.

fn tell( &self, params: &BinaryGaConfig, offspring: Tensor<B, 2, Int>, fitness: Tensor<B, 1>, state: BinaryGaState<B>, _rng: &mut dyn Rng, ) -> (BinaryGaState<B>, StrategyMetrics)

Consume offspring fitness and produce the next generation’s state.

The first call (when state.fitness is empty) caches the seed population’s fitness and increments the generation counter; no replacement is performed.

On subsequent calls the method performs elitist replacement: the elitism_k highest-fitness parents survive directly, and the remaining pop_size − elitism_k slots are filled with the best offspring. Both selections use crate::ops::selection::truncation_indices_host.

fitness must have shape (pop_size,) in the canonical maximise convention — higher is better. The harness canonicalises a Minimize objective (negation) before this call, so the strategy stays sense-unaware per ADR 0023.

Panics

Propagates the programming-error panics of the delegated host path on the elitist-replacement branch: truncation_indices_host and the bare state.fitness[i] indexing assume a pop_size-consistent fitness buffer. validate() rules this out for a well-formed config, but BinaryGaState / BinaryGaConfig fields are public and can be mutated into an inconsistent state after validation. Also panics if fitness cannot be read back as f32.

fn best(&self, state: &BinaryGaState<B>) -> Option<(Tensor<B, 2, Int>, f32)>

Return the best-so-far genome and its fitness.

Returns None before the first tell call. The fitness value uses the canonical maximise convention (higher is better).

type Params = BinaryGaConfig

Static parameters for a run.

type State = BinaryGaState<B>

Generation-to-generation state.

type Genome = Tensor<B, 2, Int>

Genome container produced by ask.