Struct CmaInject 

pub struct CmaInject<I, V, M, F = f64>
where
    F: Scalar,
    I: MemeticInner<V, F>,
{ /* private fields */ }

Memetic CMA-ES with Hansen (2011) injection: outer CMA-ES proposes λ candidates per generation, an inner local solver (MemeticInner) refines the best k, and the refined points are Mahalanobis-clipped and injected back into the population for the next CMA update.

The only departure from the standard CmaEs update is clipping each injected point’s normalized step in Mahalanobis distance:

  y_i ← min(1, c_y / ‖C^{-1/2} y_i‖) · y_i        (Hansen 2011 eq. 4)
  c_y = √n + 2n/(n+2)                              (Table 1 default)

with y_i = (x_i − m)/σ and C^{-1/2} = B D^{-1} Bᵀ from the post-update eigendecomposition CMA-ES already maintains. After clipping, replaced candidates re-enter the population on equal footing with regular samples; all subsequent CMA updates (m, p_σ, p_c, C, σ) run the standard equations unchanged. Lamarckian by construction; no Baldwinian mode in the paper.

Inner solver

Generic over any I: MemeticInner<V>. The associated I::State determines the inner state shape. Shipped impls cover NelderMead, LevenbergMarquardt, and Lbfgsb. For L-BFGS-B inner with consistent bound flow, use the bounded sibling BoundedCmaInject over BoundedCmaEs.

Eval aggregation

Same-problem composition: the inner shares the outer’s Problem wrapper, so every inner cost/gradient/Jacobian/ Hessian call bumps the same EvalCounts as the outer’s own evaluations. PopulationProgress preserves all six categories without folding derivative work into cost_evals. Use counts().total_work() for an explicit aggregate. Exact checkpoints retain the outer distribution, inner solver, progress, and counts together. With serde, these serialize when their constituent types do; application hooks cannot be serialized.

Backends

Same coverage as CmaEs: Vec<F> for F = f32 or f64 (via DenseMatrix), nalgebra, ndarray, and faer. The matrix capabilities are those of CmaEs, and the shipped MemeticInner inners are backend-generic.

Examples

See CmaEs for the base population-based Executor pattern; CmaInject adds a local-search inner via Hansen-2011 injection.

Implementations

impl<I, V, M, F: Scalar> CmaInject<I, V, M, F>

where I: MemeticInner<V, F>,

pub fn with_absolute_cost_change_tolerance<Q: Scalar>( self, value: impl Into<Option<Q>>, ) -> ConfiguredSolver<CmaInject<I, V, M, F>, (), (), CostChecks<Q>, ()>

Stop when the absolute change between consecutive observed costs is at most the tolerance.

Disabled by default. None disables; zero requests an exact-zero threshold. Values must be finite and nonnegative. Distinct enabled tests combine with OR. Evaluated at initialized iteration boundaries; repeated calls replace this setting. Change tests need two observed iterates. Trust-region solvers skip rejected iterations and compare accepted iterates.

pub fn with_relative_cost_change_tolerance<Q: Scalar>( self, value: impl Into<Option<Q>>, ) -> ConfiguredSolver<CmaInject<I, V, M, F>, (), (), CostChecks<Q>, ()>

Stop when the observed cost change is at most the tolerance times the previous absolute cost.

Disabled by default. None disables; zero requests an exact-zero threshold. Values must be finite and nonnegative. Distinct enabled tests combine with OR. Evaluated at initialized iteration boundaries; repeated calls replace this setting. Change tests need two observed iterates. Trust-region solvers skip rejected iterations and compare accepted iterates.

impl<I, V, M, F: Scalar> CmaInject<I, V, M, F>

where I: MemeticInner<V, F>,

pub fn with_absolute_step_tolerance<Param, Q: Scalar>( self, value: impl Into<Option<Q>>, ) -> ConfiguredSolver<CmaInject<I, V, M, F>, (), StepChecks<Param, Q>, (), ()>

Stop when the Euclidean distance between consecutive observed iterates is at most the tolerance.

Disabled by default. None disables; zero requests an exact-zero threshold. Values must be finite and nonnegative. Distinct enabled tests combine with OR. Evaluated at initialized iteration boundaries; repeated calls replace this setting. Change tests need two observed iterates. Trust-region solvers skip rejected iterations and compare accepted iterates.

pub fn with_relative_step_tolerance<Param, Q: Scalar>( self, value: impl Into<Option<Q>>, ) -> ConfiguredSolver<CmaInject<I, V, M, F>, (), StepChecks<Param, Q>, (), ()>

Stop when the Euclidean iterate change is at most the tolerance times the current iterate norm.

