Struct radiate_matrix_tree::matrix_tree::evtree::Evtree

pub struct Evtree { /* fields omitted */ }

A tree struct to encapsulate a bidirectional binary tree.AsMut

Each node within the tree has three pointers to its parent, left, and right child. They also have a randomly generated neural network and an output option (classification).

This struct holds the root of the tree as a raw mutable pointer and thus this structure is enherintly unsafe, however most if not all of that funtionality is encapsulated within the implementation. The tree also contains a size which represents the number of nodes in the tree, an input size which is the size of the input vector (1D), and is used to generate nodes alone with the output options which is an owned vec of i32s represnting different outputs of the classification.

Methods

impl Evtree

implement the tree

pub fn new() -> Self

Create a new default Tree given an input size and a vec of possible outputs

Returns the newly created Tree with a null raw mutable pointer as a root, a size of 0 and an owned input_size and output_options.

Important traits for IterMut<'a>

impl<'a> Iterator for IterMut<'a> type Item = &'a mut Node;

pub fn iter_mut(&mut self) -> IterMut

return an in order iterator which allows for the nodes in the tree to be mutatued while iterating

Important traits for LevelOrderIterator<'a>

impl<'a> Iterator for LevelOrderIterator<'a> type Item = &'a Node;

pub fn level_order_iter(&self) -> LevelOrderIterator

Return a level order iterator Iterators over the tree from top to bottom, going from parent, to it's left child then it's right child. Each node that the iterator yields is a reference to a Node struct

Important traits for InOrderIterator<'a>

impl<'a> Iterator for InOrderIterator<'a> type Item = &'a Node;

pub fn in_order_iter(&self) -> InOrderIterator

Return an in order iterator Iterates over the tree in order, from left to right with the root in the middle (assuming balanced) Each node that the iterator yields is a reference to a Node struct

pub fn len(&self) -> &i32

the len of the tree is it's size, the numbr of nodes

pub fn height(&self) -> i32

return the height of the tree from the root

pub fn get(&mut self, index: usize) -> &mut Node

Get a node from the tree at a given index and return an option with either the node in it, or none.

Panic! if the index is greater than the size of the tree.

pub fn index_of(&self, node: &Node) -> usize

Get the index of a given node in the tree

pub fn insert_random(&mut self, input_size: i32, outputs: &Vec<i32>)

Insert a node to the tree randomly extracting away all of the unsafe code required to iterate through the tree and check for null raw mutable pointers and increase the size by 1 each time.

pub fn display(&self)

display the tree by calling the recursive display method within the node implementation at level 0. If the root is a null raw mutable pointer, panic!

pub fn balance(&mut self)

Balance the tree by thin copying each node then calling a private recursive function to build the tree structure.

Return an option in order to use '?' instead of 'unwrap()' in the function body.

pub fn get_biased_level<'a>(&'a self) -> Vec<&'a Node>

get a vec of node references in a bised sense where nodes at a lower level are favored

pub fn get_biased_random_node<'a>(&'a self) -> &'a Node

Get a biased random node from the tree by gathering a biased random level towards the bottom of the tree, then returning a reference to the chosen node

pub fn gut_random_node(&mut self, r: &mut ThreadRng)

Gut a random node from the tree. Get a random index from the tree then give that node a new neural network.

pub fn shuffle_tree(&mut self, r: &mut ThreadRng)

Shuffel the tree by gathering a list of the nodes then shuffling the list and then balancing the tree again from that list

pub fn edit_random_node_networks(
    &mut self,
    weight_mutate: f32,
    weight_transform: f32,
    layer_mutate: f32
)

Go through each of the nodes in the tree and randomly mutate the weights and biases within the network

pub fn asymmetry(&self) -> f32

Compute the asymmetry for a single tree by adding the height times the neural network weight sum of the tree and putting it through the sine function to compress the number between (-1, 1)

pub fn propagate(&self, inputs: Matrix<f32>) -> u8

Trait Implementations

impl Clone for Evtree

Return a new copy of the tree, calling deep copy from the root node and copying over the size, input size, and output options in the most effecient way. TODO: this looks like messy.. is there a way to clean up?

fn clone(&self) -> Evtree

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Evtree

implemented a display function for the Tree just for easier debugging

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

Formats the value using the given formatter.

impl Default for Evtree

implement a function for getting a base default Evtree which is completetly empty There are multiple places within the struct implementation which will panic! if this default Evtree is passed through it.

fn default() -> Evtree

Returns the "default value" for a type.

impl Drop for Evtree

Because the tree is made out of raw mutable pointers, if those pointers are not dropped, there is a severe memory leak, like possibly gigs of ram over only a few generations depending on the size of the generation This drop implementation will recursivley drop all nodes in the tree

fn drop(&mut self)

Executes the destructor for this type.

impl Genome<Evtree, TreeEnvionment> for Evtree

fn crossover(
    one: &Evtree,
    two: &Evtree,
    settings: &Arc<RwLock<TreeEnvionment>>,
    crossover_rate: f32
) -> Option<Evtree>

one should be the more fit Evtree and two should be the less fit Evtree. This function should attemp to produce a Evtree which is no higher than the specified max height of a Evtree.

fn base(settings: &mut TreeEnvionment) -> Evtree

Implement the base trait for the tree This provides a generic way to get a base tree for starting the evolution process Get the base tree type and return a randomly generated base tree created through the tree settings given to it at its new() call

fn distance(
    one: &Evtree,
    two: &Evtree,
    _settings: &Arc<RwLock<TreeEnvionment>>
) -> f32

takes in a Rc<RefCell<Self in order to make it simpler for the Generation to throw types it already has inside the function by simplmy cloing them. This function will drop the references to the Self traits at the end of this function's scope

impl PartialEq<Evtree> for Evtree

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl Send for Evtree

These must be implemneted for the tree or any type to be used within seperate threads. Because implementing the functions themselves is dangerious and unsafe and i'm not smart enough to do that from scratch, these "implmenetaions" will get rid of the error and realistically they don't need to be implemneted for the program to work

impl StructuralPartialEq for Evtree

impl Sync for Evtree