Merge pull request #618 from SciML/ys/makesym

More serious Symbol and makesym

Author: YingboMa

src/build_function.jl

@@ -458,27 +458,12 @@ end
 
 vars_to_pairs(args) = vars_to_pairs(args[1],args[2])
 function vars_to_pairs(name,vs::AbstractArray)
-    vs_names = [term_to_symbol(value(u)) for u ∈ vs]
-	exs = [:($name[$i]) for (i, u) ∈ enumerate(vs)]
-	vs_names,exs
+    vs_names = [tosymbol(u) for u ∈ vs]
+    exs = [:($name[$i]) for (i, u) ∈ enumerate(vs)]
+    vs_names,exs
 end
-
-function term_to_symbol(t::Term)
-    if operation(t) isa Sym
-        s = nameof(operation(t))
-    else
-        error("really?")
-    end
-end
-
-term_to_symbol(s::Sym) = nameof(s)
-
 function vars_to_pairs(name,vs)
-    [term_to_symbol(value(vs))], [name]
-end
-
-function rm_calls_with_iv(expr)
-    Rewriters.Prewalk(Rewriters.Chain([@rule((~f::(x->x isa Sym))(~t::(x->x isa Sym)) => Sym{symtype((~f)(~t))}((term_to_symbol(~f))))]))(value(expr))
+    [tosymbol(vs)], [name]
 end
 
 get_varnumber(varop, vars::Vector) =  findfirst(x->isequal(x,varop),vars)
