Trait SparseSymLinearSolverInterface 

pub trait SparseSymLinearSolverInterface {
    // Required methods
    fn initialize_structure(
        &mut self,
        dim: Index,
        nonzeros: Index,
        ia: &[Index],
        ja: &[Index],
    ) -> ESymSolverStatus;
    fn values_array_mut(&mut self) -> &mut [Number] ;
    fn multi_solve(
        &mut self,
        new_matrix: bool,
        ia: &[Index],
        ja: &[Index],
        nrhs: Index,
        rhs_vals: &mut [Number],
        check_neg_evals: bool,
        number_of_neg_evals: Index,
    ) -> ESymSolverStatus;
    fn number_of_neg_evals(&self) -> Index;
    fn increase_quality(&mut self) -> bool;
    fn provides_inertia(&self) -> bool;
    fn matrix_format(&self) -> EMatrixFormat;

    // Provided methods
    fn provides_degeneracy_detection(&self) -> bool { ... }
    fn determine_dependent_rows(
        &mut self,
        _ia: &[Index],
        _ja: &[Index],
        _c_deps: &mut Vec<Index>,
    ) -> ESymSolverStatus { ... }
    fn factor_pattern(&self, _want_values: bool) -> Option<FactorPattern> { ... }
}

Backend-side trait. The lifecycle mirrors upstream’s narrative comment in IpSparseSymLinearSolverInterface.hpp:

1. caller asks Self::matrix_format.
2. caller calls Self::initialize_structure once with (ia, ja).
3. caller takes the values pointer from Self::values_array_mut, fills it.
4. caller calls Self::multi_solve with new_matrix=true for each new value pattern.
5. caller may query Self::number_of_neg_evals / Self::increase_quality between solves.

new_matrix=false requests a back-substitution against the existing factorization.

Required Methods

fn initialize_structure( &mut self, dim: Index, nonzeros: Index, ia: &[Index], ja: &[Index], ) -> ESymSolverStatus

Initialize backend internal structures for a matrix of given dimension and pattern.

fn values_array_mut(&mut self) -> &mut [Number]

Slice into which the caller writes the matrix nonzeros (in the same order as ja from Self::initialize_structure).

fn multi_solve( &mut self, new_matrix: bool, ia: &[Index], ja: &[Index], nrhs: Index, rhs_vals: &mut [Number], check_neg_evals: bool, number_of_neg_evals: Index, ) -> ESymSolverStatus

Factor (if new_matrix) and back-substitute against nrhs right-hand sides packed in rhs_vals (length nrhs * dim). Solutions overwrite rhs_vals.

fn number_of_neg_evals(&self) -> Index

Number of negative eigenvalues found in the most recent factorization. Caller must check Self::provides_inertia first.

fn increase_quality(&mut self) -> bool

Ask the backend to use a more accurate (but slower) pivot strategy on the next solve. Returns false if the maximum quality is already reached.

fn provides_inertia(&self) -> bool

Whether this backend reports the number of negative eigenvalues post-factor.

fn matrix_format(&self) -> EMatrixFormat

Required matrix layout. Caller marshals data into this format.

Provided Methods

fn provides_degeneracy_detection(&self) -> bool

Whether Self::determine_dependent_rows is supported.

fn determine_dependent_rows( &mut self, _ia: &[Index], _ja: &[Index], _c_deps: &mut Vec<Index>, ) -> ESymSolverStatus

Find linearly dependent rows — used by Ipopt’s degeneracy probe. Default is FatalError matching upstream’s default implementation.

fn factor_pattern(&self, _want_values: bool) -> Option<FactorPattern>

Snapshot of the most recent factor’s L pattern and permutation. Backends that expose their factor data structures (e.g. feral) return Some(_); backends that don’t (e.g. MA57, which keeps its factors inside opaque Fortran work arrays) return None. Diagnostic-only — consumed by the --dump kkt:*+L path. Set want_values=true to populate FactorPattern::l_vals.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors