Add canonicalexpr to generate safe expressions for evaluations

Author: YingboMa

src/direct.jl

@@ -216,21 +216,38 @@ function sparsehessian(O, vars::AbstractVector; simplify = true)
 end
 
 function toexpr(O)
-    !istree(O) && return O
-    if isa(operation(O), Differential)
-        return :(derivative($(toexpr(arguments(O)[1])),$(toexpr(operation(O).x))))
-    elseif isa(operation(O), Sym)
-        isempty(arguments(O)) && return operation(O).name
-        return Expr(:call, toexpr(operation(O)), toexpr.(arguments(O))...)
+    canonical, O = canonicalexpr(O)
+    canonical && return O
+
+    op = operation(O)
+    args = arguments(O)
+    if op isa Differential
+        return :(derivative($(toexpr(args[1])),$(toexpr(op.x))))
+    elseif op isa Sym
+        isempty(args) && return nameof(op)
+        return Expr(:call, toexpr(op), toexpr.(args)...)
     end
-    if operation(O) === (^)
-        if length(arguments(O)) > 1  && arguments(O)[2] isa Number && arguments(O)[2] < 0
-            return Expr(:call, ^, Expr(:call, inv, toexpr(arguments(O)[1])), -(arguments(O)[2]))
+    return Expr(:call, op, toexpr.(args)...)
+end
+toexpr(s::Sym) = nameof(s)
+
+"""
+    canonicalexpr(O) -> (canonical::Bool, expr)
+
+Canonicalize `O`. Return `canonical` if `expr` is valid code to generate.
+"""
+function canonicalexpr(O)
+    !istree(O) && return true, O
+    op = operation(O)
+    args = arguments(O)
+    if op === (^)
+        if length(args) == 2 && args[2] isa Number && args[2] < 0
+            expr = Expr(:call, ^, Expr(:call, inv, toexpr(args[1])), -args[2])
+            return true, expr
         end
     end
-    return Expr(:call, operation(O), toexpr.(arguments(O))...)
+    return false, O
 end
-toexpr(s::Sym) = nameof(s)
 
 function toexpr(eq::Equation)
     Expr(:(=), toexpr(eq.lhs), toexpr(eq.rhs))

src/utils.jl

@@ -163,12 +163,15 @@ function states_to_sym(states::Set)
         if O isa Equation
             Expr(:(=), _states_to_sym(O.lhs), _states_to_sym(O.rhs))
         elseif istree(O)
-            if isa(operation(O), Sym)
+            op = operation(O)
+            args = arguments(O)
+            if op isa Sym
                 O in states && return tosymbol(O)
                 # dependent variables
-                return build_expr(:call, Any[operation(O).name; _states_to_sym.(arguments(O))])
+                return build_expr(:call, Any[nameof(op); _states_to_sym.(args)])
             else
-                return build_expr(:call, Any[operation(O); _states_to_sym.(arguments(O))])
+                canonical, O = canonicalexpr(O)
+                return canonical ? O : build_expr(:call, Any[op; _states_to_sym.(args)])
             end
         elseif O isa Num
             return _states_to_sym(value(O))

test/runtests.jl

@@ -1,6 +1,5 @@
 using SafeTestsets, Test
 
-#=
 @safetestset "Parsing Test" begin include("variable_parsing.jl") end
 @safetestset "Differentiation Test" begin include("derivatives.jl") end
 @safetestset "Simplify Test" begin include("simplify.jl") end
@@ -33,5 +32,4 @@ using SafeTestsets, Test
 @safetestset "Variable Utils Test" begin include("variable_utils.jl") end
 println("Last test requires gcc available in the path!")
 @safetestset "C Compilation Test" begin include("ccompile.jl") end
-=#
 @safetestset "Latexify recipes Test" begin include("latexify.jl") end