.op -> operation; .args -> arguments

shashi · YingboMa · shashi · commit f8279d872901 · 2021-01-05T21:15:16.000-05:00
Co-authored-by: "Yingbo Ma" &lt;mayingbo5@gmail.com&gt;
diff --git a/src/build_function.jl b/src/build_function.jl
@@ -479,25 +479,25 @@ get_varnumber(varop, vars::Vector) =  findfirst(x->isequal(x,varop),vars)
 function numbered_expr(O::Union{Term,Sym},args...;varordering = args[1],offset = 0,
                        lhsname=gensym("du"),rhsnames=[gensym("MTK") for i in 1:length(args)])
     O = value(O)
-  if O isa Sym || isa(O.op, Sym)
+  if O isa Sym || isa(operation(O), Sym)
 	for j in 1:length(args)
 		i = get_varnumber(O,args[j])
 		if i !== nothing
 			return :($(rhsnames[j])[$(i+offset)])
 		end
 	end
   end
-  return Expr(:call, O isa Sym ? tosymbol(O, escape=false) : Symbol(O.op),
+  return Expr(:call, O isa Sym ? tosymbol(O, escape=false) : Symbol(operation(O)),
          [numbered_expr(x,args...;offset=offset,lhsname=lhsname,
-                        rhsnames=rhsnames,varordering=varordering) for x in O.args]...)
+                        rhsnames=rhsnames,varordering=varordering) for x in arguments(O)]...)
 end
 
 function numbered_expr(de::ModelingToolkit.Equation,args...;varordering = args[1],
                        lhsname=gensym("du"),rhsnames=[gensym("MTK") for i in 1:length(args)],offset=0)
 
     varordering = value.(args[1])
     var = var_from_nested_derivative(de.lhs)[1]
-    i = findfirst(x->isequal(tosymbol(x isa Sym ? x : x.op, escape=false), tosymbol(var, escape=false)),varordering)
+    i = findfirst(x->isequal(tosymbol(x isa Sym ? x : operation(x), escape=false), tosymbol(var, escape=false)),varordering)
     :($lhsname[$(i+offset)] = $(numbered_expr(de.rhs,args...;offset=offset,
 											  varordering = varordering,
 											  lhsname = lhsname,
diff --git a/src/differentials.jl b/src/differentials.jl
@@ -35,13 +35,13 @@ Base.show(io::IO, D::Differential) = print(io, "(D'~", D.x, ")")
 Base.:(==)(D1::Differential, D2::Differential) = isequal(D1.x, D2.x)
 
 _isfalse(occ::Bool) = occ === false
-_isfalse(occ::Term) = _isfalse(occ.op)
+_isfalse(occ::Term) = _isfalse(operation(occ))
 
 function occursin_info(x, expr::Term)
     if isequal(x, expr)
         true
     else
-        args = map(a->occursin_info(x, a), expr.args)
+        args = map(a->occursin_info(x, a), arguments(expr))
         if all(_isfalse, args)
             return false
         end
@@ -52,7 +52,7 @@ function occursin_info(x, expr::Sym)
     isequal(x, expr)
 end
 
-hasderiv(O::Term) = O.op isa Differential || any(hasderiv, O.args)
+hasderiv(O::Term) = operation(O) isa Differential || any(hasderiv, arguments(O))
 hasderiv(O) = false
 
 occursin_info(x, y) = false
@@ -64,16 +64,16 @@ TODO
 function expand_derivatives(O::Symbolic, simplify=true; occurances=nothing)
     if istree(O) && isa(operation(O), Differential)
         @assert length(arguments(O)) == 1
-        arg = expand_derivatives(O.args[1], false)
+        arg = expand_derivatives(arguments(O)[1], false)
 
         if occurances == nothing
-            occurances = occursin_info(O.op.x, arg)
+            occurances = occursin_info(operation(O).x, arg)
         end
 
         _isfalse(occurances) && return 0
         occurances isa Bool && return 1 # means it's a `true`
 
-        (D, o) = (O.op, arg)
+        (D, o) = (operation(O), arg)
 
         if !istree(o)
             return O # Cannot expand
@@ -84,25 +84,25 @@ function expand_derivatives(O::Symbolic, simplify=true; occurances=nothing)
             # a nested Differential. We can attempt to differentiate the
             # inner expression wrt to the outer iv. And leave the
             # unexpandable Differential outside.
-            if isequal(o.op.x, D.x)
+            if isequal(operation(o).x, D.x)
                 return O
             else
                 inner = expand_derivatives(D(arguments(o)[1]), false)
                 # if the inner expression is not expandable either, return
                 if istree(inner) && operation(inner) isa Differential
                     return O
                 else
-                    return expand_derivatives(o.op(inner), simplify)
+                    return expand_derivatives(operation(o)(inner), simplify)
                 end
             end
         end
 
-        l = length(o.args)
+        l = length(arguments(o))
         exprs = []
         c = 0
 
         for i in 1:l
-            t2 = expand_derivatives(D(o.args[i]),false, occurances=occurances.args[i])
+            t2 = expand_derivatives(D(arguments(o)[i]),false, occurances=arguments(occurances)[i])
 
             x = if _iszero(t2)
                 t2
@@ -136,8 +136,8 @@ function expand_derivatives(O::Symbolic, simplify=true; occurances=nothing)
     elseif !hasderiv(O)
         return O
     else
-        args = map(a->expand_derivatives(a, false), O.args)
-        O1 = make_operation(O.op, args)
+        args = map(a->expand_derivatives(a, false), arguments(O))
+        O1 = make_operation(operation(O), args)
         return simplify ? SymbolicUtils.simplify(O1) : O1
     end
 end
@@ -176,7 +176,7 @@ chain rule is not applied:
 julia> myop = sin(x) * y^2
 sin(x()) * y() ^ 2
 
-julia> typeof(myop.op)  # Op is multiplication function
+julia> typeof(operation(myop))  # Op is multiplication function
 typeof(*)
 
 julia> ModelingToolkit.derivative_idx(myop, 1)  # wrt. sin(x)
diff --git a/src/direct.jl b/src/direct.jl
@@ -214,18 +214,18 @@ function sparsehessian(O, vars::AbstractVector; simplify = true)
 end
 
 function toexpr(O::Term)
-  if isa(O.op, Differential)
-     return :(derivative($(toexpr(O.args[1])),$(toexpr(O.op.x))))
-  elseif isa(O.op, Sym)
-    isempty(O.args) && return O.op.name
-    return Expr(:call, toexpr(O.op), toexpr.(O.args)...)
+  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))...)
   end
