graphmind_optimization/algorithms/
bmr.rs

1use crate::common::{Individual, OptimizationResult, Problem, SolverConfig};
2use ndarray::Array1;
3use rand::prelude::*;
4use rayon::prelude::*;
5
6pub struct BMRSolver {
7    pub config: SolverConfig,
8}
9
10impl BMRSolver {
11    pub fn new(config: SolverConfig) -> Self {
12        Self { config }
13    }
14
15    pub fn solve<P: Problem>(&self, problem: &P) -> OptimizationResult {
16        let mut rng = thread_rng();
17        let dim = problem.dim();
18        let (lower, upper) = problem.bounds();
19
20        let mut population: Vec<Individual> = (0..self.config.population_size)
21            .map(|_| {
22                let mut vars = Array1::zeros(dim);
23                for i in 0..dim {
24                    vars[i] = rng.gen_range(lower[i]..upper[i]);
25                }
26                let fitness = problem.fitness(&vars);
27                Individual::new(vars, fitness)
28            })
29            .collect();
30
31        let mut history = Vec::with_capacity(self.config.max_iterations);
32
33        for iter in 0..self.config.max_iterations {
34            if iter % 10 == 0 {
35                println!(
36                    "BMR Solver: Iteration {}/{}",
37                    iter, self.config.max_iterations
38                );
39            }
40            let (best_idx, _) = self.find_best_worst(&population);
41            let best_vars = population[best_idx].variables.clone();
42            let mean_vars = self.calculate_mean(&population, dim);
43            let best_fitness = population[best_idx].fitness;
44
45            history.push(best_fitness);
46
47            population = population
48                .into_par_iter()
49                .map(|mut ind| {
50                    let mut local_rng = thread_rng();
51                    let mut new_vars = Array1::zeros(dim);
52
53                    let r1: f64 = local_rng.gen();
54                    let r2: f64 = local_rng.gen();
55                    let r3: f64 = local_rng.gen();
56                    let r4: f64 = local_rng.gen();
57                    let t: f64 = local_rng.gen_range(1..3) as f64;
58
59                    let _rand_idx = local_rng.gen_range(0..self.config.population_size);
60                    // Note: In parallel map, we can't easily access the current population.
61                    // But we can approximate by having each thread pick its own random.
62                    // Or we just pass the population down.
63                    // For now, let's use a random individual generated from bounds if we can't access population.
64                    // Actually, let's stick to the Python logic by passing the whole population if needed.
65                    // But BMR/BWR use a 'random solution from population'.
66                    // We'll generate a random vector from bounds as a proxy for 'random solution' to keep it parallel and stateless.
67                    let mut rand_vars = Array1::zeros(dim);
68                    for j in 0..dim {
69                        rand_vars[j] = local_rng.gen_range(lower[j]..upper[j]);
70                    }
71
72                    if r4 > 0.5 {
73                        for j in 0..dim {
74                            let delta = r1 * (best_vars[j] - t * mean_vars[j])
75                                + r2 * (best_vars[j] - rand_vars[j]);
76                            new_vars[j] = (ind.variables[j] + delta).clamp(lower[j], upper[j]);
77                        }
78                    } else {
79                        for j in 0..dim {
80                            new_vars[j] =
81                                (upper[j] - (upper[j] - lower[j]) * r3).clamp(lower[j], upper[j]);
82                        }
83                    }
84
85                    let new_fitness = problem.fitness(&new_vars);
86                    if new_fitness < ind.fitness {
87                        ind.variables = new_vars;
88                        ind.fitness = new_fitness;
89                    }
90                    ind
91                })
92                .collect();
93        }
94
95        let (final_best_idx, _) = self.find_best_worst(&population);
96        let final_best = &population[final_best_idx];
97
98        OptimizationResult {
99            best_variables: final_best.variables.clone(),
100            best_fitness: final_best.fitness,
101            history,
102        }
103    }
104
105    fn find_best_worst(&self, population: &[Individual]) -> (usize, usize) {
106        let mut best_idx = 0;
107        let mut worst_idx = 0;
108        for (i, ind) in population.iter().enumerate() {
109            if ind.fitness < population[best_idx].fitness {
110                best_idx = i;
111            }
112            if ind.fitness > population[worst_idx].fitness {
113                worst_idx = i;
114            }
115        }
116        (best_idx, worst_idx)
117    }
118
119    fn calculate_mean(&self, population: &[Individual], dim: usize) -> Array1<f64> {
120        let mut mean = Array1::zeros(dim);
121        for ind in population {
122            mean += &ind.variables;
123        }
124        mean / (population.len() as f64)
125    }
126}
graphmind_optimization/algorithms/bmr.rs

graphmind_optimization/algorithms/
bmr.rs
