Enum Transform 

#[non_exhaustive]
pub enum Transform {
    None,
    Log,
    NegativeLog,
}

A transformation of the model’s values that the surrogate is fitted to (Jones et al. 1998, §3, p. 468 and §4.2, pp. 473–474; see the module’s page).

use hpr_analysis::optimize::ego::Transform;

// −ln(−y) pulls the values near Hartmann 6's minimum, −3.32237, together and pushes the
// flat region near zero far out.
let z = |y| Transform::NegativeLog.apply(y).unwrap();
assert!((z(-3.32237) - -1.2007).abs() < 1e-4);
assert!((z(-0.01) - 4.6052).abs() < 1e-4);
// Outside its domain: none.
assert_eq!(Transform::NegativeLog.apply(0.5), None);

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

None

The values as they are.

Log

z = ln y, for a model whose values are all positive: Jones et al.’s choice for Goldstein–Price’s function.

NegativeLog

z = −ln(−y), for a model whose values are all negative: Jones et al.’s choice for Hartmann’s six-variable function. It squeezes the values near the least together and stretches those near zero.

Implementations

impl Transform

pub fn apply(self, y: f64) -> Option<f64>

z(y), or None for a value outside the transformation’s domain. +∞, a failed evaluation, stays +∞.

Trait Implementations

impl Clone for Transform

fn clone(&self) -> Transform

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Transform

impl Debug for Transform

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

Formats the value using the given formatter.

impl Default for Transform

fn default() -> Transform

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Transform

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Transform

impl PartialEq for Transform

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

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 Transform