Struct Cmaes 

pub struct Cmaes { /* private fields */ }

The optimizer’s settings: the variables, the population, and when to stop. It serializes as its fields, and reads back through the same checks as Cmaes::new and its with_ methods.

Implementations

impl Cmaes

pub fn new(variables: Vec<Variable>) -> Result<Self, AnalysisError>

The optimizer over variables, with the tutorial’s default population λ = 4 + ⌊3 ln n⌋, at most 10,000 evaluations, no target, and tolerances of 10⁻¹² (in the variables, as a fraction of each one’s step; and in the output, in its own units).

Errors

AnalysisError::TooFew for no variables, AnalysisError::Count for more than MAX_VARIABLES, and AnalysisError::DuplicateVariable for two with one name.

pub fn with_population(self, lambda: usize) -> Result<Self, AnalysisError>

The same, with λ candidates a generation. A larger population searches more widely, which helps on outputs with many local minima, at more evaluations a generation.

Errors

AnalysisError::TooFew for fewer than 2, AnalysisError::Count for more than MAX_POPULATION.

pub fn with_max_evaluations(self, max: usize) -> Result<Self, AnalysisError>

The same, stopping once max evaluations have been made (it finishes the generation, so it may make up to λ − 1 more).

Errors

AnalysisError::TooFew for none.

pub fn with_target(self, target: f64) -> Result<Self, AnalysisError>

The same, stopping once a value at or below target is found.

Errors

AnalysisError::Domain for a target that isn’t finite: an infinite one would be met by a generation whose every candidate failed.

pub fn with_tolerance_x(self, tolerance: f64) -> Result<Self, AnalysisError>

The same, ending a run once the distribution’s spread, and its evolution path, are below tolerance times each variable’s step in every variable (Stop::TolX). Zero turns the test off.

Errors

AnalysisError::Domain for a tolerance that is negative or not finite.

pub fn with_tolerance_value(self, tolerance: f64) -> Result<Self, AnalysisError>

The same, ending a run once its recent values all lie within tolerance of each other, in the output’s units (Stop::TolFun). Zero turns the test off.

Errors

AnalysisError::Domain for a tolerance that is negative or not finite.

pub fn variables(&self) -> &[Variable]

The variables.

pub fn population(&self) -> usize

The population, λ.

pub fn start(&self, seed: u64) -> Result<Run, AnalysisError>

Starts a run from seed, with its first generation drawn. Evaluate the candidates, give their values to Run::tell, and repeat until it returns why it stopped.

Errors

AnalysisError::OutOfBounds if a first candidate can’t be drawn inside the bounds, and AnalysisError::Domain if one overflows (steps near f64::MAX).

pub fn minimize_constrained( &self, seed: u64, model: impl FnMut(&[f64]) -> Evaluation, ) -> Result<Optimum, AnalysisError>

Minimizes model under constraints from seed, evaluating each candidate in turn: the model gives each candidate’s Evaluation, and Run::tell_constrained ranks them. If no candidate keeps every constraint, the optimum’s violation is above zero: check it before using the point.

Errors

Cmaes::start’s and Run::tell_constrained’s.

pub fn minimize( &self, seed: u64, model: impl FnMut(&[f64]) -> f64, ) -> Result<Optimum, AnalysisError>

Minimizes model from seed, evaluating each candidate in turn.

Errors

Cmaes::start’s and Run::tell’s.

Trait Implementations

impl Clone for Cmaes

fn clone(&self) -> Cmaes

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Cmaes

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Cmaes

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Cmaes

fn eq(&self, other: &Cmaes) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Cmaes

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Cmaes