Move Constant to separate datatype

Author: HarrisonGrodin

src/ModelingToolkit.jl

@@ -16,8 +16,8 @@ include("domains.jl")
 include("variables.jl")
 
 Base.promote_rule(::Type{T},::Type{T2}) where {T<:Number,T2<:Expression} = Expression
-Base.one(::Type{T}) where T<:Expression = Constant(1)
-Base.zero(::Type{T}) where T<:Expression = Constant(0)
+Base.zero(::Type{<:Expression}) = Constant(0)
+Base.one(::Type{<:Expression}) = Constant(1)
 Base.convert(::Type{Variable},x::Int64) = Constant(x)
 
 function caclulate_jacobian end

src/differentials.jl

@@ -31,7 +31,7 @@ function expand_derivatives(O::Operation)
 
     return O
 end
-expand_derivatives(x::Variable) = x
+expand_derivatives(x) = x
 
 # Don't specialize on the function here
 function Derivative(O::Operation,idx)

src/operations.jl

@@ -8,12 +8,12 @@ end
 function Base.:(==)(x::Operation,y::Operation)
     x.op == y.op && length(x.args) == length(y.args) && all(isequal.(x.args,y.args))
 end
-Base.:(==)(x::Operation,y::Number) = false
-Base.:(==)(x::Number,y::Operation) = false
-Base.:(==)(x::Operation,y::Nothing) = false
-Base.:(==)(x::Nothing,y::Operation) = false
-Base.:(==)(x::Variable,y::Operation) = false
-Base.:(==)(x::Operation,y::Variable) = false
+Base.:(==)(::Operation, ::Number   ) = false
+Base.:(==)(::Number   , ::Operation) = false
+Base.:(==)(::Operation, ::Variable ) = false
+Base.:(==)(::Variable , ::Operation) = false
+Base.:(==)(::Operation, ::Constant ) = false
+Base.:(==)(::Constant , ::Operation) = false
 
 Base.convert(::Type{Expr}, O::Operation) =
     build_expr(:call, Any[Symbol(O.op); convert.(Expr, O.args)])
@@ -36,8 +36,8 @@ function find_replace!(O::Operation,x::Variable,y::Expression)
 end
 
 # For inv
-Base.convert(::Type{Operation},x::Int) = Operation(identity,Expression[Constant(x)])
-Base.convert(::Type{Operation},x::Bool) = Operation(identity,Expression[Constant(x)])
-Base.convert(::Type{Operation},x::Variable) = Operation(identity,Expression[x])
-Operation(x) = convert(Operation,x)
-Operation(x::Operation) = x
+Base.convert(::Type{Operation}, x::Int) = Operation(identity, Expression[Constant(x)])
+Base.convert(::Type{Operation}, x::Bool) = Operation(identity, Expression[Constant(x)])
+Base.convert(::Type{Operation}, x::Operation) = x
+Base.convert(::Type{Operation}, x::Expression) = Operation(identity, Expression[x])
+Operation(x) = convert(Operation, x)

src/simplify.jl

@@ -1,4 +1,4 @@
-function simplify_constants(O::Operation, shorten_tree = true)
+function simplify_constants(O::Operation, shorten_tree)
     while true
         O′ = _simplify_constants(O, shorten_tree)
         if is_operation(O′)
@@ -8,10 +8,13 @@ function simplify_constants(O::Operation, shorten_tree = true)
         O = O′
     end
 end
+simplify_constants(x, shorten_tree) = x
+simplify_constants(x) = simplify_constants(x, true)
+
 
 const AC_OPERATORS = (*, +)
 
-function _simplify_constants(O, shorten_tree = true)
+function _simplify_constants(O::Operation, shorten_tree)
     # Tree shrinking
     if shorten_tree && O.op ∈ AC_OPERATORS
         # Flatten tree
@@ -67,7 +70,7 @@ function _simplify_constants(O, shorten_tree = true)
 
     return O
 end
