Struct PolynomialMutation

pub struct PolynomialMutation { /* private fields */ }

The Polynomial mutation (PM) operator.

Adapted from Deb & Deb (2014), full text available at https://www.egr.msu.edu/~kdeb/papers/k2012016.pdf.

Integer support

Since the original method does not provide support for integer variables, this has been added by using the approach proposed in:

Deep, Kusum & Singh, Krishna & Kansal, M. & Mohan, Chander. (2009). A real coded genetic algorithm for solving integer and mixed integer optimization problems. Applied Mathematics and Computation. 212. 505-518. 10.1016/j.amc.2009.02.044.

See the truncation procedure in section 2.4 in the full text, where a probability of 0.5 is applied to ensure randomness in the integer crossover.

Example

use std::error::Error;
use optirustic::core::{BoundedNumber, Individual, Problem, VariableType, VariableValue,
Objective, Constraint, ObjectiveDirection, RelationalOperator, EvaluationResult, Evaluator};
use optirustic::operators::{Crossover, PolynomialMutationArgs, PolynomialMutation, Mutation};
use std::sync::Arc;
use rand_chacha::ChaCha8Rng;
use rand::SeedableRng;

fn main() -> Result<(), Box<dyn Error>> {
    // create a new one-variable
    let objectives = vec![Objective::new("obj1", ObjectiveDirection::Minimise)];
    let variables = vec![
        VariableType::Real(BoundedNumber::new("var1", 0.0, 1000.0)?),
        VariableType::Integer(BoundedNumber::new("var2", -1, 1)?)
    ];
     
    // dummy evaluator function
    #[derive(Debug)]
    struct UserEvaluator;
    impl Evaluator for UserEvaluator {
        fn evaluate(&self, _: &Individual) -> Result<EvaluationResult, Box<dyn Error>> {
            Ok(EvaluationResult {
                constraints: Default::default(),
                objectives: Default::default(),
            })
        }
    }
    let problem = Arc::new(Problem::new(objectives, variables, None, Box::new(UserEvaluator))?);

    // add new individuals
    let mut a = Individual::new(problem.clone());
    a.update_variable("var1", VariableValue::Real(0.2))?;
    a.update_variable("var2", VariableValue::Integer(1))?;

    // crossover
    let parameters = PolynomialMutationArgs {
        index_parameter: 1.0 ,
        variable_probability: 1.0,
    };
    let pm = PolynomialMutation::new(parameters)?;
    let mut rng = ChaCha8Rng::from_seed(Default::default());
    let out = pm.mutate_offspring(&a, &mut rng)?;
    println!("{}", out);
    Ok(())
}

Implementations

impl PolynomialMutation

pub fn new(args: PolynomialMutationArgs) -> Result<Self, OError>

Initialise the Polynomial mutation (PM) operator. This returns an error if the probability is outside the [0, 1] range.

Arguments

• index_parameter:
• variable_probability: The probability of mutating a parent variable.

returns: Result<PolynomialMutation, OError>

Trait Implementations

impl Mutation for PolynomialMutation

fn mutate_offspring( &self, individual: &Individual, rng: &mut dyn RngCore, ) -> Result<Individual, OError>

Mutate a population individual.