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. CmaEsState’s CountsMirror folds every kind of work into the outer’s single cost_evals via delta.total_work(); CMA-ES outer state has no gradient_evals field, so a derivative-based inner (LM, L-BFGS-B) has its gradient work honestly collapse into cost_evals with no per-trait cross-type fold. See CONTRIBUTING.md “Solver composition” rule 1.

Backends

Same coverage as CmaEs: the default Vec<f64> (via DenseMatrix), nalgebra, ndarray, and faer. The matrix bound is SymmetricEigen, which every backend satisfies, 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> 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 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_max_iter(self, n: u64) -> Self

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

pub fn inner_terminate_on<C>(self, criterion: C) -> Self

where C: TerminationCriterion<I::State> + 'static,

Register a termination criterion on the inner loop. Criteria are reused across every outer iteration’s inner run, but each is reset at the start of every run, so stateful criteria, including MaxTime, are safe. See CONTRIBUTING.md “Solver composition” rule 2.

Trait Implementations

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

where F: Scalar, P: CostFunction<Param = V, Output = F>, 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, CmaEsState<V, M, 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: CmaEsState<V, M, F>, ) -> Result<CmaEsState<V, M, F>, Self::Error>

One-time setup before the iteration loop.

fn next_iter( &mut self, problem: &mut Problem<P>, state: CmaEsState<V, M, F>, ) -> Result<(CmaEsState<V, M, F>, Option<TerminationReason>), Self::Error>

Advance one iteration.

fn terminate(&self, _state: &S) -> Option<TerminationReason>

Optional pre-iteration solver-specific termination test.