Struct Nsga2 

pub struct Nsga2<G, F, C, M> {
    pub population_size: usize,
    pub crossover_probability: f64,
    pub mutation_probability: f64,
    pub bounds: Option<MultiBounds>,
    /* private fields */
}

NSGA-II algorithm

Fields

population_size: usize

Population size

crossover_probability: f64

Crossover probability

mutation_probability: f64

Mutation probability

bounds: Option<MultiBounds>

Problem bounds

Implementations

impl<G, F, C, M> Nsga2<G, F, C, M>

where G: EvolutionaryGenome, F: MultiObjectiveFitness<G>, C: CrossoverOperator<G>, M: MutationOperator<G>,

pub fn new(population_size: usize) -> Self

Create a new NSGA-II algorithm

pub fn with_crossover_probability(self, prob: f64) -> Self

Set crossover probability

pub fn with_mutation_probability(self, prob: f64) -> Self

Set mutation probability

pub fn with_bounds(self, bounds: MultiBounds) -> Self

Set bounds

pub fn initialize_population<R: Rng>( &self, fitness: &F, bounds: &MultiBounds, rng: &mut R, ) -> Vec<Nsga2Individual<G>>

Initialize random population

pub fn tournament_select<'a, R: Rng>( &self, population: &'a [Nsga2Individual<G>], rng: &mut R, ) -> &'a Nsga2Individual<G>

Binary tournament selection with crowded comparison

pub fn create_offspring<R: Rng>( &self, population: &[Nsga2Individual<G>], fitness: &F, crossover: &C, mutation: &M, rng: &mut R, ) -> Vec<Nsga2Individual<G>>

Create offspring population

pub fn step<R: Rng>( &self, population: &mut Vec<Nsga2Individual<G>>, fitness: &F, crossover: &C, mutation: &M, rng: &mut R, )

Run one generation of NSGA-II

pub fn run<R: Rng>( &self, fitness: &F, crossover: &C, mutation: &M, bounds: &MultiBounds, max_generations: usize, rng: &mut R, ) -> EvoResult<Vec<Nsga2Individual<G>>>

Run NSGA-II for a fixed number of generations

pub fn get_pareto_front( population: &[Nsga2Individual<G>], ) -> Vec<&Nsga2Individual<G>>

Get the Pareto front (rank 0 individuals)

impl<G, F, C, M> Nsga2<G, F, C, M>

where G: EvolutionaryGenome, F: MultiObjectiveFitness<G>, C: BoundedCrossoverOperator<G>, M: BoundedMutationOperator<G>,

Version with bounded operators

pub fn create_offspring_bounded<R: Rng>( &self, population: &[Nsga2Individual<G>], fitness: &F, crossover: &C, mutation: &M, bounds: &MultiBounds, rng: &mut R, ) -> Vec<Nsga2Individual<G>>

Create offspring population with bounded operators

pub fn step_bounded<R: Rng>( &self, population: &mut Vec<Nsga2Individual<G>>, fitness: &F, crossover: &C, mutation: &M, bounds: &MultiBounds, rng: &mut R, )

Run one generation with bounded operators

pub fn run_bounded<R: Rng>( &self, fitness: &F, crossover: &C, mutation: &M, bounds: &MultiBounds, max_generations: usize, rng: &mut R, ) -> EvoResult<Vec<Nsga2Individual<G>>>

Run NSGA-II with bounded operators