Enum Op 

pub enum Op<T> {
    Fn(&'static str, Arity, fn(&[T]) -> T),
    Var(&'static str, usize),
    Const(&'static str, T),
    MutableConst {
        name: &'static str,
        arity: Arity,
        value: T,
        supplier: fn() -> T,
        modifier: fn(&T) -> T,
        operation: fn(&[T], &T) -> T,
    },
}

Op is an enumeration that represents the different types of operations that can be performed within the genetic programming framework. Each variant of the enum encapsulates a different kind of operation, allowing for a flexible and extensible way to define the behavior of nodes within trees and graphs.

The Op heavilty depends on it’s Arity to define how many inputs it expects. This is crucial for ensuring that the operations receive the correct number of inputs and that the structures built using these operations are built in ways that respect these input requirements. For example, an addition operation would typically have an arity of 2, while a constant operation would have an arity of 0. This is the base level of the GP system, meaning that everything built on top of it (trees, graphs, etc.) will relies heavily on how these operations are defined and used.

Variants

Fn(&'static str, Arity, fn(&[T]) -> T)

1. A stateless function operation:

Arguments

• A &'static str name (e.g., “Add”, “Sigmoid”)
• Arity (how many inputs it takes)
• Arc<dyn Fn(&\[T\]) -> T> for the actual function logic

Var(&'static str, usize)

2. A variable-like operation:

Arguments

• String = a name or identifier
• usize = an index to retrieve from some external context

Const(&'static str, T)

3. A compile-time constant: e.g., 1, 2, 3, etc.

Arguments

• &'static str name
• T the actual constant value

MutableConst

4. A mutable const is a constant that can change over time:

Arguments

• &'static str name

• Arity of how many inputs it might read

• Current value of type T

• An Arc<dyn Fn() -> T> for retrieving (or resetting) the value

• An Arc<dyn Fn(&[T], &T) -> T> for updating or combining inputs & old value -> new value

  This suggests a node that can mutate its internal state over time, or one that needs a special function to incorporate the inputs into the next state.

Fields

name: &'static str

arity: Arity

value: T

supplier: fn() -> T

modifier: fn(&T) -> T

operation: fn(&[T], &T) -> T

Implementations

impl Op<bool>

pub fn and() -> Self

pub fn or() -> Self

pub fn not() -> Self

pub fn xor() -> Self

pub fn eq() -> Self

pub fn ne() -> Self

pub fn gt() -> Self

pub fn ge() -> Self

pub fn lt() -> Self

pub fn le() -> Self

pub fn if_else() -> Self

pub fn and_then() -> Self

pub fn or_else() -> Self

pub fn nand() -> Self

pub fn nor() -> Self

pub fn xnor() -> Self

pub fn implies() -> Self

pub fn iff() -> Self

impl Op<f32>

pub fn weight() -> Self

pub fn weight_with(value: f32) -> Self

pub fn add() -> Self

pub fn sub() -> Self

pub fn mul() -> Self

pub fn div() -> Self

pub fn sum() -> Self

pub fn diff() -> Self

pub fn prod() -> Self

pub fn neg() -> Self

pub fn pow() -> Self

pub fn sqrt() -> Self

pub fn abs() -> Self

pub fn exp() -> Self

pub fn log() -> Self

pub fn sin() -> Self

pub fn cos() -> Self

pub fn max() -> Self

pub fn min() -> Self

pub fn tan() -> Self

pub fn ceil() -> Self

pub fn floor() -> Self

pub fn sigmoid() -> Self

pub fn tanh() -> Self

pub fn relu() -> Self

pub fn leaky_relu() -> Self

pub fn elu() -> Self

pub fn linear() -> Self

pub fn mish() -> Self

pub fn swish() -> Self

pub fn softplus() -> Self

impl<T> Op<T>

pub fn name(&self) -> &str

pub fn arity(&self) -> Arity

pub fn is_fn(&self) -> bool

pub fn is_var(&self) -> bool

pub fn is_const(&self) -> bool

pub fn is_mutable_const(&self) -> bool

impl<T> Op<T>

pub fn var(index: usize) -> Self

pub fn vars(range: Range<usize>) -> Vec<Self>

pub fn constant(value: T) -> Self

where T: Display,

pub fn named_constant(name: &'static str, value: T) -> Self

pub fn identity() -> Self

where T: Clone,

Trait Implementations

impl<T> Clone for Op<T>

where T: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Op<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Default for Op<T>

where T: Default,

fn default() -> Self

Returns the “default value” for a type.

impl<T> Display for Op<T>

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

Formats the value using the given formatter.

impl<T> Eval<[T], T> for Op<T>

where T: Clone,

fn eval(&self, inputs: &[T]) -> T

impl<T> Factory<(), Op<T>> for Op<T>

where T: Clone,

fn new_instance(&self, _: ()) -> Op<T>

impl<T: Clone> From<Op<T>> for NodeStore<Op<T>>

fn from(value: Op<T>) -> Self

Converts to this type from the input type.

impl<T> From<Op<T>> for NodeValue<Op<T>>

fn from(value: Op<T>) -> Self

Converts to this type from the input type.

impl<T> From<Op<T>> for TreeNode<Op<T>>

fn from(value: Op<T>) -> Self

Converts to this type from the input type.

impl<T> From<Op<T>> for Vec<TreeNode<Op<T>>>

fn from(value: Op<T>) -> Self

Converts to this type from the input type.

impl<T> Hash for Op<T>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> PartialEq for Op<T>

where T: PartialEq,

fn eq(&self, other: &Self) -> 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 TreeRewriterRule<Op<f32>> for OpTreeRewriteRule<f32>

fn apply<'a>(&self, node: &'a mut TreeNode<Op<f32>>) -> bool

impl<T> Send for Op<T>

impl<T> Sync for Op<T>