Struct Bobyqa 

pub struct Bobyqa<Mode = Bounded, F = f64> { /* private fields */ }

BOBYQA (Powell 2009): bound-constrained model-based derivative-free trust-region optimization.

Configure the trust-region radii and interpolation-set size, then drive it with an Executor over a BobyqaState on a problem that implements CostFunction + BoxConstraints:

use basin::{BoxConstraints, CostFunction, Executor, Bobyqa, BobyqaState, MaxCostEvals};

struct Booth {
    lower: Vec<f64>,
    upper: Vec<f64>,
}
impl CostFunction for Booth {
    type Param = Vec<f64>;
    type Output = f64;
    type Error = std::convert::Infallible;
    fn cost(&self, x: &Vec<f64>) -> Result<f64, std::convert::Infallible> {
        Ok((x[0] + 2.0 * x[1] - 7.0).powi(2) + (2.0 * x[0] + x[1] - 5.0).powi(2))
    }
}
impl BoxConstraints for Booth {
    fn lower(&self) -> &Vec<f64> { &self.lower }
    fn upper(&self) -> &Vec<f64> { &self.upper }
}

let problem = Booth { lower: vec![-5.0, -5.0], upper: vec![5.0, 5.0] };
let solver = Bobyqa::new().with_rho_beg(0.5).with_rho_end(1e-8);
let state = BobyqaState::new(vec![0.0, 0.0]);
let result = Executor::new(problem, solver, state)
    .terminate_on(MaxCostEvals(500))
    .run()
    .unwrap();
assert!(result.best_param()[0].is_finite());

Configuration

• with_rho_beg — initial trust-region radius ρ_beg (default 1.0). Also the initial Δ. The initial sampling needs room b_i ≥ a_i + 2ρ_beg (Powell 2009, eq. 2.1); if ρ_beg is too large for a narrow box it is reduced to min(b_i − a_i)/4 (with ρ_end pulled down to match), mirroring PRIMA rather than rejecting the solve.
• with_rho_end — final radius ρ_end (default 1e-6); must satisfy ρ_beg > ρ_end > 0.
• with_npt — interpolation-set size npt, in [2n+1, ½(n+1)(n+2)] (default 2n+1).

Panics

Executor::run panics (in init) if the start point is empty, if npt is outside [2n+1, ½(n+1)(n+2)] (the n+2 ≤ npt ≤ 2n partial-model regime is not yet implemented), or if after the narrow-box revision ρ_beg > ρ_end > 0 cannot hold (e.g. a degenerate b_i = a_i).

RESCUE

The full method of RESCUE (Powell 2009, §5 — restoring the interpolation set when rounding damages the update denominator) is implemented and wired, but it fires only on severely ill-conditioned geometry. As Powell and PRIMA both note, it is essentially never invoked on well-behaved problems without heavy noise on the objective; expect it to stay dormant in normal use.

Backends

Backend-generic over the parameter vector: Vec<f64>, nalgebra, ndarray, and faer all work — the parameter type needs only Clone, VectorLen, and Index/IndexMut element access. The model algebra is internal pure-Rust Vec<f64> scratch, so no linalg-tier op is required. wasm-clean.

References

M. J. D. Powell, The BOBYQA algorithm for bound constrained optimization without derivatives, DAMTP report 2009/NA06, University of Cambridge. Cross-validated against PRIMA v0.7.2.

Implementations

impl<F: Scalar> Bobyqa<Bounded, F>

pub fn new() -> Self

A BOBYQA solver with the default schedule (ρ_beg = 1, ρ_end = 1e-6, npt = 2n+1). Tune with the with_* builders.

pub fn with_rho_beg(self, rho_beg: F) -> Self

Set the initial trust-region radius ρ_beg (also the initial Δ).

pub fn with_rho_end(self, rho_end: F) -> Self

Set the final trust-region radius ρ_end. Must satisfy ρ_beg > ρ_end > 0.

pub fn with_npt(self, npt: usize) -> Self

Set the interpolation-set size npt, in [2n+1, ½(n+1)(n+2)]. Defaults to 2n+1 when unset.

Trait Implementations

impl<F: Scalar> Default for Bobyqa<Bounded, F>

fn default() -> Self

Returns the “default value” for a type.

impl<V, F> InitialState<V> for Bobyqa<Bounded, F>

where F: Scalar, V: Clone,

type State = BobyqaState<V, F>

State shape this solver iterates against.

fn seed(&self, x: &V) -> Self::State

Build a fresh state seeded at x using the solver’s natural default scale.

impl<P, V, F> Solver<P, BobyqaState<V, F>> for Bobyqa<Bounded, F>

where F: Scalar, P: CostFunction<Param = V, Output = F> + BoxConstraints, V: Clone + VectorLen + Index<usize, Output = F> + IndexMut<usize, Output = F>,

type Error = <P as CostFunction>::Error

Hard-abort error type — mirrors the underlying problem’s type Error. See the trait docs.

fn init( &mut self, problem: &mut Problem<P>, state: BobyqaState<V, F>, ) -> Result<BobyqaState<V, F>, Self::Error>

One-time setup before the iteration loop.

fn next_iter( &mut self, problem: &mut Problem<P>, state: BobyqaState<V, F>, ) -> Result<(BobyqaState<V, F>, Option<TerminationReason>), Self::Error>

Advance one iteration.

fn terminate(&self, _state: &S) -> Option<TerminationReason>

Optional pre-iteration solver-specific termination test.