scirs2-optimize 0.4.2

Optimization module for SciRS2 (scirs2-optimize)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

//! Mutation operators for multi-objective optimization
//!
//! Various mutation strategies for maintaining diversity in populations.

use scirs2_core::random::{Distribution, Normal};
use scirs2_core::random::{Rng, RngExt};

/// Trait for mutation operators
pub trait MutationOperator {
    /// Perform mutation on a solution
    fn mutate(&self, solution: &mut [f64], bounds: &[(f64, f64)]);
}

/// Polynomial mutation
#[derive(Debug, Clone)]
pub struct PolynomialMutation {
    mutation_probability: f64,
    distribution_index: f64,
}

impl PolynomialMutation {
    pub fn new(mutation_probability: f64, distribution_index: f64) -> Self {
        Self {
            mutation_probability,
            distribution_index,
        }
    }

    fn calculate_delta(&self, rng: &mut impl Rng) -> f64 {
        let u = rng.random::<f64>();
        if u < 0.5 {
            (2.0 * u).powf(1.0 / (self.distribution_index + 1.0)) - 1.0
        } else {
            1.0 - (2.0 * (1.0 - u)).powf(1.0 / (self.distribution_index + 1.0))
        }
    }
}

impl MutationOperator for PolynomialMutation {
    fn mutate(&self, solution: &mut [f64], bounds: &[(f64, f64)]) {
        let mut rng = scirs2_core::random::rng();
        let n = solution.len();

        for i in 0..n {
            if rng.random::<f64>() <= self.mutation_probability {
                let (lower, upper) = bounds[i];
                let delta = self.calculate_delta(&mut rng);
                let max_delta = upper - lower;

                solution[i] += delta * max_delta;
                solution[i] = solution[i].max(lower).min(upper);
            }
        }
    }
}

/// Gaussian mutation
#[derive(Debug, Clone)]
pub struct GaussianMutation {
    mutation_probability: f64,
    std_dev: f64,
}

impl GaussianMutation {
    pub fn new(mutation_probability: f64, std_dev: f64) -> Self {
        Self {
            mutation_probability,
            std_dev,
        }
    }
}

impl MutationOperator for GaussianMutation {
    fn mutate(&self, solution: &mut [f64], bounds: &[(f64, f64)]) {
        let mut rng = scirs2_core::random::rng();
        let normal = Normal::new(0.0, self.std_dev).expect("Operation failed");

        for i in 0..solution.len() {
            if rng.random::<f64>() <= self.mutation_probability {
                let (lower, upper) = bounds[i];
                let perturbation = normal.sample(&mut rng);

                solution[i] += perturbation;
                solution[i] = solution[i].max(lower).min(upper);
            }
        }
    }
}

/// Uniform mutation
#[derive(Debug, Clone)]
pub struct UniformMutation {
    mutation_probability: f64,
}

impl UniformMutation {
    pub fn new(mutation_probability: f64) -> Self {
        Self {
            mutation_probability,
        }
    }
}

impl MutationOperator for UniformMutation {
    fn mutate(&self, solution: &mut [f64], bounds: &[(f64, f64)]) {
        let mut rng = scirs2_core::random::rng();

        for i in 0..solution.len() {
            if rng.random::<f64>() <= self.mutation_probability {
                let (lower, upper) = bounds[i];
                solution[i] = rng.random_range(lower..upper);
            }
        }
    }
}