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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

//! Integration tests for global optimization algorithms

use scirs2_core::ndarray::array;
use scirs2_core::ndarray::ArrayView1;
use scirs2_optimize::global::{
    basinhopping, differential_evolution, dual_annealing, BasinHoppingOptions,
    DifferentialEvolutionOptions, DualAnnealingOptions,
};

#[test]
#[allow(dead_code)]
fn test_global_optimization_on_rosenbrock() {
    // Test all three global optimization algorithms on the Rosenbrock function
    let rosenbrock = |x: &scirs2_core::ndarray::ArrayView1<f64>| {
        let a = 1.0;
        let b = 100.0;
        let x0 = x[0];
        let x1 = x[1];
        (a - x0).powi(2) + b * (x1 - x0.powi(2)).powi(2)
    };

    // Test 1: Differential Evolution
    let bounds = vec![(-5.0, 5.0), (-5.0, 5.0)];
    let options = DifferentialEvolutionOptions {
        maxiter: 100,
        popsize: 15,
        seed: Some(42),
        ..Default::default()
    };

    let result = differential_evolution(rosenbrock, bounds.clone(), Some(options), None)
        .expect("Operation failed");
    assert!(result.success);
    assert!((result.x[0] - 1.0).abs() < 0.1);
    assert!((result.x[1] - 1.0).abs() < 0.1);

    // Test 2: Basin-hopping
    let x0 = array![0.0, 0.0];
    let options = BasinHoppingOptions {
        niter: 50,
        seed: Some(42),
        ..Default::default()
    };

    let result =
        basinhopping(rosenbrock, x0.clone(), Some(options), None, None).expect("Operation failed");
    assert!(result.success);
    assert!((result.x[0] - 1.0).abs() < 0.2);
    assert!((result.x[1] - 1.0).abs() < 0.2);

    // Test 3: Dual Annealing
    let options = DualAnnealingOptions {
        maxiter: 100,
        seed: Some(42),
        bounds: bounds.clone(),
        ..Default::default()
    };

    let result = dual_annealing(rosenbrock, x0, bounds, Some(options)).expect("Operation failed");
    // Dual annealing may not always converge to exact solution, so we check if it's close
    assert!(result.fun < 1.0);
}

#[test]
fn test_global_optimization_with_constraints() {
    // Test global optimization on a function with bounded constraints
    let func =
        |x: &scirs2_core::ndarray::ArrayView1<f64>| (x[0] + 1.0).powi(2) + (x[1] + 1.0).powi(2);

    // Without bounds, minimum is at (-1, -1)
    // With bounds [0, 2] x [0, 2], minimum should be at (0, 0)
    let bounds = vec![(0.0, 2.0), (0.0, 2.0)];

    // Test Differential Evolution
    let options = DifferentialEvolutionOptions {
        maxiter: 200, // Increased iterations for better convergence
        seed: Some(42),
        ..Default::default()
    };

    let result = differential_evolution(func, bounds.clone(), Some(options), None)
        .expect("Operation failed");

    assert!(result.success);

    // Print the actual result for verification
    println!(
        "Differential Evolution result: x = {:?}, f(x) = {}",
        result.x, result.fun
    );

    // Check that the result respects the bounds
    for (i, &val) in result.x.iter().enumerate() {
        assert!(
            val >= bounds[i].0 && val <= bounds[i].1,
            "Solution x[{}] = {} is outside bounds [{}, {}]",
            i,
            val,
            bounds[i].0,
            bounds[i].1
        );
    }

    // The constrained minimum should be near (0, 0) with function value near 2.0
    // f(0,0) = (0+1)^2 + (0+1)^2 = 2
    assert!(result.x[0] >= 0.0 && result.x[0] <= 2.0);
    assert!(result.x[1] >= 0.0 && result.x[1] <= 2.0);
    assert!(result.fun >= 1.8); // Should be close to the constrained minimum value
    assert!(result.fun < 10.0); // Should be better than a random point
}

#[test]
#[allow(dead_code)]
fn test_global_optimization_multimodal() {
    // Test on a multimodal function with many local minima
    let ackley = |x: &scirs2_core::ndarray::ArrayView1<f64>| {
        let n = x.len() as f64;
        let a = 20.0;
        let b = 0.2;
        let c = 2.0 * std::f64::consts::PI;

        let sum1 = x.iter().map(|&xi| xi.powi(2)).sum::<f64>() / n;
        let sum2 = x.iter().map(|&xi| (c * xi).cos()).sum::<f64>() / n;

        -a * (-b * sum1.sqrt()).exp() - sum2.exp() + a + std::f64::consts::E
    };

    let bounds = vec![(-5.0, 5.0), (-5.0, 5.0)];

    // Test Differential Evolution
    let options = DifferentialEvolutionOptions {
        maxiter: 100,
        popsize: 20,
        seed: Some(42),
        ..Default::default()
    };

    let result =
        differential_evolution(ackley, bounds, Some(options), None).expect("Operation failed");
    assert!(result.success);
    // Ackley function has global minimum at origin with value 0
    assert!(result.x.iter().all(|&xi| xi.abs() < 0.5));
    assert!(result.fun < 1.0);
}