refactor: format with v2

Author: AayushSabharwal

docs/src/API/variables.md

@@ -293,7 +293,7 @@ For systems that contain parameters with metadata like described above, have som
 In the example below, we define a system with tunable parameters and extract bounds vectors
 
 ```@example metadata
-@variables x(t)=0 u(t)=0 [input = true] y(t)=0 [output = true]
+@variables x(t)=0 u(t)=0 [input=true] y(t)=0 [output=true]
 @parameters T [tunable = true, bounds = (0, Inf)]
 @parameters k [tunable = true, bounds = (0, Inf)]
 eqs = [D(x) ~ (-x + k * u) / T # A first-order system with time constant T and gain k

docs/src/basics/Events.md

@@ -92,8 +92,8 @@ The basic purely symbolic continuous event interface to encode *one* continuous
 event is
 
 ```julia
-AbstractSystem(eqs, ...; continuous_events::Vector{Equation})
-AbstractSystem(eqs, ...; continuous_events::Pair{Vector{Equation}, Vector{Equation}})
+AbstractSystem(eqs, _...; continuous_events::Vector{Equation})
+AbstractSystem(eqs, _...; continuous_events::Pair{Vector{Equation}, Vector{Equation}})
 ```
 
 In the former, equations that evaluate to 0 will represent conditions that should
@@ -272,7 +272,7 @@ In addition to continuous events, discrete events are also supported. The
 general interface to represent a collection of discrete events is
 
 ```julia
-AbstractSystem(eqs, ...; discrete_events = [condition1 => affect1, condition2 => affect2])
+AbstractSystem(eqs, _...; discrete_events = [condition1 => affect1, condition2 => affect2])
 ```
 
 where conditions are symbolic expressions that should evaluate to `true` when an
@@ -497,7 +497,8 @@ so far we aren't using anything that's not possible with the implicit interface.
 You can also write
 
 ```julia
