diff --git a/dev/.documenter-siteinfo.json b/dev/.documenter-siteinfo.json index 01b8d105c1..8abbd8a657 100644 --- a/dev/.documenter-siteinfo.json +++ b/dev/.documenter-siteinfo.json @@ -1 +1 @@ -{"documenter":{"julia_version":"1.10.4","generation_timestamp":"2024-08-24T13:48:59","documenter_version":"1.6.0"}} \ No newline at end of file +{"documenter":{"julia_version":"1.10.4","generation_timestamp":"2024-08-24T14:08:03","documenter_version":"1.6.0"}} \ No newline at end of file diff --git a/dev/assets/Manifest.toml b/dev/assets/Manifest.toml index ed6448b550..5170ae8370 100644 --- a/dev/assets/Manifest.toml +++ b/dev/assets/Manifest.toml @@ -861,7 +861,7 @@ version = "1.1.0" deps = ["ADTypes", "Adapt", "ArrayInterface", "DataStructures", "DiffEqBase", "DocStringExtensions", "EnumX", "FastBroadcast", "FastClosures", "FillArrays", "FunctionWrappersWrappers", "InteractiveUtils", "LinearAlgebra", "Logging", "MacroTools", "MuladdMacro", "Polyester", "PrecompileTools", "Preferences", "RecursiveArrayTools", "Reexport", "SciMLBase", "SciMLOperators", "SciMLStructures", "SimpleUnPack", "Static", "StaticArrayInterface", "StaticArraysCore", "TruncatedStacktraces"] path = "../lib/OrdinaryDiffEqCore" uuid = "bbf590c4-e513-4bbe-9b18-05decba2e5d8" -version = "1.2.0" +version = "1.3.0" weakdeps = ["EnzymeCore"] [deps.OrdinaryDiffEqCore.extensions] diff --git a/dev/dae/fully_implicit/index.html b/dev/dae/fully_implicit/index.html index e625ba49de..56a519ee15 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}); -
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.

+
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 cc7329db85..bcff454b80 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}); -
GitHub

Runge-Kutta Nystrom Methods

OrdinaryDiffEqRKN.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
OrdinaryDiffEqRKN.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
OrdinaryDiffEqRKN.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
OrdinaryDiffEqRKN.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
OrdinaryDiffEqRKN.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
OrdinaryDiffEqRKN.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,
+
GitHub
Runge-Kutta Nystrom Methods
OrdinaryDiffEqRKN.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
OrdinaryDiffEqRKN.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
OrdinaryDiffEqRKN.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
OrdinaryDiffEqRKN.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
OrdinaryDiffEqRKN.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
OrdinaryDiffEqRKN.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
OrdinaryDiffEqRKN.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
OrdinaryDiffEqRKN.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
OrdinaryDiffEqRKN.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
OrdinaryDiffEqRKN.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
OrdinaryDiffEqRKN.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
OrdinaryDiffEqRKN.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
OrdinaryDiffEqRKN.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
OrdinaryDiffEqRKN.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
OrdinaryDiffEqRKN.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
OrdinaryDiffEqRKN.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
OrdinaryDiffEqRKN.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
OrdinaryDiffEqRKN.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
OrdinaryDiffEqRKN.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
OrdinaryDiffEqRKN.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
OrdinaryDiffEqRKN.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
OrdinaryDiffEqRKN.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 92debd751c..195ab7519c 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}); -
GitHub

Symplectic Runge-Kutta Methods

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

OrdinaryDiffEqSymplecticRK.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
+
GitHub

Symplectic Runge-Kutta Methods

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

OrdinaryDiffEqSymplecticRK.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 419114261e..85705c0cbb 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}); -
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.

OrdinaryDiffEqBDF.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
OrdinaryDiffEqBDF.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
OrdinaryDiffEqBDF.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
+
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.

OrdinaryDiffEqBDF.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
OrdinaryDiffEqBDF.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
OrdinaryDiffEqBDF.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 c97a98eb22..6b4afe4123 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}); -
GitHub

IMEX SDIRK Methods

OrdinaryDiffEqBDF.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
OrdinaryDiffEqBDF.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
OrdinaryDiffEqSDIRK.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
OrdinaryDiffEqSDIRK.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
OrdinaryDiffEqSDIRK.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
OrdinaryDiffEqSDIRK.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
OrdinaryDiffEqSDIRK.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.

