Struct ScalarNormalPosterior 

pub struct ScalarNormalPosterior { /* private fields */ }

Gaussian posterior for a scalar computational quantity.

This type is intentionally generic: Bayesian quadrature can use it for an integral, while later probabilistic numerical methods can use the same representation for other scalar quantities.

Implementations

impl ScalarNormalPosterior

pub fn new(mean: f64, variance: f64) -> Result<Self, PosteriorError>

Construct a validated scalar Gaussian posterior.

Errors

Returns PosteriorError when the mean or variance is non-finite, or when the variance is negative.

pub const fn mean(self) -> f64

Posterior mean of the computational quantity.

Examples found in repository

examples/bayesian_quadrature.rs (line 21)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Prior over the integrand: zero-mean Gaussian process with an RBF kernel.
    let kernel = RbfKernel::new(1.0, 1.0)?; // signal variance, length scale
    // Integration measure p(x) = N(0, 1).
    let measure = GaussianMeasure::new(0.0, 1.0)?;
    // Jitter is an explicit, fixed diagonal regularizer. It is never escalated silently.
    let quadrature = BayesianQuadrature::new(kernel, measure, 1.0e-10);

    // Observe f(x) = cos(x) at seven nodes. Exactly, E[cos X] = exp(-1/2) for X ~ N(0, 1).
    let nodes = [-3.0, -2.0, -1.0, 0.0, 1.0, 2.0, 3.0];
    let values: Vec<f64> = nodes.iter().copied().map(f64::cos).collect();
    let exact = (-0.5_f64).exp();

    let posterior = quadrature.posterior(&nodes, &values)?;
    let standardized_error = (posterior.mean() - exact).abs() / posterior.standard_deviation();

    println!("E[I | y]           = {:.6}", posterior.mean());
    println!(
        "sd[I | y]          = {:.3e}",
        posterior.standard_deviation()
    );
    println!("exact integral     = {exact:.6}");
    println!("standardized error = {standardized_error:.3}");

    // The posterior is honest about its own error here: the exact value lies well
    // inside the reported uncertainty.
    assert!((posterior.mean() - exact).abs() < 3.0 * posterior.standard_deviation());
    Ok(())
}

examples/active_quadrature.rs (line 53)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let kernel = RbfKernel::new(1.0, 1.0)?;
    let measure = GaussianMeasure::new(0.0, 1.0)?;
    let quadrature = BayesianQuadrature::new(kernel, measure, 1.0e-10);
    let active = ActiveBayesianQuadrature::new(quadrature);

    // Start from three evaluations; allow up to six more from a fixed candidate grid,
    // stopping early once the posterior variance of the integral drops below 1e-6.
    let initial_nodes = [-1.0, 0.0, 1.0];
    let initial_values: Vec<f64> = initial_nodes.iter().copied().map(integrand).collect();
    let candidates: Vec<f64> = (0..=23).map(|i| -2.875 + 0.25 * f64::from(i)).collect();

    let initial = quadrature.posterior(&initial_nodes, &initial_values)?;
    println!("initial posterior variance = {:.3e}", initial.variance());

    let result = active.run(
        &initial_nodes,
        &initial_values,
        &candidates,
        6,
        1.0e-6,
        integrand,
    )?;

    for step in result.steps() {
        println!(
            "x = {:+.3}  predicted reduction = {:.3e}  posterior variance = {:.3e}",
            step.point(),
            step.predicted_variance_reduction(),
            step.posterior_variance(),
        );
    }

    let exact = (1.0_f64 / 3.0).sqrt() * (-0.25_f64 / 3.0).exp();
    let posterior = result.posterior();
    println!("stopped because: {:?}", result.termination());
    println!(
        "E[I | y] = {:.6} ± {:.3e}   (exact {exact:.6})",
        posterior.mean(),
        posterior.standard_deviation(),
    );
    Ok(())
}

pub const fn variance(self) -> f64

Posterior variance of the computational quantity.

Examples found in repository