@@ -494,7 +479,7 @@ function numbered_expr(O::Union{Term,Sym},args...;varordering = args[1],offset =
 		end
 	end
   end
-  return Expr(:call, O isa Sym ? nameof(O) : Symbol(O.op),
+  return Expr(:call, O isa Sym ? tosymbol(O, escape=false) : Symbol(O.op),
          [numbered_expr(x,args...;offset=offset,lhsname=lhsname,
                         rhsnames=rhsnames,varordering=varordering) for x in O.args]...)
 end
@@ -504,7 +489,7 @@ function numbered_expr(de::ModelingToolkit.Equation,args...;varordering = args[1
 
     varordering = value.(args[1])
     var = var_from_nested_derivative(de.lhs)[1]
-    i = findfirst(x->isequal(x isa Sym ? term_to_symbol(x) : term_to_symbol(x.op),term_to_symbol(var)),varordering)
+    i = findfirst(x->isequal(tosymbol(x isa Sym ? x : x.op, escape=false), tosymbol(var, escape=false)),varordering)
     :($lhsname[$(i+offset)] = $(numbered_expr(de.rhs,args...;offset=offset,
 											  varordering = varordering,
 											  lhsname = lhsname,

src/systems/control/controlsystem.jl

@@ -91,8 +91,8 @@ end
 ControlToExpr(@nospecialize(sys)) = ControlToExpr(sys,states(sys),controls(sys))
 function (f::ControlToExpr)(O::Term)
     res = if isa(O.op, Sym)
-        any(isequal(O), f.states)         && return O.op.name  # dependent variables
-        any(isequal(O), f.controls)       && return O.op.name  # control variables
+        # normal variables and control variables
+        (any(isequal(O), f.states) || any(isequal(O), f.controls)) && return tosymbol(O)
         build_expr(:call, Any[O.op.name; f.(O.args)])
     else
         build_expr(:call, Any[Symbol(O.op); f.(O.args)])

src/systems/diffeqs/abstractodesystem.jl

@@ -11,6 +11,9 @@ function calculate_tgrad(sys::AbstractODESystem;
   if simplify
       tgrad = ModelingToolkit.simplify.(notime_tgrad)
   end
+  xs = states(sys)
+  rule = Dict(map((x, xt) -> x=>xt, detime_dvs.(xs), xs))
+  tgrad = substitute.(tgrad, Ref(rule))
   sys.tgrad[] = tgrad
   return tgrad
 end
@@ -41,7 +44,8 @@ ODEToExpr(@nospecialize(sys)) = ODEToExpr(sys,states(sys))
 (f::ODEToExpr)(O::Num) = f(value(O))
 function (f::ODEToExpr)(O::Term)
     if isa(O.op, Sym)
-        any(isequal(O), f.states) && return O.op.name  # dependent variables
+        any(isequal(O), f.states) && return tosymbol(O)
+        # dependent variables
         return build_expr(:call, Any[O.op.name; f.(O.args)])
     end
     return build_expr(:call, Any[O.op; f.(O.args)])
@@ -64,18 +68,49 @@ function generate_jacobian(sys::AbstractODESystem, dvs = states(sys), ps = param
                           conv = ODEToExpr(sys), kwargs...)
 end
 
-function makesym(t::Term{T}) where {T}
-    t.op isa Sym && return makesym(t.op)
-    t.op isa Differential && return Sym{T}(Symbol(nameof(makesym(t.args[1])), :ˍ, nameof(makesym(t.op.x))))
+Base.Symbol(x::Union{Num,Symbolic}) = tosymbol(x)
+tosymbol(x; kwargs...) = x
+tosymbol(x::Sym; kwargs...) = nameof(x)
+tosymbol(t::Num; kwargs...) = tosymbol(value(t); kwargs...)
+
+"""
+    tosymbol(x::Union{Num,Symbolic}; states=nothing, escape=true) -> Symbol
+
+Convert `x` to a symbol. `states` are the states of a system, and `escape`
+means if the target has escapes like `val"y⦗t⦘"`. If `escape` then it will only
+output `y` instead of `y⦗t⦘`.
+"""
+function tosymbol(t::Term; states=nothing, escape=true)
+    if t.op isa Sym
+        if states !== nothing && !(any(isequal(t), states))
+            return nameof(t.op)
+        end
+        op = nameof(t.op)
+        args = t.args
+    elseif t.op isa Differential
+        if !(t.args[1].op isa Sym)
+            @goto err
+        end
+        op = Symbol(nameof(t.args[1].op),
+                    :ˍ,
+                    tosymbol(t.op.x))
+        args = t.args[1].args
+    else
+        @goto err
+    end
+
+    return escape ? Symbol(op, "⦗", join(args, ", "), "⦘") : op
+    @label err
     error("Cannot convert $t to a symbol")
 end
-makesym(t::Sym{T}) where {T} = t
-makesym(t::Sym{FnType{T, S}}) where {T,S} = Sym{S}(nameof(t))
+
+makesym(t::Symbolic; kwargs...) = Sym{symtype(t)}(tosymbol(t; kwargs...))
+makesym(t::Num; kwargs...) = makesym(value(t); kwargs...)
 
 function generate_function(sys::AbstractODESystem, dvs = states(sys), ps = parameters(sys); kwargs...)
     # optimization
-    dvs′ = makesym.(value.(dvs))
-    ps′ = makesym.(value.(ps))
+    dvs′ = makesym.(value.(dvs), states=dvs)
+    ps′ = makesym.(value.(ps), states=dvs)
 
     sub = Dict(dvs .=> dvs′)
     # substitute x(t) by just x
@@ -90,7 +125,7 @@ function calculate_massmatrix(sys::AbstractODESystem; simplify=true)
     M = zeros(length(eqs),length(eqs))
     for (i,eq) in enumerate(eqs)
         if eq.lhs isa Term && eq.lhs.op isa Differential
-            j = findfirst(x->isequal(term_to_symbol(x),term_to_symbol(var_from_nested_derivative(eq.lhs)[1])),dvs)
+            j = findfirst(x->isequal(tosymbol(x),tosymbol(var_from_nested_derivative(eq.lhs)[1])),dvs)
             M[i,j] = 1
         else
             eq.lhs == 0 || error("Only semi-explicit constant mass matrices are currently supported. Faulty equation: $eq.")

src/utils.jl

@@ -125,7 +125,8 @@ function states_to_sym(states::Set)
             Expr(:(=), _states_to_sym(O.lhs), _states_to_sym(O.rhs))
         elseif O isa Term
             if isa(O.op, Sym)
-                O in states && return O.op.name  # dependent variables
+                O in states && return tosymbol(O)
+                # dependent variables
                 return build_expr(:call, Any[O.op.name; _states_to_sym.(O.args)])
             else
                 return build_expr(:call, Any[O.op; _states_to_sym.(O.args)])

test/derivatives.jl

@@ -97,7 +97,7 @@ t1 = ModelingToolkit.gradient(tmp, [x1, x2])
 @parameters t k
 @variables x(t)
 @derivatives D'~k
-@test ModelingToolkit.makesym(D(x).val).name === :xˍk
+@test ModelingToolkit.makesym(D(x).val).name === Symbol("xˍk⦗t⦘")
 
 using ModelingToolkit
 @variables t x(t)

test/odesystem.jl

@@ -145,6 +145,7 @@ eqs = [D(x) ~ -A*x,
        D(y) ~ A*x - B*_x]
 de = ODESystem(eqs)
 @test begin
+    local f
     f = eval(generate_function(de, [x,y], [A,B,C])[2])
     du = [0.0,0.0]
     f(du, [1.0,2.0], [1,2,3], 0.0)