finish up dispatching-based versions

Author: ChrisRackauckas

src/systems/diffeqs/diffeqsystem.jl

@@ -152,14 +152,12 @@ function (f::ODEToExpr)(O::Operation)
 end
 (f::ODEToExpr)(x) = convert(Expr, x)
 
-function generate_jacobian(sys::ODESystem; version::FunctionVersion = nothing)
-    version != nothing && @warn("version is deprecated. Both dispatches are now constructed in the same function by defualt.")
+function generate_jacobian(sys::ODESystem, dvs = sys.dvs, ps = sys.ps)
     jac = calculate_jacobian(sys)
-    return build_function(jac, sys.dvs, sys.ps, (sys.iv.name,), ODEToExpr(sys))
+    return build_function(jac, dvs, ps, (sys.iv.name,), ODEToExpr(sys))
 end
 
-function generate_function(sys::ODESystem, dvs, ps; version::FunctionVersion = nothing)
-    version != nothing && @warn("version is deprecated. Both dispatches are now constructed in the same function by defualt.")
+function generate_function(sys::ODESystem, dvs = sys.dvs, ps = sys.ps)
     rhss = [deq.rhs for deq ∈ sys.eqs]
     dvs′ = [clean(dv) for dv ∈ dvs]
     ps′ = [clean(p) for p ∈ ps]
@@ -190,21 +188,14 @@ function calculate_factorized_W(sys::ODESystem, simplify=true)
     (Wfact,Wfact_t)
 end
 
-function generate_factorized_W(sys::ODESystem, simplify=true; version::FunctionVersion = nothing)
-    version != nothing && @warn("version is deprecated. Both dispatches are now constructed in the same function by defualt.")
+function generate_factorized_W(sys::ODESystem, vs = sys.dvs, ps = sys.ps, simplify=true)
     (Wfact,Wfact_t) = calculate_factorized_W(sys,simplify)
+    siz = size(Wfact)
+    constructor = :(x -> begin
+                        A = SMatrix{$siz...}(x)
+                        StaticArrays.LU(LowerTriangular( SMatrix{$siz...}(UnitLowerTriangular(A)) ), UpperTriangular(A), SVector(ntuple(n->n, max($siz...))))
+                    end)
 
-    if version === SArrayFunction
-        siz = size(Wfact)
-        constructor = :(x -> begin
-                            A = SMatrix{$siz...}(x)
-                            StaticArrays.LU(LowerTriangular( SMatrix{$siz...}(UnitLowerTriangular(A)) ), UpperTriangular(A), SVector(ntuple(n->n, max($siz...))))
-                        end)
-    else
-        constructor = nothing
-    end
-
-    vs, ps = sys.dvs, sys.ps
     Wfact_func   = build_function(Wfact  , vs, ps, (:gam,:t), ODEToExpr(sys);constructor=constructor)
     Wfact_t_func = build_function(Wfact_t, vs, ps, (:gam,:t), ODEToExpr(sys);constructor=constructor)
 
