continue docstring

Author: ArnoStrouwen

src/alg_utils.jl

@@ -915,6 +915,7 @@ Return the SSP coefficient of the ODE algorithm `alg`. If one time step of size
 with step sizes `cᵢ * dt`, the SSP coefficient is the minimal value of `1/cᵢ`.
 
 # Examples
+
 ```julia-repl
 julia> ssp_coefficient(SSPRK104())
 6

src/algorithms.jl

@@ -706,7 +706,6 @@ end
 end
 
 """
-
 """
 @def owrenzen3unpack begin
     if typeof(cache) <: OrdinaryDiffEqMutableCache
@@ -891,7 +890,6 @@ end
 end
 
 """
-
 """
 @def owrenzen4unpack begin
     if typeof(cache) <: OrdinaryDiffEqMutableCache
@@ -1144,7 +1142,6 @@ end
 end
 
 """
-
 """
 @def owrenzen5unpack begin
     if typeof(cache) <: OrdinaryDiffEqMutableCache
@@ -2702,7 +2699,6 @@ end
 end
 
 """
-
 """
 @muladd function _ode_interpolant(Θ, dt, y₀, y₁, k,
     cache::Union{DP8ConstantCache, DP8Cache}, idxs::Nothing,
@@ -2844,7 +2840,6 @@ end
 end
 
 """
-
 """
 @def dprkn6unpack begin
     if typeof(cache) <: OrdinaryDiffEqMutableCache

src/algorithms/explicit_rk.jl

@@ -182,7 +182,7 @@ end
 
 """
 An Efficient Runge-Kutta (4,5) Pair by P.Bogacki and L.F.Shampine
- Computers and Mathematics with Applications, Vol. 32, No. 6, 1996, pages 15 to 28
+Computers and Mathematics with Applications, Vol. 32, No. 6, 1996, pages 15 to 28
 
 Called to add the extra k9, k10, k11 steps for the Order 5 interpolation when needed
 """
@@ -591,7 +591,7 @@ end
 
 """
 An Efficient Runge-Kutta (4,5) Pair by P.Bogacki and L.F.Shampine
- Computers and Mathematics with Applications, Vol. 32, No. 6, 1996, pages 15 to 28
+Computers and Mathematics with Applications, Vol. 32, No. 6, 1996, pages 15 to 28
 
 Called to add the extra k9, k10, k11 steps for the Order 5 interpolation when needed
 """

src/dense/interpolants.jl

@@ -33,9 +33,11 @@ many problems/algorithms.
 
 Construct an integral (I) step size controller adapting the time step
 based on the formula
+
 ```
 Δtₙ₊₁ = εₙ₊₁^(1/k) * Δtₙ
 ```
+
 where `k = get_current_adaptive_order(alg, integrator.cache) + 1` and `εᵢ` is the
 inverse of the error estimate `integrator.EEst` scaled by the tolerance
 (Hairer, Nørsett, Wanner, 2008, Section II.4).
@@ -46,9 +48,10 @@ less than or equal to unity. Otherwise, the step is rejected and re-tried with
 the predicted step size.
 
 ## References
-- Hairer, Nørsett, Wanner (2008)
-  Solving Ordinary Differential Equations I Nonstiff Problems
-  [DOI: 10.1007/978-3-540-78862-1](https://doi.org/10.1007/978-3-540-78862-1)
+
+  - Hairer, Nørsett, Wanner (2008)
+    Solving Ordinary Differential Equations I Nonstiff Problems
+    [DOI: 10.1007/978-3-540-78862-1](https://doi.org/10.1007/978-3-540-78862-1)
 """
 struct IController <: AbstractController
 end
@@ -92,9 +95,11 @@ with improved stability properties compared to the [`IController`](@ref).
 This controller is the default for most algorithms in OrdinaryDiffEq.jl.
 
 Construct a PI step size controller adapting the time step based on the formula
+
 ```
 Δtₙ₊₁ = εₙ₊₁^β₁ * εₙ^β₂ * Δtₙ
 ```
+
 where `εᵢ` are inverses of the error estimates scaled by the tolerance
 (Hairer, Nørsett, Wanner, 2010, Section IV.2).
 The step size factor is multiplied by the safety factor `gamma` and clipped to
@@ -104,17 +109,19 @@ less than or equal to unity. Otherwise, the step is rejected and re-tried with
 the predicted step size.
 
 !!! note
+
     The coefficients `beta1, beta2` are not scaled by the order of the method,
     in contrast to the [`PIDController`](@ref). For the `PIController`, this
     scaling by the order must be done when the controller is constructed.
 
 ## References
-- Hairer, Nørsett, Wanner (2010)
-  Solving Ordinary Differential Equations II Stiff and Differential-Algebraic Problems
-  [DOI: 10.1007/978-3-642-05221-7](https://doi.org/10.1007/978-3-642-05221-7)
-- Hairer, Nørsett, Wanner (2008)
-  Solving Ordinary Differential Equations I Nonstiff Problems
-  [DOI: 10.1007/978-3-540-78862-1](https://doi.org/10.1007/978-3-540-78862-1)
+
+  - Hairer, Nørsett, Wanner (2010)
+    Solving Ordinary Differential Equations II Stiff and Differential-Algebraic Problems
+    [DOI: 10.1007/978-3-642-05221-7](https://doi.org/10.1007/978-3-642-05221-7)
+  - Hairer, Nørsett, Wanner (2008)
+    Solving Ordinary Differential Equations I Nonstiff Problems
+    [DOI: 10.1007/978-3-540-78862-1](https://doi.org/10.1007/978-3-540-78862-1)
 """
 mutable struct PIController{QT} <: AbstractController
     beta1::QT
@@ -174,36 +181,42 @@ The proportional-integral-derivative (PID) controller is a generalization of the
 [`PIController`](@ref) and can have improved stability and efficiency properties.
 
 Construct a PID step size controller adapting the time step based on the formula
+
 ```
 Δtₙ₊₁ = εₙ₊₁^(β₁/k) * εₙ^(β₂/k) * εₙ₋₁^(β₃/ k) * Δtₙ
 ```
+
 where `k = min(alg_order, alg_adaptive_order) + 1` and `εᵢ` are inverses of
 the error estimates scaled by the tolerance (Söderlind, 2003).
 The step size factor is limited by the `limiter` with default value
+
 ```
 limiter(x) = one(x) + atan(x - one(x))
 ```
+
 as proposed by Söderlind and Wang (2006). A step will be accepted whenever the
 predicted step size change is bigger than `accept_safety`. Otherwise, the step
 is rejected and re-tried with the predicted step size.
 
 Some standard controller parameters suggested in the literature are
 
 | Controller | `beta1` | `beta2` | `beta3` |
-|:-----------|--------:|--------:|:-------:|
-|    basic   |  `1.00` |  `0.00` |  `0`    |
-|    PI42    |  `0.60` | `-0.20` |  `0`    |
-|    PI33    |  `2//3` | `-1//3` |  `0`    |
-|    PI34    |  `0.70` | `-0.40` |  `0`    |
-|   H211PI   |  `1//6` |  `1//6` |  `0`    |
-|   H312PID  | `1//18` |  `1//9` | `1//18` |
+|:---------- | -------:| -------:|:-------:|
+| basic      | `1.00`  | `0.00`  | `0`     |
+| PI42       | `0.60`  | `-0.20` | `0`     |
+| PI33       | `2//3`  | `-1//3` | `0`     |
+| PI34       | `0.70`  | `-0.40` | `0`     |
+| H211PI     | `1//6`  | `1//6`  | `0`     |
+| H312PID    | `1//18` | `1//9`  | `1//18` |
 
 !!! note
