Merge pull request #77 from JuliaDiffEq/hg/fix/convert

Replace Expr and parse overloads with convert

Author: HarrisonGrodin

src/differentials.jl

@@ -5,7 +5,7 @@ end
 Differential(x) = Differential(x,1)
 
 Base.show(io::IO, D::Differential) = print(io,"($(D.x),$(D.order))")
-Base.Expr(D::Differential) = D
+Base.convert(::Type{Expr}, D::Differential) = D
 
 function Derivative end
 (D::Differential)(x::Operation) = Operation(D, Expression[x])
@@ -48,7 +48,7 @@ for (modu, fun, arity) ∈ DiffRules.diffrules()
             M, f = $(modu, fun)
             partials = DiffRules.diffrule(M, f, args...)
             dx = @static $arity == 1 ? partials : partials[$i]
-            parse(Operation,dx)
+            convert(Expression, dx)
         end
     end
 end

src/function_registration.jl

@@ -1,12 +1,3 @@
-# Literals treated as constants
-function Base.convert(::Type{Expression}, n::Number)
-    if !(typeof(n) <: Expression)
-        return Constant(n)
-    else
-        return n
-    end
-end
-
 # Register functions and handle literals
 macro register(sig)
     splitsig = splitdef(:($sig = nothing))

src/operations.jl

@@ -15,27 +15,10 @@ Base.:(==)(x::Nothing,y::Operation) = false
 Base.:(==)(x::Variable,y::Operation) = false
 Base.:(==)(x::Operation,y::Variable) = false
 
-function Base.Expr(O::Operation)
-    Expr(:call, Symbol(O.op), Expr.(O.args)...)
-end
-
-Base.show(io::IO,O::Operation) = print(io,string(Expr(O)))
+Base.convert(::Type{Expr}, O::Operation) =
+    build_expr(:call, Any[Symbol(O.op); convert.(Expr, O.args)])
+Base.show(io::IO, O::Operation) = print(io, convert(Expr, O))
 
