Struct TreeNode 

pub struct TreeNode<T> { /* private fields */ }

A node in a tree structure that represents a single element with optional children.

The TreeNode struct is a fundamental building block for tree-based genetic programming in Radiate. It represents a node in a tree that can have zero or more child nodes, forming a hierarchical structure. Each node has a value of type T and maintains an optional list of child nodes.

Type Parameters

• T - The type of value stored in the node. This type must implement Clone, PartialEq, and other traits required by the genetic programming operations.

Fields

• value - The actual value stored in the node
• arity - Optional Arity that specifies how many children the node can have
• children - Optional vector of child nodes

Examples

use radiate_gp::{collections::{TreeNode}, Arity, Node};

// Create a new node with value 42
let node = TreeNode::new(42);

// Create a node with specific arity
let node_with_arity = TreeNode::with_arity(42, Arity::Exact(2));
let other_node_with_arity = TreeNode::from((42, Arity::Exact(2)));

assert_eq!(node_with_arity.arity(), other_node_with_arity.arity());

// Create a node with children
let node_with_children = TreeNode::with_children(42, vec![
    TreeNode::new(1),
    TreeNode::new(2)
]);
let other_node_with_children = TreeNode::from((42, vec![
    TreeNode::new(1),
    TreeNode::new(2),
]));

Node Types and Arity

The node’s type and arity determine its behavior and validity:

• Leaf nodes have no children (arity is Arity::Zero)
• Vertex nodes can have any number of children (arity is Arity::Any)
• Root nodes are the starting point of the tree and can have any number of children

Tree Operations

The struct provides several methods for tree manipulation:

• new() - Creates a new node with no children
• with_arity() - Creates a node with a specific arity
• with_children() - Creates a node with a list of children
• add_child() - Adds a child to the node
• attach() - Attaches a child and returns self for method chaining
• detach() - Removes a child at a specific index
• swap_subtrees() - Swaps subtrees between two nodes

Tree Traversal

The struct implements the TreeIterator trait, providing three traversal methods:

• iter_pre_order() - Traverses the tree in pre-order (root, then children)
• iter_post_order() - Traverses the tree in post-order (children, then root)
• iter_breadth_first() - Traverses the tree level by level

Tree Properties

The struct provides methods to query tree properties:

• is_leaf() - Checks if the node has no children - must have Arity::Zero
• size() - Returns the total number of nodes in the subtree
• height() - Returns the height of the subtree

Validity

A node is considered valid based on its arity:

• Nodes with Arity::Zero must have no children
• Nodes with Arity::Exact must have exactly n children
• Nodes with Arity::Any can have any number of children

Implementation Details

The struct implements several traits:

• Node - Provides common node behavior and access to value and type information
• Gene - Enables genetic operations for the node making it compatible with genetic algorithms
• Valid - Defines validity rules for the node
• Debug - Provides debug formatting
• Clone, PartialEq - Required for genetic programming operations
• Format - Provides pretty-printing of the tree structure

Evaluation

When T implements the Eval trait, the node can be evaluated with input data:

use radiate_gp::{Op, Eval, TreeNode};

let tree = TreeNode::new(Op::add())
    .attach(TreeNode::new(Op::constant(2.0)))
    .attach(TreeNode::new(Op::constant(3.0)));

let result = tree.eval(&[]); // Evaluates to 5.0

Implementations

impl<T> TreeNode<T>

pub fn new(val: T) -> Self

pub fn with_arity(val: T, arity: Arity) -> Self

pub fn with_children<N>(val: T, children: Vec<N>) -> Self

where N: Into<TreeNode<T>>,

pub fn is_leaf(&self) -> bool

pub fn add_child(&mut self, child: impl Into<TreeNode<T>>)

pub fn attach(self, other: impl Into<TreeNode<T>>) -> Self

pub fn detach(&mut self, index: usize) -> Option<TreeNode<T>>

pub fn children(&self) -> Option<&[TreeNode<T>]>

pub fn children_mut(&mut self) -> Option<&mut Vec<TreeNode<T>>>

pub fn take_children(&mut self) -> Option<Vec<TreeNode<T>>>

pub fn size(&self) -> usize

pub fn height(&self) -> usize

pub fn get_mut(&mut self, index: usize) -> Option<&mut TreeNode<T>>

Trait Implementations

impl<T> AsMut<TreeNode<T>> for Tree<T>

fn as_mut(&mut self) -> &mut TreeNode<T>

Converts this type into a mutable reference of the (usually inferred) input type.

impl<T> AsRef<TreeNode<T>> for Tree<T>

fn as_ref(&self) -> &TreeNode<T>

Converts this type into a shared reference of the (usually inferred) input type.

impl<T: Clone> Clone for TreeNode<T>

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> Debug for TreeNode<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for TreeNode<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T, V> Eval<[V], V> for TreeNode<T>

where T: Eval<[V], V>, V: Clone,

fn eval(&self, input: &[V]) -> V

impl<T, V> Eval<[V], V> for &TreeNode<T>

where T: Eval<[V], V>, V: Clone,

Implements the Eval trait for TreeNode<T> where T is Eval<[V], V>. This is where the real work is done. It recursively evaluates the TreeNode and its children until it reaches a leaf node, at which point it applies the T’s eval fn to the input.

Because a Tree has only a single root node, this can only be used to return a single value. We assume here that each leaf can eval the incoming input - this is a safe and the only real logical assumption we can make.