-[temp ~ furnace_off_threshold] => ModelingToolkit.ImperativeAffect(modified = (;
+[temp ~
+ furnace_off_threshold] => ModelingToolkit.ImperativeAffect(modified = (;
     furnace_on)) do x, o, i, c
     @set! x.furnace_on = false
 end

docs/src/basics/FAQ.md

@@ -63,7 +63,7 @@ The same principle applies to any parameter type that is not `Float64`.
 @parameters p1::Int # integer-valued
 @parameters p2::Bool # boolean-valued
 @parameters p3::MyCustomStructType # non-numeric
-@parameters p4::ComponentArray{...} # non-standard array
+@parameters p4::ComponentArray{_...} # non-standard array
 ```
 
 ## Getting the index for a symbol

docs/src/basics/MTKLanguage.md

@@ -381,7 +381,8 @@ Refer the following example for different ways to define symbolic arrays.
     @parameters begin
         p1[1:4]
         p2[1:N]
-        p3[1:N, 1:M] = 10,
+        p3[1:N,
+            1:M] = 10,
         [description = "A multi-dimensional array of arbitrary length with description"]
         (p4[1:N, 1:M] = 10),
         [description = "An alternate syntax for p3 to match the syntax of vanilla parameters macro"]

docs/src/basics/Validation.md

@@ -108,7 +108,7 @@ function ModelingToolkit.get_unit(op::typeof(dummycomplex), args)
 end
 
 sts = @variables a(t)=0 [unit = u"cm"]
-ps = @parameters s=-1 [unit = u"cm"] c=c [unit = u"cm"]
+ps = @parameters s=-1 [unit=u"cm"] c=c [unit=u"cm"]
 eqs = [D(a) ~ dummycomplex(c, s);]
 sys = System(
     eqs, t, [sts...;], [ps...;], name = :sys, checks = ~ModelingToolkit.CheckUnits)

docs/src/examples/sparse_jacobians.md

@@ -23,15 +23,20 @@ function brusselator_2d_loop(du, u, p, t)
     @inbounds for I in CartesianIndices((N, N))
         i, j = Tuple(I)
         x, y = xyd_brusselator[I[1]], xyd_brusselator[I[2]]
-        ip1, im1, jp1, jm1 = limit(i + 1, N), limit(i - 1, N), limit(j + 1, N),
+        ip1, im1, jp1,
+        jm1 = limit(i + 1, N), limit(i - 1, N), limit(j + 1, N),
         limit(j - 1, N)
-        du[i, j, 1] = alpha * (u[im1, j, 1] + u[ip1, j, 1] + u[i, jp1, 1] + u[i, jm1, 1] -
-                       4u[i, j, 1]) +
-                      B + u[i, j, 1]^2 * u[i, j, 2] - (A + 1) * u[i, j, 1] +
-                      brusselator_f(x, y, t)
-        du[i, j, 2] = alpha * (u[im1, j, 2] + u[ip1, j, 2] + u[i, jp1, 2] + u[i, jm1, 2] -
-                       4u[i, j, 2]) +
-                      A * u[i, j, 1] - u[i, j, 1]^2 * u[i, j, 2]
+        du[i,
+            j,
+            1] = alpha * (u[im1, j, 1] + u[ip1, j, 1] + u[i, jp1, 1] + u[i, jm1, 1] -
+                  4u[i, j, 1]) +
+                 B + u[i, j, 1]^2 * u[i, j, 2] - (A + 1) * u[i, j, 1] +
+                 brusselator_f(x, y, t)
+        du[i,
+            j,
+            2] = alpha * (u[im1, j, 2] + u[ip1, j, 2] + u[i, jp1, 2] + u[i, jm1, 2] -
+                  4u[i, j, 2]) +
+                 A * u[i, j, 1] - u[i, j, 1]^2 * u[i, j, 2]
     end
 end
 p = (3.4, 1.0, 10.0, step(xyd_brusselator))

docs/src/examples/tearing_parallelism.md

@@ -15,7 +15,7 @@ using ModelingToolkit: t_nounits as t, D_nounits as D
 
 # Basic electric components
 @connector function Pin(; name)
-    @variables v(t)=1.0 i(t)=1.0 [connect = Flow]
+    @variables v(t)=1.0 i(t)=1.0 [connect=Flow]
     System(Equation[], t, [v, i], [], name = name)
 end
 
@@ -36,7 +36,7 @@ function ConstantVoltage(; name, V = 1.0)
 end
 
 @connector function HeatPort(; name)
-    @variables T(t)=293.15 Q_flow(t)=0.0 [connect = Flow]
+    @variables T(t)=293.15 Q_flow(t)=0.0 [connect=Flow]
     System(Equation[], t, [T, Q_flow], [], name = name)
 end
 

docs/src/tutorials/disturbance_modeling.md

@@ -188,7 +188,9 @@ disturbance_inputs = [ssys.d1, ssys.d2]
 P = ssys.system_model
 outputs = [P.inertia1.phi, P.inertia2.phi, P.inertia1.w, P.inertia2.w]
 
-(f_oop, f_ip), x_sym, p_sym, io_sys = ModelingToolkit.generate_control_function(
+(f_oop, f_ip), x_sym,
+p_sym,
+io_sys = ModelingToolkit.generate_control_function(
     model_with_disturbance, inputs, disturbance_inputs; disturbance_argument = true)
 
 g = ModelingToolkit.build_explicit_observed_function(

docs/src/tutorials/linear_analysis.md

@@ -39,7 +39,7 @@ This is signified by the name being the middle argument to `connect`.
 Of the above mentioned functions, all except for [`open_loop`](@ref) return the output of [`ModelingToolkit.linearize`](@ref), which is
 
 ```julia
-matrices, simplified_sys = linearize(...)
+matrices, simplified_sys = linearize(_...)
 # matrices = (; A, B, C, D)
 ```
 

ext/MTKCasADiDynamicOptExt.jl

@@ -67,7 +67,8 @@ function MTK.CasADiDynamicOptProblem(sys::System, op, tspan;
         dt = nothing,
         steps = nothing,
         guesses = Dict(), kwargs...)
-    prob, _ = MTK.process_DynamicOptProblem(
+    prob,
+    _ = MTK.process_DynamicOptProblem(
         CasADiDynamicOptProblem, CasADiModel, sys, op, tspan; dt, steps, guesses, kwargs...)
     prob
 end

ext/MTKInfiniteOptExt.jl

@@ -82,7 +82,8 @@ function MTK.JuMPDynamicOptProblem(sys::System, op, tspan;
         dt = nothing,
         steps = nothing,
         guesses = Dict(), kwargs...)
-    prob, _ = MTK.process_DynamicOptProblem(JuMPDynamicOptProblem, InfiniteOptModel, sys,
+    prob,
+    _ = MTK.process_DynamicOptProblem(JuMPDynamicOptProblem, InfiniteOptModel, sys,
         op, tspan; dt, steps, guesses, kwargs...)
     prob
 end
@@ -91,7 +92,8 @@ function MTK.InfiniteOptDynamicOptProblem(sys::System, op, tspan;
         dt = nothing,
         steps = nothing,
         guesses = Dict(), kwargs...)
-    prob, pmap = MTK.process_DynamicOptProblem(
+    prob,
+    pmap = MTK.process_DynamicOptProblem(
         InfiniteOptDynamicOptProblem, InfiniteOptModel,
         sys, op, tspan; dt, steps, guesses, kwargs...)
     MTK.add_equational_constraints!(prob.wrapped_model, sys, pmap, tspan)

src/bipartite_graph.jl

@@ -29,7 +29,7 @@ Base.iterate(u::Unassigned, state) = nothing
 
 Base.show(io::IO, ::Unassigned) = printstyled(io, "u"; color = :light_black)
 
-struct Matching{U, V <: AbstractVector} <: AbstractVector{Union{U, Int}} #=> :Unassigned =#
+struct Matching{U, V <: AbstractVector} <: AbstractVector{Union{U, Int}}
     match::V
     inv_match::Union{Nothing, V}
 end
@@ -608,6 +608,7 @@ function Graphs.incidence_matrix(g::BipartiteGraph, val = true)
     I = Int[]
     J = Int[]
     for i in 𝑠vertices(g), n in 𝑠neighbors(g, i)
+
         push!(I, i)
         push!(J, n)
     end

src/deprecations.jl

@@ -62,6 +62,7 @@ for T in [:ODEProblem, :DDEProblem, :SDEProblem, :SDDEProblem, :DAEProblem,
     end
 
     for pType in [SciMLBase.NullParameters, Nothing], uType in [Any, Nothing]
+
         @eval function SciMLBase.$T(sys::System, u0::$uType, tspan, p::$pType; kw...)
             ctor = string($T)
             pT = string($(QuoteNode(pType)))
@@ -142,6 +143,7 @@ for T in [:NonlinearProblem, :NonlinearLeastSquaresProblem,
         end
     end
     for pType in [SciMLBase.NullParameters, Nothing], uType in [Any, Nothing]
+
         @eval function SciMLBase.$T(sys::System, u0::$uType, p::$pType; kw...)
             ctor = string($T)
             pT = string($(QuoteNode(pType)))

src/inputoutput.jl

@@ -120,7 +120,7 @@ function same_or_inner_namespace(u, var)
     nu == nv ||           # namespaces are the same
         startswith(nv, nu) || # or nv starts with nu, i.e., nv is an inner namespace to nu
         occursin(NAMESPACE_SEPARATOR, string(getname(var))) &&
-            !occursin(NAMESPACE_SEPARATOR, string(getname(u))) # or u is top level but var is internal
+        !occursin(NAMESPACE_SEPARATOR, string(getname(u))) # or u is top level but var is internal
 end
 
 function inner_namespace(u, var)
@@ -129,7 +129,7 @@ function inner_namespace(u, var)
     nu == nv && return false
     startswith(nv, nu) || # or nv starts with nu, i.e., nv is an inner namespace to nu
         occursin(NAMESPACE_SEPARATOR, string(getname(var))) &&
-            !occursin(NAMESPACE_SEPARATOR, string(getname(u))) # or u is top level but var is internal
+        !occursin(NAMESPACE_SEPARATOR, string(getname(u))) # or u is top level but var is internal
 end
 
 """

src/linearization.jl

@@ -297,7 +297,8 @@ function (linfun::LinearizationFunction)(u, p, t)
             error("Number of unknown variables ($(linfun.num_states)) does not match the number of input unknowns ($(length(u)))")
         integ_cache = (linfun.caches,)
         integ = MockIntegrator{true}(u, p, t, fun, integ_cache, nothing)
-        u, p, success = SciMLBase.get_initial_values(
+        u, p,
+        success = SciMLBase.get_initial_values(
             linfun.prob, integ, fun, linfun.initializealg, Val(true);
             linfun.initialize_kwargs...)
         if !success
@@ -744,7 +745,8 @@ function linearize(sys, inputs, outputs; op = Dict(), t = 0.0,
         allow_input_derivatives = false,
         zero_dummy_der = false,
         kwargs...)
-    lin_fun, ssys = linearization_function(sys,
+    lin_fun,
+    ssys = linearization_function(sys,
         inputs,
         outputs;
         zero_dummy_der,

src/modelingtoolkitize/sdeproblem.jl

@@ -26,7 +26,8 @@ function modelingtoolkitize(
     odefn = ODEFunction{SciMLBase.isinplace(prob)}(
         prob.f.f; mass_matrix = prob.f.mass_matrix, sys = prob.f.sys)
     odeprob = ODEProblem(odefn, prob.u0, prob.tspan, prob.p)
-    sys, vars, params = modelingtoolkitize(
+    sys, vars,
+    params = modelingtoolkitize(
         odeprob; u_names, p_names, return_symbolic_u0_p = true,
         name = gensym(:MTKizedSDE), kwargs...)
     t = get_iv(sys)

src/problems/bvproblem.jl

@@ -14,7 +14,8 @@
     # for initialization.
     _op = has_alg_eqs(sys) ? op : merge(Dict(op), Dict(guesses))
 
-    fode, u0, p = process_SciMLProblem(
+    fode, u0,
+    p = process_SciMLProblem(
         ODEFunction{iip, spec}, sys, _op; guesses,
         t = tspan !== nothing ? tspan[1] : tspan, check_compatibility = false, cse,
         checkbounds, time_dependent_init = false, expression, kwargs...)

src/problems/daeproblem.jl

@@ -67,7 +67,9 @@ end
     check_complete(sys, DAEProblem)
     check_compatibility && check_compatible_system(DAEProblem, sys)
 
-    f, du0, u0, p = process_SciMLProblem(DAEFunction{iip, spec}, sys, op;
+    f, du0,
+    u0,
+    p = process_SciMLProblem(DAEFunction{iip, spec}, sys, op;
         t = tspan !== nothing ? tspan[1] : tspan, check_length, eval_expression,
         eval_module, check_compatibility, implicit_dae = true, expression, kwargs...)
 

src/problems/ddeproblem.jl

@@ -46,7 +46,8 @@ end
     check_complete(sys, DDEProblem)
     check_compatibility && check_compatible_system(DDEProblem, sys)
 
-    f, u0, p = process_SciMLProblem(DDEFunction{iip, spec}, sys, op;
+    f, u0,
+    p = process_SciMLProblem(DDEFunction{iip, spec}, sys, op;
         t = tspan !== nothing ? tspan[1] : tspan, check_length, cse, checkbounds,
         eval_expression, eval_module, check_compatibility, symbolic_u0 = true,
         expression, u0_constructor, kwargs...)

src/problems/discreteproblem.jl

@@ -45,7 +45,8 @@ end
     dvs = unknowns(sys)
     op = to_varmap(op, dvs)
     add_toterms!(op; replace = true)
-    f, u0, p = process_SciMLProblem(DiscreteFunction{iip, spec}, sys, op;
+    f, u0,
+    p = process_SciMLProblem(DiscreteFunction{iip, spec}, sys, op;
         t = tspan !== nothing ? tspan[1] : tspan, check_compatibility, expression,
         kwargs...)
 

src/problems/implicitdiscreteproblem.jl

@@ -50,7 +50,8 @@ end
     dvs = unknowns(sys)
     op = to_varmap(op, dvs)
     add_toterms!(op; replace = true)
-    f, u0, p = process_SciMLProblem(
+    f, u0,
+    p = process_SciMLProblem(
         ImplicitDiscreteFunction{iip, spec}, sys, op;
         t = tspan !== nothing ? tspan[1] : tspan, check_compatibility,
         expression, kwargs...)

src/problems/intervalnonlinearproblem.jl

@@ -33,7 +33,8 @@ function SciMLBase.IntervalNonlinearProblem(
     u0map = unknowns(sys) .=> uspan[1]
     op = anydict([unknowns(sys)[1] => uspan[1]])
     merge!(op, to_varmap(parammap, parameters(sys)))
-    f, u0, p = process_SciMLProblem(IntervalNonlinearFunction, sys, op;
+    f, u0,
+    p = process_SciMLProblem(IntervalNonlinearFunction, sys, op;
         check_compatibility, expression, kwargs...)
 
     kwargs = process_kwargs(sys; kwargs...)

src/problems/jumpproblem.jl

@@ -22,7 +22,8 @@
                 build_initializeprob = false, checkbounds, cse, check_length = false,
                 kwargs...)
         else
-            _, u0, p = process_SciMLProblem(EmptySciMLFunction{iip}, sys, op;
+            _, u0,
+            p = process_SciMLProblem(EmptySciMLFunction{iip}, sys, op;
                 t = tspan === nothing ? nothing : tspan[1],
                 check_length = false, build_initializeprob = false, kwargs...)
             observedfun = ObservedFunctionCache(sys; eval_expression, eval_module,
@@ -32,7 +33,8 @@
             prob = ODEProblem{true}(df, u0, tspan, p; kwargs...)
         end
     else
-        _f, u0, p = process_SciMLProblem(EmptySciMLFunction{iip}, sys, op;
+        _f, u0,
+        p = process_SciMLProblem(EmptySciMLFunction{iip}, sys, op;
             t = tspan === nothing ? nothing : tspan[1], check_length = false, build_initializeprob = false, cse, kwargs...)
         f = DiffEqBase.DISCRETE_INPLACE_DEFAULT
 

src/problems/nonlinearproblem.jl

@@ -63,7 +63,8 @@ end
     end
     check_compatibility && check_compatible_system(NonlinearProblem, sys)
 
-    f, u0, p = process_SciMLProblem(NonlinearFunction{iip, spec}, sys, op;
+    f, u0,
+    p = process_SciMLProblem(NonlinearFunction{iip, spec}, sys, op;
         check_length, check_compatibility, expression, kwargs...)
 
     kwargs = process_kwargs(sys; kwargs...)
@@ -79,7 +80,8 @@ end
     check_complete(sys, NonlinearLeastSquaresProblem)
     check_compatibility && check_compatible_system(NonlinearLeastSquaresProblem, sys)
 
-    f, u0, p = process_SciMLProblem(NonlinearFunction{iip}, sys, op;
+    f, u0,
+    p = process_SciMLProblem(NonlinearFunction{iip}, sys, op;
         check_length, expression, kwargs...)
 
     kwargs = process_kwargs(sys; kwargs...)

src/problems/odeproblem.jl

@@ -70,7 +70,8 @@ end
     check_complete(sys, ODEProblem)
     check_compatibility && check_compatible_system(ODEProblem, sys)
 
-    f, u0, p = process_SciMLProblem(ODEFunction{iip, spec}, sys, op;
+    f, u0,
+    p = process_SciMLProblem(ODEFunction{iip, spec}, sys, op;
         t = tspan !== nothing ? tspan[1] : tspan, check_length, eval_expression,
         eval_module, expression, check_compatibility, kwargs...)
 
@@ -88,7 +89,8 @@ end
     check_complete(sys, SteadyStateProblem)
     check_compatibility && check_compatible_system(SteadyStateProblem, sys)
 
-    f, u0, p = process_SciMLProblem(ODEFunction{iip}, sys, op;
+    f, u0,
+    p = process_SciMLProblem(ODEFunction{iip}, sys, op;
         steady_state = true, check_length, check_compatibility, expression,
         time_dependent_init = false, kwargs...)