From b665f31dedc326c44983d44702cda2e324b8615e Mon Sep 17 00:00:00 2001 From: "Documenter.jl" Date: Mon, 6 Nov 2023 03:31:18 +0000 Subject: [PATCH] build based on 57d87ba --- dev/assets/Manifest.toml | 71 +++++----- dev/dae/fully_implicit/index.html | 2 +- dev/dynamical/nystrom/index.html | 6 +- dev/dynamical/symplectic/index.html | 2 +- dev/imex/imex_multistep/index.html | 2 +- dev/imex/imex_sdirk/index.html | 4 +- dev/index.html | 22 ++-- dev/misc/index.html | 2 +- .../explicit_extrapolation/index.html | 2 +- dev/nonstiff/explicitrk/index.html | 64 ++++----- dev/nonstiff/lowstorage_ssprk/index.html | 122 +++++++++--------- dev/nonstiff/nonstiff_multistep/index.html | 2 +- dev/search/index.html | 2 +- dev/semilinear/exponential_rk/index.html | 2 +- dev/semilinear/magnus/index.html | 2 +- dev/stiff/firk/index.html | 2 +- dev/stiff/implicit_extrapolation/index.html | 2 +- dev/stiff/rosenbrock/index.html | 2 +- dev/stiff/sdirk/index.html | 2 +- dev/stiff/stabilized_rk/index.html | 2 +- dev/stiff/stiff_multistep/index.html | 2 +- dev/usage/index.html | 2 +- 22 files changed, 157 insertions(+), 164 deletions(-) diff --git a/dev/assets/Manifest.toml b/dev/assets/Manifest.toml index 703bdab859..8ad4cc38a4 100644 --- a/dev/assets/Manifest.toml +++ b/dev/assets/Manifest.toml @@ -74,16 +74,6 @@ git-tree-sha1 = "601f7e7b3d36f18790e2caf83a882d88e9b71ff1" uuid = "2a0fbf3d-bb9c-48f3-b0a9-814d99fd7ab9" version = "0.2.4" -[[deps.ChainRulesCore]] -deps = ["Compat", "LinearAlgebra"] -git-tree-sha1 = "e0af648f0692ec1691b5d094b8724ba1346281cf" -uuid = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" -version = "1.18.0" -weakdeps = ["SparseArrays"] - - [deps.ChainRulesCore.extensions] - ChainRulesCoreSparseArraysExt = "SparseArrays" - [[deps.CloseOpenIntervals]] deps = ["Static", "StaticArrayInterface"] git-tree-sha1 = "70232f82ffaab9dc52585e0dd043b5e0c6b714f1" @@ -162,14 +152,15 @@ deps = ["Printf"] uuid = "ade2ca70-3891-5945-98fb-dc099432e06a" [[deps.DiffEqBase]] -deps = ["ArrayInterface", "ChainRulesCore", "DataStructures", "DocStringExtensions", "EnumX", "EnzymeCore", "FastBroadcast", "ForwardDiff", "FunctionWrappers", "FunctionWrappersWrappers", "LinearAlgebra", "Logging", "Markdown", "MuladdMacro", "Parameters", "PreallocationTools", "PrecompileTools", "Printf", "RecursiveArrayTools", "Reexport", "Requires", "SciMLBase", "SciMLOperators", "Setfield", "SparseArrays", "Static", "StaticArraysCore", "Statistics", "Tricks", "TruncatedStacktraces", "ZygoteRules"] -git-tree-sha1 = "c8bc8487a7987c13576f25959ac11b25d5da84e2" +deps = ["ArrayInterface", "DataStructures", "DocStringExtensions", "EnumX", "EnzymeCore", "FastBroadcast", "ForwardDiff", "FunctionWrappers", "FunctionWrappersWrappers", "LinearAlgebra", "Logging", "Markdown", "MuladdMacro", "Parameters", "PreallocationTools", "PrecompileTools", "Printf", "RecursiveArrayTools", "Reexport", "SciMLBase", "SciMLOperators", "Setfield", "SparseArrays", "Static", "StaticArraysCore", "Statistics", "Tricks", "TruncatedStacktraces"] +git-tree-sha1 = "de4709e30bd5490435122c4b415b90a812c23fbf" uuid = "2b5f629d-d688-5b77-993f-72d75c75574e" -version = "6.136.0" +version = "6.138.1" [deps.DiffEqBase.extensions] + DiffEqBaseChainRulesCoreExt = "ChainRulesCore" DiffEqBaseDistributionsExt = "Distributions" - DiffEqBaseEnzymeExt = "Enzyme" + DiffEqBaseEnzymeExt = ["ChainRulesCore", "Enzyme"] DiffEqBaseGeneralizedGeneratedExt = "GeneralizedGenerated" DiffEqBaseMPIExt = "MPI" DiffEqBaseMeasurementsExt = "Measurements" @@ -177,9 +168,9 @@ version = "6.136.0" DiffEqBaseReverseDiffExt = "ReverseDiff" DiffEqBaseTrackerExt = "Tracker" DiffEqBaseUnitfulExt = "Unitful" - DiffEqBaseZygoteExt = "Zygote" [deps.DiffEqBase.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" Distributions = "31c24e10-a181-5473-b8eb-7969acd0382f" Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9" GeneralizedGenerated = "6b9d7cbe-bcb9-11e9-073f-15a7a543e2eb" @@ -189,7 +180,6 @@ version = "6.136.0" ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" Unitful = "1986cc42-f94f-5a68-af5c-568840ba703d" - Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" [[deps.DiffResults]] deps = ["StaticArraysCore"] @@ -208,12 +198,15 @@ deps = ["LinearAlgebra", "Statistics", "StatsAPI"] git-tree-sha1 = "5225c965635d8c21168e32a12954675e7bea1151" uuid = "b4f34e82-e78d-54a5-968a-f98e89d6e8f7" version = "0.10.10" -weakdeps = ["ChainRulesCore", "SparseArrays"] [deps.Distances.extensions] DistancesChainRulesCoreExt = "ChainRulesCore" DistancesSparseArraysExt = "SparseArrays" + [deps.Distances.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + [[deps.Distributed]] deps = ["Random", "Serialization", "Sockets"] uuid = "8ba89e20-285c-5b6f-9357-94700520ee1b" @@ -463,9 +456,9 @@ uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" [[deps.LinearSolve]] deps = ["ArrayInterface", "ConcreteStructs", "DocStringExtensions", "EnumX", "EnzymeCore", "FastLapackInterface", "GPUArraysCore", "InteractiveUtils", "KLU", "Krylov", "Libdl", "LinearAlgebra", "MKL", "MKL_jll", "PrecompileTools", "Preferences", "RecursiveFactorization", "Reexport", "Requires", "SciMLBase", "SciMLOperators", "Setfield", "SparseArrays", "Sparspak", "SuiteSparse", "UnPack"] -git-tree-sha1 = "371e4ece4fc1341f54531dde75ae7d0b19257c2c" +git-tree-sha1 = "6573ca0e133d8db412d045faafc9705d22f94fe1" uuid = "7ed4a6bd-45f5-4d41-b270-4a48e9bafcae" -version = "2.15.0" +version = "2.16.1" [deps.LinearSolve.extensions] LinearSolveBandedMatricesExt = "BandedMatrices" @@ -517,12 +510,16 @@ deps = ["ArrayInterface", "CPUSummary", "CloseOpenIntervals", "DocStringExtensio git-tree-sha1 = "0f5648fbae0d015e3abe5867bca2b362f67a5894" uuid = "bdcacae8-1622-11e9-2a5c-532679323890" version = "0.12.166" -weakdeps = ["ChainRulesCore", "ForwardDiff", "SpecialFunctions"] [deps.LoopVectorization.extensions] ForwardDiffExt = ["ChainRulesCore", "ForwardDiff"] SpecialFunctionsExt = "SpecialFunctions" + [deps.LoopVectorization.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b" + [[deps.MKL]] deps = ["Artifacts", "Libdl", "LinearAlgebra", "MKL_jll"] git-tree-sha1 = "100521a1d2181cb39036ee1a6955d6b9686bb363" @@ -591,9 +588,9 @@ version = "1.2.0" [[deps.NonlinearSolve]] deps = ["ADTypes", "ArrayInterface", "ConcreteStructs", "DiffEqBase", "EnumX", "FastBroadcast", "FiniteDiff", "ForwardDiff", "LineSearches", "LinearAlgebra", "LinearSolve", "PrecompileTools", "RecursiveArrayTools", "Reexport", "SciMLBase", "SimpleNonlinearSolve", "SparseArrays", "SparseDiffTools", "StaticArraysCore", "UnPack"] -git-tree-sha1 = "613f5d5b911ab761cc7f41191c197ba3d9ca9d78" +git-tree-sha1 = "6e7919a71af529fd58af4a7f5fd5a612f53f54a7" uuid = "8913a72c-1f9b-4ce2-8d82-65094dcecaec" -version = "2.6.0" +version = "2.7.0" [deps.NonlinearSolve.extensions] NonlinearSolveBandedMatricesExt = "BandedMatrices" @@ -772,12 +769,13 @@ uuid = "476501e8-09a2-5ece-8869-fb82de89a1fa" version = "0.6.42" [[deps.SciMLBase]] -deps = ["ADTypes", "ArrayInterface", "ChainRulesCore", "CommonSolve", "ConstructionBase", "Distributed", "DocStringExtensions", "EnumX", "FillArrays", "FunctionWrappersWrappers", "IteratorInterfaceExtensions", "LinearAlgebra", "Logging", "Markdown", "PrecompileTools", "Preferences", "Printf", "RecipesBase", "RecursiveArrayTools", "Reexport", "RuntimeGeneratedFunctions", "SciMLOperators", "StaticArraysCore", "Statistics", "SymbolicIndexingInterface", "Tables", "TruncatedStacktraces", "ZygoteRules"] -git-tree-sha1 = "9e4c2902c2e8675c3b67eb24fd7f89defcbde9af" +deps = ["ADTypes", "ArrayInterface", "CommonSolve", "ConstructionBase", "Distributed", "DocStringExtensions", "EnumX", "FillArrays", "FunctionWrappersWrappers", "IteratorInterfaceExtensions", "LinearAlgebra", "Logging", "Markdown", "PrecompileTools", "Preferences", "Printf", "RecipesBase", "RecursiveArrayTools", "Reexport", "RuntimeGeneratedFunctions", "SciMLOperators", "StaticArraysCore", "Statistics", "SymbolicIndexingInterface", "Tables", "TruncatedStacktraces"] +git-tree-sha1 = "8d1bb6b4c0aa7c1bcd3bcd81e2b8c3b4f4b0733e" uuid = "0bca4576-84f4-4d90-8ffe-ffa030f20462" -version = "2.6.0" +version = "2.7.3" [deps.SciMLBase.extensions] + SciMLBaseChainRulesCoreExt = "ChainRulesCore" SciMLBasePartialFunctionsExt = "PartialFunctions" SciMLBasePyCallExt = "PyCall" SciMLBasePythonCallExt = "PythonCall" @@ -785,6 +783,7 @@ version = "2.6.0" SciMLBaseZygoteExt = "Zygote" [deps.SciMLBase.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" PartialFunctions = "570af359-4316-4cb7-8c74-252c00c2016b" PyCall = "438e738f-606a-5dbb-bf0a-cddfbfd45ab0" PythonCall = "6099a3de-0909-46bc-b1f4-468b9a2dfc0d" @@ -799,9 +798,9 @@ version = "0.1.9" [[deps.SciMLOperators]] deps = ["ArrayInterface", "DocStringExtensions", "Lazy", "LinearAlgebra", "Setfield", "SparseArrays", "StaticArraysCore", "Tricks"] -git-tree-sha1 = "65c2e6ced6f62ea796af251eb292a0e131a3613b" +git-tree-sha1 = "51ae235ff058a64815e0a2c34b1db7578a06813d" uuid = "c0aeaf25-5076-4817-a8d5-81caf7dfa961" -version = "0.3.6" +version = "0.3.7" [[deps.Serialization]] uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b" @@ -818,9 +817,9 @@ uuid = "1a1011a3-84de-559e-8e89-a11a2f7dc383" [[deps.SimpleNonlinearSolve]] deps = ["ArrayInterface", "DiffEqBase", "FiniteDiff", "ForwardDiff", "LinearAlgebra", "PackageExtensionCompat", "PrecompileTools", "Reexport", "SciMLBase", "StaticArraysCore"] -git-tree-sha1 = "15ff97fa4881133caa324dacafe28b5ac47ad8a2" +git-tree-sha1 = "37ee39f07e0258539005473bb30dc5f9c1236449" uuid = "727e6d20-b764-4bd8-a329-72de5adea6c7" -version = "0.1.23" +version = "0.1.24" [deps.SimpleNonlinearSolve.extensions] SimpleNonlinearSolveNNlibExt = "NNlib" @@ -848,9 +847,9 @@ uuid = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" [[deps.SparseDiffTools]] deps = ["ADTypes", "Adapt", "ArrayInterface", "Compat", "DataStructures", "FiniteDiff", "ForwardDiff", "Graphs", "LinearAlgebra", "PackageExtensionCompat", "Random", "Reexport", "SciMLOperators", "Setfield", "SparseArrays", "StaticArrayInterface", "StaticArrays", "Tricks", "UnPack", "VertexSafeGraphs"] -git-tree-sha1 = "bb0ff88a054f2dbf3d54d7630a42b743fcdfa21b" +git-tree-sha1 = "e162b74fd1ce6d371ff5c584b53e34538edb9212" uuid = "47a9eef4-7e08-11e9-0b38-333d64bd3804" -version = "2.9.2" +version = "2.11.0" [deps.SparseDiffTools.extensions] SparseDiffToolsEnzymeExt = "Enzyme" @@ -873,11 +872,13 @@ deps = ["IrrationalConstants", "LogExpFunctions", "OpenLibm_jll", "OpenSpecFun_j git-tree-sha1 = "e2cfc4012a19088254b3950b85c3c1d8882d864d" uuid = "276daf66-3868-5448-9aa4-cd146d93841b" version = "2.3.1" -weakdeps = ["ChainRulesCore"] [deps.SpecialFunctions.extensions] SpecialFunctionsChainRulesCoreExt = "ChainRulesCore" + [deps.SpecialFunctions.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + [[deps.Static]] deps = ["IfElse"] git-tree-sha1 = "f295e0a1da4ca425659c57441bcb59abb035a4bc" @@ -1020,12 +1021,6 @@ deps = ["Libdl"] uuid = "83775a58-1f1d-513f-b197-d71354ab007a" version = "1.2.13+0" -[[deps.ZygoteRules]] -deps = ["ChainRulesCore", "MacroTools"] -git-tree-sha1 = "9d749cd449fb448aeca4feee9a2f4186dbb5d184" -uuid = "700de1a5-db45-46bc-99cf-38207098b444" -version = "0.2.4" - [[deps.libblastrampoline_jll]] deps = ["Artifacts", "Libdl"] uuid = "8e850b90-86db-534c-a0d3-1478176c7d93" diff --git a/dev/dae/fully_implicit/index.html b/dev/dae/fully_implicit/index.html index e4a455a264..8cecbb5651 100644 --- a/dev/dae/fully_implicit/index.html +++ b/dev/dae/fully_implicit/index.html @@ -3,4 +3,4 @@ function gtag(){dataLayer.push(arguments);} gtag('js', new Date()); gtag('config', 'UA-90474609-3', {'page_path': location.pathname + location.search + location.hash}); -
Edit on GitHub

Methods for Fully Implicit ODEs (DAEProblem)

Missing docstring.

Missing docstring for DImplicitEuler. Check Documenter's build log for details.

Missing docstring.

Missing docstring for DABDF2. Check Documenter's build log for details.

Missing docstring.

Missing docstring for DFBDF. Check Documenter's build log for details.

+
Edit on GitHub

Methods for Fully Implicit ODEs (DAEProblem)

Missing docstring.

Missing docstring for DImplicitEuler. Check Documenter's build log for details.

Missing docstring.

Missing docstring for DABDF2. Check Documenter's build log for details.

Missing docstring.

Missing docstring for DFBDF. Check Documenter's build log for details.

diff --git a/dev/dynamical/nystrom/index.html b/dev/dynamical/nystrom/index.html index 0fbc5d9d69..7cc16c14e5 100644 --- a/dev/dynamical/nystrom/index.html +++ b/dev/dynamical/nystrom/index.html @@ -3,7 +3,7 @@ function gtag(){dataLayer.push(arguments);} gtag('js', new Date()); gtag('config', 'UA-90474609-3', {'page_path': location.pathname + location.search + location.hash}); -
Edit on GitHub

Runge-Kutta Nystrom Methods

OrdinaryDiffEq.IRKN3 — Type
IRKN3

Improved Runge-Kutta-Nyström method of order three, which minimizes the amount of evaluated functions in each step. Fixed time steps only.

Second order ODE should not depend on the first derivative.

References

@article{rabiei2012numerical, title={Numerical Solution of Second-Order Ordinary Differential Equations by Improved Runge-Kutta Nystrom Method}, author={Rabiei, Faranak and Ismail, Fudziah and Norazak, S and Emadi, Saeid}, publisher={Citeseer} }

source
OrdinaryDiffEq.IRKN4 — Type
IRKN4

Improves Runge-Kutta-Nyström method of order four, which minimizes the amount of evaluated functions in each step. Fixed time steps only.

Second order ODE should not be dependent on the first derivative.

Recommended for smooth problems with expensive functions to evaluate.

References

@article{rabiei2012numerical, title={Numerical Solution of Second-Order Ordinary Differential Equations by Improved Runge-Kutta Nystrom Method}, author={Rabiei, Faranak and Ismail, Fudziah and Norazak, S and Emadi, Saeid}, publisher={Citeseer} }

source
OrdinaryDiffEq.Nystrom4 — Type
Nystrom4

A 4th order explicit Runge-Kutta-Nyström method which can be applied directly on second order ODEs. Can only be used with fixed time steps.

In case the ODE Problem is not dependent on the first derivative consider using Nystrom4VelocityIndependent to increase performance.

References

E. Hairer, S.P. Norsett, G. Wanner, (1993) Solving Ordinary Differential Equations I. Nonstiff Problems. 2nd Edition. Springer Series in Computational Mathematics, Springer-Verlag.

source
OrdinaryDiffEq.Nystrom4VelocityIndependent — Type
Nystrom4VelocityIdependent

A 4th order explicit Runkge-Kutta-Nyström method. Used directly on second order ODEs, where the acceleration is independent from velocity (ODE Problem is not dependent on the first derivative).

More efficient then Nystrom4 on velocity independent problems, since less evaluations are needed.

Fixed time steps only.

References

E. Hairer, S.P. Norsett, G. Wanner, (1993) Solving Ordinary Differential Equations I. Nonstiff Problems. 2nd Edition. Springer Series in Computational Mathematics, Springer-Verlag.

source
OrdinaryDiffEq.Nystrom5VelocityIndependent — Type
Nystrom5VelocityIndependent

A 5th order explicit Runkge-Kutta-Nyström method. Used directly on second order ODEs, where the acceleration is independent from velocity (ODE Problem is not dependent on the first derivative). Fixed time steps only.

References

E. Hairer, S.P. Norsett, G. Wanner, (1993) Solving Ordinary Differential Equations I. Nonstiff Problems. 2nd Edition. Springer Series in Computational Mathematics, Springer-Verlag.

source
OrdinaryDiffEq.FineRKN4 — Type
FineRKN4()

A 4th order explicit Runge-Kutta-Nyström method which can be applied directly to second order ODEs. In particular, this method allows the acceleration equation to depend on the velocity.

References

@article{fine1987low,
+
Edit on GitHub
Runge-Kutta Nystrom Methods
OrdinaryDiffEq.IRKN3 — Type
IRKN3
Improved Runge-Kutta-Nyström method of order three, which minimizes the amount of evaluated functions in each step. Fixed time steps only.
Second order ODE should not depend on the first derivative.
References
@article{rabiei2012numerical, title={Numerical Solution of Second-Order Ordinary Differential Equations by Improved Runge-Kutta Nystrom Method}, author={Rabiei, Faranak and Ismail, Fudziah and Norazak, S and Emadi, Saeid}, publisher={Citeseer} }
source
OrdinaryDiffEq.IRKN4 — Type
IRKN4
Improves Runge-Kutta-Nyström method of order four, which minimizes the amount of evaluated functions in each step. Fixed time steps only.
Second order ODE should not be dependent on the first derivative.
Recommended for smooth problems with expensive functions to evaluate.
References
@article{rabiei2012numerical, title={Numerical Solution of Second-Order Ordinary Differential Equations by Improved Runge-Kutta Nystrom Method}, author={Rabiei, Faranak and Ismail, Fudziah and Norazak, S and Emadi, Saeid}, publisher={Citeseer} }
source
OrdinaryDiffEq.Nystrom4 — Type
Nystrom4
A 4th order explicit Runge-Kutta-Nyström method which can be applied directly on second order ODEs. Can only be used with fixed time steps.
In case the ODE Problem is not dependent on the first derivative consider using Nystrom4VelocityIndependent to increase performance.
References
E. Hairer, S.P. Norsett, G. Wanner, (1993) Solving Ordinary Differential Equations I. Nonstiff Problems. 2nd Edition. Springer Series in Computational Mathematics, Springer-Verlag.
source
OrdinaryDiffEq.Nystrom4VelocityIndependent — Type
Nystrom4VelocityIdependent
A 4th order explicit Runkge-Kutta-Nyström method. Used directly on second order ODEs, where the acceleration is independent from velocity (ODE Problem is not dependent on the first derivative).
More efficient then Nystrom4 on velocity independent problems, since less evaluations are needed.
Fixed time steps only.
References
E. Hairer, S.P. Norsett, G. Wanner, (1993) Solving Ordinary Differential Equations I. Nonstiff Problems. 2nd Edition. Springer Series in Computational Mathematics, Springer-Verlag.
source
OrdinaryDiffEq.Nystrom5VelocityIndependent — Type
Nystrom5VelocityIndependent
A 5th order explicit Runkge-Kutta-Nyström method. Used directly on second order ODEs, where the acceleration is independent from velocity (ODE Problem is not dependent on the first derivative). Fixed time steps only.
References
E. Hairer, S.P. Norsett, G. Wanner, (1993) Solving Ordinary Differential Equations I. Nonstiff Problems. 2nd Edition. Springer Series in Computational Mathematics, Springer-Verlag.
source
OrdinaryDiffEq.FineRKN4 — Type
FineRKN4()
A 4th order explicit Runge-Kutta-Nyström method which can be applied directly to second order ODEs. In particular, this method allows the acceleration equation to depend on the velocity.
References
@article{fine1987low,
   title={Low order practical {R}unge-{K}utta-{N}ystr{"o}m methods},
   author={Fine, Jerry Michael},
   journal={Computing},
@@ -12,7 +12,7 @@
   pages={281--297},
   year={1987},
   publisher={Springer}
-}
source
OrdinaryDiffEq.FineRKN5 — Type
FineRKN5()
A 5th order explicit Runge-Kutta-Nyström method which can be applied directly to second order ODEs. In particular, this method allows the acceleration equation to depend on the velocity.
References
@article{fine1987low,
+}
source
OrdinaryDiffEq.FineRKN5 — Type
FineRKN5()
A 5th order explicit Runge-Kutta-Nyström method which can be applied directly to second order ODEs. In particular, this method allows the acceleration equation to depend on the velocity.
References
@article{fine1987low,
   title={Low order practical {R}unge-{K}utta-{N}ystr{"o}m methods},
   author={Fine, Jerry Michael},
   journal={Computing},
@@ -21,4 +21,4 @@
   pages={281--297},
   year={1987},
   publisher={Springer}
-}
source
OrdinaryDiffEq.DPRKN6 — Type
DPRKN6
6th order explicit Runge-Kutta-Nyström method. The second order ODE should not depend on the first derivative. Free 6th order interpolant.
References
@article{dormand1987runge, title={Runge-kutta-nystrom triples}, author={Dormand, JR and Prince, PJ}, journal={Computers \& Mathematics with Applications}, volume={13}, number={12}, pages={937–949}, year={1987}, publisher={Elsevier} }
source
OrdinaryDiffEq.DPRKN6FM — Type
DPRKN6FM
6th order explicit Runge-Kutta-Nyström method. The second order ODE should not depend on the first derivative.
Compared to DPRKN6, this method has smaller truncation error coefficients which leads to performance gain when only the main solution points are considered.
References
@article{Dormand1987FamiliesOR, title={Families of Runge-Kutta-Nystrom Formulae}, author={J. R. Dormand and Moawwad E. A. El-Mikkawy and P. J. Prince}, journal={Ima Journal of Numerical Analysis}, year={1987}, volume={7}, pages={235-250} }
source
OrdinaryDiffEq.DPRKN8 — Type
DPRKN8
8th order explicit Runge-Kutta-Nyström method. The second order ODE should not depend on the first derivative.
Not as efficient as DPRKN12 when high accuracy is needed, however this solver is competitive with DPRKN6 at lax tolerances and, depending on the problem, might be a good option between performance and accuracy.
References
@article{dormand1987high, title={High-order embedded Runge-Kutta-Nystrom formulae}, author={Dormand, JR and El-Mikkawy, MEA and Prince, PJ}, journal={IMA Journal of Numerical Analysis}, volume={7}, number={4}, pages={423–430}, year={1987}, publisher={Oxford University Press} }
source
OrdinaryDiffEq.DPRKN12 — Type
DPRKN12
12th order explicit Rugne-Kutta-Nyström method. The second order ODE should not depend on the first derivative.
Most efficient when high accuracy is needed.
References
@article{dormand1987high, title={High-order embedded Runge-Kutta-Nystrom formulae}, author={Dormand, JR and El-Mikkawy, MEA and Prince, PJ}, journal={IMA Journal of Numerical Analysis}, volume={7}, number={4}, pages={423–430}, year={1987}, publisher={Oxford University Press} }
source
OrdinaryDiffEq.ERKN4 — Type
ERKN4
Embedded 4(3) pair of explicit Runge-Kutta-Nyström methods. Integrates the periodic properties of the harmonic oscillator exactly.
The second order ODE should not depend on the first derivative.
Uses adaptive step size control. This method is extra efficient on periodic problems.
References
@article{demba2017embedded, title={An Embedded 4 (3) Pair of Explicit Trigonometrically-Fitted Runge-Kutta-Nystr{"o}m Method for Solving Periodic Initial Value Problems}, author={Demba, MA and Senu, N and Ismail, F}, journal={Applied Mathematical Sciences}, volume={11}, number={17}, pages={819–838}, year={2017} }
source
OrdinaryDiffEq.ERKN5 — Type
ERKN5
Embedded 5(4) pair of explicit Runge-Kutta-Nyström methods. Integrates the periodic properties of the harmonic oscillator exactly.
The second order ODE should not depend on the first derivative.
Uses adaptive step size control. This method is extra efficient on periodic problems.
References
@article{demba20165, title={A 5 (4) Embedded Pair of Explicit Trigonometrically-Fitted Runge–Kutta–Nystr{"o}m Methods for the Numerical Solution of Oscillatory Initial Value Problems}, author={Demba, Musa A and Senu, Norazak and Ismail, Fudziah}, journal={Mathematical and Computational Applications}, volume={21}, number={4}, pages={46}, year={2016}, publisher={Multidisciplinary Digital Publishing Institute} }
source
OrdinaryDiffEq.ERKN7 — Type
ERKN7
Embedded pair of explicit Runge-Kutta-Nyström methods. Integrates the periodic properties of the harmonic oscillator exactly.
The second order ODE should not depend on the first derivative.
Uses adaptive step size control. This method is extra efficient on periodic Problems.
References
@article{SimosOnHO, title={On high order Runge-Kutta-Nystr{"o}m pairs}, author={Theodore E. Simos and Ch. Tsitouras}, journal={J. Comput. Appl. Math.}, volume={400}, pages={113753} }
source

+}
source
OrdinaryDiffEq.DPRKN6 — Type
DPRKN6

6th order explicit Runge-Kutta-Nyström method. The second order ODE should not depend on the first derivative. Free 6th order interpolant.

References

@article{dormand1987runge, title={Runge-kutta-nystrom triples}, author={Dormand, JR and Prince, PJ}, journal={Computers \& Mathematics with Applications}, volume={13}, number={12}, pages={937–949}, year={1987}, publisher={Elsevier} }

source
OrdinaryDiffEq.DPRKN6FM — Type
DPRKN6FM

6th order explicit Runge-Kutta-Nyström method. The second order ODE should not depend on the first derivative.

Compared to DPRKN6, this method has smaller truncation error coefficients which leads to performance gain when only the main solution points are considered.

References

@article{Dormand1987FamiliesOR, title={Families of Runge-Kutta-Nystrom Formulae}, author={J. R. Dormand and Moawwad E. A. El-Mikkawy and P. J. Prince}, journal={Ima Journal of Numerical Analysis}, year={1987}, volume={7}, pages={235-250} }

source
OrdinaryDiffEq.DPRKN8 — Type
DPRKN8

8th order explicit Runge-Kutta-Nyström method. The second order ODE should not depend on the first derivative.

Not as efficient as DPRKN12 when high accuracy is needed, however this solver is competitive with DPRKN6 at lax tolerances and, depending on the problem, might be a good option between performance and accuracy.

References

@article{dormand1987high, title={High-order embedded Runge-Kutta-Nystrom formulae}, author={Dormand, JR and El-Mikkawy, MEA and Prince, PJ}, journal={IMA Journal of Numerical Analysis}, volume={7}, number={4}, pages={423–430}, year={1987}, publisher={Oxford University Press} }

source
OrdinaryDiffEq.DPRKN12 — Type
DPRKN12

12th order explicit Rugne-Kutta-Nyström method. The second order ODE should not depend on the first derivative.

Most efficient when high accuracy is needed.

References

@article{dormand1987high, title={High-order embedded Runge-Kutta-Nystrom formulae}, author={Dormand, JR and El-Mikkawy, MEA and Prince, PJ}, journal={IMA Journal of Numerical Analysis}, volume={7}, number={4}, pages={423–430}, year={1987}, publisher={Oxford University Press} }

source
OrdinaryDiffEq.ERKN4 — Type
ERKN4

Embedded 4(3) pair of explicit Runge-Kutta-Nyström methods. Integrates the periodic properties of the harmonic oscillator exactly.

The second order ODE should not depend on the first derivative.

Uses adaptive step size control. This method is extra efficient on periodic problems.

References

@article{demba2017embedded, title={An Embedded 4 (3) Pair of Explicit Trigonometrically-Fitted Runge-Kutta-Nystr{"o}m Method for Solving Periodic Initial Value Problems}, author={Demba, MA and Senu, N and Ismail, F}, journal={Applied Mathematical Sciences}, volume={11}, number={17}, pages={819–838}, year={2017} }

source
OrdinaryDiffEq.ERKN5 — Type
ERKN5

Embedded 5(4) pair of explicit Runge-Kutta-Nyström methods. Integrates the periodic properties of the harmonic oscillator exactly.

The second order ODE should not depend on the first derivative.

Uses adaptive step size control. This method is extra efficient on periodic problems.

References

@article{demba20165, title={A 5 (4) Embedded Pair of Explicit Trigonometrically-Fitted Runge–Kutta–Nystr{"o}m Methods for the Numerical Solution of Oscillatory Initial Value Problems}, author={Demba, Musa A and Senu, Norazak and Ismail, Fudziah}, journal={Mathematical and Computational Applications}, volume={21}, number={4}, pages={46}, year={2016}, publisher={Multidisciplinary Digital Publishing Institute} }

source
OrdinaryDiffEq.ERKN7 — Type
ERKN7

Embedded pair of explicit Runge-Kutta-Nyström methods. Integrates the periodic properties of the harmonic oscillator exactly.

The second order ODE should not depend on the first derivative.

Uses adaptive step size control. This method is extra efficient on periodic Problems.

References

@article{SimosOnHO, title={On high order Runge-Kutta-Nystr{"o}m pairs}, author={Theodore E. Simos and Ch. Tsitouras}, journal={J. Comput. Appl. Math.}, volume={400}, pages={113753} }

source
diff --git a/dev/dynamical/symplectic/index.html b/dev/dynamical/symplectic/index.html index 509bf946e6..f6bc5c82e5 100644 --- a/dev/dynamical/symplectic/index.html +++ b/dev/dynamical/symplectic/index.html @@ -3,4 +3,4 @@ function gtag(){dataLayer.push(arguments);} gtag('js', new Date()); gtag('config', 'UA-90474609-3', {'page_path': location.pathname + location.search + location.hash}); -
Edit on GitHub

Symplectic Runge-Kutta Methods

Missing docstring.

Missing docstring for SymplecticEuler. Check Documenter's build log for details.

OrdinaryDiffEq.VelocityVerlet — Type

@article{verlet1967computer, title={Computer" experiments" on classical fluids. I. Thermodynamical properties of Lennard-Jones molecules}, author={Verlet, Loup}, journal={Physical review}, volume={159}, number={1}, pages={98}, year={1967}, publisher={APS} }

source
OrdinaryDiffEq.VerletLeapfrog — Type

@article{verlet1967computer, title={Computer" experiments" on classical fluids. I. Thermodynamical properties of Lennard-Jones molecules}, author={Verlet, Loup}, journal={Physical review}, volume={159}, number={1}, pages={98}, year={1967}, publisher={APS} }

source
OrdinaryDiffEq.PseudoVerletLeapfrog — Type

@article{verlet1967computer, title={Computer" experiments" on classical fluids. I. Thermodynamical properties of Lennard-Jones molecules}, author={Verlet, Loup}, journal={Physical review}, volume={159}, number={1}, pages={98}, year={1967}, publisher={APS} }

source
OrdinaryDiffEq.McAte2 — Type

@article{mclachlan1992accuracy, title={The accuracy of symplectic integrators}, author={McLachlan, Robert I and Atela, Pau}, journal={Nonlinearity}, volume={5}, number={2}, pages={541}, year={1992}, publisher={IOP Publishing} }

source
OrdinaryDiffEq.Ruth3 — Type

@article{ruth1983canonical, title={A canonical integration technique}, author={Ruth, Ronald D}, journal={IEEE Trans. Nucl. Sci.}, volume={30}, number={CERN-LEP-TH-83-14}, pages={2669–2671}, year={1983} }

source
OrdinaryDiffEq.McAte3 — Type

@article{mclachlan1992accuracy, title={The accuracy of symplectic integrators}, author={McLachlan, Robert I and Atela, Pau}, journal={Nonlinearity}, volume={5}, number={2}, pages={541}, year={1992}, publisher={IOP Publishing} }

source
OrdinaryDiffEq.CandyRoz4 — Type

@article{candy1991symplectic, title={A symplectic integration algorithm for separable Hamiltonian functions}, author={Candy, J and Rozmus, W}, journal={Journal of Computational Physics}, volume={92}, number={1}, pages={230–256}, year={1991}, publisher={Elsevier} }

source
Missing docstring.

Missing docstring for McAte4. Check Documenter's build log for details.

OrdinaryDiffEq.CalvoSanz4 — Type

@article{sanz1993symplectic, title={Symplectic numerical methods for Hamiltonian problems}, author={Sanz-Serna, Jes{'u}s Maria and Calvo, Mari-Paz}, journal={International Journal of Modern Physics C}, volume={4}, number={02}, pages={385–392}, year={1993}, publisher={World Scientific} }

source
OrdinaryDiffEq.McAte42 — Type

@article{mclachlan1992accuracy, title={The accuracy of symplectic integrators}, author={McLachlan, Robert I and Atela, Pau}, journal={Nonlinearity}, volume={5}, number={2}, pages={541}, year={1992}, publisher={IOP Publishing} }

source
OrdinaryDiffEq.McAte5 — Type

@article{mclachlan1992accuracy, title={The accuracy of symplectic integrators}, author={McLachlan, Robert I and Atela, Pau}, journal={Nonlinearity}, volume={5}, number={2}, pages={541}, year={1992}, publisher={IOP Publishing} }

source
OrdinaryDiffEq.Yoshida6 — Type

@article{yoshida1990construction, title={Construction of higher order symplectic integrators}, author={Yoshida, Haruo}, journal={Physics letters A}, volume={150}, number={5-7}, pages={262–268}, year={1990}, publisher={Elsevier} }

source
OrdinaryDiffEq.KahanLi6 — Type

@article{kahan1997composition, title={Composition constants for raising the orders of unconventional schemes for ordinary differential equations}, author={Kahan, William and Li, Ren-Cang}, journal={Mathematics of computation}, volume={66}, number={219}, pages={1089–1099}, year={1997} }

source
OrdinaryDiffEq.McAte8 — Type

@article{mclachlan1995numerical, title={On the numerical integration of ordinary differential equations by symmetric composition methods}, author={McLachlan, Robert I}, journal={SIAM Journal on Scientific Computing}, volume={16}, number={1}, pages={151–168}, year={1995}, publisher={SIAM} }

source
OrdinaryDiffEq.KahanLi8 — Type

@article{kahan1997composition, title={Composition constants for raising the orders of unconventional schemes for ordinary differential equations}, author={Kahan, William and Li, Ren-Cang}, journal={Mathematics of computation}, volume={66}, number={219}, pages={1089–1099}, year={1997} }

source
OrdinaryDiffEq.SofSpa10 — Type

@article{sofroniou2005derivation, title={Derivation of symmetric composition constants for symmetric integrators}, author={Sofroniou, Mark and Spaletta, Giulia}, journal={Optimization Methods and Software}, volume={20}, number={4-5}, pages={597–613}, year={2005}, publisher={Taylor \& Francis} }

source
+
Edit on GitHub

Symplectic Runge-Kutta Methods

Missing docstring.

Missing docstring for SymplecticEuler. Check Documenter's build log for details.

OrdinaryDiffEq.VelocityVerlet — Type

@article{verlet1967computer, title={Computer" experiments" on classical fluids. I. Thermodynamical properties of Lennard-Jones molecules}, author={Verlet, Loup}, journal={Physical review}, volume={159}, number={1}, pages={98}, year={1967}, publisher={APS} }

source
OrdinaryDiffEq.VerletLeapfrog — Type

@article{verlet1967computer, title={Computer" experiments" on classical fluids. I. Thermodynamical properties of Lennard-Jones molecules}, author={Verlet, Loup}, journal={Physical review}, volume={159}, number={1}, pages={98}, year={1967}, publisher={APS} }

source
OrdinaryDiffEq.PseudoVerletLeapfrog — Type

@article{verlet1967computer, title={Computer" experiments" on classical fluids. I. Thermodynamical properties of Lennard-Jones molecules}, author={Verlet, Loup}, journal={Physical review}, volume={159}, number={1}, pages={98}, year={1967}, publisher={APS} }

source
OrdinaryDiffEq.McAte2 — Type

@article{mclachlan1992accuracy, title={The accuracy of symplectic integrators}, author={McLachlan, Robert I and Atela, Pau}, journal={Nonlinearity}, volume={5}, number={2}, pages={541}, year={1992}, publisher={IOP Publishing} }

source
OrdinaryDiffEq.Ruth3 — Type

@article{ruth1983canonical, title={A canonical integration technique}, author={Ruth, Ronald D}, journal={IEEE Trans. Nucl. Sci.}, volume={30}, number={CERN-LEP-TH-83-14}, pages={2669–2671}, year={1983} }

source
OrdinaryDiffEq.McAte3 — Type

@article{mclachlan1992accuracy, title={The accuracy of symplectic integrators}, author={McLachlan, Robert I and Atela, Pau}, journal={Nonlinearity}, volume={5}, number={2}, pages={541}, year={1992}, publisher={IOP Publishing} }

source
OrdinaryDiffEq.CandyRoz4 — Type

@article{candy1991symplectic, title={A symplectic integration algorithm for separable Hamiltonian functions}, author={Candy, J and Rozmus, W}, journal={Journal of Computational Physics}, volume={92}, number={1}, pages={230–256}, year={1991}, publisher={Elsevier} }

source
Missing docstring.

Missing docstring for McAte4. Check Documenter's build log for details.

OrdinaryDiffEq.CalvoSanz4 — Type

@article{sanz1993symplectic, title={Symplectic numerical methods for Hamiltonian problems}, author={Sanz-Serna, Jes{'u}s Maria and Calvo, Mari-Paz}, journal={International Journal of Modern Physics C}, volume={4}, number={02}, pages={385–392}, year={1993}, publisher={World Scientific} }

source
OrdinaryDiffEq.McAte42 — Type

@article{mclachlan1992accuracy, title={The accuracy of symplectic integrators}, author={McLachlan, Robert I and Atela, Pau}, journal={Nonlinearity}, volume={5}, number={2}, pages={541}, year={1992}, publisher={IOP Publishing} }

source
OrdinaryDiffEq.McAte5 — Type

@article{mclachlan1992accuracy, title={The accuracy of symplectic integrators}, author={McLachlan, Robert I and Atela, Pau}, journal={Nonlinearity}, volume={5}, number={2}, pages={541}, year={1992}, publisher={IOP Publishing} }

source
OrdinaryDiffEq.Yoshida6 — Type

@article{yoshida1990construction, title={Construction of higher order symplectic integrators}, author={Yoshida, Haruo}, journal={Physics letters A}, volume={150}, number={5-7}, pages={262–268}, year={1990}, publisher={Elsevier} }

source
OrdinaryDiffEq.KahanLi6 — Type

@article{kahan1997composition, title={Composition constants for raising the orders of unconventional schemes for ordinary differential equations}, author={Kahan, William and Li, Ren-Cang}, journal={Mathematics of computation}, volume={66}, number={219}, pages={1089–1099}, year={1997} }

source
OrdinaryDiffEq.McAte8 — Type

@article{mclachlan1995numerical, title={On the numerical integration of ordinary differential equations by symmetric composition methods}, author={McLachlan, Robert I}, journal={SIAM Journal on Scientific Computing}, volume={16}, number={1}, pages={151–168}, year={1995}, publisher={SIAM} }

source
OrdinaryDiffEq.KahanLi8 — Type

@article{kahan1997composition, title={Composition constants for raising the orders of unconventional schemes for ordinary differential equations}, author={Kahan, William and Li, Ren-Cang}, journal={Mathematics of computation}, volume={66}, number={219}, pages={1089–1099}, year={1997} }

source
OrdinaryDiffEq.SofSpa10 — Type

@article{sofroniou2005derivation, title={Derivation of symmetric composition constants for symmetric integrators}, author={Sofroniou, Mark and Spaletta, Giulia}, journal={Optimization Methods and Software}, volume={20}, number={4-5}, pages={597–613}, year={2005}, publisher={Taylor \& Francis} }

source
diff --git a/dev/imex/imex_multistep/index.html b/dev/imex/imex_multistep/index.html index 9cc777afcb..cecfc9d890 100644 --- a/dev/imex/imex_multistep/index.html +++ b/dev/imex/imex_multistep/index.html @@ -3,4 +3,4 @@ function gtag(){dataLayer.push(arguments);} gtag('js', new Date()); gtag('config', 'UA-90474609-3', {'page_path': location.pathname + location.search + location.hash}); -
Edit on GitHub

IMEX Multistep Methods

Missing docstring.

Missing docstring for CNAB2. Check Documenter's build log for details.

Missing docstring.

Missing docstring for CNLF2. Check Documenter's build log for details.

Missing docstring.

Missing docstring for SBDF. Check Documenter's build log for details.

OrdinaryDiffEq.SBDF2 — Function
SBDF2(;kwargs...)

The two-step version of the IMEX multistep methods of

  • Uri M. Ascher, Steven J. Ruuth, Brian T. R. Wetton. Implicit-Explicit Methods for Time-Dependent Partial Differential Equations. Society for Industrial and Applied Mathematics. Journal on Numerical Analysis, 32(3), pp 797-823, 1995. doi: https://doi.org/10.1137/0732037

See also SBDF.

source
OrdinaryDiffEq.SBDF3 — Function
SBDF3(;kwargs...)

The three-step version of the IMEX multistep methods of

  • Uri M. Ascher, Steven J. Ruuth, Brian T. R. Wetton. Implicit-Explicit Methods for Time-Dependent Partial Differential Equations. Society for Industrial and Applied Mathematics. Journal on Numerical Analysis, 32(3), pp 797-823, 1995. doi: https://doi.org/10.1137/0732037

See also SBDF.

source
OrdinaryDiffEq.SBDF4 — Function
SBDF4(;kwargs...)

The four-step version of the IMEX multistep methods of

  • Uri M. Ascher, Steven J. Ruuth, Brian T. R. Wetton. Implicit-Explicit Methods for Time-Dependent Partial Differential Equations. Society for Industrial and Applied Mathematics. Journal on Numerical Analysis, 32(3), pp 797-823, 1995. doi: https://doi.org/10.1137/0732037

See also SBDF.

source
+
Edit on GitHub

IMEX Multistep Methods

Missing docstring.

Missing docstring for CNAB2. Check Documenter's build log for details.

Missing docstring.

Missing docstring for CNLF2. Check Documenter's build log for details.

Missing docstring.

Missing docstring for SBDF. Check Documenter's build log for details.

OrdinaryDiffEq.SBDF2 — Function
SBDF2(;kwargs...)

The two-step version of the IMEX multistep methods of

  • Uri M. Ascher, Steven J. Ruuth, Brian T. R. Wetton. Implicit-Explicit Methods for Time-Dependent Partial Differential Equations. Society for Industrial and Applied Mathematics. Journal on Numerical Analysis, 32(3), pp 797-823, 1995. doi: https://doi.org/10.1137/0732037

See also SBDF.

source
OrdinaryDiffEq.SBDF3 — Function
SBDF3(;kwargs...)

The three-step version of the IMEX multistep methods of

  • Uri M. Ascher, Steven J. Ruuth, Brian T. R. Wetton. Implicit-Explicit Methods for Time-Dependent Partial Differential Equations. Society for Industrial and Applied Mathematics. Journal on Numerical Analysis, 32(3), pp 797-823, 1995. doi: https://doi.org/10.1137/0732037

See also SBDF.

source
OrdinaryDiffEq.SBDF4 — Function
SBDF4(;kwargs...)

The four-step version of the IMEX multistep methods of

  • Uri M. Ascher, Steven J. Ruuth, Brian T. R. Wetton. Implicit-Explicit Methods for Time-Dependent Partial Differential Equations. Society for Industrial and Applied Mathematics. Journal on Numerical Analysis, 32(3), pp 797-823, 1995. doi: https://doi.org/10.1137/0732037

See also SBDF.

source
diff --git a/dev/imex/imex_sdirk/index.html b/dev/imex/imex_sdirk/index.html index bd4a2bcb6e..de7658301e 100644 --- a/dev/imex/imex_sdirk/index.html +++ b/dev/imex/imex_sdirk/index.html @@ -3,5 +3,5 @@ function gtag(){dataLayer.push(arguments);} gtag('js', new Date()); gtag('config', 'UA-90474609-3', {'page_path': location.pathname + location.search + location.hash}); -
Edit on GitHub

IMEX SDIRK Methods

OrdinaryDiffEq.IMEXEuler — Function
IMEXEuler(;kwargs...)

The one-step version of the IMEX multistep methods of

  • Uri M. Ascher, Steven J. Ruuth, Brian T. R. Wetton. Implicit-Explicit Methods for Time-Dependent Partial Differential Equations. Society for Industrial and Applied Mathematics. Journal on Numerical Analysis, 32(3), pp 797-823, 1995. doi: https://doi.org/10.1137/0732037

When applied to a SplitODEProblem of the form

u'(t) = f1(u) + f2(u)

The default IMEXEuler() method uses an update of the form

unew = uold + dt * (f1(unew) + f2(uold))

See also SBDF, IMEXEulerARK.

source
OrdinaryDiffEq.IMEXEulerARK — Function
IMEXEulerARK(;kwargs...)

The one-step version of the IMEX multistep methods of

  • Uri M. Ascher, Steven J. Ruuth, Brian T. R. Wetton. Implicit-Explicit Methods for Time-Dependent Partial Differential Equations. Society for Industrial and Applied Mathematics. Journal on Numerical Analysis, 32(3), pp 797-823, 1995. doi: https://doi.org/10.1137/0732037

When applied to a SplitODEProblem of the form

u'(t) = f1(u) + f2(u)

A classical additive Runge-Kutta method in the sense of Araújo, Murua, Sanz-Serna (1997) consisting of the implicit and the explicit Euler method given by

y1   = uold + dt * f1(y1)
-unew = uold + dt * (f1(unew) + f2(y1))

See also SBDF, IMEXEuler.

source
OrdinaryDiffEq.KenCarp3 — Type

@book{kennedy2001additive, title={Additive Runge-Kutta schemes for convection-diffusion-reaction equations}, author={Kennedy, Christopher Alan}, year={2001}, publisher={National Aeronautics and Space Administration, Langley Research Center} }

KenCarp3: SDIRK Method An A-L stable stiffly-accurate 3rd order ESDIRK method with splitting

source
OrdinaryDiffEq.KenCarp4 — Type

@book{kennedy2001additive, title={Additive Runge-Kutta schemes for convection-diffusion-reaction equations}, author={Kennedy, Christopher Alan}, year={2001}, publisher={National Aeronautics and Space Administration, Langley Research Center} }

KenCarp4: SDIRK Method An A-L stable stiffly-accurate 4th order ESDIRK method with splitting

source
OrdinaryDiffEq.KenCarp47 — Type

@article{kennedy2019higher, title={Higher-order additive Runge–Kutta schemes for ordinary differential equations}, author={Kennedy, Christopher A and Carpenter, Mark H}, journal={Applied Numerical Mathematics}, volume={136}, pages={183–205}, year={2019}, publisher={Elsevier} }

KenCarp47: SDIRK Method An A-L stable stiffly-accurate 4th order seven-stage ESDIRK method with splitting

source
OrdinaryDiffEq.KenCarp5 — Type

@book{kennedy2001additive, title={Additive Runge-Kutta schemes for convection-diffusion-reaction equations}, author={Kennedy, Christopher Alan}, year={2001}, publisher={National Aeronautics and Space Administration, Langley Research Center} }

KenCarp5: SDIRK Method An A-L stable stiffly-accurate 5th order ESDIRK method with splitting

source
OrdinaryDiffEq.KenCarp58 — Type

@article{kennedy2019higher, title={Higher-order additive Runge–Kutta schemes for ordinary differential equations}, author={Kennedy, Christopher A and Carpenter, Mark H}, journal={Applied Numerical Mathematics}, volume={136}, pages={183–205}, year={2019}, publisher={Elsevier} }

KenCarp58: SDIRK Method An A-L stable stiffly-accurate 5th order eight-stage ESDIRK method with splitting

source
Missing docstring.

Missing docstring for ESDIRK54I8L2SA. Check Documenter's build log for details.

OrdinaryDiffEq.ESDIRK436L2SA2 — Type

@article{Kennedy2019DiagonallyIR, title={Diagonally implicit Runge–Kutta methods for stiff ODEs}, author={Christopher A. Kennedy and Mark H. Carpenter}, journal={Applied Numerical Mathematics}, year={2019}, volume={146}, pages={221-244} }

source
OrdinaryDiffEq.ESDIRK437L2SA — Type

@article{Kennedy2019DiagonallyIR, title={Diagonally implicit Runge–Kutta methods for stiff ODEs}, author={Christopher A. Kennedy and Mark H. Carpenter}, journal={Applied Numerical Mathematics}, year={2019}, volume={146}, pages={221-244} }

source
OrdinaryDiffEq.ESDIRK547L2SA2 — Type

@article{Kennedy2019DiagonallyIR, title={Diagonally implicit Runge–Kutta methods for stiff ODEs}, author={Christopher A. Kennedy and Mark H. Carpenter}, journal={Applied Numerical Mathematics}, year={2019}, volume={146}, pages={221-244} }

source
OrdinaryDiffEq.ESDIRK659L2SA — Type

@article{Kennedy2019DiagonallyIR, title={Diagonally implicit Runge–Kutta methods for stiff ODEs}, author={Christopher A. Kennedy and Mark H. Carpenter}, journal={Applied Numerical Mathematics}, year={2019}, volume={146}, pages={221-244}

Currently has STABILITY ISSUES, causing it to fail the adaptive tests. Check issue https://github.com/SciML/OrdinaryDiffEq.jl/issues/1933 for more details. }

source
+
Edit on GitHub

IMEX SDIRK Methods

OrdinaryDiffEq.IMEXEuler — Function
IMEXEuler(;kwargs...)

The one-step version of the IMEX multistep methods of

  • Uri M. Ascher, Steven J. Ruuth, Brian T. R. Wetton. Implicit-Explicit Methods for Time-Dependent Partial Differential Equations. Society for Industrial and Applied Mathematics. Journal on Numerical Analysis, 32(3), pp 797-823, 1995. doi: https://doi.org/10.1137/0732037

When applied to a SplitODEProblem of the form

u'(t) = f1(u) + f2(u)

The default IMEXEuler() method uses an update of the form

unew = uold + dt * (f1(unew) + f2(uold))

See also SBDF, IMEXEulerARK.

source
OrdinaryDiffEq.IMEXEulerARK — Function
IMEXEulerARK(;kwargs...)

The one-step version of the IMEX multistep methods of

  • Uri M. Ascher, Steven J. Ruuth, Brian T. R. Wetton. Implicit-Explicit Methods for Time-Dependent Partial Differential Equations. Society for Industrial and Applied Mathematics. Journal on Numerical Analysis, 32(3), pp 797-823, 1995. doi: https://doi.org/10.1137/0732037

When applied to a SplitODEProblem of the form

u'(t) = f1(u) + f2(u)

A classical additive Runge-Kutta method in the sense of Araújo, Murua, Sanz-Serna (1997) consisting of the implicit and the explicit Euler method given by

y1   = uold + dt * f1(y1)
+unew = uold + dt * (f1(unew) + f2(y1))

See also SBDF, IMEXEuler.

source
OrdinaryDiffEq.KenCarp3 — Type

@book{kennedy2001additive, title={Additive Runge-Kutta schemes for convection-diffusion-reaction equations}, author={Kennedy, Christopher Alan}, year={2001}, publisher={National Aeronautics and Space Administration, Langley Research Center} }

KenCarp3: SDIRK Method An A-L stable stiffly-accurate 3rd order ESDIRK method with splitting

source
OrdinaryDiffEq.KenCarp4 — Type

@book{kennedy2001additive, title={Additive Runge-Kutta schemes for convection-diffusion-reaction equations}, author={Kennedy, Christopher Alan}, year={2001}, publisher={National Aeronautics and Space Administration, Langley Research Center} }

KenCarp4: SDIRK Method An A-L stable stiffly-accurate 4th order ESDIRK method with splitting

source
OrdinaryDiffEq.KenCarp47 — Type

@article{kennedy2019higher, title={Higher-order additive Runge–Kutta schemes for ordinary differential equations}, author={Kennedy, Christopher A and Carpenter, Mark H}, journal={Applied Numerical Mathematics}, volume={136}, pages={183–205}, year={2019}, publisher={Elsevier} }

KenCarp47: SDIRK Method An A-L stable stiffly-accurate 4th order seven-stage ESDIRK method with splitting

source
OrdinaryDiffEq.KenCarp5 — Type

@book{kennedy2001additive, title={Additive Runge-Kutta schemes for convection-diffusion-reaction equations}, author={Kennedy, Christopher Alan}, year={2001}, publisher={National Aeronautics and Space Administration, Langley Research Center} }

KenCarp5: SDIRK Method An A-L stable stiffly-accurate 5th order ESDIRK method with splitting

source
OrdinaryDiffEq.KenCarp58 — Type

@article{kennedy2019higher, title={Higher-order additive Runge–Kutta schemes for ordinary differential equations}, author={Kennedy, Christopher A and Carpenter, Mark H}, journal={Applied Numerical Mathematics}, volume={136}, pages={183–205}, year={2019}, publisher={Elsevier} }

KenCarp58: SDIRK Method An A-L stable stiffly-accurate 5th order eight-stage ESDIRK method with splitting

source
Missing docstring.

Missing docstring for ESDIRK54I8L2SA. Check Documenter's build log for details.

OrdinaryDiffEq.ESDIRK436L2SA2 — Type

@article{Kennedy2019DiagonallyIR, title={Diagonally implicit Runge–Kutta methods for stiff ODEs}, author={Christopher A. Kennedy and Mark H. Carpenter}, journal={Applied Numerical Mathematics}, year={2019}, volume={146}, pages={221-244} }

source
OrdinaryDiffEq.ESDIRK437L2SA — Type

@article{Kennedy2019DiagonallyIR, title={Diagonally implicit Runge–Kutta methods for stiff ODEs}, author={Christopher A. Kennedy and Mark H. Carpenter}, journal={Applied Numerical Mathematics}, year={2019}, volume={146}, pages={221-244} }

source
OrdinaryDiffEq.ESDIRK547L2SA2 — Type

@article{Kennedy2019DiagonallyIR, title={Diagonally implicit Runge–Kutta methods for stiff ODEs}, author={Christopher A. Kennedy and Mark H. Carpenter}, journal={Applied Numerical Mathematics}, year={2019}, volume={146}, pages={221-244} }

source
OrdinaryDiffEq.ESDIRK659L2SA — Type

@article{Kennedy2019DiagonallyIR, title={Diagonally implicit Runge–Kutta methods for stiff ODEs}, author={Christopher A. Kennedy and Mark H. Carpenter}, journal={Applied Numerical Mathematics}, year={2019}, volume={146}, pages={221-244}

Currently has STABILITY ISSUES, causing it to fail the adaptive tests. Check issue https://github.com/SciML/OrdinaryDiffEq.jl/issues/1933 for more details. }

source
diff --git a/dev/index.html b/dev/index.html index 0cf804eb82..b713ff2875 100644 --- a/dev/index.html +++ b/dev/index.html @@ -12,10 +12,10 @@ Official https://julialang.org/ release Platform Info: OS: Linux (x86_64-linux-gnu) - CPU: 2 × Intel(R) Xeon(R) Platinum 8171M CPU @ 2.60GHz + CPU: 2 × Intel(R) Xeon(R) Platinum 8370C CPU @ 2.80GHz WORD_SIZE: 64 LIBM: libopenlibm - LLVM: libLLVM-14.0.6 (ORCJIT, skylake-avx512) + LLVM: libLLVM-14.0.6 (ORCJIT, icelake-server) Threads: 1 on 2 virtual cores
A more complete overview of all dependencies and their versions is also provided.
Status `~/work/OrdinaryDiffEq.jl/OrdinaryDiffEq.jl/docs/Manifest.toml`
   [47edcb42] ADTypes v0.2.4
   [a4c015fc] ANSIColoredPrinters v0.0.1
@@ -24,7 +24,6 @@
   [4fba245c] ArrayInterface v7.5.1
   [62783981] BitTwiddlingConvenienceFunctions v0.1.5
   [2a0fbf3d] CPUSummary v0.2.4
-  [d360d2e6] ChainRulesCore v1.18.0
   [fb6a15b2] CloseOpenIntervals v0.1.12
   [38540f10] CommonSolve v0.2.4
   [bbf7d656] CommonSubexpressions v0.3.0
@@ -35,7 +34,7 @@
   [9a962f9c] DataAPI v1.15.0
   [864edb3b] DataStructures v0.18.15
   [e2d170a0] DataValueInterfaces v1.0.0
-  [2b5f629d] DiffEqBase v6.136.0
+  [2b5f629d] DiffEqBase v6.138.1
   [163ba53b] DiffResults v1.1.0
   [b552c78f] DiffRules v1.15.1
   [b4f34e82] Distances v0.10.10
@@ -69,7 +68,7 @@
   [10f19ff3] LayoutPointers v0.1.15
   [50d2b5c4] Lazy v0.15.1
   [d3d80556] LineSearches v7.2.0
-  [7ed4a6bd] LinearSolve v2.15.0
+  [7ed4a6bd] LinearSolve v2.16.1
   [2ab3a3ac] LogExpFunctions v0.3.26
   [bdcacae8] LoopVectorization v0.12.166
   [33e6dc65] MKL v0.6.1
@@ -79,7 +78,7 @@
   [d41bc354] NLSolversBase v7.8.3
   [2774e3e8] NLsolve v4.5.1
   [77ba4419] NaNMath v1.0.2
-  [8913a72c] NonlinearSolve v2.6.0
+  [8913a72c] NonlinearSolve v2.7.0
   [6fe1bfb0] OffsetArrays v1.12.10
   [bac558e1] OrderedCollections v1.6.2
   [1dea7af3] OrdinaryDiffEq v6.58.1 `~/work/OrdinaryDiffEq.jl/OrdinaryDiffEq.jl`
@@ -99,14 +98,14 @@
   [7e49a35a] RuntimeGeneratedFunctions v0.5.12
   [94e857df] SIMDTypes v0.1.0
   [476501e8] SLEEFPirates v0.6.42
-  [0bca4576] SciMLBase v2.6.0
+  [0bca4576] SciMLBase v2.7.3
   [e9a6253c] SciMLNLSolve v0.1.9
-  [c0aeaf25] SciMLOperators v0.3.6
+  [c0aeaf25] SciMLOperators v0.3.7
   [efcf1570] Setfield v1.1.1
-  [727e6d20] SimpleNonlinearSolve v0.1.23
+  [727e6d20] SimpleNonlinearSolve v0.1.24
   [699a6c99] SimpleTraits v0.9.4
   [ce78b400] SimpleUnPack v1.1.0
-  [47a9eef4] SparseDiffTools v2.9.2
+  [47a9eef4] SparseDiffTools v2.11.0
   [e56a9233] Sparspak v0.3.9
   [276daf66] SpecialFunctions v2.3.1
   [aedffcd0] Static v0.8.8
@@ -125,7 +124,6 @@
   [3a884ed6] UnPack v1.0.2
   [3d5dd08c] VectorizationBase v0.21.64
   [19fa3120] VertexSafeGraphs v0.2.0
-  [700de1a5] ZygoteRules v0.2.4
   [1d5cc7b8] IntelOpenMP_jll v2023.2.0+0
   [856f044c] MKL_jll v2023.2.0+0
   [efe28fd5] OpenSpecFun_jll v0.5.5+0
@@ -177,4 +175,4 @@
   [3f19e933] p7zip_jll v17.4.0+0
 Info Packages marked with ⌅ have new versions available but compatibility constraints restrict them from upgrading. To see why use `status --outdated -m`
You can also download the manifest file and the -project file. +project file. diff --git a/dev/misc/index.html b/dev/misc/index.html index e31410c5b9..145b42bf69 100644 --- a/dev/misc/index.html +++ b/dev/misc/index.html @@ -3,4 +3,4 @@ function gtag(){dataLayer.push(arguments);} gtag('js', new Date()); gtag('config', 'UA-90474609-3', {'page_path': location.pathname + location.search + location.hash}); -
Edit on GitHub
Missing docstring.

Missing docstring for LinearExponential. Check Documenter's build log for details.

Missing docstring.

Missing docstring for SplitEuler. Check Documenter's build log for details.

Missing docstring.

Missing docstring for CompositeAlgorithm. Check Documenter's build log for details.

OrdinaryDiffEq.PDIRK44 — Type

PDIRK44: Parallel Diagonally Implicit Runge-Kutta Method A 2 processor 4th order diagonally non-adaptive implicit method.

source
+
Edit on GitHub
Missing docstring.

Missing docstring for LinearExponential. Check Documenter's build log for details.

Missing docstring.

Missing docstring for SplitEuler. Check Documenter's build log for details.

Missing docstring.

Missing docstring for CompositeAlgorithm. Check Documenter's build log for details.

OrdinaryDiffEq.PDIRK44 — Type

PDIRK44: Parallel Diagonally Implicit Runge-Kutta Method A 2 processor 4th order diagonally non-adaptive implicit method.

source
diff --git a/dev/nonstiff/explicit_extrapolation/index.html b/dev/nonstiff/explicit_extrapolation/index.html index 3ad48716eb..28ce312ecc 100644 --- a/dev/nonstiff/explicit_extrapolation/index.html +++ b/dev/nonstiff/explicit_extrapolation/index.html @@ -3,4 +3,4 @@ function gtag(){dataLayer.push(arguments);} gtag('js', new Date()); gtag('config', 'UA-90474609-3', {'page_path': location.pathname + location.search + location.hash}); -
Edit on GitHub

Explicit Extrapolation Methods

+
Edit on GitHub

Explicit Extrapolation Methods

diff --git a/dev/nonstiff/explicitrk/index.html b/dev/nonstiff/explicitrk/index.html index 78b040a018..3f66e3f867 100644 --- a/dev/nonstiff/explicitrk/index.html +++ b/dev/nonstiff/explicitrk/index.html @@ -5,75 +5,75 @@ gtag('config', 'UA-90474609-3', {'page_path': location.pathname + location.search + location.hash});
Edit on GitHub

Explicit Runge-Kutta Methods

With the help of FastBroadcast.jl, we can use threaded parallelism to reduce compute time for all of the explicit Runge-Kutta methods! The thread option determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads. When we call solve(prob, alg(thread=OrdinaryDiffEq.True())), we can turn on the multithreading option to achieve acceleration (for sufficiently large problems).

Standard Explicit Runge-Kutta Methods

OrdinaryDiffEq.Heun — Type
Heun(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. The second order Heun's method. Uses embedded Euler method for adaptivity.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.Ralston — Type
Ralston(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. The second order Heun's method. Uses embedded Euler method for adaptivity.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.Ralston — Type
Ralston(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. The optimized second order midpoint method. Uses embedded Euler method for adaptivity.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.Midpoint — Type
Midpoint(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. The optimized second order midpoint method. Uses embedded Euler method for adaptivity.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.Midpoint — Type
Midpoint(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. The second order midpoint method. Uses embedded Euler method for adaptivity.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.RK4 — Type
RK4(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. The second order midpoint method. Uses embedded Euler method for adaptivity.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.RK4 — Type
RK4(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. The canonical Runge-Kutta Order 4 method. Uses a defect control for adaptive stepping using maximum error over the whole interval.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

@article{shampine2005solving, title={Solving ODEs and DDEs with residual control}, author={Shampine, LF}, journal={Applied Numerical Mathematics}, volume={52}, number={1}, pages={113–127}, year={2005}, publisher={Elsevier} }

source
OrdinaryDiffEq.RKM — Type
RKM(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. The canonical Runge-Kutta Order 4 method. Uses a defect control for adaptive stepping using maximum error over the whole interval.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

@article{shampine2005solving, title={Solving ODEs and DDEs with residual control}, author={Shampine, LF}, journal={Applied Numerical Mathematics}, volume={52}, number={1}, pages={113–127}, year={2005}, publisher={Elsevier} }

source
OrdinaryDiffEq.RKM — Type
RKM(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. TBD

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.MSRK5 — Type
MSRK5(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. TBD

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.MSRK5 — Type
MSRK5(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. 5th order Explicit RK method.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Misha Stepanov - https://arxiv.org/pdf/2202.08443.pdf : Figure 3.

source
OrdinaryDiffEq.MSRK6 — Type
MSRK6(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. 5th order Explicit RK method.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Misha Stepanov - https://arxiv.org/pdf/2202.08443.pdf : Figure 3.

source
OrdinaryDiffEq.MSRK6 — Type
MSRK6(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. 6th order Explicit RK method.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Misha Stepanov - https://arxiv.org/pdf/2202.08443.pdf : Table4

source
OrdinaryDiffEq.Anas5 — Type
Anas5(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. 6th order Explicit RK method.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Misha Stepanov - https://arxiv.org/pdf/2202.08443.pdf : Table4

source
OrdinaryDiffEq.Anas5 — Type
Anas5(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
         thread = OrdinaryDiffEq.False(),
-        w = 1)

Explicit Runge-Kutta Method. 4th order Runge-Kutta method designed for periodic problems.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • w: a periodicity estimate, which when accurate the method becomes 5th order (and is otherwise 4th order with less error for better estimates).

References

source
OrdinaryDiffEq.RKO65 — Type
RKO5(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        w = 1)

Explicit Runge-Kutta Method. 4th order Runge-Kutta method designed for periodic problems.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • w: a periodicity estimate, which when accurate the method becomes 5th order (and is otherwise 4th order with less error for better estimates).

References

source
OrdinaryDiffEq.RKO65 — Type
RKO5(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. 5th order Explicit RK method.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Tsitouras, Ch. "Explicit Runge–Kutta methods for starting integration of Lane–Emden problem." Applied Mathematics and Computation 354 (2019): 353-364. doi: https://doi.org/10.1016/j.amc.2019.02.047

source
OrdinaryDiffEq.OwrenZen3 — Type
OwrenZen3(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. 5th order Explicit RK method.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Tsitouras, Ch. "Explicit Runge–Kutta methods for starting integration of Lane–Emden problem." Applied Mathematics and Computation 354 (2019): 353-364. doi: https://doi.org/10.1016/j.amc.2019.02.047

source
OrdinaryDiffEq.OwrenZen3 — Type
OwrenZen3(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Owren-Zennaro optimized interpolation 3/2 method (free 3rd order interpolant).

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

@article{owren1992derivation, title={Derivation of efficient, continuous, explicit Runge–Kutta methods}, author={Owren, Brynjulf and Zennaro, Marino}, journal={SIAM journal on scientific and statistical computing}, volume={13}, number={6}, pages={1488–1501}, year={1992}, publisher={SIAM} }

source
OrdinaryDiffEq.OwrenZen4 — Type
OwrenZen4(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Owren-Zennaro optimized interpolation 3/2 method (free 3rd order interpolant).

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

@article{owren1992derivation, title={Derivation of efficient, continuous, explicit Runge–Kutta methods}, author={Owren, Brynjulf and Zennaro, Marino}, journal={SIAM journal on scientific and statistical computing}, volume={13}, number={6}, pages={1488–1501}, year={1992}, publisher={SIAM} }

source
OrdinaryDiffEq.OwrenZen4 — Type
OwrenZen4(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Owren-Zennaro optimized interpolation 4/3 method (free 4th order interpolant).

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

@article{owren1992derivation, title={Derivation of efficient, continuous, explicit Runge–Kutta methods}, author={Owren, Brynjulf and Zennaro, Marino}, journal={SIAM journal on scientific and statistical computing}, volume={13}, number={6}, pages={1488–1501}, year={1992}, publisher={SIAM} }

source
OrdinaryDiffEq.OwrenZen5 — Type
OwrenZen5(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Owren-Zennaro optimized interpolation 4/3 method (free 4th order interpolant).

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

@article{owren1992derivation, title={Derivation of efficient, continuous, explicit Runge–Kutta methods}, author={Owren, Brynjulf and Zennaro, Marino}, journal={SIAM journal on scientific and statistical computing}, volume={13}, number={6}, pages={1488–1501}, year={1992}, publisher={SIAM} }

source
OrdinaryDiffEq.OwrenZen5 — Type
OwrenZen5(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Owren-Zennaro optimized interpolation 5/4 method (free 5th order interpolant).

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

@article{owren1992derivation, title={Derivation of efficient, continuous, explicit Runge–Kutta methods}, author={Owren, Brynjulf and Zennaro, Marino}, journal={SIAM journal on scientific and statistical computing}, volume={13}, number={6}, pages={1488–1501}, year={1992}, publisher={SIAM} }

source
OrdinaryDiffEq.BS3 — Type
OwrenZen5(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Owren-Zennaro optimized interpolation 5/4 method (free 5th order interpolant).

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

@article{owren1992derivation, title={Derivation of efficient, continuous, explicit Runge–Kutta methods}, author={Owren, Brynjulf and Zennaro, Marino}, journal={SIAM journal on scientific and statistical computing}, volume={13}, number={6}, pages={1488–1501}, year={1992}, publisher={SIAM} }

source
OrdinaryDiffEq.BS3 — Type
OwrenZen5(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Owren-Zennaro optimized interpolation 5/4 method (free 5th order interpolant).

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

@article{bogacki19893, title={A 3 (2) pair of Runge-Kutta formulas}, author={Bogacki, Przemyslaw and Shampine, Lawrence F}, journal={Applied Mathematics Letters}, volume={2}, number={4}, pages={321–325}, year={1989}, publisher={Elsevier} }

source
OrdinaryDiffEq.DP5 — Type
DP5(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Owren-Zennaro optimized interpolation 5/4 method (free 5th order interpolant).

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

@article{bogacki19893, title={A 3 (2) pair of Runge-Kutta formulas}, author={Bogacki, Przemyslaw and Shampine, Lawrence F}, journal={Applied Mathematics Letters}, volume={2}, number={4}, pages={321–325}, year={1989}, publisher={Elsevier} }

source
OrdinaryDiffEq.DP5 — Type
DP5(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Dormand-Prince's 5/4 Runge-Kutta method. (free 4th order interpolant).

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

@article{dormand1980family, title={A family of embedded Runge-Kutta formulae}, author={Dormand, John R and Prince, Peter J}, journal={Journal of computational and applied mathematics}, volume={6}, number={1}, pages={19–26}, year={1980}, publisher={Elsevier} }

source
OrdinaryDiffEq.Tsit5 — Type
Tsit5(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Dormand-Prince's 5/4 Runge-Kutta method. (free 4th order interpolant).

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

@article{dormand1980family, title={A family of embedded Runge-Kutta formulae}, author={Dormand, John R and Prince, Peter J}, journal={Journal of computational and applied mathematics}, volume={6}, number={1}, pages={19–26}, year={1980}, publisher={Elsevier} }

source
OrdinaryDiffEq.Tsit5 — Type
Tsit5(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. A fifth-order explicit Runge-Kutta method with embedded error estimator of Tsitouras. Free 4th order interpolant.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

@article{tsitouras2011runge, title={Runge–Kutta pairs of order 5 (4) satisfying only the first column simplifying assumption}, author={Tsitouras, Ch}, journal={Computers \& Mathematics with Applications}, volume={62}, number={2}, pages={770–775}, year={2011}, publisher={Elsevier} }

source
OrdinaryDiffEq.DP8 — Type
DP8(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. A fifth-order explicit Runge-Kutta method with embedded error estimator of Tsitouras. Free 4th order interpolant.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

@article{tsitouras2011runge, title={Runge–Kutta pairs of order 5 (4) satisfying only the first column simplifying assumption}, author={Tsitouras, Ch}, journal={Computers \& Mathematics with Applications}, volume={62}, number={2}, pages={770–775}, year={2011}, publisher={Elsevier} }

source
OrdinaryDiffEq.DP8 — Type
DP8(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Hairer's 8/5/3 adaption of the Dormand-Prince Runge-Kutta method. (7th order interpolant).

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

E. Hairer, S.P. Norsett, G. Wanner, (1993) Solving Ordinary Differential Equations I. Nonstiff Problems. 2nd Edition. Springer Series in Computational Mathematics, Springer-Verlag.

source
OrdinaryDiffEq.TanYam7 — Type
TanYam7(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Hairer's 8/5/3 adaption of the Dormand-Prince Runge-Kutta method. (7th order interpolant).

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

E. Hairer, S.P. Norsett, G. Wanner, (1993) Solving Ordinary Differential Equations I. Nonstiff Problems. 2nd Edition. Springer Series in Computational Mathematics, Springer-Verlag.

source
OrdinaryDiffEq.TanYam7 — Type
TanYam7(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Tanaka-Yamashita 7 Runge-Kutta method. (7th order interpolant).

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Tanaka M., Muramatsu S., Yamashita S., (1992), On the Optimization of Some Nine-Stage Seventh-order Runge-Kutta Method, Information Processing Society of Japan, 33 (12), pp. 1512-1526.

source
OrdinaryDiffEq.TsitPap8 — Type
TsitPap8(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Tanaka-Yamashita 7 Runge-Kutta method. (7th order interpolant).

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Tanaka M., Muramatsu S., Yamashita S., (1992), On the Optimization of Some Nine-Stage Seventh-order Runge-Kutta Method, Information Processing Society of Japan, 33 (12), pp. 1512-1526.

source
OrdinaryDiffEq.TsitPap8 — Type
TsitPap8(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Tsitouras-Papakostas 8/7 Runge-Kutta method.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.Feagin10 — Type

@article{feagin2012high, title={High-order explicit Runge-Kutta methods using m-symmetry}, author={Feagin, Terry}, year={2012}, publisher={Neural, Parallel \& Scientific Computations} }

Feagin10: Explicit Runge-Kutta Method Feagin's 10th-order Runge-Kutta method.

source
OrdinaryDiffEq.Feagin12 — Type

@article{feagin2012high, title={High-order explicit Runge-Kutta methods using m-symmetry}, author={Feagin, Terry}, year={2012}, publisher={Neural, Parallel \& Scientific Computations} }

Feagin12: Explicit Runge-Kutta Method Feagin's 12th-order Runge-Kutta method.

source
OrdinaryDiffEq.Feagin14 — Type

Feagin, T., “An Explicit Runge-Kutta Method of Order Fourteen,” Numerical Algorithms, 2009

Feagin14: Explicit Runge-Kutta Method Feagin's 14th-order Runge-Kutta method.

source
OrdinaryDiffEq.FRK65 — Type
FRK65(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Tsitouras-Papakostas 8/7 Runge-Kutta method.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.Feagin10 — Type

@article{feagin2012high, title={High-order explicit Runge-Kutta methods using m-symmetry}, author={Feagin, Terry}, year={2012}, publisher={Neural, Parallel \& Scientific Computations} }

Feagin10: Explicit Runge-Kutta Method Feagin's 10th-order Runge-Kutta method.

source
OrdinaryDiffEq.Feagin12 — Type

@article{feagin2012high, title={High-order explicit Runge-Kutta methods using m-symmetry}, author={Feagin, Terry}, year={2012}, publisher={Neural, Parallel \& Scientific Computations} }

Feagin12: Explicit Runge-Kutta Method Feagin's 12th-order Runge-Kutta method.

source
OrdinaryDiffEq.Feagin14 — Type

Feagin, T., “An Explicit Runge-Kutta Method of Order Fourteen,” Numerical Algorithms, 2009

Feagin14: Explicit Runge-Kutta Method Feagin's 14th-order Runge-Kutta method.

source
OrdinaryDiffEq.FRK65 — Type
FRK65(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
         thread = OrdinaryDiffEq.False(),
-        omega = 0.0)

Explicit Runge-Kutta Method. Zero Dissipation Runge-Kutta of 6th order.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • omega: a periodicity phase estimate, when accurate this method results in zero numerical dissipation.

References

source
OrdinaryDiffEq.PFRK87 — Type
PFRK87(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        omega = 0.0)

Explicit Runge-Kutta Method. Zero Dissipation Runge-Kutta of 6th order.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • omega: a periodicity phase estimate, when accurate this method results in zero numerical dissipation.

References

source
OrdinaryDiffEq.PFRK87 — Type
PFRK87(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
         thread = OrdinaryDiffEq.False(),
-        omega = 0.0)

Explicit Runge-Kutta Method. Phase-fitted Runge-Kutta of 8th order.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • omega: a periodicity phase estimate, when accurate this method results in zero numerical dissipation.

References

source
OrdinaryDiffEq.Stepanov5 — Type
Stepanov5(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        omega = 0.0)

Explicit Runge-Kutta Method. Phase-fitted Runge-Kutta of 8th order.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • omega: a periodicity phase estimate, when accurate this method results in zero numerical dissipation.

References

source
OrdinaryDiffEq.Stepanov5 — Type
Stepanov5(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. 5th order Explicit RK method.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

@article{Stepanov2021Embedded5, title={Embedded (4, 5) pairs of explicit 7-stage Runge–Kutta methods with FSAL property}, author={Misha Stepanov}, journal={Calcolo}, year={2021}, volume={59} }

source
OrdinaryDiffEq.SIR54 — Type
SIR54(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. 5th order Explicit RK method.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

@article{Stepanov2021Embedded5, title={Embedded (4, 5) pairs of explicit 7-stage Runge–Kutta methods with FSAL property}, author={Misha Stepanov}, journal={Calcolo}, year={2021}, volume={59} }

source
OrdinaryDiffEq.SIR54 — Type
SIR54(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
          step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-         thread = OrdinaryDiffEq.False())

5th order Explicit RK method suited for SIR-type epidemic models.

Like SSPRK methods, this method also takes optional arguments stage_limiter! and step_limiter!, where stage_limiter! and step_limiter! are functions of the form limiter!(u, integrator, p, t).

The argument thread determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

Reference

@article{Kovalnogov2020RungeKuttaPS, title={Runge–Kutta pairs suited for SIR‐type epidemic models}, author={Vladislav N. Kovalnogov and Theodore E. Simos and Ch. Tsitouras}, journal={Mathematical Methods in the Applied Sciences}, year={2020}, volume={44}, pages={5210 - 5216} }

source
OrdinaryDiffEq.Alshina2 — Type
Alshina2(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+         thread = OrdinaryDiffEq.False())

5th order Explicit RK method suited for SIR-type epidemic models.

Like SSPRK methods, this method also takes optional arguments stage_limiter! and step_limiter!, where stage_limiter! and step_limiter! are functions of the form limiter!(u, integrator, p, t).

The argument thread determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

Reference

@article{Kovalnogov2020RungeKuttaPS, title={Runge–Kutta pairs suited for SIR‐type epidemic models}, author={Vladislav N. Kovalnogov and Theodore E. Simos and Ch. Tsitouras}, journal={Mathematical Methods in the Applied Sciences}, year={2020}, volume={44}, pages={5210 - 5216} }

source
OrdinaryDiffEq.Alshina2 — Type
Alshina2(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
          step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-         thread = OrdinaryDiffEq.False())

2nd order, 2-stage Explicit Runge-Kutta Method with optimal parameters.

Like SSPRK methods, this method also takes optional arguments stage_limiter! and step_limiter!, where stage_limiter! and step_limiter! are functions of the form limiter!(u, integrator, p, t).

The argument thread determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

Reference

@article{Alshina2008, doi = {10.1134/s0965542508030068}, url = {https://doi.org/10.1134/s0965542508030068}, year = {2008}, month = mar, publisher = {Pleiades Publishing Ltd}, volume = {48}, number = {3}, pages = {395–405}, author = {E. A. Alshina and E. M. Zaks and N. N. Kalitkin}, title = {Optimal first- to sixth-order accurate Runge-Kutta schemes}, journal = {Computational Mathematics and Mathematical Physics} }

source
OrdinaryDiffEq.Alshina3 — Type
Alshina3(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+         thread = OrdinaryDiffEq.False())

2nd order, 2-stage Explicit Runge-Kutta Method with optimal parameters.

Like SSPRK methods, this method also takes optional arguments stage_limiter! and step_limiter!, where stage_limiter! and step_limiter! are functions of the form limiter!(u, integrator, p, t).

The argument thread determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

Reference

@article{Alshina2008, doi = {10.1134/s0965542508030068}, url = {https://doi.org/10.1134/s0965542508030068}, year = {2008}, month = mar, publisher = {Pleiades Publishing Ltd}, volume = {48}, number = {3}, pages = {395–405}, author = {E. A. Alshina and E. M. Zaks and N. N. Kalitkin}, title = {Optimal first- to sixth-order accurate Runge-Kutta schemes}, journal = {Computational Mathematics and Mathematical Physics} }

source
OrdinaryDiffEq.Alshina3 — Type
Alshina3(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
          step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-         thread = OrdinaryDiffEq.False())

3rd order, 3-stage Explicit Runge-Kutta Method with optimal parameters.

Like SSPRK methods, this method also takes optional arguments stage_limiter! and step_limiter!, where stage_limiter! and step_limiter! are functions of the form limiter!(u, integrator, p, t).

The argument thread determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

Reference

@article{Alshina2008, doi = {10.1134/s0965542508030068}, url = {https://doi.org/10.1134/s0965542508030068}, year = {2008}, month = mar, publisher = {Pleiades Publishing Ltd}, volume = {48}, number = {3}, pages = {395–405}, author = {E. A. Alshina and E. M. Zaks and N. N. Kalitkin}, title = {Optimal first- to sixth-order accurate Runge-Kutta schemes}, journal = {Computational Mathematics and Mathematical Physics} }

source
OrdinaryDiffEq.Alshina6 — Type
Alshina6(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+         thread = OrdinaryDiffEq.False())

3rd order, 3-stage Explicit Runge-Kutta Method with optimal parameters.

Like SSPRK methods, this method also takes optional arguments stage_limiter! and step_limiter!, where stage_limiter! and step_limiter! are functions of the form limiter!(u, integrator, p, t).

The argument thread determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

Reference

@article{Alshina2008, doi = {10.1134/s0965542508030068}, url = {https://doi.org/10.1134/s0965542508030068}, year = {2008}, month = mar, publisher = {Pleiades Publishing Ltd}, volume = {48}, number = {3}, pages = {395–405}, author = {E. A. Alshina and E. M. Zaks and N. N. Kalitkin}, title = {Optimal first- to sixth-order accurate Runge-Kutta schemes}, journal = {Computational Mathematics and Mathematical Physics} }

source
OrdinaryDiffEq.Alshina6 — Type
Alshina6(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
          step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-         thread = OrdinaryDiffEq.False())

6th order, 7-stage Explicit Runge-Kutta Method with optimal parameters.

Like SSPRK methods, this method also takes optional arguments stage_limiter! and step_limiter!, where stage_limiter! and step_limiter! are functions of the form limiter!(u, integrator, p, t).

The argument thread determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

Reference

@article{Alshina2008, doi = {10.1134/s0965542508030068}, url = {https://doi.org/10.1134/s0965542508030068}, year = {2008}, month = mar, publisher = {Pleiades Publishing Ltd}, volume = {48}, number = {3}, pages = {395–405}, author = {E. A. Alshina and E. M. Zaks and N. N. Kalitkin}, title = {Optimal first- to sixth-order accurate Runge-Kutta schemes}, journal = {Computational Mathematics and Mathematical Physics} }

source

Lazy Interpolation Explicit Runge-Kutta Methods

OrdinaryDiffEq.BS5 — Type
BS5(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+         thread = OrdinaryDiffEq.False())

6th order, 7-stage Explicit Runge-Kutta Method with optimal parameters.

Like SSPRK methods, this method also takes optional arguments stage_limiter! and step_limiter!, where stage_limiter! and step_limiter! are functions of the form limiter!(u, integrator, p, t).

The argument thread determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

Reference

@article{Alshina2008, doi = {10.1134/s0965542508030068}, url = {https://doi.org/10.1134/s0965542508030068}, year = {2008}, month = mar, publisher = {Pleiades Publishing Ltd}, volume = {48}, number = {3}, pages = {395–405}, author = {E. A. Alshina and E. M. Zaks and N. N. Kalitkin}, title = {Optimal first- to sixth-order accurate Runge-Kutta schemes}, journal = {Computational Mathematics and Mathematical Physics} }

source

Lazy Interpolation Explicit Runge-Kutta Methods

OrdinaryDiffEq.BS5 — Type
BS5(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
         thread = OrdinaryDiffEq.False(),
-        lazy = true)

Explicit Runge-Kutta Method. Bogacki-Shampine 5/4 Runge-Kutta method. (lazy 5th order interpolant).

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • lazy: determines if the lazy interpolant is used.

References

@article{bogacki1996efficient, title={An efficient runge-kutta (4, 5) pair}, author={Bogacki, P and Shampine, Lawrence F}, journal={Computers \& Mathematics with Applications}, volume={32}, number={6}, pages={15–28}, year={1996}, publisher={Elsevier} }

source
OrdinaryDiffEq.Vern6 — Type
Vern6(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        lazy = true)

Explicit Runge-Kutta Method. Bogacki-Shampine 5/4 Runge-Kutta method. (lazy 5th order interpolant).

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • lazy: determines if the lazy interpolant is used.

References

@article{bogacki1996efficient, title={An efficient runge-kutta (4, 5) pair}, author={Bogacki, P and Shampine, Lawrence F}, journal={Computers \& Mathematics with Applications}, volume={32}, number={6}, pages={15–28}, year={1996}, publisher={Elsevier} }

source
OrdinaryDiffEq.Vern6 — Type
Vern6(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
         thread = OrdinaryDiffEq.False(),
-        lazy = true)

Explicit Runge-Kutta Method. Verner's “Most Efficient” 6/5 Runge-Kutta method. (lazy 6th order interpolant).

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • lazy: determines if the lazy interpolant is used.

References

@article{verner2010numerically, title={Numerically optimal Runge–Kutta pairs with interpolants}, author={Verner, James H}, journal={Numerical Algorithms}, volume={53}, number={2-3}, pages={383–396}, year={2010}, publisher={Springer} }

source
OrdinaryDiffEq.Vern7 — Type
Vern7(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        lazy = true)

Explicit Runge-Kutta Method. Verner's “Most Efficient” 6/5 Runge-Kutta method. (lazy 6th order interpolant).

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • lazy: determines if the lazy interpolant is used.

References

@article{verner2010numerically, title={Numerically optimal Runge–Kutta pairs with interpolants}, author={Verner, James H}, journal={Numerical Algorithms}, volume={53}, number={2-3}, pages={383–396}, year={2010}, publisher={Springer} }

source
OrdinaryDiffEq.Vern7 — Type
Vern7(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
         thread = OrdinaryDiffEq.False(),
-        lazy = true)

Explicit Runge-Kutta Method. Verner's “Most Efficient” 7/6 Runge-Kutta method. (lazy 7th order interpolant).

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • lazy: determines if the lazy interpolant is used.

References

@article{verner2010numerically, title={Numerically optimal Runge–Kutta pairs with interpolants}, author={Verner, James H}, journal={Numerical Algorithms}, volume={53}, number={2-3}, pages={383–396}, year={2010}, publisher={Springer} }

source
OrdinaryDiffEq.Vern8 — Type
Vern8(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        lazy = true)

Explicit Runge-Kutta Method. Verner's “Most Efficient” 7/6 Runge-Kutta method. (lazy 7th order interpolant).

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • lazy: determines if the lazy interpolant is used.

References

@article{verner2010numerically, title={Numerically optimal Runge–Kutta pairs with interpolants}, author={Verner, James H}, journal={Numerical Algorithms}, volume={53}, number={2-3}, pages={383–396}, year={2010}, publisher={Springer} }

source
OrdinaryDiffEq.Vern8 — Type
Vern8(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
         thread = OrdinaryDiffEq.False(),
-        lazy = true)

Explicit Runge-Kutta Method. Verner's “Most Efficient” 8/7 Runge-Kutta method. (lazy 8th order interpolant).

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • lazy: determines if the lazy interpolant is used.

References

@article{verner2010numerically, title={Numerically optimal Runge–Kutta pairs with interpolants}, author={Verner, James H}, journal={Numerical Algorithms}, volume={53}, number={2-3}, pages={383–396}, year={2010}, publisher={Springer} }

source
OrdinaryDiffEq.Vern9 — Type
Vern9(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        lazy = true)

Explicit Runge-Kutta Method. Verner's “Most Efficient” 8/7 Runge-Kutta method. (lazy 8th order interpolant).

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • lazy: determines if the lazy interpolant is used.

References

@article{verner2010numerically, title={Numerically optimal Runge–Kutta pairs with interpolants}, author={Verner, James H}, journal={Numerical Algorithms}, volume={53}, number={2-3}, pages={383–396}, year={2010}, publisher={Springer} }

source
OrdinaryDiffEq.Vern9 — Type
Vern9(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
         thread = OrdinaryDiffEq.False(),
-        lazy = true)

Explicit Runge-Kutta Method. Verner's “Most Efficient” 9/8 Runge-Kutta method. (lazy9th order interpolant).

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • lazy: determines if the lazy interpolant is used.

References

@article{verner2010numerically, title={Numerically optimal Runge–Kutta pairs with interpolants}, author={Verner, James H}, journal={Numerical Algorithms}, volume={53}, number={2-3}, pages={383–396}, year={2010}, publisher={Springer} }

source

Fixed Timestep Only Explicit Runge-Kutta Methods

OrdinaryDiffEq.RK46NL — Type
RK46NL(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        lazy = true)

Explicit Runge-Kutta Method. Verner's “Most Efficient” 9/8 Runge-Kutta method. (lazy9th order interpolant).

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • lazy: determines if the lazy interpolant is used.

References

@article{verner2010numerically, title={Numerically optimal Runge–Kutta pairs with interpolants}, author={Verner, James H}, journal={Numerical Algorithms}, volume={53}, number={2-3}, pages={383–396}, year={2010}, publisher={Springer} }

source

Fixed Timestep Only Explicit Runge-Kutta Methods

OrdinaryDiffEq.RK46NL — Type
RK46NL(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. 6-stage, fourth order low-stage, low-dissipation, low-dispersion scheme. Fixed timestep only.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Julien Berland, Christophe Bogey, Christophe Bailly. Low-Dissipation and Low-Dispersion Fourth-Order Runge-Kutta Algorithm. Computers & Fluids, 35(10), pp 1459-1463, 2006. doi: https://doi.org/10.1016/j.compfluid.2005.04.003

source
OrdinaryDiffEq.ORK256 — Type
ORK256(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. 6-stage, fourth order low-stage, low-dissipation, low-dispersion scheme. Fixed timestep only.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Julien Berland, Christophe Bogey, Christophe Bailly. Low-Dissipation and Low-Dispersion Fourth-Order Runge-Kutta Algorithm. Computers & Fluids, 35(10), pp 1459-1463, 2006. doi: https://doi.org/10.1016/j.compfluid.2005.04.003

source
OrdinaryDiffEq.ORK256 — Type
ORK256(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
         thread = OrdinaryDiffEq.False(),
-        williamson_condition = true)

Explicit Runge-Kutta Method. A second-order, five-stage explicit Runge-Kutta method for wave propagation equations. Fixed timestep only.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • williamson_condition: allows for an optimization that allows fusing broadcast expressions with the function call f. However, it only works for Array types.

References

Matteo Bernardini, Sergio Pirozzoli. A General Strategy for the Optimization of Runge-Kutta Schemes for Wave Propagation Phenomena. Journal of Computational Physics, 228(11), pp 4182-4199, 2009. doi: https://doi.org/10.1016/j.jcp.2009.02.032

source

Parallel Explicit Runge-Kutta Methods

OrdinaryDiffEq.KuttaPRK2p5 — Type

KuttaPRK2p5: Parallel Explicit Runge-Kutta Method A 5 parallel, 2 processor explicit Runge-Kutta method of 5th order.

These methods utilize multithreading on the f calls to parallelize the problem. This requires that simultaneous calls to f are thread-safe.

source
+ williamson_condition = true)

Explicit Runge-Kutta Method. A second-order, five-stage explicit Runge-Kutta method for wave propagation equations. Fixed timestep only.

Keyword Arguments

References

Matteo Bernardini, Sergio Pirozzoli. A General Strategy for the Optimization of Runge-Kutta Schemes for Wave Propagation Phenomena. Journal of Computational Physics, 228(11), pp 4182-4199, 2009. doi: https://doi.org/10.1016/j.jcp.2009.02.032

source

Parallel Explicit Runge-Kutta Methods

OrdinaryDiffEq.KuttaPRK2p5 — Type

KuttaPRK2p5: Parallel Explicit Runge-Kutta Method A 5 parallel, 2 processor explicit Runge-Kutta method of 5th order.

These methods utilize multithreading on the f calls to parallelize the problem. This requires that simultaneous calls to f are thread-safe.

source
diff --git a/dev/nonstiff/lowstorage_ssprk/index.html b/dev/nonstiff/lowstorage_ssprk/index.html index aa5b076634..a5dd708f56 100644 --- a/dev/nonstiff/lowstorage_ssprk/index.html +++ b/dev/nonstiff/lowstorage_ssprk/index.html @@ -6,132 +6,132 @@
Edit on GitHub

PDE-Specialized Explicit Runge-Kutta Methods

Low Storage Explicit Runge-Kutta Methods

OrdinaryDiffEq.CarpenterKennedy2N54 — Type
CarpenterKennedy2N54(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
         thread = OrdinaryDiffEq.False(),
-        williamson_condition = true)

Explicit Runge-Kutta Method. A fourth-order, five-stage explicit low-storage method of Carpenter and Kennedy (free 3rd order Hermite interpolant). Fixed timestep only. Designed for hyperbolic PDEs (stability properties).

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • williamson_condition: allows for an optimization that allows fusing broadcast expressions with the function call f. However, it only works for Array types.

References

@article{carpenter1994fourth, title={Fourth-order 2N-storage Runge-Kutta schemes}, author={Carpenter, Mark H and Kennedy, Christopher A}, year={1994} }

source
OrdinaryDiffEq.SHLDDRK64 — Type
SHLDDRK64(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        williamson_condition = true)

Explicit Runge-Kutta Method. A fourth-order, five-stage explicit low-storage method of Carpenter and Kennedy (free 3rd order Hermite interpolant). Fixed timestep only. Designed for hyperbolic PDEs (stability properties).

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • williamson_condition: allows for an optimization that allows fusing broadcast expressions with the function call f. However, it only works for Array types.

References

@article{carpenter1994fourth, title={Fourth-order 2N-storage Runge-Kutta schemes}, author={Carpenter, Mark H and Kennedy, Christopher A}, year={1994} }

source
OrdinaryDiffEq.SHLDDRK64 — Type
SHLDDRK64(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
         thread = OrdinaryDiffEq.False(),
-        williamson_condition = true)

Explicit Runge-Kutta Method. A fourth-order, six-stage explicit low-storage method. Fixed timestep only.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • williamson_condition: allows for an optimization that allows fusing broadcast expressions with the function call f. However, it only works for Array types.

References

D. Stanescu, W. G. Habashi. 2N-Storage Low Dissipation and Dispersion Runge-Kutta Schemes for Computational Acoustics. Journal of Computational Physics, 143(2), pp 674-681, 1998. doi: https://doi.org/10.1006/jcph.1998.5986 }

source
OrdinaryDiffEq.SHLDDRK52 — Type
SHLDDRK52(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        williamson_condition = true)

Explicit Runge-Kutta Method. A fourth-order, six-stage explicit low-storage method. Fixed timestep only.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • williamson_condition: allows for an optimization that allows fusing broadcast expressions with the function call f. However, it only works for Array types.

References

D. Stanescu, W. G. Habashi. 2N-Storage Low Dissipation and Dispersion Runge-Kutta Schemes for Computational Acoustics. Journal of Computational Physics, 143(2), pp 674-681, 1998. doi: https://doi.org/10.1006/jcph.1998.5986 }

source
OrdinaryDiffEq.SHLDDRK52 — Type
SHLDDRK52(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. TBD

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.SHLDDRK_2N — Type
SHLDDRK_2N(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. TBD

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.SHLDDRK_2N — Type
SHLDDRK_2N(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. TBD

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.HSLDDRK64 — Type
HSLDDRK64(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. TBD

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.HSLDDRK64 — Type
HSLDDRK64(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
         thread = OrdinaryDiffEq.False(),
-        williamson_condition = true)

Explicit Runge-Kutta Method. Low-Storage Method 6-stage, fourth order low-stage, low-dissipation, low-dispersion scheme. Fixed timestep only.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • williamson_condition: allows for an optimization that allows fusing broadcast expressions with the function call f. However, it only works for Array types.

References

D. Stanescu, W. G. Habashi. 2N-Storage Low Dissipation and Dispersion Runge-Kutta Schemes for Computational Acoustics. Journal of Computational Physics, 143(2), pp 674-681, 1998. doi: https://doi.org/10.1006/jcph.1998.5986 }

source
OrdinaryDiffEq.DGLDDRK73_C — Type
DGLDDRK73_C(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        williamson_condition = true)

Explicit Runge-Kutta Method. Low-Storage Method 6-stage, fourth order low-stage, low-dissipation, low-dispersion scheme. Fixed timestep only.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • williamson_condition: allows for an optimization that allows fusing broadcast expressions with the function call f. However, it only works for Array types.

References

D. Stanescu, W. G. Habashi. 2N-Storage Low Dissipation and Dispersion Runge-Kutta Schemes for Computational Acoustics. Journal of Computational Physics, 143(2), pp 674-681, 1998. doi: https://doi.org/10.1006/jcph.1998.5986 }

source
OrdinaryDiffEq.DGLDDRK73_C — Type
DGLDDRK73_C(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
         thread = OrdinaryDiffEq.False(),
-        williamson_condition = true)

Explicit Runge-Kutta Method. 7-stage, third order low-storage low-dissipation, low-dispersion scheme for discontinuous Galerkin space discretizations applied to wave propagation problems. Optimized for PDE discretizations when maximum spatial step is small due to geometric features of computational domain. Fixed timestep only.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • williamson_condition: allows for an optimization that allows fusing broadcast expressions with the function call f. However, it only works for Array types.

References

T. Toulorge, W. Desmet. Optimal Runge–Kutta Schemes for Discontinuous Galerkin Space Discretizations Applied to Wave Propagation Problems. Journal of Computational Physics, 231(4), pp 2067-2091, 2012. doi: https://doi.org/10.1016/j.jcp.2011.11.024

source
OrdinaryDiffEq.DGLDDRK84_C — Type
DGLDDRK84_C(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        williamson_condition = true)

Explicit Runge-Kutta Method. 7-stage, third order low-storage low-dissipation, low-dispersion scheme for discontinuous Galerkin space discretizations applied to wave propagation problems. Optimized for PDE discretizations when maximum spatial step is small due to geometric features of computational domain. Fixed timestep only.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • williamson_condition: allows for an optimization that allows fusing broadcast expressions with the function call f. However, it only works for Array types.

References

T. Toulorge, W. Desmet. Optimal Runge–Kutta Schemes for Discontinuous Galerkin Space Discretizations Applied to Wave Propagation Problems. Journal of Computational Physics, 231(4), pp 2067-2091, 2012. doi: https://doi.org/10.1016/j.jcp.2011.11.024

source
OrdinaryDiffEq.DGLDDRK84_C — Type
DGLDDRK84_C(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
         thread = OrdinaryDiffEq.False(),
-        williamson_condition = true)

Explicit Runge-Kutta Method. 8-stage, fourth order low-storage low-dissipation, low-dispersion scheme for discontinuous Galerkin space discretizations applied to wave propagation problems. Optimized for PDE discretizations when maximum spatial step is small due to geometric features of computational domain. Fixed timestep only.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • williamson_condition: allows for an optimization that allows fusing broadcast expressions with the function call f. However, it only works for Array types.

References

T. Toulorge, W. Desmet. Optimal Runge–Kutta Schemes for Discontinuous Galerkin Space Discretizations Applied to Wave Propagation Problems. Journal of Computational Physics, 231(4), pp 2067-2091, 2012. doi: https://doi.org/10.1016/j.jcp.2011.11.024

source
OrdinaryDiffEq.DGLDDRK84_F — Type
DGLDDRK84_F(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        williamson_condition = true)

Explicit Runge-Kutta Method. 8-stage, fourth order low-storage low-dissipation, low-dispersion scheme for discontinuous Galerkin space discretizations applied to wave propagation problems. Optimized for PDE discretizations when maximum spatial step is small due to geometric features of computational domain. Fixed timestep only.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • williamson_condition: allows for an optimization that allows fusing broadcast expressions with the function call f. However, it only works for Array types.

References

T. Toulorge, W. Desmet. Optimal Runge–Kutta Schemes for Discontinuous Galerkin Space Discretizations Applied to Wave Propagation Problems. Journal of Computational Physics, 231(4), pp 2067-2091, 2012. doi: https://doi.org/10.1016/j.jcp.2011.11.024

source
OrdinaryDiffEq.DGLDDRK84_F — Type
DGLDDRK84_F(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
         thread = OrdinaryDiffEq.False(),
-        williamson_condition = true)

Explicit Runge-Kutta Method. 8-stage, fourth order low-storage low-dissipation, low-dispersion scheme for discontinuous Galerkin space discretizations applied to wave propagation problems. Optimized for PDE discretizations when the maximum spatial step size is not constrained. Fixed timestep only.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • williamson_condition: allows for an optimization that allows fusing broadcast expressions with the function call f. However, it only works for Array types.

References

T. Toulorge, W. Desmet. Optimal Runge–Kutta Schemes for Discontinuous Galerkin Space Discretizations Applied to Wave Propagation Problems. Journal of Computational Physics, 231(4), pp 2067-2091, 2012. doi: https://doi.org/10.1016/j.jcp.2011.11.024

source
OrdinaryDiffEq.NDBLSRK124 — Type
NDBLSRK124(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        williamson_condition = true)

Explicit Runge-Kutta Method. 8-stage, fourth order low-storage low-dissipation, low-dispersion scheme for discontinuous Galerkin space discretizations applied to wave propagation problems. Optimized for PDE discretizations when the maximum spatial step size is not constrained. Fixed timestep only.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • williamson_condition: allows for an optimization that allows fusing broadcast expressions with the function call f. However, it only works for Array types.

References

T. Toulorge, W. Desmet. Optimal Runge–Kutta Schemes for Discontinuous Galerkin Space Discretizations Applied to Wave Propagation Problems. Journal of Computational Physics, 231(4), pp 2067-2091, 2012. doi: https://doi.org/10.1016/j.jcp.2011.11.024

source
OrdinaryDiffEq.NDBLSRK124 — Type
NDBLSRK124(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
         thread = OrdinaryDiffEq.False(),
-        williamson_condition = true)

Explicit Runge-Kutta Method. 12-stage, fourth order low-storage method with optimized stability regions for advection-dominated problems. Fixed timestep only.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • williamson_condition: allows for an optimization that allows fusing broadcast expressions with the function call f. However, it only works for Array types.

References

Jens Niegemann, Richard Diehl, Kurt Busch. Efficient Low-Storage Runge–Kutta Schemes with Optimized Stability Regions. Journal of Computational Physics, 231, pp 364-372, 2012. doi: https://doi.org/10.1016/j.jcp.2011.09.003

source
OrdinaryDiffEq.NDBLSRK134 — Type
NDBLSRK134(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        williamson_condition = true)

Explicit Runge-Kutta Method. 12-stage, fourth order low-storage method with optimized stability regions for advection-dominated problems. Fixed timestep only.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • williamson_condition: allows for an optimization that allows fusing broadcast expressions with the function call f. However, it only works for Array types.

References

Jens Niegemann, Richard Diehl, Kurt Busch. Efficient Low-Storage Runge–Kutta Schemes with Optimized Stability Regions. Journal of Computational Physics, 231, pp 364-372, 2012. doi: https://doi.org/10.1016/j.jcp.2011.09.003

source
OrdinaryDiffEq.NDBLSRK134 — Type
NDBLSRK134(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
         thread = OrdinaryDiffEq.False(),
-        williamson_condition = true)

Explicit Runge-Kutta Method. 13-stage, fourth order low-storage method with optimized stability regions for advection-dominated problems. Fixed timestep only.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • williamson_condition: allows for an optimization that allows fusing broadcast expressions with the function call f. However, it only works for Array types.

References

Jens Niegemann, Richard Diehl, Kurt Busch. Efficient Low-Storage Runge–Kutta Schemes with Optimized Stability Regions. Journal of Computational Physics, 231, pp 364-372, 2012. doi: https://doi.org/10.1016/j.jcp.2011.09.003

source
OrdinaryDiffEq.NDBLSRK144 — Type
NDBLSRK144(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        williamson_condition = true)

Explicit Runge-Kutta Method. 13-stage, fourth order low-storage method with optimized stability regions for advection-dominated problems. Fixed timestep only.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • williamson_condition: allows for an optimization that allows fusing broadcast expressions with the function call f. However, it only works for Array types.

References

Jens Niegemann, Richard Diehl, Kurt Busch. Efficient Low-Storage Runge–Kutta Schemes with Optimized Stability Regions. Journal of Computational Physics, 231, pp 364-372, 2012. doi: https://doi.org/10.1016/j.jcp.2011.09.003

source
OrdinaryDiffEq.NDBLSRK144 — Type
NDBLSRK144(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
         thread = OrdinaryDiffEq.False(),
-        williamson_condition = true)

Explicit Runge-Kutta Method. 14-stage, fourth order low-storage method with optimized stability regions for advection-dominated problems. Fixed timestep only.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • williamson_condition: allows for an optimization that allows fusing broadcast expressions with the function call f. However, it only works for Array types.

References

Jens Niegemann, Richard Diehl, Kurt Busch. Efficient Low-Storage Runge–Kutta Schemes with Optimized Stability Regions. Journal of Computational Physics, 231, pp 364-372, 2012. doi: https://doi.org/10.1016/j.jcp.2011.09.003

source
OrdinaryDiffEq.CFRLDDRK64 — Type
CFRLDDRK64(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        williamson_condition = true)

Explicit Runge-Kutta Method. 14-stage, fourth order low-storage method with optimized stability regions for advection-dominated problems. Fixed timestep only.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.
  • williamson_condition: allows for an optimization that allows fusing broadcast expressions with the function call f. However, it only works for Array types.

References

Jens Niegemann, Richard Diehl, Kurt Busch. Efficient Low-Storage Runge–Kutta Schemes with Optimized Stability Regions. Journal of Computational Physics, 231, pp 364-372, 2012. doi: https://doi.org/10.1016/j.jcp.2011.09.003

source
OrdinaryDiffEq.CFRLDDRK64 — Type
CFRLDDRK64(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 6-stage, fourth order low-storage, low-dissipation, low-dispersion scheme. Fixed timestep only.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

M. Calvo, J. M. Franco, L. Randez. A New Minimum Storage Runge–Kutta Scheme for Computational Acoustics. Journal of Computational Physics, 201, pp 1-12, 2004. doi: https://doi.org/10.1016/j.jcp.2004.05.012

source
OrdinaryDiffEq.TSLDDRK74 — Type
TSLDDRK74(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 6-stage, fourth order low-storage, low-dissipation, low-dispersion scheme. Fixed timestep only.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

M. Calvo, J. M. Franco, L. Randez. A New Minimum Storage Runge–Kutta Scheme for Computational Acoustics. Journal of Computational Physics, 201, pp 1-12, 2004. doi: https://doi.org/10.1016/j.jcp.2004.05.012

source
OrdinaryDiffEq.TSLDDRK74 — Type
TSLDDRK74(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 7-stage, fourth order low-storage low-dissipation, low-dispersion scheme with maximal accuracy and stability limit along the imaginary axes. Fixed timestep only.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Kostas Tselios, T. E. Simos. Optimized Runge–Kutta Methods with Minimal Dispersion and Dissipation for Problems arising from Computational Acoustics. Physics Letters A, 393(1-2), pp 38-47, 2007. doi: https://doi.org/10.1016/j.physleta.2006.10.072

source
OrdinaryDiffEq.CKLLSRK43_2 — Type
CKLLSRK43_2(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 7-stage, fourth order low-storage low-dissipation, low-dispersion scheme with maximal accuracy and stability limit along the imaginary axes. Fixed timestep only.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Kostas Tselios, T. E. Simos. Optimized Runge–Kutta Methods with Minimal Dispersion and Dissipation for Problems arising from Computational Acoustics. Physics Letters A, 393(1-2), pp 38-47, 2007. doi: https://doi.org/10.1016/j.physleta.2006.10.072

source
OrdinaryDiffEq.CKLLSRK43_2 — Type
CKLLSRK43_2(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 4-stage, third order low-storage scheme, optimized for compressible Navier–Stokes equations.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.CKLLSRK54_3C — Type
CKLLSRK54_3C(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 4-stage, third order low-storage scheme, optimized for compressible Navier–Stokes equations.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.CKLLSRK54_3C — Type
CKLLSRK54_3C(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 5-stage, fourth order low-storage scheme, optimized for compressible Navier–Stokes equations.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.CKLLSRK95_4S — Type
CKLLSRK95_4S(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 5-stage, fourth order low-storage scheme, optimized for compressible Navier–Stokes equations.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.CKLLSRK95_4S — Type
CKLLSRK95_4S(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 9-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.CKLLSRK95_4C — Type
CKLLSRK95_4C(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 9-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.CKLLSRK95_4C — Type
CKLLSRK95_4C(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 9-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.CKLLSRK95_4M — Type
CKLLSRK95_4M(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 9-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.CKLLSRK95_4M — Type
CKLLSRK95_4M(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 9-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.CKLLSRK54_3C_3R — Type
CKLLSRK54_3C_3R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 9-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.CKLLSRK54_3C_3R — Type
CKLLSRK54_3C_3R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 5-stage, fourth order low-storage scheme, optimized for compressible Navier–Stokes equations.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.CKLLSRK54_3M_3R — Type
CKLLSRK54_3M_3R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 5-stage, fourth order low-storage scheme, optimized for compressible Navier–Stokes equations.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.CKLLSRK54_3M_3R — Type
CKLLSRK54_3M_3R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 5-stage, fourth order low-storage scheme, optimized for compressible Navier–Stokes equations.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.CKLLSRK54_3N_3R — Type
CKLLSRK54_3N_3R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 5-stage, fourth order low-storage scheme, optimized for compressible Navier–Stokes equations.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.CKLLSRK54_3N_3R — Type
CKLLSRK54_3N_3R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 5-stage, fourth order low-storage scheme, optimized for compressible Navier–Stokes equations.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.CKLLSRK85_4C_3R — Type
CKLLSRK85_4C_3R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 5-stage, fourth order low-storage scheme, optimized for compressible Navier–Stokes equations.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.CKLLSRK85_4C_3R — Type
CKLLSRK85_4C_3R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 8-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.CKLLSRK85_4M_3R — Type
CKLLSRK85_4M_3R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 8-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.CKLLSRK85_4M_3R — Type
CKLLSRK85_4M_3R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 8-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.CKLLSRK85_4P_3R — Type
CKLLSRK85_4P_3R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 8-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.CKLLSRK85_4P_3R — Type
CKLLSRK85_4P_3R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 8-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.CKLLSRK54_3N_4R — Type
CKLLSRK54_3N_4R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 8-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.CKLLSRK54_3N_4R — Type
CKLLSRK54_3N_4R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 5-stage, fourth order low-storage scheme, optimized for compressible Navier–Stokes equations.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.CKLLSRK54_3M_4R — Type
CKLLSRK54_3M_4R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 5-stage, fourth order low-storage scheme, optimized for compressible Navier–Stokes equations.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.CKLLSRK54_3M_4R — Type
CKLLSRK54_3M_4R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 5-stage, fourth order low-storage scheme, optimized for compressible Navier–Stokes equations.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.CKLLSRK65_4M_4R — Type
CKLLSRK65_4M_4R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 5-stage, fourth order low-storage scheme, optimized for compressible Navier–Stokes equations.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.CKLLSRK65_4M_4R — Type
CKLLSRK65_4M_4R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. 6-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.CKLLSRK85_4FM_4R — Type
CKLLSRK85_4FM_4R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. 6-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.CKLLSRK85_4FM_4R — Type
CKLLSRK85_4FM_4R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 8-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.CKLLSRK75_4M_5R — Type
CKLLSRK75_4M_5R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 8-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.CKLLSRK75_4M_5R — Type
CKLLSRK75_4M_5R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. CKLLSRK754M5R: Low-Storage Method 7-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.ParsaniKetchesonDeconinck3S32 — Type
ParsaniKetchesonDeconinck3S32(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. CKLLSRK754M5R: Low-Storage Method 7-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.ParsaniKetchesonDeconinck3S32 — Type
ParsaniKetchesonDeconinck3S32(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 3-stage, second order (3S) low-storage scheme, optimized the spectral difference method applied to wave propagation problems.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Parsani, Matteo, David I. Ketcheson, and W. Deconinck. Optimized explicit Runge–Kutta schemes for the spectral difference method applied to wave propagation problems. SIAM Journal on Scientific Computing 35.2 (2013): A957-A986. doi: https://doi.org/10.1137/120885899

source
OrdinaryDiffEq.ParsaniKetchesonDeconinck3S82 — Type
ParsaniKetchesonDeconinck3S82(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 3-stage, second order (3S) low-storage scheme, optimized the spectral difference method applied to wave propagation problems.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Parsani, Matteo, David I. Ketcheson, and W. Deconinck. Optimized explicit Runge–Kutta schemes for the spectral difference method applied to wave propagation problems. SIAM Journal on Scientific Computing 35.2 (2013): A957-A986. doi: https://doi.org/10.1137/120885899

source
OrdinaryDiffEq.ParsaniKetchesonDeconinck3S82 — Type
ParsaniKetchesonDeconinck3S82(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 8-stage, second order (3S) low-storage scheme, optimized for the spectral difference method applied to wave propagation problems.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Parsani, Matteo, David I. Ketcheson, and W. Deconinck. Optimized explicit Runge–Kutta schemes for the spectral difference method applied to wave propagation problems. SIAM Journal on Scientific Computing 35.2 (2013): A957-A986. doi: https://doi.org/10.1137/120885899

source
OrdinaryDiffEq.ParsaniKetchesonDeconinck3S53 — Type
ParsaniKetchesonDeconinck3S53(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 8-stage, second order (3S) low-storage scheme, optimized for the spectral difference method applied to wave propagation problems.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Parsani, Matteo, David I. Ketcheson, and W. Deconinck. Optimized explicit Runge–Kutta schemes for the spectral difference method applied to wave propagation problems. SIAM Journal on Scientific Computing 35.2 (2013): A957-A986. doi: https://doi.org/10.1137/120885899

source
OrdinaryDiffEq.ParsaniKetchesonDeconinck3S53 — Type
ParsaniKetchesonDeconinck3S53(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 5-stage, third order (3S) low-storage scheme, optimized for the spectral difference method applied to wave propagation problems.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Parsani, Matteo, David I. Ketcheson, and W. Deconinck. Optimized explicit Runge–Kutta schemes for the spectral difference method applied to wave propagation problems. SIAM Journal on Scientific Computing 35.2 (2013): A957-A986. doi: https://doi.org/10.1137/120885899

source
OrdinaryDiffEq.ParsaniKetchesonDeconinck3S173 — Type
ParsaniKetchesonDeconinck3S173(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 5-stage, third order (3S) low-storage scheme, optimized for the spectral difference method applied to wave propagation problems.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Parsani, Matteo, David I. Ketcheson, and W. Deconinck. Optimized explicit Runge–Kutta schemes for the spectral difference method applied to wave propagation problems. SIAM Journal on Scientific Computing 35.2 (2013): A957-A986. doi: https://doi.org/10.1137/120885899

source
OrdinaryDiffEq.ParsaniKetchesonDeconinck3S173 — Type
ParsaniKetchesonDeconinck3S173(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 17-stage, third order (3S) low-storage scheme, optimized for the spectral difference method applied to wave propagation problems.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Parsani, Matteo, David I. Ketcheson, and W. Deconinck. Optimized explicit Runge–Kutta schemes for the spectral difference method applied to wave propagation problems. SIAM Journal on Scientific Computing 35.2 (2013): A957-A986. doi: https://doi.org/10.1137/120885899

source
OrdinaryDiffEq.ParsaniKetchesonDeconinck3S94 — Type
ParsaniKetchesonDeconinck3S94(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 17-stage, third order (3S) low-storage scheme, optimized for the spectral difference method applied to wave propagation problems.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Parsani, Matteo, David I. Ketcheson, and W. Deconinck. Optimized explicit Runge–Kutta schemes for the spectral difference method applied to wave propagation problems. SIAM Journal on Scientific Computing 35.2 (2013): A957-A986. doi: https://doi.org/10.1137/120885899

source
OrdinaryDiffEq.ParsaniKetchesonDeconinck3S94 — Type
ParsaniKetchesonDeconinck3S94(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 9-stage, fourth order (3S) low-storage scheme, optimized for the spectral difference method applied to wave propagation problems.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Parsani, Matteo, David I. Ketcheson, and W. Deconinck. Optimized explicit Runge–Kutta schemes for the spectral difference method applied to wave propagation problems. SIAM Journal on Scientific Computing 35.2 (2013): A957-A986. doi: https://doi.org/10.1137/120885899

source
OrdinaryDiffEq.ParsaniKetchesonDeconinck3S184 — Type
ParsaniKetchesonDeconinck3S184(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 9-stage, fourth order (3S) low-storage scheme, optimized for the spectral difference method applied to wave propagation problems.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Parsani, Matteo, David I. Ketcheson, and W. Deconinck. Optimized explicit Runge–Kutta schemes for the spectral difference method applied to wave propagation problems. SIAM Journal on Scientific Computing 35.2 (2013): A957-A986. doi: https://doi.org/10.1137/120885899

source
OrdinaryDiffEq.ParsaniKetchesonDeconinck3S184 — Type
ParsaniKetchesonDeconinck3S184(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 18-stage, fourth order (3S) low-storage scheme, optimized for the spectral difference method applied to wave propagation problems.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Parsani, Matteo, David I. Ketcheson, and W. Deconinck. Optimized explicit Runge–Kutta schemes for the spectral difference method applied to wave propagation problems. SIAM Journal on Scientific Computing 35.2 (2013): A957-A986. doi: https://doi.org/10.1137/120885899

source
OrdinaryDiffEq.ParsaniKetchesonDeconinck3S105 — Type
ParsaniKetchesonDeconinck3S105(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 18-stage, fourth order (3S) low-storage scheme, optimized for the spectral difference method applied to wave propagation problems.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Parsani, Matteo, David I. Ketcheson, and W. Deconinck. Optimized explicit Runge–Kutta schemes for the spectral difference method applied to wave propagation problems. SIAM Journal on Scientific Computing 35.2 (2013): A957-A986. doi: https://doi.org/10.1137/120885899

source
OrdinaryDiffEq.ParsaniKetchesonDeconinck3S105 — Type
ParsaniKetchesonDeconinck3S105(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 10-stage, fifth order (3S) low-storage scheme, optimized for the spectral difference method applied to wave propagation problems.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Parsani, Matteo, David I. Ketcheson, and W. Deconinck. Optimized explicit Runge–Kutta schemes for the spectral difference method applied to wave propagation problems. SIAM Journal on Scientific Computing 35.2 (2013): A957-A986. doi: https://doi.org/10.1137/120885899

source
OrdinaryDiffEq.ParsaniKetchesonDeconinck3S205 — Type
ParsaniKetchesonDeconinck3S205(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 10-stage, fifth order (3S) low-storage scheme, optimized for the spectral difference method applied to wave propagation problems.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Parsani, Matteo, David I. Ketcheson, and W. Deconinck. Optimized explicit Runge–Kutta schemes for the spectral difference method applied to wave propagation problems. SIAM Journal on Scientific Computing 35.2 (2013): A957-A986. doi: https://doi.org/10.1137/120885899

source
OrdinaryDiffEq.ParsaniKetchesonDeconinck3S205 — Type
ParsaniKetchesonDeconinck3S205(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 20-stage, fifth order (3S) low-storage scheme, optimized for the spectral difference method applied to wave propagation problems.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Parsani, Matteo, David I. Ketcheson, and W. Deconinck. Optimized explicit Runge–Kutta schemes for the spectral difference method applied to wave propagation problems. SIAM Journal on Scientific Computing 35.2 (2013): A957-A986. doi: https://doi.org/10.1137/120885899

source
OrdinaryDiffEq.RDPK3Sp35 — Type
RDPK3Sp35(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. Low-Storage Method 20-stage, fifth order (3S) low-storage scheme, optimized for the spectral difference method applied to wave propagation problems.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Parsani, Matteo, David I. Ketcheson, and W. Deconinck. Optimized explicit Runge–Kutta schemes for the spectral difference method applied to wave propagation problems. SIAM Journal on Scientific Computing 35.2 (2013): A957-A986. doi: https://doi.org/10.1137/120885899

source
OrdinaryDiffEq.RDPK3Sp35 — Type
RDPK3Sp35(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. A third-order, five-stage explicit Runge-Kutta method with embedded error estimator designed for spectral element discretizations of compressible fluid mechanics.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Ranocha, Dalcin, Parsani, Ketcheson (2021) Optimized Runge-Kutta Methods with Automatic Step Size Control for Compressible Computational Fluid Dynamics arXiv:2104.06836

source
OrdinaryDiffEq.RDPK3SpFSAL35 — Type
RDPK3SpFSAL35(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. A third-order, five-stage explicit Runge-Kutta method with embedded error estimator designed for spectral element discretizations of compressible fluid mechanics.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Ranocha, Dalcin, Parsani, Ketcheson (2021) Optimized Runge-Kutta Methods with Automatic Step Size Control for Compressible Computational Fluid Dynamics arXiv:2104.06836

source
OrdinaryDiffEq.RDPK3SpFSAL35 — Type
RDPK3SpFSAL35(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. A third-order, five-stage explicit Runge-Kutta method with embedded error estimator using the FSAL property designed for spectral element discretizations of compressible fluid mechanics.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Ranocha, Dalcin, Parsani, Ketcheson (2021) Optimized Runge-Kutta Methods with Automatic Step Size Control for Compressible Computational Fluid Dynamics arXiv:2104.06836

source
OrdinaryDiffEq.RDPK3Sp49 — Type
RDPK3Sp49(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. A third-order, five-stage explicit Runge-Kutta method with embedded error estimator using the FSAL property designed for spectral element discretizations of compressible fluid mechanics.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Ranocha, Dalcin, Parsani, Ketcheson (2021) Optimized Runge-Kutta Methods with Automatic Step Size Control for Compressible Computational Fluid Dynamics arXiv:2104.06836

source
OrdinaryDiffEq.RDPK3Sp49 — Type
RDPK3Sp49(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. A fourth-order, nine-stage explicit Runge-Kutta method with embedded error estimator designed for spectral element discretizations of compressible fluid mechanics.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Ranocha, Dalcin, Parsani, Ketcheson (2021) Optimized Runge-Kutta Methods with Automatic Step Size Control for Compressible Computational Fluid Dynamics arXiv:2104.06836

source
OrdinaryDiffEq.RDPK3SpFSAL49 — Type
RDPK3SpFSAL49(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. A fourth-order, nine-stage explicit Runge-Kutta method with embedded error estimator designed for spectral element discretizations of compressible fluid mechanics.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Ranocha, Dalcin, Parsani, Ketcheson (2021) Optimized Runge-Kutta Methods with Automatic Step Size Control for Compressible Computational Fluid Dynamics arXiv:2104.06836

source
OrdinaryDiffEq.RDPK3SpFSAL49 — Type
RDPK3SpFSAL49(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. A fourth-order, nine-stage explicit Runge-Kutta method with embedded error estimator using the FSAL property designed for spectral element discretizations of compressible fluid mechanics.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Ranocha, Dalcin, Parsani, Ketcheson (2021) Optimized Runge-Kutta Methods with Automatic Step Size Control for Compressible Computational Fluid Dynamics arXiv:2104.06836

source
OrdinaryDiffEq.RDPK3Sp510 — Type
RDPK3Sp510(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. A fourth-order, nine-stage explicit Runge-Kutta method with embedded error estimator using the FSAL property designed for spectral element discretizations of compressible fluid mechanics.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Ranocha, Dalcin, Parsani, Ketcheson (2021) Optimized Runge-Kutta Methods with Automatic Step Size Control for Compressible Computational Fluid Dynamics arXiv:2104.06836

source
OrdinaryDiffEq.RDPK3Sp510 — Type
RDPK3Sp510(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. A fifth-order, ten-stage explicit Runge-Kutta method with embedded error estimator designed for spectral element discretizations of compressible fluid mechanics.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Ranocha, Dalcin, Parsani, Ketcheson (2021) Optimized Runge-Kutta Methods with Automatic Step Size Control for Compressible Computational Fluid Dynamics arXiv:2104.06836

source
OrdinaryDiffEq.RDPK3SpFSAL510 — Type
RDPK3SpFSAL510(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. A fifth-order, ten-stage explicit Runge-Kutta method with embedded error estimator designed for spectral element discretizations of compressible fluid mechanics.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Ranocha, Dalcin, Parsani, Ketcheson (2021) Optimized Runge-Kutta Methods with Automatic Step Size Control for Compressible Computational Fluid Dynamics arXiv:2104.06836

source
OrdinaryDiffEq.RDPK3SpFSAL510 — Type
RDPK3SpFSAL510(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. A fifth-order, ten-stage explicit Runge-Kutta method with embedded error estimator using the FSAL property designed for spectral element discretizations of compressible fluid mechanics.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Ranocha, Dalcin, Parsani, Ketcheson (2021) Optimized Runge-Kutta Methods with Automatic Step Size Control for Compressible Computational Fluid Dynamics arXiv:2104.06836

source

SSP Optimized Runge-Kutta Methods

OrdinaryDiffEq.KYK2014DGSSPRK_3S2 — Type
KYK2014DGSSPRK_3S2(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. A fifth-order, ten-stage explicit Runge-Kutta method with embedded error estimator using the FSAL property designed for spectral element discretizations of compressible fluid mechanics.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Ranocha, Dalcin, Parsani, Ketcheson (2021) Optimized Runge-Kutta Methods with Automatic Step Size Control for Compressible Computational Fluid Dynamics arXiv:2104.06836

source

SSP Optimized Runge-Kutta Methods

OrdinaryDiffEq.KYK2014DGSSPRK_3S2 — Type
KYK2014DGSSPRK_3S2(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. TBD

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.SSPRK22 — Type
SSPRK22(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. TBD

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.SSPRK22 — Type
SSPRK22(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. A second-order, two-stage explicit strong stability preserving (SSP) method. Fixed timestep only.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Shu, Chi-Wang, and Stanley Osher. Efficient implementation of essentially non-oscillatory shock-capturing schemes. Journal of Computational Physics 77.2 (1988): 439-471. https://doi.org/10.1016/0021-9991(88)90177-5

source
OrdinaryDiffEq.SSPRK33 — Type
SSPRK33(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. A second-order, two-stage explicit strong stability preserving (SSP) method. Fixed timestep only.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Shu, Chi-Wang, and Stanley Osher. Efficient implementation of essentially non-oscillatory shock-capturing schemes. Journal of Computational Physics 77.2 (1988): 439-471. https://doi.org/10.1016/0021-9991(88)90177-5

source
OrdinaryDiffEq.SSPRK33 — Type
SSPRK33(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. A third-order, three-stage explicit strong stability preserving (SSP) method. Fixed timestep only.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Shu, Chi-Wang, and Stanley Osher. Efficient implementation of essentially non-oscillatory shock-capturing schemes. Journal of Computational Physics 77.2 (1988): 439-471. https://doi.org/10.1016/0021-9991(88)90177-5

source
OrdinaryDiffEq.SSPRK53 — Type
SSPRK53(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. A third-order, three-stage explicit strong stability preserving (SSP) method. Fixed timestep only.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Shu, Chi-Wang, and Stanley Osher. Efficient implementation of essentially non-oscillatory shock-capturing schemes. Journal of Computational Physics 77.2 (1988): 439-471. https://doi.org/10.1016/0021-9991(88)90177-5

source
OrdinaryDiffEq.SSPRK53 — Type
SSPRK53(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. A third-order, five-stage explicit strong stability preserving (SSP) method. Fixed timestep only.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Ruuth, Steven. Global optimization of explicit strong-stability-preserving Runge-Kutta methods. Mathematics of Computation 75.253 (2006): 183-207

source
OrdinaryDiffEq.KYKSSPRK42 — Type
KYKSSPRK42(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. A third-order, five-stage explicit strong stability preserving (SSP) method. Fixed timestep only.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Ruuth, Steven. Global optimization of explicit strong-stability-preserving Runge-Kutta methods. Mathematics of Computation 75.253 (2006): 183-207

source
OrdinaryDiffEq.KYKSSPRK42 — Type
KYKSSPRK42(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. TBD

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.SSPRK53_2N1 — Type
SSPRK53_2N1(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. TBD

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

source
OrdinaryDiffEq.SSPRK53_2N1 — Type
SSPRK53_2N1(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. A third-order, five-stage explicit strong stability preserving (SSP) low-storage method. Fixed timestep only.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Higueras and T. Roldán. New third order low-storage SSP explicit Runge–Kutta methods arXiv:1809.04807v1.

source
OrdinaryDiffEq.SSPRK53_2N2 — Type
SSPRK53_2N2(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. A third-order, five-stage explicit strong stability preserving (SSP) low-storage method. Fixed timestep only.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Higueras and T. Roldán. New third order low-storage SSP explicit Runge–Kutta methods arXiv:1809.04807v1.

source
OrdinaryDiffEq.SSPRK53_2N2 — Type
SSPRK53_2N2(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. A third-order, five-stage explicit strong stability preserving (SSP) low-storage method. Fixed timestep only.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Higueras and T. Roldán. New third order low-storage SSP explicit Runge–Kutta methods arXiv:1809.04807v1.

source
OrdinaryDiffEq.SSPRK53_H — Type
SSPRK53_H(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. A third-order, five-stage explicit strong stability preserving (SSP) low-storage method. Fixed timestep only.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Higueras and T. Roldán. New third order low-storage SSP explicit Runge–Kutta methods arXiv:1809.04807v1.

source
OrdinaryDiffEq.SSPRK53_H — Type
SSPRK53_H(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. A third-order, five-stage explicit strong stability preserving (SSP) low-storage method. Fixed timestep only.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Higueras and T. Roldán. New third order low-storage SSP explicit Runge–Kutta methods arXiv:1809.04807v1.

source
OrdinaryDiffEq.SSPRK63 — Type
SSPRK63(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. A third-order, five-stage explicit strong stability preserving (SSP) low-storage method. Fixed timestep only.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Higueras and T. Roldán. New third order low-storage SSP explicit Runge–Kutta methods arXiv:1809.04807v1.

source
OrdinaryDiffEq.SSPRK63 — Type
SSPRK63(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. A third-order, six-stage explicit strong stability preserving (SSP) method. Fixed timestep only.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Ruuth, Steven. Global optimization of explicit strong-stability-preserving Runge-Kutta methods. Mathematics of Computation 75.253 (2006): 183-207

source
OrdinaryDiffEq.SSPRK73 — Type
SSPRK73(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. A third-order, six-stage explicit strong stability preserving (SSP) method. Fixed timestep only.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Ruuth, Steven. Global optimization of explicit strong-stability-preserving Runge-Kutta methods. Mathematics of Computation 75.253 (2006): 183-207

source
OrdinaryDiffEq.SSPRK73 — Type
SSPRK73(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. A third-order, seven-stage explicit strong stability preserving (SSP) method. Fixed timestep only.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Ruuth, Steven. Global optimization of explicit strong-stability-preserving Runge-Kutta methods. Mathematics of Computation 75.253 (2006): 183-207

source
OrdinaryDiffEq.SSPRK83 — Type
SSPRK83(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. A third-order, seven-stage explicit strong stability preserving (SSP) method. Fixed timestep only.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Ruuth, Steven. Global optimization of explicit strong-stability-preserving Runge-Kutta methods. Mathematics of Computation 75.253 (2006): 183-207

source
OrdinaryDiffEq.SSPRK83 — Type
SSPRK83(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. A third-order, eight-stage explicit strong stability preserving (SSP) method. Fixed timestep only.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Ruuth, Steven. Global optimization of explicit strong-stability-preserving Runge-Kutta methods. Mathematics of Computation 75.253 (2006): 183-207

source
OrdinaryDiffEq.SSPRK43 — Type
SSPRK43(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. A third-order, eight-stage explicit strong stability preserving (SSP) method. Fixed timestep only.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Ruuth, Steven. Global optimization of explicit strong-stability-preserving Runge-Kutta methods. Mathematics of Computation 75.253 (2006): 183-207

source
OrdinaryDiffEq.SSPRK43 — Type
SSPRK43(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. A third-order, four-stage explicit strong stability preserving (SSP) method.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Optimal third-order explicit SSP method with four stages discovered by

  • J. F. B. M. Kraaijevanger. "Contractivity of Runge-Kutta methods." In: BIT Numerical Mathematics 31.3 (1991), pp. 482–528. DOI: 10.1007/BF01933264.

Embedded method constructed by

  • Sidafa Conde, Imre Fekete, John N. Shadid. "Embedded error estimation and adaptive step-size control for optimal explicit strong stability preserving Runge–Kutta methods." arXiv: 1806.08693

Efficient implementation (and optimized controller) developed by

  • Hendrik Ranocha, Lisandro Dalcin, Matteo Parsani, David I. Ketcheson (2021) Optimized Runge-Kutta Methods with Automatic Step Size Control for Compressible Computational Fluid Dynamics arXiv:2104.06836
source
OrdinaryDiffEq.SSPRK432 — Type
SSPRK432(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. A third-order, four-stage explicit strong stability preserving (SSP) method.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Optimal third-order explicit SSP method with four stages discovered by

  • J. F. B. M. Kraaijevanger. "Contractivity of Runge-Kutta methods." In: BIT Numerical Mathematics 31.3 (1991), pp. 482–528. DOI: 10.1007/BF01933264.

Embedded method constructed by

  • Sidafa Conde, Imre Fekete, John N. Shadid. "Embedded error estimation and adaptive step-size control for optimal explicit strong stability preserving Runge–Kutta methods." arXiv: 1806.08693

Efficient implementation (and optimized controller) developed by

  • Hendrik Ranocha, Lisandro Dalcin, Matteo Parsani, David I. Ketcheson (2021) Optimized Runge-Kutta Methods with Automatic Step Size Control for Compressible Computational Fluid Dynamics arXiv:2104.06836
source
OrdinaryDiffEq.SSPRK432 — Type
SSPRK432(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. A third-order, four-stage explicit strong stability preserving (SSP) method.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Gottlieb, Sigal, David I. Ketcheson, and Chi-Wang Shu. Strong stability preserving Runge-Kutta and multistep time discretizations. World Scientific, 2011. Example 6.1

source
OrdinaryDiffEq.SSPRKMSVS43 — Type
SSPRKMSVS43(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. A third-order, four-stage explicit strong stability preserving (SSP) method.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Gottlieb, Sigal, David I. Ketcheson, and Chi-Wang Shu. Strong stability preserving Runge-Kutta and multistep time discretizations. World Scientific, 2011. Example 6.1

source
OrdinaryDiffEq.SSPRKMSVS43 — Type
SSPRKMSVS43(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. A third-order, four-step explicit strong stability preserving (SSP) linear multistep method. This method does not come with an error estimator and requires a fixed time step size.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Shu, Chi-Wang. Total-variation-diminishing time discretizations. SIAM Journal on Scientific and Statistical Computing 9, no. 6 (1988): 1073-1084. DOI: 10.1137/0909073

source
OrdinaryDiffEq.SSPRKMSVS32 — Type
SSPRKMSVS32(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. A third-order, four-step explicit strong stability preserving (SSP) linear multistep method. This method does not come with an error estimator and requires a fixed time step size.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Shu, Chi-Wang. Total-variation-diminishing time discretizations. SIAM Journal on Scientific and Statistical Computing 9, no. 6 (1988): 1073-1084. DOI: 10.1137/0909073

source
OrdinaryDiffEq.SSPRKMSVS32 — Type
SSPRKMSVS32(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. A second-order, three-step explicit strong stability preserving (SSP) linear multistep method. This method does not come with an error estimator and requires a fixed time step size.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Shu, Chi-Wang. Total-variation-diminishing time discretizations. SIAM Journal on Scientific and Statistical Computing 9, no. 6 (1988): 1073-1084. DOI: 10.1137/0909073

source
OrdinaryDiffEq.SSPRK932 — Type
SSPRK932(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. A second-order, three-step explicit strong stability preserving (SSP) linear multistep method. This method does not come with an error estimator and requires a fixed time step size.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Shu, Chi-Wang. Total-variation-diminishing time discretizations. SIAM Journal on Scientific and Statistical Computing 9, no. 6 (1988): 1073-1084. DOI: 10.1137/0909073

source
OrdinaryDiffEq.SSPRK932 — Type
SSPRK932(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. A third-order, nine-stage explicit strong stability preserving (SSP) method.

Consider using SSPRK43 instead, which uses the same main method and an improved embedded method.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Gottlieb, Sigal, David I. Ketcheson, and Chi-Wang Shu. Strong stability preserving Runge-Kutta and multistep time discretizations. World Scientific, 2011.

source
OrdinaryDiffEq.SSPRK54 — Type
SSPRK54(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. A third-order, nine-stage explicit strong stability preserving (SSP) method.

Consider using SSPRK43 instead, which uses the same main method and an improved embedded method.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Gottlieb, Sigal, David I. Ketcheson, and Chi-Wang Shu. Strong stability preserving Runge-Kutta and multistep time discretizations. World Scientific, 2011.

source
OrdinaryDiffEq.SSPRK54 — Type
SSPRK54(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. A fourth-order, five-stage explicit strong stability preserving (SSP) method. Fixed timestep only.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Ruuth, Steven. Global optimization of explicit strong-stability-preserving Runge-Kutta methods. Mathematics of Computation 75.253 (2006): 183-207.

source
OrdinaryDiffEq.SSPRK104 — Type
SSPRK104(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. A fourth-order, five-stage explicit strong stability preserving (SSP) method. Fixed timestep only.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Ruuth, Steven. Global optimization of explicit strong-stability-preserving Runge-Kutta methods. Mathematics of Computation 75.253 (2006): 183-207.

source
OrdinaryDiffEq.SSPRK104 — Type
SSPRK104(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. A fourth-order, ten-stage explicit strong stability preserving (SSP) method. Fixed timestep only.

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False(), default) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Ketcheson, David I. Highly efficient strong stability-preserving Runge–Kutta methods with low-storage implementations. SIAM Journal on Scientific Computing 30.4 (2008): 2113-2136.

source
+ thread = OrdinaryDiffEq.False(),)

Explicit Runge-Kutta Method. A fourth-order, ten-stage explicit strong stability preserving (SSP) method. Fixed timestep only.

Keyword Arguments

References

Ketcheson, David I. Highly efficient strong stability-preserving Runge–Kutta methods with low-storage implementations. SIAM Journal on Scientific Computing 30.4 (2008): 2113-2136.

source diff --git a/dev/nonstiff/nonstiff_multistep/index.html b/dev/nonstiff/nonstiff_multistep/index.html index b06da4564c..15bc9af655 100644 --- a/dev/nonstiff/nonstiff_multistep/index.html +++ b/dev/nonstiff/nonstiff_multistep/index.html @@ -3,4 +3,4 @@ function gtag(){dataLayer.push(arguments);} gtag('js', new Date()); gtag('config', 'UA-90474609-3', {'page_path': location.pathname + location.search + location.hash}); -
Edit on GitHub

Multistep Methods for Non-Stiff Equations

Explicit Multistep Methods

OrdinaryDiffEq.AB3 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

AB3: Adams-Bashforth Explicit Method The 3-step third order multistep method. Ralston's Second Order Method is used to calculate starting values.

source
OrdinaryDiffEq.AB4 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

AB4: Adams-Bashforth Explicit Method The 4-step fourth order multistep method. Runge-Kutta method of order 4 is used to calculate starting values.

source
OrdinaryDiffEq.AB5 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

AB5: Adams-Bashforth Explicit Method The 3-step third order multistep method. Ralston's Second Order Method is used to calculate starting values.

source
OrdinaryDiffEq.AN5 — Type

AN5: Adaptive step size Adams explicit Method An adaptive 5th order fixed-leading coefficient Adams method in Nordsieck form.

source

Predictor-Corrector Methods

OrdinaryDiffEq.ABM32 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

ABM32: Adams-Bashforth Explicit Method It is third order method. In ABM32, AB3 works as predictor and Adams Moulton 2-steps method works as Corrector. Ralston's Second Order Method is used to calculate starting values.

source
OrdinaryDiffEq.ABM43 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

ABM43: Adams-Bashforth Explicit Method It is fourth order method. In ABM43, AB4 works as predictor and Adams Moulton 3-steps method works as Corrector. Runge-Kutta method of order 4 is used to calculate starting values.

source
OrdinaryDiffEq.ABM54 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

ABM54: Adams-Bashforth Explicit Method It is fifth order method. In ABM54, AB5 works as predictor and Adams Moulton 4-steps method works as Corrector. Runge-Kutta method of order 4 is used to calculate starting values.

source
OrdinaryDiffEq.VCAB3 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

VCAB3: Adaptive step size Adams explicit Method The 3rd order Adams method. Bogacki-Shampine 3/2 method is used to calculate starting values.

source
OrdinaryDiffEq.VCAB4 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

VCAB4: Adaptive step size Adams explicit Method The 4th order Adams method. Runge-Kutta 4 is used to calculate starting values.

source
OrdinaryDiffEq.VCAB5 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

VCAB5: Adaptive step size Adams explicit Method The 5th order Adams method. Runge-Kutta 4 is used to calculate starting values.

source
OrdinaryDiffEq.VCABM3 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

VCABM3: Adaptive step size Adams explicit Method The 3rd order Adams-Moulton method. Bogacki-Shampine 3/2 method is used to calculate starting values.

source
OrdinaryDiffEq.VCABM4 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

VCABM4: Adaptive step size Adams explicit Method The 4th order Adams-Moulton method. Runge-Kutta 4 is used to calculate starting values.

source
OrdinaryDiffEq.VCABM5 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

VCABM5: Adaptive step size Adams explicit Method The 5th order Adams-Moulton method. Runge-Kutta 4 is used to calculate starting values.

source
OrdinaryDiffEq.VCABM — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

VCABM: Adaptive step size Adams explicit Method An adaptive order adaptive time Adams Moulton method. It uses an order adaptivity algorithm is derived from Shampine's DDEABM.

source
+
Edit on GitHub

Multistep Methods for Non-Stiff Equations

Explicit Multistep Methods

OrdinaryDiffEq.AB3 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

AB3: Adams-Bashforth Explicit Method The 3-step third order multistep method. Ralston's Second Order Method is used to calculate starting values.

source
OrdinaryDiffEq.AB4 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

AB4: Adams-Bashforth Explicit Method The 4-step fourth order multistep method. Runge-Kutta method of order 4 is used to calculate starting values.

source
OrdinaryDiffEq.AB5 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

AB5: Adams-Bashforth Explicit Method The 3-step third order multistep method. Ralston's Second Order Method is used to calculate starting values.

source
OrdinaryDiffEq.AN5 — Type

AN5: Adaptive step size Adams explicit Method An adaptive 5th order fixed-leading coefficient Adams method in Nordsieck form.

source

Predictor-Corrector Methods

OrdinaryDiffEq.ABM32 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

ABM32: Adams-Bashforth Explicit Method It is third order method. In ABM32, AB3 works as predictor and Adams Moulton 2-steps method works as Corrector. Ralston's Second Order Method is used to calculate starting values.

source
OrdinaryDiffEq.ABM43 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

ABM43: Adams-Bashforth Explicit Method It is fourth order method. In ABM43, AB4 works as predictor and Adams Moulton 3-steps method works as Corrector. Runge-Kutta method of order 4 is used to calculate starting values.

source
OrdinaryDiffEq.ABM54 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

ABM54: Adams-Bashforth Explicit Method It is fifth order method. In ABM54, AB5 works as predictor and Adams Moulton 4-steps method works as Corrector. Runge-Kutta method of order 4 is used to calculate starting values.

source
OrdinaryDiffEq.VCAB3 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

VCAB3: Adaptive step size Adams explicit Method The 3rd order Adams method. Bogacki-Shampine 3/2 method is used to calculate starting values.

source
OrdinaryDiffEq.VCAB4 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

VCAB4: Adaptive step size Adams explicit Method The 4th order Adams method. Runge-Kutta 4 is used to calculate starting values.

source
OrdinaryDiffEq.VCAB5 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

VCAB5: Adaptive step size Adams explicit Method The 5th order Adams method. Runge-Kutta 4 is used to calculate starting values.

source
OrdinaryDiffEq.VCABM3 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

VCABM3: Adaptive step size Adams explicit Method The 3rd order Adams-Moulton method. Bogacki-Shampine 3/2 method is used to calculate starting values.

source
OrdinaryDiffEq.VCABM4 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

VCABM4: Adaptive step size Adams explicit Method The 4th order Adams-Moulton method. Runge-Kutta 4 is used to calculate starting values.

source
OrdinaryDiffEq.VCABM5 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

VCABM5: Adaptive step size Adams explicit Method The 5th order Adams-Moulton method. Runge-Kutta 4 is used to calculate starting values.

source
OrdinaryDiffEq.VCABM — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

VCABM: Adaptive step size Adams explicit Method An adaptive order adaptive time Adams Moulton method. It uses an order adaptivity algorithm is derived from Shampine's DDEABM.

source
diff --git a/dev/search/index.html b/dev/search/index.html index 90149deb74..b9589f0bee 100644 --- a/dev/search/index.html +++ b/dev/search/index.html @@ -3,4 +3,4 @@ function gtag(){dataLayer.push(arguments);} gtag('js', new Date()); gtag('config', 'UA-90474609-3', {'page_path': location.pathname + location.search + location.hash}); -

Loading search...

    +

    Loading search...

      diff --git a/dev/semilinear/exponential_rk/index.html b/dev/semilinear/exponential_rk/index.html index 7fc4cb5976..4899462008 100644 --- a/dev/semilinear/exponential_rk/index.html +++ b/dev/semilinear/exponential_rk/index.html @@ -3,4 +3,4 @@ function gtag(){dataLayer.push(arguments);} gtag('js', new Date()); gtag('config', 'UA-90474609-3', {'page_path': location.pathname + location.search + location.hash}); -
      Edit on GitHub

      Exponential Runge-Kutta Integrators

      Missing docstring.

      Missing docstring for LawsonEuler. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for NorsettEuler. Check Documenter's build log for details.

      OrdinaryDiffEq.ETD2 — Type

      ETD2: Exponential Runge-Kutta Method Second order Exponential Time Differencing method (in development).

      source
      Missing docstring.

      Missing docstring for ETDRK2. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for ETDRK3. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for ETDRK4. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for HochOst4. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for Exp4. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for EPIRK4s3A. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for EPIRK4s3B. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for EPIRK5s3. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for EXPRB53s3. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for EPIRK5P1. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for EPIRK5P2. Check Documenter's build log for details.

      +
      Edit on GitHub

      Exponential Runge-Kutta Integrators

      Missing docstring.

      Missing docstring for LawsonEuler. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for NorsettEuler. Check Documenter's build log for details.

      OrdinaryDiffEq.ETD2 — Type

      ETD2: Exponential Runge-Kutta Method Second order Exponential Time Differencing method (in development).

      source
      Missing docstring.

      Missing docstring for ETDRK2. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for ETDRK3. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for ETDRK4. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for HochOst4. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for Exp4. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for EPIRK4s3A. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for EPIRK4s3B. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for EPIRK5s3. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for EXPRB53s3. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for EPIRK5P1. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for EPIRK5P2. Check Documenter's build log for details.

      diff --git a/dev/semilinear/magnus/index.html b/dev/semilinear/magnus/index.html index 446d8e6e27..52cc589294 100644 --- a/dev/semilinear/magnus/index.html +++ b/dev/semilinear/magnus/index.html @@ -3,4 +3,4 @@ function gtag(){dataLayer.push(arguments);} gtag('js', new Date()); gtag('config', 'UA-90474609-3', {'page_path': location.pathname + location.search + location.hash}); -
      Edit on GitHub

      Magnus and Lie Group Integrators

      Missing docstring.

      Missing docstring for MagnusMidpoint. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for MagnusLeapfrog. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for LieEuler. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for MagnusGauss4. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for MagnusNC6. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for MagnusGL6. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for MagnusGL8. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for MagnusNC8. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for MagnusGL4. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for RKMK2. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for RKMK4. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for LieRK4. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for CG2. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for CG3. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for CG4a. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for MagnusAdapt4. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for CayleyEuler. Check Documenter's build log for details.

      +
      Edit on GitHub

      Magnus and Lie Group Integrators

      Missing docstring.

      Missing docstring for MagnusMidpoint. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for MagnusLeapfrog. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for LieEuler. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for MagnusGauss4. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for MagnusNC6. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for MagnusGL6. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for MagnusGL8. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for MagnusNC8. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for MagnusGL4. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for RKMK2. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for RKMK4. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for LieRK4. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for CG2. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for CG3. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for CG4a. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for MagnusAdapt4. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for CayleyEuler. Check Documenter's build log for details.

      diff --git a/dev/stiff/firk/index.html b/dev/stiff/firk/index.html index b6f5f7e81f..7fb726c035 100644 --- a/dev/stiff/firk/index.html +++ b/dev/stiff/firk/index.html @@ -3,4 +3,4 @@ function gtag(){dataLayer.push(arguments);} gtag('js', new Date()); gtag('config', 'UA-90474609-3', {'page_path': location.pathname + location.search + location.hash}); -
      Edit on GitHub

      Fully Implicit Runge-Kutta (FIRK) Methods

      OrdinaryDiffEq.RadauIIA3 — Type

      @article{hairer1999stiff, title={Stiff differential equations solved by Radau methods}, author={Hairer, Ernst and Wanner, Gerhard}, journal={Journal of Computational and Applied Mathematics}, volume={111}, number={1-2}, pages={93–111}, year={1999}, publisher={Elsevier} }

      RadauIIA3: Fully-Implicit Runge-Kutta Method An A-B-L stable fully implicit Runge-Kutta method with internal tableau complex basis transform for efficiency.

      source
      OrdinaryDiffEq.RadauIIA5 — Type

      @article{hairer1999stiff, title={Stiff differential equations solved by Radau methods}, author={Hairer, Ernst and Wanner, Gerhard}, journal={Journal of Computational and Applied Mathematics}, volume={111}, number={1-2}, pages={93–111}, year={1999}, publisher={Elsevier} }

      RadauIIA5: Fully-Implicit Runge-Kutta Method An A-B-L stable fully implicit Runge-Kutta method with internal tableau complex basis transform for efficiency.

      source
      +
      Edit on GitHub

      Fully Implicit Runge-Kutta (FIRK) Methods

      OrdinaryDiffEq.RadauIIA3 — Type

      @article{hairer1999stiff, title={Stiff differential equations solved by Radau methods}, author={Hairer, Ernst and Wanner, Gerhard}, journal={Journal of Computational and Applied Mathematics}, volume={111}, number={1-2}, pages={93–111}, year={1999}, publisher={Elsevier} }

      RadauIIA3: Fully-Implicit Runge-Kutta Method An A-B-L stable fully implicit Runge-Kutta method with internal tableau complex basis transform for efficiency.

      source
      OrdinaryDiffEq.RadauIIA5 — Type

      @article{hairer1999stiff, title={Stiff differential equations solved by Radau methods}, author={Hairer, Ernst and Wanner, Gerhard}, journal={Journal of Computational and Applied Mathematics}, volume={111}, number={1-2}, pages={93–111}, year={1999}, publisher={Elsevier} }

      RadauIIA5: Fully-Implicit Runge-Kutta Method An A-B-L stable fully implicit Runge-Kutta method with internal tableau complex basis transform for efficiency.

      source
      diff --git a/dev/stiff/implicit_extrapolation/index.html b/dev/stiff/implicit_extrapolation/index.html index 3c413449a4..c31e61d148 100644 --- a/dev/stiff/implicit_extrapolation/index.html +++ b/dev/stiff/implicit_extrapolation/index.html @@ -3,4 +3,4 @@ function gtag(){dataLayer.push(arguments);} gtag('js', new Date()); gtag('config', 'UA-90474609-3', {'page_path': location.pathname + location.search + location.hash}); -
      Edit on GitHub

      Implicit Extrapolation Methods

      +
      Edit on GitHub

      Implicit Extrapolation Methods

      diff --git a/dev/stiff/rosenbrock/index.html b/dev/stiff/rosenbrock/index.html index 690751f155..bd974bcbaf 100644 --- a/dev/stiff/rosenbrock/index.html +++ b/dev/stiff/rosenbrock/index.html @@ -3,4 +3,4 @@ function gtag(){dataLayer.push(arguments);} gtag('js', new Date()); gtag('config', 'UA-90474609-3', {'page_path': location.pathname + location.search + location.hash}); -
      Edit on GitHub

      Rosenbrock Methods

      Standard Rosenbrock Methods

      Missing docstring.

      Missing docstring for ROS3P. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for Rodas3. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for RosShamp4. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for Veldd4. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for Velds4. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for GRK4T. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for GRK4A. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for Ros4LStab. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for Rodas4. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for Rodas42. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for Rodas4P. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for Rodas4P2. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for Rodas5. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for Rodas5P. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for GeneralRosenbrock. Check Documenter's build log for details.

      Rosenbrock W-Methods

      Missing docstring.

      Missing docstring for Rosenbrock23. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for Rosenbrock32. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for ROS34PW1a. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for ROS34PW1b. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for ROS34PW2. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for ROS34PW3. Check Documenter's build log for details.

      +
      Edit on GitHub

      Rosenbrock Methods

      Standard Rosenbrock Methods

      Missing docstring.

      Missing docstring for ROS3P. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for Rodas3. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for RosShamp4. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for Veldd4. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for Velds4. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for GRK4T. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for GRK4A. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for Ros4LStab. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for Rodas4. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for Rodas42. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for Rodas4P. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for Rodas4P2. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for Rodas5. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for Rodas5P. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for GeneralRosenbrock. Check Documenter's build log for details.

      Rosenbrock W-Methods

      Missing docstring.

      Missing docstring for Rosenbrock23. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for Rosenbrock32. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for ROS34PW1a. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for ROS34PW1b. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for ROS34PW2. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for ROS34PW3. Check Documenter's build log for details.

      diff --git a/dev/stiff/sdirk/index.html b/dev/stiff/sdirk/index.html index ab8f7e4dc7..1e6e70ba57 100644 --- a/dev/stiff/sdirk/index.html +++ b/dev/stiff/sdirk/index.html @@ -3,4 +3,4 @@ function gtag(){dataLayer.push(arguments);} gtag('js', new Date()); gtag('config', 'UA-90474609-3', {'page_path': location.pathname + location.search + location.hash}); -
      Edit on GitHub

      Singly-Diagonally Implicit Runge-Kutta (SDIRK) Methods

      OrdinaryDiffEq.ImplicitEuler — Type

      ImplicitEuler: SDIRK Method A 1st order implicit solver. A-B-L-stable. Adaptive timestepping through a divided differences estimate via memory. Strong-stability preserving (SSP).

      source
      OrdinaryDiffEq.ImplicitMidpoint — Type

      ImplicitMidpoint: SDIRK Method A second order A-stable symplectic and symmetric implicit solver. Good for highly stiff equations which need symplectic integration.

      source
      OrdinaryDiffEq.Trapezoid — Type

      Andre Vladimirescu. 1994. The Spice Book. John Wiley & Sons, Inc., New York, NY, USA.

      Trapezoid: SDIRK Method A second order A-stable symmetric ESDIRK method. "Almost symplectic" without numerical dampening. Also known as Crank-Nicolson when applied to PDEs. Adaptive timestepping via divided differences approximation to the second derivative terms in the local truncation error estimate (the SPICE approximation strategy).

      source
      OrdinaryDiffEq.TRBDF2 — Type

      @article{hosea1996analysis, title={Analysis and implementation of TR-BDF2}, author={Hosea, ME and Shampine, LF}, journal={Applied Numerical Mathematics}, volume={20}, number={1-2}, pages={21–37}, year={1996}, publisher={Elsevier} }

      TRBDF2: SDIRK Method A second order A-B-L-S-stable one-step ESDIRK method. Includes stiffness-robust error estimates for accurate adaptive timestepping, smoothed derivatives for highly stiff and oscillatory problems.

      source
      OrdinaryDiffEq.SDIRK2 — Type

      @article{hindmarsh2005sundials, title={{SUNDIALS}: Suite of nonlinear and differential/algebraic equation solvers}, author={Hindmarsh, Alan C and Brown, Peter N and Grant, Keith E and Lee, Steven L and Serban, Radu and Shumaker, Dan E and Woodward, Carol S}, journal={ACM Transactions on Mathematical Software (TOMS)}, volume={31}, number={3}, pages={363–396}, year={2005}, publisher={ACM} }

      SDIRK2: SDIRK Method An A-B-L stable 2nd order SDIRK method

      source
      Missing docstring.

      Missing docstring for SDIRK22. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for SSPSDIRK2. Check Documenter's build log for details.

      OrdinaryDiffEq.Kvaerno3 — Type

      @article{kvaerno2004singly, title={Singly diagonally implicit Runge–Kutta methods with an explicit first stage}, author={Kv{\ae}rn{\o}, Anne}, journal={BIT Numerical Mathematics}, volume={44}, number={3}, pages={489–502}, year={2004}, publisher={Springer} }

      Kvaerno3: SDIRK Method An A-L stable stiffly-accurate 3rd order ESDIRK method

      source
      Missing docstring.

      Missing docstring for CFNLIRK3. Check Documenter's build log for details.

      OrdinaryDiffEq.Cash4 — Type

      @article{hindmarsh2005sundials, title={{SUNDIALS}: Suite of nonlinear and differential/algebraic equation solvers}, author={Hindmarsh, Alan C and Brown, Peter N and Grant, Keith E and Lee, Steven L and Serban, Radu and Shumaker, Dan E and Woodward, Carol S}, journal={ACM Transactions on Mathematical Software (TOMS)}, volume={31}, number={3}, pages={363–396}, year={2005}, publisher={ACM} }

      Cash4: SDIRK Method An A-L stable 4th order SDIRK method

      source
      Missing docstring.

      Missing docstring for SFSDIRK4. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for SFSDIRK5. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for SFSDIRK6. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for SFSDIRK7. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for SFSDIRK8. Check Documenter's build log for details.

      OrdinaryDiffEq.Hairer4 — Type

      E. Hairer, G. Wanner, Solving ordinary differential equations II, stiff and differential-algebraic problems. Computational mathematics (2nd revised ed.), Springer (1996)

      Hairer4: SDIRK Method An A-L stable 4th order SDIRK method

      source
      OrdinaryDiffEq.Hairer42 — Type

      E. Hairer, G. Wanner, Solving ordinary differential equations II, stiff and differential-algebraic problems. Computational mathematics (2nd revised ed.), Springer (1996)

      Hairer42: SDIRK Method An A-L stable 4th order SDIRK method

      source
      OrdinaryDiffEq.Kvaerno4 — Type

      @article{kvaerno2004singly, title={Singly diagonally implicit Runge–Kutta methods with an explicit first stage}, author={Kv{\ae}rn{\o}, Anne}, journal={BIT Numerical Mathematics}, volume={44}, number={3}, pages={489–502}, year={2004}, publisher={Springer} }

      Kvaerno4: SDIRK Method An A-L stable stiffly-accurate 4th order ESDIRK method.

      source
      OrdinaryDiffEq.Kvaerno5 — Type

      @article{kvaerno2004singly, title={Singly diagonally implicit Runge–Kutta methods with an explicit first stage}, author={Kv{\ae}rn{\o}, Anne}, journal={BIT Numerical Mathematics}, volume={44}, number={3}, pages={489–502}, year={2004}, publisher={Springer} }

      Kvaerno5: SDIRK Method An A-L stable stiffly-accurate 5th order ESDIRK method

      source
      +
      Edit on GitHub

      Singly-Diagonally Implicit Runge-Kutta (SDIRK) Methods

      OrdinaryDiffEq.ImplicitEuler — Type

      ImplicitEuler: SDIRK Method A 1st order implicit solver. A-B-L-stable. Adaptive timestepping through a divided differences estimate via memory. Strong-stability preserving (SSP).

      source
      OrdinaryDiffEq.ImplicitMidpoint — Type

      ImplicitMidpoint: SDIRK Method A second order A-stable symplectic and symmetric implicit solver. Good for highly stiff equations which need symplectic integration.

      source
      OrdinaryDiffEq.Trapezoid — Type

      Andre Vladimirescu. 1994. The Spice Book. John Wiley & Sons, Inc., New York, NY, USA.

      Trapezoid: SDIRK Method A second order A-stable symmetric ESDIRK method. "Almost symplectic" without numerical dampening. Also known as Crank-Nicolson when applied to PDEs. Adaptive timestepping via divided differences approximation to the second derivative terms in the local truncation error estimate (the SPICE approximation strategy).

      source
      OrdinaryDiffEq.TRBDF2 — Type

      @article{hosea1996analysis, title={Analysis and implementation of TR-BDF2}, author={Hosea, ME and Shampine, LF}, journal={Applied Numerical Mathematics}, volume={20}, number={1-2}, pages={21–37}, year={1996}, publisher={Elsevier} }

      TRBDF2: SDIRK Method A second order A-B-L-S-stable one-step ESDIRK method. Includes stiffness-robust error estimates for accurate adaptive timestepping, smoothed derivatives for highly stiff and oscillatory problems.

      source
      OrdinaryDiffEq.SDIRK2 — Type

      @article{hindmarsh2005sundials, title={{SUNDIALS}: Suite of nonlinear and differential/algebraic equation solvers}, author={Hindmarsh, Alan C and Brown, Peter N and Grant, Keith E and Lee, Steven L and Serban, Radu and Shumaker, Dan E and Woodward, Carol S}, journal={ACM Transactions on Mathematical Software (TOMS)}, volume={31}, number={3}, pages={363–396}, year={2005}, publisher={ACM} }

      SDIRK2: SDIRK Method An A-B-L stable 2nd order SDIRK method

      source
      Missing docstring.

      Missing docstring for SDIRK22. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for SSPSDIRK2. Check Documenter's build log for details.

      OrdinaryDiffEq.Kvaerno3 — Type

      @article{kvaerno2004singly, title={Singly diagonally implicit Runge–Kutta methods with an explicit first stage}, author={Kv{\ae}rn{\o}, Anne}, journal={BIT Numerical Mathematics}, volume={44}, number={3}, pages={489–502}, year={2004}, publisher={Springer} }

      Kvaerno3: SDIRK Method An A-L stable stiffly-accurate 3rd order ESDIRK method

      source
      Missing docstring.

      Missing docstring for CFNLIRK3. Check Documenter's build log for details.

      OrdinaryDiffEq.Cash4 — Type

      @article{hindmarsh2005sundials, title={{SUNDIALS}: Suite of nonlinear and differential/algebraic equation solvers}, author={Hindmarsh, Alan C and Brown, Peter N and Grant, Keith E and Lee, Steven L and Serban, Radu and Shumaker, Dan E and Woodward, Carol S}, journal={ACM Transactions on Mathematical Software (TOMS)}, volume={31}, number={3}, pages={363–396}, year={2005}, publisher={ACM} }

      Cash4: SDIRK Method An A-L stable 4th order SDIRK method

      source
      Missing docstring.

      Missing docstring for SFSDIRK4. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for SFSDIRK5. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for SFSDIRK6. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for SFSDIRK7. Check Documenter's build log for details.

      Missing docstring.

      Missing docstring for SFSDIRK8. Check Documenter's build log for details.

      OrdinaryDiffEq.Hairer4 — Type

      E. Hairer, G. Wanner, Solving ordinary differential equations II, stiff and differential-algebraic problems. Computational mathematics (2nd revised ed.), Springer (1996)

      Hairer4: SDIRK Method An A-L stable 4th order SDIRK method

      source
      OrdinaryDiffEq.Hairer42 — Type

      E. Hairer, G. Wanner, Solving ordinary differential equations II, stiff and differential-algebraic problems. Computational mathematics (2nd revised ed.), Springer (1996)

      Hairer42: SDIRK Method An A-L stable 4th order SDIRK method

      source
      OrdinaryDiffEq.Kvaerno4 — Type

      @article{kvaerno2004singly, title={Singly diagonally implicit Runge–Kutta methods with an explicit first stage}, author={Kv{\ae}rn{\o}, Anne}, journal={BIT Numerical Mathematics}, volume={44}, number={3}, pages={489–502}, year={2004}, publisher={Springer} }

      Kvaerno4: SDIRK Method An A-L stable stiffly-accurate 4th order ESDIRK method.

      source
      OrdinaryDiffEq.Kvaerno5 — Type

      @article{kvaerno2004singly, title={Singly diagonally implicit Runge–Kutta methods with an explicit first stage}, author={Kv{\ae}rn{\o}, Anne}, journal={BIT Numerical Mathematics}, volume={44}, number={3}, pages={489–502}, year={2004}, publisher={Springer} }

      Kvaerno5: SDIRK Method An A-L stable stiffly-accurate 5th order ESDIRK method

      source
      diff --git a/dev/stiff/stabilized_rk/index.html b/dev/stiff/stabilized_rk/index.html index 154cf05ada..f87e21e494 100644 --- a/dev/stiff/stabilized_rk/index.html +++ b/dev/stiff/stabilized_rk/index.html @@ -3,4 +3,4 @@ function gtag(){dataLayer.push(arguments);} gtag('js', new Date()); gtag('config', 'UA-90474609-3', {'page_path': location.pathname + location.search + location.hash}); -
      Edit on GitHub

      Stabilized Runge-Kutta Methods (Runge-Kutta-Chebyshev)

      Explicit Stabilized Runge-Kutta Methods

      Explicit stabilized methods utilize an upper bound on the spectral radius of the Jacobian. Users can supply an upper bound by specifying the keyword argument eigen_est, for example

      `eigen_est = (integrator) -> integrator.eigen_est = upper_bound`

      The methods ROCK2 and ROCK4 also include keyword arguments min_stages and max_stages, which specify upper and lower bounds on the adaptively chosen number of stages for stability.

      OrdinaryDiffEq.ROCK2 — Type

      Assyr Abdulle, Alexei A. Medovikov. Second Order Chebyshev Methods based on Orthogonal Polynomials. Numerische Mathematik, 90 (1), pp 1-18, 2001. doi: https://dx.doi.org/10.1007/s002110100292

      ROCK2: Stabilized Explicit Method. Second order stabilized Runge-Kutta method. Exhibits high stability for real eigenvalues and is smoothened to allow for moderate sized complex eigenvalues.

      This method takes optional keyword arguments min_stages, max_stages, and eigen_est. The function eigen_est should be of the form

      eigen_est = (integrator) -> integrator.eigen_est = upper_bound,

      where upper_bound is an estimated upper bound on the spectral radius of the Jacobian matrix. If eigen_est is not provided, upper_bound will be estimated using the power iteration.

      source
      OrdinaryDiffEq.ROCK4 — Type
      ROCK4(; min_stages = 0, max_stages = 152, eigen_est = nothing)

      Assyr Abdulle. Fourth Order Chebyshev Methods With Recurrence Relation. 2002 Society for Industrial and Applied Mathematics Journal on Scientific Computing, 23(6), pp 2041-2054, 2001. doi: https://doi.org/10.1137/S1064827500379549

      ROCK4: Stabilized Explicit Method. Fourth order stabilized Runge-Kutta method. Exhibits high stability for real eigenvalues and is smoothened to allow for moderate sized complex eigenvalues.

      This method takes optional keyword arguments min_stages, max_stages, and eigen_est. The function eigen_est should be of the form

      eigen_est = (integrator) -> integrator.eigen_est = upper_bound,

      where upper_bound is an estimated upper bound on the spectral radius of the Jacobian matrix. If eigen_est is not provided, upper_bound will be estimated using the power iteration.

      source
      Missing docstring.

      Missing docstring for SERK2. Check Documenter's build log for details.

      OrdinaryDiffEq.ESERK4 — Type
      ESERK4(; eigen_est = nothing)

      J. Martín-Vaquero, B. Kleefeld. Extrapolated stabilized explicit Runge-Kutta methods, Journal of Computational Physics, 326, pp 141-155, 2016. doi: https://doi.org/10.1016/j.jcp.2016.08.042.

      ESERK4: Stabilized Explicit Method. Fourth order extrapolated stabilized Runge-Kutta method. Exhibits high stability for real eigenvalues and is smoothened to allow for moderate sized complex eigenvalues.

      This method takes the keyword argument eigen_est of the form

      eigen_est = (integrator) -> integrator.eigen_est = upper_bound,

      where upper_bound is an estimated upper bound on the spectral radius of the Jacobian matrix. If eigen_est is not provided, upper_bound will be estimated using the power iteration.

      source
      OrdinaryDiffEq.ESERK5 — Type
      ESERK5(; eigen_est = nothing)

      J. Martín-Vaquero, A. Kleefeld. ESERK5: A fifth-order extrapolated stabilized explicit Runge-Kutta method, Journal of Computational and Applied Mathematics, 356, pp 22-36, 2019. doi: https://doi.org/10.1016/j.cam.2019.01.040.

      ESERK5: Stabilized Explicit Method. Fifth order extrapolated stabilized Runge-Kutta method. Exhibits high stability for real eigenvalues and is smoothened to allow for moderate sized complex eigenvalues.

      This method takes the keyword argument eigen_est of the form

      eigen_est = (integrator) -> integrator.eigen_est = upper_bound,

      where upper_bound is an estimated upper bound on the spectral radius of the Jacobian matrix. If eigen_est is not provided, upper_bound will be estimated using the power iteration.

      source
      OrdinaryDiffEq.RKC — Type
      RKC(; eigen_est = nothing)

      B. P. Sommeijer, L. F. Shampine, J. G. Verwer. RKC: An Explicit Solver for Parabolic PDEs, Journal of Computational and Applied Mathematics, 88(2), pp 315-326, 1998. doi: https://doi.org/10.1016/S0377-0427(97)00219-7

      RKC: Stabilized Explicit Method. Second order stabilized Runge-Kutta method. Exhibits high stability for real eigenvalues.

      This method takes the keyword argument eigen_est of the form

      eigen_est = (integrator) -> integrator.eigen_est = upper_bound,

      where upper_bound is an estimated upper bound on the spectral radius of the Jacobian matrix. If eigen_est is not provided, upper_bound will be estimated using the power iteration.

      source

      Implicit Stabilized Runge-Kutta Methods

      Missing docstring.

      Missing docstring for IRKC. Check Documenter's build log for details.

      +
      Edit on GitHub

      Stabilized Runge-Kutta Methods (Runge-Kutta-Chebyshev)

      Explicit Stabilized Runge-Kutta Methods

      Explicit stabilized methods utilize an upper bound on the spectral radius of the Jacobian. Users can supply an upper bound by specifying the keyword argument eigen_est, for example

      `eigen_est = (integrator) -> integrator.eigen_est = upper_bound`

      The methods ROCK2 and ROCK4 also include keyword arguments min_stages and max_stages, which specify upper and lower bounds on the adaptively chosen number of stages for stability.

      OrdinaryDiffEq.ROCK2 — Type

      Assyr Abdulle, Alexei A. Medovikov. Second Order Chebyshev Methods based on Orthogonal Polynomials. Numerische Mathematik, 90 (1), pp 1-18, 2001. doi: https://dx.doi.org/10.1007/s002110100292

      ROCK2: Stabilized Explicit Method. Second order stabilized Runge-Kutta method. Exhibits high stability for real eigenvalues and is smoothened to allow for moderate sized complex eigenvalues.

      This method takes optional keyword arguments min_stages, max_stages, and eigen_est. The function eigen_est should be of the form

      eigen_est = (integrator) -> integrator.eigen_est = upper_bound,

      where upper_bound is an estimated upper bound on the spectral radius of the Jacobian matrix. If eigen_est is not provided, upper_bound will be estimated using the power iteration.

      source
      OrdinaryDiffEq.ROCK4 — Type
      ROCK4(; min_stages = 0, max_stages = 152, eigen_est = nothing)

      Assyr Abdulle. Fourth Order Chebyshev Methods With Recurrence Relation. 2002 Society for Industrial and Applied Mathematics Journal on Scientific Computing, 23(6), pp 2041-2054, 2001. doi: https://doi.org/10.1137/S1064827500379549

      ROCK4: Stabilized Explicit Method. Fourth order stabilized Runge-Kutta method. Exhibits high stability for real eigenvalues and is smoothened to allow for moderate sized complex eigenvalues.

      This method takes optional keyword arguments min_stages, max_stages, and eigen_est. The function eigen_est should be of the form

      eigen_est = (integrator) -> integrator.eigen_est = upper_bound,

      where upper_bound is an estimated upper bound on the spectral radius of the Jacobian matrix. If eigen_est is not provided, upper_bound will be estimated using the power iteration.

      source
      Missing docstring.

      Missing docstring for SERK2. Check Documenter's build log for details.

      OrdinaryDiffEq.ESERK4 — Type
      ESERK4(; eigen_est = nothing)

      J. Martín-Vaquero, B. Kleefeld. Extrapolated stabilized explicit Runge-Kutta methods, Journal of Computational Physics, 326, pp 141-155, 2016. doi: https://doi.org/10.1016/j.jcp.2016.08.042.

      ESERK4: Stabilized Explicit Method. Fourth order extrapolated stabilized Runge-Kutta method. Exhibits high stability for real eigenvalues and is smoothened to allow for moderate sized complex eigenvalues.

      This method takes the keyword argument eigen_est of the form

      eigen_est = (integrator) -> integrator.eigen_est = upper_bound,

      where upper_bound is an estimated upper bound on the spectral radius of the Jacobian matrix. If eigen_est is not provided, upper_bound will be estimated using the power iteration.

      source
      OrdinaryDiffEq.ESERK5 — Type
      ESERK5(; eigen_est = nothing)

      J. Martín-Vaquero, A. Kleefeld. ESERK5: A fifth-order extrapolated stabilized explicit Runge-Kutta method, Journal of Computational and Applied Mathematics, 356, pp 22-36, 2019. doi: https://doi.org/10.1016/j.cam.2019.01.040.

      ESERK5: Stabilized Explicit Method. Fifth order extrapolated stabilized Runge-Kutta method. Exhibits high stability for real eigenvalues and is smoothened to allow for moderate sized complex eigenvalues.

      This method takes the keyword argument eigen_est of the form

      eigen_est = (integrator) -> integrator.eigen_est = upper_bound,

      where upper_bound is an estimated upper bound on the spectral radius of the Jacobian matrix. If eigen_est is not provided, upper_bound will be estimated using the power iteration.

      source
      OrdinaryDiffEq.RKC — Type
      RKC(; eigen_est = nothing)

      B. P. Sommeijer, L. F. Shampine, J. G. Verwer. RKC: An Explicit Solver for Parabolic PDEs, Journal of Computational and Applied Mathematics, 88(2), pp 315-326, 1998. doi: https://doi.org/10.1016/S0377-0427(97)00219-7

      RKC: Stabilized Explicit Method. Second order stabilized Runge-Kutta method. Exhibits high stability for real eigenvalues.

      This method takes the keyword argument eigen_est of the form

      eigen_est = (integrator) -> integrator.eigen_est = upper_bound,

      where upper_bound is an estimated upper bound on the spectral radius of the Jacobian matrix. If eigen_est is not provided, upper_bound will be estimated using the power iteration.

      source

      Implicit Stabilized Runge-Kutta Methods

      Missing docstring.

      Missing docstring for IRKC. Check Documenter's build log for details.

      diff --git a/dev/stiff/stiff_multistep/index.html b/dev/stiff/stiff_multistep/index.html index 541cb32e4c..d0e2ac4f17 100644 --- a/dev/stiff/stiff_multistep/index.html +++ b/dev/stiff/stiff_multistep/index.html @@ -3,4 +3,4 @@ function gtag(){dataLayer.push(arguments);} gtag('js', new Date()); gtag('config', 'UA-90474609-3', {'page_path': location.pathname + location.search + location.hash}); -
      Edit on GitHub

      Multistep Methods for Stiff Equations

      OrdinaryDiffEq.QNDF1 — Type

      QNDF1: Multistep Method An adaptive order 1 quasi-constant timestep L-stable numerical differentiation function (NDF) method. Optional parameter kappa defaults to Shampine's accuracy-optimal -0.1850.

      See also QNDF.

      source
      OrdinaryDiffEq.QNDF2 — Type

      QNDF2: Multistep Method An adaptive order 2 quasi-constant timestep L-stable numerical differentiation function (NDF) method.

      See also QNDF.

      source
      OrdinaryDiffEq.ABDF2 — Type

      E. Alberdi Celayaa, J. J. Anza Aguirrezabalab, P. Chatzipantelidisc. Implementation of an Adaptive BDF2 Formula and Comparison with The MATLAB Ode15s. Procedia Computer Science, 29, pp 1014-1026, 2014. doi: https://doi.org/10.1016/j.procs.2014.05.091

      ABDF2: Multistep Method An adaptive order 2 L-stable fixed leading coefficient multistep BDF method.

      source
      OrdinaryDiffEq.QNDF — Type

      QNDF: Multistep Method An adaptive order quasi-constant timestep NDF method. Utilizes Shampine's accuracy-optimal kappa values as defaults (has a keyword argument for a tuple of kappa coefficients).

      @article{shampine1997matlab, title={The matlab ode suite}, author={Shampine, Lawrence F and Reichelt, Mark W}, journal={SIAM journal on scientific computing}, volume={18}, number={1}, pages={1–22}, year={1997}, publisher={SIAM} }

      source
      OrdinaryDiffEq.FBDF — Type

      FBDF: Fixed leading coefficient BDF

      An adaptive order quasi-constant timestep NDF method. Utilizes Shampine's accuracy-optimal kappa values as defaults (has a keyword argument for a tuple of kappa coefficients).

      @article{shampine2002solving, title={Solving 0= F (t, y (t), y′(t)) in Matlab}, author={Shampine, Lawrence F}, year={2002}, publisher={Walter de Gruyter GmbH \& Co. KG} }

      source
      OrdinaryDiffEq.MEBDF2 — Type

      MEBDF2: Multistep Method The second order Modified Extended BDF method, which has improved stability properties over the standard BDF. Fixed timestep only.

      source
      +
      Edit on GitHub

      Multistep Methods for Stiff Equations

      OrdinaryDiffEq.QNDF1 — Type

      QNDF1: Multistep Method An adaptive order 1 quasi-constant timestep L-stable numerical differentiation function (NDF) method. Optional parameter kappa defaults to Shampine's accuracy-optimal -0.1850.

      See also QNDF.

      source
      OrdinaryDiffEq.QNDF2 — Type

      QNDF2: Multistep Method An adaptive order 2 quasi-constant timestep L-stable numerical differentiation function (NDF) method.

      See also QNDF.

      source
      OrdinaryDiffEq.ABDF2 — Type

      E. Alberdi Celayaa, J. J. Anza Aguirrezabalab, P. Chatzipantelidisc. Implementation of an Adaptive BDF2 Formula and Comparison with The MATLAB Ode15s. Procedia Computer Science, 29, pp 1014-1026, 2014. doi: https://doi.org/10.1016/j.procs.2014.05.091

      ABDF2: Multistep Method An adaptive order 2 L-stable fixed leading coefficient multistep BDF method.

      source
      OrdinaryDiffEq.QNDF — Type

      QNDF: Multistep Method An adaptive order quasi-constant timestep NDF method. Utilizes Shampine's accuracy-optimal kappa values as defaults (has a keyword argument for a tuple of kappa coefficients).

      @article{shampine1997matlab, title={The matlab ode suite}, author={Shampine, Lawrence F and Reichelt, Mark W}, journal={SIAM journal on scientific computing}, volume={18}, number={1}, pages={1–22}, year={1997}, publisher={SIAM} }

      source
      OrdinaryDiffEq.FBDF — Type

      FBDF: Fixed leading coefficient BDF

      An adaptive order quasi-constant timestep NDF method. Utilizes Shampine's accuracy-optimal kappa values as defaults (has a keyword argument for a tuple of kappa coefficients).

      @article{shampine2002solving, title={Solving 0= F (t, y (t), y′(t)) in Matlab}, author={Shampine, Lawrence F}, year={2002}, publisher={Walter de Gruyter GmbH \& Co. KG} }

      source
      OrdinaryDiffEq.MEBDF2 — Type

      MEBDF2: Multistep Method The second order Modified Extended BDF method, which has improved stability properties over the standard BDF. Fixed timestep only.

      source
      diff --git a/dev/usage/index.html b/dev/usage/index.html index 289f83ec55..503dc5bb2a 100644 --- a/dev/usage/index.html +++ b/dev/usage/index.html @@ -38,4 +38,4 @@ initial_positions = [0.0,0.1] initial_velocities = [0.5,0.0] prob = SecondOrderODEProblem(HH_acceleration,initial_velocities,initial_positions,tspan) -sol2 = solve(prob, KahanLi8(), dt=1/10);

      Other refined forms are IMEX and semi-linear ODEs (for exponential integrators).

      Available Solvers

      For the list of available solvers, please refer to the DifferentialEquations.jl ODE Solvers, Dynamical ODE Solvers, and the Split ODE Solvers pages.

      +sol2 = solve(prob, KahanLi8(), dt=1/10);

      Other refined forms are IMEX and semi-linear ODEs (for exponential integrators).

      Available Solvers

      For the list of available solvers, please refer to the DifferentialEquations.jl ODE Solvers, Dynamical ODE Solvers, and the Split ODE Solvers pages.