ctrl_freeq/optim/
derivative_free.rs1use std::cell::{Cell, RefCell};
8
9use super::{Derivatives, Exit, Monitor, Objective, OptimResult, Optimizer, RunControl};
10use crate::error::{Error, Result};
11
12const BOX: f64 = 100.0;
15
16fn bounds(x0: &[f64]) -> (Vec<f64>, Vec<f64>) {
17 let half = x0.iter().fold(BOX, |m, v| m.max(2.0 * v.abs()));
18 (vec![-half; x0.len()], vec![half; x0.len()])
19}
20
21fn step(monitor: &mut Monitor, error: &mut Option<Error>, obj: &dyn Objective, x: &[f64]) -> Option<f64> {
23 match obj.value(x) {
24 Ok(e) => {
25 monitor.evaluated(x, e);
26 let n = monitor.evaluations;
27 monitor.report(n, e, None);
28 Some(e.cost)
29 }
30 Err(err) => {
31 *error = Some(err);
32 None
33 }
34 }
35}
36
37fn failed(monitor: Monitor, error: Error) -> Result<OptimResult> {
38 let n = monitor.evaluations;
39 if monitor.best.is_some() {
40 monitor.finish(n, Exit::Failed(error.to_string()))
41 } else {
42 Err(error)
43 }
44}
45
46#[derive(Clone, Copy, Debug, Default)]
48pub struct Cobyla;
49
50impl Optimizer for Cobyla {
51 fn name(&self) -> &'static str {
52 "cobyla"
53 }
54
55 fn derivatives(&self) -> Derivatives {
56 Derivatives::None
57 }
58
59 fn minimize(&self, obj: &dyn Objective, x0: &[f64], ctl: &mut RunControl) -> Result<OptimResult> {
60 let (lower, upper) = bounds(x0);
61 let stop = Cell::new(0);
62 let state = RefCell::new((Monitor::new(ctl), None::<Error>));
63 let (status, _, _) = super::cobyla::minimize(
64 |x| {
65 let mut guard = state.borrow_mut();
66 let (monitor, error) = &mut *guard;
67 let value = step(monitor, error, obj, x);
68 if monitor.exit.is_some() || error.is_some() {
69 stop.set(1);
70 }
71 value.unwrap_or(f64::MAX)
72 },
73 x0,
74 &lower,
75 &upper,
76 1.0,
77 usize::MAX,
78 &stop,
79 );
80 let (monitor, error) = state.into_inner();
81 if let Some(e) = error {
82 return failed(monitor, e);
83 }
84 let n = monitor.evaluations;
85 let exit = match status {
86 super::cobyla::Status::Failed(m) => Exit::Failed(m.into()),
87 super::cobyla::Status::MaxEvalReached => Exit::MaxIterations,
88 _ => Exit::Converged,
89 };
90 monitor.finish(n, exit)
91 }
92}
93
94#[derive(Clone, Copy, Debug, Default)]
96pub struct Bobyqa;
97
98impl Optimizer for Bobyqa {
99 fn name(&self) -> &'static str {
100 "bobyqa"
101 }
102
103 fn derivatives(&self) -> Derivatives {
104 Derivatives::None
105 }
106
107 fn minimize(&self, obj: &dyn Objective, x0: &[f64], ctl: &mut RunControl) -> Result<OptimResult> {
108 let n = x0.len();
109 if n < 2 {
110 return Err(Error::NotSupported("BOBYQA needs at least two parameters".into()));
111 }
112 let (lower, upper) = bounds(x0);
113 let f_target = -ctl.target_fidelity;
114 let mut config = bobyqa::Config::new(n);
115 config.rho_begin = 0.5;
116 config.rho_end = 1e-8;
117 config.f_target = f_target;
118 config.max_fun = (ctl.max_iter + 1).max(config.npt + 1);
121 let mut solver = bobyqa::Bobyqa::new(n, config)
122 .map_err(|s| Error::Numerical(format!("BOBYQA refused its settings: {s}")))?;
123 let mut monitor = Monitor::new(ctl);
124 let mut error = None;
125 let mut x = x0.to_vec();
126 let outcome = solver.minimize(
127 |x| {
128 if monitor.exit.is_some() || error.is_some() {
129 return f_target - 1.0;
130 }
131 let value = step(&mut monitor, &mut error, obj, x);
132 if monitor.exit.is_some() || error.is_some() {
133 f_target - 1.0
134 } else {
135 value.unwrap_or(f64::MAX)
136 }
137 },
138 &mut x,
139 &lower,
140 &upper,
141 );
142 if let Some(e) = error {
143 return failed(monitor, e);
144 }
145 let iterations = monitor.evaluations;
146 let exit = match outcome.status {
147 bobyqa::Status::MaxFunReached => Exit::MaxIterations,
148 bobyqa::Status::InvalidArgs | bobyqa::Status::AllocationFailed => {
149 Exit::Failed(format!("BOBYQA: {}", outcome.status))
150 }
151 _ => Exit::Converged,
152 };
153 monitor.finish(iterations, exit)
154 }
155}