OrdinaryDiffEqSDIRK.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
OrdinaryDiffEqSDIRK.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
OrdinaryDiffEqSDIRK.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
OrdinaryDiffEqSDIRK.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
+
GitHub

IMEX SDIRK Methods

OrdinaryDiffEqBDF.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
OrdinaryDiffEqBDF.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
OrdinaryDiffEqSDIRK.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
OrdinaryDiffEqSDIRK.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
OrdinaryDiffEqSDIRK.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
OrdinaryDiffEqSDIRK.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
OrdinaryDiffEqSDIRK.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.

OrdinaryDiffEqSDIRK.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
OrdinaryDiffEqSDIRK.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
OrdinaryDiffEqSDIRK.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
OrdinaryDiffEqSDIRK.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 ba1c1ec76e..27764035e3 100644 --- a/dev/index.html +++ b/dev/index.html @@ -96,7 +96,7 @@ [1dea7af3] OrdinaryDiffEq v6.88.0 `~/work/OrdinaryDiffEq.jl/OrdinaryDiffEq.jl` [89bda076] OrdinaryDiffEqAdamsBashforthMoulton v1.1.0 `../lib/OrdinaryDiffEqAdamsBashforthMoulton` [6ad6398a] OrdinaryDiffEqBDF v1.1.0 `../lib/OrdinaryDiffEqBDF` - [bbf590c4] OrdinaryDiffEqCore v1.2.0 `../lib/OrdinaryDiffEqCore` + [bbf590c4] OrdinaryDiffEqCore v1.3.0 `../lib/OrdinaryDiffEqCore` [50262376] OrdinaryDiffEqDefault v1.1.0 `../lib/OrdinaryDiffEqDefault` [4302a76b] OrdinaryDiffEqDifferentiation v1.1.0 `../lib/OrdinaryDiffEqDifferentiation` [9286f039] OrdinaryDiffEqExplicitRK v1.1.0 `../lib/OrdinaryDiffEqExplicitRK` @@ -226,4 +226,4 @@ [3f19e933] p7zip_jll v17.4.0+2 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 "https://github.com/SciML/OrdinaryDiffEq.jl/tree/gh-pages/v6.88.0/assets/Manifest.toml"">manifest file and the -"https://github.com/SciML/OrdinaryDiffEq.jl/tree/gh-pages/v6.88.0/assets/Project.toml"">project file. +"https://github.com/SciML/OrdinaryDiffEq.jl/tree/gh-pages/v6.88.0/assets/Project.toml"">project file. diff --git a/dev/misc/index.html b/dev/misc/index.html index 04342588bd..481afd460c 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}); -
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.

Missing docstring.

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

+
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.

Missing docstring.

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

diff --git a/dev/nonstiff/explicit_extrapolation/index.html b/dev/nonstiff/explicit_extrapolation/index.html index ee729df7ca..14524727a6 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}); -
GitHub

Explicit Extrapolation Methods

+
GitHub

Explicit Extrapolation Methods

diff --git a/dev/nonstiff/explicitrk/index.html b/dev/nonstiff/explicitrk/index.html index bcc4124147..6a751c8ad2 100644 --- a/dev/nonstiff/explicitrk/index.html +++ b/dev/nonstiff/explicitrk/index.html @@ -3,15 +3,15 @@ function gtag(){dataLayer.push(arguments);} gtag('js', new Date()); gtag('config', 'UA-90474609-3', {'page_path': location.pathname + location.search + location.hash}); -
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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

OrdinaryDiffEqFeagin.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
OrdinaryDiffEqFeagin.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
OrdinaryDiffEqFeagin.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
Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Lazy Interpolation Explicit Runge-Kutta Methods

Missing docstring.

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

