Merge branch 'master' into compathelper/new_version/2025-01-05-01-23-24-852-00256837307

Author: MilesCranmer

Project.toml

@@ -1,7 +1,7 @@
 name = "DynamicExpressions"
 uuid = "a40a106e-89c9-4ca8-8020-a735e8728b6b"
 authors = ["MilesCranmer <miles.cranmer@gmail.com>"]
-version = "1.9.2"
+version = "1.9.4"
 
 [deps]
 ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4"

docs/src/eval.md

@@ -47,7 +47,7 @@ tree([1 2 3; 4 5 6.], operators)
 ```
 
 This is possible because when you call `OperatorEnum`, it automatically re-defines
-`(::Node)(X)` to call the evaluation operation with the given `operators loaded.
+`(::Node)(X)` to call the evaluation operation with the given `operators` loaded.
 It also re-defines `print`, `show`, and the various operators, to work with the `Node` type.
 
 !!! warning

src/DynamicExpressions.jl

@@ -69,7 +69,7 @@ import .NodeModule:
     get_scalar_constants,
     set_scalar_constants!
 @reexport import .StringsModule: string_tree, print_tree
-import .StringsModule: get_op_name
+import .StringsModule: get_op_name, get_pretty_op_name
 @reexport import .OperatorEnumModule: AbstractOperatorEnum
 @reexport import .OperatorEnumConstructionModule:
     OperatorEnum, GenericOperatorEnum, @extend_operators, set_default_variable_names!

src/ExpressionAlgebra.jl

@@ -154,7 +154,8 @@ end
 for op in (
     :*, :/, :+, :-, :^, :÷, :mod, :log,
     :atan, :atand, :copysign, :flipsign,
-    :&, :|, :⊻, ://, :\,
+    :&, :|, :⊻, ://, :\, :rem,
+    :(>), :(<), :(>=), :(<=), :max, :min,
 )
     @eval @declare_expression_operator Base.$(op) 2
 end

src/Strings.jl

@@ -4,19 +4,24 @@ using ..UtilsModule: deprecate_varmap
 using ..OperatorEnumModule: AbstractOperatorEnum
 using ..NodeModule: AbstractExpressionNode, tree_mapreduce
 
-function dispatch_op_name(::Val{deg}, ::Nothing, idx)::Vector{Char} where {deg}
-    if deg == 1
-        return vcat(collect("unary_operator["), collect(string(idx)), [']'])
-    else
-        return vcat(collect("binary_operator["), collect(string(idx)), [']'])
-    end
+function dispatch_op_name(
+    ::Val{deg}, ::Nothing, idx, pretty::Bool
+)::Vector{Char} where {deg}
+    return vcat(
+        collect(deg == 1 ? "unary_operator[" : "binary_operator["),
+        collect(string(idx)),
+        [']'],
+    )
 end
-function dispatch_op_name(::Val{deg}, operators::AbstractOperatorEnum, idx) where {deg}
-    if deg == 1
-        return collect(get_op_name(operators.unaops[idx])::String)
+function dispatch_op_name(
+    ::Val{deg}, operators::AbstractOperatorEnum, idx, pretty::Bool
+) where {deg}
+    op = if deg == 1
+        operators.unaops[idx]
     else
-        return collect(get_op_name(operators.binops[idx])::String)
+        operators.binops[idx]
     end
+    return collect((pretty ? get_pretty_op_name(op) : get_op_name(op))::String)
 end
 
 const OP_NAME_CACHE = (; x=Dict{UInt64,String}(), lock=Threads.SpinLock())
@@ -47,6 +52,9 @@ function get_op_name(op::F) where {F}
         unlock(OP_NAME_CACHE.lock)
     end
 end
+function get_pretty_op_name(op::F) where {F}
+    return get_op_name(op)
+end
 
 @inline function strip_brackets(s::Vector{Char})::Vector{Char}
     if first(s) == '(' && last(s) == ')'
@@ -82,7 +90,7 @@ end
 
 # Vector of chars is faster than strings, so we use that.
 function combine_op_with_inputs(op, l, r)::Vector{Char}
-    if first(op) in ('+', '-', '*', '/', '^', '.')
+    if first(op) in ('+', '-', '*', '/', '^', '.', '>', '<', '=') || op == "!="
         # "(l op r)"
         out = ['(']
         append!(out, l)
@@ -145,8 +153,9 @@ function string_tree(
     raw::Union{Bool,Nothing}=nothing,
     varMap=nothing,
 )::String where {T,F1<:Function,F2<:Function}
-    !isnothing(raw) &&
+    if !isnothing(raw)
         Base.depwarn("`raw` is deprecated; use `pretty` instead", :string_tree)
