Merge pull request #1341 from SciML/myb/scalarize

collect -> scalarize

Author: YingboMa

.github/workflows/Downstream.yml

@@ -17,13 +17,13 @@ jobs:
         julia-version: [1]
         os: [ubuntu-latest]
         package:
+          - {user: SciML, repo: SciMLBase.jl, group: Downstream}
           - {user: SciML, repo: Catalyst.jl, group: All}
           - {user: SciML, repo: CellMLToolkit.jl, group: All}
           - {user: SciML, repo: SBMLToolkit.jl, group: All}
           - {user: SciML, repo: NeuralPDE.jl, group: NNPDE}
           - {user: SciML, repo: DataDrivenDiffEq.jl, group: Standard}
           - {user: SciML, repo: StructuralIdentifiability.jl, group: All}
-          
     steps:
       - uses: actions/checkout@v2
       - uses: julia-actions/setup-julia@v1

src/systems/diffeqs/abstractodesystem.jl

@@ -173,12 +173,12 @@ function generate_rootfinding_callback(cbs, sys::ODESystem, dvs = states(sys), p
 
     rhss = map(x->x.rhs, eqs)
     root_eq_vars = unique(collect(Iterators.flatten(map(ModelingToolkit.vars, rhss))))
-    
+
     u = map(x->time_varying_as_func(value(x), sys), dvs)
     p = map(x->time_varying_as_func(value(x), sys), ps)
     t = get_iv(sys)
     rf_oop, rf_ip = build_function(rhss, u, p, t; expression=Val{false}, kwargs...)
-    
+
     affect_functions = map(cbs) do cb # Keep affect function separate
         eq_aff = affect_equations(cb)
         affect = compile_affect(eq_aff, sys, dvs, ps; kwargs...)
@@ -233,7 +233,7 @@ function compile_affect(eqs::Vector{Equation}, sys, dvs, ps; kwargs...)
         length(update_vars) == length(unique(update_vars)) == length(eqs) ||
             error("affected variables not unique, each state can only be affected by one equation for a single `root_eqs => affects` pair.")
         vars = states(sys)
-    
+
         u        = map(x->time_varying_as_func(value(x), sys), vars)
         p        = map(x->time_varying_as_func(value(x), sys), ps)
         t        = get_iv(sys)

src/systems/diffeqs/odesystem.jl

@@ -120,7 +120,7 @@ function ODESystem(
                    checks = true,
                   )
     name === nothing && throw(ArgumentError("The `name` keyword must be provided. Please consider using the `@named` macro"))
-    deqs = collect(deqs)
+    deqs = scalarize(deqs)
     @assert all(control -> any(isequal.(control, ps)), controls) "All controls must also be parameters."
 
     iv′ = value(scalarize(iv))
@@ -152,7 +152,7 @@ function ODESystem(
 end
 
 function ODESystem(eqs, iv=nothing; kwargs...)
-    eqs = collect(eqs)
+    eqs = scalarize(eqs)
     # NOTE: this assumes that the order of algebric equations doesn't matter
     diffvars = OrderedSet()
     allstates = OrderedSet()
@@ -186,7 +186,7 @@ function ODESystem(eqs, iv=nothing; kwargs...)
     end
     algevars = setdiff(allstates, diffvars)
     # the orders here are very important!
-    return ODESystem(append!(diffeq, algeeq), iv, vcat(collect(diffvars), collect(algevars)), ps; kwargs...)
+    return ODESystem(append!(diffeq, algeeq), iv, collect(Iterators.flatten((diffvars, algevars))), ps; kwargs...)
 end
 
 # NOTE: equality does not check cached Jacobian
@@ -248,7 +248,7 @@ function build_explicit_observed_function(
     vars = Set()
     foreach(Base.Fix1(vars!, vars), ts)
     ivs = independent_variables(sys)
-    dep_vars = collect(setdiff(vars, ivs))
+    dep_vars = scalarize(setdiff(vars, ivs))
 
     obs = observed(sys)
     sts = Set(states(sys))

src/systems/diffeqs/sdesystem.jl

@@ -109,7 +109,7 @@ function SDESystem(deqs::AbstractVector{<:Equation}, neqs, iv, dvs, ps;
                    checks = true,
                    )
     name === nothing && throw(ArgumentError("The `name` keyword must be provided. Please consider using the `@named` macro"))
-    deqs = collect(deqs)
+    deqs = scalarize(deqs)
     iv′ = value(iv)
     dvs′ = value.(dvs)
     ps′ = value.(ps)

src/systems/discrete_system/discrete_system.jl

@@ -83,7 +83,7 @@ function DiscreteSystem(
                    kwargs...,
                   )
     name === nothing && throw(ArgumentError("The `name` keyword must be provided. Please consider using the `@named` macro"))
-    eqs = collect(eqs)
+    eqs = scalarize(eqs)
     iv′ = value(iv)
     dvs′ = value.(dvs)
     ps′ = value.(ps)
@@ -108,7 +108,7 @@ end
 
 
 function DiscreteSystem(eqs, iv=nothing; kwargs...)
-    eqs = collect(eqs)
+    eqs = scalarize(eqs)
     # NOTE: this assumes that the order of algebric equations doesn't matter
     diffvars = OrderedSet()
     allstates = OrderedSet()
@@ -142,7 +142,7 @@ function DiscreteSystem(eqs, iv=nothing; kwargs...)
     end
     algevars = setdiff(allstates, diffvars)
     # the orders here are very important!
-    return DiscreteSystem(append!(diffeq, algeeq), iv, vcat(collect(diffvars), collect(algevars)), ps; kwargs...)
+    return DiscreteSystem(append!(diffeq, algeeq), iv, collect(Iterators.flatten((diffvars, algevars))), ps; kwargs...)
 end
 
 """

src/systems/jumps/jumpsystem.jl

@@ -74,7 +74,7 @@ function JumpSystem(eqs, iv, states, ps;
                     checks = true,
                     kwargs...)
     name === nothing && throw(ArgumentError("The `name` keyword must be provided. Please consider using the `@named` macro"))
-    eqs = collect(eqs)
+    eqs = scalarize(eqs)
     sysnames = nameof.(systems)
     if length(unique(sysnames)) != length(sysnames)
         throw(ArgumentError("System names must be unique."))

src/systems/nonlinear/nonlinearsystem.jl

@@ -77,7 +77,10 @@ function NonlinearSystem(eqs, states, ps;
         throw(ArgumentError("NonlinearSystem does not accept `continuous_events`, you provided $continuous_events"))
     name === nothing && throw(ArgumentError("The `name` keyword must be provided. Please consider using the `@named` macro"))
     # Move things over, but do not touch array expressions
-    eqs = [0 ~ x.rhs - x.lhs for x in collect(eqs)]
+    #
+    # # we cannot scalarize in the loop because `eqs` itself might require
+    # scalarization
+    eqs = [0 ~ x.rhs - x.lhs for x in scalarize(eqs)]
 
     if !(isempty(default_u0) && isempty(default_p))
         Base.depwarn("`default_u0` and `default_p` are deprecated. Use `defaults` instead.", :NonlinearSystem, force=true)
@@ -90,7 +93,7 @@ function NonlinearSystem(eqs, states, ps;
     defaults = todict(defaults)
     defaults = Dict{Any,Any}(value(k) => value(v) for (k, v) in pairs(defaults))
 
-    states = collect(states)
+    states = scalarize(states)
     states, ps = value.(states), value.(ps)
     var_to_name = Dict()
     process_variables!(var_to_name, defaults, states)