samyama-optimization 0.5.8

High-performance metaheuristic optimization algorithms (Jaya, Rao, TLBO, BMR, BWR, QOJaya, ITLBO) in Rust.
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

use samyama_optimization::algorithms::*;
use samyama_optimization::common::*;
use ndarray::{Array1, array};

struct SphereProblem;

impl Problem for SphereProblem {
    fn objective(&self, variables: &Array1<f64>) -> f64 {
        variables.iter().map(|&x| x * x).sum()
    }

    fn dim(&self) -> usize { 2 }

    fn bounds(&self) -> (Array1<f64>, Array1<f64>) {
        (array![-10.0, -10.0], array![10.0, 10.0])
    }
}

#[test]
fn test_jaya_sphere() {
    let problem = SphereProblem;
    let config = SolverConfig { population_size: 50, max_iterations: 500 };
    let solver = JayaSolver::new(config);
    let result = solver.solve(&problem);
    
    assert!(result.best_fitness < 0.01, "Jaya failed: fitness {}", result.best_fitness);
}

#[test]
fn test_qojaya_sphere() {
    let problem = SphereProblem;
    let config = SolverConfig { population_size: 50, max_iterations: 500 };
    let solver = QOJayaSolver::new(config);
    let result = solver.solve(&problem);
    
    assert!(result.best_fitness < 0.01, "QOJaya failed: fitness {}", result.best_fitness);
}

#[test]
fn test_itlbo_sphere() {
    let problem = SphereProblem;
    let config = SolverConfig { population_size: 50, max_iterations: 500 };
    let solver = ITLBOSolver::new(config);
    let result = solver.solve(&problem);
    
    assert!(result.best_fitness < 0.01, "ITLBO failed: fitness {}", result.best_fitness);
}

#[test]
fn test_rao3_sphere() {
    let problem = SphereProblem;
    let config = SolverConfig { population_size: 100, max_iterations: 1000 };
    let solver = RaoSolver::new(config, RaoVariant::Rao3);
    let result = solver.solve(&problem);
    
    assert!(result.best_fitness < 1.0, "Rao3 failed: fitness {}", result.best_fitness);
}

#[test]
fn test_tlbo_sphere() {
    let problem = SphereProblem;
    let config = SolverConfig { population_size: 50, max_iterations: 500 };
    let solver = TLBOSolver::new(config);
    let result = solver.solve(&problem);
    
    assert!(result.best_fitness < 0.01, "TLBO failed: fitness {}", result.best_fitness);
}

#[test]
fn test_bmr_sphere() {
    let problem = SphereProblem;
    let config = SolverConfig { population_size: 50, max_iterations: 500 };
    let solver = BMRSolver::new(config);
    let result = solver.solve(&problem);
    
    assert!(result.best_fitness < 0.1, "BMR failed: fitness {}", result.best_fitness);
}

#[test]
fn test_bwr_sphere() {
    let problem = SphereProblem;
    let config = SolverConfig { population_size: 50, max_iterations: 500 };
    let solver = BWRSolver::new(config);
    let result = solver.solve(&problem);
    
    assert!(result.best_fitness < 0.1, "BWR failed: fitness {}", result.best_fitness);
}

#[test]
fn test_pso_sphere() {
    let problem = SphereProblem;
    let config = SolverConfig { population_size: 50, max_iterations: 500 };
    let solver = PSOSolver::new(config);
    let result = solver.solve(&problem);
    
    assert!(result.best_fitness < 0.01, "PSO failed: fitness {}", result.best_fitness);
}

#[test]
fn test_de_sphere() {
    let problem = SphereProblem;
    let config = SolverConfig { population_size: 50, max_iterations: 500 };
    let solver = DESolver::new(config);
    let result = solver.solve(&problem);
    
    assert!(result.best_fitness < 0.01, "DE failed: fitness {}", result.best_fitness);
}