Struct Ego 

pub struct Ego { /* private fields */ }

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

Branin’s function from seed 1, in 50 evaluations, the initial design’s 20 included:

use hpr_analysis::optimize::Variable;
use hpr_analysis::optimize::benchmark::global::{BRANIN_MINIMUM, branin};
use hpr_analysis::optimize::ego::Ego;

let variables = vec![
    Variable::new("x0", 2.5, 3.0)?.within(-5.0, 10.0)?,
    Variable::new("x1", 7.5, 3.0)?.within(0.0, 15.0)?,
];
let optimum = Ego::new(variables)?.with_max_evaluations(50)?.minimize(1, branin)?;
assert_eq!(optimum.evaluations, 50);
assert!(optimum.value < 1.01 * BRANIN_MINIMUM);

Implementations

impl Ego

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

The optimizer for variables, each with two finite bounds and continuous: EGO searches the box they make, so a variable’s start and step aren’t used. The initial design has 10 points per variable, and a run stops after 20 evaluations per variable.

Errors

AnalysisError::TooFew for no variables, AnalysisError::Count for more than MAX_EGO_VARIABLES, and AnalysisError::Domain for a variable with an infinite bound or an integer one.

pub fn with_initial(self, points: usize) -> Result<Self, AnalysisError>

The same, with an initial design of points points.

Errors

AnalysisError::TooFew for fewer than 2, as the likelihood needs a spread of values, and AnalysisError::Count for more than MAX_POINTS.

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

The same, stopping once max evaluations have been made, the initial design’s included. A budget smaller than the initial design shrinks the design to the budget, and the run stops after it.

Errors

AnalysisError::TooFew for none, and AnalysisError::Count for more than MAX_POINTS.

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.

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

The same, stopping once the largest expected improvement found is below tolerance, an amount in the model’s units, or with a Transform in the transformed values’ units (with a log transform, about a relative change: Jones et al. stop at 0.01 on the log scale, p. 474). Jones et al. stop at 1% of the best value’s size, which may end a run well before it is within 1% of the minimum (on Hartmann 3, 8 runs of 20 ended more than 1% away, the worst 4.7%); for a model whose least value is near zero (a miss), state an amount. Zero, the default, turns the test off.

Errors

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

pub fn with_transform(self, transform: Transform) -> Self

The same, fitting the surrogate to transform of the values (none by default). The expected improvement is then on the transformed scale, as is the improvement tolerance; the best point, the target and the result are on the model’s.

pub fn transform(&self) -> Transform

The transformation the surrogate is fitted to.

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

The variables.

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

Minimizes model from seed, evaluating one point at a time.

A value of +∞ is a failed evaluation: the surrogate is fitted to the largest finite value so far in its place.

Errors

AnalysisError::Output for a NaN or −∞, with the evaluation’s index counted from 0, AnalysisError::Domain for a finite value outside the Transform’s domain, and cmaes’s errors from the fits and searches.

Trait Implementations

impl Clone for Ego

fn clone(&self) -> Ego

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Ego

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Ego

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Ego

fn eq(&self, other: &Ego) -> 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 Ego

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 Ego