Struct TreeGenome 

pub struct TreeGenome<T: Terminal = ArithmeticTerminal, F: Function = ArithmeticFunction> {
    pub root: TreeNode<T, F>,
    pub max_depth: usize,
}

Tree genome for genetic programming

Fields

root: TreeNode<T, F>

Root node of the tree

max_depth: usize

Maximum allowed depth

Implementations

impl<T: Terminal, F: Function> TreeGenome<T, F>

pub fn new(root: TreeNode<T, F>, max_depth: usize) -> Self

Create a new tree genome

pub fn depth(&self) -> usize

Get the depth of the tree

pub fn size(&self) -> usize

Get the number of nodes in the tree

pub fn evaluate(&self, variables: &[f64]) -> f64

Evaluate the tree with given variable bindings.

Uses an explicit work stack (iterative post-order traversal) rather than recursion, so a pathologically deep tree cannot overflow the call stack (see the module note on deep trees).

pub fn dismantle(self)

Free this tree without deep recursion.

Consumes the genome and dismantles its tree iteratively (see the module note on deep trees). Use this for pathologically deep trees that would otherwise overflow the stack when dropped implicitly.

pub fn generate_full<R: Rng>( rng: &mut R, depth: usize, max_depth: usize, ) -> Self

Generate a random tree using the “full” method

pub fn generate_grow<R: Rng>( rng: &mut R, max_depth: usize, terminal_prob: f64, ) -> Self

Generate a random tree using the “grow” method

pub fn generate_ramped_half_and_half<R: Rng>( rng: &mut R, min_depth: usize, max_depth: usize, ) -> Self

Generate using ramped half-and-half

pub fn generate_with_depth<R: Rng>(rng: &mut R, max_depth: usize) -> Self

Generate a random tree with an explicit maximum depth.

This is the honest constructor for random generation: unlike EvolutionaryGenome::generate, which overloads MultiBounds and remaps its dimension count to a depth, this takes the maximum depth directly. It uses ramped half-and-half between depth 2 and max_depth (both clamped to at least 1).

pub fn to_sexpr(&self) -> String

Convert tree to S-expression string

pub fn random_position<R: Rng>(&self, rng: &mut R) -> Vec<usize>

Get a random node position

pub fn random_terminal_position<R: Rng>( &self, rng: &mut R, ) -> Option<Vec<usize>>

Get a random terminal position

pub fn random_function_position<R: Rng>( &self, rng: &mut R, ) -> Option<Vec<usize>>

Get a random function position

Trait Implementations

impl<T: Clone + Terminal, F: Clone + Function> Clone for TreeGenome<T, F>

fn clone(&self) -> TreeGenome<T, F>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Terminal, F: Function> CrossoverOperator<TreeGenome<T, F>> for SubtreeCrossover

fn crossover<R: Rng>( &self, parent1: &TreeGenome<T, F>, parent2: &TreeGenome<T, F>, rng: &mut R, ) -> OperatorResult<(TreeGenome<T, F>, TreeGenome<T, F>)>

Apply crossover to two parents and produce two offspring

fn crossover_probability(&self) -> f64

Get the probability of crossover being applied

impl<T: Debug + Terminal, F: Debug + Function> Debug for TreeGenome<T, F>

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

Formats the value using the given formatter.

impl<'de, T: Terminal, F: Function> Deserialize<'de> for TreeGenome<T, F>

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Terminal, F: Function> Display for TreeGenome<T, F>

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

Formats the value using the given formatter.

impl<T: Terminal, F: Function> EvolutionaryGenome for TreeGenome<T, F>

fn generate<R: Rng>(rng: &mut R, bounds: &MultiBounds) -> Self

Generate a random tree.

Only bounds.dimension() is consulted — it is remapped (clamped to [3, 10]) to a maximum tree depth — and the per-dimension min/max values are ignored. Prefer TreeGenome::generate_with_depth to make the depth explicit instead of overloading MultiBounds.

type Allele = TreeNode<T, F>

The allele type for individual genes

