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

#![doc(hidden)]
use crate::utility::prelude::*;

const OFFSET: f64 = 7.;

pub struct TestObj([f64; 4], [f64; 4]);

impl Default for TestObj {
    fn default() -> Self {
        Self([-50.; 4], [50.; 4])
    }
}

impl TestObj {
    pub fn new() -> Self {
        Self::default()
    }
}

impl ObjFunc for TestObj {
    type Result = f64;
    type Fitness = f64;

    fn fitness(&self, v: &[f64], _: f64) -> Self::Fitness {
        OFFSET + v[0] * v[0] + 8. * v[1] * v[1] + v[2] * v[2] + v[3] * v[3]
    }

    fn result(&self, v: &[f64]) -> Self::Result {
        self.fitness(v, 0.)
    }

    fn ub(&self) -> &[f64] {
        &self.1
    }
    fn lb(&self) -> &[f64] {
        &self.0
    }
}

#[cfg(test)]
fn test<S>()
where
    S: Setting + Default,
    S::Algorithm: utility::Algorithm<TestObj>,
{
    let s = Solver::build(S::default())
        .task(|ctx| ctx.best_f - OFFSET < 1e-20)
        .solve(TestObj::default());
    let ans = s.result();
    let x = s.best_parameters();
    let y = s.best_fitness();
    let report = s.report();
    assert!(report.len() > 0, "{}", report.len());
    assert!((ans - OFFSET).abs() < 1e-20, "{}", ans);
    for i in 0..4 {
        assert!(x[i].abs() < 1e-6, "x{} = {}", i, x[i]);
    }
    assert_eq!(y.abs(), ans);
}

#[test]
fn de() {
    test::<De>();
}

#[test]
fn pso() {
    test::<Pso<_>>();
}

#[test]
fn fa() {
    test::<Fa>();
}

#[test]
fn rga() {
    test::<Rga<_>>();
}

#[test]
fn tlbo() {
    test::<Tlbo>();
}