Remove Operation, Constant, and Expression

YingboMa · YingboMa · commit 8119ad558bbc · 2020-10-17T18:27:37.000-04:00
diff --git a/src/ModelingToolkit.jl b/src/ModelingToolkit.jl
@@ -31,15 +31,7 @@ import TreeViews
 
 using Requires
 
-"""
-$(TYPEDEF)
-
-Base type for a symbolic expression.
-"""
-abstract type Expression <: Number end
-
-
-export Num
+export Num, Variable
 """
 $(TYPEDEF)
 
@@ -141,14 +133,6 @@ TODO
 abstract type AbstractSystem end
 abstract type AbstractODESystem <: AbstractSystem end
 
-Base.promote_rule(::Type{<:Number},::Type{<:Expression}) = Expression
-Base.zero(::Type{<:Expression}) = Constant(0)
-Base.zero(::Expression) = Constant(0)
-Base.one(::Type{<:Expression}) = Constant(1)
-Base.one(::Expression) = Constant(1)
-Base.oneunit(::Expression) = Constant(1)
-Base.oneunit(::Type{<:Expression}) = Constant(1)
-
 """
 $(TYPEDSIGNATURES)
 
@@ -172,7 +156,6 @@ function parameters end
 
 include("variables.jl")
 include("context_dsl.jl")
-include("operations.jl")
 include("differentials.jl")
 
 include("equations.jl")
@@ -228,7 +211,7 @@ export Reaction, ReactionSystem, ismassaction, oderatelaw, jumpratelaw
 export Differential, expand_derivatives, @derivatives
 export IntervalDomain, ProductDomain, ⊗, CircleDomain
 export Equation, ConstrainedEquation
-export Term, Sym, Operation, Expression, Variable
+export Term, Sym
 export independent_variable, states, parameters, equations, controls, pins, observed
 
 export calculate_jacobian, generate_jacobian, generate_function
diff --git a/src/build_function.jl b/src/build_function.jl
@@ -13,7 +13,7 @@ struct DaggerForm <: ParallelForm end
 """
 `build_function`
 
-Generates a numerically-usable function from a ModelingToolkit `Expression`.
+Generates a numerically-usable function from a ModelingToolkit `Num`.
 
 ```julia
 build_function(ex, args...;
@@ -24,7 +24,7 @@ build_function(ex, args...;
 
 Arguments:
 
-- `ex`: The `Expression` to compile
+- `ex`: The `Num` to compile
 - `args`: The arguments of the function
 - `expression`: Whether to generate code or whether to generate the compiled form.
   By default, `expression = Val{true}`, which means that the code for the
@@ -176,7 +176,7 @@ Generates a Julia function which can then be utilized for further evaluations.
 If expression=Val{false}, the return is a Julia function which utilizes
 RuntimeGeneratedFunctions.jl in order to be free of world-age issues.
 
-If the `Expression` is an `Operation`, the generated function is a function
+If the `Num` is an `Operation`, the generated function is a function
 with a scalar output, otherwise if it's an `AbstractArray{Operation}`, the output
 is two functions, one for out-of-place AbstractArray output and a second which
 is a mutating function. The outputted functions match the given argument order,
diff --git a/src/differentials.jl b/src/differentials.jl
@@ -71,7 +71,7 @@ function expand_derivatives(O::Term, simplify=true; occurances=nothing)
         end
 
         _isfalse(occurances) && return 0
-        occurances isa Bool && return 1 # means it's a Constant(true)
+        occurances isa Bool && return 1 # means it's a `true`
 
         (D, o) = (O.op, arg)
 
diff --git a/src/direct.jl b/src/direct.jl
@@ -1,6 +1,6 @@
 """
 ```julia
-gradient(O::Expression, vars::AbstractVector; simplify = true)
+gradient(O, vars::AbstractVector; simplify = true)
 ```
 
 A helper function for computing the gradient of an expression with respect to
