basin 1.5.0

Numerical optimization in pure Rust, with pluggable linear-algebra backends and WASM support.
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

/// Augmented-Lagrangian method for linear equality constraints `A x = b`
/// (penalty + multiplier updates over any unconstrained inner solver;
/// tolerates infeasible starts).
pub mod augmented_lagrangian_method;
/// Log-barrier method for linear inequality constraints `A x ≤ b`
/// (`constrOptim`-style layer over any unconstrained inner solver).
pub mod barrier_method;
/// Basin-hopping (Wales & Doye 1997): Metropolis Monte-Carlo walk over the
/// `Ẽ(x) = min{f(x)}` transform, wrapping any [`WarmStart`](crate::core::inner::WarmStart)
/// local solver with a pluggable step taker and acceptance test.
pub mod basin_hopping;
/// Box-constrained CMA-ES with adaptive quadratic boundary penalty
/// (Hansen `BoundPenalty`, the default in pycma).
pub mod bounded_cma_es;
/// Memetic [`BoundedCmaEs`] with
/// Hansen-2011 injection: sibling of [`cma_inject`] over the bounded
/// outer. Inners: Nelder-Mead, Levenberg-Marquardt, L-BFGS-B.
pub mod bounded_cma_inject;
/// Brent's method (1D root or minimum bracketing).
pub mod brent;
/// Brent's method using first derivatives ("dbrent", 1D minimization).
pub mod brent_derivative;
/// Hansen 2016 (µ/µ_W, λ)-CMA-ES with negative weights.
pub mod cma_es;
/// Memetic CMA-ES with Hansen-2011 injection. Inners: Nelder-Mead,
/// Levenberg-Marquardt. For L-BFGS-B inner with consistent bound
/// handling, see [`bounded_cma_inject`].
pub mod cma_inject;
/// Differential Evolution (DE/rand/1/bin): Storn-Price 1997 global
/// optimizer on a feasible box, fully backend-generic.
pub mod de;
/// Memetic [`De`] with per-generation top-k local refinement: the
/// DE-flavored sibling of [`cma_inject`]. Inners: Nelder-Mead,
/// Levenberg-Marquardt, L-BFGS-B.
pub mod de_inject;
/// Pure Gauss-Newton solver for nonlinear least squares.
pub mod gauss_newton;
/// Golden-section search (1D minimization on a bracketed interval).
pub mod golden_section;
/// Steepest-descent solver with a pluggable line search and optional
/// heavy-ball momentum.
pub mod gradient_descent;
/// L-BFGS family: unconstrained `Lbfgs<Unbounded>` (two-loop
/// recursion) and box-constrained `Lbfgs<Bounded>` (faithful port of
/// Nocedal's L-BFGS-B v3.0). `Lbfgsb` is a type alias for
/// `Lbfgs<Bounded>`.
pub mod lbfgs;
/// Levenberg-Marquardt solver for nonlinear least squares with
/// Nielsen 1999 damping update.
pub mod levenberg_marquardt;
/// Generic MA-LSCh memetic framework: SSGA + local-search chains,
/// generic over the resumable LS operator.
pub mod ma_ls_ch;
/// MA-LSCh-CMA: memetic algorithm with LS chains (inner: CMA-ES).
pub mod ma_ls_ch_cma;
/// MA-SW-Chains: memetic algorithm with LS chains (inner: Solis-Wets).
pub mod ma_ls_ch_sw;
/// MADS (Audet & Dennis 2006): mesh adaptive direct search (deterministic
/// OrthoMADS instance) for nonsmooth or non-continuous objectives.
pub mod mads;
/// Nelder-Mead derivative-free simplex solver.
pub mod nelder_mead;
/// NEWUOA (Powell 2006): model-based derivative-free trust-region solver
/// (quadratic surrogate + least-Frobenius-norm update).
pub mod newuoa;
/// Shared core of the Powell-family DFO solvers (NEWUOA, BOBYQA, …): the
/// least-Frobenius-norm [`QuadraticModel`](powell::QuadraticModel), its `H`
/// update and origin shift, and the swappable
/// [`TrustRegionSubproblem`](powell::TrustRegionSubproblem) seam.
pub(crate) mod powell;
/// Projected gradient descent for box-constrained problems.
pub mod projected_gradient_descent;
/// Elitist (1+λ) random search over a feasible box.
pub mod random_search;
/// Mini-batch stochastic gradient descent with constant learning rate
/// and optional Polyak heavy-ball momentum.
pub mod sgd;
/// Solis-Wets (1981) adaptive random local search: biased normal
/// mutations with success/failure step-size control.
pub mod solis_wets;
/// Steady-state real-coded GA with BLX-α + NAM + BGA + replace-worst.
pub mod ssga;
/// Levenberg-Marquardt with box bounds (TRF, trust-region-reflective).
pub mod trf;

/// BFGS quasi-Newton solver (dense inverse-Hessian; `Vec<f64>`, nalgebra,
/// faer).
pub mod bfgs;

/// BOBYQA (Powell 2009): bound-constrained model-based derivative-free
/// trust-region solver (shared Powell core + TRSBOX + ALTMOV + RESCUE).
pub mod bobyqa;

/// LINCOA (Powell 2015): linearly-constrained model-based derivative-free
/// trust-region solver (shared Powell core + TRSTEP projected-CG + GETACT).
pub mod lincoa;

/// COBYLA (Powell 1994): nonlinearly-constrained derivative-free solver
/// (simplex linear models + L-infinity merit + `trstlp`).
pub mod cobyla;

/// Trust-region Newton solver (Nocedal & Wright Algorithm 4.1) with
/// pluggable subproblem strategies (Steihaug-CG, dogleg, Cauchy point).
pub mod trust_region;

pub use augmented_lagrangian_method::AugmentedLagrangianMethod;
pub use barrier_method::BarrierMethod;
pub use basin_hopping::{AcceptanceTest, BasinHopping, Metropolis, RandomDisplacement, StepTaker};
pub use bfgs::Bfgs;
pub use bobyqa::Bobyqa;
pub use bounded_cma_es::BoundedCmaEs;
pub use bounded_cma_inject::BoundedCmaInject;
pub use brent::Brent;
pub use brent_derivative::BrentDerivative;
pub use cma_es::CmaEs;
pub use cma_inject::{ClosureInner, CmaInject, MemeticInner};
pub use cobyla::Cobyla;
pub use de::De;
pub use de_inject::DeInject;
pub use gauss_newton::GaussNewton;
pub use golden_section::GoldenSection;
pub use gradient_descent::GradientDescent;
pub use levenberg_marquardt::LevenbergMarquardt;
pub use lincoa::Lincoa;
pub use ma_ls_ch::{MaLsCh, MaLsChGenericState};
pub use ma_ls_ch_cma::{MaLsChCma, MaLsChState};
pub use ma_ls_ch_sw::{MaLsChSw, MaLsChSwState};
pub use mads::{Bounded, Constrained, Mads};
pub use nelder_mead::{NelderMead, Projected, Unbounded};
pub use newuoa::Newuoa;
pub use projected_gradient_descent::ProjectedGradientDescent;
pub use random_search::RandomSearch;
pub use sgd::Sgd;
pub use solis_wets::SolisWets;
pub use ssga::Ssga;
pub use trf::Trf;
pub use trust_region::{CauchyPoint, Dogleg, ExactHessian, MatrixFree, Steihaug, TrustRegion};