OrdinaryDiffEqVerner.Vern6 — Type
Vern6(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+
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
Missing docstring.
Missing docstring for Heun. Check Documenter's build log for details.
Missing docstring.
Missing docstring for Ralston. Check Documenter's build log for details.
Missing docstring.
Missing docstring for Midpoint. Check Documenter's build log for details.
Missing docstring.
Missing docstring for RK4. Check Documenter's build log for details.
Missing docstring.
Missing docstring for RKM. Check Documenter's build log for details.
Missing docstring.
Missing docstring for MSRK5. Check Documenter's build log for details.
Missing docstring.
Missing docstring for MSRK6. Check Documenter's build log for details.
Missing docstring.
Missing docstring for Anas5. Check Documenter's build log for details.
Missing docstring.
Missing docstring for RKO65. Check Documenter's build log for details.
Missing docstring.
Missing docstring for OwrenZen3. Check Documenter's build log for details.
Missing docstring.
Missing docstring for OwrenZen4. Check Documenter's build log for details.
Missing docstring.
Missing docstring for OwrenZen5. Check Documenter's build log for details.
Missing docstring.
Missing docstring for BS3. Check Documenter's build log for details.
Missing docstring.
Missing docstring for DP5. Check Documenter's build log for details.
Missing docstring.
Missing docstring for Tsit5. Check Documenter's build log for details.
Missing docstring.
Missing docstring for DP8. Check Documenter's build log for details.
Missing docstring.
Missing docstring for TanYam7. Check Documenter's build log for details.
Missing docstring.
Missing docstring for TsitPap8. Check Documenter's build log for details.
OrdinaryDiffEqFeagin.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
OrdinaryDiffEqFeagin.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
OrdinaryDiffEqFeagin.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
Missing docstring.
Missing docstring for FRK65. Check Documenter's build log for details.
Missing docstring.
Missing docstring for PFRK87. Check Documenter's build log for details.
Missing docstring.
Missing docstring for Stepanov5. Check Documenter's build log for details.
Missing docstring.
Missing docstring for SIR54. Check Documenter's build log for details.
Missing docstring.
Missing docstring for Alshina2. Check Documenter's build log for details.
Missing docstring.
Missing docstring for Alshina3. Check Documenter's build log for details.
Missing docstring.
Missing docstring for Alshina6. Check Documenter's build log for details.
Lazy Interpolation Explicit Runge-Kutta Methods
Missing docstring.
Missing docstring for BS5. Check Documenter's build log for details.
OrdinaryDiffEqVerner.Vern6 — Type
Vern6(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_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)
  • 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
OrdinaryDiffEqVerner.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)
  • 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
OrdinaryDiffEqVerner.Vern7 — Type
Vern7(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_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)
  • 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
OrdinaryDiffEqVerner.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)
  • 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
OrdinaryDiffEqVerner.Vern8 — Type
Vern8(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_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)
  • 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
OrdinaryDiffEqVerner.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)
  • 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
OrdinaryDiffEqVerner.Vern9 — Type
Vern9(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_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)
  • 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
Missing docstring.
Missing docstring for Euler. Check Documenter's build log for details.
OrdinaryDiffEqLowStorageRK.RK46NL — Type
RK46NL(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
-         step_limiter! = OrdinaryDiffEq.trivial_limiter!)
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)
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
OrdinaryDiffEqLowStorageRK.ORK256 — Type
ORK256(; 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)
  • 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
Missing docstring.
Missing docstring for Euler. Check Documenter's build log for details.
OrdinaryDiffEqLowStorageRK.RK46NL — Type
RK46NL(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+         step_limiter! = OrdinaryDiffEq.trivial_limiter!)
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)
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
OrdinaryDiffEqLowStorageRK.ORK256 — Type
ORK256(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
          step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-         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)
  • 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
Missing docstring.
Missing docstring for KuttaPRK2p5. Check Documenter's build log for details.

+         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)
  • 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

Missing docstring.

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

diff --git a/dev/nonstiff/lowstorage_ssprk/index.html b/dev/nonstiff/lowstorage_ssprk/index.html index aa6b545b4d..7458fb2723 100644 --- a/dev/nonstiff/lowstorage_ssprk/index.html +++ b/dev/nonstiff/lowstorage_ssprk/index.html @@ -5,72 +5,72 @@ gtag('config', 'UA-90474609-3', {'page_path': location.pathname + location.search + location.hash});
GitHub

PDE-Specialized Explicit Runge-Kutta Methods

Low Storage Explicit Runge-Kutta Methods

OrdinaryDiffEqLowStorageRK.CarpenterKennedy2N54 — Type
CarpenterKennedy2N54(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
                        step_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)
  • 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
OrdinaryDiffEqLowStorageRK.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)
  • 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
OrdinaryDiffEqLowStorageRK.SHLDDRK64 — Type
SHLDDRK64(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
             step_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)
  • 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
OrdinaryDiffEqSSPRK.SHLDDRK52 — Type
SHLDDRK52(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
-            step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

References

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

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)

References

source
OrdinaryDiffEqLowStorageRK.HSLDDRK64 — Type
HSLDDRK64(; 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)
  • 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