-  if O.op === (^)
-      if length(O.args) > 1  && O.args[2] isa Number && O.args[2] < 0
-          return Expr(:call, ^, Expr(:call, inv, toexpr(O.args[1])), -(O.args[2]))
+  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]))
       end
   end
-  return Expr(:call, O.op, toexpr.(O.args)...)
+  return Expr(:call, operation(O), toexpr.(arguments(O))...)
 end
 toexpr(s::Sym) = nameof(s)
 toexpr(s) = s
diff --git a/src/latexify_recipes.jl b/src/latexify_recipes.jl
@@ -12,15 +12,15 @@ prettify_expr(expr::Expr) = Expr(expr.head, prettify_expr.(expr.args)...)
 
     rhs = getfield.(eqs, :rhs)
     rhs = prettify_expr.(toexpr.(rhs))
-    rhs = [postwalk(x -> x isa Expr && length(x.args) == 1 ? x.args[1] : x, eq) for eq in rhs]
-    rhs = [postwalk(x -> x isa Expr && x.args[1] == :derivative && length(x.args[2].args) == 2 ? :($(Symbol(:d, x.args[2]))/($(Symbol(:d, x.args[2].args[2])))) : x, eq) for eq in rhs]
-    rhs = [postwalk(x -> x isa Expr && x.args[1] == :derivative ? "\\frac{d\\left($(Latexify.latexraw(x.args[2]))\\right)}{d$(Latexify.latexraw(x.args[3]))}" : x, eq) for eq in rhs]
+    rhs = [postwalk(x -> x isa Expr && length(arguments(x)) == 1 ? arguments(x)[1] : x, eq) for eq in rhs]
+    rhs = [postwalk(x -> x isa Expr && arguments(x)[1] == :derivative && length(arguments(x)[2].args) == 2 ? :($(Symbol(:d, arguments(x)[2]))/($(Symbol(:d, arguments(x)[2].args[2])))) : x, eq) for eq in rhs]
+    rhs = [postwalk(x -> x isa Expr && arguments(x)[1] == :derivative ? "\\frac{d\\left($(Latexify.latexraw(arguments(x)[2]))\\right)}{d$(Latexify.latexraw(arguments(x)[3]))}" : x, eq) for eq in rhs]
 
     lhs = getfield.(eqs, :lhs)
     lhs = prettify_expr.(toexpr.(lhs))