type Phenotype = TreeGenome<T, F>

The phenotype or decoded solution type

fn decode(&self) -> Self::Phenotype

Decode genome into phenotype for fitness evaluation

fn dimension(&self) -> usize

Compute dimensionality for adaptive operators

fn distance(&self, other: &Self) -> f64

Distance metric between two genomes.

fn try_distance(&self, other: &Self) -> Result<f64, GenomeError>

Fallible distance metric.

fn as_slice(&self) -> Option<&[Self::Allele]>

Get the genome’s genes as a slice (for numeric genomes)

fn as_mut_slice(&mut self) -> Option<&mut [Self::Allele]>

Get the genome’s genes as a mutable slice (for numeric genomes)

impl GenomeLikelihood<TreeGenome> for GaussianRegression

fn model( &self, tree: &TreeGenome<ArithmeticTerminal, ArithmeticFunction>, beta: f64, ) -> Model<()>

The observation program conditioned on genome, at likelihood temperature beta.

impl<T: Terminal, F: Function> MutationOperator<TreeGenome<T, F>> for PointMutation

fn mutate<R: Rng>(&self, genome: &mut TreeGenome<T, F>, rng: &mut R)

Apply mutation to a genome in place

fn mutation_probability(&self) -> Option<f64>

Report the per-gene mutation probability actually applied by this operator.

impl<T: Terminal, F: Function> MutationOperator<TreeGenome<T, F>> for SubtreeMutation

fn mutate<R: Rng>(&self, genome: &mut TreeGenome<T, F>, rng: &mut R)

Apply mutation to a genome in place

fn mutation_probability(&self) -> Option<f64>

Report the per-gene mutation probability actually applied by this operator.

impl<T: Terminal, F: Function> MutationOperator<TreeGenome<T, F>> for HoistMutation

fn mutate<R: Rng>(&self, genome: &mut TreeGenome<T, F>, rng: &mut R)

Apply mutation to a genome in place

fn mutation_probability(&self) -> Option<f64>

Report the per-gene mutation probability actually applied by this operator.

impl<T: Terminal, F: Function> MutationOperator<TreeGenome<T, F>> for ShrinkMutation

fn mutate<R: Rng>(&self, genome: &mut TreeGenome<T, F>, rng: &mut R)

Apply mutation to a genome in place

fn mutation_probability(&self) -> Option<f64>

Report the per-gene mutation probability actually applied by this operator.

impl<T: Terminal, F: Function> MutationOperator<TreeGenome<T, F>> for AdaptiveTreeMutation

fn mutate<R: Rng>(&self, genome: &mut TreeGenome<T, F>, rng: &mut R)

Apply mutation to a genome in place

fn mutation_probability(&self) -> Option<f64>

Report the per-gene mutation probability actually applied by this operator.

impl<T: PartialEq + Terminal, F: PartialEq + Function> PartialEq for TreeGenome<T, F>

fn eq(&self, other: &TreeGenome<T, F>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<T: Terminal, F: Function> Serialize for TreeGenome<T, F>

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: PartialEq + Terminal, F: PartialEq + Function> StructuralPartialEq for TreeGenome<T, F>

impl<T: Terminal, F: Function> TraceGenome for TreeGenome<T, F>

Available on crate feature ppl only.

fn to_trace(&self) -> Trace

Convert genome to a fugue trace.

fn from_trace(trace: &Trace) -> Result<Self, GenomeError>

Reconstruct genome from a fugue trace.

fn trace_prefix() -> &'static str

Get the address prefix used for trace storage (default: "gene").

impl<T: Terminal, F: Function> TreeGenomeType for TreeGenome<T, F>

type Term = T

The terminal type

type Func = F

The function type

fn root(&self) -> &TreeNode<T, F>

Get the root of the tree

fn root_mut(&mut self) -> &mut TreeNode<T, F>

Get a mutable reference to the root

fn max_depth(&self) -> usize

Get the maximum depth

fn from_root(root: TreeNode<T, F>, max_depth: usize) -> Self

Create a new tree from a root node