@@ -81,7 +81,7 @@ end
 
 """
 ```julia
-hessian(O::Expression, vars::AbstractVector; simplify = true)
+hessian(O, vars::AbstractVector; simplify = true)
 ```
 
 A helper function for computing the Hessian of an expression with respect to
@@ -105,7 +105,7 @@ isidx(x) = x isa TermCombination
 
 """
 ```julia
-hessian_sparsity(ops::AbstractVector{<:Expression}, vars::AbstractVector{<:Expression})
+hessian_sparsity(ops::AbstractVector, vars::AbstractVector)
 ```
 
 Return the sparsity pattern of the Hessian of an array of expressions with respect to
@@ -162,7 +162,7 @@ end
 
 """
 ```julia
-islinear(ex::Expression, u)
+islinear(ex, u)
 ```
 Check if an expression is linear with respect to a list of variable expressions.
 """
@@ -172,7 +172,7 @@ end
 
 """
 ```julia
-sparsehessian(O::Expression, vars::AbstractVector; simplify = true)
+sparsehessian(O, vars::AbstractVector; simplify = true)
 ```
 
 A helper function for computing the sparse Hessian of an expression with respect to
@@ -211,7 +211,7 @@ function toexpr(O::Term)
     return Expr(:call, toexpr(O.op), toexpr.(O.args)...)
   end
   if O.op === (^)
-      if length(O.args) > 1  && O.args[2] isa Constant && O.args[2].value < 0
+      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].value))
       end
   end
diff --git a/src/equations.jl b/src/equations.jl
@@ -20,8 +20,8 @@ SymbolicUtils.simplify(x::Equation; kw...) = simplify(x.lhs; kw...) ~ simplify(x
 """
 $(TYPEDSIGNATURES)
 
-Create an [`Equation`](@ref) out of two [`Expression`](@ref) instances, or an
-`Expression` and a `Number`.
+Create an [`Equation`](@ref) out of two [`Num`](@ref) instances, or an
+`Num` and a `Number`.
 
 # Examples
 
diff --git a/src/latexify_recipes.jl b/src/latexify_recipes.jl
@@ -8,14 +8,12 @@
 
     rhs = getfield.(eqs, :rhs)
     rhs = toexpr.(rhs)
-    rhs = [postwalk(x -> x isa ModelingToolkit.Constant ? x.value : x, eq) for eq in 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]
 
     lhs = getfield.(eqs, :lhs)
     lhs = toexpr.(lhs)
-    lhs = [postwalk(x -> x isa ModelingToolkit.Constant ? x.value : x, eq) for eq in 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]
diff --git a/src/register_function.jl b/src/register_function.jl
@@ -21,7 +21,7 @@ macro register(expr, Ts = [Num, Symbolic, Real])
          for ts in types]...) |> esc
 end
 
-# Ensure that Operations that get @registered from outside the ModelingToolkit
+# Ensure that Num that get @registered from outside the ModelingToolkit
 # module can work without having to bring in the associated function into the
 # ModelingToolkit namespace. We basically store information about functions
 # registered at runtime in a ModelingToolkit variable,
diff --git a/src/solve.jl b/src/solve.jl
@@ -75,10 +75,6 @@ function _solve(A, b)
     SymbolicUtils.simplify.(ldiv(sym_lu(A), b))
 end
 
-LinearAlgebra.:(\)(A::AbstractMatrix{<:Expression}, b::AbstractVector{<:Expression}) = _solve(A, b)
-LinearAlgebra.:(\)(A::AbstractMatrix{<:Expression}, b::AbstractVector) = _solve(A, b)
-LinearAlgebra.:(\)(A::AbstractMatrix, b::AbstractVector{<:Expression}) = _solve(A, b)
-
 # ldiv below
 
 _iszero(x::Number) = iszero(x)
diff --git a/src/systems/abstractsystem.jl b/src/systems/abstractsystem.jl
@@ -5,7 +5,7 @@ calculate_tgrad(sys::AbstractSystem)
 
 Calculate the time gradient of a system.
 
-Returns a vector of [`Expression`](@ref) instances. The result from the first
+Returns a vector of [`Num`](@ref) instances. The result from the first
 call will be cached in the system object.
 """
 function calculate_tgrad end
@@ -17,7 +17,7 @@ calculate_gradient(sys::AbstractSystem)
 
 Calculate the gradient of a scalar system.
 
-Returns a vector of [`Expression`](@ref) instances. The result from the first
+Returns a vector of [`Num`](@ref) instances. The result from the first
 call will be cached in the system object.
 """
 function calculate_gradient end
