Struct CovarianceGreedyProjectionSolver 

pub struct CovarianceGreedyProjectionSolver { /* private fields */ }

Sequential probabilistic linear solver with data-independent covariance-greedy directions.

Implementations

impl CovarianceGreedyProjectionSolver

pub fn new( covariance_trace_tolerance: f64, max_projections: usize, ) -> Result<Self, LinearSolverError>

Construct the solver with explicit uncertainty tolerance and projection budget.

Errors

Returns LinearSolverError when the covariance-trace tolerance is invalid.

Examples found in repository

examples/probabilistic_linear_solver.rs (line 52)

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 solve( &self, system: &SpdLinearSystem, initial_belief: &GaussianLinearBelief, candidates: &[Vec<f64>], ) -> Result<CovarianceGreedySolveResult, LinearSolverError>

Run covariance-greedy sequential conditioning from an initial Gaussian belief.

Direction selection and stopping depend only on A, the candidate set, the covariance state, and the configured budget/tolerance. They do not depend on the observed right-hand side.

Errors

Returns LinearSolverError for incompatible dimensions or invalid candidates.

Examples found in repository

examples/probabilistic_linear_solver.rs (line 53)

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(())
}

Trait Implementations

impl Clone for CovarianceGreedyProjectionSolver

fn clone(&self) -> CovarianceGreedyProjectionSolver

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for CovarianceGreedyProjectionSolver

impl Debug for CovarianceGreedyProjectionSolver

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

Formats the value using the given formatter.

impl PartialEq for CovarianceGreedyProjectionSolver

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for CovarianceGreedyProjectionSolver