Fix independent variable usage

Author: HarrisonGrodin

README.md

@@ -95,11 +95,11 @@ nlsys_func = generate_function(ns)
 which generates:
 
 ```julia
-:((##366, u, p, t)->begin
-          let (y, z, x, ρ, σ, β) = (u[1], u[2], u[3], p[1], p[2], p[3])
-              ##366[1] = σ * (y - x)
-              ##366[2] = x * (ρ - z) - y
-              ##366[3] = x * y - β * z
+:((##364, u, p)->begin
+          let (x, z, y, ρ, σ, β) = (u[1], u[2], u[3], p[1], p[2], p[3])
+              ##364[1] = σ * (y - x)
+              ##364[2] = x * (ρ - z) - y
+              ##364[3] = x * y - β * z
           end
       end)
 ```
@@ -279,11 +279,11 @@ nlsys_func = generate_function(ns)
 expands to:
 
 ```julia
-:((##367, u, p, t)->begin
+:((##365, u, p)->begin
           let (x, y, z, σ, ρ, β) = (u[1], u[2], u[3], p[1], p[2], p[3])
-              ##367[1] = σ * (y - x)
-              ##367[2] = x * (ρ - z) - y
-              ##367[3] = x * y - β * z
+              ##365[1] = σ * (y - x)
+              ##365[2] = x * (ρ - z) - y
+              ##365[3] = x * y - β * z
           end
       end)
 ```

src/systems/diffeqs/diffeqsystem.jl

@@ -15,7 +15,6 @@ function Base.convert(::Type{DiffEq}, eq::Equation)
     isintermediate(eq) && throw(ArgumentError("intermediate equation received"))
     return DiffEq(eq.lhs.op, eq.lhs.args[1], eq.rhs)
 end
-Base.convert(::Type{Equation}, eq::DiffEq) = Equation(eq.D(eq.var), eq.rhs)
 Base.:(==)(a::DiffEq, b::DiffEq) = (a.D, a.var, a.rhs) == (b.D, b.var, b.rhs)
 get_args(eq::DiffEq) = Expression[eq.var, eq.rhs]
 
@@ -55,9 +54,15 @@ function calculate_jacobian(sys::DiffEqSystem)
     return jac
 end
 
-system_eqs(sys::DiffEqSystem) = collect(Equation, sys.eqs)
-system_vars(sys::DiffEqSystem) = sys.dvs
-system_params(sys::DiffEqSystem) = sys.ps
+function generate_jacobian(sys::DiffEqSystem; version::FunctionVersion = ArrayFunction)
+    jac = calculate_jacobian(sys)
+    return build_function(jac, sys.dvs, sys.ps, (sys.iv.name,); version = version)
+end
+
+function generate_function(sys::DiffEqSystem; version::FunctionVersion = ArrayFunction)
+    rhss = [eq.rhs for eq ∈ sys.eqs]
+    return build_function(rhss, sys.dvs, sys.ps, (sys.iv.name,); version = version)
+end
 
 
 function generate_ode_iW(sys::DiffEqSystem, simplify=true; version::FunctionVersion = ArrayFunction)
@@ -80,7 +85,7 @@ function generate_ode_iW(sys::DiffEqSystem, simplify=true; version::FunctionVers
         iW_t = simplify_constants.(iW_t)
     end
 
-    vs, ps = system_vars(sys), system_params(sys)
+    vs, ps = sys.dvs, sys.ps
     iW_func   = build_function(iW  , vs, ps, (:gam,:t); version = version)
     iW_t_func = build_function(iW_t, vs, ps, (:gam,:t); version = version)
 

src/systems/nonlinear/nonlinear_system.jl

@@ -8,7 +8,6 @@ function Base.convert(::Type{NLEq}, eq::Equation)
     isequal(eq.lhs, Constant(0)) || return NLEq(eq.rhs - eq.lhs)
     return NLEq(eq.rhs)
 end
-Base.convert(::Type{Equation}, eq::NLEq) = Equation(0, eq.rhs)
 Base.:(==)(a::NLEq, b::NLEq) = a.rhs == b.rhs
 get_args(eq::NLEq) = Expression[eq.rhs]
 
@@ -30,6 +29,12 @@ function calculate_jacobian(sys::NonlinearSystem)
     return jac
 end
 
-system_eqs(sys::NonlinearSystem) = collect(Equation, sys.eqs)
-system_vars(sys::NonlinearSystem) = sys.vs
-system_params(sys::NonlinearSystem) = sys.ps
+function generate_jacobian(sys::NonlinearSystem; version::FunctionVersion = ArrayFunction)
+    jac = calculate_jacobian(sys)
+    return build_function(jac, sys.vs, sys.ps; version = version)
+end
+
+function generate_function(sys::NonlinearSystem; version::FunctionVersion = ArrayFunction)
+    rhss = [eq.rhs for eq ∈ sys.eqs]
+    return build_function(rhss, sys.vs, sys.ps; version = version)
+end

src/systems/systems.jl

@@ -3,26 +3,13 @@ export generate_jacobian, generate_function
 
 abstract type AbstractSystem end
 
-function system_eqs    end
-function system_vars   end
-function system_params end
+function generate_jacobian end
+function generate_function end
 
-function generate_jacobian(sys::AbstractSystem; version = ArrayFunction)
-    vs, ps = system_vars(sys), system_params(sys)
-    jac = calculate_jacobian(sys)
-    return build_function(jac, vs, ps, (:t,); version = version)
-end
-
-function generate_function(sys::AbstractSystem; version::FunctionVersion = ArrayFunction)
-    sys_eqs = system_eqs(sys)
-    vs, ps = system_vars(sys), system_params(sys)
-    return build_function([eq.rhs for eq ∈ sys_eqs], vs, ps, (:t,); version = version)
-end
-
-function build_function(rhss, vs, ps, args; version::FunctionVersion)
+function build_function(rhss, vs, ps, args = (); version::FunctionVersion)
     var_pairs   = [(u.name, :(u[$i])) for (i, u) ∈ enumerate(vs)]
     param_pairs = [(p.name, :(p[$i])) for (i, p) ∈ enumerate(ps)]
-    (ls, rs) = collect(zip(var_pairs..., param_pairs...))
+    (ls, rs) = zip(var_pairs..., param_pairs...)
 
     var_eqs = Expr(:(=), build_expr(:tuple, ls), build_expr(:tuple, rs))