Override the default loop so we can use the projected gradient (rather than the full gradient) as the convergence criterion for `stopping_progress.gra

Convenience wrapper: call `cstep` with mutable local state and return the info code. Mirrors the raw parameter order of the implementation so test se

Classifier-accuracy helper shared across the SVM examples. `scores` is the signed margin `w^T x + b`; a positive value predicts class +1.

Load the versicolor-vs-virginica subset. When `normalize == true` (the default), each feature column is centred and scaled to unit standard deviation

Extend a CG iterate to the trust-region boundary along the current direction. Solves the scalar quadratic ||p + tau * direction||^2 = radius^2 for `t

Sup-norm of the box-projected gradient: |g_j| zeroed at any coordinate where `x_j` has hit an active bound and `g_j` points out of the box. This is t

Updates state from function information. For plain `FunctionState`, the `(value, gradient)` invariant means we can read the numbers we need directly

Convenience: run the solver on the problem bound at construction.

CG-Steihaug subproblem solver. Computes an approximate solution to min_{||p|| <= Delta} g^T p + 0.5 p^T H p. The returned `*step` is the approximat

Constructor #1: Construct from an initial guess, custom initializer lists for equality and inequality multipliers, and a penalty value. Usage: Augmen

HZ, stage U3 with theta = 0.5: bisect until slope flips or interval collapses, keeping `a` on the descent side.

Clamp an equality-multiplier candidate into the symmetric safeguard box. NaN values (e.g. from an ill-posed inner solve) are replaced by zero so the

Clamp an inequality-multiplier candidate into the non-negative safeguard box. The caller has already applied the `max(0, .)` projection; this clamp o

Auto-scale the initial penalty so that the augmented-Lagrangian penalty term has the same order of magnitude as the objective at the initial iterate.

Evaluate grad_x L(x, lambda, mu) at the current state and return the sup-norm of its projected form. L(x, lambda, mu) = f(x) + sum lambda_i c_i(x) -

Install the subproblem stopping criteria on the provided inner solver clone. Two distinct modes: - On outer iteration 1 of a problem that has at lea

* @brief find alpha* = max {a : a <= 1 and l_i-xc_i <= a*d_i <= u_i-xc_i} */

Legacy x-only constructor. Leaves value = 0 and gradient = empty; the caller must populate them before the state is consumed by the new eval-free cod

Dimension at runtime: `d + 1` where `d` is the feature count.

Initialize the solver with the starting point.

Constructor: initializes multipliers with zeros.

Inherit `Solver`'s default constructor, then re-enable the factr-equivalent f-delta stopping test. Plain L-BFGS/BFGS leave `f_delta = 0` (reference-c

Nelder-Mead is derivative-free: it cannot use a gradient-norm test to confirm "we really are at a minimum", so the solver relies on `x_delta`/`f_delta

Performs one iteration (step) of the Nelder–Mead algorithm. This implementation updates the internal simplex and returns the current best vertex.

Constructor: initializes the penalty value.

Evaluate phi(alpha) = f(x + alpha * s) and its directional derivative dphi(alpha) = g(x+alpha*s)^T s, reusing workspace to avoid allocation.

HZ Wolfe and approximate-Wolfe acceptance test (paper equations T1/T2). The approximate-Wolfe (T2) branch becomes active only once `phi_c` drops withi

* @brief Run the Hager-Zhang search and return only the step width. */

* @brief use Armijo Rule for (weak) Wolfe conditiions * @details [long description] * * @param search_direction search direction for next upd

* @brief use Armijo Rule for (weak) Wolfe conditiions * @details [long description] * * @param search_direction search direction for next upd

* @brief Run the More-Thuente search and return only the step width. * * Convenience overload that evaluates `function(x, &g)` internally. Pref

HZ, stages S1-S4: scalar secant between two derivative samples.

HZ, stages S1-S4: take two secant-driven candidates, call Update up to twice. Returns `(wolfe_hit, new_ia, new_ib)`.

* @brief Solve MM * x = b using stored LU factorization (triangular solves) * More efficient than computing M_ * b when M_ = MM^{-1} */

* @brief sort pairs (k,v) according v ascending */