+    end
     pretty = @something(pretty, _not(raw), false)
     variable_names = deprecate_varmap(variable_names, varMap, :string_tree)
     raw_output = tree_mapreduce(
@@ -162,9 +171,9 @@ function string_tree(
         end,
         let operators = operators
             (branch,) -> if branch.degree == 1
-                dispatch_op_name(Val(1), operators, branch.op)::Vector{Char}
+                dispatch_op_name(Val(1), operators, branch.op, pretty)::Vector{Char}
             else
-                dispatch_op_name(Val(2), operators, branch.op)::Vector{Char}
+                dispatch_op_name(Val(2), operators, branch.op, pretty)::Vector{Char}
             end
         end,
         combine_op_with_inputs,

test/test_expressions.jl

@@ -454,3 +454,48 @@ end
     @test get_variable_names(new_ex2, nothing) == ["x1"]
     @test get_operators(new_ex2, nothing) == new_operators
 end
+
+@testitem "New binary operators" begin
+    using DynamicExpressions
+
+    operators = OperatorEnum(;
+        binary_operators=[+, -, *, /, >, <, >=, <=, max, min, rem],
+        unary_operators=[sin, cos],
+    )
+    x1, x2 = [Node(Float64; feature=i) for i in 1:2]
+
+    # Test comparison operators string representation
+    tree = x1 > x2
+    @test string(tree) == "x1 > x2"
+
+    tree = x1 < x2
+    @test string(tree) == "x1 < x2"
+
+    tree = x1 >= x2
+    @test string(tree) == "x1 >= x2"
+
+    tree = x1 <= x2
+    @test string(tree) == "x1 <= x2"
+
+    # Test max/min operators
+    tree = max(x1, x2)
+    X = [1.0 2.0; 3.0 1.0]'  # Two points: (1,3) and (2,1)
+    @test tree(X, operators) ≈ [2.0, 3.0]
+
+    tree = min(x1, x2)
+    @test tree(X, operators) ≈ [1.0, 1.0]
+
+    # Test remainder operator
+    tree = rem(x1, x2)
+    X = [5.0 7.0; 3.0 2.0]'  # Two points: (5,7) and (3,2)
+    @test tree(X, operators) ≈ [5.0, 1.0]
+
+    # Test combinations string representation
+    tree = max(x1, 2.0) > min(x2, 3.0)
+    @test string(tree) == "max(x1, 2.0) > min(x2, 3.0)"
+
+    # Test with constants
+    tree = rem(x1, 2.0)
+    X = [5.0 7.0]  # Two points: 5 and 7
+    @test tree(X, operators) ≈ [1.0, 1.0]
+end

test/test_print.jl

@@ -117,3 +117,61 @@ end
     @test string(tree) == "(k1 * x2) + x3"
     empty!(DynamicExpressions.OperatorEnumConstructionModule.LATEST_VARIABLE_NAMES.x)
 end
+
+@testset "Test pretty format for operators" begin
+    # Define a custom operator with different pretty representation
+    @eval begin
+        my_pretty_op(x, y) = x + y
+        DE.get_op_name(::typeof(my_pretty_op)) = "my_pretty_op"
+        DE.get_pretty_op_name(::typeof(my_pretty_op)) = "pretty_op_two"
+    end
+
+    operators = OperatorEnum(;
+        default_params...,
+        binary_operators=(+, *, /, -, my_pretty_op),
+        unary_operators=(cos, sin),
+    )
+    @extend_operators operators
+
+    x1, x2 = [Node(; feature=i) for i in 1:2]
+
+    # Test default format (not pretty)
+    tree = my_pretty_op(x1, x2)
+    @test string_tree(tree, operators) == "my_pretty_op(x1, x2)"
+
+    # Test pretty format
+    @test string_tree(tree, operators; pretty=true) == "pretty_op_two(x1, x2)"
+
+    # Test with nested expressions
+    tree = sin(my_pretty_op(x1, x2))
+    @test string_tree(tree, operators) == "sin(my_pretty_op(x1, x2))"
+    @test string_tree(tree, operators; pretty=true) == "sin(pretty_op_two(x1, x2))"
+
+    # Test with constants
+    tree = my_pretty_op(x1, Node(; val=3.14))
+    @test string_tree(tree, operators) == "my_pretty_op(x1, 3.14)"
+    @test string_tree(tree, operators; pretty=true) == "pretty_op_two(x1, 3.14)"
+
+    # Test that the default implementation of get_pretty_op_name falls back to get_op_name
+    tree = sin(x1)
+    @test string_tree(tree, operators) == "sin(x1)"
+    @test string_tree(tree, operators; pretty=true) == "sin(x1)"
+
+    # Test with a unary operator that has a different pretty name
+    @eval begin
+        my_unary_op(x) = sin(x)
+        DE.get_op_name(::typeof(my_unary_op)) = "my_unary_op"
+        DE.get_pretty_op_name(::typeof(my_unary_op)) = "sine"
+    end
+
+    operators_with_unary = OperatorEnum(;
+        default_params...,
+        binary_operators=(+, *, /, -),
+        unary_operators=(cos, sin, my_unary_op),
+    )
+    @extend_operators operators_with_unary
+
+    tree = my_unary_op(x1)
+    @test string_tree(tree, operators_with_unary) == "my_unary_op(x1)"
+    @test string_tree(tree, operators_with_unary; pretty=true) == "sine(x1)"
+end