Struct LinearSolveStep 

pub struct LinearSolveStep { /* private fields */ }

One residual-projection conditioning step.

Implementations

impl LinearSolveStep

pub const fn residual_norm_before(&self) -> f64

Residual norm ||b - A m|| of the belief mean before this projection.

Examples found in repository

examples/probabilistic_linear_solver.rs (line 30)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // A x = b with A symmetric positive definite, stored row-major.
    let system = SpdLinearSystem::new(
        &[4.0, 1.0, 0.0, 1.0, 3.0, 1.0, 0.0, 1.0, 2.0],
        &[1.0, 2.0, 3.0],
        3,
    )?;
    // Prior belief x ~ N(0, I).
    let identity = [1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0];
    let prior = GaussianLinearBelief::new(&[0.0; 3], &identity, 3)?;

    // Residual-driven policy: each step observes the projection along the normalized residual.
    let solver = ResidualProjectionSolver::new(1.0e-10, 0.0, 3)?;
    let result = solver.solve(&system, &prior)?;
    println!("residual policy");
    println!("  mean            = {:?}", result.belief().mean());
    println!("  stopped because = {:?}", result.termination());
    for (index, step) in result.steps().iter().enumerate() {
        println!(
            "  step {index}: residual {:.3e} -> {:.3e}, covariance trace {:.3e}",
            step.residual_norm_before(),
            step.residual_norm_after(),
            step.covariance_trace_after(),
        );
    }

    // A-conjugate policy: the same information subspace in an A-orthogonal basis.
    let conjugate = AConjugateProjectionSolver::new(1.0e-10, 0.0, 3)?;
    let result = conjugate.solve(&system, &prior)?;
    println!("A-conjugate policy");
    println!("  mean            = {:?}", result.belief().mean());
    println!("  stopped because = {:?}", result.termination());

    // Covariance-greedy policy: directions are chosen without looking at b, so the
    // posterior covariance keeps its calibrated interpretation under the assumed prior.
    let candidates: Vec<Vec<f64>> = (0..3)
        .map(|axis| {
            let mut direction = vec![0.0; 3];
            direction[axis] = 1.0;
            direction
        })
        .collect();
    let greedy = CovarianceGreedyProjectionSolver::new(0.0, 2)?;
    let result = greedy.solve(&system, &prior, &candidates)?;
    println!("covariance-greedy policy (budget of two projections)");
    println!("  mean            = {:?}", result.belief().mean());
    println!("  stopped because = {:?}", result.termination());
    for (index, step) in result.steps().iter().enumerate() {
        println!(
            "  step {index}: direction {:?}, predicted trace reduction {:.3e}, posterior trace {:.3e}",
            step.direction(),
            step.predicted_trace_reduction(),
            step.posterior_trace(),
        );
    }
    Ok(())
}

pub const fn residual_norm_after(&self) -> f64

Residual norm of the updated belief mean after this projection.

Examples found in repository

examples/probabilistic_linear_solver.rs (line 31)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // A x = b with A symmetric positive definite, stored row-major.
    let system = SpdLinearSystem::new(
        &[4.0, 1.0, 0.0, 1.0, 3.0, 1.0, 0.0, 1.0, 2.0],
        &[1.0, 2.0, 3.0],
        3,
    )?;
    // Prior belief x ~ N(0, I).
    let identity = [1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0];
    let prior = GaussianLinearBelief::new(&[0.0; 3], &identity, 3)?;

    // Residual-driven policy: each step observes the projection along the normalized residual.
    let solver = ResidualProjectionSolver::new(1.0e-10, 0.0, 3)?;
    let result = solver.solve(&system, &prior)?;
    println!("residual policy");
    println!("  mean            = {:?}", result.belief().mean());
    println!("  stopped because = {:?}", result.termination());
    for (index, step) in result.steps().iter().enumerate() {
        println!(
            "  step {index}: residual {:.3e} -> {:.3e}, covariance trace {:.3e}",
            step.residual_norm_before(),
            step.residual_norm_after(),
            step.covariance_trace_after(),
        );
    }

    // A-conjugate policy: the same information subspace in an A-orthogonal basis.
    let conjugate = AConjugateProjectionSolver::new(1.0e-10, 0.0, 3)?;
    let result = conjugate.solve(&system, &prior)?;
    println!("A-conjugate policy");
    println!("  mean            = {:?}", result.belief().mean());
    println!("  stopped because = {:?}", result.termination());

    // Covariance-greedy policy: directions are chosen without looking at b, so the
    // posterior covariance keeps its calibrated interpretation under the assumed prior.
    let candidates: Vec<Vec<f64>> = (0..3)
        .map(|axis| {
            let mut direction = vec![0.0; 3];
            direction[axis] = 1.0;
            direction
        })
        .collect();
    let greedy = CovarianceGreedyProjectionSolver::new(0.0, 2)?;
    let result = greedy.solve(&system, &prior, &candidates)?;
    println!("covariance-greedy policy (budget of two projections)");
    println!("  mean            = {:?}", result.belief().mean());
    println!("  stopped because = {:?}", result.termination());
    for (index, step) in result.steps().iter().enumerate() {
        println!(
            "  step {index}: direction {:?}, predicted trace reduction {:.3e}, posterior trace {:.3e}",
            step.direction(),
            step.predicted_trace_reduction(),
            step.posterior_trace(),
        );
    }
    Ok(())
}

