Rename DiffEqSystem to ODESystem

Author: HarrisonGrodin

README.md

@@ -43,11 +43,11 @@ eqs = [D(x) ~ σ*(y-x),
 
 Each operation builds an `Operation` type, and thus `eqs` is an array of
 `Operation` and `Variable`s. This holds a tree of the full system that can be
-analyzed by other programs. We can turn this into a `DiffEqSystem` via:
+analyzed by other programs. We can turn this into a `ODESystem` via:
 
 ```julia
-de = DiffEqSystem(eqs,t,[x,y,z],[σ,ρ,β])
-de = DiffEqSystem(eqs)
+de = ODESystem(eqs,t,[x,y,z],[σ,ρ,β])
+de = ODESystem(eqs)
 ```
 
 where we tell it the variable types and ordering in the first version, or let it

src/systems/diffeqs/diffeqsystem.jl

@@ -1,4 +1,4 @@
-export DiffEqSystem, ODEFunction
+export ODESystem, ODEFunction
 
 
 using Base: RefValue
@@ -31,13 +31,13 @@ function to_diffeq(eq::Equation)
 end
 Base.:(==)(a::DiffEq, b::DiffEq) = isequal((a.x, a.t, a.n, a.rhs), (b.x, b.t, b.n, b.rhs))
 
-struct DiffEqSystem <: AbstractSystem
+struct ODESystem <: AbstractSystem
     eqs::Vector{DiffEq}
     iv::Variable
     dvs::Vector{Variable}
     ps::Vector{Variable}
     jac::RefValue{Matrix{Expression}}
-    function DiffEqSystem(eqs)
+    function ODESystem(eqs)
         reformatted = to_diffeq.(eqs)
 
         ivs = unique(r[1] for r ∈ reformatted)
@@ -58,7 +58,7 @@ struct DiffEqSystem <: AbstractSystem
 end
 
 
-function calculate_jacobian(sys::DiffEqSystem)
+function calculate_jacobian(sys::ODESystem)
     isempty(sys.jac[]) || return sys.jac[]  # use cached Jacobian, if possible
     rhs = [eq.rhs for eq ∈ sys.eqs]
 
@@ -67,13 +67,13 @@ function calculate_jacobian(sys::DiffEqSystem)
     return jac
 end
 
-function generate_jacobian(sys::DiffEqSystem; version::FunctionVersion = ArrayFunction)
+function generate_jacobian(sys::ODESystem; version::FunctionVersion = ArrayFunction)
     jac = calculate_jacobian(sys)
     return build_function(jac, sys.dvs, sys.ps, (sys.iv.name,); version = version)
 end
 
 struct DiffEqToExpr
-    sys::DiffEqSystem
+    sys::ODESystem
 end
 function (f::DiffEqToExpr)(O::Operation)
     if isa(O.op, Variable)
@@ -86,15 +86,15 @@ function (f::DiffEqToExpr)(O::Operation)
 end
 (f::DiffEqToExpr)(x) = convert(Expr, x)
 
-function generate_function(sys::DiffEqSystem, vs, ps; version::FunctionVersion = ArrayFunction)
+function generate_function(sys::ODESystem, vs, ps; version::FunctionVersion = ArrayFunction)
     rhss = [deq.rhs for deq ∈ sys.eqs]
     vs′ = [clean(v) for v ∈ vs]
     ps′ = [clean(p) for p ∈ ps]
     return build_function(rhss, vs′, ps′, (sys.iv.name,), DiffEqToExpr(sys); version = version)
 end
 
 
-function generate_ode_iW(sys::DiffEqSystem, simplify=true; version::FunctionVersion = ArrayFunction)
+function generate_ode_iW(sys::ODESystem, simplify=true; version::FunctionVersion = ArrayFunction)
     jac = calculate_jacobian(sys)
 
     gam = Variable(:gam; known = true)()
@@ -121,7 +121,7 @@ function generate_ode_iW(sys::DiffEqSystem, simplify=true; version::FunctionVers
     return (iW_func, iW_t_func)
 end
 
-function DiffEqBase.ODEFunction(sys::DiffEqSystem; version::FunctionVersion = ArrayFunction)
+function DiffEqBase.ODEFunction(sys::ODESystem; version::FunctionVersion = ArrayFunction)
     expr = generate_function(sys; version = version)
     if version === ArrayFunction
         ODEFunction{true}(eval(expr))

src/systems/diffeqs/first_order_transform.jl

@@ -7,9 +7,9 @@ function lower_varname(var::Variable, idv, order)
     return Variable(name; known = var.known)
 end
 
-function ode_order_lowering(sys::DiffEqSystem)
+function ode_order_lowering(sys::ODESystem)
     eqs_lowered = ode_order_lowering(sys.eqs, sys.iv)
-    DiffEqSystem(eqs_lowered, sys.iv, sys.dvs, sys.ps)
+    ODESystem(eqs_lowered, sys.iv, sys.dvs, sys.ps)
 end
 function ode_order_lowering(eqs, iv)
     var_order = Dict{Variable,Int}()

test/system_construction.jl

@@ -7,7 +7,7 @@ using Test
 @derivatives D'~t
 
 function test_diffeq_inference(name, de, iv, dvs, ps)
-    @testset "DiffEqSystem construction: $name" begin
+    @testset "ODESystem construction: $name" begin
         @test de.iv.name == :t
         @test Set([dv.name for dv ∈ de.dvs]) == Set(dvs)
         @test Set([p.name  for p  ∈ de.ps ]) == Set(ps)
@@ -18,7 +18,7 @@ end
 eqs = [D(x) ~ σ*(y-x),
        D(y) ~ x*(ρ-z)-y,
        D(z) ~ x*y - β*z]
-de = DiffEqSystem(eqs)
+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)
@@ -34,7 +34,7 @@ ModelingToolkit.generate_ode_iW(de)
     eqs = [D(x) ~ σ′*(y-x),
            D(y) ~ x*(ρ-z)-y,
            D(z) ~ x*y - β*z]
-    de = DiffEqSystem(eqs)
+    de = ODESystem(eqs)
     test_diffeq_inference("global iv-varying", de, :t, (:x, :y, :z), (:σ′, :ρ, :β))
     @test begin
         f = eval(generate_function(de, [x,y,z], [σ′,ρ,β]))
@@ -47,7 +47,7 @@ ModelingToolkit.generate_ode_iW(de)
     eqs = [D(x) ~ σ(t-1)*(y-x),
            D(y) ~ x*(ρ-z)-y,
            D(z) ~ x*y - β*z]
-    de = DiffEqSystem(eqs)
+    de = ODESystem(eqs)
     test_diffeq_inference("single internal iv-varying", de, :t, (:x, :y, :z), (:σ, :ρ, :β))
     @test begin
         f = eval(generate_function(de, [x,y,z], [σ,ρ,β]))
@@ -57,7 +57,7 @@ ModelingToolkit.generate_ode_iW(de)
     end
 
     eqs = [D(x) ~ x + 10σ(t-1) + 100σ(t-2) + 1000σ(t^2)]
-    de = DiffEqSystem(eqs)
+    de = ODESystem(eqs)
     test_diffeq_inference("many internal iv-varying", de, :t, (:x,), (:σ,))
     @test begin
         f = eval(generate_function(de, [x], [σ]))
@@ -74,7 +74,7 @@ end
 @variables u(t) u_tt(t) u_t(t) x_t(t)
 eqs = [D3(u) ~ 2(D2(u)) + D(u) + D(x) + 1
        D2(x) ~ D(x) + 2]
-de = DiffEqSystem(eqs, t)
+de = ODESystem(eqs, t)
 de1 = ode_order_lowering(de)
 lowered_eqs = [D(u_tt) ~ 2u_tt + u_t + x_t + 1
                D(x_t)  ~ x_t + 2
@@ -89,7 +89,7 @@ a = y - x
 eqs = [D(x) ~ σ*a,
        D(y) ~ x*(ρ-z)-y,
        D(z) ~ x*y - β*z]
-de = DiffEqSystem(eqs)
+de = ODESystem(eqs)
 generate_function(de, [x,y,z], [σ,ρ,β])
 jac = calculate_jacobian(de)
 @test_broken begin
@@ -117,7 +117,7 @@ end
 _x = y / C
 eqs = [D(x) ~ -A*x,
        D(y) ~ A*x - B*_x]
-de = DiffEqSystem(eqs)
+de = ODESystem(eqs)
 @test begin
     f = eval(generate_function(de, [x,y], [A,B,C]))
     du = [0.0,0.0]