Depend on SymbolicIndexingInterface, formatting

- SymbolicIndexingInterface.jl is registered, and contains all the
  interface methods previously defined in RecursiveArrayTools
- SymbolicIndexingInterface is imported and not `using` so unexported
  `states` and `parameters` functions shouldn't need to unnecessarily
  overload the interface

Author: AayushSabharwal

Project.toml

@@ -40,6 +40,7 @@ SimpleNonlinearSolve = "727e6d20-b764-4bd8-a329-72de5adea6c7"
 SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b"
 StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
+SymbolicIndexingInterface = "2efcf032-c050-4f8e-a9bb-153293bab1f5"
 SymbolicUtils = "d1185830-fcd6-423d-90d6-eec64667417b"
 Symbolics = "0c5d862f-8b57-4792-8d23-62f2024744c7"
 UnPack = "3a884ed6-31ef-47d7-9d2a-63182c4928ed"
@@ -76,6 +77,7 @@ Setfield = "0.7, 0.8, 1"
 SimpleNonlinearSolve = "0.1.0"
 SpecialFunctions = "0.7, 0.8, 0.9, 0.10, 1.0, 2"
 StaticArrays = "0.10, 0.11, 0.12, 1.0"
+SymbolicIndexingInterface = "0.1"
 SymbolicUtils = "0.19"
 Symbolics = "4.9"
 UnPack = "0.1, 1.0"

src/ModelingToolkit.jl

@@ -33,9 +33,8 @@ import FunctionWrappersWrappers
 RuntimeGeneratedFunctions.init(@__MODULE__)
 
 using RecursiveArrayTools
-export independent_variables, states, parameters
-# using RecursiveArrayTools
 
+import SymbolicIndexingInterface
 import SymbolicUtils
 import SymbolicUtils: istree, arguments, operation, similarterm, promote_symtype,
                       Symbolic, Term, Add, Mul, Pow, Sym, FnType,

src/systems/abstractsystem.jl

@@ -148,7 +148,7 @@ function independent_variable(sys::AbstractSystem)
 end
 
 #Treat the result as a vector of symbols always
-function RecursiveArrayTools.independent_variables(sys::AbstractSystem)
+function SymbolicIndexingInterface.independent_variables(sys::AbstractSystem)
     systype = typeof(sys)
     @warn "Please declare ($systype) as a subtype of `AbstractTimeDependentSystem`, `AbstractTimeIndependentSystem` or `AbstractMultivariateSystem`."
     if isdefined(sys, :iv)
@@ -160,11 +160,11 @@ function RecursiveArrayTools.independent_variables(sys::AbstractSystem)
     end
 end
 
-function RecursiveArrayTools.independent_variables(sys::AbstractTimeDependentSystem)
+function SymbolicIndexingInterface.independent_variables(sys::AbstractTimeDependentSystem)
     [getfield(sys, :iv)]
 end
-RecursiveArrayTools.independent_variables(sys::AbstractTimeIndependentSystem) = []
-function RecursiveArrayTools.independent_variables(sys::AbstractMultivariateSystem)
+SymbolicIndexingInterface.independent_variables(sys::AbstractTimeIndependentSystem) = []
+function SymbolicIndexingInterface.independent_variables(sys::AbstractMultivariateSystem)
     getfield(sys, :ivs)
 end
 
@@ -466,15 +466,15 @@ function namespace_expr(O, sys, n = nameof(sys))
     end
 end
 
-function RecursiveArrayTools.states(sys::AbstractSystem)
+function SymbolicIndexingInterface.states(sys::AbstractSystem)
     sts = get_states(sys)
     systems = get_systems(sys)
     unique(isempty(systems) ?
            sts :
            [sts; reduce(vcat, namespace_variables.(systems))])
 end
 
-function RecursiveArrayTools.parameters(sys::AbstractSystem)
+function SymbolicIndexingInterface.parameters(sys::AbstractSystem)
     ps = get_ps(sys)
     systems = get_systems(sys)
     unique(isempty(systems) ? ps : [ps; reduce(vcat, namespace_parameters.(systems))])
@@ -509,10 +509,10 @@ function defaults(sys::AbstractSystem)
     isempty(systems) ? defs : mapfoldr(namespace_defaults, merge, systems; init = defs)
 end
 
-RecursiveArrayTools.states(sys::AbstractSystem, v) = renamespace(sys, v)
-RecursiveArrayTools.parameters(sys::AbstractSystem, v) = toparam(states(sys, v))
+states(sys::AbstractSystem, v) = renamespace(sys, v)
+parameters(sys::AbstractSystem, v) = toparam(states(sys, v))
 for f in [:states, :parameters]