OrdinaryDiffEqSSPRK.SHLDDRK52 — Type
SHLDDRK52(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+            step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

References

source
OrdinaryDiffEqSSPRK.SHLDDRK_2N — Type
SHLDDRK_2N(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+             step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

References

source
OrdinaryDiffEqLowStorageRK.HSLDDRK64 — Type
HSLDDRK64(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
             step_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)
  • 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
OrdinaryDiffEqLowStorageRK.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)
  • 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
OrdinaryDiffEqLowStorageRK.DGLDDRK73_C — Type
DGLDDRK73_C(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
               step_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)
  • 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
OrdinaryDiffEqLowStorageRK.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)
  • 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
OrdinaryDiffEqLowStorageRK.DGLDDRK84_C — Type
DGLDDRK84_C(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
               step_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)
  • 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
OrdinaryDiffEqLowStorageRK.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)
  • 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
OrdinaryDiffEqLowStorageRK.DGLDDRK84_F — Type
DGLDDRK84_F(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
               step_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)
  • 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
OrdinaryDiffEqLowStorageRK.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)
  • 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
OrdinaryDiffEqLowStorageRK.NDBLSRK124 — Type
NDBLSRK124(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
              step_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)
  • 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
OrdinaryDiffEqLowStorageRK.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)
  • 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
OrdinaryDiffEqLowStorageRK.NDBLSRK134 — Type
NDBLSRK134(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
              step_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)
  • 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
OrdinaryDiffEqLowStorageRK.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)
  • 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
OrdinaryDiffEqLowStorageRK.NDBLSRK144 — Type
NDBLSRK144(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
              step_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)
  • 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
OrdinaryDiffEqLowStorageRK.CFRLDDRK64 — Type
CFRLDDRK64(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
-             step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

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
OrdinaryDiffEqLowStorageRK.TSLDDRK74 — Type
TSLDDRK74(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
-            step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

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
OrdinaryDiffEqLowStorageRK.CKLLSRK43_2 — Type
CKLLSRK43_2(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
-              step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

References

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

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)

References

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

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)

References

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

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)

References

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

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)

References

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

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)

References

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

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)

References

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

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)

References

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

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)

References

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

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)

References

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

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)

References

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

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)

References

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

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)

References

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

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)

References

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

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)

References

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

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)

References

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

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)

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
OrdinaryDiffEqLowStorageRK.ParsaniKetchesonDeconinck3S82 — Type
ParsaniKetchesonDeconinck3S82(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
-                                step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

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
OrdinaryDiffEqLowStorageRK.ParsaniKetchesonDeconinck3S53 — Type
ParsaniKetchesonDeconinck3S53(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
-                                step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

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
OrdinaryDiffEqLowStorageRK.ParsaniKetchesonDeconinck3S173 — Type
ParsaniKetchesonDeconinck3S173(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
-                                 step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

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
OrdinaryDiffEqLowStorageRK.ParsaniKetchesonDeconinck3S94 — Type
ParsaniKetchesonDeconinck3S94(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
-                                step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

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
OrdinaryDiffEqLowStorageRK.ParsaniKetchesonDeconinck3S184 — Type
ParsaniKetchesonDeconinck3S184(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
-                                 step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

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
OrdinaryDiffEqLowStorageRK.ParsaniKetchesonDeconinck3S105 — Type
ParsaniKetchesonDeconinck3S105(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
-                                 step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

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
OrdinaryDiffEqLowStorageRK.ParsaniKetchesonDeconinck3S205 — Type
ParsaniKetchesonDeconinck3S205(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
-                                 step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

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
OrdinaryDiffEqLowStorageRK.RDPK3Sp35 — Type
RDPK3Sp35(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
-            step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

References

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

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

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)

References

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

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

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)

References

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

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

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)

References

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

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

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)

References

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

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

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)

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

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

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)

References

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

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)

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
OrdinaryDiffEqSSPRK.SSPRK33 — Type
SSPRK33(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
-          step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

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
OrdinaryDiffEqSSPRK.SSPRK53 — Type
SSPRK53(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
-          step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

References

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

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

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)

References

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

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)

References

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

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

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)

References

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

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

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)

References

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

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

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)

References

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

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

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)

References

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

