move util function to src/utils.jl and handle high order diff to symbol

Author: YingboMa

src/systems/diffeqs/abstractodesystem.jl

@@ -68,45 +68,6 @@ function generate_jacobian(sys::AbstractODESystem, dvs = states(sys), ps = param
                           conv = ODEToExpr(sys), kwargs...)
 end
 
-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::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), states=dvs)

src/systems/diffeqs/first_order_transform.jl

@@ -1,24 +1,3 @@
-function lower_varname(var::Term, idv, order)
-    order == 0 && return var
-    name = Symbol(nameof(var.op), :ˍ, string(idv)^order)
-    #name = Symbol(var.name, :ˍ, string(idv.name)^order)
-    return Sym{symtype(var.op)}(name)(var.args[1])
-end
-
-function lower_varname(t::Term, iv)
-    var, order = var_from_nested_derivative(t)
-    lower_varname(var, iv, order)
-end
-lower_varname(t::Sym, iv) = t
-
-function flatten_differential(O::Term)
-    @assert is_derivative(O) "invalid differential: $O"
-    is_derivative(O.args[1]) || return (O.args[1], O.op.x, 1)
-    (x, t, order) = flatten_differential(O.args[1])
-    isequal(t, O.op.x) || throw(ArgumentError("non-matching differentials on lhs: $t, $(O.op.x)"))
-    return (x, t, order + 1)
-end
-
 """
 $(TYPEDSIGNATURES)
 
@@ -47,7 +26,7 @@ function ode_order_lowering(eqs, iv, states)
             # only save to the dict when we need to lower the order to save memory
             maxorder > get(var_order, var, 1) && (var_order[var] = maxorder)
             var′ = lower_varname(var, iv, maxorder - 1)
-            rhs′ = rename_lower_order(eq.rhs)
+            rhs′ = diff2symbol(eq.rhs)
             push!(diff_vars, var′)
             push!(diff_eqs, D(var′) ~ rhs′)
         end
@@ -68,12 +47,3 @@ function ode_order_lowering(eqs, iv, states)
     # we want to order the equations and variables to be `(diff, alge)`
     return (vcat(diff_eqs, alge_eqs), vcat(diff_vars, alge_vars))
 end
-
-function rename_lower_order(O)
-    isa(O, Term) || return O
-    if is_derivative(O)
-        (x, t, order) = flatten_differential(O)
-        return lower_varname(x, t, order)
-    end
-    return Term(O.op, rename_lower_order.(O.args))
-end

src/utils.jl

@@ -155,3 +155,67 @@ Maps the variable to a variable (state).
 """
 tovar(s::Sym{<:Parameter}) = Sym{symtype(s)}(s.name)
 tovar(s::Sym) = s
+
+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
+        term = diff2symbol(t)
+        op = Symbol(operation(term))
+        args = arguments(term)
+    else
+        @goto err
+    end
+
+    return escape ? Symbol(op, "⦗", join(args, ", "), "⦘") : op
+    @label err
+    error("Cannot convert $t to a symbol")
+end
+
+makesym(t::Symbolic; kwargs...) = Sym{symtype(t)}(tosymbol(t; kwargs...))
+makesym(t::Num; kwargs...) = makesym(value(t); kwargs...)
+
+function lower_varname(var::Term, idv, order)
+    order == 0 && return var
+    name = Symbol(nameof(var.op), :ˍ, string(idv)^order)
+    return Sym{symtype(var.op)}(name)(var.args[1])
+end
+
+function lower_varname(t::Term, iv)
+    var, order = var_from_nested_derivative(t)
+    lower_varname(var, iv, order)
+end
+lower_varname(t::Sym, iv) = t
+
+function flatten_differential(O::Term)
+    @assert is_derivative(O) "invalid differential: $O"
+    is_derivative(O.args[1]) || return (O.args[1], O.op.x, 1)
+    (x, t, order) = flatten_differential(O.args[1])
+    isequal(t, O.op.x) || throw(ArgumentError("non-matching differentials on lhs: $t, $(O.op.x)"))
+    return (x, t, order + 1)
+end
+
+function diff2symbol(O)
+    isa(O, Term) || return O
+    if is_derivative(O)
+        (x, t, order) = flatten_differential(O)
+        return lower_varname(x, t, order)
+    end
+    return Term(O.op, diff2symbol.(O.args))
+end