Struct OrthogonalReparam 

pub struct OrthogonalReparam { /* private fields */ }

An exact orthogonal reparameterization of one confound block against one primary block’s column span in a fixed row metric W.

Holds the shear matrix B (p_m × p_c) and the reparameterized confound design C̃ = C − M·B (n × p_c). The transform is a pure change of basis, so it is fully described by B; C̃ is cached because the solver needs the new design and recomputing it is wasteful.

Build with OrthogonalReparam::build_unconditional. The round-trip recover_original maps fitted reparameterized coefficients back to the original basis exactly.

Implementations

impl OrthogonalReparam

pub fn build_unconditional( primary: ArrayView2<'_, f64>, confound: ArrayView2<'_, f64>, w_metric: &Array1<f64>, ) -> Result<Self, String>

Build the exact orthogonal reparameterization of the confound block against the primary block’s column span in the w_metric row metric.

Robustness is unconditional, so this always constructs the reparam (the caller decides whether there is anything to orthogonalize; an empty span p_m == 0 or p_c == 0 yields an identity-on-confound transform).

Returns:

• Ok(reparam) with C̃ exactly W-orthogonal to span(primary).
• Err on a dimension mismatch, a non-finite/negative metric, or a non-finite result.

primary is n × p_m, confound is n × p_c, w_metric is length n with w_i ≥ 0 (the PIRLS row inner product at the pilot, so the resulting orthogonality holds in the metric the penalized joint solve actually sees; pass all-ones for the plain Euclidean metric).

pub fn shear(&self) -> ArrayView2<'_, f64>

The shear matrix B (p_m × p_c). Original primary coefficients are β_m = β̃_m − B·β_c.

pub fn reparameterized_confound(&self) -> ArrayView2<'_, f64>

The reparameterized confound design C̃ = C − M·B (n × p_c), exactly W-orthogonal to span(primary). This is the design the solver fits the confound coefficients against.

pub fn primary_cols(&self) -> usize

Number of primary columns p_m.

pub fn confound_cols(&self) -> usize

Number of confound columns p_c.

pub fn recover_original( &self, beta_m_reparam: &Array1<f64>, beta_c: &Array1<f64>, ) -> Result<(Array1<f64>, Array1<f64>), String>

Map the fitted reparameterized coefficients (β̃_m, β_c) back to the original basis (β_m, β_c) exactly:

    β_m = β̃_m − B·β_c,      β_c unchanged.

beta_m_reparam has length p_m, beta_c has length p_c. Returns the original-basis (β_m, β_c). Because the predictor M·β̃_m + C̃·β_c equals M·β_m + C·β_c for these recovered coefficients, predictions in the original basis are unchanged.

pub fn to_reparameterized( &self, beta_m: &Array1<f64>, beta_c: &Array1<f64>, ) -> Result<Array1<f64>, String>

Forward shear: map original-basis primary coefficients β_m to the reparameterized basis β̃_m = β_m + B·β_c (the inverse of recover_original). Useful for warm-starting the reparameterized solve from an original-basis initial guess.

Trait Implementations

impl Clone for OrthogonalReparam

fn clone(&self) -> OrthogonalReparam

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for OrthogonalReparam

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

Formats the value using the given formatter.