-    @eval function RecursiveArrayTools.$f(sys::AbstractSystem, vs::AbstractArray)
+    @eval function $f(sys::AbstractSystem, vs::AbstractArray)
         map(v -> $f(sys, v), vs)
     end
 end
@@ -578,20 +578,20 @@ function time_varying_as_func(x, sys::AbstractTimeDependentSystem)
     return x
 end
 
-RecursiveArrayTools.is_indep_sym(sys::AbstractSystem, sym) = isequal(sym, get_iv(sys))
+SymbolicIndexingInterface.is_indep_sym(sys::AbstractSystem, sym) = isequal(sym, get_iv(sys))
 
-function RecursiveArrayTools.state_sym_to_index(sys::AbstractSystem, sym)
-    findfirst(isequal(sym), states(sys))
+function SymbolicIndexingInterface.state_sym_to_index(sys::AbstractSystem, sym)
+    findfirst(isequal(sym), SymbolicIndexingInterface.states(sys))
 end
-function RecursiveArrayTools.is_state_sym(sys::AbstractSystem, sym)
-    !isnothing(RecursiveArrayTools.state_sym_to_index(sys, sym))
+function SymbolicIndexingInterface.is_state_sym(sys::AbstractSystem, sym)
+    !isnothing(SymbolicIndexingInterface.state_sym_to_index(sys, sym))
 end
 
-function RecursiveArrayTools.param_sym_to_index(sys::AbstractSystem, sym)
-    findfirst(isequal(sym), parameters(sys))
+function SymbolicIndexingInterface.param_sym_to_index(sys::AbstractSystem, sym)
+    findfirst(isequal(sym), SymbolicIndexingInterface.parameters(sys))
 end
-function RecursiveArrayTools.is_param_sym(sys::AbstractSystem, sym)
-    !isnothing(RecursiveArrayTools.param_sym_to_index(sys, sym))
+function SymbolicIndexingInterface.is_param_sym(sys::AbstractSystem, sym)
+    !isnothing(SymbolicIndexingInterface.param_sym_to_index(sys, sym))
 end
 
 struct AbstractSysToExpr

src/systems/callbacks.jl

@@ -35,9 +35,9 @@ FunctionalAffect(; f, sts, pars, ctx = nothing) = FunctionalAffect(f, sts, pars,
 
 func(f::FunctionalAffect) = f.f
 context(a::FunctionalAffect) = a.ctx
-RecursiveArrayTools.parameters(a::FunctionalAffect) = a.pars
+parameters(a::FunctionalAffect) = a.pars
 parameters_syms(a::FunctionalAffect) = a.pars_syms
-RecursiveArrayTools.states(a::FunctionalAffect) = a.sts
+states(a::FunctionalAffect) = a.sts
 states_syms(a::FunctionalAffect) = a.sts_syms
 
 function Base.:(==)(a1::FunctionalAffect, a2::FunctionalAffect)

src/systems/connectors.jl

@@ -161,7 +161,7 @@ function Base.:(==)(l1::ConnectionElement, l2::ConnectionElement)
     nameof(l1.sys) == nameof(l2.sys) && isequal(l1.v, l2.v) && l1.isouter == l2.isouter
 end
 namespaced_var(l::ConnectionElement) = states(l, l.v)
-RecursiveArrayTools.states(l::ConnectionElement, v) = states(copy(l.sys), v)
+states(l::ConnectionElement, v) = states(copy(l.sys), v)
 
 struct ConnectionSet
     set::Vector{ConnectionElement} # namespace.sys, var, isouter

src/systems/diffeqs/sdesystem.jl

@@ -520,8 +520,7 @@ function SDEFunctionExpr{iip}(sys::SDESystem, dvs = states(sys),
                           tgrad = tgrad,
                           Wfact = Wfact,
                           Wfact_t = Wfact_t,
-                          mass_matrix = M,
-                          )
+                          mass_matrix = M)
     end
     !linenumbers ? striplines(ex) : ex
 end

src/systems/nonlinear/nonlinearsystem.jl

@@ -297,8 +297,7 @@ function NonlinearFunctionExpr{iip}(sys::NonlinearSystem, dvs = states(sys),
         jac = $_jac
         NonlinearFunction{$iip}(f,
                                 jac = jac,
-                                jac_prototype = $jp_expr,
-                                )
+                                jac_prototype = $jp_expr)
     end
     !linenumbers ? striplines(ex) : ex
 end