Use isequal instead of ==

Author: HarrisonGrodin

src/differentials.jl

@@ -12,7 +12,7 @@ function (D::Differential)(x::Variable)
     return Operation(D, Expression[x])
 end
 (::Differential)(::Any) = Constant(0)
-Base.:(==)(D1::Differential, D2::Differential) = D1.x == D2.x
+Base.:(==)(D1::Differential, D2::Differential) = isequal(D1.x, D2.x)
 
 function expand_derivatives(O::Operation)
     @. O.args = expand_derivatives(O.args)

src/equations.jl

@@ -5,15 +5,15 @@ struct Equation
     lhs::Expression
     rhs::Expression
 end
-Base.:(==)(a::Equation, b::Equation) = (a.lhs, a.rhs) == (b.lhs, b.rhs)
+Base.:(==)(a::Equation, b::Equation) = isequal((a.lhs, a.rhs), (b.lhs, b.rhs))
 
 Base.:~(lhs::Expression, rhs::Expression) = Equation(lhs, rhs)
 Base.:~(lhs::Expression, rhs::Number    ) = Equation(lhs, rhs)
 Base.:~(lhs::Number    , rhs::Expression) = Equation(lhs, rhs)
 
 
 _is_dependent(x::Variable) = !x.known && !isempty(x.dependents)
-_is_parameter(iv) = x -> x.known && x ≠ iv
+_is_parameter(iv) = x -> x.known && !isequal(x, iv)
 _is_known(x::Variable) = x.known
 _is_unknown(x::Variable) = !x.known
 

src/function_registration.jl

@@ -32,7 +32,13 @@ for (M, f, arity) in DiffRules.diffrules()
     @eval @register $sig
 end
 
-for fun = (:<, :>, :(==), :!, :&, :|, :div)
+for fun ∈ [:!]
+    basefun = Expr(:., Base, QuoteNode(fun))
+    sig = :($basefun(x))
+    @eval @register $sig
+end
+
+for fun ∈ [:<, :>, :(==), :&, :|, :div]
     basefun = Expr(:., Base, QuoteNode(fun))
     sig = :($basefun(x,y))
     @eval @register $sig

src/operations.jl

@@ -4,15 +4,15 @@ struct Operation <: Expression
 end
 
 # Recursive ==
-function Base.:(==)(x::Operation,y::Operation)
+function Base.isequal(x::Operation,y::Operation)
     x.op == y.op && length(x.args) == length(y.args) && all(isequal.(x.args,y.args))
 end
-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.isequal(::Operation, ::Number   ) = false
+Base.isequal(::Number   , ::Operation) = false
+Base.isequal(::Operation, ::Variable ) = false
+Base.isequal(::Variable , ::Operation) = false
+Base.isequal(::Operation, ::Constant ) = false
+Base.isequal(::Constant , ::Operation) = false
 
 Base.convert(::Type{Expr}, O::Operation) =
     build_expr(:call, Any[Symbol(O.op); convert.(Expr, O.args)])

src/simplify.jl

@@ -4,7 +4,7 @@ function simplify_constants(O::Operation, shorten_tree)
         if is_operation(O′)
             O′ = Operation(O′.op, simplify_constants.(O′.args, shorten_tree))
         end
-        O == O′ && return O
+        isequal(O, O′) && return O
         O = O′
     end
 end

src/systems/diffeqs/diffeqsystem.jl

@@ -10,7 +10,7 @@ function flatten_differential(O::Operation)
     @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])
-    t == O.op.x || throw(ArgumentError("non-matching differentials on lhs: $t, $(O.op.x)"))
+    isequal(t, O.op.x) || throw(ArgumentError("non-matching differentials on lhs: $t, $(O.op.x)"))
     return (x, t, order + 1)
 end
 
@@ -26,7 +26,7 @@ function Base.convert(::Type{DiffEq}, eq::Equation)
     (x, t, n) = flatten_differential(eq.lhs)
     return DiffEq(x, t, n, eq.rhs)
 end
-Base.:(==)(a::DiffEq, b::DiffEq) = (a.x, a.t, a.n, a.rhs) == (b.x, b.t, b.n, b.rhs)
+Base.:(==)(a::DiffEq, b::DiffEq) = isequal((a.x, a.t, a.n, a.rhs), (b.x, b.t, b.n, b.rhs))
 get_args(eq::DiffEq) = Expression[eq.x, eq.t, eq.rhs]
 
 struct DiffEqSystem <: AbstractSystem

src/systems/diffeqs/first_order_transform.jl

@@ -17,7 +17,7 @@ function ode_order_lowering(eqs, iv)
         var, maxorder = eq.x, eq.n
         if maxorder > get(var_order, var, 0)
             var_order[var] = maxorder
-            var ∈ vars || push!(vars, var)
+            any(isequal(var), vars) || push!(vars, var)
         end
         var′ = lower_varname(eq.x, eq.t, eq.n - 1)
         rhs′ = rename(eq.rhs)

src/utils.jl

@@ -65,4 +65,4 @@ is_derivative(::Any) = false
 
 has_dependent(t::Variable) = Base.Fix2(has_dependent, t)
 has_dependent(x::Variable, t::Variable) =
-    t ∈ x.dependents || any(has_dependent(t), x.dependents)
+    any(isequal(t), x.dependents) || any(has_dependent(t), x.dependents)

