Struct ConstrainedMadsState 

pub struct ConstrainedMadsState<V, F = f64> { /* private fields */ }

Solver state for the constrained MADS variant (Mads<Constrained>), which handles nonlinear inequality constraints c(x) ≤ 0 by the progressive barrier (see Mads::constrained).

It carries the same poll/mesh bookkeeping as MadsState plus the aggregate constraint violation h(x) = Σⱼ max(cⱼ(x), 0)² at the reported incumbent (constraint_violation; 0 ⇔ feasible). Construct it with new from the starting point — an infeasible start is allowed (the progressive barrier relaxes its way to feasibility).

Current vs best

Unlike the unconstrained MadsState, the reported objective is not monotone — a newly found feasible point can have a higher f than a prior infeasible incumbent. The solver’s progressive-barrier driver owns the incumbent selection, so update_best mirrors the current iterate unconditionally (the same rule CobylaState uses), rather than ranking by cost.

The scalar F defaults to f64 so call sites resolve unchanged.

Implementations

impl<V, F: Scalar> ConstrainedMadsState<V, F>

pub fn new(x0: V) -> Self

Build an initial constrained-MADS state at the starting point x0 (which may be infeasible). The solver evaluates x0’s cost and violation and fills the poll size in Solver::init.

pub fn constraint_violation(&self) -> F

The aggregate constraint violation h = Σⱼ max(cⱼ, 0)² at the reported incumbent. 0 once the incumbent is feasible; +∞ before Solver::init.

pub fn poll_size(&self) -> F

The current poll size Δᵖ.

pub fn mesh_index(&self) -> i32

The current mesh index ℓ (OrthoMADS eq. (1)).

Trait Implementations

impl<V, F> CountsMirror for ConstrainedMadsState<V, F>

where ConstrainedMadsState<V, F>: State,

fn mirror(&mut self, delta: &EvalCounts)

Overwrite the state’s counters from the per-run wrapper delta. Called by the executor after every successful Solver::init / Solver::next_iter.

impl<V: Clone, F: Scalar> MeshState for ConstrainedMadsState<V, F>

fn poll_size(&self) -> F

The current poll size Δᵖ (bounds the distance from the incumbent to the poll trial points).

fn mesh_index(&self) -> i32

The current mesh index ℓ (OrthoMADS eq. (1)).

impl<P, V, F> Solver<P, ConstrainedMadsState<V, F>> for Mads<Constrained, F>

where F: Scalar, P: CostFunction<Param = V, Output = F> + NonlinearInequalityConstraints, 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: ConstrainedMadsState<V, F>, ) -> Result<ConstrainedMadsState<V, F>, Self::Error>

One-time setup before the iteration loop.

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

Advance one iteration.

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

Optional pre-iteration solver-specific termination test.

impl<V: Clone, F: Scalar> State for ConstrainedMadsState<V, F>

fn cost(&self) -> F

Cost at the current param.

Panics

Panics if read before Solver::init has evaluated the starting point.

fn update_best(&mut self)

Mirror the current incumbent unconditionally — the progressive-barrier driver owns incumbent selection, and the reported cost is not monotone across the feasibility transition, so a cost-ranked best would be wrong.

type Param = V

The parameter type the solver iterates over (e.g. Vec<f64>, nalgebra::DVector<f64>).

type Float = F

The scalar type of the objective. In practice always f64 (see the module docs).

fn iter(&self) -> u64

Number of fully completed iterations. A Solver::next_iter that bails mid-iteration with Some(reason) does not increment this counter — see the executor module for the exact ordering.

fn increment_iter(&mut self)

Increment iter by one. Called by the executor after a successful Solver::next_iter.

fn cost_evals(&self) -> u64

Cumulative count of cost-function evaluations performed so far. Diverges from iter() whenever a single iteration evaluates the cost more than once (line searches, Nelder-Mead shrinks, etc.) — this is what users actually budget against.

fn param(&self) -> &V

Current iterate. Stable between Solver::next_iter calls; safe to read at any iteration including iter 0.

fn best_param(&self) -> &V

Best param ever observed by the executor’s best-tracking on this state.

fn best_cost(&self) -> F

Cost at best_param — the lowest cost ever observed on this state.

fn best_iter(&self) -> u64

Iteration at which the current best was found. 0 before the first update_best call; thereafter, the value of iter at the moment of the last strict improvement in best_cost().

fn best_cost_evals(&self) -> u64

Cumulative cost evaluations at the moment the current best was found — useful for benchmarking (“how many evals until the solver hit its best?”).

fn reset_best(&mut self)

Reset the best-so-far slots to their pre-init defaults (best_cost = +∞, all best counters zero).