Upstream

Project.toml

@@ -1,7 +1,7 @@
 name = "OrdinaryDiffEq"
 uuid = "1dea7af3-3e70-54e6-95c3-0bf5283fa5ed"
 authors = ["Chris Rackauckas <[email protected]>", "Yingbo Ma <[email protected]>"]
-version = "6.88.1"
+version = "6.89.0"
 
 [deps]
 ADTypes = "47edcb42-4c32-4615-8424-f2b9edc5f35b"

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,87 @@ 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("semiimplicit", "Rosenbrock.md"),
+            joinpath("massmatrixdae", "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/Verner.md",
+            "explicit/AdamsBashforthMoulton.md",
+            "explicit/LowStorageRK.md",
+            "explicit/SSPRK.md",
+            "explicit/LowOrderRK.md",
+            "explicit/HighOrderRK.md",
+            "explicit/Feagin.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"
+        "Semi-Implicit Solvers" => [
+            "semiimplicit/Rosenbrock.md",
+            "semiimplicit/StabalizedRK.md",
+            "semiimplicit/ExponentialRK.md"
         ],
-        "Second Order and Dynamical ODE Solvers" => [
-            "dynamical/nystrom.md",
-            "dynamical/symplectic.md"
+        "Implicit Solvers" => [
+            "implicit/SDIRK.md",
+            "implicit/FIRK.md",
+            "implicit/BDF.md",
+            "implicit/Extrapolation.md",
+            "implicit/PDIRK.md",
+            "implicit/Nordsieck.md"
         ],
         "IMEX Solvers" => [
-            "imex/imex_multistep.md",
-            "imex/imex_sdirk.md"
+            "imex/IMEXMultistep.md",
+            "imex/StabalizedIRK.md",
+            "imex/IMEXBDF.md"
+        ],
+        "Dynamical ODE Explicit Solvers" => [
+            "dynamicalodeexplicit/RKN.md",
+            "dynamicalodeexplicit/SymplecticRK.md"
         ],
         "Semilinear ODE Solvers" => [
-            "semilinear/exponential_rk.md",
-            "semilinear/magnus.md"
+            "semilinear/ExponentialRK.md",
+            "semilinear/Linear.md"
+        ],
+        "Mass Matrix DAE Solvers" => [
+            "massmatrixdae/Rosenbrock.md",
+            "massmatrixdae/BDF.md"
         ],
-        "DAEProblem Solvers" => [
-            "dae/fully_implicit.md"
+        "Fully Implicit DAE Solvers" => [
+            "fullyimplicitdae/BDF.md"
         ],
         "Misc Solvers" => [
             "misc.md"

docs/src/dynamicalodeexplicit/RKN.md

@@ -0,0 +1,57 @@
+```@meta
+CollapsedDocStrings = true
+```
+
+# OrdinaryDiffEqRKN
+
+Second order solvers.
+
+To be able to access the solvers in `OrdinaryDiffEqRKN`, you must first install them use the Julia package manager:
+
+```julia
+using Pkg
+Pkg.add("OrdinaryDiffEqRKN")
+```
+
+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 OrdinaryDiffEqOrdinaryDiffEqRKN
+function HH_acceleration!(dv, v, u, p, t)
+    x, y = u
+    dx, dy = dv
+    dv[1] = -x - 2x * y
+    dv[2] = y^2 - y - x^2
+end
+initial_positions = [0.0, 0.1]
+initial_velocities = [0.5, 0.0]
+tspan = (0.0, 1.0)
+prob = SecondOrderODEProblem(HH_acceleration!, initial_velocities, initial_positions, tspan)
+sol = solve(prob, Nystrom4(), dt = 1 / 10)
+```
+
+## Full list of solvers
+
+```@docs
+IRKN3
+IRKN4
+Nystrom4
+Nystrom4VelocityIndependent
+Nystrom5VelocityIndependent
+FineRKN4
+FineRKN5
+DPRKN4
+DPRKN5
+DPRKN6
+DPRKN6FM
+DPRKN8
+DPRKN12
+ERKN4
+ERKN5
+ERKN7
+RKN4
+```

docs/src/dynamicalodeexplicit/SymplecticRK.md

@@ -0,0 +1,64 @@
+```@meta
+CollapsedDocStrings = true
+```
+
+# OrdinaryDiffEqSymplecticRK
+
+A symplectic integrator is an integrator whose solution resides on a symplectic manifold.
+Because of discretization error, when it is solving a Hamiltonian system it doesn't get exactly the correct trajectory on the manifold.
+Instead, that trajectory itself is perturbed `O(Δtn)` for the order n from the true trajectory.
+Then there's a linear drift due to numerical error of this trajectory over time
+Normal integrators tend to have a quadratic (or more) drift, and do not have any good global guarantees about this phase space path (just local).
+What means is that symplectic integrators tend to capture the long-time patterns better than normal integrators because of this lack of drift and this almost guarantee of periodicity.
+
+## Installation
+
+To be able to access the solvers in `OrdinaryDiffEqSymplecticRK`, you must first install them use the Julia package manager:
+
+```julia
+using Pkg
+Pkg.add("OrdinaryDiffEqSymplecticRK")
+```
+
+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 OrdinaryDiffEqSymplecticRK
+function HH_acceleration!(dv, v, u, p, t)
+    x, y = u
+    dx, dy = dv
+    dv[1] = -x - 2x * y
+    dv[2] = y^2 - y - x^2
+end
+initial_positions = [0.0, 0.1]
+initial_velocities = [0.5, 0.0]
+tspan = (0.0, 1.0)
+prob = SecondOrderODEProblem(HH_acceleration!, initial_velocities, initial_positions, tspan)
+sol = solve(prob, KahanLi8(), dt = 1 / 10)
+```
+
+## Full list of solvers
+
+```@docs
+SymplecticEuler
+VelocityVerlet
+VerletLeapfrog
+PseudoVerletLeapfrog
+McAte2
+Ruth3
+McAte3
+CandyRoz4
+McAte4
+CalvoSanz4
+McAte42
+McAte5
+Yoshida6
+KahanLi6
+McAte8
+KahanLi8
+SofSpa10
+```

docs/src/explicit/AdamsBashforthMoulton.md

@@ -0,0 +1,37 @@
+```@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,24 @@
+```@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
+```