-    lhs = [postwalk(x -> x isa Expr && length(x.args) == 1 ? x.args[1] : x, eq) for eq in lhs]
-    lhs = [postwalk(x -> x isa Expr && x.args[1] == :derivative && length(x.args[2].args) == 2 ? :($(Symbol(:d, x.args[2]))/($(Symbol(:d, x.args[2].args[2])))) : x, eq) for eq in lhs]
-    lhs = [postwalk(x -> x isa Expr && x.args[1] == :derivative ? "\\frac{d\\left($(Latexify.latexraw(x.args[2]))\\right)}{d$(Latexify.latexraw(x.args[3]))}" : x, eq) for eq in lhs]
+    lhs = [postwalk(x -> x isa Expr && length(arguments(x)) == 1 ? arguments(x)[1] : x, eq) for eq in lhs]
+    lhs = [postwalk(x -> x isa Expr && arguments(x)[1] == :derivative && length(arguments(x)[2].args) == 2 ? :($(Symbol(:d, arguments(x)[2]))/($(Symbol(:d, arguments(x)[2].args[2])))) : x, eq) for eq in lhs]
+    lhs = [postwalk(x -> x isa Expr && arguments(x)[1] == :derivative ? "\\frac{d\\left($(Latexify.latexraw(arguments(x)[2]))\\right)}{d$(Latexify.latexraw(arguments(x)[3]))}" : x, eq) for eq in lhs]
 
     return lhs, rhs
 end
diff --git a/src/systems/abstractsystem.jl b/src/systems/abstractsystem.jl
@@ -118,7 +118,7 @@ Generate a function to evaluate the system's equations.
 function generate_function end
 
 getname(x::Sym) = nameof(x)
-getname(t::Term) = t.op isa Sym ? getname(t.op) : error("Cannot get name of $t")
+getname(t::Term) = operation(t) isa Sym ? getname(operation(t)) : error("Cannot get name of $t")
 
 function Base.getproperty(sys::AbstractSystem, name::Symbol)
 
@@ -161,7 +161,7 @@ function renamespace(namespace, x::Sym)
 end
 
 function renamespace(namespace, x::Term)
-    renamespace(namespace, x.op)(x.args...)
+    renamespace(namespace, operation(x))(arguments(x)...)
 end
 
 function namespace_variables(sys::AbstractSystem)
@@ -189,10 +189,10 @@ function namespace_expr(O::Sym,name,ivname)
 end
 
 function namespace_expr(O::Term{T},name,ivname) where {T}
-    if O.op isa Sym
-        Term{T}(rename(O.op,renamespace(name,O.op.name)),namespace_expr.(O.args,name,ivname))
+    if operation(O) isa Sym
+        Term{T}(rename(operation(O),renamespace(name,operation(O).name)),namespace_expr.(arguments(O),name,ivname))
     else
-        Term{T}(O.op,namespace_expr.(O.args,name,ivname))
+        Term{T}(operation(O),namespace_expr.(arguments(O),name,ivname))
     end
 end
 namespace_expr(O,name,ivname) = O
@@ -278,11 +278,11 @@ struct AbstractSysToExpr
 end
 AbstractSysToExpr(sys) = AbstractSysToExpr(sys,states(sys))
 function (f::AbstractSysToExpr)(O::Term)
-    any(isequal(O), f.states) && return O.op.name  # variables
-    if isa(O.op, Sym)
-        return build_expr(:call, Any[O.op.name; f.(O.args)])
+    any(isequal(O), f.states) && return operation(O).name  # variables
+    if isa(operation(O), Sym)
+        return build_expr(:call, Any[operation(O).name; f.(arguments(O))])
     end
