Num <: Real

Author: YingboMa

src/ModelingToolkit.jl

@@ -43,9 +43,9 @@ export Num
 """
 $(TYPEDEF)
 
-Wrap anything in a type that is a subtype of Number
+Wrap anything in a type that is a subtype of Real
 """
-struct Num <: Number
+struct Num <: Real
     val
 end
 
@@ -106,9 +106,20 @@ macro num_method(f, expr, Ts=nothing)
     end |> esc
 end
 
-@num_method Base.isless isless(value(a), value(b))
-@num_method Base.isequal isequal(value(a), value(b)) (Number, Symbolic)
-@num_method Base.:(==) value(a) == value(b) (Number,)
+"""
+    tosymbolic(a::Union{Sym,Num}) -> Sym{Real}
+    tosymbolic(a::T) -> T
+"""
+tosymbolic(a::Num) = tosymbolic(value(a))
+tosymbolic(a::Sym) = tovar(a)
+tosymbolic(a) = a
+@num_method Base.isless isless(tosymbolic(a), tosymbolic(b)) (Real,)
+@num_method Base.:(<) (tosymbolic(a) < tosymbolic(b)) (Real,)
+@num_method Base.:(<=) (tosymbolic(a) <= tosymbolic(b)) (Real,)
+@num_method Base.:(>) (tosymbolic(a) > tosymbolic(b)) (Real,)
+@num_method Base.:(>=) (tosymbolic(a) >= tosymbolic(b)) (Real,)
+@num_method Base.isequal isequal(tosymbolic(a), tosymbolic(b)) (Number, Symbolic)
+@num_method Base.:(==) tosymbolic(a) == tosymbolic(b) (Number,)
 
 Base.hash(x::Num, h::UInt) = hash(value(x), h)
 
@@ -120,13 +131,6 @@ Base.convert(::Type{<:Array{Num}}, x::AbstractArray) = map(Num, x)
 Base.convert(::Type{<:Array{Num}}, x::AbstractArray{Num}) = x
 Base.convert(::Type{Sym}, x::Num) = value(x) isa Sym ? value(x) : error("cannot convert $x to Sym")
 
-#=
-# TODO: use register?
-Base.isless(n::Num, x::Number) = value(n) < value(x)
-Base.isless(n::Num, x::Num) = value(n) < value(x)
-Base.isless(n::Number, x::Num) = value(n) < value(x)
-=#
-
 LinearAlgebra.lu(x::Array{Num}; kw...) = lu(x, Val{false}(); kw...)
 
 """

src/context_dsl.jl

@@ -15,5 +15,5 @@ $(SIGNATURES)
 Define one or more known variables.
 """
 macro parameters(xs...)
-    esc(_parse_vars(:parameters, Parameter{Number}, xs))
+    esc(_parse_vars(:parameters, Parameter{Real}, xs))
 end

src/register_function.jl

@@ -1,4 +1,4 @@
-macro register(expr, Ts = [Num, Symbolic, Number])
+macro register(expr, Ts = [Num, Symbolic, Real])
     @assert expr.head == :call
 
     f = expr.args[1]
@@ -8,16 +8,16 @@ macro register(expr, Ts = [Num, Symbolic, Number])
 
     types = vec(collect(Iterators.product(ntuple(_->Ts, length(symbolic_args))...)))
 