examples/active_quadrature.rs (line 28)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let kernel = RbfKernel::new(1.0, 1.0)?;
    let measure = GaussianMeasure::new(0.0, 1.0)?;
    let quadrature = BayesianQuadrature::new(kernel, measure, 1.0e-10);
    let active = ActiveBayesianQuadrature::new(quadrature);

    // Start from three evaluations; allow up to six more from a fixed candidate grid,
    // stopping early once the posterior variance of the integral drops below 1e-6.
    let initial_nodes = [-1.0, 0.0, 1.0];
    let initial_values: Vec<f64> = initial_nodes.iter().copied().map(integrand).collect();
    let candidates: Vec<f64> = (0..=23).map(|i| -2.875 + 0.25 * f64::from(i)).collect();

    let initial = quadrature.posterior(&initial_nodes, &initial_values)?;
    println!("initial posterior variance = {:.3e}", initial.variance());

    let result = active.run(
        &initial_nodes,
        &initial_values,
        &candidates,
        6,
        1.0e-6,
        integrand,
    )?;

    for step in result.steps() {
        println!(
            "x = {:+.3}  predicted reduction = {:.3e}  posterior variance = {:.3e}",
            step.point(),
            step.predicted_variance_reduction(),
            step.posterior_variance(),
        );
    }

    let exact = (1.0_f64 / 3.0).sqrt() * (-0.25_f64 / 3.0).exp();
    let posterior = result.posterior();
    println!("stopped because: {:?}", result.termination());
    println!(
        "E[I | y] = {:.6} ± {:.3e}   (exact {exact:.6})",
        posterior.mean(),
        posterior.standard_deviation(),
    );
    Ok(())
}

pub fn standard_deviation(self) -> f64

Posterior standard deviation of the computational quantity.

Examples found in repository

examples/bayesian_quadrature.rs (line 21)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Prior over the integrand: zero-mean Gaussian process with an RBF kernel.
    let kernel = RbfKernel::new(1.0, 1.0)?; // signal variance, length scale
    // Integration measure p(x) = N(0, 1).
    let measure = GaussianMeasure::new(0.0, 1.0)?;
    // Jitter is an explicit, fixed diagonal regularizer. It is never escalated silently.
    let quadrature = BayesianQuadrature::new(kernel, measure, 1.0e-10);

    // Observe f(x) = cos(x) at seven nodes. Exactly, E[cos X] = exp(-1/2) for X ~ N(0, 1).
    let nodes = [-3.0, -2.0, -1.0, 0.0, 1.0, 2.0, 3.0];
    let values: Vec<f64> = nodes.iter().copied().map(f64::cos).collect();
    let exact = (-0.5_f64).exp();

    let posterior = quadrature.posterior(&nodes, &values)?;
    let standardized_error = (posterior.mean() - exact).abs() / posterior.standard_deviation();

    println!("E[I | y]           = {:.6}", posterior.mean());
    println!(
        "sd[I | y]          = {:.3e}",
        posterior.standard_deviation()
    );
    println!("exact integral     = {exact:.6}");
    println!("standardized error = {standardized_error:.3}");

    // The posterior is honest about its own error here: the exact value lies well
    // inside the reported uncertainty.
    assert!((posterior.mean() - exact).abs() < 3.0 * posterior.standard_deviation());
    Ok(())
}

examples/active_quadrature.rs (line 54)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let kernel = RbfKernel::new(1.0, 1.0)?;
    let measure = GaussianMeasure::new(0.0, 1.0)?;
    let quadrature = BayesianQuadrature::new(kernel, measure, 1.0e-10);
    let active = ActiveBayesianQuadrature::new(quadrature);

    // Start from three evaluations; allow up to six more from a fixed candidate grid,
    // stopping early once the posterior variance of the integral drops below 1e-6.
    let initial_nodes = [-1.0, 0.0, 1.0];
    let initial_values: Vec<f64> = initial_nodes.iter().copied().map(integrand).collect();
    let candidates: Vec<f64> = (0..=23).map(|i| -2.875 + 0.25 * f64::from(i)).collect();

    let initial = quadrature.posterior(&initial_nodes, &initial_values)?;
    println!("initial posterior variance = {:.3e}", initial.variance());

    let result = active.run(
        &initial_nodes,
        &initial_values,
        &candidates,
        6,
        1.0e-6,
        integrand,
    )?;

    for step in result.steps() {
        println!(
            "x = {:+.3}  predicted reduction = {:.3e}  posterior variance = {:.3e}",
            step.point(),
            step.predicted_variance_reduction(),
            step.posterior_variance(),
        );
    }

    let exact = (1.0_f64 / 3.0).sqrt() * (-0.25_f64 / 3.0).exp();
    let posterior = result.posterior();
    println!("stopped because: {:?}", result.termination());
    println!(
        "E[I | y] = {:.6} ± {:.3e}   (exact {exact:.6})",
        posterior.mean(),
        posterior.standard_deviation(),
    );
    Ok(())
}

Trait Implementations

impl Clone for ScalarNormalPosterior

fn clone(&self) -> ScalarNormalPosterior

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ScalarNormalPosterior

impl Debug for ScalarNormalPosterior

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

Formats the value using the given formatter.

impl PartialEq for ScalarNormalPosterior

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ScalarNormalPosterior