docs Verner

docs/make.jl

@@ -31,7 +31,8 @@ makedocs(sitename = "OrdinaryDiffEq.jl",
         "Explicit Solvers" => [
             "explicit/Tsit5.md",
             "explicit/LowOrderRK.md",
-            "explicit/HighOrderRK.md"
+            "explicit/HighOrderRK.md",
+            "explicit/Verner.md"
         ],
         "ODEProblem Solver Libraries" => [
             "Explicit Solvers" =>[

docs/src/explicit/HighOrderRK.md

@@ -1,7 +1,7 @@
 # OrdinaryDiffEqHighOrderRK
 
 Solvers for non-stiff problems at low tolerance.
-However, the solvers in `OrdinaryDiffEqVerner` are generally perform better at low 
+However, the solvers in [`OrdinaryDiffEqVerner`](@ref OrdinaryDiffEqVerner) generally perform better at low tolerances. 
 
 ```@eval
 first_steps = evalfile("./common_first_steps.jl")

docs/src/explicit/Verner.md

@@ -0,0 +1,27 @@
+# [OrdinaryDiffEqVerner](@id OrdinaryDiffEqVerner)
+
+Preferred solvers for non-stiff problems at low tolerance.
+`Vern6`, `Vern7`, or `Vern8` are good methods for tolerances between `~1e-8-1e-12`,
+and using `Float64` numbers for the state of the differential equation.
+For even lower tolerances,`Vern9` should be used, combined with the more precise `BigFloat` number type. 
+
+```@eval
+first_steps = evalfile("./common_first_steps.jl")
+first_steps("OrdinaryDiffEqVerner", "Vern6")
+```
+
+## Full list of solvers
+
+```@docs
+Vern6
+Vern7
+Vern8
+Vern9
+```
+
+```@docs
+AutoVern6
+AutoVern7
+AutoVern8
+AutoVern9
+```

lib/OrdinaryDiffEqVerner/src/algorithms.jl

@@ -113,7 +113,43 @@ function Vern9(stage_limiter!, step_limiter! = trivial_limiter!; lazy = true)
     Vern9(stage_limiter!, step_limiter!, False(), lazy)
 end
 
+"""
+Automatic switching algorithm that can switch between the (non-stiff) `Vern6()` and `stiff_alg`.
+
+    AutoVern6(stiff_alg; kwargs...)
+
+This method is equivalent to `AutoAlgSwitch(Vern6(), stiff_alg; kwargs...)`.
+To gain access to stiff algorithms you might have to install additional libraries,
+such as `OrdinaryDiffEqRosenbrock`.
+"""
 AutoVern6(alg; lazy = true, kwargs...) = AutoAlgSwitch(Vern6(lazy = lazy), alg; kwargs...)
+"""
+Automatic switching algorithm that can switch between the (non-stiff) `Vern7()` and `stiff_alg`.
+
+    AutoVern7(stiff_alg; kwargs...)
+
+This method is equivalent to `AutoAlgSwitch(Vern7(), stiff_alg; kwargs...)`.
+To gain access to stiff algorithms you might have to install additional libraries,
+such as `OrdinaryDiffEqRosenbrock`.
+"""
 AutoVern7(alg; lazy = true, kwargs...) = AutoAlgSwitch(Vern7(lazy = lazy), alg; kwargs...)
+"""
+Automatic switching algorithm that can switch between the (non-stiff) `Vern8()` and `stiff_alg`.
+
+    AutoVern8(stiff_alg; kwargs...)
+
+This method is equivalent to `AutoAlgSwitch(Vern8(), stiff_alg; kwargs...)`.
+To gain access to stiff algorithms you might have to install additional libraries,
+such as `OrdinaryDiffEqRosenbrock`.
+"""
 AutoVern8(alg; lazy = true, kwargs...) = AutoAlgSwitch(Vern8(lazy = lazy), alg; kwargs...)
+"""
+Automatic switching algorithm that can switch between the (non-stiff) `Vern9()` and `stiff_alg`.
+
+    AutoVern9(stiff_alg; kwargs...)
+
+This method is equivalent to `AutoAlgSwitch(Vern9(), stiff_alg; kwargs...)`.
+To gain access to stiff algorithms you might have to install additional libraries,
+such as `OrdinaryDiffEqRosenbrock`.
+"""
 AutoVern9(alg; lazy = true, kwargs...) = AutoAlgSwitch(Vern9(lazy = lazy), alg; kwargs...)