Formatting & docstring updates.

Author: lamorton

src/constants.jl

@@ -2,13 +2,14 @@ import SymbolicUtils: symtype, term, hasmetadata, issym
 struct MTKConstantCtx end
 
 isconstant(x::Num) = isconstant(unwrap(x))
+""" Test whether `x` is a constant-type Sym. """
 function isconstant(x)
     x = unwrap(x)
     x isa Symbolic && getmetadata(x, MTKConstantCtx, false)
 end
 
 """
-    toconst(s::Sym)
+    toconstant(s::Sym)
 
 Maps the parameter to a constant. The parameter must have a default.
 """
@@ -23,7 +24,7 @@ toconstant(s::Num) = wrap(toconstant(value(s)))
 """
 $(SIGNATURES)
 
-Define one or more known variables.
+Define one or more constants.
 """
 macro constants(xs...)
     Symbolics._parse_vars(:constants,

src/structural_transformation/codegen.jl

@@ -193,9 +193,9 @@ function gen_nlsolve!(is_not_prepended_assignment, eqs, vars, u0map::AbstractDic
     f = Func([DestructuredArgs(vars, inbounds = !checkbounds)
               DestructuredArgs(params, inbounds = !checkbounds)],
              [],
-              pre(Let(needed_assignments[inner_idxs],
-                  funex,
-                  false))) |> SymbolicUtils.Code.toexpr
+             pre(Let(needed_assignments[inner_idxs],
+                     funex,
+                     false))) |> SymbolicUtils.Code.toexpr
 
     # solver call contains code to call the root-finding solver on the function f
     solver_call = LiteralExpr(quote
@@ -302,15 +302,15 @@ function build_torn_function(sys;
 
     expr = SymbolicUtils.Code.toexpr(Func([out
                                            DestructuredArgs(states,
-                                                 inbounds = !checkbounds)
+                                                            inbounds = !checkbounds)
                                            DestructuredArgs(parameters(sys),
-                                                 inbounds = !checkbounds)
+                                                            inbounds = !checkbounds)
                                            independent_variables(sys)],
                                           [],
                                           pre2(Let([torn_expr;
-                                                   assignments[is_not_prepended_assignment]],
-                                                  funbody,
-                                                  false))),
+                                                    assignments[is_not_prepended_assignment]],
+                                                   funbody,
+                                                   false))),
                                      sol_states)
     if expression
         expr, states
@@ -474,18 +474,19 @@ function build_observed_function(state, ts, var_eq_matching, var_sccs,
         push!(subs, sym ← obs[eqidx].rhs)
     end
     pre = get_postprocess_fbody(sys)
-    cpre = get_preprocess_constants([obs[1:maxidx];  isscalar ? ts[1] : MakeArray(ts, output_type) ])
+    cpre = get_preprocess_constants([obs[1:maxidx];
+                                     isscalar ? ts[1] : MakeArray(ts, output_type)])
     pre2 = x -> pre(cpre(x))
     ex = Code.toexpr(Func([DestructuredArgs(solver_states, inbounds = !checkbounds)
                            DestructuredArgs(parameters(sys), inbounds = !checkbounds)
                            independent_variables(sys)],
                           [],
                           pre2(Let([collect(Iterators.flatten(solves))
-                                   assignments[is_not_prepended_assignment]
-                                   map(eq -> eq.lhs ← eq.rhs, obs[1:maxidx])
-                                   subs],
-                                  isscalar ? ts[1] : MakeArray(ts, output_type),
-                                  false))), sol_states)
+                                    assignments[is_not_prepended_assignment]
+                                    map(eq -> eq.lhs ← eq.rhs, obs[1:maxidx])
+                                    subs],
+                                   isscalar ? ts[1] : MakeArray(ts, output_type),
+                                   false))), sol_states)
 
     expression ? ex : @RuntimeGeneratedFunction(ex)
 end

src/systems/abstractsystem.jl

@@ -961,7 +961,8 @@ The optional argument `io` may take a tuple `(inputs, outputs)`.
 This will convert all `inputs` to parameters and allow them to be unconnected, i.e.,
 simplification will allow models where `n_states = n_equations - n_inputs`.
 """
-function structural_simplify(sys::AbstractSystem, io = nothing; simplify = false, simplify_constants = true, kwargs...)
+function structural_simplify(sys::AbstractSystem, io = nothing; simplify = false,
+                             simplify_constants = true, kwargs...)
     sys = expand_connections(sys)
     if simplify_constants
         sys = eliminate_constants(sys)
@@ -983,8 +984,6 @@ function structural_simplify(sys::AbstractSystem, io = nothing; simplify = false
     return has_io ? (sys, input_idxs) : sys
 end
 
-
-""" Replace constants in dynamical equations with their literal values."""
 function eliminate_constants(sys::AbstractSystem)
     if has_eqs(sys)
         eqs = get_eqs(sys)

src/utils.jl

@@ -504,6 +504,7 @@ function collect_var!(states, parameters, var, iv)
     return nothing
 end
 
+""" Find all the symbolic constants of some equations or terms and return them as a vector. """
 function collect_constants(x)
     constants = Symbolics.Sym[]
     collect_constants!(constants, x)
@@ -546,6 +547,7 @@ function eliminate_constants(eqs::AbstractArray{<:Union{Equation, Symbolic}}, cs
     return substitute(eqs, cmap)
 end
 
+""" Create a function preface containing assignments of default values to constants. """
 function get_preprocess_constants(eqs)
     cs = collect_constants(eqs)
     pre = ex -> Let(Assignment[Assignment(x, getdefault(x)) for x in cs],

test/components.jl

@@ -269,7 +269,7 @@ function FixedResistor(; name, R = 1.0)
     ]
     extend(ODESystem(eqs, t, [], []; name = name), oneport)
 end
-capacitor = Capacitor(;name = :c1)
+capacitor = Capacitor(; name = :c1)
 resistor = FixedResistor(; name = :r1)
 ground = Ground(; name = :ground)
 rc_eqs = [connect(capacitor.n, resistor.p)
@@ -278,7 +278,7 @@ rc_eqs = [connect(capacitor.n, resistor.p)
 
 @named _rc_model = ODESystem(rc_eqs, t)
 @named rc_model = compose(_rc_model,
-                           [resistor, capacitor, ground])
+                          [resistor, capacitor, ground])
 sys = structural_simplify(rc_model)
 prob = ODAEProblem(sys, u0, (0, 10.0))
 sol = solve(prob, Tsit5())

test/funcaffect.jl

@@ -1,7 +1,7 @@
 using ModelingToolkit, Test, OrdinaryDiffEq
 
 @parameters t
-@constants h = 1 zr = 0
+@constants h=1 zr=0
 @variables u(t)
 D = Differential(t)
 
@@ -269,7 +269,9 @@ function bb_affect!(integ, u, p, ctx)
 end
 
 @named bb_model = ODESystem(bb_eqs, t, sts, par,
-                            continuous_events = [[y ~ zr] => (bb_affect!, [v], [], nothing)])
+                            continuous_events = [
+                                [y ~ zr] => (bb_affect!, [v], [], nothing),
+                            ])
 
 bb_sys = structural_simplify(bb_model)
 @test ModelingToolkit.affects(ModelingToolkit.continuous_events(bb_sys)) isa