Struct AlgorithmBuilder 

pub struct AlgorithmBuilder {

    pub algorithm: AlgorithmChoice,
    pub linear_solver: LinearSolverChoice,
    pub linear_system_scaling: LinearSystemScalingChoice,
    pub linear_scaling_on_demand: bool,
    pub mu_strategy: MuStrategyChoice,
    pub mu_oracle: MuOracleKind,
    pub hessian_approximation: HessianApproxChoice,
    pub partitioned_update_type: UpdateType,
    pub partitioned_update_type_was_set: bool,
    pub partitioned_max_element: usize,
    pub objective_nonlinear_vars: Option<Vec<Index>>,
    pub partitioned_curvature_cap: Number,
    pub partitioned_elements: ElementMode,
    pub partitioned_block_size: usize,
    pub fd_hessian_pattern: FdPatternSource,
    pub fd_hessian_coloring: FdColoring,
    pub fd_hessian_reuse_tol: Number,
    pub limited_memory_update_type: UpdateType,
    pub limited_memory_max_history: i32,
    pub limited_memory_init_val_max: Number,
    pub limited_memory_init_val_min: Number,
    pub limited_memory_initialization: InitialApprox,
    pub limited_memory_init_val: Number,
    pub limited_memory_max_skipping: Index,
    pub limited_memory_nonlinear_vars: Option<Vec<Index>>,
    pub line_search_method: LineSearchChoice,
    pub warm_start_init_point: bool,
    pub mehrotra_algorithm: bool,
    pub fast_step_computation: bool,
    pub kappa_sigma: Number,
    pub recalc_y: bool,
    pub recalc_y_feas_tol: Number,
    pub kappa_d: Number,
    pub s_max: Number,
    pub tiny_step_tol: Number,
    pub tiny_step_y_tol: Number,
    pub diverging_iterates_tol: Number,
    pub dual_diverging_streak: Index,
    pub dual_divergence_retry_step_tol: Number,
    pub dual_divergence_retry_du_floor: Number,
    pub resto_decline_deferrals: Index,
    pub resto_decline_progress_ratio: Number,
    pub neg_curv_escapes: Index,
    pub limited_memory_ls_failure_restarts: Index,
    pub kkt_fidelity_tol: Number,
    pub conv_check: ConvCheckOptions,
    pub mu: MuOptions,
    pub line_search: LineSearchOptions,
    pub refinement: RefinementOptions,
    pub perturbation: PerturbationOptions,
    pub resto: RestoOptions,
    pub output: OutputOptions,
    pub warm: WarmStartOptions,
    pub sqp: SqpOptions,
    pub sqp_qp: QpOptions,
    pub init: InitOptions,
    pub kkt_schur: Option<(Vec<usize>, FeralConfig)>,
    pub quality_escalation_counter: Option<Rc<Cell<u64>>>,
}

Fields

algorithm: AlgorithmChoice

Top-level algorithm dispatch. Default InteriorPoint ⇒ build_with_backend returns the existing AlgorithmBundle (consumed by IpoptAlgorithm). ActiveSetSqp ⇒ caller must use build_sqp_with_backend to assemble the Phase 5b SqpAlgorithm. The two builder methods sit side by side because the assembled algorithm shape differs (IPM bundle vs SQP struct).

linear_solver: LinearSolverChoice

linear_system_scaling: LinearSystemScalingChoice

Symmetric scaling method for the augmented KKT system. Wired into TSymLinearSolver by Self::build_with_backend. Mirrors upstream linear_system_scaling (IpAlgBuilder.cpp:538-560).

linear_scaling_on_demand: bool

Lazy-vs-eager scaling toggle (linear_scaling_on_demand, IpTSymLinearSolver.cpp:50-58). Only consulted when linear_system_scaling != None. Upstream default is true (compute scaling only on the first solve that fails / shows poor conditioning); pounce mirrors that. Set to false to scale every factorization.

mu_strategy: MuStrategyChoice

mu_oracle: MuOracleKind

Selector forwarded to AdaptiveMuUpdate when mu_strategy = Adaptive. Ignored for Monotone. Defaults to QualityFunction per upstream’s RegisterOptions default.

hessian_approximation: HessianApproxChoice

partitioned_update_type: UpdateType

