Struct DifferentialEvolution 

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

Classical DE/rand/1/bin (and friends).

Example

use burn::backend::Flex;
use rlevo_evolution::algorithms::de::{DeConfig, DeVariant, DifferentialEvolution};

let strategy = DifferentialEvolution::<Flex>::new();
let mut params = DeConfig::default_for(30, 10);
params.variant = DeVariant::Rand1Bin;
let _ = (strategy, params);

Implementations

impl<B: Backend> DifferentialEvolution<B>

pub fn new() -> Self

Builds a new (stateless) strategy object.

Trait Implementations

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

fn clone(&self) -> DifferentialEvolution<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 DifferentialEvolution<B>

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

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

Formats the value using the given formatter.

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

fn default() -> DifferentialEvolution<B>

Returns the “default value” for a type.

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

where B::Device: Clone,

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

Samples the initial population uniformly within params.bounds and returns a DeState with an empty fitness cache, signalling that the first ask/tell cycle should evaluate the initial population rather than generate trial vectors.

Initial sampling goes through seed_stream rather than B::seed + Tensor::random to keep results reproducible across parallel test threads.

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

Proposes the next population of candidate solutions.

First call (fitness cache empty): returns the initial population from DeState::population unchanged so the caller can evaluate it before any mutation/crossover step.

Subsequent calls: for each individual i in 0..pop_size:

1. Sample the required number of distinct random indices (excluding i) via seed_stream with SeedPurpose::Trial.
2. Compute the mutant vector v_i according to DeConfig::variant.
3. Apply binomial or exponential crossover (also seeded through seed_stream with SeedPurpose::Crossover) to blend v_i with the current individual, ensuring at least one gene comes from v_i (j_rand guarantee).
4. Clamp the trial genome to params.bounds.

The returned state is a clone of the input state; no fitness update occurs here — that happens in Strategy::tell.

fn tell( &self, _params: &DeConfig, trial: Tensor<B, 2>, fitness: Tensor<B, 1>, state: DeState<B>, _rng: &mut dyn Rng, ) -> (DeState<B>, StrategyMetrics)

Consumes the evaluated trial population and advances the state.

First call (fitness cache empty): stores the initial population’s fitness, initializes best_genome/best_fitness, and increments the generation counter. No replacement occurs because there are no previous individuals to compare against.

Subsequent calls: applies greedy per-slot replacement — each trial individual replaces its corresponding current individual if and only if trial_fitness[i] >= state.fitness[i]. The best-ever genome and fitness are updated if the new generation improves on state.best_fitness.

Returns the updated DeState and a StrategyMetrics snapshot covering the current generation’s fitness distribution.

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

Returns the best-so-far genome and its canonical (maximise) fitness.

Returns None before the first Strategy::tell call, when DeState::best_genome is still None.

type Params = DeConfig

Static parameters for a run.

type State = DeState<B>

Generation-to-generation state.

type Genome = Tensor<B, 2>

Genome container produced by ask.