Struct DifferentialEvolution 

pub struct DifferentialEvolution {
    pub config: DifferentialEvolutionConfig,
    pub bounds: RealBounds,
}

Single-objective DE/rand/1/bin (spec §12.4).

Vec<f64> decisions only; single-objective problems only. Bounds come from the embedded RealBounds, and mutant vectors are clamped to those bounds.

Example

use heuropt::prelude::*;

struct Sphere;
impl Problem for Sphere {
    type Decision = Vec<f64>;
    fn objectives(&self) -> ObjectiveSpace {
        ObjectiveSpace::new(vec![Objective::minimize("f")])
    }
    fn evaluate(&self, x: &Vec<f64>) -> Evaluation {
        Evaluation::new(vec![x.iter().map(|v| v * v).sum::<f64>()])
    }
}

let mut opt = DifferentialEvolution::new(
    DifferentialEvolutionConfig {
        population_size: 20,
        generations: 50,
        differential_weight: 0.5,
        crossover_probability: 0.9,
        seed: 42,
    },
    RealBounds::new(vec![(-5.0, 5.0); 5]),
);
let r = opt.run(&Sphere);
// DE crushes Sphere; expect very small objective.
assert!(r.best.unwrap().evaluation.objectives[0] < 1e-3);

Fields

config: DifferentialEvolutionConfig

Algorithm configuration.

bounds: RealBounds

Per-variable bounds — used both to seed the population and to clamp mutants.

Implementations

impl DifferentialEvolution

pub fn new(config: DifferentialEvolutionConfig, bounds: RealBounds) -> Self

Construct a DifferentialEvolution optimizer.

Trait Implementations

impl AlgorithmInfo for DifferentialEvolution

fn name(&self) -> &'static str

Canonical short algorithm name — e.g. "NSGA-II", "DE", "CMA-ES". This is the form that should appear in tables, plot legends, and exported JSON metadata.

fn full_name(&self) -> &'static str

Academic long name, expanded — e.g. "Non-dominated Sorting Genetic Algorithm II". Defaults to name() for algorithms whose short and long forms coincide (Random Search, Hill Climber, Tabu Search, Hyperband, …).

fn seed(&self) -> Option<u64>

The deterministic seed driving this run, if the algorithm uses one. Default: None. Built-in algorithms return Some(self.config.seed).

impl Clone for DifferentialEvolution

fn clone(&self) -> DifferentialEvolution

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DifferentialEvolution

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

Formats the value using the given formatter.

impl<P> Optimizer<P> for DifferentialEvolution

where P: Problem<Decision = Vec<f64>> + Sync,

fn run(&mut self, problem: &P) -> OptimizationResult<P::Decision>

Run the optimizer to completion against problem.