src/variables.jl

@@ -22,14 +22,14 @@ Base.isone(ex::Expression)  = isa(ex, Constant) && isone(ex.value)
 
 
 # Variables use isequal for equality since == is an Operation
-Base.:(==)(x::Variable, y::Variable) = (x.name, x.known) == (y.name, y.known)
-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
+Base.isequal(x::Variable, y::Variable) = (x.name, x.known) == (y.name, y.known)
+Base.isequal(::Variable, ::Number) = false
+Base.isequal(::Number, ::Variable) = false
+Base.isequal(::Variable, ::Constant) = false
+Base.isequal(::Constant, ::Variable) = false
+Base.isequal(c::Constant, n::Number) = c.value == n
+Base.isequal(n::Number, c::Constant) = c.value == n
+Base.isequal(a::Constant, b::Constant) = a.value == b.value
 
 function Base.convert(::Type{Expr}, x::Variable)
     x.known               || return x.name

test/derivatives.jl

@@ -6,52 +6,52 @@ using Test
 @Unknown x(t) y(t) z(t)
 @Deriv D'~t D2''~t
 
-@test expand_derivatives(D(t)) == 1
-@test expand_derivatives(D(D(t))) == 0
+@test isequal(expand_derivatives(D(t)), 1)
+@test isequal(expand_derivatives(D(D(t))), 0)
 
 dsin = D(sin(t))
-@test expand_derivatives(dsin) == cos(t)
+@test isequal(expand_derivatives(dsin), cos(t))
 
 dcsch = D(csch(t))
-@test expand_derivatives(dcsch) == simplify_constants(coth(t) * csch(t) * -1)
+@test isequal(expand_derivatives(dcsch), simplify_constants(coth(t) * csch(t) * -1))
 
-@test expand_derivatives(D(-7)) == 0
-@test expand_derivatives(D(sin(2t))) == simplify_constants(cos(2t) * 2)
-@test expand_derivatives(D2(sin(t))) == simplify_constants(-sin(t))
-@test expand_derivatives(D2(sin(2t))) == simplify_constants(sin(2t) * -4)
-@test expand_derivatives(D2(t)) == 0
-@test expand_derivatives(D2(5)) == 0
+@test isequal(expand_derivatives(D(-7)), 0)
+@test isequal(expand_derivatives(D(sin(2t))), simplify_constants(cos(2t) * 2))
+@test isequal(expand_derivatives(D2(sin(t))), simplify_constants(-sin(t)))
+@test isequal(expand_derivatives(D2(sin(2t))), simplify_constants(sin(2t) * -4))
+@test isequal(expand_derivatives(D2(t)), 0)
+@test isequal(expand_derivatives(D2(5)), 0)
 
 # Chain rule
 dsinsin = D(sin(sin(t)))
-@test expand_derivatives(dsinsin) == cos(sin(t))*cos(t)
+@test isequal(expand_derivatives(dsinsin), cos(sin(t))*cos(t))
 
 d1 = D(sin(t)*t)
 d2 = D(sin(t)*cos(t))
-@test expand_derivatives(d1) == t*cos(t)+sin(t)
-@test expand_derivatives(d2) == simplify_constants(cos(t)*cos(t)+sin(t)*(-1*sin(t)))
+@test isequal(expand_derivatives(d1), t*cos(t)+sin(t))
+@test isequal(expand_derivatives(d2), simplify_constants(cos(t)*cos(t)+sin(t)*(-1*sin(t))))
 
 eqs = [0 ~ σ*(y-x),
        0 ~ x*(ρ-z)-y,
        0 ~ x*y - β*z]
 sys = NonlinearSystem(eqs,[x,y,z],[σ,ρ,β])
 jac = calculate_jacobian(sys)
-@test jac[1,1] == σ*-1
-@test jac[1,2] == σ
-@test jac[1,3] == 0
-@test jac[2,1] == ρ-z
-@test jac[2,2] == -1
-@test jac[2,3] == x*-1
-@test jac[3,1] == y
-@test jac[3,2] == x
-@test jac[3,3] == -1*β
+@test isequal(jac[1,1], σ*-1)
+@test isequal(jac[1,2], σ)
+@test isequal(jac[1,3], 0)
+@test isequal(jac[2,1], ρ-z)
+@test isequal(jac[2,2], -1)
+@test isequal(jac[2,3], x*-1)
+@test isequal(jac[3,1], y)
+@test isequal(jac[3,2], x)
+@test isequal(jac[3,3], -1*β)
 
 # Variable dependence checking in differentiation
 @Unknown a(t) b(a)
-@test D(b) ≠ 0
+@test !isequal(D(b), 0)
 
-@test expand_derivatives(D(x * y)) == simplify_constants(y*D(x) + x*D(y))
-@test_broken expand_derivatives(D(x * y)) == simplify_constants(D(x)*y + x*D(y))
+@test isequal(expand_derivatives(D(x * y)), simplify_constants(y*D(x) + x*D(y)))
+@test_broken isequal(expand_derivatives(D(x * y)), simplify_constants(D(x)*y + x*D(y)))
 
-@test expand_derivatives(D(2t)) == 2
-@test expand_derivatives(D(2x)) == 2D(x)
+@test isequal(expand_derivatives(D(2t)), 2)
+@test isequal(expand_derivatives(D(2x)), 2D(x))