Merge pull request #34 from astroautomata/cleaner-operator-syntax

feat!: cleaner operator syntax

Author: MilesCranmer

README.md

@@ -64,8 +64,7 @@ fn main() {
 
     let dataset = Dataset::new(x, y);
 
-    let operators = Operators::<D>::from_names_by_arity::<BuiltinOpsF32>(&["cos", "exp", "sin"], &["+", "-", "*", "/"], &[])
-        .unwrap();
+    let operators = BuiltinOpsF32::from_names(["cos", "exp", "sin", "+", "sub", "*", "/"]).unwrap();
 
     let options = Options::<f32, D> {
         operators,
@@ -99,42 +98,46 @@ fn main() {
 
 ## Custom operators
 
-Define light-weight operator sets with inline evaluation and derivatives using the `custom_opset!` macro (re-exported from `symbolic_regression`):
+Define custom operators with `op!`, then build an operator set with `opset!`:
 
 ```rust
-use symbolic_regression::custom_opset;
 use symbolic_regression::prelude::*;
 
-custom_opset! {
-    pub struct CustomOps<f64> {
-        1 {
-            square {
-                eval(args) { args[0] * args[0] },
-                partial(args, _idx) { 2.0 * args[0] },
-            }
-            exp {
-                eval(args) { args[0].exp() },
-                partial(args, _idx) { args[0].exp() },
-            }
-        }
-        2 {
-            add {
-                eval(args) { args[0] + args[1] },
-                partial(_args, _idx) { 1.0 },
-            }
-            sub {
-                infix: "-",    // optional
-                complexity: 2, // optional
-                eval(args) { args[0] - args[1] },
-                partial(_args, idx) {
-                    if idx == 0 { 1.0 } else { -1.0 }
-                },
-            }
-        }
+op!(Square for f64 {
+    eval: |[x]| { x * x },
+    partial: |[x], _idx| { 2.0 * x },
+});
+
+op!(Exp for f64 {
+    eval: |[x]| { x.exp() },
+    partial: |[x], _idx| { x.exp() },
+});
+
+op!(Add for f64 {
+    infix: "+",
+    commutative: true,
+    associative: true,
+    eval: |[x, y]| { x + y },
+    partial: |[_x, _y], _idx| { 1.0 },
+});
+
+op!(Sub for f64 {
+    infix: "-",    // optional
+    complexity: 2, // optional
+    eval: |[x, y]| { x - y },
+    partial: |[_x, _y], idx| { if idx == 0 { 1.0 } else { -1.0 } },
+});
+
+opset! {
+    pub CustomOps for f64 {
+        Square,
+        Exp,
+        Add,
+        Sub,
     }
 }
 
-let operators = CustomOps::from_names_by_arity(&["square", "exp"], &["add", "sub"], &[]).unwrap();
+let operators = CustomOps::from_names(["square", "exp", "add", "sub"]).unwrap();
 let options = Options::<f64, _> { operators, ..Default::default() };
 ```
 

dynamic_expressions/benches/eval.rs

@@ -2,6 +2,7 @@ use criterion::{criterion_group, criterion_main};
 use dynamic_expressions::evaluate::EvalOptions;
 use dynamic_expressions::expression::PostfixExpr;
 use dynamic_expressions::node::PNode;
+use dynamic_expressions::operator_enum::builtin::*;
 use dynamic_expressions::{OperatorSet, opset};
 use ndarray::Array2;
 use num_traits::Float;
@@ -14,19 +15,11 @@ const N_TREES: usize = 100;
 const N_ROWS: usize = 1_000;
 
 opset! {
-    pub struct BenchOpsF32<f32>;
-    ops {
-        (1, UnaryF32) { Cos, Exp, }
-        (2, BinaryF32) { Add, Sub, Mul, Div, }
-    }
+    pub BenchOpsF32 for f32 { Cos, Exp, Add, Sub, Mul, Div }
 }
 
 opset! {
-    pub struct BenchOpsF64<f64>;
-    ops {
-        (1, UnaryF64) { Cos, Exp, }
-        (2, BinaryF64) { Add, Sub, Mul, Div, }
-    }
+    pub BenchOpsF64 for f64 { Cos, Exp, Add, Sub, Mul, Div }
 }
 
 fn random_leaf<T: Float, R: Rng>(rng: &mut R, n_features: usize, consts: &mut Vec<T>) -> PNode {

dynamic_expressions/src/lib.rs

@@ -12,6 +12,7 @@ pub mod operator_enum;
 pub mod operators;
 #[cfg(feature = "proptest-utils")]
 pub mod proptest_utils;
+pub mod select;
 pub mod simplify;
 pub mod strings;
 pub mod traits;
@@ -31,6 +32,7 @@ pub use crate::node_utils::{
     count_constant_nodes, count_depth, count_nodes, has_constants, has_operators, subtree_range, subtree_sizes,
     tree_mapreduce,
 };
+pub use crate::select::{OperatorSelectError, Operators};
 pub use crate::simplify::{combine_operators_in_place, simplify_in_place, simplify_tree_in_place};
 pub use crate::strings::{StringTreeOptions, print_tree, string_tree};
 pub use crate::traits::{HasOp, LookupError, OpId, OpMeta, OpTag, Operator, OperatorSet};