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::INFINITY; 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).

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 lowest-cost 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,) with values in the minimization (cost) convention — lower is better.

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 minimization convention (lower 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.