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, Fseed> ClosureObjective<S, Fc, Fe, Fr, Fefs, Feo, Fsp, Fseed>

pub fn with_exact_polish<Fpolish>(self, transition: Fpolish) -> Self

where Fpolish: FnMut(&mut S) -> bool + 'static,

pub fn with_terminal_eval_order(self, order: OuterEvalOrder) -> Self

Force final state installation through one analytic evaluator order. Search-time solver selection remains unchanged.

pub fn with_rail_face_limit<Fface>(self, limit: Fface) -> Self

where Fface: FnMut(&mut S, &Array1<f64>, &[usize]) -> Result<RailFaceLimitOutcome, EstimationError> + 'static,

Install the analytic λ→∞ rail-face limit hook (#2348 Inc 5).

pub fn with_soft_rho_guard_gradient<Fguard>(self, guard: Fguard) -> Self

where Fguard: FnMut(&mut S, &Array1<f64>) -> Array1<f64> + 'static,

Install the soft rho-guard barrier gradient hook (#2545).

The closure must PROJECT the barrier gradient the criterion already added (for REML: RemlState::soft_rho_guard_gradient, which reads the same SoftRhoGuardPriorAtom build_prior reads), never recompute it from the policy constants — the barrier is evaluated at the weight-anchored coordinate, so a raw-ρ closed form is a different function on any weighted fit.

The closure speaks ρ, not θ: it receives the leading rho_dim entries of the outer point and returns one entry per ρ-coordinate. OuterObjective::soft_rho_guard_gradient embeds that into the full θ with exact zeros in the ψ/link block, so an objective with auxiliary outer coordinates installs the SAME closure as one without — the layout arithmetic that the mixture/SAS arm would otherwise have had to hand-write (and that #2629 records as invisible when wrong) lives in one place, driven by the declared OuterThetaLayout.

A closure whose criterion is NOT built on RemlState must not install this hook at all: None is the correct answer for an objective that carries no barrier, and publishing a zero array would be indistinguishable from publishing a real one at the consumers.

pub fn with_criterion_invariance<Finv>(self, invariance: Finv) -> Self

where Finv: FnMut(&mut S, &Array1<f64>) -> Option<Array2<f64>> + 'static,

Publish the criterion’s exact invariance directions (#2676).

The closure receives the FULL outer point and returns orthonormal columns in the same coordinates, so an objective with auxiliary psi or link coordinates supplies the embedding itself (the rho block is what carries the invariance; every other coordinate is exactly zero).

An objective whose criterion is not built on a penalty map must not install this hook: None is the correct answer, and publishing an empty matrix would be indistinguishable from publishing a real one.

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 eval_fixed_point_certificate( &mut self, rho: &Array1<f64>, ) -> Result<FixedPointCertificateEval, EstimationError>

Re-evaluate the terminal fixed point and provide an explicit analytic residual for every optimized coordinate.

fn rail_face_limit( &mut self, rho: &Array1<f64>, face: &[usize], ) -> Result<RailFaceLimitOutcome, EstimationError>

Analytic λ→∞ limit data for a rail face (#2348 Inc 5).

fn soft_rho_guard_gradient( &mut self, theta: &Array1<f64>, ) -> Option<Array1<f64>>

The ρ-gradient of the soft numerical-guard BARRIER this objective adds to its criterion, if it adds one (#2545).

fn criterion_invariant_directions( &mut self, theta: &Array1<f64>, ) -> Option<Array2<f64>>

Directions of the outer coordinate along which this criterion is EXACTLY constant by construction, at theta (#2676).

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 a typed reactive continuation path forwards OuterEval::inner_beta_hint from the previous step.

fn terminal_eval_order(&self) -> Option<OuterEvalOrder>

Optional analytic evaluation order that must own the final installed objective state, independently of the solver plan that found rho.

fn reset(&mut self)

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

fn owns_terminal_coefficient_mode(&self) -> bool

Whether this objective owns a terminal coefficient mode whose bitwise identity fit assembly will later bind against the certified outer value.

fn begin_exact_polish(&mut self) -> bool

Transition an objective that actually used an approximate derivative pilot to its exact full-data measure.

fn outer_domain_upper_bound( &self, ) -> Result<Option<Array1<f64>>, EstimationError>

Optional objective-owned hard upper domain for the outer coordinates.

fn outer_domain_lower_bound( &self, ) -> Result<Option<Array1<f64>>, EstimationError>

Optional objective-owned hard lower domain for the outer coordinates.

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 reactive_domain_scalar_contract( &self, ) -> Result<Option<ContinuationScalarContract>, EstimationError>

Typed scalar continuation contract for repairing a non-finite literal outer seed through crate::continuation_path::ContinuationPath.

fn install_reactive_domain_scalar_state( &mut self, state: &ContinuationScalarState, ) -> Result<(), EstimationError>

Install one scalar waypoint before the continuation rho spine evaluates the objective. Objectives that return Some from Self::reactive_domain_scalar_contract must override this method; the default is a typed contract refusal, never a silent no-op.

fn begin_reactive_domain_waypoint(&mut self) -> Result<(), EstimationError>

Snapshot the objective’s complete accepted inner state before a reactive coupled waypoint is installed. Contract-advertising objectives must make this transactional: a failed trial is restored by Self::rollback_reactive_domain_waypoint.

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

Commit the converged full inner state produced by the value evaluation at rho. A coefficient-only handoff is insufficient: latent coordinates, routing logits, decoder frames, loss, and scalar state must advance as one accepted waypoint.

fn rollback_reactive_domain_waypoint(&mut self) -> Result<(), EstimationError>

Restore the full accepted state saved by Self::begin_reactive_domain_waypoint after an errored or non-finite trial.

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.