Struct PresolveOptions 

pub struct PresolveOptions {

    pub enabled: bool,
    pub bound_tightening: bool,
    pub redundant_constraint_removal: bool,
    pub linear_eq_reduction: bool,
    pub licq_check: bool,
    pub print_level: Index,
    pub max_passes: Index,
    pub licq_action: LicqAction,
    pub warm_z_bounds: bool,
    pub bound_mult_init_val: Number,
    pub auxiliary: bool,
    pub auxiliary_tol: Number,
    pub auxiliary_max_block_dim: Index,
    pub auxiliary_wall_time_fraction: Number,
    pub auxiliary_coupling: AuxiliaryCouplingPolicy,
    pub auxiliary_diagnostics: bool,
    pub fbbt: bool,
    pub fbbt_tol: Number,
    pub fbbt_max_iter: Index,
    pub fbbt_max_constraints: Index,
}

Resolved presolve options, materialised from an OptionsList.

Keeping this as a plain Copy struct makes Phase 0’s no-op path branch-free; later phases that grow more state can promote it to a Clone struct without API churn.

Fields

enabled: bool

Master switch (presolve). When false, the wrapper is a no-op and wrap_with_presolve returns the inner TNLP.

bound_tightening: bool

presolve_bound_tightening — Phase 1.

redundant_constraint_removal: bool

presolve_redundant_constraint_removal — Phase 2.

linear_eq_reduction: bool

presolve_linear_eq_reduction — Phase ≥2, off by default.

licq_check: bool

presolve_licq_check — Phase 3.

print_level: Index

presolve_print_level — 0 silent, 5 per-pass, 8 per-xform.

max_passes: Index

presolve_max_passes — fixed-point iteration cap.

licq_action: LicqAction

presolve_licq_action — what to do on degenerate equality rows. Phase 3 honours auto_l1; Phase 0 just stores it.

warm_z_bounds: bool

presolve_warm_z_bounds — Phase 4: hint bound-multiplier warm starts for variables whose bounds were tightened.

bound_mult_init_val: Number

presolve_bound_mult_init_val — value used for those hints.

auxiliary: bool