Disabled by default. None disables; zero requests an exact-zero threshold. Values must be finite and nonnegative. Distinct enabled tests combine with OR. Evaluated at initialized iteration boundaries; repeated calls replace this setting. Change tests need two observed iterates. Trust-region solvers skip rejected iterations and compare accepted iterates.

impl<I, V, M, F> CmaInject<I, V, M, F>

where F: Scalar, I: MemeticInner<V, F>, I::State: CountsMirror,

pub fn with_inner_solver(cma: CmaEs<V, M, F>, inner: I) -> Self

Wrap a configured CmaEs with inner as the local refinement step. Defaults: k = 1 refinement per generation, inner max_iter = 50, c_y = Hansen-2011 Table 1 default.

pub fn cma(&self) -> &CmaEs<V, M, F>

Inspect the outer distribution model without transferring its ownership.

pub fn with_k(self, k: usize) -> Self

Number of best-ranked candidates to refine and inject each generation. Default 1.

Panics

Panics if k == 0. k > λ is silently clamped at runtime.

pub fn with_c_y(self, c_y: F) -> Self

Override the Hansen-2011 clipping threshold c_y (default √n + 2n/(n+2)).

Panics

Panics if c_y <= 0.

pub fn with_inner_diagnostics(self, enabled: bool) -> Self

Enable owned inner stopping reports and count snapshots. Disabled by default. Fresh initialization clears records; exact continuation retains them.

pub fn inner_diagnostics(&self) -> &[Record<F>]

Inner reports consumed during this outer run, in dispatch order. A callback error retains counts and has no returned report.

pub fn with_inner_max_iter(self, n: u64) -> Self

Inner solver iteration budget per outer generation (default 50).

pub fn with_absolute_distribution_size_tolerance( self, value: impl Into<Option<F>>, ) -> Self

Configure the outer CMA distribution-size tolerance; None disables it.

pub fn inner_stop_when_factory<Mk, CheckFn>(self, make: Mk) -> Self

where Mk: FnMut() -> CheckFn + 'static, CheckFn: FnMut(&I::State) -> Option<ApplicationStop> + 'static,

Add a factory creating fresh application-stop history for each inner run.

Trait Implementations

impl<'de, I, V, M, F> Deserialize<'de> for CmaInject<I, V, M, F>

where F: Scalar + Deserialize<'de>, I: MemeticInner<V, F> + Deserialize<'de>, V: Deserialize<'de>, M: Deserialize<'de>,

Available on crate feature serde only.

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<I, V, M, F> Serialize for CmaInject<I, V, M, F>

where F: Scalar + Serialize, I: MemeticInner<V, F> + Serialize, V: Serialize, M: Serialize,

Available on crate feature serde only.

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<P, I, V, M, F> Solver<P, PopulationProgress<V, F>> for CmaInject<I, V, M, F>

where F: Scalar, P: CostFunction<Param = V, Output = F> + ProblemConstraints<Constraints = NoConstraints>, I: MemeticInner<V, F> + Solver<P, <I as InitialState<V>>::State, Error = P::Error>, I::State: State<Param = V, Float = F> + CountsMirror, V: VectorLen + Clone + ScaledAdd<F> + ScaleInPlace<F> + ComponentMulAssign + NormSquared<F> + SampleStandardNormal + Index<usize, Output = F> + IndexMut<usize, Output = F>, M: MatrixIdentity + MatrixFromDiagonal<V> + MatVec<V> + MatTransposeVec<V> + ScaleInPlace<F> + RankOneUpdate<V, F> + SymmetricEigen<V> + Clone, CmaEs<V, M, F>: Solver<P, PopulationProgress<V, F>, Error = P::Error>,

type Error = <P as CostFunction>::Error

Hard-abort error type, mirroring the underlying problem’s type Error. See the trait docs.

fn init( &mut self, problem: &mut Problem<P>, state: PopulationProgress<V, F>, ) -> Result<PopulationProgress<V, F>, Self::Error>

One-time setup before the iteration loop.

fn next_iter( &mut self, problem: &mut Problem<P>, state: PopulationProgress<V, F>, ) -> Result<SolverStep<PopulationProgress<V, F>>, Self::Error>

Advance one iteration.

fn terminate(&self, state: &PopulationProgress<V, F>) -> Option<Termination<F>>

Optional pre-iteration solver-specific termination test.

fn reset_convergence(&mut self)

Reset per-run convergence history without changing algorithm state.

fn should_check_iterate_change(&self) -> bool

Whether the current boundary can enter cost- and step-change checks.

fn check_convergence( &mut self, _problem: &Problem<P>, state: &S, ) -> Option<Termination<S::Float>>

Check convergence at an initialized iteration boundary.