-# Bigger printing
-# Is there a way to just not have this as the default?
-function Base.parse(::Type{Operation},ex::Expr)
-    f = ex.args[1]
-    operands = ex.args[2:end]
-    if ex.head == :call && any(x -> x isa Expr, ex.args)
-        args = Expression[parse(Operation,o) for o in operands]
-        parse(Operation, f, args)
-    else
-        parse(Operation, f, Expression[parse(Operation,o) for o in operands])
-    end
-end
-Base.parse(::Type{Operation},x::Expression) = x
-Base.parse(::Type{Operation},sym::Symbol,args) = Operation(eval(sym), args)
-Base.parse(::Type{Operation},x::Union{Symbol, Number}) = x
 
 """
 find_replace(O::Operation,x::Variable,y::Expression)

src/systems/diffeqs/diffeqsystem.jl

@@ -95,7 +95,7 @@ function generate_ode_jacobian(sys::DiffEqSystem,simplify=true)
     diff_exprs = sys.eqs[diff_idxs]
     jac = calculate_jacobian(sys,simplify)
     sys.jac = jac
-    jac_exprs = [:(J[$i,$j] = $(Expr(jac[i,j]))) for i in 1:size(jac,1), j in 1:size(jac,2)]
+    jac_exprs = [:(J[$i,$j] = $(convert(Expr, jac[i,j]))) for i in 1:size(jac,1), j in 1:size(jac,2)]
     exprs = vcat(var_exprs,param_exprs,vec(jac_exprs))
     block = expr_arr_to_block(exprs)
     :((J,u,p,t)->$(block))
@@ -125,11 +125,11 @@ function generate_ode_iW(sys::DiffEqSystem,simplify=true)
         iW_t = simplify_constants.(iW_t)
     end
 
-    iW_exprs = [:(iW[$i,$j] = $(Expr(iW[i,j]))) for i in 1:size(iW,1), j in 1:size(iW,2)]
+    iW_exprs = [:(iW[$i,$j] = $(convert(Expr, iW[i,j]))) for i in 1:size(iW,1), j in 1:size(iW,2)]
     exprs = vcat(var_exprs,param_exprs,vec(iW_exprs))
     block = expr_arr_to_block(exprs)
 
-    iW_t_exprs = [:(iW[$i,$j] = $(Expr(iW_t[i,j]))) for i in 1:size(iW_t,1), j in 1:size(iW_t,2)]
+    iW_t_exprs = [:(iW[$i,$j] = $(convert(Expr, iW_t[i,j]))) for i in 1:size(iW_t,1), j in 1:size(iW_t,2)]
     exprs = vcat(var_exprs,param_exprs,vec(iW_t_exprs))
     block2 = expr_arr_to_block(exprs)
     :((iW,u,p,gam,t)->$(block)),:((iW,u,p,gam,t)->$(block2))

src/systems/nonlinear/nonlinear_system.jl

@@ -59,7 +59,7 @@ function generate_nlsys_jacobian(sys::NonlinearSystem,simplify=true)
     var_exprs = [:($(sys.vs[i].name) = u[$i]) for i in 1:length(sys.vs)]
     param_exprs = [:($(sys.ps[i].name) = p[$i]) for i in 1:length(sys.ps)]
     jac = calculate_jacobian(sys,simplify)
-    jac_exprs = [:(J[$i,$j] = $(Expr(jac[i,j]))) for i in 1:size(jac,1), j in 1:size(jac,2)]
+    jac_exprs = [:(J[$i,$j] = $(convert(Expr, jac[i,j]))) for i in 1:size(jac,1), j in 1:size(jac,2)]
     exprs = vcat(var_exprs,param_exprs,vec(jac_exprs))
     block = expr_arr_to_block(exprs)
     :((J,u,p,t)->$(block))

src/utils.jl

@@ -1,9 +1,23 @@
 using MacroTools
-function expr_arr_to_block(exprs)
-  block = :(begin end)
-  foreach(expr -> push!(block.args, expr), exprs)
-  block
+
+
+function Base.convert(::Type{Expression}, ex::Expr)
+    ex.head === :call || throw(ArgumentError("internal representation does not support non-call Expr"))
+
+    op = eval(ex.args[1])  # HACK
+    args = convert.(Expression, ex.args[2:end])
+
+    return Operation(op, args)
+end
+Base.convert(::Type{Expression}, x::Expression) = x
+Base.convert(::Type{Expression}, x::Number) = Constant(x)
+
+function build_expr(head::Symbol, args)
+    ex = Expr(head)
+    append!(ex.args, args)
+    ex
 end
+expr_arr_to_block(exprs) = build_expr(:block, exprs)
 
 # used in parsing
 isblock(x) = length(x) == 1 && x[1] isa Expr && x[1].head == :block
@@ -17,7 +31,7 @@ function flatten_expr!(x)
     x
 end
 
-toexpr(ex) = MacroTools.postwalk(x->x isa Union{Expression,Operation} ? Expr(x) : x, ex)
+toexpr(ex) = MacroTools.postwalk(x -> isa(x, Expression) ? convert(Expr, x) : x, ex)
 
 is_constant(x::Variable) = x.subtype === :Constant
 is_constant(::Any) = false

src/variables.jl

@@ -86,7 +86,7 @@ function Base.:(==)(x::Number,y::Variable)
     Constant(x) == y
 end
 
-function Base.Expr(x::Variable)
+function Base.convert(::Type{Expr}, x::Variable)
     if x.subtype == :Constant
         return x.value
     elseif x.diff == nothing

test/internal.jl

@@ -6,12 +6,15 @@ using Test
 @Param b
 @DVar x(t)
 @Var y
-@test parse(Operation, 2) == 2
+@test convert(Expression, 2) == 2
 expr = :(-inv(2sqrt(+($a, $b))))
 op   = Operation(-, [Operation(inv,
                 [Operation(*, [2, Operation(sqrt,
                               [Operation(+, [a, b])])])])])
-@test parse(Operation, expr) == op
+@test convert(Expression, expr) == op
 expr1 = :($x^($y-1))
 op1   = Operation(^, [x, Operation(-, [y, 1])])
-@test parse(Operation, expr1) == op1
+@test convert(Expression, expr1) == op1
+
+@test_throws ArgumentError convert(Expression, :([a, b]))
+@test_throws ArgumentError convert(Expression, :(a ? b : c))

test/variable_parsing.jl

@@ -4,7 +4,7 @@ using Test
 @Var a=1.0 b
 a1 = Variable(:a,1.0)
 @test a1 == a
-@test Expr(a) == :a
+@test convert(Expr, a) == :a
 
 @Var begin
     a = 1.0
@@ -21,9 +21,9 @@ z1 = DependentVariable(:z,dependents = [t])
 @test x1 == x
 @test y1 == y
 @test z1 == z
-@test Expr(x) == :x
-@test Expr(y) == :y
-@test Expr(z) == :z
+@test convert(Expr, x) == :x
+@test convert(Expr, y) == :y
+@test convert(Expr, z) == :z
 
 @IVar begin
     t
@@ -33,19 +33,19 @@ t1 = IndependentVariable(:t)
 s1 = IndependentVariable(:s, cos(2.5))
 @test t1 == t
 @test s1 == s
-@test Expr(t) == :t
-@test Expr(s) == :s
-@test Expr(cos(t + sin(s))) == :(cos(t + sin(s)))
+@test convert(Expr, t) == :t
+@test convert(Expr, s) == :s
+@test convert(Expr, cos(t + sin(s))) == :(cos(t + sin(s)))
 
 @Deriv D''~t
 D1 = Differential(t, 2)
 @test D1 == D
-@test Expr(D) == D
+@test convert(Expr, D) == D
 
 @Const c=0 v=2
 c1 = Constant(0)
 v1 = Constant(2)
 @test c1 == c
 @test v1 == v
-@test Expr(c) == 0
-@test Expr(v) == 2
+@test convert(Expr, c) == 0
+@test convert(Expr, v) == 2