Struct BayesianQuadrature 

pub struct BayesianQuadrature { /* private fields */ }

Bayesian quadrature with an RBF covariance kernel and Gaussian integration measure.

The current implementation assumes a zero Gaussian-process prior mean. This is intentionally explicit rather than hidden behind a generic prior-mean abstraction.

Implementations

impl BayesianQuadrature

pub const fn new( kernel: RbfKernel, measure: GaussianMeasure, jitter: f64, ) -> Self

Construct the first supported Bayesian quadrature configuration.

Examples found in repository

examples/bayesian_quadrature.rs (line 13)

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 18)

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 kernel(&self) -> RbfKernel

Return the RBF kernel.

pub const fn measure(&self) -> GaussianMeasure

Return the Gaussian integration measure.

pub const fn jitter(&self) -> f64

Return the fixed diagonal jitter used by Gaussian conditioning.

pub fn posterior( &self, nodes: &[f64], values: &[f64], ) -> Result<ScalarNormalPosterior, BayesianQuadratureError>

Compute the posterior distribution of the integral from observed function values.

For observations y = f(X) and zero prior mean,

posterior_mean = z^T (K + jitter I)^(-1) y
posterior_var  = kappa - z^T (K + jitter I)^(-1) z

The inverse is never formed explicitly; both systems are solved from one reusable Cholesky factorization.

Errors

Returns BayesianQuadratureError for invalid observations, conditioning failures, or an invalid posterior variance.

Examples found in repository

examples/bayesian_quadrature.rs (line 20)

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 27)

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 BayesianQuadrature

fn clone(&self) -> BayesianQuadrature

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for BayesianQuadrature

impl Debug for BayesianQuadrature

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

Formats the value using the given formatter.

impl PartialEq for BayesianQuadrature

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for BayesianQuadrature