Struct metaheuristics_nature::Solver

pub struct Solver<F: ObjFunc> { /* private fields */ }

A public API for using optimization methods.

Users can simply obtain their solution and see the result.

• The method is a type that implemented Algorithm.
• The objective function is a type that implement ObjFunc.
• A basic algorithm data is hold by Ctx.

The builder of this type can infer the algorithm by AlgCfg::Algorithm.

Please use Solver::build() method to start a task.

The settings are defined in the SolverBuilder type.

Implementations

impl<F: ObjFunc> Solver<F>

pub fn func(&self) -> &F

Get the reference of the objective function.

It’s useful when you need to get the preprocessed data from the initialization process, which is stored in the objective function.

pub fn as_best_set(&self) -> &<F::Ys as Fitness>::Best<F::Ys>

Get the reference of the best set.

Use Solver::as_best() to get the best parameters and the fitness value directly.

pub fn as_best(&self) -> (&[f64], &F::Ys)

Get the reference of the best parameters and the fitness value.

pub fn as_best_xs(&self) -> &[f64]

Get the reference of the best fitness value.

pub fn as_best_fit(&self) -> &F::Ys

Get the reference of the best fitness value.

pub fn get_best_eval(&self) -> <F::Ys as Fitness>::Eval

Get the final best fitness value.

pub fn into_result<P, Fit: Fitness>(self) -> P

where F: ObjFunc<Ys = WithProduct<Fit, P>>, P: MaybeParallel + Clone + 'static,

Get the final best element.

pub fn into_err_result<P, Fit: Fitness>(self) -> (Fit::Eval, P)

where F: ObjFunc<Ys = WithProduct<Fit, P>>, P: MaybeParallel + Clone + 'static,

Get the fitness value and the final result.

pub fn into_err_result_func<P, Fit: Fitness>(self) -> (Fit::Eval, P, F)

where F: ObjFunc<Ys = WithProduct<Fit, P>>, P: MaybeParallel + Clone + 'static,

Get the fitness value, final result and the objective function.

pub fn seed(&self) -> Seed

Seed of the random number generator.

pub fn pool(&self) -> &[Vec<f64>]

Get the pool from the last status.

impl<F: ObjFunc> Solver<F>

pub fn build<A: AlgCfg>( cfg: A, func: F ) -> SolverBuilder<'static, A::Algorithm<F>, F>

Start to build a solver. Take a setting and setup the configurations.

The signature is something like Solver::build(Rga::default(), MyFunc::new()). Please check the SolverBuilder type, it will help you choose your configuration.

If all things are well-setup, call SolverBuilder::solve().

The default value of each option can be found in their document.

Use Solver::build_boxed() for dynamic dispatching.

pub fn build_boxed<A: AlgCfg>(cfg: A, func: F) -> SolverBox<'static, F>

Start to build a solver with a boxed algorithm, the dynamic dispatching.

This method allows you to choose the algorithm at runtime and mix them with the same type.

use metaheuristics_nature as mh;

let s = if use_ga {
    mh::Solver::build_boxed(mh::Rga::default(), MyFunc::new())
} else {
    mh::Solver::build_boxed(mh::De::default(), MyFunc::new())
};

Use Solver::build() for optimized memory allocation and access.