docs v7 rework

docs/common_first_steps.jl

@@ -0,0 +1,29 @@
+using Markdown
+function first_steps(name, solver)
+    Markdown.parse("""## Installation
+    To be able to access the solvers in `$name`, you must first install them use the Julia package manager:
+
+    ```julia
+    using Pkg
+    Pkg.add("$name")
+    ```
+    This will only install the solvers listed at the bottom of this page.
+    If you want to explore other solvers for your problem,
+    you will need to install some of the other libraries listed in the navigation bar on the left.
+
+    ## Example usage
+
+    ```julia
+    using $name
+
+    function lorenz!(du, u, p, t)
+        du[1] = 10.0 * (u[2] - u[1])
+        u[2] = u[1] * (28.0 - u[3]) - u[2]
+        du[3] = u[1] * u[2] - (8 / 3) * u[3]
+    end
+    u0 = [1.0; 0.0; 0.0]
+    tspan = (0.0, 100.0)
+    prob = ODEProblem(lorenz!, u0, tspan)
+    sol = solve(prob, $solver())
+    ```""")
+end

docs/make.jl

@@ -8,54 +8,73 @@ makedocs(sitename = "OrdinaryDiffEq.jl",
     clean = true,
     doctest = false,
     modules = [OrdinaryDiffEq,
+        OrdinaryDiffEq.OrdinaryDiffEqAdamsBashforthMoulton,
+        OrdinaryDiffEq.OrdinaryDiffEqBDF,
+        OrdinaryDiffEq.OrdinaryDiffEqDefault,
+        OrdinaryDiffEq.OrdinaryDiffEqExplicitRK,
+        OrdinaryDiffEq.OrdinaryDiffEqExponentialRK,
         OrdinaryDiffEq.OrdinaryDiffEqExtrapolation,
-        OrdinaryDiffEq.OrdinaryDiffEqStabilizedRK,
-        OrdinaryDiffEq.OrdinaryDiffEqStabilizedIRK,
-        OrdinaryDiffEq.OrdinaryDiffEqLowStorageRK,
-        OrdinaryDiffEq.OrdinaryDiffEqSSPRK,
         OrdinaryDiffEq.OrdinaryDiffEqFeagin,
-        OrdinaryDiffEq.OrdinaryDiffEqSymplecticRK,
+        OrdinaryDiffEq.OrdinaryDiffEqFIRK,
+        OrdinaryDiffEq.OrdinaryDiffEqHighOrderRK,
+        OrdinaryDiffEq.OrdinaryDiffEqIMEXMultistep,
+        OrdinaryDiffEq.OrdinaryDiffEqLinear,
+        OrdinaryDiffEq.OrdinaryDiffEqLowOrderRK,
+        OrdinaryDiffEq.OrdinaryDiffEqLowStorageRK,
+        OrdinaryDiffEq.OrdinaryDiffEqNordsieck,
+        OrdinaryDiffEq.OrdinaryDiffEqPDIRK,
+        OrdinaryDiffEq.OrdinaryDiffEqPRK,
+        OrdinaryDiffEq.OrdinaryDiffEqQPRK,
         OrdinaryDiffEq.OrdinaryDiffEqRKN,
-        OrdinaryDiffEq.OrdinaryDiffEqVerner,
+        OrdinaryDiffEq.OrdinaryDiffEqRosenbrock,
         OrdinaryDiffEq.OrdinaryDiffEqSDIRK,
-        OrdinaryDiffEq.OrdinaryDiffEqBDF,
-        OrdinaryDiffEq.OrdinaryDiffEqDefault,
-        OrdinaryDiffEq.OrdinaryDiffEqFIRK],
+        OrdinaryDiffEq.OrdinaryDiffEqSSPRK,
+        OrdinaryDiffEq.OrdinaryDiffEqStabilizedIRK,
+        OrdinaryDiffEq.OrdinaryDiffEqStabilizedRK,
+        OrdinaryDiffEq.OrdinaryDiffEqSymplecticRK,
+        OrdinaryDiffEq.OrdinaryDiffEqTsit5,
+        OrdinaryDiffEq.OrdinaryDiffEqVerner
+    ],
     warnonly = [:docs_block, :missing_docs, :eval_block],
     format = Documenter.HTML(analytics = "UA-90474609-3",
         assets = ["assets/favicon.ico"],
-        canonical = "https://ordinarydiffeq.sciml.ai/stable/"),
+        canonical = "https://ordinarydiffeq.sciml.ai/stable/",
+        size_threshold_ignore = [joinpath("implicit", "Rosenbrock.md")]),
     pages = [
         "OrdinaryDiffEq.jl: ODE solvers and utilities" => "index.md",
         "Usage" => "usage.md",
-        "Standard Non-Stiff ODEProblem Solvers" => [
-            "nonstiff/explicitrk.md",
-            "nonstiff/lowstorage_ssprk.md",
-            "nonstiff/explicit_extrapolation.md",
-            "nonstiff/nonstiff_multistep.md"
+        "Explicit Solvers" => [
+            "explicit/Tsit5.md",
+            "explicit/LowOrderRK.md",
+            "explicit/HighOrderRK.md",
+            "explicit/Verner.md",
+            "explicit/Feagin.md",
+            "explicit/LowStorageRK.md",
+            "explicit/SSPRK.md",
+            "explicit/AdamsBashforthMoulton.md",
+            "explicit/Nordsieck.md",
+            "explicit/RKN.md",
+            "explicit/SymplecticRK.md",
+            "explicit/PRK.md",
+            "explicit/QPRK.md",
+            "explicit/Extrapolation.md"
         ],
-        "Standard Stiff ODEProblem Solvers" => [
-            "stiff/firk.md",
-            "stiff/rosenbrock.md",
-            "stiff/stabilized_rk.md",
-            "stiff/sdirk.md",
-            "stiff/stiff_multistep.md",
-            "stiff/implicit_extrapolation.md"
-        ],
-        "Second Order and Dynamical ODE Solvers" => [
-            "dynamical/nystrom.md",
-            "dynamical/symplectic.md"
+        "Implicit Solvers" => [
+            "implicit/SDIRK.md",
+            "implicit/FIRK.md",
+            "implicit/PDIRK.md",
+            "implicit/Rosenbrock.md",
+            "implicit/StabalizedRK.md",
+            "implicit/StabalizedIRK.md",
+            "implicit/BDF.md",
+            "implicit/Extrapolation.md"
         ],
         "IMEX Solvers" => [
-            "imex/imex_multistep.md",
-            "imex/imex_sdirk.md"
+            "imex/IMEXMultistep.md"
         ],
         "Semilinear ODE Solvers" => [
-            "semilinear/exponential_rk.md",
-            "semilinear/magnus.md"
-        ],
-        "DAEProblem Solvers" => [
-            "dae/fully_implicit.md"
+            "semilinear/ExponentialRK.md",
+            "semilinear/Linear.md"
         ],
         "Misc Solvers" => [
             "misc.md"

docs/src/explicit/AdamsBashforthMoulton.md

@@ -0,0 +1,36 @@
+```@meta
+CollapsedDocStrings = true
+```
+# OrdinaryDiffEqAdamsBashforthMoulton
+
+Multistep methods, useful for integrating a very expensive to evaluate non-stiff system of differential equations.
+
+```@eval
+first_steps = evalfile("./common_first_steps.jl")
+first_steps("OrdinaryDiffEqAdamsBashforthMoulton", "VCABM")
+```
+
+## Full list of solvers
+
+### Explicit Multistep Methods
+
+```@docs
+AB3
+AB4
+AB5
+```
+
+### Predictor-Corrector Methods
+
+```@docs
+ABM32
+ABM43
+ABM54
+VCAB3
+VCAB4
+VCAB5
+VCABM3
+VCABM4
+VCABM5
+VCABM
+```

docs/src/explicit/Extrapolation.md

@@ -0,0 +1,23 @@
+```@meta
+CollapsedDocStrings = true
+```
+# OrdinaryDiffEqExtrapolation
+
+Solvers based on within method parallelism, allowing multithreading of the solution across
+different values of `f`.
+The explicit extrapolation solvers are generally outclassed by other explicit methods.
+However, some [stiff extrapolation](@ref StiffExtrapolation) methods perform very well if
+the problem is sufficiently stiff.
+
+```@eval
+first_steps = evalfile("./common_first_steps.jl")
+first_steps("OrdinaryDiffEqExtrapolation", "ExtrapolationMidpointDeuflhard")
+```
+
+## Full list of solvers
+
+```@docs
+AitkenNeville
+ExtrapolationMidpointDeuflhard
+ExtrapolationMidpointHairerWanner
+```

docs/src/explicit/Feagin.md

@@ -0,0 +1,25 @@
+```@meta
+CollapsedDocStrings = true
+```
+# OrdinaryDiffEqFeagin
+
+Preferred solvers for non-stiff problems at very low tolerance, `<1e-30`.
+Best combined with preciser than `Float64` number types for the state, such as the `BigFloat` number type.
+Note that the Feagin methods have a less robust error estimator than the Verner methods, and thus even for
+very low tolerance problems the Verner methods (`Vern9`) may still be more efficient. In addition, at extremely
+low tolerances the explicit extrapolation methods allow for arbitrarily high variable order stepping which will
+also outperform the Feagin methods. As such, the Feagin methods may be useful in the Float128 precision range
+but should be tested against other algorithms.
+
+```@eval
+first_steps = evalfile("./common_first_steps.jl")
+first_steps("OrdinaryDiffEqFeagin", "Feagin14")
+```
+
+## Full list of solvers
+
+```@docs
+Feagin10
+Feagin12
+Feagin14
+```

docs/src/explicit/HighOrderRK.md

@@ -0,0 +1,21 @@
+```@meta
+CollapsedDocStrings = true
+```
+# OrdinaryDiffEqHighOrderRK
+
+Solvers for non-stiff problems at low tolerance.
+However, the solvers in [`OrdinaryDiffEqVerner`](@ref OrdinaryDiffEqVerner) generally perform better at low tolerances.
+
+```@eval
+first_steps = evalfile("./common_first_steps.jl")
+first_steps("OrdinaryDiffEqHighOrderRK", "DP8")
+```
+
+## Full list of solvers
+
+```@docs
+TanYam7
+TsitPap8
+DP8
+PFRK87
+```

docs/src/explicit/LowOrderRK.md

@@ -0,0 +1,47 @@
+```@meta
+CollapsedDocStrings = true
+```
+# OrdinaryDiffEqLowOrderRK
+
+If [`OrdinaryDiffEqTsit5`](@ref OrdinaryDiffEqTsit5) is not working well for your non-stiff problem at default and higher tolerance,
+it can be worthwhile to explore the options in this package.
+In particular, when more robust error control is required, [`BS5`](@ref) is a good choice.
+If at moderate tolerances and the interpolation error is very important,
+consider the [`OwrenZen5`](@ref) method.
+For fast solving at higher tolerances, we recommend [`BS3`](@ref),
+or [`OwrenZen3`](@ref)if the interpolation error is important.
+
+```@eval
+first_steps = evalfile("./common_first_steps.jl")
+first_steps("OrdinaryDiffEqLowOrderRK", "BS3")
+```
+
+## Full list of solvers
+
+```@docs
+Euler
+Heun
+Ralston
+Midpoint
+RK4
+BS3
+OwrenZen3
+OwrenZen4
+OwrenZen5
+BS5
+DP5
+Anas5
+RKO65
+FRK65
+RKM
+MSRK5
+MSRK6
+PSRK4p7q6
+PSRK3p5q4
+PSRK3p6q5
+Stepanov5
+SIR54
+Alshina2
+Alshina3
+Alshina6
+```