@@ -218,12 +209,12 @@ Create an `ODEFunction` from the [`ODESystem`](@ref). The arguments `dvs` and `p
 are used to set the order of the dependent variable and parameter vectors,
 respectively.
 """
-function DiffEqBase.ODEFunction{iip}(sys::ODESystem, dvs, ps; version::FunctionVersion = nothing,
-                                                         jac = false, Wfact = false) where iip
-    version != nothing && @warn("version is deprecated. Both dispatches are now constructed in the same function by defualt.")
+function DiffEqBase.ODEFunction{iip}(sys::ODESystem, dvs, ps;
+                                     version = nothing,
+                                     jac = false, Wfact = false) where iip
     expr = eval(generate_function(sys, dvs, ps))
-    jac_expr = jac ? nothing : eval(generate_jacobian(sys))
-    Wfact_expr,Wfact_t_expr = Wfact ? (nothing,nothing) : eval.(generate_factorized_W(sys))
+    jac_expr = jac ? nothing : eval(generate_jacobian(sys, dvs, ps))
+    Wfact_expr,Wfact_t_expr = Wfact ? (nothing,nothing) : eval.(generate_factorized_W(sys, dvs, ps))
     ODEFunction{iip}(eval(expr),jac=jac_expr,
                       Wfact = Wfact_expr, Wfact_t = Wfact_t_expr)
 end

src/systems/nonlinear/nonlinear_system.jl

@@ -66,9 +66,9 @@ function calculate_jacobian(sys::NonlinearSystem)
     return jac
 end
 
-function generate_jacobian(sys::NonlinearSystem; version::FunctionVersion = ArrayFunction)
+function generate_jacobian(sys::NonlinearSystem)
     jac = calculate_jacobian(sys)
-    return build_function(jac, clean.(sys.vs), sys.ps, (), NLSysToExpr(sys); version = version)
+    return build_function(jac, clean.(sys.vs), sys.ps, (), NLSysToExpr(sys))
 end
 
 struct NLSysToExpr
@@ -85,9 +85,9 @@ end
 (f::NLSysToExpr)(x) = convert(Expr, x)
 
 
-function generate_function(sys::NonlinearSystem, vs, ps; version::FunctionVersion = ArrayFunction)
+function generate_function(sys::NonlinearSystem, vs, ps; version = nothing)
     rhss = [eq.rhs for eq ∈ sys.eqs]
     vs′ = [clean(v) for v ∈ vs]
     ps′ = [clean(p) for p ∈ ps]
-    return build_function(rhss, vs′, ps′, (), NLSysToExpr(sys); version = version)
+    return build_function(rhss, vs′, ps′, (), NLSysToExpr(sys))
 end

src/utils.jl

@@ -31,10 +31,11 @@ function flatten_expr!(x)
     x
 end
 
-function build_function(rhss, vs, ps, args = (), conv = rhs -> convert(Expr, rhs); version::FunctionVersion=nothing, constructor=nothing)
-    version != nothing && @warn("version is deprecated. Both dispatches are now constructed in the same function by defualt.")
-    var_pairs   = [(u.name, :(u[$i])) for (i, u) ∈ enumerate(vs)]
-    param_pairs = [(p.name, :(p[$i])) for (i, p) ∈ enumerate(ps)]
+function build_function(rhss, vs, ps, args = (), conv = rhs -> convert(Expr, rhs); constructor=nothing)
+    _vs = map(x-> x isa Operation ? x.op : x, vs)
+    _ps = map(x-> x isa Operation ? x.op : x, ps)
+    var_pairs   = [(u.name, :(u[$i])) for (i, u) ∈ enumerate(_vs)]
+    param_pairs = [(p.name, :(p[$i])) for (i, p) ∈ enumerate(_ps)]
     (ls, rs) = zip(var_pairs..., param_pairs...)
 
     var_eqs = Expr(:(=), build_expr(:tuple, ls), build_expr(:tuple, rs))

test/system_construction.jl

@@ -32,7 +32,6 @@ eqs = [D(x) ~ σ*(y-x),
 de = ODESystem(eqs)
 test_diffeq_inference("standard", de, t, (x, y, z), (σ, ρ, β))
 generate_function(de, [x,y,z], [σ,ρ,β])
-generate_function(de, [x,y,z], [σ,ρ,β]; version=ModelingToolkit.SArrayFunction)
 jac_expr = generate_jacobian(de)
 jac = calculate_jacobian(de)
 jacfun = eval(jac_expr)
@@ -52,8 +51,8 @@ FWt = zeros(3, 3)
 fw(FW, u, p, 0.2, 0.1)
 fwt(FWt, u, p, 0.2, 0.1)
 # oop
-f = ODEFunction(de, [x,y,z], [σ,ρ,β]; version=ModelingToolkit.SArrayFunction)
-fw, fwt = map(eval, ModelingToolkit.generate_factorized_W(de; version=ModelingToolkit.SArrayFunction))
+f = ODEFunction(de, [x,y,z], [σ,ρ,β])
+fw, fwt = map(eval, ModelingToolkit.generate_factorized_W(de))
 du = @SArray zeros(3)
 u  = SVector(1:3...)
 p  = SVector(4:6...)