Struct Corrector 

pub struct Corrector { /* private fields */ }

Corrector for applying robust loss functions via residual and Jacobian adjustment.

This struct holds the precomputed scaling factors needed to transform a robust loss problem into an equivalent reweighted least squares problem. It is instantiated once per residual block during each iteration of the optimizer.

Fields

• sqrt_rho1: √(ρ’(s)) - Square root of the first derivative, used for residual scaling
• residual_scaling: √(ρ’(s)) - Same as sqrt_rho1, stored separately for clarity
• alpha_sq_norm: α² = ρ’‘(s) / ρ’(s) - Ratio of second to first derivative, used for Jacobian correction

where s = ||r||² is the squared norm of the residual.

Implementations

impl Corrector

pub fn new(loss_function: &dyn LossFunction, sq_norm: f64) -> Self

Create a new Corrector by evaluating the loss function at the given squared norm.

Arguments

• loss_function - The robust loss function ρ(s)
• sq_norm - The squared norm of the residual: s = ||r||²

Returns

A Corrector instance with precomputed scaling factors

Example

use apex_solver::core::corrector::Corrector;
use apex_solver::core::loss_functions::{LossFunction, HuberLoss};
use nalgebra::DVector;

let loss = HuberLoss::new(1.0)?;
let residual = DVector::from_vec(vec![1.0, 2.0, 3.0]);
let squared_norm = residual.dot(&residual); // 14.0

let corrector = Corrector::new(&loss, squared_norm);
// corrector is now ready to apply corrections

pub fn correct_jacobian( &self, residual: &DVector<f64>, jacobian: &mut DMatrix<f64>, )

Apply correction to the Jacobian matrix.

Transforms the Jacobian J into J̃ according to the Ceres Solver corrector algorithm:

J̃ = √(ρ'(s)) · (J - α²·r·r^T·J)

where:

• √(ρ'(s)) scales the Jacobian by the loss function weight
• α is computed by solving the quadratic equation: 0.5·α² - α - (ρ’‘/ρ’)·s = 0
• The subtractive term α²·r·r^T·J is a rank-1 curvature correction

Arguments

• residual - The original residual vector r
• jacobian - Mutable reference to the Jacobian matrix (modified in-place)

Implementation Notes

The correction is applied in-place for efficiency. The algorithm:

1. Scales all Jacobian entries by √(ρ'(s))
2. Adds the outer product correction: α · (J^T r) · r^T / ||r||

Example

use apex_solver::core::corrector::Corrector;
use apex_solver::core::loss_functions::{LossFunction, HuberLoss};
use nalgebra::{DVector, DMatrix};

let loss = HuberLoss::new(1.0)?;
let residual = DVector::from_vec(vec![2.0, 1.0]);
let squared_norm = residual.dot(&residual);

let corrector = Corrector::new(&loss, squared_norm);

let mut jacobian = DMatrix::from_row_slice(2, 3, &[
    1.0, 0.0, 1.0,
    0.0, 1.0, 1.0,
]);

corrector.correct_jacobian(&residual, &mut jacobian);
// jacobian is now corrected to account for the robust loss

pub fn correct_residuals(&self, residual: &mut DVector<f64>)

Apply correction to the residual vector.

Transforms the residual r into r̃ by scaling:

r̃ = √(ρ'(s)) · r

This ensures that ||r̃||² ≈ ρ(||r||²), i.e., the squared norm of the corrected residual approximates the robust cost.

Arguments

• residual - Mutable reference to the residual vector (modified in-place)

Example

use apex_solver::core::corrector::Corrector;
use apex_solver::core::loss_functions::{LossFunction, HuberLoss};
use nalgebra::DVector;

let loss = HuberLoss::new(1.0)?;
let mut residual = DVector::from_vec(vec![2.0, 3.0, 1.0]);
let squared_norm = residual.dot(&residual);

let corrector = Corrector::new(&loss, squared_norm);

corrector.correct_residuals(&mut residual);
// Outlier residuals are scaled down

pub fn correct_residual_in_place(&self, residual: &mut [f64])

In-place residual correction over a flat slice. Equivalent to correct_residuals but does not require a DVector wrapper.

pub fn correct_jacobian_in_place( &self, residual: &[f64], jac: &mut [f64], rows: usize, cols: usize, )

In-place Jacobian correction over a column-major (rows × cols) buffer.

jac.len() == rows * cols, residual.len() == rows. The math is identical to Corrector::correct_jacobian but operates directly on flat memory — no DVector/DMatrix allocation or copy.

Formula: J̃ = √ρ₁ · (J − α²·r·rᵀ·J)

Trait Implementations

impl Clone for Corrector

fn clone(&self) -> Corrector

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Corrector

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

Formats the value using the given formatter.