-simplify_constants(x::Variable, y=false) = x
-_simplify_constants(x::Variable, y=false) = x
+_simplify_constants(x, shorten_tree) = x
+_simplify_constants(x) = _simplify_constants(x, true)
 
 export simplify_constants

src/utils.jl

@@ -33,7 +33,7 @@ end
 
 toexpr(ex) = MacroTools.postwalk(x -> isa(x, Expression) ? convert(Expr, x) : x, ex)
 
-is_constant(x::Variable) = x.subtype === :Constant
+is_constant(::Constant) = true
 is_constant(::Any) = false
 
 is_operation(::Operation) = true

src/variables.jl

@@ -31,8 +31,6 @@ Variable(name,x::Variable) = Variable(name,x.value,x.value_type,
                 x.size,x.context)
 
 Parameter(name,args...;kwargs...) = Variable(name,args...;subtype=:Parameter,kwargs...)
-Constant(value::Number) = Variable(Symbol(value),value,typeof(value);subtype=:Constant)
-Constant(name,args...;kwargs...) = Variable(name,args...;subtype=:Constant,kwargs...)
 IndependentVariable(name,args...;kwargs...) = Variable(name,args...;subtype=:IndependentVariable,kwargs...)
 
 function DependentVariable(name,args...;dependents = [],kwargs...)
@@ -64,53 +62,38 @@ export Variable,Parameter,Constant,DependentVariable,IndependentVariable,JumpVar
        @Var, @DVar, @IVar, @Param, @Const
 
 
-Base.get(x::Variable) = x.value
+struct Constant <: Expression
+    value::Number
+end
+Base.get(c::Constant) = c.value
+
 
-Base.iszero(::Expression) = false
-Base.iszero(c::Variable) = get(c) isa Number && iszero(get(c))
-Base.isone(::Expression) = false
-Base.isone(c::Variable) = get(c) isa Number && isone(get(c))
+Base.iszero(ex::Expression) = isa(ex, Constant) && iszero(ex.value)
+Base.isone(ex::Expression)  = isa(ex, Constant) && isone(ex.value)
 
 
 # Variables use isequal for equality since == is an Operation
 function Base.:(==)(x::Variable,y::Variable)
     x.name == y.name && x.subtype == y.subtype && x.value == y.value &&
     x.value_type == y.value_type && x.diff == y.diff
 end
-
-function Base.:(==)(x::Variable,y::Number)
-    x == Constant(y)
-end
-
-function Base.:(==)(x::Number,y::Variable)
-    Constant(x) == y
-end
+Base.:(==)(::Variable, ::Number) = false
+Base.:(==)(::Number, ::Variable) = false
+Base.:(==)(::Variable, ::Constant) = false
+Base.:(==)(::Constant, ::Variable) = false
+Base.:(==)(c::Constant, n::Number) = c.value == n
+Base.:(==)(n::Number, c::Constant) = c.value == n
+Base.:(==)(a::Constant, b::Constant) = a.value == b.value
 
 function Base.convert(::Type{Expr}, x::Variable)
-    if x.subtype == :Constant
-        return x.value
-    elseif x.diff == nothing
-        return :($(x.name))
-    else
-        return :($(Symbol("$(x.name)_$(x.diff.x.name)")))
-    end
+    x.diff === nothing && return x.name
+    return Symbol("$(x.name)_$(x.diff.x.name)")
 end
+Base.convert(::Type{Expr}, c::Constant) = c.value
 
-function Base.show(io::IO, A::Variable)
-    if A.subtype == :Constant
-        print(io,"Constant($(A.value))")
-    else
-        str = "$(A.subtype)($(A.name))"
-        if A.value != nothing
-            str *= ", value = " * string(A.value)
-        end
-
-        if A.diff != nothing
-            str *= ", diff = " * string(A.diff)
-        end
-
-        print(io,str)
-    end
+function Base.show(io::IO, x::Variable)
+    print(io, x.subtype, '(', x.name, ')')
+    x.diff === nothing || print(io, ", diff = ", x.diff)
 end
 
 extract_idv(eq) = eq.args[1].diff.x