diff --git a/previews/PR2309/.documenter-siteinfo.json b/previews/PR2309/.documenter-siteinfo.json index 71468dbebe..de52dba600 100644 --- a/previews/PR2309/.documenter-siteinfo.json +++ b/previews/PR2309/.documenter-siteinfo.json @@ -1 +1 @@ -{"documenter":{"julia_version":"1.10.4","generation_timestamp":"2024-08-06T00:26:20","documenter_version":"1.5.0"}} \ No newline at end of file +{"documenter":{"julia_version":"1.10.4","generation_timestamp":"2024-08-06T00:35:11","documenter_version":"1.5.0"}} \ No newline at end of file diff --git a/previews/PR2309/dae/fully_implicit/index.html b/previews/PR2309/dae/fully_implicit/index.html index 64d0395971..9c1ee56825 100644 --- a/previews/PR2309/dae/fully_implicit/index.html +++ b/previews/PR2309/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/previews/PR2309/dynamical/nystrom/index.html b/previews/PR2309/dynamical/nystrom/index.html index 5e4ad57869..5fff68b317 100644 --- a/previews/PR2309/dynamical/nystrom/index.html +++ b/previews/PR2309/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

OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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/previews/PR2309/dynamical/symplectic/index.html b/previews/PR2309/dynamical/symplectic/index.html index 0b268b82d1..3e8cea83a9 100644 --- a/previews/PR2309/dynamical/symplectic/index.html +++ b/previews/PR2309/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.

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

OrdinaryDiffEq.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/previews/PR2309/imex/imex_multistep/index.html b/previews/PR2309/imex/imex_multistep/index.html index e58e456222..0570cba2bb 100644 --- a/previews/PR2309/imex/imex_multistep/index.html +++ b/previews/PR2309/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.

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

OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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/previews/PR2309/imex/imex_sdirk/index.html b/previews/PR2309/imex/imex_sdirk/index.html index 0b7fbba507..4201a71306 100644 --- a/previews/PR2309/imex/imex_sdirk/index.html +++ b/previews/PR2309/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

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

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

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

OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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/previews/PR2309/index.html b/previews/PR2309/index.html index 5ee5d581b0..b4a2778693 100644 --- a/previews/PR2309/index.html +++ b/previews/PR2309/index.html @@ -197,4 +197,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.87.0/assets/Manifest.toml"">manifest file and the -"https://github.com/SciML/OrdinaryDiffEq.jl/tree/gh-pages/v6.87.0/assets/Project.toml"">project file. +"https://github.com/SciML/OrdinaryDiffEq.jl/tree/gh-pages/v6.87.0/assets/Project.toml"">project file. diff --git a/previews/PR2309/misc/index.html b/previews/PR2309/misc/index.html index f330e1cb76..8f0e33fe2d 100644 --- a/previews/PR2309/misc/index.html +++ b/previews/PR2309/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.

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

diff --git a/previews/PR2309/nonstiff/explicit_extrapolation/index.html b/previews/PR2309/nonstiff/explicit_extrapolation/index.html index 9ab086059c..3062f66353 100644 --- a/previews/PR2309/nonstiff/explicit_extrapolation/index.html +++ b/previews/PR2309/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/previews/PR2309/nonstiff/explicitrk/index.html b/previews/PR2309/nonstiff/explicitrk/index.html index 383da1aead..a855300c6b 100644 --- a/previews/PR2309/nonstiff/explicitrk/index.html +++ b/previews/PR2309/nonstiff/explicitrk/index.html @@ -4,48 +4,48 @@ 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

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

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

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

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

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

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

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

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

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

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

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

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

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

