Merge branch 'master' into dev

Author: MilesCranmer

Project.toml

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

README.md

@@ -30,8 +30,8 @@ using DynamicExpressions
 
 operators = OperatorEnum(; binary_operators=[+, -, *], unary_operators=[cos])
 
-x1 = Node(; feature=1)
-x2 = Node(; feature=2)
+x1 = Node{Float64}(feature=1)
+x2 = Node{Float64}(feature=2)
 
 expression = x1 * cos(x2 - 3.2)
 

docs/src/utils.md

@@ -1,11 +1,5 @@
 # Node utilities
 
-## Creating trees
-
-```@docs
-@parse_expression
-```
-
 ## `Base`
 
 Various functions in `Base` are overloaded to treat an `AbstractNode` as a

src/DynamicExpressions.jl

@@ -79,9 +79,17 @@ include("deprecated.jl")
 
 import TOML: parsefile
 
-const PACKAGE_VERSION = let
-    project = parsefile(joinpath(pkgdir(@__MODULE__), "Project.toml"))
-    VersionNumber(project["version"])
+const PACKAGE_VERSION = let d = pkgdir(@__MODULE__)
+    try
+        if d isa String
+            project = parsefile(joinpath(d, "Project.toml"))
+            VersionNumber(project["version"])
+        else
+            v"0.0.0"
+        end
+    catch
+        v"0.0.0"
+    end
 end
 
 # To get LanguageServer to register library within tests

src/EvaluateDerivative.jl

@@ -80,7 +80,9 @@ end
         end
     end
     deg2_branch = if nbin > OPERATOR_LIMIT_BEFORE_SLOWDOWN
