Enum Optimiser 

pub enum Optimiser {
    Nsga {
        pop_size: usize,
        crossover: SbxParams,
        mutation: PmParams,
        seed: Option<u64>,
    },
    Pso {
        n_particles: usize,
        params: PsoParams,
        constraint_handler: Option<ConstraintHandler>,
        seed: Option<u64>,
    },
}

Represents the top-level configuration for an optimisation algorithm.

This enum acts as a factory for creating and running different optimisation strategies, such as NSGA-II or Particle Swarm Optimisation.

Variants

Nsga

Configures the NSGA-II (Non-dominated Sorting Genetic Algorithm II) optimiser.

Fields

pop_size: usize

The number of individuals in the population for each generation. This should be an even number, and typically >= 4.

crossover: SbxParams

Parameters for the Simulated Binary Crossover (SBX) operator.

mutation: PmParams

Parameters for the Polynomial Mutation operator.

seed: Option<u64>

An optional seed for the random number generator to ensure reproducible results.

Pso

Configures the Particle Swarm Optimisation (PSO) optimiser.

Fields

n_particles: usize

The number of particles in the swarm.

params: PsoParams

Parameters controlling the behaviour of the particles (e.g., inertia, social/cognitive factors).

constraint_handler: Option<ConstraintHandler>

An optional constraint handler to apply to the solutions.

seed: Option<u64>

An optional seed for the random number generator to ensure reproducible results.

Implementations

impl Optimiser

pub fn solve<F>( &self, func: &mut F, vars: &[Variable], max_iter: usize, ) -> Result<OptimiserResult>

where F: FnMut(&[f64]) -> (Vec<f64>, Option<Vec<f64>>),

Solves an optimisation problem using the configured algorithm (SERIAL VERSION).

This method is compiled by default. It accepts a mutable closure (FnMut), allowing the objective function to maintain its own internal state between calls.

Arguments

• func - A mutable closure that takes a slice of f64 (the variables) and returns the objective values and optional constraint values.
• vars - A slice defining the bounds for each variable in the search space.
• max_iter - The maximum number of iterations or generations to run the optimiser for.

Returns

A Result containing the OptimiserResult on success, or an error string on failure.

pub fn solve_par<F>( &self, func: &F, vars: &[Variable], max_iter: usize, ) -> Result<OptimiserResult>

where F: Fn(&[f64]) -> (Vec<f64>, Option<Vec<f64>>) + Sync + Send,

Solves an optimisation problem using the configured algorithm (PARALLEL VERSION).

This method is compiled only when the parallel feature is enabled. It requires a thread-safe closure (Fn + Sync + Send). See solve [Serial version] for more details

Trait Implementations

impl Debug for Optimiser

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

Formats the value using the given formatter.