turboswarm-core 0.7.0

Particle Swarm Optimization core: extensible and modular
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

//! Continuous search space (real variables). Classic PSO.

use rand::{Rng, RngCore};

use crate::traits::SearchSpace;

/// Continuous search box defined by `[min, max]` bounds per dimension.
#[derive(Debug, Clone)]
pub struct ContinuousSpace {
    bounds: Vec<(f64, f64)>,
}

impl ContinuousSpace {
    /// Creates the space from the per-dimension bounds.
    /// Panics if any bound has `min > max`.
    pub fn new(bounds: Vec<(f64, f64)>) -> Self {
        for (i, (lo, hi)) in bounds.iter().enumerate() {
            assert!(lo <= hi, "invalid bound in dimension {i}: {lo} > {hi}");
        }
        Self { bounds }
    }

    /// Convenience: a `dim`-dimensional box with the same `(lo, hi)` range on
    /// every dimension. `ContinuousSpace::uniform(2, -5.12, 5.12)` is the same
    /// as `ContinuousSpace::new(vec![(-5.12, 5.12); 2])`.
    pub fn uniform(dim: usize, lo: f64, hi: f64) -> Self {
        Self::new(vec![(lo, hi); dim])
    }

    /// The `(min, max)` bounds per dimension.
    pub fn bounds(&self) -> &[(f64, f64)] {
        &self.bounds
    }
}

impl SearchSpace for ContinuousSpace {
    type Scalar = f64;

    fn dim(&self) -> usize {
        self.bounds.len()
    }

    fn sample(&self, rng: &mut dyn RngCore) -> Vec<f64> {
        self.bounds
            .iter()
            .map(|&(lo, hi)| rng.gen_range(lo..=hi))
            .collect()
    }

    fn sample_velocity(&self, rng: &mut dyn RngCore) -> Vec<f64> {
        // Initial velocity in [-range, +range], a common practice.
        self.bounds
            .iter()
            .map(|&(lo, hi)| {
                let range = hi - lo;
                rng.gen_range(-range..=range)
            })
            .collect()
    }

    fn clamp(&self, position: &mut [f64]) {
        for (x, &(lo, hi)) in position.iter_mut().zip(&self.bounds) {
            *x = x.clamp(lo, hi);
        }
    }

    fn enforce_bounds(
        &self,
        position: &mut [f64],
        velocity: &mut [f64],
        handling: crate::traits::BoundaryHandling,
        rng: &mut dyn RngCore,
    ) {
        super::apply_boundary(position, velocity, |i| self.bounds[i], handling, rng);
    }

    fn decode(&self, raw: &[f64]) -> Vec<f64> {
        raw.to_vec() // identity: the continuous space evaluates in f64 directly
    }

    fn span(&self) -> Vec<(f64, f64)> {
        self.bounds.clone()
    }
}