-    return build_expr(:call, Any[O.op; f.(O.args)])
+    return build_expr(:call, Any[operation(O); f.(arguments(O))])
 end
 (f::AbstractSysToExpr)(x) = toexpr(x)
 
diff --git a/src/systems/control/controlsystem.jl b/src/systems/control/controlsystem.jl
@@ -90,12 +90,12 @@ struct ControlToExpr
 end
 ControlToExpr(@nospecialize(sys)) = ControlToExpr(sys,states(sys),controls(sys))
 function (f::ControlToExpr)(O::Term)
-    res = if isa(O.op, Sym)
+    res = if isa(operation(O), Sym)
         # 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)])
+        build_expr(:call, Any[operation(O).name; f.(arguments(O))])
     else
-        build_expr(:call, Any[Symbol(O.op); f.(O.args)])
+        build_expr(:call, Any[Symbol(operation(O)); f.(arguments(O))])
     end
 end
 (f::ControlToExpr)(x::Sym) = x.name
@@ -138,11 +138,11 @@ function runge_kutta_discretize(sys::ControlSystem,dt,tspan;
     var(n, i...) = var(nameof(n), i...)
     var(n::Symbol, i...) = Sym{FnType{Tuple{symtype(sys.iv)}, Real}}(nameof(Variable(n, i...)))
     # Expand out all of the variables in time and by stages
-    timed_vars = [[var(x.op,i)(sys.iv) for i in 1:n+1] for x in states(sys)]
-    k_vars = [[var(Symbol(:ᵏ,nameof(x.op)),i,j)(sys.iv) for i in 1:m, j in 1:n] for x in states(sys)]
+    timed_vars = [[var(operation(x),i)(sys.iv) for i in 1:n+1] for x in states(sys)]
+    k_vars = [[var(Symbol(:ᵏ,nameof(operation(x))),i,j)(sys.iv) for i in 1:m, j in 1:n] for x in states(sys)]
     states_timeseries = [getindex.(timed_vars,j) for j in 1:n+1]
     k_timeseries = [[Num.(getindex.(k_vars,i,j)) for i in 1:m] for j in 1:n]
-    control_timeseries = [[[var(x.op,i,j)(sys.iv) for x in controls(sys)] for i in 1:m] for j in 1:n]
+    control_timeseries = [[[var(operation(x),i,j)(sys.iv) for x in controls(sys)] for i in 1:m] for j in 1:n]
     ps = parameters(sys)
     iv = sys.iv
 
diff --git a/src/systems/diffeqs/abstractodesystem.jl b/src/systems/diffeqs/abstractodesystem.jl
@@ -43,12 +43,12 @@ end
 ODEToExpr(@nospecialize(sys)) = ODEToExpr(sys,states(sys))
 (f::ODEToExpr)(O::Num) = f(value(O))
 function (f::ODEToExpr)(O::Term)
-    if isa(O.op, Sym)
+    if isa(operation(O), Sym)
         any(isequal(O), f.states) && return tosymbol(O)
         # dependent variables
-        return build_expr(:call, Any[O.op.name; f.(O.args)])
+        return build_expr(:call, Any[operation(O).name; f.(arguments(O))])
     end
-    return build_expr(:call, Any[O.op; f.(O.args)])
+    return build_expr(:call, Any[operation(O); f.(arguments(O))])
 end
 (f::ODEToExpr)(x) = toexpr(x)
 
@@ -85,7 +85,7 @@ function calculate_massmatrix(sys::AbstractODESystem; simplify=true)
     dvs = states(sys)
     M = zeros(length(eqs),length(eqs))
     for (i,eq) in enumerate(eqs)
-        if eq.lhs isa Term && eq.lhs.op isa Differential
+        if eq.lhs isa Term && operation(eq.lhs) isa Differential
             j = findfirst(x->isequal(tosymbol(x),tosymbol(var_from_nested_derivative(eq.lhs)[1])),dvs)
             M[i,j] = 1
         else
diff --git a/src/systems/diffeqs/odesystem.jl b/src/systems/diffeqs/odesystem.jl
@@ -79,10 +79,10 @@ function ODESystem(deqs::AbstractVector{<:Equation}, iv, dvs, ps;
 end
 
 var_from_nested_derivative(x, i=0) = (missing, missing)
-var_from_nested_derivative(x::Term,i=0) = x.op isa Differential ? var_from_nested_derivative(x.args[1],i+1) : (x,i)
+var_from_nested_derivative(x::Term,i=0) = operation(x) isa Differential ? var_from_nested_derivative(arguments(x)[1],i+1) : (x,i)
 var_from_nested_derivative(x::Sym,i=0) = (x,i)
 
-iv_from_nested_derivative(x::Term) = x.op isa Differential ? iv_from_nested_derivative(x.args[1]) : x.args[1]
+iv_from_nested_derivative(x::Term) = operation(x) isa Differential ? iv_from_nested_derivative(arguments(x)[1]) : arguments(x)[1]
 iv_from_nested_derivative(x::Sym) = x
 iv_from_nested_derivative(x) = missing
 
@@ -92,8 +92,8 @@ function vars!(vars, O)
     isa(O, Sym) && return push!(vars, O)
     !isa(O, Term) && return vars
 
-    O.op isa Sym && push!(vars, O)
-    for arg ∈ O.args
+    operation(O) isa Sym && push!(vars, O)
+    for arg ∈ arguments(O)
         vars!(vars, arg)
     end
 
@@ -148,7 +148,7 @@ function collect_vars!(states, parameters, expr, iv)
 end
 
 function collect_var!(states, parameters, var, iv)
-    if isparameter(var) || isparameter(var.op)
+    if isparameter(var) || isparameter(operation(var))
         isequal(var, iv) || push!(parameters, var)
     else
         push!(states, var)
diff --git a/src/systems/diffeqs/validation.jl b/src/systems/diffeqs/validation.jl
@@ -4,12 +4,12 @@ instantiate(x::ModelingToolkit.Variable{Real}) = 1.0
 instantiate(x::ModelingToolkit.Variable) = oneunit(1*ModelingToolkit.vartype(x))
 function instantiate(x::Num)
     x = value(x)
-    if x.op isa Sym
-        return instantiate(x.op)
-    elseif x.op isa Differential
-        instantiate(x.args[1])/instantiate(x.args[1].args[1])
+    if operation(x) isa Sym
+        return instantiate(operation(x))
+    elseif operation(x) isa Differential
+        instantiate(arguments(x)[1])/instantiate(arguments(x)[1].args[1])
     else
-        x.op(instantiate.(x.args)...)
+        operation(x)(instantiate.(arguments(x))...)
     end
 end
 
diff --git a/src/systems/optimization/optimizationsystem.jl b/src/systems/optimization/optimizationsystem.jl
@@ -77,11 +77,11 @@ function generate_function(sys::OptimizationSystem, vs = states(sys), ps = param
                           conv = AbstractSysToExpr(sys),kwargs...)
 end
 
-equations(sys::OptimizationSystem) = isempty(sys.systems) ? sys.op : sys.op + reduce(+,namespace_expr.(sys.systems))
-namespace_expr(sys::OptimizationSystem) = namespace_expr(sys.op,sys.name,nothing)
+equations(sys::OptimizationSystem) = isempty(sys.systems) ? operation(sys) : operation(sys) + reduce(+,namespace_expr.(sys.systems))
+namespace_expr(sys::OptimizationSystem) = namespace_expr(operation(sys),sys.name,nothing)
 
 hessian_sparsity(sys::OptimizationSystem) =
-    hessian_sparsity(sys.op, states(sys))
+    hessian_sparsity(operation(sys), states(sys))
 
 struct AutoModelingToolkit <: DiffEqBase.AbstractADType end
 
diff --git a/src/systems/reduction.jl b/src/systems/reduction.jl
@@ -59,7 +59,7 @@ function alias_elimination(sys::ODESystem)
     subs = Pair[]
     diff_vars = filter(!isnothing, map(eqs) do eq
             if isdiffeq(eq)
-                eq.lhs.args[1]
+                arguments(eq.lhs)[1]
             else
                 nothing
             end
diff --git a/src/utils.jl b/src/utils.jl
diff --git a/src/variables.jl b/src/variables.jl
diff --git a/test/function_registration.jl b/test/function_registration.jl
