Merge branch 'develop'

Author: pkalivas

crates/radiate-gp/src/collections/graphs/aggregate.rs

@@ -136,12 +136,12 @@ impl<'a, T: Clone> GraphAggregate<'a, T> {
                 let node = self.nodes[node_id];
 
                 trans.push((index, node.node_type(), node.value().clone(), node.arity()));
-                id_index_map.insert(node_id, index);
+                id_index_map.insert(*node_id, index);
             }
 
             for rel in self.relationships.iter() {
-                let source_idx = id_index_map[&rel.source_id];
-                let target_idx = id_index_map[&rel.target_id];
+                let source_idx = id_index_map[rel.source_id];
+                let target_idx = id_index_map[rel.target_id];
 
                 trans.attach(source_idx, target_idx);
             }
@@ -256,50 +256,42 @@ impl<'a, T: Clone> GraphAggregate<'a, T> {
 
     fn attach(&mut self, group: &AggregateInsertValue<'a, T>) -> Vec<&'a GraphNodeId> {
         match group {
-            AggregateInsertValue::Single(node) => self.attach_single(node),
-            AggregateInsertValue::Many(nodes) => self.attach_many(nodes),
-        }
-    }
-
-    fn attach_single(&mut self, node: &'a GraphNode<T>) -> Vec<&'a GraphNodeId> {
-        if !self.nodes.contains_key(node.id()) {
-            let ordinal = self.node_order.len();
-            self.nodes.insert(node.id(), node);
-            self.node_order.insert(ordinal, node.id());
-
-            return vec![node.id()];
-        }
-
-        vec![node.id()]
-    }
-
-    fn attach_many(&mut self, nodes: &'a [GraphNode<T>]) -> Vec<&'a GraphNodeId> {
-        let mut indexes = Vec::with_capacity(nodes.len());
-        for node in nodes.iter() {
-            let node_id = node.id();
-
-            if !self.nodes.contains_key(node_id) {
-                let ordinal = self.node_order.len();
-
-                self.nodes.insert(node_id, node);
-                self.node_order.insert(ordinal, node_id);
-                indexes.push(node_id);
-
-                nodes
-                    .iter()
-                    .filter(|item| node.outgoing().contains(&item.index()))
-                    .for_each(|item| {
-                        self.relationships.push(Relationship {
-                            source_id: node.id(),
-                            target_id: item.id(),
-                        });
-                    });
-            } else {
-                indexes.push(node_id);
+            AggregateInsertValue::Single(node) => {
+                if !self.nodes.contains_key(node.id()) {
+                    let ordinal = self.node_order.len();
+                    self.nodes.insert(node.id(), node);
+                    self.node_order.insert(ordinal, node.id());
+                }
+
+                vec![node.id()]
+            }
+            AggregateInsertValue::Many(nodes) => {
+                let mut indexes = Vec::with_capacity(nodes.len());
+                for node in nodes.iter() {
+                    let node_id = node.id();
+                    indexes.push(node_id);
+
+                    if !self.nodes.contains_key(node_id) {
+                        let ordinal = self.node_order.len();
+
+                        self.nodes.insert(node_id, node);
+                        self.node_order.insert(ordinal, node_id);
+
+                        nodes
+                            .iter()
+                            .filter(|item| node.outgoing().contains(&item.index()))
+                            .for_each(|item| {
+                                self.relationships.push(Relationship {
+                                    source_id: node.id(),
+                                    target_id: item.id(),
+                                });
+                            });
+                    }
+                }
+
+                indexes
             }
         }
-
-        indexes
     }
 
     fn one_to_one_connect(&mut self, one: &[&'a GraphNodeId], two: &[&'a GraphNodeId]) {
@@ -856,10 +848,12 @@ mod tests {
         for i in 0..ins.len() {
             assert_eq!(g[i].outgoing().len(), outs.len());
         }
+
         // Each output receives from all inputs
         for j in 0..outs.len() {
             assert_eq!(g[ins.len() + j].incoming().len(), ins.len());
         }
+
         assert!(g.is_valid());
     }
 

crates/radiate-gp/src/collections/graphs/diversity.rs

@@ -28,19 +28,6 @@ impl NeatDistance {
     }
 }
 
-impl Diversity<GraphChromosome<Op<f32>>> for NeatDistance {
-    fn measure(
-        &self,
-        one: &Genotype<GraphChromosome<Op<f32>>>,
-        two: &Genotype<GraphChromosome<Op<f32>>>,
-    ) -> f32 {
-        one.iter()
-            .zip(two.iter())
-            .map(|(a, b)| self.graph_distance_iter(a, b))
-            .sum()
-    }
-}
-
 impl NeatDistance {
     #[inline]
     fn graph_distance_iter(
@@ -126,3 +113,16 @@ impl NeatDistance {
             + (self.op_mismatch_penalty * op_mismatch_penalty)
     }
 }
+
+impl Diversity<GraphChromosome<Op<f32>>> for NeatDistance {
+    fn measure(
+        &self,
+        one: &Genotype<GraphChromosome<Op<f32>>>,
+        two: &Genotype<GraphChromosome<Op<f32>>>,
+    ) -> f32 {
+        one.iter()
+            .zip(two.iter())
+            .map(|(a, b)| self.graph_distance_iter(a, b))
+            .sum()
+    }
+}

crates/radiate-gp/src/ops/math.rs

@@ -30,26 +30,14 @@ pub(super) const fn clamp(value: f32) -> f32 {
 /// common cases - vals with a len <= 5.
 #[inline]
 pub(super) fn aggregate(vals: &[f32]) -> f32 {
-    let len = vals.len();
-    if len == 0 {
-        return ZERO;
-    } else if len == 1 {
-        return vals[0];
-    } else if len == 2 {
-        return vals[0] + vals[1];
-    } else if len == 3 {
-        return vals[0] + vals[1] + vals[2];
-    } else if len == 4 {
-        return vals[0] + vals[1] + vals[2] + vals[3];
-    } else if len == 5 {
-        return vals[0] + vals[1] + vals[2] + vals[3] + vals[4];
-    } else if len == 6 {
-        return vals[0] + vals[1] + vals[2] + vals[3] + vals[4] + vals[5];
-    } else if len == 7 {
-        return vals[0] + vals[1] + vals[2] + vals[3] + vals[4] + vals[5] + vals[6];
-    }
-
-    vals.iter().cloned().sum::<f32>()
+    match vals {
+        [] => ZERO,
+        [a] => *a,
+        [a, b] => a + b,
+        [a, b, c] => a + b + c,
+        [a, b, c, d] => a + b + c + d,
+        _ => vals.iter().copied().sum(),
+    }
 }
 
 #[inline]

crates/radiate-gp/src/ops/param.rs

@@ -75,14 +75,3 @@ where
         self.data.fmt(f)
     }
 }
-
-// impl<T> Factory<T, Param<T>> for Param<T> {
-//     fn new_instance(&self, mut val: T) -> Param<T> {
-//         (self.modifier)(&mut val);
-//         Param {
-//             data: val,
-//             supplier: self.supplier,
-//             modifier: self.modifier,
-//         }
-//     }
-// }

crates/radiate-utils/src/buff/window.rs

@@ -110,12 +110,6 @@ mod tests {
         let mut buffer = WindowBuffer::with_window(5);
         for i in 0..20 {
             buffer.push(i);
-            println!(
-                "Added value {}, buffer len: {:?} -> {:?} ",
-                i,
-                buffer.len(),
-                buffer.values(),
-            );
         }
     }
 }

docs/source/events.md

@@ -1,14 +1,10 @@
 # Events and Subscriptions
 
-!!! warning ":construction: Under Construction :construction:"
-
-    As of `12/15/2025`: These docs are a work in progress and may not be complete or fully accurate. Please check back later for updates.
-
 Radiate provides an event system that allows you to monitor and react to the evolution process in real-time. This is great for:
 
 - Tracking the progress of evolution
 - Collecting metrics and statistics
-- Implementing custom logging
+- Implementing custom logging or logic based on the state of evolution
 - Visualizing the evolution process
 
 ## Overview
@@ -19,7 +15,7 @@ The `GeneticEngine` trys it's best to off-load almost the entire compute workloa
 
 !!! note "Threading Behavior"
 
-    Currently, the rust implementation is multi-threaded, meaning if you have multiple subscribers, there is no guarantee of the order in which they will be called. For python, regardless of if you are using a free-threaded interpreter (3.13t/3.14t, ect) or not, the events will be dispatched on a single thread in the order they were added.
+    Currently, the rust implementation is multi-threaded (if multi-threaded executors are used), meaning if you have multiple subscribers, there is no guarantee of the order in which they will be called. For python, regardless of if you are using a free-threaded interpreter (3.13t/3.14t, ect) or not, the events will be dispatched on a single thread in the order they were added.
 
 --- 
 ## Event Types
@@ -66,7 +62,7 @@ Below there is a brief description of each event type with its representative da
     {
         'event_type': 'stop_event',
         'index': 0, // Current generation number
-        // This will be a dictionary of metrics collected, see Engine's metrics docs for more info
+        // This will be a MetricSet (or dictionary in python) of metrics collected, see Engine's metrics docs for more info
         'metrics': ..., 
         // This will be the decoded best individual found so far. So, if you are 
         // evolving a vector of FloatGenes, this will be a list of floats
@@ -164,7 +160,7 @@ The simplest way to subscribe to events is by providing a callback function:
     use radiate::*;
 
     let mut engine = GeneticEngine::builder()
-        .codec(your_codec)
+        .codec(FloatCodec::vector(6, -5.0..5.0))
         .fitness_fn(your_fitness_fn)
         .subscribe(|event: &EngineEvent<Vec<f32>>| {
             if let EngineEvent::EpochComplete(index, best, metrics, score, objective) = event {
@@ -215,7 +211,7 @@ For more complex event handling, you can create a custom event handler class:
     engine.run(rd.GenerationsLimit(100))
     ```
 
-    Its also completely possible to create more advanced forms of visualization or logging through this method. For example, below we will collect the score distrubution from each epoch using polars then plot it with matplotlib.
+    Its also completely possible to create more advanced forms of visualization or logging through this method. For example, below we will collect the scores from each epoch then use polars to create a DataFrame and finally plot it with matplotlib.
 
     ```python
     class ScorePlotterHandler(rd.EventHandler):
@@ -278,7 +274,7 @@ For more complex event handling, you can create a custom event handler class:
 
     // Create and configure the engine
     let mut engine = GeneticEngine::builder()
-        .codec(your_codec)
+        .codec(FloatCodec::vector(6, -5.0..5.0))
         .subscribe(MyHandler)   // Add your handler here
         .fitness_fn(your_fitness_fn)
         // ... other parameters ...

docs/source/fitness.md

@@ -27,7 +27,7 @@ Simple fitness functions are the most common type - they take a phenotype and re
 
 !!! note ":fontawesome-brands-python: Python `numba`"
 
-    For python, In come cases (primarily if you are decoding to a `np.array`) it is possible to compile your fitness function down to native C using [numba](https://numba.pydata.org). 
+    For python, In some cases it is possible to compile your fitness function down to machine code using [numba](https://numba.pydata.org). 
     In most cases with this, this will result in your engine running as fast or almost as fast as rust. Check the examples page for an example using this method.
 
 === ":fontawesome-brands-python: Python"

examples/graphs/regression-graph/src/main.rs

@@ -25,9 +25,9 @@ fn main() {
         ))
         .build();
 
-    engine
+    radiate::ui(engine)
         .iter()
-        .logging()
+        // .logging()
         .until_score(MIN_SCORE)
         .last()
         .inspect(display);