Struct ConstantMutation 

pub struct ConstantMutation { /* private fields */ }

Constant mutation (Poli, Langdon and McPhee 2008, sec. 5.2.2, after Schoenauer et al. 1996): one constant, chosen uniformly, is perturbed by normal noise of standard deviation sigma times the width of its type’s range, mirrored at the ends of the range. Each call changes one constant, as each change is a separate mutation there.

It applies to constants of Constants::uniform and Constants::integers with more than one value (integers are rounded), and of Constants::normal, whose noise is sigma times the deviation, without ends to mirror at; the constants of a Constants::choice have no range, and PointMutation draws them anew. The constant always changes: the noise is drawn again while it leaves the value as it is (for integers, while it rounds to the same value), up to 64 times, then the value is drawn uniformly from the others. A tree without such a constant is left unchanged. The cheap tuning of constants: it keeps the tree’s shape and moves a constant a little.

use genoxide::gp::{Constants, ConstantMutation, Gp, PrimitiveSet};
use genoxide::prelude::*;

#[derive(Clone, Copy, Debug)]
enum Op {
    Mul,
    X,
}

let mut set = PrimitiveSet::builder();
let real = set.new_type("real");
set.function("mul", Op::Mul, [real, real], real)
    .terminal("x", Op::X, real)
    .constants(real, Constants::uniform(-1.0..=1.0)?);
let gp = Gp::builder(set.build(real)?).build()?;
let mut tree = gp.primitives().parse("mul(x, 0.5)")?;
ConstantMutation::gaussian(0.05)?.mutate(&gp, &mut tree, &mut StreamRng::seed_from_u64(1));
assert_ne!(tree, gp.primitives().parse("mul(x, 0.5)")?);
assert!(gp.validate(&tree).is_ok()); // still within [-1, 1]

Implementations

impl ConstantMutation

pub fn gaussian(sigma: f64) -> Result<Self>

Normal noise of standard deviation sigma (positive and finite) times the width of the constant’s range, or the deviation of Constants::normal constants, e.g. 0.1.

Errors

Error::InvalidSetting (setting constant_sigma) for a sigma that isn’t positive and finite.

pub fn sigma(&self) -> f64

The standard deviation of the noise, as a fraction of a constant’s range.

Trait Implementations

impl Clone for ConstantMutation

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ConstantMutation

impl Debug for ConstantMutation

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ConstantMutation

Available on crate feature serde only.

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<ConstantMutation> for TreeMutation

fn from(mutation: ConstantMutation) -> Self

Converts to this type from the input type.

impl<P: Copy + Debug + Send + Sync> Mutate<Gp<P>> for ConstantMutation

fn mutate(&self, gp: &Gp<P>, tree: &mut Tree, rng: &mut StreamRng)

Mutates genome. A mutation with a per-gene rate can leave it unchanged when it picks no gene; the other mutations always change it (unless its space has a single genome).

impl PartialEq for ConstantMutation

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for ConstantMutation

Available on crate feature serde only.

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 ConstantMutation