Struct ActiveBayesianQuadrature 

pub struct ActiveBayesianQuadrature { /* private fields */ }

Sequential active Bayesian quadrature over a finite candidate set.

Implementations

impl ActiveBayesianQuadrature

pub const fn new(quadrature: BayesianQuadrature) -> Self

Construct active Bayesian quadrature from one consistent kernel/measure setup.

Examples found in repository

examples/active_quadrature.rs (line 19)

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 quadrature(&self) -> BayesianQuadrature

Return the underlying Bayesian-quadrature configuration.

pub fn run<F>( &self, initial_nodes: &[f64], initial_values: &[f64], candidates: &[f64], max_new_evaluations: usize, variance_tolerance: f64, function: F, ) -> Result<ActiveDesignResult, ActiveDesignError>

where F: FnMut(f64) -> f64,

Run sequential active selection and function evaluation.

The loop stops when the posterior integral variance is no greater than variance_tolerance, when max_new_evaluations points have been added, or when the finite candidate set is exhausted.

Errors

Returns ActiveDesignError for invalid stopping tolerance, non-finite candidates or function evaluations, candidate-selection failures, or posterior-construction failures.

Examples found in repository

examples/active_quadrature.rs (lines 30-37)

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 ActiveBayesianQuadrature

fn clone(&self) -> ActiveBayesianQuadrature

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ActiveBayesianQuadrature

impl Debug for ActiveBayesianQuadrature

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

Formats the value using the given formatter.

impl PartialEq for ActiveBayesianQuadrature

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ActiveBayesianQuadrature