Merge branch 'develop'

Author: pkalivas

Cargo.toml

@@ -63,8 +63,8 @@ homepage = "https://pkalivas.github.io/radiate/"
 
 [workspace.dependencies]
 rand = "0.9.2"
-pyo3 = "0.26.0"
-numpy ="0.26.0"
+pyo3 = "0.27.1"
+numpy ="0.27.0"
 rayon = "1.11.0"
 serde = { version = "1.0.228", features = ["derive"] }
 serde_json = { version = "1.0.143" }

crates/radiate-core/src/evaluator.rs

@@ -267,7 +267,6 @@ where
             }
         }
 
-        // integer ceiling division to determine batch size - number of individuals per batch
         let num_workers = self.executor.num_workers();
         let batch_size = (pairs.len() + num_workers - 1) / num_workers;
 
@@ -305,7 +304,6 @@ where
                 .collect(),
         );
 
-        // replace the genotypes and add their associated scores
         let mut count = 0;
         for (indices, scores, genotypes) in results {
             count += indices.len();

crates/radiate-core/src/genome/chromosomes/bit.rs

@@ -24,7 +24,7 @@ use std::fmt::{Debug, Display};
 /// let gene = gene.with_allele(allele);
 /// ```
 ///
-#[derive(Clone, PartialEq, Debug)]
+#[derive(Clone, PartialEq, Debug, Default)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct BitGene {
     allele: bool,
@@ -65,12 +65,6 @@ impl Gene for BitGene {
 /// Because a [`BitGene`] is either `true` or `false` it is always valid.
 impl Valid for BitGene {}
 
-impl Default for BitGene {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
 impl Display for BitGene {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}", if self.allele { 1 } else { 0 })

crates/radiate-engines/src/builder/evaluators.rs

@@ -24,6 +24,11 @@ where
         self
     }
 
+    #[cfg(feature = "rayon")]
+    pub fn parallel(self) -> Self {
+        self.executor(Executor::WorkerPool)
+    }
+
     pub fn executor(mut self, executor: Executor) -> Self {
         let executor = Arc::new(executor);
         self.params.evaluation_params = EvaluationParams {

crates/radiate-engines/src/builder/objectives.rs

@@ -26,8 +26,11 @@ where
         self
     }
 
-    pub fn multi_objective(mut self, objectives: Vec<Optimize>) -> GeneticEngineBuilder<C, T> {
-        self.params.optimization_params.objectives = Objective::Multi(objectives);
+    pub fn multi_objective(
+        mut self,
+        objectives: impl Into<Vec<Optimize>>,
+    ) -> GeneticEngineBuilder<C, T> {
+        self.params.optimization_params.objectives = Objective::Multi(objectives.into());
         self
     }
 

crates/radiate-gp/src/collections/eval.rs

@@ -0,0 +1,49 @@
+/// [Eval] trait is used to evaluate a [Tree] or [Graph] of node's.
+/// It is implemented directly on the GP structures to allow for easy and dynamic
+/// evaluation of the structures with a given input.
+///
+/// The [Eval] trait and subsequent method is used to transform the `Input` into
+/// the `Output`. This is extremely useful for evaluating the [Graph] or [Tree] with a given input
+/// as traversing each can be very slow or sometimes cumbersome to do manually.
+///
+/// # Example
+/// ```rust
+/// use radiate_gp::{Op, Eval, TreeNode};
+///
+/// let root = TreeNode::new(Op::add())
+///     .attach(
+///         TreeNode::new(Op::mul())
+///             .attach(TreeNode::new(Op::constant(2.0)))
+///             .attach(TreeNode::new(Op::constant(3.0))),
+///     )
+///     .attach(
+///         TreeNode::new(Op::add())
+///             .attach(TreeNode::new(Op::constant(2.0)))
+///             .attach(TreeNode::new(Op::var(0))),
+///     );
+///
+/// // And the result of evaluating this tree with an input of `1` would be:
+/// let result = root.eval(&vec![1_f32]);
+/// assert_eq!(result, 9.0);
+/// ```
+/// This creates a `Tree` that looks like:
+/// ```text
+///      +
+///    /   \
+///   *     +
+///  / \   / \
+/// 2  3  2   x
+/// ```
+/// Where `x` is the first variable in the input.
+///
+/// This can also be thought of (and is functionally equivalent) as:
+/// ```text
+/// f(x) = (2 * 3) + (2 + x)
+/// ```
+pub trait Eval<I: ?Sized, O> {
+    fn eval(&self, input: &I) -> O;
+}
+
+pub trait EvalMut<I: ?Sized, O> {
+    fn eval_mut(&mut self, input: &I) -> O;
+}

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

@@ -40,6 +40,7 @@ where
     ///
     /// # Arguments
     /// * graph - The [Graph] to reduce.
+    #[inline]
     pub fn new<N>(graph: &'a N) -> GraphEvaluator<'a, T, V>
     where
         N: AsRef<[GraphNode<T>]>,

crates/radiate-gp/src/collections/mod.rs

@@ -1,4 +1,5 @@
 pub mod dot;
+pub mod eval;
 pub mod factory;
 pub mod format;
 pub mod graphs;
@@ -7,6 +8,7 @@ pub mod store;
 pub mod trees;
 
 pub use dot::ToDot;
+pub use eval::{Eval, EvalMut};
 pub use factory::*;
 pub use format::*;
 pub use graphs::{
@@ -18,62 +20,3 @@ pub use store::{NodeStore, NodeValue};
 pub use trees::{
     HoistMutator, Tree, TreeChromosome, TreeCodec, TreeCrossover, TreeIterator, TreeNode,
 };
-/// [Eval] trait is used to evaluate a [Tree] or [Graph] of node's.
-/// It is implemented directly on the [Tree] and [TreeNode] types as well as
-/// on the [GraphEvaluator] struct.
-///
-/// The [Eval] trait and subsequent method is used to transform the `Input` into
-/// the `Output`. This is extremely useful for evaluating the [Graph] or [Tree] with a given input
-/// as traversing each can be very slow or sometimes cumbersome to do manually.
-///
-/// # Example
-/// ```rust
-/// use radiate_gp::{Op, Eval, TreeNode};
-///
-/// let root = TreeNode::new(Op::add())
-///     .attach(
-///         TreeNode::new(Op::mul())
-///             .attach(TreeNode::new(Op::constant(2.0)))
-///             .attach(TreeNode::new(Op::constant(3.0))),
-///     )
-///     .attach(
-///         TreeNode::new(Op::add())
-///             .attach(TreeNode::new(Op::constant(2.0)))
-///             .attach(TreeNode::new(Op::var(0))),
-///     );
-///
-/// // And the result of evaluating this tree with an input of `1` would be:
-/// let result = root.eval(&vec![1_f32]);
-/// assert_eq!(result, 9.0);
-/// ```
-/// This creates a `Tree` that looks like:
-/// ```text
-///      +
-///    /   \
-///   *     +
-///  / \   / \
-/// 2  3  2   x
-/// ```
-/// Where `x` is the first variable in the input.
-///
-/// This can also be thought of (and is functionally equivalent) as:
-/// ```text
-/// f(x) = (2 * 3) + (2 + x)
-/// ```
-pub trait Eval<I: ?Sized, O> {
-    fn eval(&self, input: &I) -> O;
-}
-
-pub trait EvalMut<I: ?Sized, O> {
-    fn eval_mut(&mut self, input: &I) -> O;
-}
-
-impl<I, O, T> EvalMut<I, O> for T
-where
-    I: ?Sized,
-    T: Eval<I, O>,
-{
-    fn eval_mut(&mut self, input: &I) -> O {
-        self.eval(input)
-    }
-}

crates/radiate-gp/src/collections/trees/eval.rs

@@ -1,5 +1,40 @@
 use super::Tree;
-use crate::{Eval, TreeNode, node::Node};
+use crate::{Eval, EvalMut, TreeNode, node::Node};
+
+/// Implements the [Eval] trait for [`Tree<T>`] where `T` is `Eval<[V], V>`. All this really does is
+/// call the `eval` method on the root node of the [Tree]. The real work is
+/// done in the [TreeNode] implementation below.
+impl<T, V> Eval<[V], V> for Tree<T>
+where
+    T: Eval<[V], V>,
+    V: Clone,
+{
+    #[inline]
+    fn eval(&self, input: &[V]) -> V {
+        self.root()
+            .map(|root| root.eval(input))
+            .unwrap_or_else(|| panic!("Tree has no root node."))
+    }
+}
+
+/// Implements the [EvalMut] trait for [`Tree<T>`] where `T` is `Eval<[V], V>`. This is primarily just a simple
+/// implementation to satisfy the [regression](crate::regression) use-case where we want to evaluate
+/// a `Tree` and return a `Vec` of results. Since a [`Tree<T>`] only has a single root node, we return
+/// a `Vec` with a single element. All it really does is call the `eval` method on the root node of the [Tree].
+impl<T, V> EvalMut<[V], Vec<V>> for Tree<T>
+where
+    T: Eval<[V], V>,
+    V: Clone,
+{
+    #[inline]
+    fn eval_mut(&mut self, input: &[V]) -> Vec<V> {
+        vec![
+            self.root()
+                .map(|root| root.eval(input))
+                .unwrap_or_else(|| panic!("Tree has no root node.")),
+        ]
+    }
+}
 
 /// Implements the [Eval] trait for `Vec<Tree<T>>`. This is a wrapper around a `Vec<Tree<T>>`
 /// and allows for the evaluation of each [Tree] in the `Vec` with a single input.
@@ -17,33 +52,35 @@ where
     }
 }
 
-/// Implements the [Eval] trait for `Vec<&TreeNode<T>>`. This is a wrapper around a `Vec<&TreeNode<T>>`
-/// and allows for the evaluation of each [TreeNode] in the `Vec` with a single input.
-/// The len of the input slice must equal the number of nodes in the `Vec`.
-impl<T, V> Eval<[V], Vec<V>> for Vec<&TreeNode<T>>
+/// Implements the [EvalMut] trait for `Vec<Tree<T>>`. This is a wrapper around a `Vec<Tree<T>>`
+/// and allows for the evaluation of each [Tree] in the `Vec` with a single input.
+/// This is useful for things like `Ensemble` models where multiple models are used to make a prediction.
+///
+/// This is a simple implementation that just maps over the `Vec` and calls [Eval] on each [Tree]. Just like
+/// the implementation of [`EvalMut<[V], Vec<V>>`] for [`Tree<T>`] above, this is primarily to satisfy the
+/// [regression](crate::regression) use-case.
+impl<T, V> EvalMut<[V], Vec<V>> for Vec<Tree<T>>
 where
     T: Eval<[V], V>,
     V: Clone,
 {
     #[inline]
-    fn eval(&self, inputs: &[V]) -> Vec<V> {
-        self.iter().map(|node| node.eval(inputs)).collect()
+    fn eval_mut(&mut self, inputs: &[V]) -> Vec<V> {
+        self.iter_mut().map(|tree| tree.eval(inputs)).collect()
     }
 }
 
-/// Implements the [Eval] trait for [`Tree<T>`] where `T` is `Eval<[V], V>`. All this really does is
-/// call the `eval` method on the root node of the [Tree]. The real work is
-/// done in the [TreeNode] implementation below.
-impl<T, V> Eval<[V], V> for Tree<T>
+/// Implements the [Eval] trait for `Vec<&TreeNode<T>>`. This is a wrapper around a `Vec<&TreeNode<T>>`
+/// and allows for the evaluation of each [TreeNode] in the `Vec` with a single input.
+/// The len of the input slice must equal the number of nodes in the `Vec`.
+impl<T, V> Eval<[V], Vec<V>> for Vec<&TreeNode<T>>
 where
     T: Eval<[V], V>,
     V: Clone,
 {
     #[inline]
-    fn eval(&self, input: &[V]) -> V {
-        self.root()
-            .map(|root| root.eval(input))
-            .unwrap_or_else(|| panic!("Tree has no root node."))
+    fn eval(&self, inputs: &[V]) -> Vec<V> {
+        self.iter().map(|node| node.eval(inputs)).collect()
     }
 }
 

crates/radiate-gp/src/collections/trees/node.rs

@@ -22,19 +22,26 @@ use std::fmt::Debug;
 ///
 /// # Examples
 /// ```
-/// use radiate_gp::{collections::{TreeNode}, Arity};
+/// 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]
@@ -341,6 +348,18 @@ impl<T: Debug> Debug for TreeNode<T> {
     }
 }
 
+impl<T> From<(T, Arity)> for TreeNode<T> {
+    fn from(value: (T, Arity)) -> Self {
+        TreeNode::with_arity(value.0, value.1)
+    }
+}
+
+impl<T> From<(T, Vec<TreeNode<T>>)> for TreeNode<T> {
+    fn from(value: (T, Vec<TreeNode<T>>)) -> Self {
+        TreeNode::with_children(value.0, value.1)
+    }
+}
+
 macro_rules! impl_from {
     ($($t:ty),+) => {
         $(