SimpleGA Reference

The Simple Genetic Algorithm is a flexible, general-purpose evolutionary optimization algorithm.

Module

use fugue_evo::algorithms::simple_ga::{SimpleGA, SimpleGABuilder, SimpleGAConfig};

Builder API

Required Configuration

MethodTypeDescription
bounds(bounds)MultiBoundsSearch space bounds
selection(sel)impl SelectionOperatorSelection operator
crossover(cx)impl CrossoverOperatorCrossover operator
mutation(mut)impl MutationOperatorMutation operator
fitness(fit)impl FitnessFitness function

Optional Configuration

MethodTypeDefaultDescription
population_size(n)usize100Population size
max_generations(n)usize100Max generations
elitism(b)boolfalseEnable elitism
elite_count(n)usize1Number of elites
parallel(b)boolfalseParallel evaluation
initial_population(pop)Vec<G>RandomCustom initial population

Usage

Basic Example

use fugue_evo::prelude::*;

let result = SimpleGABuilder::<RealVector, f64, _, _, _, _, _>::new()
    .population_size(100)
    .bounds(MultiBounds::symmetric(5.12, 10))
    .selection(TournamentSelection::new(3))
    .crossover(SbxCrossover::new(20.0))
    .mutation(PolynomialMutation::new(20.0))
    .fitness(Sphere::new(10))
    .max_generations(200)
    .elitism(true)
    .build()?
    .run(&mut rng)?;

With Custom Termination

let result = SimpleGABuilder::<RealVector, f64, _, _, _, _, _>::new()
    // ... configuration
    .termination(AnyOf::new(vec![
        Box::new(MaxGenerations::new(1000)),
        Box::new(TargetFitness::new(-0.001)),
        Box::new(FitnessStagnation::new(50)),
    ]))
    .build()?
    .run(&mut rng)?;

Step-by-Step Execution

let mut ga = SimpleGABuilder::new()
    // ... configuration
    .build()?;

ga.initialize(&mut rng)?;

while !ga.should_terminate() {
    ga.step(&mut rng)?;

    // Access current state
    println!("Generation {}: best = {:.6}",
        ga.generation(),
        ga.best_fitness().unwrap_or(0.0));
}

let result = ga.into_result();

Configuration Struct

pub struct SimpleGAConfig {
    pub population_size: usize,
    pub elitism: bool,
    pub elite_count: usize,
    pub parallel: bool,
}

Generic Parameters

The builder has extensive generics for type safety:

SimpleGABuilder::<G, F, S, C, M, Fit, Term>
ParameterConstraintDescription
GEvolutionaryGenomeGenome type
FFitnessValueFitness value type
SSelectionOperator<G>Selection operator
CCrossoverOperator<G>Crossover operator
MMutationOperator<G>Mutation operator
FitFitness<G, Value=F>Fitness function
TermTerminationCriterionTermination criterion

Algorithm Flow

┌─────────────────────────────────────────┐
│           SimpleGA Flow                  │
│                                          │
│  1. Initialize random population         │
│  2. Evaluate fitness                     │
│  3. while not terminated:                │
│     a. Select parents                    │
│     b. Apply crossover                   │
│     c. Apply mutation                    │
│     d. Evaluate offspring                │
│     e. Replace population (with elitism) │
│     f. Update statistics                 │
│  4. Return best solution                 │
└─────────────────────────────────────────┘

Error Handling

let result = SimpleGABuilder::new()
    .population_size(100)
    // Missing required configuration
    .build(); // Returns Err(ConfigurationError)

match result {
    Ok(ga) => { /* run */ }
    Err(e) => eprintln!("Configuration error: {}", e),
}

Performance Tips

  1. Population size: Start with 100, increase for multimodal problems
  2. Selection pressure: Higher tournament size = faster convergence
  3. Elitism: Almost always beneficial
  4. Parallelism: Enable for expensive fitness functions

See Also