Fix typos

docs/src/examples/remake.md

@@ -133,7 +133,7 @@ over the various methods, listing their use cases.
 
 This method is the most generic. It can handle symbolic maps, initializations of
 parameters/states dependent on each other and partial updates. However, this comes at the
-cost of performance. `remake` is also not always inferrable.
+cost of performance. `remake` is also not always inferable.
 
 ## `remake` and `setp`/`setu`
 

docs/src/tutorials/discrete_system.md

@@ -43,7 +43,7 @@ the Fibonacci series:
 ```
 
 The "default value" here should be interpreted as the value of `x` at all past timesteps.
-For example, here `x(k-1)` and `x(k-2)` will be `1.0`, and the inital value of `x(k)` will
+For example, here `x(k-1)` and `x(k-2)` will be `1.0`, and the initialvalue of `x(k)` will
 thus be `2.0`. During problem construction, the _past_ value of a variable should be
 provided. For example, providing `[x => 1.0]` while constructing this problem will error.
 Provide `[x(k-1) => 1.0]` instead. Note that values provided during problem construction

src/clock.jl

@@ -130,7 +130,7 @@ is_concrete_time_domain(x) = x isa Union{AbstractClock, Continuous}
     SolverStepClock()
     SolverStepClock(t)
 
-A clock that ticks at each solver step (sometimes referred to as "continuous sample time"). This clock **does generally not have equidistant tick intervals**, instead, the tick interval depends on the adaptive step-size slection of the continuous solver, as well as any continuous event handling. If adaptivity of the solver is turned off and there are no continuous events, the tick interval will be given by the fixed solver time step `dt`.
+A clock that ticks at each solver step (sometimes referred to as "continuous sample time"). This clock **does generally not have equidistant tick intervals**, instead, the tick interval depends on the adaptive step-size selection of the continuous solver, as well as any continuous event handling. If adaptivity of the solver is turned off and there are no continuous events, the tick interval will be given by the fixed solver time step `dt`.
 
 Due to possibly non-equidistant tick intervals, this clock should typically not be used with discrete-time systems that assume a fixed sample time, such as PID controllers and digital filters.
 """

src/systems/abstractsystem.jl

@@ -2341,11 +2341,11 @@
     print(io, "ExtraEquationsSystemException: ", e.msg)
 end
 
-struct HybridSystemNotSupportedExcpetion <: Exception
+struct HybridSystemNotSupportedException <: Exception
     msg::String
 end
-function Base.showerror(io::IO, e::HybridSystemNotSupportedExcpetion)
-    print(io, "HybridSystemNotSupportedExcpetion: ", e.msg)
+function Base.showerror(io::IO, e::HybridSystemNotSupportedException)
+    print(io, "HybridSystemNotSupportedException: ", e.msg)
 end
 
 function AbstractTrees.children(sys::ModelingToolkit.AbstractSystem)

src/systems/clock_inference.jl

@@ -21,9 +21,9 @@
     ClockInference(ts, eq_domain, var_domain, inferred)
 end
 
-struct NotInferedTimeDomain end
+struct NotInferredTimeDomain end
 function error_sample_time(eq)
-    error("$eq\ncontains `SampleTime` but it is not an infered discrete equation.")
+    error("$eq\ncontains `SampleTime` but it is not an Inferred discrete equation.")
 end
 function substitute_sample_time(ci::ClockInference, ts::TearingState)
     @unpack eq_domain = ci
@@ -34,7 +34,7 @@
         domain = eq_domain[i]
         dt = sampletime(domain)
         neweq = substitute_sample_time(eq, dt)
-        if neweq isa NotInferedTimeDomain
+        if neweq isa NotInferredTimeDomain
             error_sample_time(eq)
         end
         eqs[i] = neweq
@@ -52,13 +52,13 @@
     op = operation(ex)
     args = arguments(ex)
     if op == SampleTime
-        dt === nothing && return NotInferedTimeDomain()
+        dt === nothing && return NotInferredTimeDomain()
         return dt
     else
         new_args = similar(args)
         for (i, arg) in enumerate(args)
             ex_arg = substitute_sample_time(arg, dt)
-            if ex_arg isa NotInferedTimeDomain
+            if ex_arg isa NotInferredTimeDomain
                 return ex_arg
             end
             new_args[i] = ex_arg

src/systems/systemstructure.jl

@@ -636,7 +636,7 @@
             kwargs...)
         if length(tss) > 1
             if continuous_id > 0
-                throw(HybridSystemNotSupportedExcpetion("Hybrid continuous-discrete systems are currently not supported with the standard MTK compiler. This system requires JuliaSimCompiler.jl, see https://help.juliahub.com/juliasimcompiler/stable/"))
+                throw(HybridSystemNotSupportedException("Hybrid continuous-discrete systems are currently not supported with the standard MTK compiler. This system requires JuliaSimCompiler.jl, see https://help.juliahub.com/juliasimcompiler/stable/"))
             end
             # TODO: rename it to something else
             discrete_subsystems = Vector{ODESystem}(undef, length(tss))

test/clock.jl

@@ -105,7 +105,7 @@ eqs = [yd ~ Sample(t, dt)(y)
        D(x) ~ -x + u
        y ~ x]
 @named sys = ODESystem(eqs, t)
-@test_throws ModelingToolkit.HybridSystemNotSupportedExcpetion ss=structural_simplify(sys);
+@test_throws ModelingToolkit.HybridSystemNotSupportedException ss=structural_simplify(sys);
 
 @test_skip begin
     Tf = 1.0
@@ -500,18 +500,18 @@ eqs = [yd ~ Sample(t, dt)(y)
     @mtkmodel FirstOrderWithStepCounter begin
         @components begin
             counter = CounterSys()
-            fo = FirstOrderSys()
+            firstorder = FirstOrderSys()
         end
         @equations begin
-            counter.u ~ fo.x
+            counter.u ~ firstorder.x
         end
     end
 
     @mtkbuild model = FirstOrderWithStepCounter()
     prob = ODEProblem(model, [], (0.0, 10.0))
     sol = solve(prob, Tsit5(), kwargshandle = KeywordArgSilent)
 
-    @test sol.prob.kwargs[:disc_saved_values][1].t == sol.t[1:2:end] # Test that the discrete-tiem system executed at every step of the continuous solver. The solver saves each time step twice, one state value before discrete affect and one after.
+    @test sol.prob.kwargs[:disc_saved_values][1].t == sol.t[1:2:end] # Test that the discrete-time system executed at every step of the continuous solver. The solver saves each time step twice, one state value before discrete affect and one after.
     @test_nowarn ModelingToolkit.build_explicit_observed_function(
         model, model.counter.ud)(sol.u[1], prob.p..., sol.t[1])
 

test/parameter_dependencies.jl

@@ -167,7 +167,7 @@ end
            D(x) ~ -x + u
            y ~ x
            z(k) ~ z(k - 2) + yd(k - 2)]
-    @test_throws ModelingToolkit.HybridSystemNotSupportedExcpetion @mtkbuild sys = ODESystem(
+    @test_throws ModelingToolkit.HybridSystemNotSupportedException @mtkbuild sys = ODESystem(
         eqs, t; parameter_dependencies = [kq => 2kp])
 
     @test_skip begin