Struct ClosureObjective 

pub struct ClosureObjective<S, Fc, Fe, Fr = fn(&mut S), Fefs = fn(&mut S, &Array1<f64>) -> Result<EfsEval, EstimationError>, Feo = fn(&mut S, &Array1<f64>, OuterEvalOrder) -> Result<OuterEval, EstimationError>, Fsp = fn(&mut S, &Array1<f64>) -> Result<f64, EstimationError>, Fseed = fn(&mut S, &Array1<f64>) -> Result<SeedOutcome, EstimationError>> {
    pub state: S,
    /* private fields */
}

Closure-based adapter for OuterObjective.

This allows any call site to construct an OuterObjective from closures without needing to define a wrapper struct or modify the state type. Each call site wraps its existing methods into closures and passes them here.

Fields

state: S

Implementations

impl<S, Fc, Fe, Fr, Fefs, Feo, Fsp> ClosureObjective<S, Fc, Fe, Fr, Fefs, Feo, Fsp>

where Fc: FnMut(&mut S, &Array1<f64>) -> Result<f64, EstimationError>, Fe: FnMut(&mut S, &Array1<f64>) -> Result<OuterEval, EstimationError>, Fr: FnMut(&mut S), Fefs: FnMut(&mut S, &Array1<f64>) -> Result<EfsEval, EstimationError>, Feo: FnMut(&mut S, &Array1<f64>, OuterEvalOrder) -> Result<OuterEval, EstimationError>, Fsp: FnMut(&mut S, &Array1<f64>) -> Result<f64, EstimationError>,

pub fn with_seed_inner_state<Fseed>( self, seed_fn: Fseed, ) -> ClosureObjective<S, Fc, Fe, Fr, Fefs, Feo, Fsp, Fseed>

where Fseed: FnMut(&mut S, &Array1<f64>) -> Result<SeedOutcome, EstimationError>,

Trait Implementations

impl<S, Fc, Fe, Fr, Fefs, Feo, Fsp, Fseed> OuterObjective for ClosureObjective<S, Fc, Fe, Fr, Fefs, Feo, Fsp, Fseed>

where Fc: FnMut(&mut S, &Array1<f64>) -> Result<f64, EstimationError>, Fe: FnMut(&mut S, &Array1<f64>) -> Result<OuterEval, EstimationError>, Fr: FnMut(&mut S), Fefs: FnMut(&mut S, &Array1<f64>) -> Result<EfsEval, EstimationError>, Feo: FnMut(&mut S, &Array1<f64>, OuterEvalOrder) -> Result<OuterEval, EstimationError>, Fsp: FnMut(&mut S, &Array1<f64>) -> Result<f64, EstimationError>, Fseed: FnMut(&mut S, &Array1<f64>) -> Result<SeedOutcome, EstimationError>,

fn capability(&self) -> OuterCapability

Declare what this objective can compute analytically.

fn eval_cost(&mut self, rho: &Array1<f64>) -> Result<f64, EstimationError>

Evaluate cost only for cost-based optimization paths.

fn eval_screening_proxy( &mut self, rho: &Array1<f64>, ) -> Result<f64, EstimationError>

Evaluate the seed-screening ranking proxy at this rho.

fn eval(&mut self, rho: &Array1<f64>) -> Result<OuterEval, EstimationError>

Evaluate cost + gradient + (if capable) Hessian.

fn eval_with_order( &mut self, rho: &Array1<f64>, order: OuterEvalOrder, ) -> Result<OuterEval, EstimationError>

Evaluate the outer objective at the order requested by the active plan.

fn eval_efs(&mut self, rho: &Array1<f64>) -> Result<EfsEval, EstimationError>

Evaluate cost + EFS step vector. Only needed when the plan selects Solver::Efs. The default returns an error indicating EFS is not supported by this objective.

fn seed_inner_state( &mut self, beta: &Array1<f64>, ) -> Result<SeedOutcome, EstimationError>

Seed the inner-solver iterate before the first eval, e.g. when the outer-iterate cache restored a (ρ, β) pair from a prior run, or when the continuation walk forwards OuterEval::inner_beta_hint from the previous step.

fn allow_continuation_prewarm(&self) -> bool

Whether the objective can benefit from continuation pre-warm before the first solver eval at a candidate seed.

fn reset(&mut self)

Restore to a clean baseline for the next multi-start candidate.

fn outer_device_admission(&self) -> Option<RemlOuterAdmission>

Optional opt-in to the device-resident outer REML BFGS-over-ρ driver (crate::gpu::reml_outer::run_reml_outer_on_device). Returns Some(adm) when the objective is a REML evaluator whose (spec, n, p, num_rho) admission predicate accepts the device path, and None otherwise.

fn requires_continuation_path_entry(&self) -> bool

Whether every joint fit of this objective must ENTER through the crate::continuation_path::ContinuationPath (heavy-smoothing entry) rather than being solved cold at the seed ρ*.

fn curvature_homotopy_entry( &mut self, rho: &Array1<f64>, ) -> Option<Result<bool, EstimationError>>

Run the objective’s certified curvature-homotopy entry leg, if it has one, leaving the inner state warm at the real (η = 1) objective.

fn accept_seed_without_outer_iterations( &mut self, rho: &Array1<f64>, ) -> Result<Option<f64>, EstimationError>

Let an objective declare that a seed is already a terminal outer result. Used for objectives with a certified high-quality construction seed where the generic rho optimizer can only degrade the fitted state.

fn finalize_outer_result( &mut self, rho: &Array1<f64>, plan: &OuterPlan, ) -> Result<(), EstimationError>

Re-install the selected outer result into the mutable objective before callers consume objective-owned fitted state. Optimizers may evaluate rejected trial points after the best point was found; without this final synchronization, stateful objectives can report the last trial fit rather than the returned OuterResult::rho.