Struct GraphNode 

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

A node in a graph structure that represents a single element with connections to other nodes.

The GraphNode struct is a fundamental building block for graph-based genetic programming in Radiate. It represents a node in a directed graph that can have both incoming and outgoing connections to other nodes. Each node has a unique identifier, an index in the graph, a value of type T, and maintains sets of incoming and outgoing connections.

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
• id - A unique identifier for the node (GraphNodeId)
• index - The position of the node in the graph’s node collection
• direction - The direction of the node’s connections (Forward or Backward)
• node_type - Optional NodeType that specifies the role of the node (Input, Output, Vertex, Edge, etc.)
• arity - Optional Arity that specifies how many incoming connections the node can have. If the arity is not supplied, the node will try it’s best to determine it based on the node type and the number of connections.
• incoming - Set of indices of nodes that have connections to this node
• outgoing - Set of indices of nodes that this node has connections to

Examples

use radiate_gp::{collections::{GraphNode, NodeType}, Arity};

// Create a new input node with value 42
let node = GraphNode::new(0, NodeType::Input, 42);

// Create a node with specific arity
// This node will be invalid if it has a number of incoming connections other than 2
let node_with_arity = GraphNode::with_arity(1, NodeType::Vertex, 42, Arity::Exact(2));

Node Types and Arity

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

• Input nodes should have no incoming connections and at least one outgoing connection
• Output nodes should have at least one incoming connection
• Vertex nodes can have both incoming and outgoing connections
• Edge nodes should have exactly one incoming and one outgoing connection

Recurrent Connections

Nodes can form recurrent connections (cycles) in the graph by:

• Setting the node’s direction to Direction::Backward
• Having a connection to itself (index in incoming/outgoing sets)

Validity

A node is considered valid based on its type and connections:

• Input nodes are valid when they have no incoming connections and at least one outgoing connection
• Output nodes are valid when they have at least one incoming connection
• Vertex nodes are valid when they have both incoming and outgoing connections
• Edge nodes are valid when they have exactly one incoming and one outgoing connection

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

Serialization

When the “serde” feature is enabled, the struct implements Serialize and Deserialize traits.

Implementations

impl<T> GraphNode<T>

pub fn new(index: usize, node_type: NodeType, value: T) -> Self

Creates a new GraphNode with the specified index, node type, and value.

This is the most basic constructor for a graph node, initializing it with default direction (Forward) and no specific arity or node type.

pub fn with_arity( index: usize, node_type: NodeType, value: T, arity: Arity, ) -> Self

Creates a new GraphNode with the specified index, node type, value, and arity.

This constructor allows for more control over the node’s behavior by specifying the arity, which defines how many incoming connections the node can accept - if the number of connections does not match the arity, the node will be considered invalid.

pub fn with_incoming<I: IntoIterator<Item = usize>>(self, incoming: I) -> Self

pub fn with_outgoing<O: IntoIterator<Item = usize>>(self, outgoing: O) -> Self

pub fn direction(&self) -> Direction

pub fn set_direction(&mut self, direction: Direction)

pub fn innovation(&self) -> Option<InnovationId>

pub fn set_innovation(&mut self, innovation: Option<InnovationId>)

pub fn index(&self) -> usize

pub fn id(&self) -> &GraphNodeId

pub fn is_recurrent(&self) -> bool

pub fn incoming(&self) -> &[usize]

pub fn outgoing(&self) -> &[usize]

pub fn incoming_mut(&mut self) -> &mut [usize]

pub fn outgoing_mut(&mut self) -> &mut [usize]

pub fn is_locked(&self) -> bool

pub fn insert_incoming(&mut self, value: usize)

pub fn remove_incoming(&mut self, value: &usize)

pub fn insert_outgoing(&mut self, value: usize)

pub fn remove_outgoing(&mut self, value: &usize)

Trait Implementations

impl<T: Clone> Clone for GraphNode<T>

fn clone(&self) -> GraphNode<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for GraphNode<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for GraphNode<T>

fn default() -> Self

Returns the “default value” for a type.

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

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

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

Evaluates the GraphNode with the given input. Returns the output of the GraphNode.

Arguments

• inputs - A Vec of V to evaluate the GraphNode with.

Returns

• A V which is the output of the GraphNode.

impl<T> From<(usize, NodeType, T)> for GraphNode<T>

fn from((index, node_type, value): (usize, NodeType, T)) -> Self

Converts to this type from the input type.

impl<T> From<(usize, NodeType, T, Arity)> for GraphNode<T>

fn from((index, node_type, value, arity): (usize, NodeType, T, Arity)) -> Self

Converts to this type from the input type.

impl<T, I> From<(usize, NodeType, T, I, I)> for GraphNode<T>

where I: Into<SortedBuffer<usize>>,

fn from( (index, node_type, value, incoming, outgoing): (usize, NodeType, T, I, I), ) -> Self

Converts to this type from the input type.

impl<T: Default> From<(usize, T)> for GraphNode<T>

fn from((index, value): (usize, T)) -> Self

Converts to this type from the input type.

impl<T: Default> From<(usize, T, Arity)> for GraphNode<T>

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

Converts to this type from the input type.

impl<T> FromIterator<GraphNode<T>> for GraphChromosome<T>

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

Creates a value from an iterator.

impl<T> FromIterator<GraphNode<T>> for Graph<T>

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

Creates a value from an iterator.

impl<T> Gene for GraphNode<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) -> GraphNode<T>

Create a new instance of the Gene.

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

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 GraphNode<T>

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

Feeds this value into the given Hasher.

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

where Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> Node for GraphNode<T>

Implementing the Node trait for GraphNode This joins common functionality for nodes in a graph structure together.

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 GraphNode<T>

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

Equality operator ==.

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

Inequality operator !=.

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

impl<T> Valid for GraphNode<T>

Implementing the Valid trait for GraphNode This trait checks if the node is valid based on its type and connections. A valid node must have the correct number of incoming and outgoing connections according to its arity and node type.

A node is considered valid based on its type and connections:

• Input nodes are valid when they have no incoming connections and at least one outgoing connection
• Output nodes are valid when they have at least one incoming connection
• Vertex nodes are valid when they have both incoming and outgoing connections
• Edge nodes are valid when they have exactly one incoming and one outgoing connection

fn is_valid(&self) -> bool