-        diff_deg2_eval(tree, cX, operators.binops[op_idx], operators, direction)
+        quote
+            diff_deg2_eval(tree, cX, operators.binops[op_idx], operators, direction)
+        end
     else
         quote
             Base.Cartesian.@nif(

src/Expression.jl

@@ -28,7 +28,7 @@ end
 """
     AbstractExpression{T}
 
-Abstract type for user-facing expression types, which contain
+(Experimental) Abstract type for user-facing expression types, which contain
 both the raw expression tree operating on a value type of `T`,
 as well as associated metadata to evaluate and render the expression.
 
@@ -74,7 +74,7 @@ abstract type AbstractExpression{T} end
 """
     Expression{T, N, D} <: AbstractExpression{T}
 
-Defines a high level, user-facing, expression type that encapsulates an
+(Experimental) Defines a high-level, user-facing, expression type that encapsulates an
 expression tree (like `Node`) along with associated metadata for evaluation and rendering.
 
 # Fields
@@ -214,8 +214,8 @@ import ..NodeUtilsModule:
     set_constants!
 
 #! format: off
-count_constants(ex::AbstractExpression; kws...) = count_constants(get_tree(ex); kws...)
-count_depth(ex::AbstractExpression; kws...) = count_depth(get_tree(ex); kws...)
+count_constants(ex::AbstractExpression) = count_constants(get_tree(ex))
+count_depth(ex::AbstractExpression) = count_depth(get_tree(ex))
 index_constants(ex::AbstractExpression, ::Type{T}=UInt16) where {T} = index_constants(get_tree(ex), T)
 has_operators(ex::AbstractExpression) = has_operators(get_tree(ex))
 has_constants(ex::AbstractExpression) = has_constants(get_tree(ex))
@@ -311,14 +311,14 @@ end
 import ..SimplifyModule: combine_operators, simplify_tree!
 
 # Avoid implementing a generic version for these, as it is less likely to generalize
-function combine_operators(ex::Expression, operators=nothing; kws...)
+function combine_operators(ex::Expression, operators=nothing)
     return Expression(
-        combine_operators(get_tree(ex), get_operators(ex, operators); kws...), ex.metadata
+        combine_operators(get_tree(ex), get_operators(ex, operators)), ex.metadata
     )
 end
-function simplify_tree!(ex::Expression, operators=nothing; kws...)
+function simplify_tree!(ex::Expression, operators=nothing)
     return Expression(
-        simplify_tree!(get_tree(ex), get_operators(ex, operators); kws...), ex.metadata
+        simplify_tree!(get_tree(ex), get_operators(ex, operators)), ex.metadata
     )
 end
 

src/OperatorEnumConstruction.jl

@@ -84,7 +84,7 @@ function set_default_variable_names!(variable_names::Vector{String})
     return LATEST_VARIABLE_NAMES.x = copy(variable_names)
 end
 
-Base.@deprecate create_evaluation_helpers! set_default_operators!
+Base.@deprecate create_evaluation_helpers!(operators) set_default_operators!(operators)
 
 function set_default_operators!(operators::OperatorEnum)
     LATEST_OPERATORS.x = operators
@@ -374,7 +374,6 @@ redefine operators for `AbstractExpressionNode` types, as well as `show`, `print
     # Deprecated:
     enable_autodiff=nothing,
 )
-    @assert length(binary_operators) > 0 || length(unary_operators) > 0
     enable_autodiff !== nothing && Base.depwarn(
         "The option `enable_autodiff` has been deprecated. " *
         "Differential operators are now automatically computed within the gradient call.",

src/Parse.jl

@@ -4,25 +4,27 @@ using DispatchDoctor: @unstable
 
 using ..NodeModule: AbstractExpressionNode, Node, constructorof
 using ..OperatorEnumModule: AbstractOperatorEnum
-using ..OperatorEnumConstructionModule: empty_all_globals!
+using ..OperatorEnumConstructionModule: OperatorEnum, empty_all_globals!
 using ..ExpressionModule: AbstractExpression, Expression
 
 """
     @parse_expression(expr; operators, variable_names, node_type=Node, evaluate_on=[])
 
-Parse a symbolic expression `expr` into a computational graph where nodes represent operations or variables.
+(Experimental) Parse a symbolic expression `expr` into a computational graph where nodes represent operations or variables.
 
 ## Arguments
 
 - `expr`: An expression to parse into an `AbstractExpression`.
 
 ## Keyword Arguments
 
-- `operators`: An instance of `OperatorEnum` specifying the available unary and binary operators.
+- `operators`: An instance of `AbstractOperatorEnum` specifying the available unary and binary operators.
 - `variable_names`: A list of variable names as strings or symbols that are allowed in the expression.
 - `evaluate_on`: A list of external functions to evaluate explicitly when encountered.
 - `node_type`: The type of the nodes in the resulting expression tree. Defaults to `Node`.
 - `expression_type`: The type of the resulting expression. Defaults to `Expression`.
+- `binary_operators`: Convenience syntax for creating an `OperatorEnum`.
+- `unary_operators`: Convenience syntax for creating an `OperatorEnum`.
 
 ## Usage
 
@@ -105,6 +107,8 @@ end
     expression_type = Expression
     evaluate_on = nothing
     extra_metadata = ()
+    binops = nothing
+    unaops = nothing
 
     # Iterate over keyword arguments to extract operators and variable_names
     for kw in kws
@@ -127,6 +131,12 @@ end
             elseif kw == :extra_metadata
                 extra_metadata = kw
                 continue
+            elseif kw == :binary_operators
+                binops = kw
+                continue
+            elseif kw == :unary_operators
+                unaops = kw
+                continue
             end
         elseif kw isa Expr && kw.head == :(=)
             if kw.args[1] == :operators
@@ -147,6 +157,12 @@ end
             elseif kw.args[1] == :extra_metadata
                 extra_metadata = kw.args[2]
                 continue
+            elseif kw.args[1] == :binary_operators
+                binops = kw.args[2]
+                continue
+            elseif kw.args[1] == :unary_operators
+                unaops = kw.args[2]
+                continue
             end
         end
         throw(
@@ -156,8 +172,19 @@ end
         )
     end
 
-    # Ensure that operators are provided
-    @assert operators !== nothing "The 'operators' keyword argument must be provided."
+    if operators === nothing
+        @assert(
+            binops !== nothing || unaops !== nothing,
+            "You must specify the operators using either `operators`, or `binary_operators` and `unary_operators`"
+        )
+        operators = :($(OperatorEnum)(;
+            binary_operators=$(binops === nothing ? :(Function[]) : binops),
+            unary_operators=$(unaops === nothing ? :(Function[]) : unaops),
+        ))
+    else
+        @assert (binops === nothing && unaops === nothing)
+    end
+
     return (;
         operators, variable_names, node_type, expression_type, evaluate_on, extra_metadata
     )

src/deprecated.jl

@@ -1,8 +1,8 @@
 import Base: @deprecate
 import .NodeModule: Node, GraphNode
 
-@deprecate set_constants set_constants!
-@deprecate simplify_tree simplify_tree!
+@deprecate set_constants(tree, constants) set_constants!(tree, constants)
+@deprecate simplify_tree(tree, operators) simplify_tree!(tree, operators)
 
 for N in (:Node, :GraphNode)
     @eval begin

test/Project.toml

@@ -6,6 +6,7 @@ Compat = "34da2185-b29b-5c13-b0c7-acf172513d20"
 DispatchDoctor = "8d63f2c5-f18a-4cf2-ba9d-b3f60fc568c8"
 Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9"
 ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210"
+JET = "c3a54625-cd67-489e-a8e7-0a5a0ff4e31b"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 LoopVectorization = "bdcacae8-1622-11e9-2a5c-532679323890"
 Optim = "429524aa-4258-5aef-a3af-852621145aeb"