@@ -29,7 +29,7 @@ calculate_jacobian(sys::AbstractSystem)
 
 Calculate the jacobian matrix of a system.
 
-Returns a matrix of [`Expression`](@ref) instances. The result from the first
+Returns a matrix of [`Num`](@ref) instances. The result from the first
 call will be cached in the system object.
 """
 function calculate_jacobian end
@@ -41,7 +41,7 @@ calculate_factorized_W(sys::AbstractSystem)
 
 Calculate the factorized W-matrix of a system.
 
-Returns a matrix of [`Expression`](@ref) instances. The result from the first
+Returns a matrix of [`Num`](@ref) instances. The result from the first
 call will be cached in the system object.
 """
 function calculate_factorized_W end
@@ -53,7 +53,7 @@ calculate_hessian(sys::AbstractSystem)
 
 Calculate the hessian matrix of a scalar system.
 
-Returns a matrix of [`Expression`](@ref) instances. The result from the first
+Returns a matrix of [`Num`](@ref) instances. The result from the first
 call will be cached in the system object.
 """
 function calculate_hessian end
diff --git a/src/systems/diffeqs/abstractodesystem.jl b/src/systems/diffeqs/abstractodesystem.jl
@@ -98,7 +98,6 @@ function calculate_massmatrix(sys::AbstractODESystem; simplify=true)
     end
     M = simplify ? ModelingToolkit.simplify.(M) : M
     # M should only contain concrete numbers
-    M = map(x->x isa Constant ? x.value : x, M)
     M == I ? I : M
 end
 
diff --git a/src/systems/diffeqs/first_order_transform.jl b/src/systems/diffeqs/first_order_transform.jl
@@ -39,7 +39,7 @@ function ode_order_lowering(eqs, iv, states)
     alge_vars = []
 
     for (i, (eq, ss)) ∈ enumerate(zip(eqs, states))
-        if isequal(eq.lhs, Constant(0))
+        if _iszero(eq.lhs)
             push!(alge_vars, ss)
             push!(alge_eqs, eq)
         else
diff --git a/src/systems/diffeqs/odesystem.jl b/src/systems/diffeqs/odesystem.jl
@@ -64,8 +64,8 @@ struct ODESystem <: AbstractODESystem
 end
 
 function ODESystem(deqs::AbstractVector{<:Equation}, iv, dvs, ps;
-                   pins = Variable[],
-                   observed = Operation[],
+                   pins = Num[],
+                   observed = Num[],
                    systems = ODESystem[],
                    name=gensym(:ODESystem))
     iv′ = value(iv)
@@ -111,7 +111,7 @@ function ODESystem(eqs, iv=nothing; kwargs...)
     # initial loop for finding `iv`
     if iv === nothing
         for eq in eqs
-            if !(eq.lhs isa Constant) # assume eq.lhs is either Differential or Constant
+            if !(eq.lhs isa Number) # assume eq.lhs is either Differential or Number
                 iv = iv_from_nested_derivative(eq.lhs)
                 break
             end
diff --git a/src/systems/diffeqs/validation.jl b/src/systems/diffeqs/validation.jl
@@ -1,9 +1,10 @@
-Base.:*(x::Expression,y::Unitful.AbstractQuantity) = x * y
+Base.:*(x::Union{Num,Symbolic},y::Unitful.AbstractQuantity) = x * y
 
 instantiate(x::ModelingToolkit.Variable{Real}) = 1.0
 instantiate(x::ModelingToolkit.Variable) = oneunit(1*ModelingToolkit.vartype(x))
-function instantiate(x::ModelingToolkit.Operation)
-    if x.op isa Variable
+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])
diff --git a/src/systems/jumps/jumpsystem.jl b/src/systems/jumps/jumpsystem.jl
@@ -255,7 +255,7 @@ function DiffEqJump.JumpProblem(js::JumpSystem, prob, aggregator; kwargs...)
     invttype  = typeof(1 / prob.tspan[2])
 
     # handling parameter substition and empty param vecs
-    p = (prob.p == DiffEqBase.NullParameters()) ? Operation[] : prob.p
+    p = (prob.p == DiffEqBase.NullParameters()) ? Num[] : prob.p
     parammap  = map((x,y)->Pair(x,y), parameters(js), p)
     subber    = substituter(parammap)
 
diff --git a/src/systems/reaction/reactionsystem.jl b/src/systems/reaction/reactionsystem.jl
@@ -490,7 +490,7 @@ function DiffEqBase.ODEProblem(rs::ReactionSystem, u0::Union{AbstractArray, Numb
 end
 
 # SDEProblem from AbstractReactionNetwork
-function DiffEqBase.SDEProblem(rs::ReactionSystem, u0::Union{AbstractArray, Number}, tspan, p=DiffEqBase.NullParameters(), args...; noise_scaling=nothing::Union{Operation,Nothing}, kwargs...)
+function DiffEqBase.SDEProblem(rs::ReactionSystem, u0::Union{AbstractArray, Number}, tspan, p=DiffEqBase.NullParameters(), args...; noise_scaling=nothing, kwargs...)
     sde_sys = convert(SDESystem,rs,noise_scaling=noise_scaling)
     u0 = typeof(u0) <: Array{<:Pair} ? u0 : Pair.(rs.states,u0)
     p = typeof(p) <: Union{Array{<:Pair},DiffEqBase.NullParameters} ? p : Pair.(sde_sys.ps,p)
diff --git a/src/systems/reduction.jl b/src/systems/reduction.jl
@@ -27,13 +27,6 @@ function substitute_aliases(diffeqs, dict)
     lhss(diffeqs) .~ fixpoint_sub.(rhss(diffeqs), (dict,))
 end
 
-function make_lhs_0(eq)
-    if eq.lhs isa Constant && iszero(eq.lhs)
-        return eq
-    else
-        0 ~ eq.lhs - eq.rhs
-    end
-end
 isvar(s::Sym) = !isparameter(s)
 isvar(s::Term) = isvar(s.op)
 isvar(s::Any) = false
@@ -44,6 +37,14 @@ function filterexpr(f, s)
     vs
 end
 
+function make_lhs_0(eq)
+    if eq.lhs isa Number && iszero(eq.lhs)
+        return eq
+    else
+        0 ~ eq.lhs - eq.rhs
+    end
+end
+
 function alias_elimination(sys::ODESystem)
     eqs = vcat(equations(sys), observed(sys))
 
diff --git a/src/utils.jl b/src/utils.jl
@@ -49,12 +49,6 @@ function retime_dvs(op::Term, dvs, iv)
 end
 retime_dvs(op,dvs,iv) = op
 
-is_constant(::Constant) = true
-is_constant(::Any) = false
-
-is_operation(::Operation) = true
-is_operation(::Any) = false
-
 is_derivative(O::Term) = isa(O.op, Differential)
 is_derivative(::Any) = false
 
@@ -95,11 +89,11 @@ modified_states!(mstates, e::Equation, statelist=nothing) = get_variables!(mstat
 # variable substitution
 # Piracy but mild
 """
-substitute(expr::Operation, s::Pair)
-substitute(expr::Operation, s::Dict)
-substitute(expr::Operation, s::Vector)
+substitute(expr, s::Pair)
+substitute(expr, s::Dict)
+substitute(expr, s::Vector)
 
-Performs the substitution `Operation => val` on the `expr` Operation.
+Performs the substitution `Num => val` on the `expr` Num.
 """
 substitute(expr::Num, s::Union{Pair, Vector, Dict}; kw...) = Num(substituter(s)(value(expr); kw...))
 # TODO: move this to SymbolicUtils
diff --git a/src/variables.jl b/src/variables.jl
diff --git a/test/build_function_arrayofarray.jl b/test/build_function_arrayofarray.jl
diff --git a/test/components.jl b/test/components.jl
diff --git a/test/direct.jl b/test/direct.jl