fn eval(&self, input: &[V]) -> V

impl<T> Factory<(usize, Option<NodeStore<T>>), Option<TreeNode<T>>> for TreeNode<T>

where T: Clone + Default,

fn new_instance( &self, (index, store): (usize, Option<NodeStore<T>>), ) -> Option<TreeNode<T>>

impl<T: Debug> Format for TreeNode<T>

fn format(&self) -> String

impl From<&'static str> for TreeNode<&'static str>

fn from(value: &'static str) -> Self

Converts to this type from the input type.

impl From<()> for TreeNode<()>

fn from(value: ()) -> Self

Converts to this type from the input type.

impl<T> From<(T, Arity)> for TreeNode<T>

fn from(value: (T, Arity)) -> Self

Converts to this type from the input type.

impl<T> From<(T, Vec<TreeNode<T>>)> for TreeNode<T>

fn from(value: (T, Vec<TreeNode<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 From<String> for TreeNode<String>

fn from(value: String) -> Self

Converts to this type from the input type.

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

fn from(node: TreeNode<T>) -> Self

Converts to this type from the input type.

impl From<bool> for TreeNode<bool>

fn from(value: bool) -> Self

Converts to this type from the input type.

impl From<char> for TreeNode<char>

fn from(value: char) -> Self

Converts to this type from the input type.

impl From<f32> for TreeNode<f32>

fn from(value: f32) -> Self

Converts to this type from the input type.

impl From<f64> for TreeNode<f64>

fn from(value: f64) -> Self

Converts to this type from the input type.

impl From<i8> for TreeNode<i8>

fn from(value: i8) -> Self

Converts to this type from the input type.

impl From<i16> for TreeNode<i16>

fn from(value: i16) -> Self

Converts to this type from the input type.

impl From<i32> for TreeNode<i32>

fn from(value: i32) -> Self

Converts to this type from the input type.

impl From<i64> for TreeNode<i64>

fn from(value: i64) -> Self

Converts to this type from the input type.

impl From<i128> for TreeNode<i128>

fn from(value: i128) -> Self

Converts to this type from the input type.

impl From<isize> for TreeNode<isize>

fn from(value: isize) -> Self

Converts to this type from the input type.

impl From<u8> for TreeNode<u8>

fn from(value: u8) -> Self

Converts to this type from the input type.

impl From<u16> for TreeNode<u16>

fn from(value: u16) -> Self

Converts to this type from the input type.

impl From<u32> for TreeNode<u32>

fn from(value: u32) -> Self

Converts to this type from the input type.

impl From<u64> for TreeNode<u64>

fn from(value: u64) -> Self

Converts to this type from the input type.

impl From<u128> for TreeNode<u128>

fn from(value: u128) -> Self

Converts to this type from the input type.

impl From<usize> for TreeNode<usize>

fn from(value: usize) -> Self

Converts to this type from the input type.

impl<T> FromIterator<TreeNode<T>> for TreeChromosome<T>

fn from_iter<I: IntoIterator<Item = TreeNode<T>>>(iter: I) -> Self

Creates a value from an iterator.

impl<T> Gene for TreeNode<T>

where T: Clone + PartialEq,

type Allele = T

fn allele(&self) -> &Self::Allele

Get the allele of the Gene. This is the value that the Gene represents or “expresses”.

fn allele_mut(&mut self) -> &mut Self::Allele

Get a mutable reference to the allele of the Gene.

fn new_instance(&self) -> Self

Create a new instance of the Gene.

fn with_allele(&self, allele: &Self::Allele) -> Self

Create a new Gene with the given allele.

fn set_allele(&mut self, allele: Self::Allele)

Set the allele of the Gene to the given value.

impl<T: Hash> Hash for TreeNode<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> Node for TreeNode<T>

type Value = T

fn value(&self) -> &Self::Value

Get a reference to the node’s value.

fn value_mut(&mut self) -> &mut Self::Value

Get a mutable reference to the node’s value.

fn node_type(&self) -> NodeType

Get the NodeType of the node. As previously mentioned, if the NodeType is not supplied during creation, this value is determined by the node’s relationship to the rest of the structure holding it. IE, a GraphNode with 0 incoming connections is likely an Input, while a TreeNode with 0 children is likely a Leaf.

fn arity(&self) -> Arity

Get the arity of the node, which is the number of incoming connections it can have. In a genetic programming sense, this is the number of allowed inputs for a node. In a Graph, this is the number of allowed incoming connections while for a Tree, this is the number of children it is allowed to have.

impl<T: PartialEq> PartialEq for TreeNode<T>

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

Equality operator ==.

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

Inequality operator !=.

impl<T: PartialEq> StructuralPartialEq for TreeNode<T>

impl<T> TreeIterator<T> for TreeNode<T>

Implement the TreeIterator trait for TreeNode

This allows for traversal of a single node and its children in pre-order, post-order, and breadth-first order.

fn iter_pre_order(&self) -> PreOrderIterator<'_, T>

fn iter_post_order(&self) -> PostOrderIterator<'_, T>

fn iter_breadth_first(&self) -> TreeBreadthFirstIterator<'_, T>

fn apply<F: Fn(&mut TreeNode<T>)>(&mut self, visit_fn: F)

impl<T> Valid for TreeNode<T>

fn is_valid(&self) -> bool