source
OrdinaryDiffEq.OrdinaryDiffEqLowOrderRK.RKM — Type
RKM(; 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
OrdinaryDiffEq.OrdinaryDiffEqLowOrderRK.MSRK5 — Type
MSRK5(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

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

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

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

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

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

source
OrdinaryDiffEq.OrdinaryDiffEqLowOrderRK.Anas5 — Type
Anas5(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+       step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

source
OrdinaryDiffEq.OrdinaryDiffEqLowOrderRK.Ralston — Type
Ralston(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+          step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

source
OrdinaryDiffEq.OrdinaryDiffEqLowOrderRK.Midpoint — Type
Midpoint(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+           step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

source
OrdinaryDiffEq.OrdinaryDiffEqLowOrderRK.RK4 — Type
RK4(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+      step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

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

source
OrdinaryDiffEq.OrdinaryDiffEqLowOrderRK.RKM — Type
RKM(; 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
OrdinaryDiffEq.OrdinaryDiffEqLowOrderRK.MSRK5 — Type
MSRK5(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

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

source
OrdinaryDiffEq.OrdinaryDiffEqLowOrderRK.MSRK6 — Type
MSRK6(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

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

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

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

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • w: a periodicity estimate, which when accurate the method becomes 5th order (and is otherwise 4th order with less error for better estimates).

References

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

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

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

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

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

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

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

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

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

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

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

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

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

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

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

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

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

Explicit Runge-Kutta Method. A third-order, four-stage explicit FSAL Runge-Kutta method with embedded error estimator of Bogacki and Shampine.

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

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

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

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

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

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

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

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

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

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

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

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

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

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

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

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

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

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

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

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

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

source
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.OrdinaryDiffEqLowOrderRK.FRK65 — Type
FRK65(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        w = 1)

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

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • w: a periodicity estimate, which when accurate the method becomes 5th order (and is otherwise 4th order with less error for better estimates).

References

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

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

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

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

source
OrdinaryDiffEq.OrdinaryDiffEqLowOrderRK.OwrenZen3 — Type
OwrenZen3(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+            step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

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

source
OrdinaryDiffEq.OrdinaryDiffEqLowOrderRK.OwrenZen4 — Type
OwrenZen4(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+            step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

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

source
OrdinaryDiffEq.OrdinaryDiffEqLowOrderRK.OwrenZen5 — Type
OwrenZen5(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+            step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

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

source
OrdinaryDiffEq.OrdinaryDiffEqLowOrderRK.BS3 — Type
BS3(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+      step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Explicit Runge-Kutta Method. A third-order, four-stage explicit FSAL Runge-Kutta method with embedded error estimator of Bogacki and Shampine.

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

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

source
OrdinaryDiffEq.OrdinaryDiffEqLowOrderRK.DP5 — Type
DP5(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+      step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

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

source
OrdinaryDiffEq.OrdinaryDiffEqTsit5.Tsit5 — Type
Tsit5(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+        step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

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

source
OrdinaryDiffEq.OrdinaryDiffEqHighOrderRK.DP8 — Type
DP8(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+      step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

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

source
OrdinaryDiffEq.OrdinaryDiffEqHighOrderRK.TanYam7 — Type
TanYam7(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+          step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

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

source
OrdinaryDiffEq.OrdinaryDiffEqHighOrderRK.TsitPap8 — Type
TsitPap8(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+           step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

source
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.OrdinaryDiffEqLowOrderRK.FRK65 — Type
FRK65(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
-        omega = 0.0)

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

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • omega: a periodicity phase estimate, when accurate this method results in zero numerical dissipation.

References

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

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

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • omega: a periodicity phase estimate, when accurate this method results in zero numerical dissipation.

References

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

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

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • omega: a periodicity phase estimate, when accurate this method results in zero numerical dissipation.

References

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

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

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

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

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

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

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • omega: a periodicity phase estimate, when accurate this method results in zero numerical dissipation.

References

source
OrdinaryDiffEq.OrdinaryDiffEqLowOrderRK.Stepanov5 — Type
Stepanov5(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
+            step_limiter! = OrdinaryDiffEq.trivial_limiter!)

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

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

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

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

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

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

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

Reference

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

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

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

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

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

Reference

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

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

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

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

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

Reference

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

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

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

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

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

Reference

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

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

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

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

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

Reference

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

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

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

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

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

Reference

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

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

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

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

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

Reference

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

source

Lazy Interpolation Explicit Runge-Kutta Methods

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

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

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

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

Reference

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

source

Lazy Interpolation Explicit Runge-Kutta Methods

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

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

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • lazy: determines if the lazy interpolant is used.

References

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

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

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

Keyword Arguments

  • stage_limiter!: function of the form limiter!(u, integrator, p, t)
  • step_limiter!: function of the form limiter!(u, integrator, p, t)
  • lazy: determines if the lazy interpolant is used.

References

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

source
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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

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

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

OrdinaryDiffEq.OrdinaryDiffEqPRK.KuttaPRK2p5 — Type

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

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

source
+ williamson_condition = true)

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

Keyword Arguments

References

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

source

Parallel Explicit Runge-Kutta Methods

OrdinaryDiffEq.OrdinaryDiffEqPRK.KuttaPRK2p5 — Type

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

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

source
diff --git a/previews/PR2309/nonstiff/lowstorage_ssprk/index.html b/previews/PR2309/nonstiff/lowstorage_ssprk/index.html index c482bda700..89b1ae2899 100644 --- a/previews/PR2309/nonstiff/lowstorage_ssprk/index.html +++ b/previews/PR2309/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

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

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

OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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/previews/PR2309/nonstiff/nonstiff_multistep/index.html b/previews/PR2309/nonstiff/nonstiff_multistep/index.html index 493dd9e8d3..9c6e51f29e 100644 --- a/previews/PR2309/nonstiff/nonstiff_multistep/index.html +++ b/previews/PR2309/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

OrdinaryDiffEq.OrdinaryDiffEqAdamsBashforthMoulton.AB3 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

AB3: Adams-Bashforth Explicit Method The 3-step third order multistep method. Ralston's Second Order Method is used to calculate starting values.

source
OrdinaryDiffEq.OrdinaryDiffEqAdamsBashforthMoulton.AB4 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

AB4: Adams-Bashforth Explicit Method The 4-step fourth order multistep method. Runge-Kutta method of order 4 is used to calculate starting values.

source
OrdinaryDiffEq.OrdinaryDiffEqAdamsBashforthMoulton.AB5 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

AB5: Adams-Bashforth Explicit Method The 3-step third order multistep method. Ralston's Second Order Method is used to calculate starting values.

source

Predictor-Corrector Methods

OrdinaryDiffEq.OrdinaryDiffEqAdamsBashforthMoulton.ABM32 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

ABM32: Adams-Bashforth Explicit Method It is third order method. In ABM32, AB3 works as predictor and Adams Moulton 2-steps method works as Corrector. Ralston's Second Order Method is used to calculate starting values.

source
OrdinaryDiffEq.OrdinaryDiffEqAdamsBashforthMoulton.ABM43 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

ABM43: Adams-Bashforth Explicit Method It is fourth order method. In ABM43, AB4 works as predictor and Adams Moulton 3-steps method works as Corrector. Runge-Kutta method of order 4 is used to calculate starting values.

source
OrdinaryDiffEq.OrdinaryDiffEqAdamsBashforthMoulton.ABM54 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

ABM54: Adams-Bashforth Explicit Method It is fifth order method. In ABM54, AB5 works as predictor and Adams Moulton 4-steps method works as Corrector. Runge-Kutta method of order 4 is used to calculate starting values.

source
OrdinaryDiffEq.OrdinaryDiffEqAdamsBashforthMoulton.VCAB3 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

VCAB3: Adaptive step size Adams explicit Method The 3rd order Adams method. Bogacki-Shampine 3/2 method is used to calculate starting values.

source
OrdinaryDiffEq.OrdinaryDiffEqAdamsBashforthMoulton.VCAB4 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

VCAB4: Adaptive step size Adams explicit Method The 4th order Adams method. Runge-Kutta 4 is used to calculate starting values.

source
OrdinaryDiffEq.OrdinaryDiffEqAdamsBashforthMoulton.VCAB5 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

VCAB5: Adaptive step size Adams explicit Method The 5th order Adams method. Runge-Kutta 4 is used to calculate starting values.

source
OrdinaryDiffEq.OrdinaryDiffEqAdamsBashforthMoulton.VCABM3 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

VCABM3: Adaptive step size Adams explicit Method The 3rd order Adams-Moulton method. Bogacki-Shampine 3/2 method is used to calculate starting values.

source
OrdinaryDiffEq.OrdinaryDiffEqAdamsBashforthMoulton.VCABM4 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

VCABM4: Adaptive step size Adams explicit Method The 4th order Adams-Moulton method. Runge-Kutta 4 is used to calculate starting values.

source
OrdinaryDiffEq.OrdinaryDiffEqAdamsBashforthMoulton.VCABM5 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

VCABM5: Adaptive step size Adams explicit Method The 5th order Adams-Moulton method. Runge-Kutta 4 is used to calculate starting values.

source
OrdinaryDiffEq.OrdinaryDiffEqAdamsBashforthMoulton.VCABM — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

VCABM: Adaptive step size Adams explicit Method An adaptive order adaptive time Adams Moulton method. It uses an order adaptivity algorithm is derived from Shampine's DDEABM.

source
+
GitHub

Multistep Methods for Non-Stiff Equations

Explicit Multistep Methods

OrdinaryDiffEq.OrdinaryDiffEqAdamsBashforthMoulton.AB3 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

AB3: Adams-Bashforth Explicit Method The 3-step third order multistep method. Ralston's Second Order Method is used to calculate starting values.

source
OrdinaryDiffEq.OrdinaryDiffEqAdamsBashforthMoulton.AB4 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

AB4: Adams-Bashforth Explicit Method The 4-step fourth order multistep method. Runge-Kutta method of order 4 is used to calculate starting values.

source
OrdinaryDiffEq.OrdinaryDiffEqAdamsBashforthMoulton.AB5 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

AB5: Adams-Bashforth Explicit Method The 3-step third order multistep method. Ralston's Second Order Method is used to calculate starting values.

source

Predictor-Corrector Methods

OrdinaryDiffEq.OrdinaryDiffEqAdamsBashforthMoulton.ABM32 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

ABM32: Adams-Bashforth Explicit Method It is third order method. In ABM32, AB3 works as predictor and Adams Moulton 2-steps method works as Corrector. Ralston's Second Order Method is used to calculate starting values.

source
OrdinaryDiffEq.OrdinaryDiffEqAdamsBashforthMoulton.ABM43 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

ABM43: Adams-Bashforth Explicit Method It is fourth order method. In ABM43, AB4 works as predictor and Adams Moulton 3-steps method works as Corrector. Runge-Kutta method of order 4 is used to calculate starting values.

source
OrdinaryDiffEq.OrdinaryDiffEqAdamsBashforthMoulton.ABM54 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

ABM54: Adams-Bashforth Explicit Method It is fifth order method. In ABM54, AB5 works as predictor and Adams Moulton 4-steps method works as Corrector. Runge-Kutta method of order 4 is used to calculate starting values.

source
OrdinaryDiffEq.OrdinaryDiffEqAdamsBashforthMoulton.VCAB3 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

VCAB3: Adaptive step size Adams explicit Method The 3rd order Adams method. Bogacki-Shampine 3/2 method is used to calculate starting values.

source
OrdinaryDiffEq.OrdinaryDiffEqAdamsBashforthMoulton.VCAB4 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

VCAB4: Adaptive step size Adams explicit Method The 4th order Adams method. Runge-Kutta 4 is used to calculate starting values.

source
OrdinaryDiffEq.OrdinaryDiffEqAdamsBashforthMoulton.VCAB5 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

VCAB5: Adaptive step size Adams explicit Method The 5th order Adams method. Runge-Kutta 4 is used to calculate starting values.

source
OrdinaryDiffEq.OrdinaryDiffEqAdamsBashforthMoulton.VCABM3 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

VCABM3: Adaptive step size Adams explicit Method The 3rd order Adams-Moulton method. Bogacki-Shampine 3/2 method is used to calculate starting values.

source
OrdinaryDiffEq.OrdinaryDiffEqAdamsBashforthMoulton.VCABM4 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

VCABM4: Adaptive step size Adams explicit Method The 4th order Adams-Moulton method. Runge-Kutta 4 is used to calculate starting values.

source
OrdinaryDiffEq.OrdinaryDiffEqAdamsBashforthMoulton.VCABM5 — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

VCABM5: Adaptive step size Adams explicit Method The 5th order Adams-Moulton method. Runge-Kutta 4 is used to calculate starting values.

source
OrdinaryDiffEq.OrdinaryDiffEqAdamsBashforthMoulton.VCABM — Type

E. Hairer, S. P. Norsett, G. Wanner, Solving Ordinary Differential Equations I, Nonstiff Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1

VCABM: Adaptive step size Adams explicit Method An adaptive order adaptive time Adams Moulton method. It uses an order adaptivity algorithm is derived from Shampine's DDEABM.

source
diff --git a/previews/PR2309/semilinear/exponential_rk/index.html b/previews/PR2309/semilinear/exponential_rk/index.html index 6c799069a2..679a8e67dc 100644 --- a/previews/PR2309/semilinear/exponential_rk/index.html +++ b/previews/PR2309/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 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 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/previews/PR2309/semilinear/magnus/index.html b/previews/PR2309/semilinear/magnus/index.html index e1b8f76dcc..becb27957a 100644 --- a/previews/PR2309/semilinear/magnus/index.html +++ b/previews/PR2309/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/previews/PR2309/stiff/firk/index.html b/previews/PR2309/stiff/firk/index.html index 00d637e2dd..998b720275 100644 --- a/previews/PR2309/stiff/firk/index.html +++ b/previews/PR2309/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

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

OrdinaryDiffEq.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
OrdinaryDiffEq.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/previews/PR2309/stiff/implicit_extrapolation/index.html b/previews/PR2309/stiff/implicit_extrapolation/index.html index c755ee0796..155b39ccd7 100644 --- a/previews/PR2309/stiff/implicit_extrapolation/index.html +++ b/previews/PR2309/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/previews/PR2309/stiff/rosenbrock/index.html b/previews/PR2309/stiff/rosenbrock/index.html index c204e97928..84975ba80d 100644 --- a/previews/PR2309/stiff/rosenbrock/index.html +++ b/previews/PR2309/stiff/rosenbrock/index.html @@ -6,117 +6,117 @@
GitHub

Rosenbrock Methods

Standard Rosenbrock Methods

OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.ROS2 — Type
ROS2(; autodiff = Val{true}(),
        concrete_jac = nothing,
        linsolve = nothing,
-       precs = DEFAULT_PRECS)

Rosenbrock Method. A 2nd order L-stable Rosenbrock method with 2 internal stages.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver

References

  • J. G. Verwer et al. (1999): A second-order Rosenbrock method applied to photochemical dispersion problems https://doi.org/10.1137/S1064827597326651
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.ROS3 — Type
ROS3(; autodiff = Val{true}(),
+       precs = DEFAULT_PRECS)

Rosenbrock Method. A 2nd order L-stable Rosenbrock method with 2 internal stages.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver

References

  • J. G. Verwer et al. (1999): A second-order Rosenbrock method applied to photochemical dispersion problems https://doi.org/10.1137/S1064827597326651
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.ROS3 — Type
ROS3(; autodiff = Val{true}(),
        concrete_jac = nothing,
        linsolve = nothing,
-       precs = DEFAULT_PRECS)

Rosenbrock Method. 3rd order L-stable Rosenbrock method with 3 internal stages with an embedded strongly A-stable 2nd order method.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver

References

  • E. Hairer, G. Wanner, Solving ordinary differential equations II, stiff and differential-algebraic problems. Computational mathematics (2nd revised ed.), Springer (1996)
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.ROS2PR — Type
ROS2PR(; autodiff = Val{true}(),
+       precs = DEFAULT_PRECS)

Rosenbrock Method. 3rd order L-stable Rosenbrock method with 3 internal stages with an embedded strongly A-stable 2nd order method.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver

References

  • E. Hairer, G. Wanner, Solving ordinary differential equations II, stiff and differential-algebraic problems. Computational mathematics (2nd revised ed.), Springer (1996)
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.ROS2PR — Type
ROS2PR(; autodiff = Val{true}(),
          concrete_jac = nothing,
          linsolve = nothing,
-         precs = DEFAULT_PRECS)

Rosenbrock Method. 2nd order stiffly accurate Rosenbrock method with 3 internal stages with (Rinf=0). For problems with medium stiffness the convergence behaviour is very poor and it is recommended to use ROS2S instead.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver

References

  • Rang, Joachim (2014): The Prothero and Robinson example: Convergence studies for Runge-Kutta and Rosenbrock-Wanner methods. https://doi.org/10.24355/dbbs.084-201408121139-0
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.ROS3PR — Type
ROS3PR(; autodiff = Val{true}(),
+         precs = DEFAULT_PRECS)

Rosenbrock Method. 2nd order stiffly accurate Rosenbrock method with 3 internal stages with (Rinf=0). For problems with medium stiffness the convergence behaviour is very poor and it is recommended to use ROS2S instead.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver

References

  • Rang, Joachim (2014): The Prothero and Robinson example: Convergence studies for Runge-Kutta and Rosenbrock-Wanner methods. https://doi.org/10.24355/dbbs.084-201408121139-0
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.ROS3PR — Type
ROS3PR(; autodiff = Val{true}(),
          concrete_jac = nothing,
          linsolve = nothing,
-         precs = DEFAULT_PRECS)

Rosenbrock Method. 3nd order stiffly accurate Rosenbrock method with 3 internal stages with B_PR consistent of order 3, which is strongly A-stable with Rinf~=-0.73.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver

References

  • Rang, Joachim (2014): The Prothero and Robinson example: Convergence studies for Runge-Kutta and Rosenbrock-Wanner methods. https://doi.org/10.24355/dbbs.084-201408121139-0
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.Scholz4_7 — Type
Scholz4_7(; autodiff = Val{true}(),
+         precs = DEFAULT_PRECS)

Rosenbrock Method. 3nd order stiffly accurate Rosenbrock method with 3 internal stages with B_PR consistent of order 3, which is strongly A-stable with Rinf~=-0.73.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver

References

  • Rang, Joachim (2014): The Prothero and Robinson example: Convergence studies for Runge-Kutta and Rosenbrock-Wanner methods. https://doi.org/10.24355/dbbs.084-201408121139-0
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.Scholz4_7 — Type
Scholz4_7(; autodiff = Val{true}(),
             concrete_jac = nothing,
             linsolve = nothing,
-            precs = DEFAULT_PRECS)

Rosenbrock Method. 3nd order stiffly accurate Rosenbrock method with 3 internal stages with B_PR consistent of order 3, which is strongly A-stable with Rinf~=-0.73. Convergence with order 4 for the stiff case, but has a poor accuracy.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver

References

  • Rang, Joachim (2014): The Prothero and Robinson example: Convergence studies for Runge-Kutta and Rosenbrock-Wanner methods. https://doi.org/10.24355/dbbs.084-201408121139-0
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.ROS3PRL — Type
ROS3PRL(; autodiff = Val{true}(),
+            precs = DEFAULT_PRECS)

Rosenbrock Method. 3nd order stiffly accurate Rosenbrock method with 3 internal stages with B_PR consistent of order 3, which is strongly A-stable with Rinf~=-0.73. Convergence with order 4 for the stiff case, but has a poor accuracy.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver

References

  • Rang, Joachim (2014): The Prothero and Robinson example: Convergence studies for Runge-Kutta and Rosenbrock-Wanner methods. https://doi.org/10.24355/dbbs.084-201408121139-0
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.ROS3PRL — Type
ROS3PRL(; autodiff = Val{true}(),
           concrete_jac = nothing,
           linsolve = nothing,
-          precs = DEFAULT_PRECS)

Rosenbrock Method. 3rd order stiffly accurate Rosenbrock method with 4 internal stages, B_PR consistent of order 2 with Rinf=0. The order of convergence decreases if medium stiff problems are considered, but it has good results for very stiff cases.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver

References

  • Rang, Joachim (2014): The Prothero and Robinson example: Convergence studies for Runge-Kutta and Rosenbrock-Wanner methods. https://doi.org/10.24355/dbbs.084-201408121139-0
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.ROS3PRL2 — Type
ROS3PRL2(; autodiff = Val{true}(),
+          precs = DEFAULT_PRECS)

Rosenbrock Method. 3rd order stiffly accurate Rosenbrock method with 4 internal stages, B_PR consistent of order 2 with Rinf=0. The order of convergence decreases if medium stiff problems are considered, but it has good results for very stiff cases.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver

References

  • Rang, Joachim (2014): The Prothero and Robinson example: Convergence studies for Runge-Kutta and Rosenbrock-Wanner methods. https://doi.org/10.24355/dbbs.084-201408121139-0
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.ROS3PRL2 — Type
ROS3PRL2(; autodiff = Val{true}(),
            concrete_jac = nothing,
            linsolve = nothing,
-           precs = DEFAULT_PRECS)

Rosenbrock Method. 3rd order stiffly accurate Rosenbrock method with 4 internal stages, B_PR consistent of order 3. The order of convergence does NOT decreases if medium stiff problems are considered as it does for ROS3PRL.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver

References

  • Rang, Joachim (2014): The Prothero and Robinson example: Convergence studies for Runge-Kutta and Rosenbrock-Wanner methods. https://doi.org/10.24355/dbbs.084-201408121139-0
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.ROS3P — Type
ROS3P(; autodiff = Val{true}(),
+           precs = DEFAULT_PRECS)

Rosenbrock Method. 3rd order stiffly accurate Rosenbrock method with 4 internal stages, B_PR consistent of order 3. The order of convergence does NOT decreases if medium stiff problems are considered as it does for ROS3PRL.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver

References

  • Rang, Joachim (2014): The Prothero and Robinson example: Convergence studies for Runge-Kutta and Rosenbrock-Wanner methods. https://doi.org/10.24355/dbbs.084-201408121139-0
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.ROS3P — Type
ROS3P(; autodiff = Val{true}(),
         concrete_jac = nothing,
         linsolve = nothing,
         precs = DEFAULT_PRECS,
-        step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock Method. 3rd order A-stable and stiffly stable Rosenbrock method. Keeps high accuracy on discretizations of nonlinear parabolic PDEs.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

  • Lang, J. & Verwer, ROS3P—An Accurate Third-Order Rosenbrock Solver Designed for Parabolic Problems J. BIT Numerical Mathematics (2001) 41: 731. doi:10.1023/A:1021900219772
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.Rodas3 — Type
Rodas3(; autodiff = Val{true}(),
+        step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock Method. 3rd order A-stable and stiffly stable Rosenbrock method. Keeps high accuracy on discretizations of nonlinear parabolic PDEs.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

  • Lang, J. & Verwer, ROS3P—An Accurate Third-Order Rosenbrock Solver Designed for Parabolic Problems J. BIT Numerical Mathematics (2001) 41: 731. doi:10.1023/A:1021900219772
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.Rodas3 — Type
Rodas3(; autodiff = Val{true}(),
          concrete_jac = nothing,
          linsolve = nothing,
          precs = DEFAULT_PRECS,
-         step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock Method. 3rd order A-stable and stiffly stable Rosenbrock method.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

  • Steinebach G. Construction of Rosenbrock–Wanner method Rodas5P and numerical benchmarks within the Julia Differential Equations package. In: BIT Numerical Mathematics, 63(2), 2023
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.Rodas3P — Type
Rodas3P(; autodiff = Val{true}(),
+         step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock Method. 3rd order A-stable and stiffly stable Rosenbrock method.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

  • Steinebach G. Construction of Rosenbrock–Wanner method Rodas5P and numerical benchmarks within the Julia Differential Equations package. In: BIT Numerical Mathematics, 63(2), 2023
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.Rodas3P — Type
Rodas3P(; autodiff = Val{true}(),
           concrete_jac = nothing,
           linsolve = nothing,
           precs = DEFAULT_PRECS,
-          step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock Method. 3rd order A-stable and stiffly stable Rosenbrock method with a stiff-aware 3rd order interpolant and additional error test for interpolation. Keeps accuracy on discretizations of linear parabolic PDEs.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

  • Steinebach G., Rodas23W / Rodas32P - a Rosenbrock-type method for DAEs with additional error estimate for dense output and Julia implementation, In progress.
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.RosShamp4 — Type
RosShamp4(; autodiff = Val{true}(),
+          step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock Method. 3rd order A-stable and stiffly stable Rosenbrock method with a stiff-aware 3rd order interpolant and additional error test for interpolation. Keeps accuracy on discretizations of linear parabolic PDEs.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

  • Steinebach G., Rodas23W / Rodas32P - a Rosenbrock-type method for DAEs with additional error estimate for dense output and Julia implementation, In progress.
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.RosShamp4 — Type
RosShamp4(; autodiff = Val{true}(),
             concrete_jac = nothing,
             linsolve = nothing,
-            precs = DEFAULT_PRECS)

Rosenbrock Method. An A-stable 4th order Rosenbrock method.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver

References

  • L. F. Shampine, Implementation of Rosenbrock Methods, ACM Transactions on Mathematical Software (TOMS), 8: 2, 93-113. doi:10.1145/355993.355994
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.Veldd4 — Type
Veldd4(; autodiff = Val{true}(),
+            precs = DEFAULT_PRECS)

Rosenbrock Method. An A-stable 4th order Rosenbrock method.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver

References

  • L. F. Shampine, Implementation of Rosenbrock Methods, ACM Transactions on Mathematical Software (TOMS), 8: 2, 93-113. doi:10.1145/355993.355994
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.Veldd4 — Type
Veldd4(; autodiff = Val{true}(),
          concrete_jac = nothing,
          linsolve = nothing,
          precs = DEFAULT_PRECS,
-         step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock Method. A 4th order D-stable Rosenbrock method.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

  • van Veldhuizen, D-stability and Kaps-Rentrop-methods, M. Computing (1984) 32: 229. doi:10.1007/BF02243574
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.Velds4 — Type
Velds4(; autodiff = Val{true}(),
+         step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock Method. A 4th order D-stable Rosenbrock method.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

  • van Veldhuizen, D-stability and Kaps-Rentrop-methods, M. Computing (1984) 32: 229. doi:10.1007/BF02243574
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.Velds4 — Type
Velds4(; autodiff = Val{true}(),
          concrete_jac = nothing,
          linsolve = nothing,
          precs = DEFAULT_PRECS,
-         step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock Method. A 4th order A-stable Rosenbrock method.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

  • van Veldhuizen, D-stability and Kaps-Rentrop-methods, M. Computing (1984) 32: 229. doi:10.1007/BF02243574
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.GRK4T — Type
GRK4T(; autodiff = Val{true}(),
+         step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock Method. A 4th order A-stable Rosenbrock method.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

  • van Veldhuizen, D-stability and Kaps-Rentrop-methods, M. Computing (1984) 32: 229. doi:10.1007/BF02243574
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.GRK4T — Type
GRK4T(; autodiff = Val{true}(),
         concrete_jac = nothing,
         linsolve = nothing,
         precs = DEFAULT_PRECS,
-        step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock Method. An efficient 4th order Rosenbrock method.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

  • Kaps, P. & Rentrop, Generalized Runge-Kutta methods of order four with stepsize control for stiff ordinary differential equations. P. Numer. Math. (1979) 33: 55. doi:10.1007/BF01396495
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.GRK4A — Type
GRK4A(; autodiff = Val{true}(),
+        step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock Method. An efficient 4th order Rosenbrock method.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

  • Kaps, P. & Rentrop, Generalized Runge-Kutta methods of order four with stepsize control for stiff ordinary differential equations. P. Numer. Math. (1979) 33: 55. doi:10.1007/BF01396495
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.GRK4A — Type
GRK4A(; autodiff = Val{true}(),
         concrete_jac = nothing,
         linsolve = nothing,
         precs = DEFAULT_PRECS,
-        step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock Method. An A-stable 4th order Rosenbrock method. Essentially "anti-L-stable" but efficient.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

  • Kaps, P. & Rentrop, Generalized Runge-Kutta methods of order four with stepsize control for stiff ordinary differential equations. P. Numer. Math. (1979) 33: 55. doi:10.1007/BF01396495
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.Ros4LStab — Type
Ros4LStab(; autodiff = Val{true}(),
+        step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock Method. An A-stable 4th order Rosenbrock method. Essentially "anti-L-stable" but efficient.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

  • Kaps, P. & Rentrop, Generalized Runge-Kutta methods of order four with stepsize control for stiff ordinary differential equations. P. Numer. Math. (1979) 33: 55. doi:10.1007/BF01396495
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.Ros4LStab — Type
Ros4LStab(; autodiff = Val{true}(),
             concrete_jac = nothing,
             linsolve = nothing,
             precs = DEFAULT_PRECS,
-            step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock Method. A 4th order A-stable stiffly stable Rosenbrock method with a stiff-aware 3rd order interpolant

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

  • E. Hairer, G. Wanner, Solving ordinary differential equations II, stiff and differential-algebraic problems. Computational mathematics (2nd revised ed.), Springer (1996)
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.Rodas4 — Type
Rodas4(; autodiff = Val{true}(),
+            step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock Method. A 4th order A-stable stiffly stable Rosenbrock method with a stiff-aware 3rd order interpolant

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

  • E. Hairer, G. Wanner, Solving ordinary differential equations II, stiff and differential-algebraic problems. Computational mathematics (2nd revised ed.), Springer (1996)
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.Rodas4 — Type
Rodas4(; autodiff = Val{true}(),
          concrete_jac = nothing,
          linsolve = nothing,
          precs = DEFAULT_PRECS,
-         step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock Method. A 4th order L-stable Rosenbrock method.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

  • E. Hairer, G. Wanner, Solving ordinary differential equations II, stiff and differential-algebraic problems. Computational mathematics (2nd revised ed.), Springer (1996)
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.Rodas42 — Type
Rodas42(; autodiff = Val{true}(),
+         step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock Method. A 4th order L-stable Rosenbrock method.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

  • E. Hairer, G. Wanner, Solving ordinary differential equations II, stiff and differential-algebraic problems. Computational mathematics (2nd revised ed.), Springer (1996)
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.Rodas42 — Type
Rodas42(; autodiff = Val{true}(),
           concrete_jac = nothing,
           linsolve = nothing,
           precs = DEFAULT_PRECS,
-          step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock Method. A 4th order A-stable stiffly stable Rosenbrock method with a stiff-aware 3rd order interpolant

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

  • E. Hairer, G. Wanner, Solving ordinary differential equations II, stiff and differential-algebraic problems. Computational mathematics (2nd revised ed.), Springer (1996)
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.Rodas4P — Type
Rodas4P(; autodiff = Val{true}(),
+          step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock Method. A 4th order A-stable stiffly stable Rosenbrock method with a stiff-aware 3rd order interpolant

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

  • E. Hairer, G. Wanner, Solving ordinary differential equations II, stiff and differential-algebraic problems. Computational mathematics (2nd revised ed.), Springer (1996)
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.Rodas4P — Type
Rodas4P(; autodiff = Val{true}(),
           concrete_jac = nothing,
           linsolve = nothing,
           precs = DEFAULT_PRECS,
-          step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner Method. 4th order A-stable stiffly stable Rosenbrock method with a stiff-aware 3rd order interpolant. 4th order on linear parabolic problems and 3rd order accurate on nonlinear parabolic problems (as opposed to lower if not corrected).

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

  • Steinebach G., Rodas23W / Rodas32P - a Rosenbrock-type method for DAEs with additional error estimate for dense output and Julia implementation, In progress.
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.Rodas4P2 — Type
Rodas4P2(; autodiff = Val{true}(),
+          step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner Method. 4th order A-stable stiffly stable Rosenbrock method with a stiff-aware 3rd order interpolant. 4th order on linear parabolic problems and 3rd order accurate on nonlinear parabolic problems (as opposed to lower if not corrected).

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

  • Steinebach G., Rodas23W / Rodas32P - a Rosenbrock-type method for DAEs with additional error estimate for dense output and Julia implementation, In progress.
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.Rodas4P2 — Type
Rodas4P2(; autodiff = Val{true}(),
            concrete_jac = nothing,
            linsolve = nothing,
            precs = DEFAULT_PRECS,
-           step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner Method. A 4th order L-stable stiffly stable Rosenbrock method with a stiff-aware 3rd order interpolant. 4th order on linear parabolic problems and 3rd order accurate on nonlinear parabolic problems. It is an improvement of Roadas4P and in case of inexact Jacobians a second order W method.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

  • Steinebach G., Rodas23W / Rodas32P - a Rosenbrock-type method for DAEs with additional error estimate for dense output and Julia implementation, In progress.
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.Rodas5 — Type
Rodas5(; autodiff = Val{true}(),
+           step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner Method. A 4th order L-stable stiffly stable Rosenbrock method with a stiff-aware 3rd order interpolant. 4th order on linear parabolic problems and 3rd order accurate on nonlinear parabolic problems. It is an improvement of Roadas4P and in case of inexact Jacobians a second order W method.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

  • Steinebach G., Rodas23W / Rodas32P - a Rosenbrock-type method for DAEs with additional error estimate for dense output and Julia implementation, In progress.
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.Rodas5 — Type
Rodas5(; autodiff = Val{true}(),
          concrete_jac = nothing,
          linsolve = nothing,
          precs = DEFAULT_PRECS,
-         step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock Method. A 5th order A-stable stiffly stable Rosenbrock method with a stiff-aware 4th order interpolant.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

  • Di Marzo G. RODAS5(4) – Méthodes de Rosenbrock d’ordre 5(4) adaptées aux problemes différentiels-algébriques. MSc mathematics thesis, Faculty of Science, University of Geneva, Switzerland.
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.Rodas5P — Type
Rodas5P(; autodiff = Val{true}(),
+         step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock Method. A 5th order A-stable stiffly stable Rosenbrock method with a stiff-aware 4th order interpolant.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

  • Di Marzo G. RODAS5(4) – Méthodes de Rosenbrock d’ordre 5(4) adaptées aux problemes différentiels-algébriques. MSc mathematics thesis, Faculty of Science, University of Geneva, Switzerland.
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.Rodas5P — Type
Rodas5P(; autodiff = Val{true}(),
           concrete_jac = nothing,
           linsolve = nothing,
           precs = DEFAULT_PRECS,
-          step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock Method. A 5th order A-stable stiffly stable Rosenbrock method with a stiff-aware 4th order interpolant. Has improved stability in the adaptive time stepping embedding.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

  • Steinebach G. Construction of Rosenbrock–Wanner method Rodas5P and numerical benchmarks within the Julia Differential Equations package. In: BIT Numerical Mathematics, 63(2), 2023
source

Rosenbrock W-Methods

OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.Rosenbrock23 — Type
Rosenbrock23(; autodiff = Val{true}(),
+          step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock Method. A 5th order A-stable stiffly stable Rosenbrock method with a stiff-aware 4th order interpolant. Has improved stability in the adaptive time stepping embedding.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

  • Steinebach G. Construction of Rosenbrock–Wanner method Rodas5P and numerical benchmarks within the Julia Differential Equations package. In: BIT Numerical Mathematics, 63(2), 2023
source

Rosenbrock W-Methods

OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.Rosenbrock23 — Type
Rosenbrock23(; autodiff = Val{true}(),
                concrete_jac = nothing,
                linsolve = nothing,
                precs = DEFAULT_PRECS,
-               step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner Method. An Order 2/3 L-Stable Rosenbrock-W method which is good for very stiff equations with oscillations at low tolerances. 2nd order stiff-aware interpolation.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

  • Shampine L.F. and Reichelt M., (1997) The MATLAB ODE Suite, SIAM Journal of

Scientific Computing, 18 (1), pp. 1-22.

source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.Rosenbrock32 — Type
Rosenbrock32(; autodiff = Val{true}(),
+               step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner Method. An Order 2/3 L-Stable Rosenbrock-W method which is good for very stiff equations with oscillations at low tolerances. 2nd order stiff-aware interpolation.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

  • Shampine L.F. and Reichelt M., (1997) The MATLAB ODE Suite, SIAM Journal of

Scientific Computing, 18 (1), pp. 1-22.

source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.Rosenbrock32 — Type
Rosenbrock32(; autodiff = Val{true}(),
                concrete_jac = nothing,
                linsolve = nothing,
                precs = DEFAULT_PRECS,
-               step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner Method. An Order 3/2 A-Stable Rosenbrock-W method which is good for mildly stiff equations without oscillations at low tolerances. Note that this method is prone to instability in the presence of oscillations, so use with caution. 2nd order stiff-aware interpolation.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

  • Shampine L.F. and Reichelt M., (1997) The MATLAB ODE Suite, SIAM Journal of

Scientific Computing, 18 (1), pp. 1-22.

source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.Rodas23W — Type
Rodas23W(; autodiff = Val{true}(),
+               step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner Method. An Order 3/2 A-Stable Rosenbrock-W method which is good for mildly stiff equations without oscillations at low tolerances. Note that this method is prone to instability in the presence of oscillations, so use with caution. 2nd order stiff-aware interpolation.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

  • Shampine L.F. and Reichelt M., (1997) The MATLAB ODE Suite, SIAM Journal of

Scientific Computing, 18 (1), pp. 1-22.

source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.Rodas23W — Type
Rodas23W(; autodiff = Val{true}(),
            concrete_jac = nothing,
            linsolve = nothing,
            precs = DEFAULT_PRECS,
-           step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner Method. An Order 2/3 L-Stable Rosenbrock-W method for stiff ODEs and DAEs in mass matrix form. 2nd order stiff-aware interpolation and additional error test for interpolation.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

  • Steinebach G., Rodas23W / Rodas32P - a Rosenbrock-type method for DAEs with additional error estimate for dense output and Julia implementation, In progress.
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.ROS34PW1a — Type
ROS34PW1a(; autodiff = Val{true}(),
+           step_limiter! = OrdinaryDiffEq.trivial_limiter!)

Rosenbrock-Wanner Method. An Order 2/3 L-Stable Rosenbrock-W method for stiff ODEs and DAEs in mass matrix form. 2nd order stiff-aware interpolation and additional error test for interpolation.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver
  • step_limiter!: function of the form limiter!(u, integrator, p, t)

References

  • Steinebach G., Rodas23W / Rodas32P - a Rosenbrock-type method for DAEs with additional error estimate for dense output and Julia implementation, In progress.
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.ROS34PW1a — Type
ROS34PW1a(; autodiff = Val{true}(),
             concrete_jac = nothing,
             linsolve = nothing,
-            precs = DEFAULT_PRECS)

Rosenbrock-Wanner Method. A 4th order L-stable Rosenbrock-W method.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver

References

source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.ROS34PW1b — Type
ROS34PW1b(; autodiff = Val{true}(),
+            precs = DEFAULT_PRECS)

Rosenbrock-Wanner Method. A 4th order L-stable Rosenbrock-W method.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver

References

source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.ROS34PW1b — Type
ROS34PW1b(; autodiff = Val{true}(),
             concrete_jac = nothing,
             linsolve = nothing,
-            precs = DEFAULT_PRECS)

Rosenbrock-Wanner Method. A 4th order L-stable Rosenbrock-W method.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver

References

source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.ROS34PW2 — Type
ROS34PW2(; autodiff = Val{true}(),
+            precs = DEFAULT_PRECS)

Rosenbrock-Wanner Method. A 4th order L-stable Rosenbrock-W method.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver

References

source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.ROS34PW2 — Type
ROS34PW2(; autodiff = Val{true}(),
            concrete_jac = nothing,
            linsolve = nothing,
-           precs = DEFAULT_PRECS)

Rosenbrock-Wanner Method. A 4th order stiffy accurate Rosenbrock-W method for PDAEs.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver

References

source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.ROS34PW3 — Type
ROS34PW3(; autodiff = Val{true}(),
+           precs = DEFAULT_PRECS)

Rosenbrock-Wanner Method. A 4th order stiffy accurate Rosenbrock-W method for PDAEs.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver

References

source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.ROS34PW3 — Type
ROS34PW3(; autodiff = Val{true}(),
            concrete_jac = nothing,
            linsolve = nothing,
-           precs = DEFAULT_PRECS)

Rosenbrock-Wanner Method. A 4th order strongly A-stable (Rinf~0.63) Rosenbrock-W method.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver

References

source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.ROS34PRw — Type
ROS34PRw(; autodiff = Val{true}(),
+           precs = DEFAULT_PRECS)

Rosenbrock-Wanner Method. A 4th order strongly A-stable (Rinf~0.63) Rosenbrock-W method.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver

References

source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.ROS34PRw — Type
ROS34PRw(; autodiff = Val{true}(),
            concrete_jac = nothing,
            linsolve = nothing,
-           precs = DEFAULT_PRECS)

Rosenbrock-Wanner Method. 3rd order stiffly accurate Rosenbrock-Wanner W-method with 4 internal stages, B_PR consistent of order 2. The order of convergence decreases if medium stiff problems are considered.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver

References

  • Joachim Rang, Improved traditional Rosenbrock–Wanner methods for stiff ODEs and DAEs, Journal of Computational and Applied Mathematics, https://doi.org/10.1016/j.cam.2015.03.010
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.ROK4a — Type
ROK4a(; autodiff = Val{true}(),
+           precs = DEFAULT_PRECS)

Rosenbrock-Wanner Method. 3rd order stiffly accurate Rosenbrock-Wanner W-method with 4 internal stages, B_PR consistent of order 2. The order of convergence decreases if medium stiff problems are considered.

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver

References

  • Joachim Rang, Improved traditional Rosenbrock–Wanner methods for stiff ODEs and DAEs, Journal of Computational and Applied Mathematics, https://doi.org/10.1016/j.cam.2015.03.010
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.ROK4a — Type
ROK4a(; autodiff = Val{true}(),
         concrete_jac = nothing,
         linsolve = nothing,
-        precs = DEFAULT_PRECS)

Rosenbrock-Wanner Method. 4rd order L-stable Rosenbrock-Krylov method with 4 internal stages, with a 3rd order embedded method which is strongly A-stable with Rinf~=0.55. (when using exact Jacobians)

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver

References

  • Tranquilli, Paul and Sandu, Adrian (2014): Rosenbrock–Krylov Methods for Large Systems of Differential Equations https://doi.org/10.1137/130923336
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.ROS2S — Type
ROS2S(; autodiff = Val{true}(),
+        precs = DEFAULT_PRECS)

Rosenbrock-Wanner Method. 4rd order L-stable Rosenbrock-Krylov method with 4 internal stages, with a 3rd order embedded method which is strongly A-stable with Rinf~=0.55. (when using exact Jacobians)

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver

References

  • Tranquilli, Paul and Sandu, Adrian (2014): Rosenbrock–Krylov Methods for Large Systems of Differential Equations https://doi.org/10.1137/130923336
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.ROS2S — Type
ROS2S(; autodiff = Val{true}(),
         concrete_jac = nothing,
         linsolve = nothing,
-        precs = DEFAULT_PRECS)

Rosenbrock-Wanner Method. 2nd order stiffly accurate Rosenbrock-Wanner W-method with 3 internal stages with B_PR consistent of order 2 with (Rinf=0).

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver

References

  • Rang, Joachim (2014): The Prothero and Robinson example: Convergence studies for Runge-Kutta and Rosenbrock-Wanner methods. https://doi.org/10.24355/dbbs.084-201408121139-0
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.RosenbrockW6S4OS — Type
RosenbrockW6S4OS(; autodiff = Val{true}(),
+        precs = DEFAULT_PRECS)

Rosenbrock-Wanner Method. 2nd order stiffly accurate Rosenbrock-Wanner W-method with 3 internal stages with B_PR consistent of order 2 with (Rinf=0).

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver

References

  • Rang, Joachim (2014): The Prothero and Robinson example: Convergence studies for Runge-Kutta and Rosenbrock-Wanner methods. https://doi.org/10.24355/dbbs.084-201408121139-0
source
OrdinaryDiffEq.OrdinaryDiffEqRosenbrock.RosenbrockW6S4OS — Type
RosenbrockW6S4OS(; autodiff = Val{true}(),
                    concrete_jac = nothing,
                    linsolve = nothing,
-                   precs = DEFAULT_PRECS)

Rosenbrock-Wanner Method. A 4th order L-stable Rosenbrock-W method (fixed step only).

Keyword Arguments

  • autodiff: boolean to control if the Jacobian should be computed via AD or not
  • concrete_jac: function of the form jac!(J, u, p, t)
  • linsolve: custom solver for the inner linear systems
  • precs: custom preconditioner for the inner linear solver

References

https://doi.org/10.1016/j.cam.2009.09.017

source
+ precs = DEFAULT_PRECS)

Rosenbrock-Wanner Method. A 4th order L-stable Rosenbrock-W method (fixed step only).

Keyword Arguments

References

https://doi.org/10.1016/j.cam.2009.09.017

source diff --git a/previews/PR2309/stiff/sdirk/index.html b/previews/PR2309/stiff/sdirk/index.html index 8c531825bd..e4fe608380 100644 --- a/previews/PR2309/stiff/sdirk/index.html +++ b/previews/PR2309/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

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

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

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

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

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

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

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

OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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/previews/PR2309/stiff/stabilized_rk/index.html b/previews/PR2309/stiff/stabilized_rk/index.html index 11ee37c0c4..125062061f 100644 --- a/previews/PR2309/stiff/stabilized_rk/index.html +++ b/previews/PR2309/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.

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

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

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

OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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/previews/PR2309/stiff/stiff_multistep/index.html b/previews/PR2309/stiff/stiff_multistep/index.html index 0faf74adae..6c98e0b38d 100644 --- a/previews/PR2309/stiff/stiff_multistep/index.html +++ b/previews/PR2309/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

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

Multistep Methods for Stiff Equations

OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
OrdinaryDiffEq.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
diff --git a/previews/PR2309/usage/index.html b/previews/PR2309/usage/index.html index 62b6109a8c..03ef01a276 100644 --- a/previews/PR2309/usage/index.html +++ b/previews/PR2309/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.