Struct RealFactorization 

pub struct RealFactorization { /* private fields */ }

A real sparse system whose sparsity pattern and values are both fixed across repeated solves, so the whole factorization — not merely the symbolic half — is computed once and reused.

This is the real-arithmetic twin of ComplexSparseSystem, and it exists for the same reason that type does: the DC (Bθ) susceptance matrix (linear::btheta) depends only on the topology, so a DC solve, a PTDF column and a LODF column are all just different right-hand sides against one factorization.

RealSparseSystem cannot serve that. Its contract — the one LinearSolver codifies — is “pattern fixed, values change every call”, so it numerically refactorizes on every factor_and_solve. That is exactly right for Newton-Raphson, whose Jacobian really does change every iteration, and exactly wrong for PTDF, which would pay a fresh factorization once per bus.

Implementations

impl RealFactorization

pub fn new(n: usize, entries: &[(usize, usize, f64)]) -> Option<Self>

Factorizes once. Returns None if the matrix is singular or malformed.

pub fn n(&self) -> usize

pub fn solve(&self, rhs: &[f64]) -> Option<Vec<f64>>

Solves A x = b against the cached factorization.

Singularity is checked on the result rather than reported by faer, which returns NaN-poisoned values instead of an error — the same contract solve_complex documents.

pub fn solve_transpose(&self, rhs: &[f64]) -> Option<Vec<f64>>

Solves Aᵀ x = b against the same cached factorization.

No second factorization is involved: an LU = PAQ decomposition solves the transposed system by running the same triangular factors in the opposite order, which is what faer’s solve_transpose_in_place does.

This is what makes an adjoint sensitivity affordable. A forward sensitivity answers “how does everything respond to this variable” in one solve against A; the adjoint answers “how does this quantity respond to everything” in one solve against Aᵀ. Both directions are useful and neither is derivable from the other cheaply, so ac_sensitivity offers both — see linear::sensitivity’s ptdf_column/ptdf_row pair for the same duality on the DC side.