Element update formula for HessianApproxChoice::Partitioned (partitioned_update_type). SR1 by default: a single constraint is not convex, so damped BFGS would force every ∇²c_j model PSD and then scale it by a multiplier of either sign.

partitioned_update_type_was_set: bool

Whether the caller named partitioned_update_type explicitly, so the block mode’s BFGS default does not override them.

partitioned_max_element: usize

Widest element that keeps a dense block under HessianApproxChoice::Partitioned; wider elements degrade to a diagonal approximation (partitioned_max_element).

objective_nonlinear_vars: Option<Vec<Index>>

Variables the objective is nonlinear in, in the compressed x_var space — TNLPAdapter::objective_nonlinear_vars. Consumed by both the partitioned updater (as its objective element’s support) and the finite-difference updater (as the objective’s contribution to a Jacobian-derived Hessian pattern, which the constraint Jacobian cannot supply). None leaves each to fall back on the first ∇f’s nonzeros, which is value-derived; see that method for what it costs.

partitioned_curvature_cap: Number

partitioned_curvature_cap — multiple of an element’s implied curvature that one update may reach. See crate::hess::partitioned_quasi_newton.

partitioned_elements: ElementMode

How the Lagrangian is split into elements under HessianApproxChoice::Partitioned (partitioned_elements).

partitioned_block_size: usize

Target primal-block width when partitioned_elements is blocks (partitioned_block_size).

fd_hessian_pattern: FdPatternSource

Where HessianApproxChoice::FiniteDifference takes its sparsity pattern from (fd_hessian_pattern).

fd_hessian_coloring: FdColoring

How finite-difference probe groups are formed (fd_hessian_coloring).

fd_hessian_reuse_tol: Number

Relative movement in x AND y below which the previous Hessian is reused (fd_hessian_reuse_tol). 0 rebuilds every iteration.

limited_memory_update_type: UpdateType

limited_memory_max_history: i32

History length for the limited-memory quasi-Newton approximation (limited_memory_max_history). Defaults to upstream’s 6.

limited_memory_init_val_max: Number

