Struct SBXCrossover 

pub struct SBXCrossover { /* private fields */ }

Simulated Binary Crossover (SBX)

A crossover operator for real-valued variables that simulates the behavior of single-point crossover on binary strings. Widely used in multi-objective optimization.

Implementations

impl SBXCrossover

pub fn new(distribution_index: f64) -> Self

Create a new SBX crossover operator

Parameters

• distribution_index: Controls the spread of offspring (typical value: 20.0) Higher values produce offspring closer to parents

pub fn new_default() -> Self

Create with default distribution index

Examples found in repository

examples/zdt1_nsga2_demo.rs (line 23)

fn main() {
    let seed = seed_from_cli_or(42);

    let problem = ZDT1Problem::new(30);

    let parameters = NSGAIIParameters::new(
        60,
        0.9,
        1.0 / 30.0,
        SBXCrossover::new_default(),
        PolynomialMutation::new_default(),
        MultiObjectiveTournamentSelection::new(),
        TerminationCriteria::new(vec![TerminationCriterion::MaxIterations(40)]),
    )
    .with_seed(seed);

    let mut algorithm = NSGAII::new(parameters);
    let observer = ConsoleObserver::new(true);
    let observer2 = ChartObserver::new_default();
    algorithm.add_observer(Box::new(observer));
    algorithm.add_observer(Box::new(observer2));
    let result = algorithm
        .run(&problem)
        .expect("NSGA-II run failed");

    if let Some(best) = result.get(0) {
        println!(
            "NSGA-II finished (seed={}). population={}, best objectives={:?}",
            seed,
            result.size(),
            best.objectives()
        );
    } else {
        println!("NSGA-II finished with empty population (seed={})", seed);
    }
}

Trait Implementations

impl<Q> CrossoverOperator<f64, Q> for SBXCrossover

where Q: Clone + Display,

fn execute( &self, parent1: &Solution<f64, Q>, parent2: &Solution<f64, Q>, rng: &mut Random, ) -> Vec<Solution<f64, Q>>

Applies crossover to two parent solutions and returns offspring.

fn execute_several( &self, solutions: Vec<Solution<f64, Q>>, rng: &mut Random, ) -> Vec<Solution<f64, Q>>

Applies crossover to several parent solutions and returns offspring.

fn number_of_offspring(&self) -> usize

Returns the expected number of offspring produced by this operator

impl Operator for SBXCrossover

fn name(&self) -> &str

Returns the name of the operator for debugging/logging purposes