Struct EstimationProblem 

pub struct EstimationProblem<E: Equation, F: Framework> { /* private fields */ }

Implementations

impl<E: Equation + Send + 'static> EstimationProblem<E, NonParametric>

pub fn fit_controller( self, algorithm: impl Into<NonParametricAlgorithm>, ) -> Result<FitController<E>>

Start a fit you drive yourself, one step at a time.

Takes any non-parametric config (NpagConfig, NpodConfig, NpmapConfig) or a NonParametricAlgorithm.

use pmcore::prelude::*;
let mut controller = problem.fit_controller(NpagConfig::new())?;
while controller.step()?.is_continue() {
    println!("cycle {} | -2LL {:.4}", controller.cycle(), controller.n2ll());
}
let result = controller.into_result()?;

pub fn fit_with_observer<O: FitObserver<E>>( self, algorithm: impl Into<NonParametricAlgorithm>, observer: O, ) -> Result<NonParametricResult<E>>

Run a fit to completion, calling observer after every cycle.

The observer sees every cycle, the last one included, and can return CycleFlow::Stop to bail out early. Returns the same result as fit_with.

use pmcore::prelude::*;
let result = problem.fit_with_observer(NpagConfig::new(), |c: &FitController<_>| {
    println!("cycle {} | -2LL {:.4}", c.cycle(), c.n2ll());
    CycleFlow::Continue
})?;

impl<E: Equation, F: Framework> EstimationProblem<E, F>

pub fn fit_with<A>(self, algorithm: A) -> Result<A::Output>

where A: Algorithm<E, F>,

Consumes the problem and an algorithm configuration, runs the fit to completion, and returns the result.

impl<E: Equation + EquationMetadataSource> EstimationProblem<E, NonParametric>

pub fn nonparametric( equation: E, data: Data, prior: Theta, error_models: AssayErrorModels, ) -> Result<Self>

Creates a non-parametric estimation problem.

The prior is a Theta holding the prior distribution (the initial set of support points) together with the ParameterSpace it was built from. The parameter space is taken directly from the prior, so there is no separate parameter-declaration step.

impl<E: Equation> EstimationProblem<E, Parametric>

pub fn parametric(equation: E, data: Data) -> ParametricBuilder<E>

Begins building a parametric estimation problem.

pub fn parameters(&self) -> &ParameterSpace<UnboundedParameter>

Returns the parameter space defined for this problem.

impl<E: Equation> EstimationProblem<E, NonParametric>

pub fn parameters(&self) -> &ParameterSpace<BoundedParameter>

Returns the parameter space carried by the prior Theta.

Trait Implementations

impl<E: Clone + Equation, F: Clone + Framework> Clone for EstimationProblem<E, F>

where F::ErrorModels: Clone, F::Prior: Clone,

fn clone(&self) -> EstimationProblem<E, F>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<E: Debug + Equation, F: Debug + Framework> Debug for EstimationProblem<E, F>

where F::ErrorModels: Debug, F::Prior: Debug,

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

Formats the value using the given formatter.