presolve_auxiliary — master switch for the Phase-0 auxiliary-equality preprocessing pass (issue #53). When false (the default), Phase 0 is a no-op even if the outer enabled master switch is on.

auxiliary_tol: Number

presolve_auxiliary_tol — residual tolerance for accepting a candidate block solve (full-space KKT residual after the reduction must stay within this).

auxiliary_max_block_dim: Index

presolve_auxiliary_max_block_dim — the lightweight Newton solver only handles blocks up to this dimension. PR 11 lifts this by injecting an IPM-backed fallback.

auxiliary_wall_time_fraction: Number

presolve_auxiliary_wall_time_fraction — fraction of the solver’s overall wall-time budget Phase 0 is allowed to spend.

auxiliary_coupling: AuxiliaryCouplingPolicy

presolve_auxiliary_coupling — which coupling classes are eligible for elimination.

auxiliary_diagnostics: bool

presolve_auxiliary_diagnostics — emit the diagnostics struct via the journalist.

fbbt: bool

presolve_fbbt — Feasibility-Based Bound Tightening over nonlinear constraint expression DAGs (issue #62). Off by default until benchmark evidence justifies a flip.

fbbt_tol: Number

fbbt_tol — minimum bound improvement to keep iterating.

fbbt_max_iter: Index

fbbt_max_iter — outer sweep cap.

fbbt_max_constraints: Index

fbbt_max_constraints — cap on constraints examined per sweep; 0 means unlimited.

Implementations

impl PresolveOptions

pub fn defaults() -> Self

All-default settings, matching the registered defaults.

Examples found in repository

examples/auxiliary_noop.rs (line 84)

fn main() {
    let opts = PresolveOptions {
        enabled: true,
        auxiliary: true,
        auxiliary_coupling: AuxiliaryCouplingPolicy::Safe,
        auxiliary_diagnostics: true,
        ..PresolveOptions::defaults()
    };
    let inner: Rc<RefCell<dyn TNLP>> = Rc::new(RefCell::new(Mini));
    let wrapped = wrap_with_presolve(inner, opts).expect("wrap ok");

    // Trigger lazy init through any TNLP method.
    let info = wrapped.borrow_mut().get_nlp_info().expect("get_nlp_info");

    // Force one Jacobian-values call so the example exercises the
    // forwarding path (the wrapper does not change anything in PR 1).
    let mut values = vec![0.0; info.nnz_jac_g as usize];
    let ok = wrapped.borrow_mut().eval_jac_g(
        Some(&[0.5, 0.5]),
        true,
        SparsityRequest::Values {
            values: &mut values,
        },
    );
    assert!(ok, "eval_jac_g(Values) must succeed");

    // Downcast back to PresolveTnlp via a typed handle would require
    // a different constructor; instead, build a second wrapper using
    // PresolveTnlp::new so we can read the diagnostics.
    let inner2: Rc<RefCell<dyn TNLP>> = Rc::new(RefCell::new(Mini));
    let mut typed = PresolveTnlp::new(inner2, opts);
    let _ = typed.get_nlp_info();
    let d = typed.auxiliary_diagnostics();

    println!("auxiliary_noop example — PR 1 of pounce#53");
    println!(
        "inner shape: n={}, m={}, nnz_jac_g={}",
        info.n, info.m, info.nnz_jac_g
    );
    println!("jac values at (0.5, 0.5): {:?}", values);
    println!(
        "diagnostics: blocks_eliminated={}, vars_eliminated={}, rows_eliminated={}, total_time_ms={}",
        d.blocks_eliminated, d.vars_eliminated, d.rows_eliminated, d.total_time_ms,
    );
    println!("rejection_reasons: {:?}", d.rejection_reasons);
}

examples/phase0_via_tnlp.rs (line 128)

fn main() {
    let opts = PresolveOptions {
        enabled: true,
        auxiliary: true,
        // Aggressive lets us eliminate even when grad_f is non-zero
        // at the block variables at the probe (ObjectiveCoupled).
        auxiliary_coupling: AuxiliaryCouplingPolicy::Aggressive,
        ..PresolveOptions::defaults()
    };
    let inner: Rc<RefCell<dyn TNLP>> = Rc::new(RefCell::new(Mini));
    let wrapped = wrap_with_presolve(inner, opts).expect("wrap ok");

    let info = wrapped.borrow_mut().get_nlp_info().expect("init");
    println!("phase0_via_tnlp — PR 8 of pounce#53");
    println!("====================================");
    println!("Inner TNLP: n=2, m=2 (two equalities).");
    println!("After PresolveTnlp wrapping with presolve_auxiliary=yes:");
    println!("   outer n = {}", info.n);
    println!("   outer m = {}", info.m);
    println!("   outer nnz_jac_g = {}", info.nnz_jac_g);

    // Read the clamped bounds.
    let mut x_l = vec![0.0; info.n as usize];
    let mut x_u = vec![0.0; info.n as usize];
    let mut g_l = vec![0.0; info.m as usize];
    let mut g_u = vec![0.0; info.m as usize];
    wrapped.borrow_mut().get_bounds_info(BoundsInfo {
        x_l: &mut x_l,
        x_u: &mut x_u,
        g_l: &mut g_l,
        g_u: &mut g_u,
    });
    println!("\nClamped bounds (from PresolveTnlp):");
    println!("   x_l = {:?}", x_l);
    println!("   x_u = {:?}", x_u);
    println!("   g_l = {:?}", g_l);

    // Simulate the IPM handing back a solution: the eliminated vars
    // are pinned to their clamps; outer lambda is empty (no rows).
    let sol_x = [x_l[0], x_l[1]];
    let sol_z_l = vec![0.0; info.n as usize];
    let sol_z_u = vec![0.0; info.n as usize];
    let sol_lambda: Vec<Number> = Vec::new(); // outer m == 0
    let sol_g: Vec<Number> = Vec::new();
    let ip_data = IpoptData::default();
    let ip_cq = IpoptCq::default();
    wrapped.borrow_mut().finalize_solution(
        Solution {
            status: SolverReturn::Success,
            x: &sol_x,
            z_l: &sol_z_l,
            z_u: &sol_z_u,
            g: &sol_g,
            lambda: &sol_lambda,
            obj_value: 0.0,
        },
        &ip_data,
        &ip_cq,
    );

    println!("\n✓ End-to-end orchestrator path exercised.");
}

pub fn from_options_list(opts: &OptionsList) -> Result<Self, SolverException>

Read every presolve_* key out of an OptionsList, falling back to registered defaults where unset.

Trait Implementations

impl Clone for PresolveOptions

fn clone(&self) -> PresolveOptions

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PresolveOptions

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

Formats the value using the given formatter.

impl Copy for PresolveOptions