pub const fn covariance_trace_after(&self) -> f64

Trace of the posterior covariance after this projection.

Examples found in repository

examples/probabilistic_linear_solver.rs (line 32)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // A x = b with A symmetric positive definite, stored row-major.
    let system = SpdLinearSystem::new(
        &[4.0, 1.0, 0.0, 1.0, 3.0, 1.0, 0.0, 1.0, 2.0],
        &[1.0, 2.0, 3.0],
        3,
    )?;
    // Prior belief x ~ N(0, I).
    let identity = [1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0];
    let prior = GaussianLinearBelief::new(&[0.0; 3], &identity, 3)?;

    // Residual-driven policy: each step observes the projection along the normalized residual.
    let solver = ResidualProjectionSolver::new(1.0e-10, 0.0, 3)?;
    let result = solver.solve(&system, &prior)?;
    println!("residual policy");
    println!("  mean            = {:?}", result.belief().mean());
    println!("  stopped because = {:?}", result.termination());
    for (index, step) in result.steps().iter().enumerate() {
        println!(
            "  step {index}: residual {:.3e} -> {:.3e}, covariance trace {:.3e}",
            step.residual_norm_before(),
            step.residual_norm_after(),
            step.covariance_trace_after(),
        );
    }

    // A-conjugate policy: the same information subspace in an A-orthogonal basis.
    let conjugate = AConjugateProjectionSolver::new(1.0e-10, 0.0, 3)?;
    let result = conjugate.solve(&system, &prior)?;
    println!("A-conjugate policy");
    println!("  mean            = {:?}", result.belief().mean());
    println!("  stopped because = {:?}", result.termination());

    // Covariance-greedy policy: directions are chosen without looking at b, so the
    // posterior covariance keeps its calibrated interpretation under the assumed prior.
    let candidates: Vec<Vec<f64>> = (0..3)
        .map(|axis| {
            let mut direction = vec![0.0; 3];
            direction[axis] = 1.0;
            direction
        })
        .collect();
    let greedy = CovarianceGreedyProjectionSolver::new(0.0, 2)?;
    let result = greedy.solve(&system, &prior, &candidates)?;
    println!("covariance-greedy policy (budget of two projections)");
    println!("  mean            = {:?}", result.belief().mean());
    println!("  stopped because = {:?}", result.termination());
    for (index, step) in result.steps().iter().enumerate() {
        println!(
            "  step {index}: direction {:?}, predicted trace reduction {:.3e}, posterior trace {:.3e}",
            step.direction(),
            step.predicted_trace_reduction(),
            step.posterior_trace(),
        );
    }
    Ok(())
}

pub fn search_direction(&self) -> &[f64]

Unit search direction s defining the projection s^T A x = s^T b.

Trait Implementations

impl Clone for LinearSolveStep

fn clone(&self) -> LinearSolveStep

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LinearSolveStep

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

Formats the value using the given formatter.

impl PartialEq for LinearSolveStep

fn eq(&self, other: &LinearSolveStep) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for LinearSolveStep