source
OrdinaryDiffEqSSPRK.SSPRK83 — Type
SSPRK83(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
-          step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

References

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

source
OrdinaryDiffEqSSPRK.SSPRK43 — Type
SSPRK43(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
-          step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

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
OrdinaryDiffEqSSPRK.SSPRK432 — Type
SSPRK432(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
-           step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

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
OrdinaryDiffEqSSPRK.SSPRKMSVS43 — Type
SSPRKMSVS43(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
-              step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

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
OrdinaryDiffEqSSPRK.SSPRKMSVS32 — Type
SSPRKMSVS32(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
-              step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

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
OrdinaryDiffEqSSPRK.SSPRK932 — Type
SSPRK932(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
-           step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

References

Gottlieb, Sigal, David I. Ketcheson, and Chi-Wang Shu. Strong stability preserving Runge-Kutta and multistep time discretizations. World Scientific, 2011.

source
OrdinaryDiffEqSSPRK.SSPRK54 — Type
SSPRK54(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
-          step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

References

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

source
OrdinaryDiffEqSSPRK.SSPRK104 — Type
SSPRK104(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
-           step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

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
+ 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

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
OrdinaryDiffEqLowStorageRK.CFRLDDRK64 — Type
CFRLDDRK64(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+             step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

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
OrdinaryDiffEqLowStorageRK.TSLDDRK74 — Type
TSLDDRK74(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+            step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

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
OrdinaryDiffEqLowStorageRK.CKLLSRK43_2 — Type
CKLLSRK43_2(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+              step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

References

source
OrdinaryDiffEqLowStorageRK.CKLLSRK54_3C — Type
CKLLSRK54_3C(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+               step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

References

source
OrdinaryDiffEqLowStorageRK.CKLLSRK95_4S — Type
CKLLSRK95_4S(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+               step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

References

source
OrdinaryDiffEqLowStorageRK.CKLLSRK95_4C — Type
CKLLSRK95_4C(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+               step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

References

source
OrdinaryDiffEqLowStorageRK.CKLLSRK95_4M — Type
CKLLSRK95_4M(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+               step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

References

source
OrdinaryDiffEqLowStorageRK.CKLLSRK54_3C_3R — Type
CKLLSRK54_3C_3R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+                  step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

References

source
OrdinaryDiffEqLowStorageRK.CKLLSRK54_3M_3R — Type
CKLLSRK54_3M_3R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+                  step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

References

source
OrdinaryDiffEqLowStorageRK.CKLLSRK54_3N_3R — Type
CKLLSRK54_3N_3R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+                  step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

References

source
OrdinaryDiffEqLowStorageRK.CKLLSRK85_4C_3R — Type
CKLLSRK85_4C_3R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+                  step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

References

source
OrdinaryDiffEqLowStorageRK.CKLLSRK85_4M_3R — Type
CKLLSRK85_4M_3R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+                  step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

References

source
OrdinaryDiffEqLowStorageRK.CKLLSRK85_4P_3R — Type
CKLLSRK85_4P_3R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+                  step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

References

source
OrdinaryDiffEqLowStorageRK.CKLLSRK54_3N_4R — Type
CKLLSRK54_3N_4R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+                  step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

References

source
OrdinaryDiffEqLowStorageRK.CKLLSRK54_3M_4R — Type
CKLLSRK54_3M_4R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+                  step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

References

source
OrdinaryDiffEqLowStorageRK.CKLLSRK65_4M_4R — Type
CKLLSRK65_4M_4R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+                  step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

References

source
OrdinaryDiffEqLowStorageRK.CKLLSRK85_4FM_4R — Type
CKLLSRK85_4FM_4R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+                   step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

References

source
OrdinaryDiffEqLowStorageRK.CKLLSRK75_4M_5R — Type
CKLLSRK75_4M_5R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+                  step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

References

source
OrdinaryDiffEqLowStorageRK.ParsaniKetchesonDeconinck3S32 — Type
ParsaniKetchesonDeconinck3S32(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+                                step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

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
OrdinaryDiffEqLowStorageRK.ParsaniKetchesonDeconinck3S82 — Type
ParsaniKetchesonDeconinck3S82(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+                                step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

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
OrdinaryDiffEqLowStorageRK.ParsaniKetchesonDeconinck3S53 — Type
ParsaniKetchesonDeconinck3S53(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+                                step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

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
OrdinaryDiffEqLowStorageRK.ParsaniKetchesonDeconinck3S173 — Type
ParsaniKetchesonDeconinck3S173(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+                                 step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

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
OrdinaryDiffEqLowStorageRK.ParsaniKetchesonDeconinck3S94 — Type
ParsaniKetchesonDeconinck3S94(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+                                step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

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
OrdinaryDiffEqLowStorageRK.ParsaniKetchesonDeconinck3S184 — Type
ParsaniKetchesonDeconinck3S184(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+                                 step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

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
OrdinaryDiffEqLowStorageRK.ParsaniKetchesonDeconinck3S105 — Type
ParsaniKetchesonDeconinck3S105(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+                                 step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

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
OrdinaryDiffEqLowStorageRK.ParsaniKetchesonDeconinck3S205 — Type
ParsaniKetchesonDeconinck3S205(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+                                 step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

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
OrdinaryDiffEqLowStorageRK.RDPK3Sp35 — Type
RDPK3Sp35(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+            step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

References

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

source
OrdinaryDiffEqLowStorageRK.RDPK3SpFSAL35 — Type
RDPK3SpFSAL35(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+                step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

References

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

source
OrdinaryDiffEqLowStorageRK.RDPK3Sp49 — Type
RDPK3Sp49(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+            step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

References

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

source
OrdinaryDiffEqLowStorageRK.RDPK3SpFSAL49 — Type
RDPK3SpFSAL49(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+                step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

References

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

source
OrdinaryDiffEqLowStorageRK.RDPK3Sp510 — Type
RDPK3Sp510(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+             step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

References

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

source
OrdinaryDiffEqLowStorageRK.RDPK3SpFSAL510 — Type
RDPK3SpFSAL510(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+                 step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

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

OrdinaryDiffEqLowStorageRK.KYK2014DGSSPRK_3S2 — Type
KYK2014DGSSPRK_3S2(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+                     step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

References

source
OrdinaryDiffEqSSPRK.SSPRK22 — Type
SSPRK22(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+          step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

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
OrdinaryDiffEqSSPRK.SSPRK33 — Type
SSPRK33(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+          step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

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
OrdinaryDiffEqSSPRK.SSPRK53 — Type
SSPRK53(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+          step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

References

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

source
OrdinaryDiffEqSSPRK.KYKSSPRK42 — Type
KYKSSPRK42(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+             step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

References

source
OrdinaryDiffEqSSPRK.SSPRK53_2N1 — Type
SSPRK53_2N1(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+              step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

References

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

source
OrdinaryDiffEqSSPRK.SSPRK53_2N2 — Type
SSPRK53_2N2(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+              step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

References

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

source
OrdinaryDiffEqSSPRK.SSPRK53_H — Type
SSPRK53_H(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+            step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

References

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

source
OrdinaryDiffEqSSPRK.SSPRK63 — Type
SSPRK63(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+          step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

References

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

source
OrdinaryDiffEqSSPRK.SSPRK73 — Type
SSPRK73(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+          step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

References

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

source
OrdinaryDiffEqSSPRK.SSPRK83 — Type
SSPRK83(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+          step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

References

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

source
OrdinaryDiffEqSSPRK.SSPRK43 — Type
SSPRK43(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+          step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

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
OrdinaryDiffEqSSPRK.SSPRK432 — Type
SSPRK432(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+           step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

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
OrdinaryDiffEqSSPRK.SSPRKMSVS43 — Type
SSPRKMSVS43(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+              step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

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
OrdinaryDiffEqSSPRK.SSPRKMSVS32 — Type
SSPRKMSVS32(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+              step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

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
OrdinaryDiffEqSSPRK.SSPRK932 — Type
SSPRK932(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+           step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

References

Gottlieb, Sigal, David I. Ketcheson, and Chi-Wang Shu. Strong stability preserving Runge-Kutta and multistep time discretizations. World Scientific, 2011.

source
OrdinaryDiffEqSSPRK.SSPRK54 — Type
SSPRK54(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+          step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

References

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

source
OrdinaryDiffEqSSPRK.SSPRK104 — Type
SSPRK104(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+           step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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)

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 139c9ab241..f7c87610f0 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}); -
GitHub

Multistep Methods for Non-Stiff Equations

Explicit Multistep Methods

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Predictor-Corrector Methods

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

+
GitHub

Multistep Methods for Non-Stiff Equations

Explicit Multistep Methods

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Predictor-Corrector Methods

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

diff --git a/dev/semilinear/exponential_rk/index.html b/dev/semilinear/exponential_rk/index.html index 100aad78f4..0e91c7100e 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}); -
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.

Missing docstring.

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

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.

+
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.

Missing docstring.

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

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 d5b0904af3..9307e84fa1 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}); -
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.

+
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 3a79ce65dd..f2d2095f97 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}); -
GitHub

Fully Implicit Runge-Kutta (FIRK) Methods

OrdinaryDiffEqFIRK.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
OrdinaryDiffEqFIRK.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
+
GitHub

Fully Implicit Runge-Kutta (FIRK) Methods

OrdinaryDiffEqFIRK.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
OrdinaryDiffEqFIRK.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 6fd71f4873..dfe5d677ed 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}); -
GitHub

Implicit Extrapolation Methods

+
GitHub

Implicit Extrapolation Methods

diff --git a/dev/stiff/rosenbrock/index.html b/dev/stiff/rosenbrock/index.html index 683e46949e..769bfb49bd 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}); -
GitHub

Rosenbrock Methods

Standard Rosenbrock Methods

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

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 Rodas3P. 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.

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 Rodas23W. 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.

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

+
GitHub

Rosenbrock Methods

Standard Rosenbrock Methods

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

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 Rodas3P. 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.

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 Rodas23W. 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.

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

Missing docstring.

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

diff --git a/dev/stiff/sdirk/index.html b/dev/stiff/sdirk/index.html index e7caf1949a..bd69f3eb91 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}); -
GitHub

Singly-Diagonally Implicit Runge-Kutta (SDIRK) Methods

OrdinaryDiffEqSDIRK.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
OrdinaryDiffEqSDIRK.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
OrdinaryDiffEqSDIRK.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
OrdinaryDiffEqSDIRK.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
OrdinaryDiffEqSDIRK.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.

OrdinaryDiffEqSDIRK.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.

OrdinaryDiffEqSDIRK.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.

OrdinaryDiffEqSDIRK.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
OrdinaryDiffEqSDIRK.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
OrdinaryDiffEqSDIRK.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
OrdinaryDiffEqSDIRK.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
+
GitHub

Singly-Diagonally Implicit Runge-Kutta (SDIRK) Methods

OrdinaryDiffEqSDIRK.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
OrdinaryDiffEqSDIRK.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
OrdinaryDiffEqSDIRK.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
OrdinaryDiffEqSDIRK.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
OrdinaryDiffEqSDIRK.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.

OrdinaryDiffEqSDIRK.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.

OrdinaryDiffEqSDIRK.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.

OrdinaryDiffEqSDIRK.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
OrdinaryDiffEqSDIRK.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
OrdinaryDiffEqSDIRK.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
OrdinaryDiffEqSDIRK.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 71e6b1d78a..07cd0ac0ac 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}); -
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.

OrdinaryDiffEqStabilizedRK.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
OrdinaryDiffEqStabilizedRK.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.

OrdinaryDiffEqStabilizedRK.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
OrdinaryDiffEqStabilizedRK.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
OrdinaryDiffEqStabilizedRK.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.

+
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.

OrdinaryDiffEqStabilizedRK.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
OrdinaryDiffEqStabilizedRK.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.

OrdinaryDiffEqStabilizedRK.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
OrdinaryDiffEqStabilizedRK.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
OrdinaryDiffEqStabilizedRK.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 06e368593a..00136b411f 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}); -
GitHub

Multistep Methods for Stiff Equations

OrdinaryDiffEqBDF.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
OrdinaryDiffEqBDF.QNDF2 — Type

QNDF2: Multistep Method An adaptive order 2 quasi-constant timestep L-stable numerical differentiation function (NDF) method.

See also QNDF.

source
OrdinaryDiffEqBDF.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
OrdinaryDiffEqBDF.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
OrdinaryDiffEqBDF.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
OrdinaryDiffEqBDF.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
+
GitHub

Multistep Methods for Stiff Equations

OrdinaryDiffEqBDF.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
OrdinaryDiffEqBDF.QNDF2 — Type

QNDF2: Multistep Method An adaptive order 2 quasi-constant timestep L-stable numerical differentiation function (NDF) method.

See also QNDF.

source
OrdinaryDiffEqBDF.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
OrdinaryDiffEqBDF.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
OrdinaryDiffEqBDF.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
OrdinaryDiffEqBDF.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 c0d3ab768a..ae1161761b 100644 --- a/dev/usage/index.html +++ b/dev/usage/index.html @@ -39,4 +39,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.