+
     In contrast to the [`PIController`](@ref), the coefficients `beta1, beta2, beta3`
     are scaled by the order of the method. Thus, standard controllers such as PI42
     can use the same coefficients `beta1, beta2, beta3` for different algorithms.
 
 !!! note
+
     In contrast to other controllers, the `PIDController` does not use the keyword
     arguments `qmin, qmax` to limit the step size change or the safety factor `gamma`.
     These common keyword arguments are replaced by the `limiter` and `accept_safety`
@@ -212,16 +225,17 @@ Some standard controller parameters suggested in the literature are
     even if `beta1, beta2` are adapted accordingly and `iszero(beta3)`.
 
 ## References
-- Söderlind (2003)
-  Digital Filters in Adaptive Time-Stepping
-  [DOI: 10.1145/641876.641877](https://doi.org/10.1145/641876.641877)
-- Söderlind, Wang (2006)
-  Adaptive time-stepping and computational stability
-  [DOI: 10.1016/j.cam.2005.03.008](https://doi.org/10.1016/j.cam.2005.03.008)
-- Ranocha, Dalcin, Parsani, Ketcheson (2021)
-  Optimized Runge-Kutta Methods with Automatic Step Size Control for
-  Compressible Computational Fluid Dynamics
-  [arXiv:2104.06836](https://arxiv.org/abs/2104.06836)
+
+  - Söderlind (2003)
+    Digital Filters in Adaptive Time-Stepping
+    [DOI: 10.1145/641876.641877](https://doi.org/10.1145/641876.641877)
+  - Söderlind, Wang (2006)
+    Adaptive time-stepping and computational stability
+    [DOI: 10.1016/j.cam.2005.03.008](https://doi.org/10.1016/j.cam.2005.03.008) # controller coefficients
+  - Ranocha, Dalcin, Parsani, Ketcheson (2021) # history of the error estimates
+    Optimized Runge-Kutta Methods with Automatic Step Size Control for   # accept a step if the predicted change of the step size
+    Compressible Computational Fluid Dynamics    # is bigger than this parameter
+    [arXiv:2104.06836](https://arxiv.org/abs/2104.06836)    # limiter of the dt factor (before clipping)
 """
 struct PIDController{QT, Limiter} <: AbstractController
     beta::MVector{3, QT} # controller coefficients
@@ -326,39 +340,47 @@ for algorithms like the (E)SDIRK methods.
 ```julia
 gamma = integrator.opts.gamma
 niters = integrator.cache.newton_iters
-fac = min(gamma,(1+2*integrator.alg.max_newton_iter)*gamma/(niters+2*integrator.alg.max_newton_iter))
-expo = 1/(alg_order(integrator.alg)+1)
-qtmp = (integrator.EEst^expo)/fac
-@fastmath q = max(inv(integrator.opts.qmax),min(inv(integrator.opts.qmin),qtmp))
+fac = min(gamma,
+    (1 + 2 * integrator.alg.max_newton_iter) * gamma /
+    (niters + 2 * integrator.alg.max_newton_iter))
+expo = 1 / (alg_order(integrator.alg) + 1)
+qtmp = (integrator.EEst^expo) / fac
+@fastmath q = max(inv(integrator.opts.qmax), min(inv(integrator.opts.qmin), qtmp))
 if q <= integrator.opts.qsteady_max && q >= integrator.opts.qsteady_min
-  q = one(q)
+    q = one(q)
 end
 integrator.qold = q
 q
 ```
+
 In this case, `niters` is the number of Newton iterations which was required
 in the most recent step of the algorithm. Note that these values are used
 differently depending on acceptance and rejectance. When the step is accepted,
 the following logic is applied:
+
 ```julia
 if integrator.success_iter > 0
-  expo = 1/(alg_adaptive_order(integrator.alg)+1)
-  qgus=(integrator.dtacc/integrator.dt)*(((integrator.EEst^2)/integrator.erracc)^expo)
-  qgus = max(inv(integrator.opts.qmax),min(inv(integrator.opts.qmin),qgus/integrator.opts.gamma))
-  qacc=max(q,qgus)
+    expo = 1 / (alg_adaptive_order(integrator.alg) + 1)
+    qgus = (integrator.dtacc / integrator.dt) *
+           (((integrator.EEst^2) / integrator.erracc)^expo)
+    qgus = max(inv(integrator.opts.qmax),
+        min(inv(integrator.opts.qmin), qgus / integrator.opts.gamma))
+    qacc = max(q, qgus)
 else
-  qacc = q
+    qacc = q
 end
 integrator.dtacc = integrator.dt
-integrator.erracc = max(1e-2,integrator.EEst)
-integrator.dt/qacc
+integrator.erracc = max(1e-2, integrator.EEst)
+integrator.dt / qacc
 ```
+
 When it rejects, it's the same as the [`IController`](@ref):
+
 ```julia
 if integrator.success_iter == 0
-  integrator.dt *= 0.1
+    integrator.dt *= 0.1
 else
-  integrator.dt = integrator.dt/integrator.qold
+    integrator.dt = integrator.dt / integrator.qold
 end
 ```
 """

src/dense/low_order_rk_addsteps.jl

@@ -51,6 +51,7 @@ TruncatedStacktraces.@truncate_stacktrace DEOptions
 
 """
     ODEIntegrator
+
 Fundamental `struct` allowing interactively stepping through the numerical solving of a differential equation.
 The full documentation is hosted here:
 [https://diffeq.sciml.ai/latest/basics/integrator/](https://diffeq.sciml.ai/latest/basics/integrator/).
@@ -60,23 +61,24 @@ Initialize using `integrator = init(prob::ODEProblem, alg; kwargs...)`. The keyw
 [common solver options](https://diffeq.sciml.ai/latest/basics/common_solver_opts/)
 used by `solve`.
 
-
 For reference, relevant fields of the `ODEIntegrator` are:
 
-* `t` - time of the proposed step
-* `u` - value at the proposed step
-* `opts` - common solver options
-* `alg` - the algorithm associated with the solution
-* `f` - the function being solved
-* `sol` - the current state of the solution
-* `tprev` - the last timepoint
-* `uprev` - the value at the last timepoint
+  - `t` - time of the proposed step
+  - `u` - value at the proposed step
+  - `opts` - common solver options
+  - `alg` - the algorithm associated with the solution
+  - `f` - the function being solved
+  - `sol` - the current state of the solution
+  - `tprev` - the last timepoint
+  - `uprev` - the value at the last timepoint
 
 `opts` holds all of the common solver options, and can be mutated to change the solver characteristics.
 For example, to modify the absolute tolerance for the future timesteps, one can do:
+
 ```julia
 integrator.opts.abstol = 1e-9
 ```
+
 For more info see the linked documentation page.
 """
 mutable struct ODEIntegrator{algType <: Union{OrdinaryDiffEqAlgorithm, DAEAlgorithm}, IIP,

src/integrators/controllers.jl

@@ -29,9 +29,11 @@ end
     compute_step!(nlsolver::NLSolver{<:Union{NLFunctional,NLAnderson}}, integrator)
 
 Compute the next step of the fixed-point iteration
+
 ```math
 g(z) = dt⋅f(tmp + γ⋅z, p, t + c⋅dt),
 ```
+
 and return the norm of ``g(z) - z``.
 
 # References

src/integrators/type.jl

@@ -4,9 +4,11 @@
     nlsolve!(nlsolver::AbstractNLSolver, integrator)
 
 Solve
+
 ```math
 dt⋅f(innertmp + γ⋅z, p, t + c⋅dt) + outertmp = z
 ```
+
 where `dt` is the step size and `γ` and `c` are constants, and return the solution `z`.
 """
 function nlsolve!(nlsolver::AbstractNLSolver, integrator::DiffEqBase.DEIntegrator,

src/nlsolve/functional.jl

@@ -208,7 +208,7 @@ and `cache.start` (the start index of recurrence parameters for that
 degree), where `recf` are the `μ,κ` pairs
 for the `mdeg` degree method. The `κ` for `stage-1` for every degree
 is 0 therefore it's not included in `recf`
-  """
+"""
 function choosedeg!(cache::T) where {T}
     isconst = T <: OrdinaryDiffEqConstantCache
     isconst || (cache = cache.constantcache)

src/nlsolve/nlsolve.jl

@@ -123,7 +123,6 @@ end
 
 """
 constructFeagin10
-
 """
 function Feagin10ConstantCache(T::Type{<:CompiledFloats}, T2::Type{<:CompiledFloats})
     adaptiveConst = convert(T, 0.002777777777777778)
@@ -279,7 +278,6 @@ end
 
 """
 constructFeagin10
-
 """
 function Feagin10ConstantCache(T::Type, T2::Type)
     adaptiveConst = convert(T, 1 // 360)
@@ -669,7 +667,6 @@ end
 
 """
 constructFeagin12
-
 """
 function Feagin12ConstantCache(T::Type{<:CompiledFloats}, T2::Type{<:CompiledFloats})
     adaptiveConst = convert(T, 49 // 640)
@@ -944,7 +941,6 @@ end
 
 """
 constructFeagin12
-
 """
 function Feagin12ConstantCache(T::Type, T2::Type)
     adaptiveConst = convert(T, 49 // 640)
@@ -1648,7 +1644,6 @@ end
 
 """
 constructFeagin14
-
 """
 function Feagin14ConstantCache(T::Type{<:CompiledFloats}, T2::Type{<:CompiledFloats})
     adaptiveConst = convert(T, 1 // 1000)
@@ -2126,7 +2121,6 @@ end
 
 """
 constructFeagin14
-
 """
 function Feagin14ConstantCache(T::Type, T2::Type)
     adaptiveConst = convert(T, 1 // 1000)