limited_memory_init_val_max / _min — the clamp on the initial Hessian scalar σ before the rank-2 updates. Upstream defaults 1e8 / 1e-8, which LimMemQuasiNewtonUpdater has carried as hard-coded fields and consumed in initial_hessian_scalar all along; only the read sites were missing (gh#483, #191 round 2).

limited_memory_init_val_min: Number

limited_memory_initialization: InitialApprox

limited_memory_initialization — which formula picks the initial Hessian scalar σ. Matches upstream’s scalar1 (σ = sᵀy/sᵀs). pounce shipped scalar2 (σ = yᵀy/sᵀy) with no way to change it, because the option was registered and never read (#677).

limited_memory_init_val: Number

limited_memory_init_val — σ on the first iteration, before any curvature pair exists, and every iteration under InitialApprox::Constant. Upstream default 1.0.

limited_memory_max_skipping: Index

limited_memory_max_skipping — consecutive skipped curvature updates before the approximation is discarded (#686). Upstream default 2.

limited_memory_nonlinear_vars: Option<Vec<Index>>

Positions in the algorithm’s compressed x_var space that enter the problem nonlinearly (gh#624). None — the default — approximates the Hessian over every variable, which is what the limited-memory path has always done. When set, the quasi-Newton update is restricted to this subspace and the Hessian is exactly zero elsewhere. Comes from TNLPAdapter::quasi_newton_nonlinear_vars (the TNLP’s get_list_of_nonlinear_variables, or the num_linear_variables prefix fallback) and is ignored on the exact-Hessian path.

The restoration sub-IPM must clear this: the mask indexes the original NLP’s variables, not the restoration compound primal.

line_search_method: LineSearchChoice

warm_start_init_point: bool

mehrotra_algorithm: bool

mehrotra_algorithm — when true, PdSearchDirCalc folds the Mehrotra second-order complementarity term into the search-direction RHS. Mirrors upstream’s IpAlgBuilder.cpp:Mehrotra flag. Requires mu_strategy = Adaptive so that an affine step is computed each iteration; Self::build_with_backend does not enforce this — the option-parser in application.rs is responsible for the cascading defaults (mu_oracle = probing etc.).

fast_step_computation: bool

fast_step_computation — when true, PdSearchDirCalc accepts the search direction without the residual check and allows an inexact linear solve. Mirrors upstream’s flag of the same name, default no. The field existed and was consumed from the day the search-direction calculator landed, hard-coded to false; only the option’s read site was missing, so setting it did nothing (gh#483 follow-up, #191 round 2).

kappa_sigma: Number

kappa_sigma — factor bounding how far the bound multipliers may deviate from their primal estimates. The clamp (kappa_sigma_clamp) runs after every accepted step; < 1 disables the correction. Mirrors IpIpoptAlg.cpp (Eqn. (16)), default 1e10. Baked onto crate::ipopt_alg::IpoptAlgorithm by the solve path.

recalc_y: bool

recalc_y / recalc_y_feas_tol — least-square re-estimation of the equality multipliers once feasible (#677). Registered upstream, refused by pounce as unimplemented until now. Default false matches the registry; the limited-memory path turns it on for itself in application.rs, as upstream’s own option text says it does.

recalc_y_feas_tol: Number

kappa_d: Number

kappa_d — weight of the linear damping term added to the barrier objective/gradient (and dual-infeasibility) to handle one-sided bounds. Mirrors IpIpoptCalculatedQuantities.cpp, default 1e-5. Baked onto crate::ipopt_cq::IpoptCalculatedQuantities by the solve path.

s_max: Number

s_max — cap on the average multiplier magnitude used to build the (s_d, s_c) scaling factors of the KKT error test (IpIpoptCalculatedQuantities.cpp:ComputeOptimalityErrorScaling, the paragraph after Eqn. (6) of the implementation paper). Registered default 100, which is what crate::ipopt_cq::IpoptCalculatedQuantities already carries as its struct default, so forwarding it is behaviour-neutral for a run that does not set it (#551 / #677). Baked onto the cq by the solve path, next to kappa_d.

tiny_step_tol: Number

tiny_step_tol — relative primal step size below which the full step is accepted without line search; repeated tiny steps terminate the solve. Mirrors IpBacktrackingLineSearch.cpp, default 10·EPSILON. Baked onto crate::ipopt_alg::IpoptAlgorithm by the solve path.

tiny_step_y_tol: Number

tiny_step_y_tol — dual-step threshold; when both primal and dual steps are tiny in consecutive iterations the algorithm stops at the best attainable accuracy. Default 1e-2.

diverging_iterates_tol: Number

diverging_iterates_tol — if max_i |x_i| exceeds this the solve aborts as diverging. Default 1e20.

dual_diverging_streak: Index

dual_diverging_streak (pounce#246) — consecutive growing-dual- infeasibility iterations before the dual-divergence guard routes to restoration. Default 0 (off).

It defaulted to 15 when introduced, on the strength of a reported emfl050 bad-warm-start grind. That justification did not survive being reproduced: the measurement was caller-side JAX compilation, and the build predating the guard solves both emfl050 instances to the same optimum in the same time (pounce#246 / pounce#250). What remained was a knife-edge, non-monotone effect on four of 1284 MINLPLib models — so it is opt-in rather than imposed. See upstream_options.rs for the full account.

dual_divergence_retry_step_tol: Number

dual_divergence_retry_step_tol (gh#884) — the scale-relative step max_i |d_i| / (1 + |x_i|) at or below which the biactive dual-divergence detector calls the primal iterate settled. Default 1e-5; 0 disables the detector without disabling the dual_divergence_retry option. See upstream_options.rs for the measured population behind the default.

dual_divergence_retry_du_floor: Number

dual_divergence_retry_du_floor (gh#884) — the unscaled dual infeasibility at or above which the same detector calls the multipliers diverged. Default 1e2. Measured in the model’s own units on purpose: the s_d-normalised aggregate is what hid the defect. See upstream_options.rs.

resto_decline_deferrals: Index

resto_decline_deferrals (gh #534) — how many times the acceptable-point restoration decline may be deferred on a solve whose NLP error is still contracting. Default 1; 0 restores the pre-#534 behaviour (decline immediately, always). See upstream_options.rs.

resto_decline_progress_ratio: Number

resto_decline_progress_ratio (gh #534) — required per-iteration contraction of the NLP error before a decline is deferred. Default 0.5; at or above 1 the progress requirement is dropped entirely.

neg_curv_escapes: Index

neg_curv_escapes (gh #797) — how many times a certified stationary point with an indefinite reduced Hessian may be left along a direction of negative curvature instead of reported. Default 1; 0 restores the pre-#797 behaviour. See upstream_options.rs.

limited_memory_ls_failure_restarts: Index

limited_memory_ls_failure_restarts (gh #818) — how many times a line-search failure at an already-feasible point may re-anchor the quasi-Newton model and retry instead of entering restoration. Default 0, i.e. the rung is off and a line-search failure always hands off, which is upstream’s behaviour; see DEFAULT_LBFGS_LS_FAILURE_RESTARTS in ipopt_alg.rs for the measurement that put it there. See upstream_options.rs.

kkt_fidelity_tol: Number

kkt_fidelity_tol (pounce#173). Read by the algorithm as well as by the post-solve gate, because the #200 fallback’s tiebreak has to rank the two candidate points by the status each will be reported under. Default 0.0 (gate disabled).

conv_check: ConvCheckOptions

mu: MuOptions

line_search: LineSearchOptions

refinement: RefinementOptions

perturbation: PerturbationOptions

resto: RestoOptions

output: OutputOptions

warm: WarmStartOptions

sqp: SqpOptions

SQP-specific options (consulted only when algorithm = ActiveSetSqp).

sqp_qp: QpOptions

QP-subproblem-solver options for the active-set SQP path (pounce_qp::QpOptions), threaded into the SqpAlgorithm via with_qp_options. Consulted only when algorithm = ActiveSetSqp. Populated from the sqp_qp_* CLI options by application::apply_qp_subproblem_options.

init: InitOptions

kkt_schur: Option<(Vec<usize>, FeralConfig)>

Optional block-triangular / Schur KKT partition (pounce#180 item 2): (schur_indices, feral_cfg). When Some and the IPM path is selected with the feral linear solver and an exact Hessian, build_with_backend wraps the standard aug-system solver in a crate::kkt::SchurAugSystemSolver over the given KKT-space indices. The Schur solver falls back to the standard solver transparently when the partition is unsuitable. Set via Self::set_kkt_schur.

quality_escalation_counter: Option<Rc<Cell<u64>>>

Shared tally of successful linear-solver quality escalations, handed to the assembled PdFullSpaceSolver by Self::build_with_backend. None leaves that solver with its own private counter, which is what every test double and every direct builder user gets.

The point of sharing it is the restoration sub-solve: its inner algorithm is assembled from a clone of this builder (resto_inner_solver::run_inner_resto), so a Some here makes the sub-solve’s escalations land in the same total as the main loop’s. gh#857’s exact leg escalates once in each, and counting only the main loop would report half the trajectory change.

Implementations

impl AlgorithmBuilder

pub fn new() -> Self

pub fn set_kkt_schur(&mut self, schur_indices: Vec<usize>, cfg: FeralConfig)

Install a Schur KKT partition (pounce#180 item 2). schur_indices are KKT-space indices (0..dim, the x,s,c,d block order the aug-system solver assembles); cfg configures the per-block feral solvers. Only honored on the IPM + feral + exact-Hessian path by Self::build_with_backend; ignored otherwise.

pub fn build(&self) -> AlgorithmBundle

Assemble the strategy bundle without a search-direction calculator. Used by structural unit tests that don’t want to pull in a linear-solver backend.

pub fn build_with_backend( &self, factory: LinearBackendFactory, ) -> AlgorithmBundle

Same as Self::build but also constructs the SymLinearSolver → AugSystemSolver → PdFullSpaceSolver → PdSearchDirCalc chain via the supplied factory.

pub fn build_sqp_with_backend( &self, factory: LinearBackendFactory, ) -> Option<SqpAlgorithm>

Phase 5b assembly path for the SQP algorithm. Consults self.algorithm: when ActiveSetSqp, constructs an SqpAlgorithm using the supplied backend factory for the QP subproblem solver; otherwise returns None so the caller can fall back to the IPM build_with_backend.

Sister to build_with_backend: the SQP algorithm doesn’t share AlgorithmBundle’s shape (no mu_update / no IPM line search), so the two paths return different types.

Trait Implementations

impl Clone for AlgorithmBuilder

fn clone(&self) -> AlgorithmBuilder

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AlgorithmBuilder

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for AlgorithmBuilder

fn default() -> Self

Returns the “default value” for a type.