-    # remove Number Number Number methods
-    filter!(Ts->!all(T->T == Number, Ts), types)
+    # remove Real Real Real methods
+    filter!(Ts->!all(T->T == Real, Ts), types)
 
     annotype(name,T) = :($name :: $T)
     setinds(xs, idx, vs) = (xs=copy(xs); xs[idx] .= map(annotype, xs[idx], vs); xs)
     name(x::Symbol) = :($value($x))
     name(x::Expr) = ((@assert x.head == :(::)); :($value($(x.args[1]))))
 
     Expr(:block,
-         [:($f($(setinds(args, symbolic_args, ts)...)) = Term{Number}($f, [$(map(name, args)...)]))
+         [:($f($(setinds(args, symbolic_args, ts)...)) = Term{Real}($f, [$(map(name, args)...)]))
          for ts in types]...) |> esc
 end
 

src/systems/abstractsystem.jl

@@ -169,7 +169,7 @@ function namespace_variables(sys::AbstractSystem)
 end
 
 function namespace_parameters(sys::AbstractSystem)
-    [makeparam(renamespace(sys.name,x)) for x in parameters(sys)]
+    [toparam(renamespace(sys.name,x)) for x in parameters(sys)]
 end
 
 function namespace_pins(sys::AbstractSystem)

src/systems/control/controlsystem.jl

@@ -136,7 +136,7 @@ function runge_kutta_discretize(sys::ControlSystem,dt,tspan;
     L = @RuntimeGeneratedFunction(build_function(sys.loss,sys.states,sys.controls,sys.ps,sys.iv,conv = ModelingToolkit.ControlToExpr(sys)))
 
     var(n, i...) = var(nameof(n), i...)
-    var(n::Symbol, i...) = Sym{FnType{Tuple{symtype(sys.iv)}, Number}}(nameof(Variable(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)]

src/systems/diffeqs/modelingtoolkitize.jl

@@ -14,7 +14,7 @@ function modelingtoolkitize(prob::DiffEqBase.ODEProblem)
         p = prob.p
     end
 
-    var(x, i) = Sym{FnType{Tuple{symtype(t)}, Number}}(nameof(Variable(:x, i)))
+    var(x, i) = Sym{FnType{Tuple{symtype(t)}, Real}}(nameof(Variable(:x, i)))
     vars = reshape([var(:x, i)(value(t)) for i in eachindex(prob.u0)],size(prob.u0))
     params = p isa DiffEqBase.NullParameters ? [] :
              reshape([Variable(:α,i) for i in eachindex(p)],size(p))
@@ -52,7 +52,7 @@ function modelingtoolkitize(prob::DiffEqBase.SDEProblem)
     else
         p = prob.p
     end
-    var(x, i) = Sym{FnType{Tuple{symtype(t)}, Number}}(nameof(Variable(:x, i)))
+    var(x, i) = Sym{FnType{Tuple{symtype(t)}, Real}}(nameof(Variable(:x, i)))
     vars = reshape([var(:x, i)(value(t)) for i in eachindex(prob.u0)],size(prob.u0))
     params = p isa DiffEqBase.NullParameters ? [] :
              reshape([Variable(:α,i) for i in eachindex(p)],size(p))

src/systems/diffeqs/validation.jl

@@ -1,7 +1,6 @@
-Base.:*(x::Expression,y::Unitful.AbstractQuantity) = x * ModelingToolkit.Constant(y)
+Base.:*(x::Expression,y::Unitful.AbstractQuantity) = x * y
 
-instantiate(x::ModelingToolkit.Constant) = x.value
-instantiate(x::ModelingToolkit.Variable{Number}) = 1.0
+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

src/systems/reaction/reactionsystem.jl

@@ -380,9 +380,6 @@ function Base.convert(::Type{<:ODESystem}, rs::ReactionSystem; combinatoric_rate
               systems=convert.(ODESystem,rs.systems))
 end
 
-makeparam(s::Sym) = Sym{Parameter{Number}}(s.name)
-makeparam(s::Sym{<:Parameter}) = s
-
 """
 ```julia
 Base.convert(::Type{<:SDESystem},rs::ReactionSystem)
@@ -426,7 +423,7 @@ function Base.convert(::Type{<:SDESystem},rs::ReactionSystem, combinatoric_ratel
               rs.states,
               (noise_scaling===nothing) ?
                     rs.ps :
-                    union(rs.ps,makeparam.(noise_scaling)),
+                    union(rs.ps,toparam.(noise_scaling)),
                     name=rs.name,systems=convert.(SDESystem,rs.systems))
 end
 

src/utils.jl

@@ -33,15 +33,15 @@ end
 
 function detime_dvs(op::Term)
   if op.op isa Sym
-      Sym{Number}(nameof(op.op))
+      Sym{Real}(nameof(op.op))
   else
     Term(op.op,detime_dvs.(op.args))
   end
 end
 detime_dvs(op) = op
 
 function retime_dvs(op::Sym,dvs,iv)
-    Sym{FnType{Tuple{symtype(iv)}, Number}}(nameof(op))(iv)
+    Sym{FnType{Tuple{symtype(iv)}, Real}}(nameof(op))(iv)
 end
 
 function retime_dvs(op::Term, dvs, iv)
@@ -143,3 +143,19 @@ function states_to_sym(states)
         end
     end
 end
+
+"""
+    toparam(s::Sym) -> Sym{<:Parameter}
+
+Maps the variable to a paramter.
+"""
+toparam(s::Sym) = Sym{Parameter{symtype(s)}}(s.name)
+toparam(s::Sym{<:Parameter}) = s
+
+"""
+    tovar(s::Sym) -> Sym{Real}
+
+Maps the variable to a variable (state).
+"""
+tovar(s::Sym{<:Parameter}) = Sym{symtype(s)}(s.name)
+tovar(s::Sym) = s

src/variables.jl

@@ -49,7 +49,7 @@ expr = β₁ * x + y^α + σ(3) * (z - t) - β₂ * w(t - 1)
 struct Variable{T} <: Function
     """The variable's unique name."""
     name::Symbol
-    Variable(name) = Sym{Number}(name)
+    Variable(name) = Sym{Real}(name)
     Variable{T}(name) where T = Sym{T}(name)
     function Variable{T}(name, indices...) where T
         var_name = Symbol("$(name)$(join(map_subscripts.(indices), "ˏ"))")
@@ -215,7 +215,7 @@ z
 ```
 """
 macro variables(xs...)
-    esc(_parse_vars(:variables, Number, xs))
+    esc(_parse_vars(:variables, Real, xs))
 end
 
 """