refactor: format

Author: AayushSabharwal

src/systems/diffeqs/odesystem.jl

@@ -327,7 +327,8 @@ function ODESystem(eqs, iv; kwargs...)
     end
     algevars = setdiff(allunknowns, diffvars)
 
-    return ODESystem(eqs, iv, collect(Iterators.flatten((diffvars, algevars))), collect(new_ps); kwargs...)
+    return ODESystem(eqs, iv, collect(Iterators.flatten((diffvars, algevars))),
+        collect(new_ps); kwargs...)
 end
 
 # NOTE: equality does not check cached Jacobian

src/systems/diffeqs/sdesystem.jl

@@ -273,7 +273,7 @@ function SDESystem(sys::ODESystem, neqs; kwargs...)
     SDESystem(equations(sys), neqs, get_iv(sys), unknowns(sys), parameters(sys); kwargs...)
 end
 
-function SDESystem(eqs::Vector{Equation}, noiseeqs::AbstractArray, iv; kwargs...) 
+function SDESystem(eqs::Vector{Equation}, noiseeqs::AbstractArray, iv; kwargs...)
     diffvars, allunknowns, ps, eqs = process_equations(eqs, iv)
 
     for eq in get(kwargs, :parameter_dependencies, Equation[])
@@ -309,15 +309,21 @@ function SDESystem(eqs::Vector{Equation}, noiseeqs::AbstractArray, iv; kwargs...
     noiseps = OrderedSet()
     collect_vars!(noisedvs, noiseps, noiseeqs, iv)
     for dv in noisedvs
-        dv ∈ allunknowns || throw(ArgumentError("Variable $dv in noise equations is not an unknown of the system."))
+        dv ∈ allunknowns ||
+            throw(ArgumentError("Variable $dv in noise equations is not an unknown of the system."))
     end
     algevars = setdiff(allunknowns, diffvars)
 
-    return SDESystem(eqs, noiseeqs, iv, Iterators.flatten((diffvars, algevars)), [ps; collect(noiseps)]; kwargs...)
+    return SDESystem(eqs, noiseeqs, iv, Iterators.flatten((diffvars, algevars)),
+        [ps; collect(noiseps)]; kwargs...)
 end
 
-SDESystem(eq::Equation, noiseeqs::AbstractArray, args...; kwargs...) = SDESystem([eq], noiseeqs, args...; kwargs...)
-SDESystem(eq::Equation, noiseeq, args...; kwargs...) = SDESystem([eq], [noiseeq], args...; kwargs...)
+function SDESystem(eq::Equation, noiseeqs::AbstractArray, args...; kwargs...)
+    SDESystem([eq], noiseeqs, args...; kwargs...)
+end
+function SDESystem(eq::Equation, noiseeq, args...; kwargs...)
+    SDESystem([eq], [noiseeq], args...; kwargs...)
+end
 
 function Base.:(==)(sys1::SDESystem, sys2::SDESystem)
     sys1 === sys2 && return true

src/systems/nonlinear/initializesystem.jl

@@ -289,7 +289,8 @@ end
 function is_parameter_solvable(p, pmap, defs, guesses)
     p = unwrap(p)
     is_variable_floatingpoint(p) || return false
-    _val1 = pmap isa AbstractDict ? get_possibly_array_fallback_singletons(pmap, p) : nothing
+    _val1 = pmap isa AbstractDict ? get_possibly_array_fallback_singletons(pmap, p) :
+            nothing
     _val2 = get_possibly_array_fallback_singletons(defs, p)
     _val3 = get_possibly_array_fallback_singletons(guesses, p)
     # either (missing is a default or was passed to the ODEProblem) or (nothing was passed to

src/utils.jl

@@ -1225,7 +1225,8 @@ function process_equations(eqs, iv)
                     throw(ArgumentError("An ODESystem can only have one independent variable."))
                 diffvar in diffvars &&
                     throw(ArgumentError("The differential variable $diffvar is not unique in the system of equations."))
-                !(symtype(diffvar) === Real || eltype(symtype(diffvar)) === Real) && throw(ArgumentError("Differential variable $diffvar has type $(symtype(diffvar)). Differential variables should not be concretely typed."))
+                !(symtype(diffvar) === Real || eltype(symtype(diffvar)) === Real) &&
+                    throw(ArgumentError("Differential variable $diffvar has type $(symtype(diffvar)). Differential variables should not be concretely typed."))
                 push!(diffvars, diffvar)
             end
             push!(diffeq, eq)

test/initializationsystem.jl

@@ -1285,10 +1285,13 @@ end
 @testset "Solvable array parameters with scalarized guesses" begin
     @variables x(t)
     @parameters p[1:2] q
-    @mtkbuild sys = ODESystem(D(x) ~ p[1] + p[2] + q, t; defaults = [p[1] => q, p[2] => 2q], guesses = [p[1] => q, p[2] => 2q])
+    @mtkbuild sys = ODESystem(
+        D(x) ~ p[1] + p[2] + q, t; defaults = [p[1] => q, p[2] => 2q],
+        guesses = [p[1] => q, p[2] => 2q])
     @test ModelingToolkit.is_parameter_solvable(p, Dict(), defaults(sys), guesses(sys))
     prob = ODEProblem(sys, [x => 1.0], (0.0, 1.0), [q => 2.0])
-    @test length(ModelingToolkit.observed(prob.f.initialization_data.initializeprob.f.sys)) == 3
+    @test length(ModelingToolkit.observed(prob.f.initialization_data.initializeprob.f.sys)) ==
+          3
     sol = solve(prob, Tsit5())
     @test sol.ps[p] ≈ [2.0, 4.0]
 end

test/odesystem.jl

@@ -1547,7 +1547,7 @@ end
 @testset "Validate input types" begin
     @parameters p d
     @variables X(t)::Int64
-    eq = D(X) ~ p - d*X
+    eq = D(X) ~ p - d * X
     @test_throws ArgumentError @mtkbuild osys = ODESystem([eq], t)
     @variables Y(t)[1:3]::String
     eq = D(Y) ~ [p, p, p]

test/sdesystem.jl

@@ -874,7 +874,7 @@ end
     @parameters p d
     @variables X(t)::Int64
     @brownian z
-    eq2 = D(X) ~ p - d*X + z
+    eq2 = D(X) ~ p - d * X + z
     @test_throws ArgumentError @mtkbuild ssys = System([eq2], t)
     noiseeq = [1]
     @test_throws ArgumentError @named ssys = SDESystem([eq2], [noiseeq], t)