DSMGA-II

High-performance Rust implementation of DSMGA-II with automatic linkage learning for discrete optimization.

Quick Start

use dsmga2::{Dsmga2, fitness::OneMax};

let fitness_fn = OneMax;
let mut ga = Dsmga2::new(100, &fitness_fn)
    .population_size(200)
    .max_generations(1000)
    .build();

ga.run();
println!("Best fitness: {}", ga.best_fitness());

Features

• Automatic linkage learning with two-edge model
• Parallel fitness evaluation and linkage building
• Optional greedy hill climbing
• Checkpoint save/resume support
• Iterator and callback interfaces

Usage

Configuration

let mut ga = Dsmga2::new(problem_size, &fitness_fn)
    .population_size(200)
    .max_generations(1000)
    .use_ghc(true)
    .seed(42)
    .build();

Iteration

for state in ga.take(100) {
    println!("Gen {}: {:.2}", state.generation, state.best_fitness);
}

Callbacks

ga.run_with(|state| {
    println!("Generation {}: {:.2}", state.generation, state.best_fitness);
});

Checkpoints

ga.save_checkpoint("checkpoint.bin")?;
let checkpoint = Dsmga2::load_checkpoint("checkpoint.bin")?;
let mut ga = Dsmga2::from_checkpoint(checkpoint, &fitness_fn);

Custom Fitness Functions

use dsmga2::FitnessFunction;

struct MyProblem;

impl FitnessFunction for MyProblem {
    fn evaluate(&self, genes: &[bool]) -> f64 {
        genes.iter().filter(|&&g| g).count() as f64
    }

    fn optimum(&self, problem_size: usize) -> f64 {
        problem_size as f64
    }
}

Architecture

src/dsmga2/
├── mod.rs          # Main algorithm
├── config.rs       # Configuration
├── population.rs   # Population & GHC
├── linkage.rs      # Linkage learning
├── selection.rs    # Tournament selection
├── mixing.rs       # Restricted mixing
└── convergence.rs  # Convergence detection

Examples & Tools

Run examples:

cargo run --example basic_usage
cargo run --example custom_fitness

CLI tools:

cargo run --bin dsmga2_cli -- --help
cargo run --bin dsmga2_sweep -- --help

Testing

cargo test
cargo bench